机器学习-逻辑回归

逻辑回归

1. 数学基础

"""
数学基础
	sigmoid函数:
		作用
			把(-oo, +oo) 映射到 (0, 1)
		数学性质
			单调递增函数
		导函数公式
			f′(x) = f(x)(1 - f(x))
	概率:
		概率
			事件发生的可能性
		联合概率
			指两个或多个随机变量同时发生的概率 P(AB)
				P(AB) = P(A) * P(B)
		条件概率
			表示事件A在另一个事件B已经发生条件下发生概率 P(A|B)
				P(A|B) = P(AB) / P(A)
	极大似然估计
		核心思想
			根据观测到的结果来估计模型算法中的未知参数
	对数:
		对数性质
			log MN = log M + log N
			log M/N = log M - log N
			log Mⁿ = nlog M
"""

2. 逻辑回归原理

"""
逻辑回归原理
	基本思想:
		利用线性模型:
			根据方程将特征的重要性计算出一个值
			再使用sigmoid函数将f(x)的输出值映射为概率值
			设置阈值(eg:0.5) 概率输出值大于0.5 将未知样本输出为 1 类
			否则 输出为 0 类
	假设函数:
		线性回归的输出 作为逻辑回归的输入
	损失函数:
		工作原理
			每个样本预测值有两个类别 A B
			真实类别对应的位置, 概率值越大越好
	开发API
		sklearn.linear_model.LogisticRegression(solver='liblinear', penalty=‘l2’, C = 1.0)
		solver 损失函数优化方法
		penalty：正则化的种类
		C：正则化力度
		默认将类别数量少的当做正例
	开发思路
		1.导入依赖包
		2.加载数据及数据预处理
			2.1 缺失值处理
			2.2 确定特征值,目标值
			2.3 分割数据
		3.特征工程(标准化)
		4.模型训练，机器学习(逻辑回归)
		5.模型预测和评估
"""
# 1.导入依赖包
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import numpy as np

# 暂不关注warn信息
import warnings

warnings.filterwarnings("ignore")


def logisticRegression():
    """
    回归API案例展示
    :return:
    """
    # 2.加载数据及数据预处理
    src_data = pd.read_csv('data/breast-cancer-wisconsin.csv')
    # 2.1 缺失值处理
    have_nan_data = src_data.replace(to_replace='?', value=np.NAN)
    handle_data = have_nan_data.dropna()
    # 2.2 确定特征值,目标值
    x = handle_data.iloc[:, 1:-1]
    y = handle_data.iloc[:, -1]
    # 2.3 分割数据
    X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=2)
    # 3.特征工程(标准化)
    std_scaler = StandardScaler()
    x_train = std_scaler.fit_transform(X_train)
    x_test = std_scaler.transform(X_test)
    # 4.模型训练 机器学习(逻辑回归)
    logistic_regr = LogisticRegression()
    logistic_regr.fit(X_train, y_train)
    # 5.模型预测和评估
    y_pred = logistic_regr.predict(x_test)
    acc_score = accuracy_score(y_test, y_pred)
    return acc_score

3. 分类评估

"""
分类评估
	混淆矩阵
		TP 真正例
		FP 伪正例
		FN 伪反例
		TN 真反例
	精确率 precision
		对正例样本的预测准确率
		P = TP/(TP+FP)
			
	召回率 recall
		预测为真正例样本占所有真实正例样本的比重
		P = TP/()TP+FN
	F1-score
		P = 2 * precision * recall / (precision + recall)   -- 概率值
		
	AUC指标
		ROC曲线的优劣可以通过曲线下的面积（AUC）来衡量，AUC越大表示分类器性能越好
		当AUC=0.5时，表示分类器的性能等同于随机猜测
		当AUC=1时，表示分类器的性能完美，能够完全正确地将正负例分类
		AUC的计算API
			from sklearn.metrics import roc_auc_score roc_auc_score(y_true, y_score)
			计算ROC曲线面积，即AUC值
			y_true: 每个样本的真实类别，必须为0(反例),1(正例)标记
			y_score: 预测得分，可以是正例的估计概率、置信值或者分类器方法的返回值
		分类评估报告API
			y_true: 真实目标值
			y_pred: 估计器预测目标值
			labels: 指定类别对应的数字
			target_names: 目标类别名称
			return: 每个类别精确率与召回率
	ROC曲线
		正样本中被预测为正样本的概率TPR
		负样本中被预测为正样本的概率FPR
		通过这两个指标可以描述模型对正/负样本的分辨能力
		ROC曲线以模型的真正率TPR为纵轴，假正率FPR为横轴
		ROC 曲线图像中，4 个特殊点的含义
			曲线越靠近 (0,1) 点则模型对正负样本的辨别能力就越强
			点(0, 0): 所有的负样本都预测正确 所有的正样本都预测错误 相当于点的(FPR值0, TPR值0）
			点(1, 0): 所有的负样本都预测错误 所有的正样本都预测错误 相当于点的(FPR值1, TPR值0)
			点(1, 1): 所有的负样本都预测错误 表示所有的正样本都预测正确 相当于点的(FPR值1，TPR值1)
			点(0, 1): 所有的负样本都预测正确 表示所有的正样本都预测正确 相当于点的(FPR值0，TPR值1)

"""
# 1.导入依赖包
from sklearn.metrics import confusion_matrix


def confusionMatrix():
    """
    混淆矩阵 API
    :return:
    """
    # 2.构建数据 样本集中共有6个劣样本, 4个优样本
    y_true = ["劣", "劣", "劣", "劣", "劣", "劣", "优", "优", "优", "优"]
    # 3.1 混淆矩阵 模型 A: 预测对了3个劣样本, 4个优样本
    print("模型A: ")
    print("*" * 20)
    y_pred1 = ["劣", "劣", "劣", "优", "优", "优", "优", "优", "优", "优"]
    result = confusion_matrix(y_true, y_pred1, labels=["劣", "优"])
    print(pd.DataFrame(result, columns=["劣(正例)", "优(反例)"], index=["劣(正例)", "优(反例)"]))
    # 3.2 混淆矩阵 模型 B: 预测对了6个劣样本, 1个优样本
    print("模型B: ")
    print("*" * 20)
    y_pred2 = ["劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "优"]
    result = confusion_matrix(y_true, y_pred2, labels=["劣", "优"])
    print(pd.DataFrame(result, columns=["劣(正例)", "优(反例)"], index=["劣(正例)", "优(反例)"]))


# 1.导入依赖包
from sklearn.metrics import precision_score


def precisionScore():
    """
    精确率 API
    :return:
    """
    # 2.构建数据，样本集中共有6个劣样本, 4个优样本
    y_true = ["劣", "劣", "劣", "劣", "劣", "劣", "优", "优", "优", "优"]
    # 3.1 模型精确率评估，模型 A: 预测对了3个劣样本, 4个优样本
    y_pred1 = ["劣", "劣", "劣", "优", "优", "优", "优", "优", "优", "优"]
    result = precision_score(y_true, y_pred1, pos_label="劣")
    print("模型A精度: ", result)
    # 3.2 模型精确率评估，模型 B: 预测对了6个劣样本, 1个优样本
    y_pred2 = ["劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "优"]
    result = precision_score(y_true, y_pred2, pos_label="劣")
    print("模型B精度:", result)


# 1.导入依赖包
from sklearn.metrics import recall_score


def recallScore():
    """
    召回率 API
    :return:
    """
    # 2.构建数据，样本集中共有6个劣样本, 4个优样本
    y_true = ["劣", "劣", "劣", "劣", "劣", "劣", "优", "优", "优", "优"]
    # 3.1 模型召回率评估，模型 A: 预测对了3个劣样本, 4个优样本
    y_pred1 = ["劣", "劣", "劣", "优", "优", "优", "优", "优", "优", "优"]
    result = recall_score(y_true, y_pred1, pos_label="劣")
    print("模型A召回率:", result)
    # 3.2 模型召回率评估，模型 B: 预测对了6个劣样本, 1个优样本
    y_pred2 = ["劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "优"]
    result = recall_score(y_true, y_pred2, pos_label="劣")
    print("模型B召回率:", result)


# 1.导入依赖包
from sklearn.metrics import f1_score


def f1Score():
    # 2.构建数据，样本集中共有6个劣样本, 4个优样本
    y_true = ["劣", "劣", "劣", "劣", "劣", "劣", "优", "优", "优", "优"]
    # 3.1 模型F1-score评估，模型 A: 预测对了3个劣样本, 4个优样本
    y_pred = ["劣", "劣", "劣", "优", "优", "优", "优", "优", "优", "优"]
    result = f1_score(y_true, y_pred, pos_label="劣")
    print("模型Af1-score:", result)
    # 3.2 模型F1-score评估，模型 B: 预测对了6个劣样本, 1个优样本
    y_pred = ["劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "劣", "优"]
    result = f1_score(y_true, y_pred, pos_label="劣")
    print("模型Bf1-score::", result)

4. 开发步骤

"""
开发步骤:
	1. 数据基本处理
		主要是查看数据行/列数量
		对类别数据进行one-hot处理
		查看标签分布情况
	2. 特征筛选(特征工程)
		分析哪些特征对标签值影响大
		对标签进行分组统计, 对比0/1标签分组后的均值等
		初步筛选初对标签影响比较大的特征 作为 x(特征值) y(目标值) 
	3. 模型训练
		样本均衡情况下模型训练
		样本不平衡情况下模型训练
		交叉验证网格搜索等方式进行模型训练
	4, 模型评估
		精确率
		ROC_AUC 指标计算
"""
# 1.导入依赖包
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import classification_report, roc_auc_score


def countPlot():
    churn_pd = pd.read_csv('data/churn.csv')
    # 1 处理类别型的数据 类别型数据做one-hot编码
    churn_pd = pd.get_dummies(churn_pd)
    # 2 去除列 Churn_no gender_Male # nplace=True 在原来的数据上进行删除
    churn_pd.drop(['Churn_No', 'gender_Male'], axis=1, inplace=True)
    # 3 列标签重命名 打印列名
    churn_pd.rename(columns={'Churn_Yes': 'flag'}, inplace=True)
    # 4 查看标签的分布情况 0.26用户流失
    value_counts = churn_pd.flag.value_counts(1)
    # 5 查看Contract_Month 是否月签约流失情况
    sns.countplot(data=churn_pd, y="Contract_Month", hue='flag')
    plt.show()


def churnModel():
    # 1 数据基本处理
    churn_pd = pd.read_csv('./data/churn.csv')
    # 1-1 处理类别型的数据 类别型数据做one-hot编码
    churn_pd = pd.get_dummies(churn_pd)
    # 1-2 去除列 Churn_no gender_Male # nplace=True 在原来的数据上进行删除
    churn_pd.drop(['Churn_No', 'gender_Male'], axis=1, inplace=True)
    # 1-3 列标签重命名 打印列名
    churn_pd.rename(columns={'Churn_Yes': 'flag'}, inplace=True)
    # 2 特征处理
    # 2-1 确定目标值和特征值
    x = churn_pd[['Contract_Month', 'internet_other', 'PaymentElectronic']]
    y = churn_pd['flag']
    # 2-2 数据集划分
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3,
                                                        random_state=100)
    # 3 实例化模型 训练模型 模型预测
    estimator = LogisticRegression()
    estimator.fit(x_train, y_train)
    y_pred = estimator.predict(x_test)
    # 4 模型评估
    my_accuracy_score = accuracy_score(y_test, y_pred)
    print('my_accuracy_score-->', my_accuracy_score)
    my_score = estimator.score(x_test, y_test)
    print('my_score-->', my_score)
    # 计算AUC值
    my_roc_auc_score = roc_auc_score(y_test, y_pred)
    print('my_roc_auc_score-->', my_roc_auc_score)
    result = classification_report(y_test, y_pred, target_names=['flag0', 'flag1'])
    print('classification_report result->\n', result)