1. 技术文章
  2. Python 高数篇 1

Python 高数篇 1

由 元气小坏坏 提交于 2020-01-15 04:40:49

Python 高数篇 1

零蚀

  1. 什么是机器学习
  2. feature和label
  3. KNN模型
  4. 训练集&测试集
  5. 二维空间的KNN

  • 什么是机器学习

    机器学习就是对于数学方法的运用，利用数学模型，最总进行数据的预测，事务通过大量的数据进行训练，通过预测解决一个未知的问题。由于机器学习非常依赖硬件的性能，所以很多机器学习的功能一直被搁置到现在才出现。

    输入
    训练
    预测
    新数据
    模型
    历史数据
    结果

  • feature和label

    1. feature 特征变量
    2. label 结果标签

    收集问题的相关的数据，构造数据模型，建立feature和label关系，根据模型进行预测。

    feature
    function
    label

  • KNN模型
    K Nearest Neighbors基于统计学，概率论的预测模型。

    • 数组处理案例1:
    import numpy as np

data = np.array([
    [111, 1],
    [152, 2],
    [23, 2],
    [241, 2],
    [193, 2],
    [152, 2],
    [374, 4]
])

# 取第一个
feature = data[:, 0]
# 取倒数第一个
label = data[0:, -1]
# 计算每个item的距离标准值200的距离
distance = list(map(lambda x: abs(200 - x), feature))  # [89, 48, 177, 41, 7, 48, 174]
# 每个参数从小到大进行排序，然后返回脚标
sort_list = np.argsort(distance)  # [4 3 1 5 0 6 2]
# 拿到对应脚标的label_list
sort_label = label[sort_list]  # [2 2 2 2 1 4 2]
    • 列表处理
    import numpy as np
import collections as cl
data = np.array([
    1,
    2,
    2,
    2,
    2,
    2,
    4,
])

# most_common(args)打印输出最多的item,[(item,count)...],args指定，打印出的item个数，默认全部
print(cl.Counter(data).most_common())  # [(2, 5), (1, 1), (4, 1)]

    由上诉可以得到在200的位置所对应的label

    import numpy as np
import collections as cl

data = np.array([
    [111, 1],
    [152, 2],
    [23, 2],
    [241, 2],
    [193, 2],
    [152, 2],
    [374, 4]
])

feature = data[:, 0]
label = data[:, -1]

dis = list(map(lambda x: abs(x - 200), feature))
sort_list = np.argsort(dis)
sort_label = label[sort_list]
# 取最近的3个数
three = sort_label[0:3]
# 前三个出频率最高的数
num = cl.Counter(three).most_common(3)[0][0]
print(num)

    通过在200附近的临近数的最大概率的值，来估计这一点的值的可能值。

    在操作csv的数据表格时候需要应用csv的plugins
    在这里插入图片描述
    抽出knn进行文件数据的预测

from Knn01 import *
import numpy as np

# 需要设置delimiter来告知是使用什么作为分隔符
data = np.loadtxt('data.csv', delimiter=',')  # [[195.   6.]....]

# 用knn来预测点feature=500的label
num = knn(100, 500, data[:, 0], data[:, -1])
print(num)

'''
k 是key neighbors范围
point 是预测点
'''


def knn(k, point, feature, label):
    dis = list(map(lambda x: abs(x - point), feature))
    sort_list = np.argsort(dis)
    sort_label = label[sort_list]
    # 取最近的3个数
    three = sort_label[0:k]
    # 拿出频率最高的数
    num = cl.Counter(three).most_common(1)[0][0]
    return num

如果数据的概率出现偏差，我们通过调整key来减小偏差。当key有问题，误差就会变大，所以重点是在key的选择上，所以会针对key进行模型评估。评估可以通过transitData训练集创建模型，通过testData测试集来测试模型的准确性。

  • 训练集&测试集

    首先要充分的打散数据，让数据不会过拟合，导致数据精度出现问题。

    • 洗数据
    # 需要设置delimiter来告知是使用什么作为分隔符
data = np.loadtxt('data.csv', delimiter=',')  # [[195.   6.]....]

# 充分打散,将数据洗1000+次
np.random.shuffle(data)

print(data)  # [[442.   5.].....]
    • 拆分数据
    # 需要设置delimiter来告知是使用什么作为分隔符
data = np.loadtxt('data.csv', delimiter=',')  # [[195.   6.]....]

# 充分打散,将数据洗1000+次
np.random.shuffle(data)

testData = data[:100]

transitData = data[100:-1]

# 保存测试集
np.savetxt('data.test.csv', testData, delimiter=',', fmt='%d')
# 保存训练集
np.savetxt('data.train.csv', transitData, delimiter=',', fmt='%d')

    测试集的数据量一般只有训练集的十分之一。通过测试集对测试数据进行逐一测试，来测试准确率。

    • 准确率测试
    test_data = np.loadtxt('data.test.csv', delimiter=',')
count = 0
for item in test_data:
    num = knn(k=10, point=item[0], feature=test_data[:, 0], label=test_data[:, -1])
    if num == item[1]:
        print(num, ":准确")
        count += 1
    else:
        print(item[1], ":失败")
print("准确率 ={}% ".format(count / len(test_data) * 100))

# print
# .....
4.0 :失败
3.0 :失败
3.0 :失败
5.0 :准确
4.0 :失败
4.0 :失败
3.0 :准确
准确率 =48.0%

    key值的选择一般在sqrt(data)的值时候，概率最大。

    • 解决数据的不精确问题

      1. 参数调整
      2. 增加数据纬度（增加feature种类）
      3. 增加测试数据
      4. 选择其他机器学习算法

  • 二维空间的KNN

    • 构建knn算法
    import numpy as np


def knn(key, point, feature, label):
    # 获取点到这个参考系的多维坐标距离
    distance = list(map(lambda item: math.sqrt((item[0] - point[0]) ** 2 + (item[1] - point[1]) ** 2), feature))
    index = np.argsort(distance)
    label_sort = label[index]
    num = cl.Counter(label_sort[:key]).most_common(1)[0][0]
    return num
    • 拆分和预测
    # converters将item进行操作,skiprows=0默认不跳过行。usecol获取的指定列数(见文档）
data = np.loadtxt('data1.csv',skiprows=0, usecols=(0,1,2),delimiter=',', converters={1: converter}, encoding='gbk')
np.random.shuffle(data)
testData = data[:120]
trainData = data[120:-1]


np.savetxt('data1.test.csv', testData, fmt="%d", delimiter=',')
np.savetxt('data1.train.csv', trainData, fmt="%d", delimiter=',')
count=0
for item in testData:
    num = knn(key=36, point=(item[0], item[2]), feature=testData[:, :2], label=testData[:, -1])
    if num == item[2]:
        print('预测成功：{}'.format(num))
        count+=1
    else:
        print('预测失败：{}'.format(item[2]))
print('预测成功率为：{}%'.format(count/len(testData)*100))
#........
# 预测失败：5.0
# 预测失败：3.0
# 预测失败：4.0
# 预测成功：3.0
# 预测失败：6.0
# 预测成功：6.0
# 预测失败：3.0
# 预测成功：3.0
# 预测成功：6.0
# 预测成功率为：40.0%

    多维就是将将距离计算放进了多维度，而这里并没有对精度产生很大的影响，并没有很大的产生过大的精度差异。案例中由于第二类feature的数过于小，对事务的影响过小，在knn中其实并没有起到什么作用。所以要将数据重新定义，对数据整形。

    • 数据归一化（数据整形）
      公式如下：
      Xnorm=X−XminXmax−XminX_{norm}=\frac{X-X_{min}} {X_{max}-X_{min}}\quad
      代码如下：
    def knn(key, point, feature, label):
    # 数据归一化处理
    max_value = max(feature[:, 0])
    min_value = min(feature[:, 0])

    # 获取点到这个参考系的多维坐标距离
    distance = list(
        map(lambda item: math.sqrt(((item[0] - min_value) / (max_value - min_value) - point[0]) ** 2 + (item[1] - point[1]) ** 2),
        feature))
    index = np.argsort(distance)
    label_sort = label[index]
    num = cl.Counter(label_sort[:key]).most_common(1)[0][0]
    return num
    • 向量和矩阵应用

    向量的基本运算：

    (5,2)T−(2,5)T=(3,−3)T(5,2)^T-(2,5)^T=(3,-3)^T

    a∗b=∑i=1nai∗bi=∣a∣∣b∣cosθa*b=\sum_{i=1}^n{a_i*b_i}=|a||b|cos\theta

    向量的距离：

    d(x,y)=(x1−y1)2+(x2−y2)2+(x3−y3)2+...+(xn−yn)2d_{(x,y)}=\sqrt{(x_1-y_1)^2+(x_2-y_2)^2+(x_3-y_3)^2+...+(x_n-y_n)^2}\quad

    在做矩阵的加减时，如果存在矩阵的行列不同时候，系统会通过矩阵广播（Broadcasting）对数据自动进行匹配，使得矩阵行数不足的进行自我复制，从而达到满足Am∗n−B1∗nA_{m*n}-B_{1*n}类同于Am∗n−Bm∗nA_{m*n}-B_{m*n}的效果。
    代码如下：

    # 矩阵和向量解决问题
feature = np.array([
    [-132, 66],
    [343.2, 45.4],
    [-233, 22.3],
    [321.9, 11.7]
])

label = np.array([
    320, 530, 160, 235, 192
])

# 定义预测点（x，y）
predict_point = np.array([122, 39])

# 矩阵广播计算(平方想家)
matrix = feature - predict_point
# 将矩阵的每一个item平方
distance_point = np.square(matrix)
# 将所有的item相加
# sum_value=np.sum(matrix)
# 将某一行item相加,axis=num,代表每次sum的行数
square_sum = np.sum(distance_point, axis=1)
# 逐行开方
sqrt_distance = np.sqrt(square_sum)
# index排序
index_distance = np.argsort(sqrt_distance)
key = 10
sort_label = label[index_distance]
num = cl.Counter(sort_label).most_common(1)[0][0]

print('预测数据为：%d' % num)
    • 数据的标准化

    数据归一化：数据的分布均匀时候用的是数据的归一化，可以将区间锁定在某一个小的区间中。
    数据标准化：数据的分布不均匀的时候，即使用了归一化，数据还是出现了极明显的两极分化，这时一般采用数据标准化来优化每个item的之间的差距。

    代码如下：

    # 求第一列的平均值
average = np.mean(data[:, 0])
# 标准差
std = np.std(data[:, 0])
# 第一列标准化
print(((data[:0] - average) / std))

    数据标准化=Value−平均值x‾标准差σ数据标准化=\frac{Value - 平均值\overline{x}}{标准差\sigma}\quad

    (σ=1N∑i=1N(xi−u)2)(\sigma=\sqrt{\frac{1}{N}\sum_{i=1}^N{(x_i-u)^2}}\quad)

    • 分类和回归

    分类问题：答案有限，范围确定，且内容全可知（三个小球里面选一个）
    回归问题：答案不限，范围不确定，且内容非定向（现在的情感变化，预测房价走势）

🔗 前言
🔗 Python 高数列表
🔗 Python 高数篇 2

标签
label
python算法
num
data
sort
python
knn
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!