好坏质检分类实战（异常数据检测、降维、KNN模型分类、混淆矩阵进行模型评估）

任务

好坏质检分类实战 task:

1、基于 data_class_raw.csv 数据，根据高斯分布概率密度函数，寻找异常点并剔除

2、基于 data_class_processed.csv 数据，进行 PCA 处理，确定重要数据维度及成分

3、完成数据分离，数据分离参数：random_state=4,test_size=0.4

4、建立 KNN 模型完成分类，n_neighbors 取 10，计算分类准确率，可视化分类边界

5、计算测试数据集对应的混淆矩阵，计算准确率、召回率、特异度、精确率、F1 分数

6、尝试不同的 n_neighbors（1-20），计算其在训练数据集、测试数据集上的准确率并作图。

参考资料

32.36 实战（二）_哔哩哔哩_bilibili

33.37 实战（三）_哔哩哔哩_bilibili

数据准备

数据集名称：data_class_raw.csv、data_class_processed.csv

点我转到百度网盘获取数据集提取码: 8497

1、异常数据检测

加载数据

复制代码

#load the data
import pandas as pd
import numpy as np
data = pd.read_csv('data_class_raw.csv')
data.head()

x1，x2 是芯片质量相关的两个维度，y 代表芯片质量是否合格。

复制代码

#define X and y
X = data.drop(['y'], axis = 1)
y = data.loc[:,'y']

原始数据可视化

复制代码

#visualize the data
%matplotlib inline
from matplotlib import pyplot as plt
fig1 = plt.figure(figsize = (5,5))
bad = plt.scatter(X.loc[:,'x1'][y==0], X.loc[:,'x2'][y==0])
good = plt.scatter(X.loc[:,'x1'][y==1], X.loc[:,'x2'][y==1])
plt.legend((good,bad),('good','bad'))
plt.title('raw data')
plt.xlabel('x1')
plt.ylabel('x2')
plt.show()

根据高斯分布概率密度函数，寻找异常点并剔除

复制代码

#根据高斯分布概率密度函数，寻找异常点并剔除
#anomay detection
from sklearn.covariance import EllipticEnvelope
ad_model = EllipticEnvelope(contamination = 0.02)
ad_model.fit(X[y==0])
y_predict_bad = ad_model.predict(X[y==0])
print(y_predict_bad)[ 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1 -1]

找出异常点并画出异常点

复制代码

#找出异常点并画出异常点
fig1 = plt.figure(figsize = (5,5))
bad = plt.scatter(X.loc[:,'x1'][y==0], X.loc[:,'x2'][y==0])
good = plt.scatter(X.loc[:,'x1'][y==1], X.loc[:,'x2'][y==1])
plt.scatter(X.loc[:,'x1'][y==0][y_predict_bad == -1], 
            X.loc[:,'x2'][y==0][y_predict_bad == -1],marker = 'x', s=150)# 找出来的异常点
plt.legend((good,bad),('good','bad'))
plt.title('raw data')
plt.xlabel('x1')
plt.ylabel('x2')
plt.show()

2、基于剔除了异常点的数据进行PCA处理

加载数据

复制代码

#任务二：基于剔除了异常点的数据进行PCA处理
data = pd.read_csv('data_class_processed.csv')
data.head()
#define X and y
X = data.drop(['y'], axis = 1)
y = data.loc[:,'y']

进行PCA的预处理

复制代码

#接下来进行PCA的预处理
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
X_norm = StandardScaler().fit_transform(X) # 进行标准化处理
pca = PCA(n_components = 2) # 进行 2 维的PCA处理
X_reduced = pca.fit_transform(X_norm)#参数是标准化之后的数据
#下面计算各个维度上主成分标准差的比例是多少
var_ratio = pca.explained_variance_ratio_
print(var_ratio)#[0.5369408 0.4630592], 对应主成分的标准差的比例
fig4 = plt.figure(figsize = (5,5))
plt.bar([1,2], var_ratio)
plt.show()# 这两个主成分上的标准差都挺高的，也就意味着这两个维度的数据都需要进行保留

3、数据分离

复制代码

# train and test split: random_state=4, test_size=0.4
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y, random_state=4, test_size=0.4)
print(X_train.shape, X_test.shape, X.shape)

4、KNN 模型进行分类

针对训练数据集建立KNN模型、进行训练和预测

复制代码

#4、建立 KNN 模型完成分类，n_neighbors 取 10，计算分类准确率，可视化分类边界、
#针对训练数据集建立KNN模型
from sklearn.neighbors import KNeighborsClassifier
knn_10 = KNeighborsClassifier(n_neighbors = 10)
knn_10.fit(X_train, y_train)
y_train_predict = knn_10.predict(X_train)
y_test_predict = knn_10.predict(X_test)

计算准确率

复制代码

#4、建立 KNN 模型完成分类，n_neighbors 取 10，计算分类准确率，可视化分类边界、
#针对训练数据集建立KNN模型
from sklearn.neighbors import KNeighborsClassifier
knn_10 = KNeighborsClassifier(n_neighbors = 10)
knn_10.fit(X_train, y_train)
y_train_predict = knn_10.predict(X_train)
y_test_predict = knn_10.predict(X_test)

可视化分类边界

流程：生成一些新的数据组，然后利用模型进行预测，最后画出模型的预测结果。

生成一些新的数据组

复制代码

# 可视化分类边界(生成一些新的数据组，然后利用模型进行预测，最后画出模型的预测结果)
xx,yy = np.meshgrid(np.arange(0,10,0.05), np.arange(0,10,0.05))#观察到原来数据是0-10之间
print(xx)
print(yy.shape)# (200, 200), 200行， 200 列

复制代码

x_range = np.c_[xx.ravel(),yy.ravel()]
#np.c_[xx.ravel(),yy.ravel()] 是 NumPy 中一种常用的数组拼接操作，
#通常与网格坐标生成（例如 np.meshgrid）结合使用，用于创建二维平面上所有可能的坐标点组合
print(x_range.shape) #(40000, 2) , 相当于200 行 200 列的组合

进行预测

复制代码

y_range_predict = knn_10.predict(x_range)

画出分类边界

复制代码

fig4 = plt.figure(figsize = (10,10))
knn_bad = plt.scatter(x_range[:,0][y_range_predict == 0]
                      , x_range[:,1][y_range_predict == 0])#所有行，第一列；所有行，第二列
knn_good = plt.scatter(x_range[:,0][y_range_predict == 1]
                      , x_range[:,1][y_range_predict == 1])

#下面是原始数据
bad = plt.scatter(X.loc[:,'x1'][y==0], X.loc[:,'x2'][y==0])
good = plt.scatter(X.loc[:,'x1'][y==1], X.loc[:,'x2'][y==1])

plt.legend((good,bad , knn_good, knn_bad),('good','bad','knn_good','knn_bad'))
plt.title('prediction result')
plt.xlabel('x1')
plt.ylabel('x2')
plt.show()

5、计算测试数据集对应的混淆矩阵

复制代码

#5、计算测试数据集对应的混淆矩阵，计算准确率、召回率、特异度、精确率、F1 分数
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_test_predict) #计算测试数据的混淆矩阵
print(cm)

复制代码

TP = cm[1,1]
TN = cm[0,0]
FP = cm[0,1]
FN = cm[1,0]
print(TP, TN, FP, FN)

准确率：整体样本中，预测正确样本数的比例

・Accuracy = (TP + TN)/(TP + TN + FP + FN) 。

这里涉及机器学习等领域的评估指标概念：

Accuracy（准确率）：是一个衡量分类模型性能的指标。

TP（True Positive，真正例）：实际为正例且被模型正确预测为正例的样本数量。

TN（True Negative，真负例）：实际为负例且被模型正确预测为负例的样本数量。

FP（False Positive，假正例）：实际为负例但被模型错误预测为正例的样本数量。

FN（False Negative，假负例）：实际为正例但被模型错误预测为负例的样本数量。

复制代码

accuracy = (TP + TN)/(TP + TN + FP + FN) #0.6428571428571429
print(accuracy#0.6428571428571429

灵敏度（召回率）：正样本中，预测正确的比例

・Sensitivity = Recall = TP/(TP + FN)

复制代码

recall = TP/(TP+FN)
print(recall)#0.625

特异度: 负样本中，预测正确的比例

Specificity = TN/(TN + FP)

复制代码

specificity = TN/(TN + FP)
print(specificity)#0.6666666666666666

精确率：预测结果为正的样本中，预测正确的比例

・Precision = TP/(TP + FP)

复制代码

precision = TP/(TP + FP)
print(precision)#0.7142857142857143

precision = TP/(TP + FP)

print(precision)#0.7142857142857143

复制代码

f1 = 2*precision*recall/(precision + recall)
print(f1)#0.6666666666666666

6、KNN 尝试不同的 n_neighbors（1-20）

复制代码

#尝试不同的 n_neighbors（1-20），计算其在训练数据集、测试数据集上的准确率并作图
# try different k and calculate the accuracy for each
n = [i for i in range(1,21)]
# print(n)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
accuracy_train = []
accuracy_test = []
for i in n:
    knn = KNeighborsClassifier(n_neighbors = i)
    knn.fit(X_train, y_train)
    y_train_predict = knn.predict(X_train) #进行训练数据的预测
    y_test_predict  = knn.predict(X_test) #进行测试数据的预测
    accuracy_train_i = accuracy_score(y_train, y_train_predict)
    accuracy_test_i = accuracy_score(y_test, y_test_predict)
    accuracy_train.append(accuracy_train_i)
    accuracy_test.append(accuracy_test_i)
print(accuracy_train, accuracy_test)

复制代码

fig5 = plt.figure(figsize=(12,5))
plt.subplot(121)
plt.plot(n, accuracy_train,marker = 'o') # 训练数据的准确率, n 是 n_neighbors 参数
plt.title('training accuracy vs n_neighbors')
plt.xlabel('n_neighbors')
plt.ylabel('accuracy')

plt.subplot(122)
plt.plot(n, accuracy_test,marker = 'o') # 测试数据的准确率, n 是 n_neighbors 参数
plt.title('testing accuracy vs n_neighbors')
plt.xlabel('n_neighbors')
plt.ylabel('accuracy')

plt.show()

7、好坏质检分类实战 summary

1、通过进行异常检测，帮助找到了潜在的异常数据点；

2、通过 PCA 分析，发现需要保留 2 维数据集；

3、实现了训练数据与测试数据的分离，并计算模型对于测试数据的预测准确率

4、计算得到混淆矩阵，实现模型更全面的评估

5、通过新的方法，可视化分类的决策边界

6、通过调整核心参数 n_neighbors 值，在计算对应的准确率，可以帮助我们更好的确定使用哪个模型

7、核心算法参考链接：https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html