机器学习-逻辑回归

逻辑回归

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
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75