机器学习-简单了解KNN的编码过程

机器学习-KNN

KNN入门-了解KNN

import numpy as np
import matplotlib as mpl
mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
import matplotlib.pyplot as plt

# 随机种子:确保随机点不再变化
np.random.seed(28)

# 苹果的形状  reshape(-1, 1) -1行1列的数据
x_apple = np.random.normal(loc=3, scale=2, size=20).reshape(-1, 1)
# 苹果的颜色
y_apple = np.random.normal(loc=8, scale=2, size=20).reshape(-1, 1)
# 梨的形状和颜色
x_pear = np.random.normal(loc=20, scale=3, size=20).reshape(-1, 1)
y_pear = np.random.normal(loc=15, scale=3, size=20).reshape(-1, 1)

plt.figure()

plt.scatter(x_apple, y_apple, label='苹果')
plt.scatter(x_pear, y_pear, label='梨')

plt.legend(loc='upper left')
plt.xlabel('形状')
plt.ylabel('颜色')

plt.show()

# 数据集的准备  将apple和pear的数据一起拼接成数据集 apple用0来表示 pear用1来表示
X_apple = np.concatenate([x_apple, y_apple, [[0]] * 20], axis=1)
X_pear = np.concatenate([x_pear, y_pear, [[1]] * 20], axis=1)
data = np.concatenate([X_apple, X_pear])
# print(data)

# 待测样本点的准备
target = np.asarray([15, 12])

plt.scatter(15, 12)
plt.show()
# 计算待测样本点到所有数据集中的相似度并排序
def getDistance():
    # 创建40行两列的
    return_list = np.zeros(shape=(40, 2))
    i = 0
    for item in data:
        distance = np.sqrt((item[0] - target[0])**2 + (item[1] - target[1])**2)
        return_list[i] = [distance, item[2]]
        i += 1
    return return_list
return_list = getDistance()
# print(return_list)
# 排序 获得排序之后的index
sorted_index = np.argsort(return_list[:, 0])
# 改变了索引
sorted_list = return_list[sorted_index]
# 选择距离最相似的K个数据集中的样本点
k = 5
apple = 0
pear = 0
for i in range(k):
    if sorted_list[i][1] == 0:
        apple += 1
    elif sorted_list[i][1] == 1:
        pear += 1
# 表决策略（通过K个样本点）
print('apple:{}---pear:{}'.format(apple, pear))
if apple > pear:
    print('这是apple')
elif apple < pear:
    print('这是pear')
else:
    print('error')

通过已知的点和KNN算法来画KD树

import numpy as np
import pandas as pd
import matplotlib as mpl
mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
import matplotlib.pyplot as plt

data = np.array([[7, 2], [5, 4], [9, 6], [2, 3], [4, 7], [8, 1], [2, 6], [8, 9], [1, 5]])
# 数据
data = pd.DataFrame(data, columns=['x', 'y'])

# 计算方差
# print(data['x'].var())
# print(data['y'].var())

plt.figure()
# 绘制散点图
plt.scatter(data['x'].values, data['y'].values)

# 排序
def sort_data(data, is_x):
    if is_x:
        # 排序
        data = data.sort_values(by='x')
        # 重新索引
        data.reset_index(drop=True, inplace=True)
    else:
        # 排序
        data = data.sort_values(by='y')
        # 重新索引
        data.reset_index(drop=True, inplace=True)
    return data

# 画线
def draw_line(line_num, space_start, space_end, is_x):
    if is_x:
        # 绘制垂直于x的线
        plt.plot([line_num, line_num], [space_start, space_end])
    else:
        plt.plot([space_start, space_end], [line_num, line_num])

# 画kd树
def draw_kd_tree(data, is_x, space_start_x, space_start_y, space_end_x, space_end_y):

    if data['x'].count() <= 0:
        return

    # 画垂直于x的线
    if is_x:
        data = sort_data(data, True)
        # 获得中位数
        mid_index = int(data['x'].count()/2)
        # 获得该节点
        line_num = data.loc[mid_index, 'x']
        # 画线
        draw_line(line_num, space_start_y, space_end_y, True)
        left_data = data.loc[0:mid_index-1, :]
        right_data = data.loc[mid_index + 1:, :]

        draw_kd_tree(left_data, bool(1-is_x), space_start_x, space_start_y, line_num, space_end_y)
        draw_kd_tree(right_data, bool(1-is_x), line_num, space_start_y, space_end_x, space_end_y)
        pass
    # 画垂直于y的线
    else:
        data = sort_data(data, False)
        mid_index = int(data['y'].count()/2)
        line_num = data.loc[mid_index, 'y']
        draw_line(line_num, space_start_x, space_end_x, False)

        left_data = data.loc[0:mid_index - 1, :]
        right_data = data.loc[mid_index + 1:, :]
        draw_kd_tree(left_data, bool(1-is_x), space_start_x, space_start_y, space_end_x, line_num)
        draw_kd_tree(right_data, bool(1-is_x), space_start_x, line_num, space_end_x, space_end_y)
        pass


is_x = False
if data['x'].var() >= data['y'].var():
    is_x = True
else:
    is_x = False


draw_kd_tree(data, is_x, 0, 0, 10, 10)

plt.show()

导入KNN的包使用KNN的API来画树

# 数据集的生成函数
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib as mpl
mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
import matplotlib.pyplot as plt

# 导入KNN算法
from sklearn.neighbors import KNeighborsClassifier

plt.figure()

# 数据集的生成
data = make_blobs(n_samples=200, centers=2, random_state=28)
x, y = data

# KNN算法
clf = KNeighborsClassifier()

# 定义一些点  等差数列(前闭后开) -10 -9.88 -9.86
x_grid = np.arange(-10, 10, 0.02)
y_grid = np.arange(-6, 6, 0.02)

# 绘制网格
x_grid, y_grid = np.meshgrid(x_grid, y_grid)

# 把x_grid y_grid结合成一个一个坐标
z = np.c_[x_grid.ravel(), y_grid.ravel()]

# KNN预测
clf.fit(x, y)
# 将传入的点来预测是哪个分类 最终会在图上显示出范围
z = clf.predict(z)
# 将z改变为x的样式
z = z.reshape(x_grid.shape)

# 绘制背景
plt.pcolormesh(x_grid, y_grid, z, cmap=plt.cm.Pastel1)

# 绘制散点图
plt.scatter(x[:, 0], x[:, 1], c=y, cmap=plt.cm.spring, edgecolors='k')


# 预测一个坐标是哪个分类
plt.scatter(-2.5, -4, marker='*', s=200, c='r')
z = clf.predict([[-2.5, -4]])
print(z)
plt.show()

多分类KNN

# 数据集的生成函数
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib as mpl
mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
import matplotlib.pyplot as plt

# 导入KNN算法
from sklearn.neighbors import KNeighborsClassifier

# 创建数据集
data = make_blobs(n_samples=500, centers=5, random_state=8)
x, y = data


# KNN
clf = KNeighborsClassifier()
clf.fit(x, y)
print(clf.score(x, y))


# 画网格
x_grid = np.arange(-10, 12, 0.02)
y_grid = np.arange(-15, 15, 0.02)
x_grid, y_grid = np.meshgrid(x_grid, y_grid)
# 创建网格点
z = np.c_[x_grid.ravel(), y_grid.ravel()]
# 通过z去预测 预测的结果是类别
result = clf.predict(z)

# result长度重新定义
result = result.reshape(x_grid.shape)

# 先画背景
plt.pcolormesh(x_grid, y_grid, result, cmap=plt.cm.Pastel1)
# 再画散点
plt.scatter(x[:, 0], x[:, 1], c=y, cmap=plt.cm.spring, edgecolors='k')

plt.show()

使用KNN算法做回归

# 使用KNN算法做回归
from sklearn.datasets import make_regression
# 数据集的生成函数
from sklearn.datasets import make_blobs
import numpy as np
import matplotlib as mpl
mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
import matplotlib.pyplot as plt


plt.figure()
# 数据集
x, y = make_regression(n_features=1, noise=50, random_state=2)
# 绘制散点
plt.scatter(x, y)

# 创建-3到3的200个点
z = np.linspace(-3, 3, 200).reshape(-1, 1)

# todo 使用线性回归
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline

# 创建线性回归
# reg_line = LinearRegression()
# reg_line.fit(x, y)
# # 画线
# plt.plot(z, reg_line.predict(z))

# todo 多项式回归
polyModel = Pipeline([
    ('Poly', PolynomialFeatures(include_bias=True)),
    ('Linear', LinearRegression(fit_intercept=False))
])
#展开两项
polyModel.set_params()
polyModel.fit(x, y)
plt.plot(z, polyModel.predict(z), c='g', linewidth=2)
print('多项式', polyModel.score(x, y))

# todo  KNN做回归
from sklearn.neighbors import KNeighborsRegressor
# 创建KNN n_neighbors选择最近的几个点(K值)  k值过低就过拟合了
reg = KNeighborsRegressor(n_neighbors=5)
reg.fit(x, y)
plt.plot(z, reg.predict(z), c='r', linewidth=2)
print('KNN', reg.score(x, y))

plt.show()