sklearn分类算法

转换器--特征工程的父类

1.实例化（实例化的是一个转换器类（Transformer)）

2.调用fit_transform

        标准化：

(x-mean)/std
fit_transform()
    fit()        #计算每一列的平均值、标准差
    transform()   #(x-mean)/std进行最终的转换

估计器estimator（sklearn机器学习算法的实现）

1.实例化一个estimator

2.计算，调用完毕后生成模型

estimator.fit(x_train,y_train)  #计算

3.模型评估

1）直接比对真实值以及预测值

y_predict = estimator.predict(x_test)
y_test == y_predict

2）计算准确度

accary = estimator.score(x_test,y_test)

KNN算法（K近邻算法）

定义

如果一个样本在特征空间中的k个最相似（即最邻近）的样本中的大多数属于某一个类别，则该样本也属于这一个类别。

PS:K值取得过小，容易受到异常点的影响

      K值取得过大，样本不均衡的影响

标准化

sklearn.neighbor.KNeighborsClassifier(n_neighbors=5,algorithm='auto')

n_neighbors:K值

from sklearn.datasets import load_iris
from sklearn.model_selection import  train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

def knn_iris():
    """
    用KNN算法对鸢尾花进行分类
    :return:
    """
    # 获取数据
    iris = load_iris()

    # 划分数据集
    x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target,random_state=6)
    # 特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train,y_train)
    # 模型评估
    # 直接比对真实值以及预测值
    y_pretict = estimator.predict(x_test)
    print("y_predict:\n",y_pretict)
    print("直接比对真实值和预测值：\n",y_test == y_pretict)
    # 计算准确率
    score = estimator.score(x_test,y_test)
    print("准确率为：\n",score)

    return None
if __name__ == "__main__":
    knn_iris()

运行结果：

y_predict:
 [0 2 1 2 1 1 1 2 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 2 2 2 2 0 0 1 1 1 0 0
 0]
直接比对真实值和预测值：
 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True]
准确率为：
 0.9736842105263158

Process finished with exit code 0

优点：简单，易于理解实现，无需训练

缺点：必须指定K值，K值选择不当影响精度，对测试样本分类时计算量大，内存开销大

模型选择与调优

交叉验证

超参数搜索-网格搜索

sklearn.model_selection.GridSearchCV(estimator,param_grid=None,cv=None)

estimator:估计器对象

param_grid:估计器参数

cv:指定几折交叉验证

fit()输入训练数据

score():准确率

import sklearn.model_selection
from sklearn.datasets import load_iris
from sklearn.model_selection import  train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV


def knn_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类,添加网格搜索以及交叉验证
    :return:
    """
    # 获取数据
    iris = load_iris()

    # 划分数据集
    x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target,random_state=22)
    # 特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # KNN算法预估器
    estimator = KNeighborsClassifier()
    estimator.fit(x_train,y_train)
    # 加入网格搜索以及交叉验证
    # 参数准备
    param_dict = {"n_neighbors":[1,3,5,7,9,11]}   #注意n_neighbors，小编因为少了s一直报错
    estimator = GridSearchCV(estimator,param_grid=param_dict,cv=10)
    estimator.fit(x_train,y_train)
    # 模型评估
    # 直接比对真实值以及预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("直接比对真实值和预测值：\n",y_test == y_predict)
    # 计算准确率
    score = estimator.score(x_test,y_test)
    print("准确率为：\n",score)

    print("最佳参数:\n",estimator.best_params_)
    print("最佳结果:\n", estimator.best_score_)
    print("最佳估计器:\n", estimator.best_estimator_)
    print("交叉验证结果:\n", estimator.cv_results_)

    return None
if __name__ == "__main__":
    knn_iris_gscv()

运行结果：

D:\Anaconda\python.exe "D:\pythonProject\PyTorch\mechine learning\sklearn20231009.py" 
y_predict:
 [0 2 1 2 1 1 1 2 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 2 2 2 2 0 0 1 1 1 0 0
 0]
直接比对真实值和预测值：
 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True]
准确率为：
 0.9736842105263158
最佳参数:
 {'n_neighbors': 3}
最佳结果:
 0.9553030303030303
最佳估计器:
 KNeighborsClassifier(n_neighbors=3)
交叉验证结果:
 {'mean_fit_time': array([0.00040319, 0.00040002, 0.00040333, 0.00029492, 0.00030046,
       0.00040343]), 'std_fit_time': array([0.00049387, 0.00048992, 0.00049405, 0.00045056, 0.00045895,
       0.00049417]), 'mean_score_time': array([0.00069377, 0.00079978, 0.00080028, 0.00070093, 0.00069993,
       0.00069602]), 'std_score_time': array([0.00045435, 0.00039989, 0.00040014, 0.00045887, 0.00045821,
       0.00045597]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
             mask=[False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([0.91666667, 0.91666667, 1.        , 1.        , 0.91666667,
       0.91666667]), 'split1_test_score': array([1., 1., 1., 1., 1., 1.]), 'split2_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 0.90909091,
       0.90909091]), 'split3_test_score': array([0.90909091, 1.        , 0.90909091, 0.90909091, 0.90909091,
       1.        ]), 'split4_test_score': array([1., 1., 1., 1., 1., 1.]), 'split5_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 0.90909091,
       0.90909091]), 'split6_test_score': array([0.90909091, 0.90909091, 0.90909091, 1.        , 1.        ,
       1.        ]), 'split7_test_score': array([0.90909091, 0.90909091, 0.81818182, 0.81818182, 0.81818182,
       0.81818182]), 'split8_test_score': array([1., 1., 1., 1., 1., 1.]), 'split9_test_score': array([1., 1., 1., 1., 1., 1.]), 'mean_test_score': array([0.94621212, 0.95530303, 0.94545455, 0.95454545, 0.94621212,
       0.95530303]), 'std_test_score': array([0.04397204, 0.0447483 , 0.06030227, 0.06098367, 0.05988683,
       0.0604591 ]), 'rank_test_score': array([4, 1, 6, 3, 4, 1])}

Process finished with exit code 0