提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 实验相关内容
  *
  –
  • 1.数据分析实验
  • 2.数据集介绍
  • 3.实验目标
  • 4.整个流程
  • 实验前讲解
• 使用步骤
  *
  –
  +
  *
  – 代码如下（示例）：

实验相关内容

1.数据分析实验

非均衡数据的处理

提示：以下是本篇文章正文内容，下面案例可供参考

2.数据集介绍

数据集包括了 2013 年 9 月份两天时间内的信用卡交易数据，284807 笔交易中，一共有 492 笔是欺诈行为。输入数据一共包括了 28 个特征 V1，V2，……V28 对应的取值，以及交易时间 Time 和交易金额 Amount。为了保护数据隐私，我们不知道 V1 到 V28 这些特征代表的具体含义，只知道这 28 个特征值是通过 PCA 变换得到的结果。另外字段 Class 代表该笔交易的分类，Class=0 为正常（非欺诈），Class=1 代表欺诈

3.实验目标

目标是针对这个数据集构建一个信用卡欺诈分析的分类器，采用的是逻辑回归。

4.整个流程

1. 了解逻辑回归分类，以及如何在 sklearn 中使用它；
2. 信用卡欺诈属于二分类问题，欺诈交易在所有交易中的比例很小，对于这种数据不平衡的情况，到底采用什么样的模型评估标准会更准确；
3. 完成信用卡欺诈分析的实战项目，并通过数据可视化对数据探索和模型结果评估进一步加强了解。

; 实验前讲解

– 如何使用 sklearn 中的逻辑回归工具：

• 在 sklearn 中，使用 LogisticRegression() 函数构建逻辑回归分类器，函数里有一些常用的构造参数：

• penalty：惩罚项，取值为 l1 或 l2，默认为 l2。当模型参数满足高斯分布的时候，使用
  l2，当模型参数满足拉普拉斯分布的时候，使用 l1；

• solver：代表的是逻辑回归损失函数的优化方法。有 5 个参数可选，分别为
  liblinear、lbfgs、newton-cg、sag 和 saga。默认为
  liblinear，适用于数据量小的数据集，当数据量大的时候可以选用 sag 或 saga 方法；
• max_iter：算法收敛的最大迭代次数，默认为 10； n_jobs：拟合和预测的时候 CPU 的核数，默认是1，也可以是整数，如果是-1 则代表 CPU 的核数。当我们创建好之后，就可以使用 fit 函数拟合，使用 predict 函数预测。*

– 模型评估指标

这里先介绍下数据预测的四种情况：TP、FP、TN、FN。*

• 准确率 Accuracy = (TP+TN)/(TP+TN+FN+FP)；
• 精确率 P = TP/ (TP+FP)； 召回率 R = TP/ (TP+FN)，也称为查全率。
• F1 作为精确率 P 和召回率 R 的调和平均，数值越大代表模型的结果越好。

使用步骤

代码如下（示例）：

`python
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import itertools
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, precision_recall_curve
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
import warnings
warnings.filterwarnings('ignore')

def plot_confusion_matrix(cm, classes, normalize = False, title = 'Confusion matrix"', cmap = plt.cm.Blues) :
    plt.figure()
    plt.imshow(cm, interpolation = 'nearest', cmap = cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation = 0)
    plt.yticks(tick_marks, classes)

    thresh = cm.max() / 2.

    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])) :
        plt.text(j, i, cm[i, j],
                 horizontalalignment = 'center',
                 color = 'white' if cm[i, j] > thresh else 'black')

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')
    plt.show()

def show_metrics():
    tp = cm[1,1]
    fn = cm[1,0]
    fp = cm[0,1]
    tn = cm[0,0]
    print('精确率: {:.3f}'.format(tp/(tp+fp)))
    print('召回率: {:.3f}'.format(tp/(tp+fn)))
    print('F1值: {:.3f}'.format(2*(((tp/(tp+fp))*(tp/(tp+fn)))/((tp/(tp+fp))+(tp/(tp+fn))))))
def show_metrics1():
    tp = cm1[1,1]
    fn = cm1[1,0]
    fp = cm1[0,1]
    tn = cm1[0,0]
    print('精确率: {:.3f}'.format(tp/(tp+fp)))
    print('召回率: {:.3f}'.format(tp/(tp+fn)))
    print('F1值: {:.3f}'.format(2*(((tp/(tp+fp))*(tp/(tp+fn)))/((tp/(tp+fp))+(tp/(tp+fn))))))

def plot_precision_recall():
    plt.step(recall, precision, color = 'b', alpha = 0.2, where = 'post')
    plt.fill_between(recall, precision, step ='post', alpha = 0.2, color = 'b')
    plt.plot(recall, precision, linewidth=2)
    plt.xlim([0.0,1])
    plt.ylim([0.0,1.05])
    plt.xlabel('召回率')
    plt.ylabel('精确率')
    plt.title('精确率-召回率 曲线')
    plt.show();

data = pd.read_csv('creditcard.csv')

data.describe()

plt.rcParams['font.sans-serif'] = ['SimHei']

plt.figure()
ax = sns.countplot(x = 'Class', data = data)
plt.title('类别分布')
plt.show()

num = len(data)
num_fraud = len(data[data['Class'] == 1])

print('总交易笔数: ', num)
print('诈骗交易笔数：', num_fraud)
print('诈骗交易比例：{:.6f}'.format(num_fraud/num))

f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(15,8))
bins = 50
ax1.hist(data.Time[data.Class == 1], bins = bins, color = 'deeppink')
ax1.set_title('诈骗交易')
ax2.hist(data.Time[data.Class == 0], bins = bins, color = 'deepskyblue')
ax2.set_title('正常交易')
plt.xlabel('时间')
plt.ylabel('交易次数')
plt.show()

data['Amount_Norm'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1,1))

y = np.array(data.Class.tolist())
data = data.drop(['Time','Amount','Class'],axis = 1)
X = np.array(data.iloc[:,:].values)

train_x,test_x,train_y,test_y = train_test_split(X, y, test_size = 0.1,random_state =  33)
train_x1,test_x1,train_y1,test_y1 = train_test_split(X, y, test_size = 0.1,random_state =  3)

clf = LogisticRegression()
clf.fit(train_x,train_y)
predict_y = clf.predict(test_x)

cls =LinearSVC()
cls.fit(train_x1,train_y1)
predict_y1 = cls.predict(test_x1)

score_y = clf.decision_function(test_x)

score_y1 = cls.decision_function(test_x1)

cm = confusion_matrix(test_y, predict_y)
class_names = [0,1]

cm1 = confusion_matrix(test_y1, predict_y1)
class_names = [0,1]

plot_confusion_matrix(cm, classes = class_names, title = '逻辑回归 混淆矩阵')

plot_confusion_matrix(cm1, classes = class_names, title = 'svc 混淆矩阵')

show_metrics()

show_metrics1()

precision, recall, thresholds = precision_recall_curve(test_y, score_y)
plot_precision_recall()

precision, recall, thresholds = precision_recall_curve(test_y1, score_y1)
plot_precision_recall()

由于用了两种分类 一种逻辑回归 一种线性SVM，在代码中都有标注

Original: https://blog.csdn.net/m0_59592892/article/details/123779390
Author: 拉垮的菜鸟
Title: 数据分析实验 sklearn 逻辑回归