近邻算法

import numpy as np
from collections import Counter
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.utils import shuffle

iris = datasets.load_iris()  # 导入sklearn iris数据集
X, y = shuffle(iris.data, iris.target, random_state=13)  # 打乱数据后的数据与标签
X = X.astype(np.float32)  # 数据转换为float32格式
offset = int(X.shape[0] * 0.7)  # 训练集与测试集的简单划分，训练-测试比例为7：3
X_train, y_train = X[:offset], y[:offset]
X_test, y_test = X[offset:], y[offset:]

y_train = y_train.reshape((-1, 1))
y_test = y_test.reshape((-1, 1))
print('X_train=', X_train.shape)
print('X_test=', X_test.shape)
print('y_train=', y_train.shape)
print('y_test=', y_test.shape)


# 定义欧氏距离
def compute_distances(X, X_train):
    num_test = X.shape[0]  # 测试实例样本量
    num_train = X_train.shape[0]  # 训练实例样本量
    dists = np.zeros((num_test, num_train))  # 基于训练和测试维度的欧氏距离初始化
    M = np.dot(X, X_train.T)  # 测试样本与训练样本的矩阵点乘
    te = np.square(X).sum(axis=1)  # 测试样本矩阵平方
    tr = np.square(X_train).sum(axis=1)  # 训练样本矩阵平方
    dists = np.sqrt(-2 * M + tr + np.matrix(te).T)  # 计算欧式距离
    return dists


dists = compute_distances(X_test, X_train)
plt.imshow(dists, interpolation='none')
plt.show()


# 定义预测函数
def predict_labels(y_train, dists, k=1):
    num_test = dists.shape[0]  # 测试样本量
    y_pred = np.zeros(num_test)  # 初始化测试集预测结果
    for i in range(num_test):
        closest_y = []  # 初始化最近邻列表
        labels = y_train[np.argsort(dists[i, :])].flatten()
        closest_y = labels[0:k]  # 取最近的k个值
        c = Counter(closest_y)  # 对最近的k个值进行计数统计
        y_pred[i] = c.most_common(1)[0][0]  # 取计数最多的类别
    return y_pred


# 测试集预测结果
y_test_pred = predict_labels(y_train, dists, k=1)
y_test_pred = y_test_pred.reshape((-1, 1))
# 找出预测正确的实例
num_correct = np.sum(y_test_pred == y_test)
# 计算准确率
accuracy = float(num_correct) / X_test.shape[0]
print('Got %d/%d correct=>accuracy:%f' % (num_correct, X_test.shape[0], accuracy))

# 5折交叉验证
num_folds = 5
k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]  # 候选k值
X_train_folds = np.array_split(X_train, num_folds)  # 训练数据划分
y_train_folds = np.array_split(y_train, num_folds)  # 训练标签划分
k_to_accuracies = {}
# 遍历所有候选k值
for k in k_choices:
    for fold in range(num_folds):  # 五折遍历
        # 对传入的训练集单独划出一个验证集作为测试集
        validation_X_test = X_train_folds[fold]
        validation_y_test = y_train_folds[fold]
        temp_X_train = np.concatenate(X_train_folds[:fold] + X_train_folds[fold + 1:])
        temp_y_train = np.concatenate(y_train_folds[:fold] + y_train_folds[fold + 1:])
        # 计算距离
        temp_dists = compute_distances(validation_X_test, temp_X_train)
        temp_y_test_pred = predict_labels(temp_y_train, temp_dists, k=k)
        temp_y_test_pred = temp_y_test_pred.reshape((-1, 1))
        # 查看分类准确率
        num_correct = np.sum(temp_y_test_pred == validation_y_test)
        num_test = validation_X_test.shape[0]
        accuracy = float(num_correct) / num_test
        k_to_accuracies[k] = k_to_accuracies.get(k, []) + [accuracy]

# 打印不同 k 值不同折数下的分类准确率
for k in sorted(k_to_accuracies):
    for accuracy in k_to_accuracies[k]:
        print('k = %d, accuracy = %f' % (k, accuracy))

# 打印不同 k 值不同折数下的分类准确率
for k in k_choices:
    accuracies = k_to_accuracies[k]  # 取出第k个k值的分类准确率
    plt.scatter([k] * len(accuracies), accuracies)  # 绘制不同k值准确率的散点图

accuracies_mean = np.array([np.mean(v) for k, v in sorted(k_to_accuracies.items())])
accuracies_std = np.array([np.std(v) for k, v in sorted(k_to_accuracies.items())])
plt.errorbar(k_choices, accuracies_mean, yerr=accuracies_std)
plt.title('Cross-validation on k')
plt.xlabel('k')
plt.ylabel('Cross-validation accuracy')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report


def plot_decision_boundary(model, axis):
    """
    在axis范围内绘制模型model的决策边界
    :param model: classification model which must have 'predict' function
    :param axis: [left, right, down, up]
    """
    x0, x1 = np.meshgrid(
        np.linspace(axis[0], axis[1], int((axis[1] - axis[0]) * 100)).reshape(-1, 1),
        np.linspace(axis[2], axis[3], int((axis[3] - axis[2]) * 100)).reshape(-1, 1),
    )
    X_new = np.c_[x0.ravel(), x1.ravel()]

    y_predict = model.predict(X_new)
    zz = y_predict.reshape(x0.shape)

    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A', '#FFF59D', '#90CAF9'])

    plt.contourf(x0, x1, zz, linewidth=5, cmap=custom_cmap)


X, y = load_iris(return_X_y=True)
X = X[:, :2]  # 仅选择前两个特征，便于绘制决策边界
X_train, X_test, y_train, y_test = train_test_split(X, y)  # 将数据划分为训练集和测试集
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)  # (112, 2) (38, 2) (112,) (38,)

for i, n in enumerate([1, 5, 30]):
    plt.subplot(1, 3, i + 1)

    knn_cls = KNeighborsClassifier(n_neighbors=n)
    knn_cls.fit(X_train, y_train)
    y_pred = knn_cls.predict(X_test)

    print(classification_report(y_test, y_pred))  # 分类报告中包含precision/recall/f1-score

    plt.title('n_neighbors=' + str(n))
    plot_decision_boundary(knn_cls, axis=[3, 8, 1, 5])
    plt.scatter(X_test[y_test == 0, 0], X_test[y_test == 0, 1])
    plt.scatter(X_test[y_test == 1, 0], X_test[y_test == 1, 1])
    plt.scatter(X_test[y_test == 2, 0], X_test[y_test == 2, 1])

plt.show()