Python 高数篇 1

最新推荐文章于 2023-07-18 17:12:25 发布

零蚀zero eclipse

最新推荐文章于 2023-07-18 17:12:25 发布

阅读量374

点赞数

分类专栏：高数篇

本文链接：https://blog.csdn.net/qq_38315348/article/details/103928982

版权

高数篇专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Python 高数篇 1

零蚀

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

什么是机器学习

机器学习就是对于数学方法的运用，利用数学模型，最总进行数据的预测，事务通过大量的数据进行训练，通过预测解决一个未知的问题。由于机器学习非常依赖硬件的性能，所以很多机器学习的功能一直被搁置到现在才出现。
feature和label
1. feature 特征变量
2. label 结果标签
收集问题的相关的数据，构造数据模型，建立feature和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中其实并没有起到什么作用。所以要将数据重新定义，对数据整形。
- 数据归一化（数据整形）
  公式如下：
  $X_{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$

$a*b=\sum_{i=1}^n{a_i*b_i}=|a||b|cos\theta$

向量的距离：

$d_{(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）对数据自动进行匹配，使得矩阵行数不足的进行自我复制，从而达到满足 $A_{m*n}-B_{1*n}$ 类同于 $A_{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))
```
$数据标准化=\frac{Value - 平均值\overline{x}}{标准差\sigma}\quad$

$(\sigma=\sqrt{\frac{1}{N}\sum_{i=1}^N{(x_i-u)^2}}\quad)$
- 分类和回归
分类问题：答案有限，范围确定，且内容全可知（三个小球里面选一个）
回归问题：答案不限，范围不确定，且内容非定向（现在的情感变化，预测房价走势）

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

零蚀zero eclipse

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python 高数篇 1

Python 高数篇 1什么是机器学习feature和labelKNN模型训练集&测试集什么是机器学习机器学习就是对于数学方法的运用，利用数学模型，最总进行数据的预测，事务通过大量的数据进行训练，通过预测解决一个未知的问题。由于机器学习非常依赖硬件的性能，所以很多机器学习的功能一直被搁置到现在才出现。输入训练预测新数据模型历史数据结果feature和label...
复制链接

扫一扫