python之简单机器学习

最新推荐文章于 2023-05-06 20:26:51 发布

hongge_smile

最新推荐文章于 2023-05-06 20:26:51 发布

阅读量559

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/hongge_smile/article/details/104242087

版权

Python 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

3.高等数学及算法

•机器学习：用大量数据进行训练，获取到一个数据模型，预测就是应用训练的模型，来解决一个未知的问题。

•人学习：用大量模拟题作为数据进行训练，获得的模型就是解题的方法。

机器学习入门经典模型KNN模型

K最近邻(k-Nearest Neighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

Knn算法

import numpy as np
import collections as c

# 将数据存储在二维列表里
date = np.array([[154, 1],
                 [126, 2],
                 [70, 2],
                 [196, 2],
                 [161, 2],
                 [371, 4]])
# 特征变量feature
feature = date[:, 0]
print(list(feature))
# 结果变量label
label = date[:, -1]
print(list(label))
# 预测点
predictPoint = 200
# 计算每个投掷点距离预测点的距离
distance = list(map(lambda item: abs(item - predictPoint), feature))
print(distance)
# 将距离排序,从小到大排序,返回的是下标的位置
index = np.argsort(distance)
print(index)
# 根据index值找到label值
print(label[index])
sortedLabel = label[index]
# 找到index中出现次数最多的数字
print(c.Counter(label[index]).most_common(1))
# 设置变量k,切片切取列表前k项
k = 3
sortedLabel2 = sortedLabel[0:k]
s = c.Counter(sortedLabel2).most_common(1)[0][0]
print(s)

•Numpy

Numpy是一个python的科学计算的库.

导入文件:date = np.loadtxt(‘data0.csv’,delimiter=’,’)

预测不是很准确的解决方案

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBiD6xGF-1581259573446)(img/22.png)]

优化数据模型:

•testData 测试数据集

•trainDate 训练数据集

 # 将数据存储在二维列表里
    date = np.loadtxt('data2.csv', delimiter=',')
    # 打乱数据
    np.random.shuffle(date)
    # print(date)
    # 测试集数据testDate
    testDate = date[0:110]
    # 训练集数据trainDate
    trainDate = date[110:-1]
    # 保存数据 def savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='',
    #             footer='', comments='# ', encoding=None):
    np.savetxt('data2_testDate.csv',testDate,delimiter=',', fmt='%f')
    np.savetxt('data2_trainDate.csv', trainDate, delimiter=',', fmt='%f')

numpy特殊数据转化

def color2number(str):
    dict = {'红': 0.50, '黄': 0.51, '蓝': 0.52, '绿': 0.53, '紫': 0.54, '粉': 0.55}
    return dict[str]

data=np.loadtxt('data1.csv', delimiter=',', converters={1: color2number}, encoding='GBK')
print(data)

欧式距离

在这里插入图片描述

数据的归一化(normalization)和数据的标准化(standardzation)

在这里插入图片描述

'''
归一化公式:Xnorm=(X-Xmin)/(Xmax-Xmin)
'''
import numpy as np

feature = np.array([200, 150, 630, 450])
feature1=(feature-np.min(feature))/(np.max(feature)-np.min(feature))
print(feature1)

'''
数据标准化
standardization, (value-平均值mean)/标准差
标准差公式:
'''
feature2=(feature-np.mean(feature))/np.std(feature)
print(feature2)

向量转置对数据进行标准化

import  numpy as np

data = np.array([
    [47.5112, -122.257, 1180, 221900],
    [48.5112, -123.257, 1280, 231900],
    [46.5112, -124.257, 1380, 241900],
    [45.5112, -121.257, 1480, 251900],
    [43.5112, -127.257, 1580, 261900],
])

for i in range(0,len(data.T)-1):
    feature = (data.T[i])
    mean = (np.mean(feature))
    std = np.std(feature)
    data.T[i] = (((feature - mean) / std))

print(data)

numpy中的向量和向量的计算

向量的点乘

在这里插入图片描述

'''向量运算示例'''
import numpy as np

feature = np.array([[84, 83], [84.1, 85], [84.2, 85], [84.3, 84.5], [85, 83.6]])
label = np.array([200, 250, 234, 246, 243])
predictPoint =np.array([84.2, 85.2])
#向量相减
feature1 = feature - predictPoint
#向量平方
feature2 = np.square(feature1)
# axis=表示逐行相加
feature3 = np.sum(feature2, axis=1)
# print(feature3)
#向量开方
feature4 = np.sqrt(feature3)
print(feature4)
#排序,返回索引值
index=np.argsort(feature4)
print(index)
sortlabel=label[index]
k=3
predictionPrice=np.sum(sortlabel[0:k])/k
print('预测的房价是:{}'.format(predictionPrice))

分类(classification)和回归(regression)的区别

–回归的是求topk的value 求平均值

–分类是求topk中出现最多的类别

线性回归

线性回归和knn的区别

•knn必须需要有全套数据集，每次预测都要重新计算整套数据集

•线性回归，数据集用完后，其实可以丢弃。线性回归是算一个模型。 knn可以理解成是数学统计学的方法研究问题

•线性回归，是一种总结规律，总结模型的解决问题的方法。

•线性回归就是求线性函数的参数的值的过程,自变量（independent variable）和应变量（dependent variable）

线性回归算法

普通最小二乘法,广义最小二乘法,梯度下降法,其他方法

模型分析损失函数（lost function）和最小均方差(Mean Squared Error)

在这里插入图片描述

最小均方差求导

在这里插入图片描述

偏导数

•只考虑一个变量的求导，就是偏导数
在这里插入图片描述

梯度下降代码

'''
梯度下降代码:
1.gradientdecent() 运行一次梯度下降算法
2.train() 多次运行梯度下降算法
3.predict() 使用前面train() 计算的m和b 进行预测
4.test() 测试预测的准确性（评估模型准确性）
'''
import numpy as np

m = 1
b = 1
learning_rate = 0.0000001
carData = np.loadtxt('cars.csv', delimiter=',', skiprows=1, usecols=(4, 1))
# 打乱数据
np.random.shuffle(carData)
# print(date)
# 测试集数据testDate
testDate = carData[0:110]
# 训练集数据trainDate
trainDate = carData[110:-1]
# 保存数据 def savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='',
#             footer='', comments='# ', encoding=None):
np.savetxt('car_testDate.csv', testDate, delimiter=',', fmt='%f')
np.savetxt('car_trainDate.csv', trainDate, delimiter=',', fmt='%f')
xarray = trainDate[:, 0]
yarray = trainDate[:, -1]


def gradientdecent():
    '''计算一次偏导数的函数'''
    bslop = 0
    mslop = 0
    for index, x in enumerate(xarray):
        global m
        global b
        bslop = bslop+(x * m + b - yarray[index])
    xslop = bslop * 2 / len(xarray)

    for index, x in enumerate(xarray):
        mslop = mslop+(x * m + b - yarray[index]) * x
    yslop = mslop * 2 / len(xarray)
    return (xslop, yslop)


def train():
    for i in range(0, 1000):
        (xslop, yslop) = gradientdecent()
        global m
        global b
        m = m - learning_rate * yslop
        b = b - learning_rate * xslop
        if abs(m) < 0.5 and abs(b) < 0.5:
            break
    print('m={},b={}'.format(m, b))

if __name__ == '__main__':
    train()

矩阵的运算

查看矩阵的形状:np.shape(date).

矩阵的乘法:np.dot(A,B),矩阵的乘法不满足交换律

查看矩形的形状

import numpy as np
# 引入一个科学的图形库matplotlib
import matplotlib.pyplot as plt

points = np.array([[0, 0],
                   [0, 5],
                   [3, 5],
                   [3, 4],
                   [1, 4],
                   [1, 3],
                   [2, 3],
                   [2, 2],
                   [1, 2],
                   [1, 0],
                   [0, 0]
                   ])
plt.plot(points[:, 0], points[:, 1])
# matrix = np.array([[1, 0], [0, -1]])
# p2 = points.dot(matrix)
# plt.plot(p2[:, 0], p2[:, 1])
# plt.xlim(-10, 10)
# plt.ylim(-10, 10)
plt.show()

在这里插入图片描述

矩阵的旋转

在这里插入图片描述

import numpy as np
import matplotlib.pyplot as plt
import math

points = np.array([[0, 0],
                   [0, 5],
                   [3, 5],
                   [3, 4],
                   [1, 4],
                   [1, 3],
                   [2, 3],
                   [2, 2],
                   [1, 2],
                   [1, 0],
                   [0, 0]
                   ])
plt.plot(points[:, 0], points[:, 1])
matrix = np.array([[math.cos(math.pi / 4), -math.sin(math.pi / 4)], [math.sin(math.pi / 4), math.cos(math.pi / 4)]])
p2 = points.dot(matrix.T)
plt.plot(p2[:, 0], p2[:, 1])
# 显示图形显示的区域
plt.xlim(-9, 9)
plt.ylim(-9, 9)
plt.show()

在这里插入图片描述

矩阵的平移

在这里插入图片描述

图形的缩放

在这里插入图片描述

图形的变形

在这里插入图片描述

线性回归的矩阵代码

import numpy as np

car_testDate = np.loadtxt('car_testDate.csv', delimiter=',')
car_trainDate = np.loadtxt('car_trainDate.csv', delimiter=',')

feature = car_trainDate[:, 0:1]
label = car_trainDate[:, -1:]
# label=np.expand_dims(car_trainDate[:,-1],axis=1)
m = 1
b = 1
learningrate = 0.000001
weights = np.array([[m], [b]])
# feature在后面加一列,1
featureMatrix = np.append(feature, np.ones(shape=(len(feature), 1)), axis=1)
import numpy as np

car_testDate = np.loadtxt('car_testDate.csv', delimiter=',')
car_trainDate = np.loadtxt('car_trainDate.csv', delimiter=',')

feature = car_trainDate[:, 0:1]
# label = car_trainDate[:, -1:]
label=np.expand_dims(car_trainDate[:,-1],axis=1)
m = 1
b = 1
learningrate = 0.000001
weights = np.array([[m], [b]])
# feature在后面加一列,1
featureMatrix = np.append(feature, np.ones(shape=(len(feature), 1)), axis=1)
# featureMatrix与weights相乘,得到预测值,然后减去真实值,得到差值
dmatrix = np.dot(featureMatrix, weights) - label


# featureMatrix,转置,然后与上面得到的差值相乘,得到m和b的偏导数
# zmatrix = np.dot(featureMatrix.T, dmatrix) * 2 / len(feature)
# print(zmatrix)

def grandentdecent():
    return np.dot(featureMatrix.T, np.dot(featureMatrix, weights) - label) / len(feature) * 2


def train():
    for i in range(1, 300):
        result = grandentdecent()
        global weights
        weights = weights - result * learningrate
        if abs(result[0, 0]) < 0.5 and (result[1, 0]) < 0.5:
            print('weights={}'.format(weights))
            break
    print('weights={}'.format(weights))


if __name__ == '__main__':
    train()

线性回归误差分析

import  numpy as np

#模型
def calc(x1,x2):
   return -0.09881976*x1+(-4.73274969)*x2+40.65357893

#评估模型的准确性

if __name__ == '__main__':
    testdata = np.loadtxt("test-data.csv",delimiter=",")
    feature = testdata[:,0:2]
    label = testdata[:,-1]

    totalerror = 0
    for index,item in enumerate(feature):
        predict = calc(item[0],item[1])
        real = label[index]
        errorrate = (real - predict)/real
        totalerror = totalerror + abs(errorrate)

    error = totalerror/len(label)
    print("错误率：{}".format(error))

逻辑回归和线性回归

•线性回归，预测的数字是连续的

•逻辑回归，预测的是分类的问题

在这里插入图片描述

逻辑回归代码

import numpy as np

data = np.array([[5, 0],
                 [15, 0],
                 [25, 1],
                 [35, 1],
                 [45, 1],
                 [55, 1]
                 ])
feature = data[:, 0:1]
featureMatrix = np.append(feature, np.ones(shape=(len(feature), 1)), axis=1)
label = data[:, -1:]
m = 1
b = 1
learning = 0.001
weights = np.array([[m],
                    [b]
                    ])


# 预测值


def gradentDecent():
    predict = 1 / (1 + np.exp(-(np.dot(featureMatrix, weights))))
    # 带入sigmod函数
    return (np.dot(featureMatrix.T, predict - label))


def train():
    for i in range(1, 10000000):
        slop = gradentDecent()
        global weights
        weights = weights - slop * learning
        if abs(slop[0]) < 0.0001 and abs(slop[1]) < 0.0001:
            print(weights)
            print(slop)
            break
    else:
        print(weights)
        print(slop)


if __name__ == '__main__':
    train()

数据预测代码

import numpy as np

weights = np.array([[1.43147863],
                    [-28.37462375]])
feature = np.array([[50, 1],
                    [10, 1],
                    [13, 1],
                    [23, 1]])
predict = 1 / (1 + np.exp(-np.dot(feature, weights)))
print(predict)

多问题分类hot encoding

在这里插入图片描述

数字识别预测代码

import numpy as np

# 保证所有数据能够显示，而不是用省略号表示，np.inf表示一个足够大的数
np.set_printoptions(threshold=np.inf)
# 若想不以科学计数显示:
np.set_printoptions(suppress=True)


def filter(str):
    if int(str.decode()) == 0:
        return 1
    else:
        return 0


# 得到feature并且归一化
feature = np.loadtxt('train_image.csv', delimiter=',', max_rows=3000) / 255
# print(len(feature))
# print(feature)
learningrate = 0.0001
featureMatrix = np.append(feature, np.ones(shape=(len(feature), 1)), axis=1)
weights = np.ones(shape=(785, 1))
# 获取label，假设设别4
label = np.loadtxt('train_labels.csv', delimiter=',', max_rows=3000, converters={0: filter})
labelMatrix = np.expand_dims(label, axis=1)


def gradentDecent():
    predict = 1 / (1 + np.exp(-(np.dot(featureMatrix, weights))))
    # 带入sigmod函数
    return (np.dot(featureMatrix.T, predict - labelMatrix))


def train():
    for i in range(1, 5000):
        slop = gradentDecent()
        global weights
        weights = weights - slop * learningrate
        # if abs(slop[0]) < 0.0001 and abs(slop[1]) < 0.0001:
        #     print(weights)
        #     print(slop)
        #     break
    # else:
    # print(weights)
    # print()
    # print(slop)
    return weights


if __name__ == '__main__':
    # 训练
    weights = train()
    testfeature = np.loadtxt('test_image.csv', delimiter=',', max_rows=100) / 255
    testfeatureMatrix = np.append(testfeature, np.ones(shape=(len(testfeature), 1)), axis=1)
    testlabel = np.loadtxt('test_label.csv', delimiter=',', max_rows=100)
    predict = 1 / (1 + np.exp(-(np.dot(testfeatureMatrix, weights))))
    print(predict)

神经网络数学原理解释

人工神经网络（Artificial Neural Networks，简写为ANNs）也简称为神经网络（NNs）或称作连接模型（Connection Model），它是一种模仿动物神经网络行为特征，进行分布式并行信息处理的算法数学模型。这种网络依靠系统的复杂程度，通过调整内部大量节点之间相互连接的关系，从而达到处理信息的目的。

在这里插入图片描述

•Cross-entropy交叉熵

交叉熵（Cross Entropy）是Shannon信息论中一个重要概念，主要用于度量两个概率分布间的差异性信息。语言模型的性能通常用交叉熵和复杂度（perplexity）来衡量。交叉熵的意义是用该模型对文本识别的难度，或者从压缩的角度来看，每个词平均要用几个位来编码。复杂度的意义是用该模型表示这一文本平均的分支数，其倒数可视为每个词的平均概率。

在这里插入图片描述