示例代码:
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
if __name__ == '__main__':
# 1. 加载数据集
iris = load_iris() #通过iris.data 获取数据集中的特征值 iris.target获取目标值
# 2. 数据标准化
transformer = StandardScaler()
x_ = transformer.fit_transform(iris.data) # iris.data 数据的特征值
# 3. 模型训练
estimator = KNeighborsClassifier(n_neighbors=3) # n_neighbors 邻居的数量,也就是Knn中的K值
estimator.fit(x_, iris.target) # 调用fit方法 传入特征和目标进行模型训练
# 4. 利用模型预测
result = estimator.predict(x_)
print(result)
1、sklearn中K近邻算法的对象:
from sklearn.neighbors import KNeighborsClassifier
estimator = KNeighborsClassifier(n_neighbors=3) # K的取值通过n_neighbors传递
K值也就是n_beighbors的选择尤为重要 ,下文我们会继续介绍
2、sklearn中大多数算法模型训练的API都是同一个套路
estimator = KNeighborsClassifier(n_neighbors=3) # 创建算法模型对象
estimator.fit(x_, iris.target) # 调用fit方法训练模型
estimator.predict(x_) # 用训练好的模型进行预测
3、sklearn中自带了几个学习数据集
我们在建立模型时,少不了对数据的引用,接下来我们首先介绍数据划分及选样的方法
💡💡为什么要划分数据集呢? 结论:不能将所有数据集全部用于训练,为了能够评估模型的泛化能力,可以通过实验测试对学习器的泛化能力进行评估,进而做出选择。因此需要使用一个 "测试集" 来测试学习器对新样本的判别能力,以测试集上的 "测试误差" 作为泛化误差的近似。
💡留出法 (hold-out) 将数据集 D 划分为两个互斥的集合,其中一个集合作为训练集 S,另一个作为测试集 T。
from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import ShuffleSplit
from collections import Counter
from sklearn.datasets import load_iris
def test01():
# 1. 加载数据集
x, y = load_iris(return_X_y=True)
print('原始类别比例:', Counter(y))
# 2. 留出法(随机分割)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
print('随机类别分割:', Counter(y_train), Counter(y_test))
# 3. 留出法(分层分割)
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, stratify=y)
print('分层类别分割:', Counter(y_train), Counter(y_test))
def test02():
# 1. 加载数据集
x, y = load_iris(return_X_y=True)
print('原始类别比例:', Counter(y))
print('*' * 40)
# 2. 多次划分(随机分割)
spliter = ShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
for train, test in spliter.split(x, y):
print('随机多次分割:', Counter(y[test]))
print('*' * 40)
# 3. 多次划分(分层分割)
spliter = StratifiedShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
for train, test in spliter.split(x, y):
print('分层多次分割:', Counter(y[test]))
if __name__ == '__main__':
test01()
test02()
💡K-Fold交叉验证,将数据随机且均匀地分成k分,如上图所示(k为10),假设每份数据的标号为0-9
from sklearn.model_selection import KFold
from sklearn.model_selection import StratifiedKFold
from collections import Counter
from sklearn.datasets import load_iris
def test():
# 1. 加载数据集
x, y = load_iris(return_X_y=True)
print('原始类别比例:', Counter(y))
print('*' * 40)
# 2. 随机交叉验证
spliter = KFold(n_splits=5, shuffle=True, random_state=0)
for train, test in spliter.split(x, y):
print('随机交叉验证:', Counter(y[test]))
print('*' * 40)
# 3. 分层交叉验证
spliter = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
for train, test in spliter.split(x, y):
print('分层交叉验证:', Counter(y[test]))
if __name__ == '__main__':
test()
💡 留一法( Leave-One-Out,简称LOO),即每次抽取一个样本做为测试集
from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import LeavePOut
from sklearn.datasets import load_iris
from collections import Counter
def test01():
# 1. 加载数据集
x, y = load_iris(return_X_y=True)
print('原始类别比例:', Counter(y))
print('*' * 40)
# 2. 留一法
spliter = LeaveOneOut()
for train, test in spliter.split(x, y):
print('训练集:', len(train), '测试集:', len(test), test)
print('*' * 40)
# 3. 留P法
spliter = LeavePOut(p=3)
for train, test in spliter.split(x, y):
print('训练集:', len(train), '测试集:', len(test), test)
if __name__ == '__main__':
test01()
💡每次随机从D中抽出一个样本,将其拷贝放入D,然后再将该样本放回初始数据集D中,使得该样本在下次采样时仍有可能被抽到; 这个过程重复执行m次后,我们就得到了包含m个样本的数据集D′,这就是自助采样的结果。
import pandas as pd
if __name__ == '__main__':
# 1. 构造数据集
data = [[90, 2, 10, 40],
[60, 4, 15, 45],
[75, 3, 13, 46],
[78, 2, 64, 22]]
data = pd.DataFrame(data)
print('数据集:\n',data)
print('*' * 30)
# 2. 产生训练集
train = data.sample(frac=1, replace=True)
print('训练集:\n', train)
print('*' * 30)
# 3. 产生测试集
test = data.loc[data.index.difference(train.index)]
print('测试集:\n', test)
我们得知了这几种数据划分的方法,但是哪一种划分得出的预测值是最好的呢?🔒️
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
#加载鸢尾花数据
X,y = datasets.load_iris(return_X_y = True)
#训练集 测试集划分
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
# 创建KNN分类器对象 近邻数为6
knn_clf = KNeighborsClassifier(n_neighbors=6)
#训练集训练模型
knn_clf.fit(X_train,y_train)
#使用训练好的模型进行预测
y_predict = knn_clf.predict(X_test)
计算准确率:
sum(y_predict==y_test)/y_test.shape[0]
💣️💣️sklearn封装了计算准确率的相关API:
#计算准确率
from sklearn.metrics import accuracy_score
#方式1:
accuracy_score(y_test,y_predict)
#方式2:
knn_classifier.score(X_test,y_test)
举例:
解决方案:
🐵有时候出现K值选择困难的问题
KNN算法的关键是什么?
答案一定是K值的选择,下图中K=3,属于红色三角形,K=5属于蓝色的正方形。这个时候就是K选择困难的时候。
👋👋使用 scikit-learn 提供的 GridSearchCV 工具, 配合交叉验证法可以搜索参数组合.
# 1. 加载数据集
x, y = load_iris(return_X_y=True)
# 2. 分割数据集
x_train, x_test, y_train, y_test = \
train_test_split(x, y, test_size=0.2, stratify=y, random_state=0)
# 3. 创建网格搜索对象
estimator = KNeighborsClassifier()
param_grid = {'n_neighbors': [1, 3, 5, 7]}
estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5, verbose=0)
estimator.fit(x_train, y_train)
# 4. 打印最优参数
print('最优参数组合:', estimator.best_params_, '最好得分:', estimator.best_score_)
# 4. 测试集评估模型
print('测试集准确率:', estimator.score(x_test, y_test))
KNN 算法中K值过大、过小都不好, 一般会取一个较小的值
GridSearchCV 工具可以用来寻找最优的模型超参数,可以用来做KNN中K值的选择
K近邻算法的优缺点:
本期主要介绍了KNN算法的API及分类划分的方法及评估,下一期我们将会引入案例更好的理解和巩固KNN算法,下期还将介绍距离的度量方法 👋👋