好坏质检分类实战(异常数据检测、降维、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

相关推荐
Tiandaren37 分钟前
Selenium 4 教程:自动化 WebDriver 管理与 Cookie 提取 || 用于解决chromedriver版本不匹配问题
selenium·测试工具·算法·自动化
岁忧2 小时前
(LeetCode 面试经典 150 题 ) 11. 盛最多水的容器 (贪心+双指针)
java·c++·算法·leetcode·面试·go
chao_7892 小时前
二分查找篇——搜索旋转排序数组【LeetCode】两次二分查找
开发语言·数据结构·python·算法·leetcode
秋说4 小时前
【PTA数据结构 | C语言版】一元多项式求导
c语言·数据结构·算法
Maybyy4 小时前
力扣61.旋转链表
算法·leetcode·链表
卡卡卡卡罗特6 小时前
每日mysql
数据结构·算法
chao_7896 小时前
二分查找篇——搜索旋转排序数组【LeetCode】一次二分查找
数据结构·python·算法·leetcode·二分查找
lifallen7 小时前
Paimon 原子提交实现
java·大数据·数据结构·数据库·后端·算法
lixzest7 小时前
C++ Lambda 表达式详解
服务器·开发语言·c++·算法
EndingCoder7 小时前
搜索算法在前端的实践
前端·算法·性能优化·状态模式·搜索算法