机器学习的敲门砖：kNN算法（中）

import numpy as npfrom sklearn import datasetsimport matplotlib.pyplot as plt

iris = datasets.load_iris()

X = iris.data
y = iris.target

X.shape
输出：(150, 4)

X.shape
输出：(150,)

# 方法1# 使用concatenate函数进行拼接，因为传入的矩阵必须具有相同的形状。因此需要对label进行reshape操作，reshape(-1,1)表示行数自动计算，1列。axis=1表示纵向拼接。tempConcat = np.concatenate((X, y.reshape(-1,1)), axis=1)# 拼接好后，直接进行乱序操作np.random.shuffle(tempConcat)# 再将shuffle后的数组使用split方法拆分shuffle_X,shuffle_y = np.split(tempConcat, [4], axis=1)# 设置划分的比例test_ratio = 0.2test_size = int(len(X) * test_ratio)
X_train = shuffle_X[test_size:]
y_train = shuffle_y[test_size:]
X_test = shuffle_X[:test_size]
y_test = shuffle_y[:test_size]

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)
输出：(120, 4)
(30, 4)
(120, 1)
(30, 1)

# 方法2# 将x长度这么多的数，返回一个新的打乱顺序的数组，注意，数组中的元素不是原来的数据，而是混乱的索引shuffle_index = np.random.permutation(len(X))# 指定测试数据的比例test_ratio = 0.2test_size = int(len(X) * test_ratio)
test_index = shuffle_index[:test_size]
train_index = shuffle_index[test_size:]
X_train = X[train_index]
X_test = X[test_index]
y_train = y[train_index]
y_test = y[test_index]

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

输出：(120, 4)
(30, 4)
(120,)
(30,)

import numpy as npdef train_test_split(X, y, test_ratio=0.2, seed=None):
    """将矩阵X和标签y按照test_ration分割成X_train, X_test, y_train, y_test"""
    assert X.shape[0] == y.shape[0], \        "the size of X must be equal to the size of y"
    assert 0.0 <= test_ratio <= 1.0, \        "test_train must be valid"

    if seed:    # 是否使用随机种子，使随机结果相同，方便debug
        np.random.seed(seed)    # permutation(n) 可直接生成一个随机排列的数组，含有n个元素
    shuffle_index = np.random.permutation(len(X))

    test_size = int(len(X) * test_ratio)
    test_index = shuffle_index[:test_size]
    train_index = shuffle_index[test_size:]
    X_train = X[train_index]
    X_test = X[test_index]
    y_train = y[train_index]
    y_test = y[test_index]    return X_train, X_test, y_train, y_test

from myAlgorithm.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y)

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

输出：(120, 4)
(30, 4)
(120,)
(30,)

from myAlgorithm.kNN import kNNClassifier

my_kNNClassifier = kNNClassifier(k=3)
my_kNNClassifier.fit(X_train, y_train)

y_predict = my_kNNClassifier.predict(X_test)
y_predict
y_test# 两个向量的比较，返回一个布尔型向量，对这个布尔向量（faluse=1，true=0）sum，sum(y_predict == y_test)29sum(y_predict == y_test)/len(y_test)0.96666666666667

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)
输出：(112, 4)
(38, 4)
(112,)
(38,)

import numpy as npimport matplotlibimport matplotlib.pyplot as pltfrom sklearn import datasetsfrom sklearn.model_selection import train_test_splitfrom sklearn.neighbors import KNeighborsClassifier# 手写数字数据集，封装好的对象，可以理解为一个字段digits = datasets.load_digits()# 可以使用keys()方法来看一下数据集的详情digits.keys()

输出：dict_keys(['data', 'target', 'target_names', 'images', 'DESCR'])

# 5620张图片，每张图片有64个像素点即特征（8*8整数像素图像），每个特征的取值范围是1～16（sklearn中的不全），对应的分类结果是10个数字print(digits.DESCR)

# 特征的shapeX = digits.data
X.shape
(1797, 64)# 标签的shapey = digits.target
y.shape
(1797, )# 标签分类digits.target_names
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])# 去除某一个具体的数据，查看其特征以及标签信息some_digit = X[666]
some_digit
array([ 0.,  0.,  5., 15., 14.,  3.,  0.,  0.,  0.,  0., 13., 15.,  9.,15.,  2.,  0.,  0.,  4., 16., 12.,  0., 10.,  6.,  0.,  0.,  8.,16.,  9.,  0.,  8., 10.,  0.,  0.,  7., 15.,  5.,  0., 12., 11.,0.,  0.,  7., 13.,  0.,  5., 16.,  6.,  0.,  0.,  0., 16., 12.,15., 13.,  1.,  0.,  0.,  0.,  6., 16., 12.,  2.,  0.,  0.])
y[666]0# 也可以这条数据进行可视化some_digmit_image = some_digit.reshape(8, 8)
plt.imshow(some_digmit_image, cmap = matplotlib.cm.binary)
plt.show()

X_train, X_test, y_train, y_test = train_test_split(X, y)
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
y_predict = knn_clf.predict(X_test)# 比对y_predict和y_test结果是否一致sum(y_predict == y_test) / len(y_test)0.9955555555555555

import numpy as npfrom math import sqrtdef accuracy_score(y_true, y_predict):
    """计算y_true和y_predict之间的准确率"""
    assert y_true.shape[0] != y_predict.shape[0], \        "the size of y_true must be equal to the size of y_predict"
    return sum(y_true == y_predict) / len(y_true)

from myAlgorithm.metrics import accuracy_score

accuracy_score(y_test, y_predict)

def score(self, X_test, y_test):
    """根据X_test进行预测, 给出预测的真值y_test，计算预测算法的准确度"""
    y_predict = self.predict(X_test)    return accuracy_score(y_test, y_predict)

my_knn_clf.score(X_test, y_test)

from sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
y_predict = knn_clf.predict(X_test)
accuracy_score(y_test, y_predict)

输出：0.9888888888888889# 不看y_predictknn_clf.score(X_test,y_test)

输出：0.9888888888888889

# 指定最佳值的分数，初始化为0.0；设置最佳值k，初始值为-1best_score = 0.0best_k = -1for k in range(1, 11):  # 暂且设定到1～11的范围内
    knn_clf = KNeighborsClassifier(n_neighbors=k)
    knn_clf.fit(X_train, y_train)
    score = knn_clf.score(X_test, y_test)    if score > best_score:
        best_k = k
        best_score = score
print("best_k = ", best_k)
print("best_score = ", best_score)

输出：best_k =  4best_score =  0.9916666666666667

# 两种方式进行比较best_method = ""best_score = 0.0best_k = -1for method in ["uniform","distance"]:    for k in range(1, 11):
        knn_clf = KNeighborsClassifier(n_neighbors=k, weights=method, p=2)
        knn_clf.fit(X_train, y_train)
        score = knn_clf.score(X_test, y_test)        if score > best_score:
            best_k = k
            best_score = score
            best_method = method
print("best_method = ", method)
print("best_k = ", best_k)
print("best_score = ", best_score)

输出：best_method =  distance
best_k =  4best_score =  0.9916666666666667

param_search = [
    {        "weights":["uniform"],        "n_neighbors":[i for i in range(1,11)]
    },
    {        "weights":["distance"],        "n_neighbors":[i for i in range(1,11)],        "p":[i for i in range(1,6)]
    }
]

knn_clf = KNeighborsClassifier()# 调用网格搜索方法from sklearn.model_selection import GridSearchCV# 定义网格搜索的对象grid_search，其构造函数的第一个参数表示对哪一个分类器进行算法搜索，第二个参数表示网格搜索相应的参数grid_search = GridSearchCV(knn_clf, param_search)

%%time
grid_search.fit(X_train, y_train)

输出：CPU times: user 2min 21s, sys: 628 ms, total: 2min 21s
Wall time: 2min 23s
GridSearchCV(cv=None, error_score='raise',
       estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=5, p=2,
           weights='uniform'),
       fit_params=None, iid=True, n_jobs=1,
       param_grid=[{'weights': ['uniform'], 'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}, {'weights': ['distance'], 'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'p': [1, 2, 3, 4, 5]}],
       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',
       scoring=None, verbose=0)

# 返回的是网格搜索搜索到的最佳的分类器对应的参数 grid_search.best_estimator_

输出：KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=3, p=3,
           weights='distance')

grid_search.best_score_

输出：0.9853862212943633grid_search.beat_params_

输出：{'n_neighbors':3, 'p':3, 'weights':'distance'}

knn_clf = grid_search.beat_estimator_
knn_clf.score(X_test, y_test)

输出：0.9833333333328