python的第三方库知识笔记

库安装

pip

安装

命令行搜cmd

更新卸载下载但不安装列出信息搜第三方库已安装的库

更新：U代表updata

卸载

下载但不安装

提升速度

换源后缀

-i https://pypi.tuna.tsinghua.edu.cn/simple

各类源

清华镜像源（大幅提升包下载速度） pip install”命令后加入“-i 源地址” pip install -U tensorflow-gpu -i https://pypi.tuna.tsinghua.edu.cn/simple（-U表示有的话直接升级） pip install jieba -i https://pypi.tuna.tsinghua.edu.cn/simple /*国内镜像源*/ 清华大学镜像源： pip install [包名] -i https://pypi.tuna.tsinghua.edu.cn/simple some-package 阿里云镜像源：pip install -i https://mirrors.aliyun.com/pypi/simple/[包名] 豆瓣镜像源：pip install [包名] -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com 中国科技大学镜像源： https://pypi.mirrors.ustc.edu.cn/simple/ 华中理工大学镜像源：http://pypi.hustunique.com/ 山东理工大学镜像源：http://pypi.sdutlinux.org/

pip install -y jupyter d2l torch torchvision -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com

更新PIP

python -m pip install --upgrade pip

若能下载因为需要编译不能安装的情况

uci

Anaconda

通用描述信息获取

变量+？

a?

执行程序

%run 程序名

魔术命令

常用conda命令

conda -h/–help 查看帮助信息 conda list 列出当前环境下所有安装的 conda包。 conda search 查询 conda 包，只有经过 conda 重新编译入库的才能查询得到 conda install scrapy=1.5.0 安装 conda update scrapy 更新 conda remove scrapy 卸载

换源提速

解决方案：更换anaconda源，使用清华的源 conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/ conda config --set show_channel_urls yes 再次执行升级操作，速度飞起！

相关分析

协方差判定（并不精确）

皮尔森系数

r的取值在-1与+1之间，若r>0，表明两个变量是正相关，即一个变量的值越大，另一个变量的值也会越大；若r<0，表明两个变量是负相关，即一个变量的值越大另一个变量的值反而会越小。r 的绝对值越大表明相关性越强，要注意的是这里并不存在因果关系。若r=0，表明两个变量间不是线性相关，但有可能是其他方式的相关（比如曲线方式）

代码实现

两个都是一维

官方技术文档

https://pandas.pydata.org/pandas-docs/stable/reference/index.html

其它

介绍

一维Series类型

介绍

自定义索引

作为第二个参数，可以省略index=

创建

标量创建

字典创建

Index指定结构创建

ndarray创建

列表创建

操作

获取索引/数据值

索引

单值索引

自定义索引和自动索引并存

多值索引

再加一个[ ]

条件索引

切片

索引判定

类似字典

对齐

只会留下相同索引值

Series对象命名

修改值

类似字典，直接赋值即可

二维多维DataFrame

定义

自然语言处理

jieba分词库

安装

原理

三种模式（输入=str 输出=list）

wordcloud词云库

介绍

文本变词云

基本原理（接受分类器）

加载文本输出图像

流程

内部流程

wordcloudWordCloud()参数

图像长宽

字体大小

字体~最大单词数~排除列表

词云形状~背景色

tensorflow

安装

参考文章

https://blog.csdn.net/weixin_44170512/article/details/103990592

报错处理

错：twisted 18.7.0 requires PyHamcrest>=1.9.0, which is not installed.

解：pip install PyHamcrest -i https://pypi.tuna.tsinghua.edu.cn/simple

缺什么安装什么

流程

CUDA安装

CUDA软件安装

cuDNN神经网络加速库安装

配置环境变量

TensorFlow安装

pip install -U tensorflow-gpu -i https://pypi.tuna.tsinghua.edu.cn/simple

新版安装

tf下载命令（豆瓣快） pip install tensorflow==2.1 -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com

经典实例代码

鸢尾花数据分类

流程

神经网络结构

实敲

# 利用鸢尾花数据集，实现前向传播、反向传播，可视化loss曲线 # 导入所需模块 import tensorflow as tf from sklearn import datasets from matplotlib import pyplot as plt import numpy as np # 导入数据，分别为输入特征和标签 x_data = datasets.load_iris().data y_data = datasets.load_iris().target # 随机打乱数据（因为原始数据是顺序的，顺序不打乱会影响准确率） # seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样（为方便教学，以保每位同学结果一致） np.random.seed(116) # 使用相同的seed，保证输入特征和标签一一对应 np.random.shuffle(x_data) np.random.seed(116) np.random.shuffle(y_data) tf.random.set_seed(116) # 将打乱后的数据集分割为训练集和测试集，训练集为前120行，测试集为后30行 x_train = x_data[:-30] y_train = y_data[:-30] x_test = x_data[-30:] y_test = y_data[-30:] # 转换x的数据类型，否则后面矩阵相乘时会因数据类型不一致报错 x_train = tf.cast(x_train, tf.float32) x_test = tf.cast(x_test, tf.float32) # from_tensor_slices函数使输入特征和标签值一一对应。（把数据集分批次，每个批次batch组数据） train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32) test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32) # 生成神经网络的参数，4个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元 # 用tf.Variable()标记参数可训练 # 使用seed使每次生成的随机数相同（方便教学，使大家结果都一致，在现实使用时不写seed） w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1)) b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1)) lr = 0.1 # 学习率为0.1 train_loss_results = [] # 将每轮的loss记录在此列表中，为后续画loss曲线提供数据 test_acc = [] # 将每轮的acc记录在此列表中，为后续画acc曲线提供数据 epoch = 500 # 循环500轮 loss_all = 0 # 每轮分4个step，loss_all记录四个step生成的4个loss的和 # 训练部分 for epoch in range(epoch): #数据集级别的循环，每个epoch循环一次数据集 for step, (x_train, y_train) in enumerate(train_db): #batch级别的循环，每个step循环一个batch with tf.GradientTape() as tape: # with结构记录梯度信息 y = tf.matmul(x_train, w1) + b1 # 神经网络乘加运算 y = tf.nn.softmax(y) # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss） y_ = tf.one_hot(y_train, depth=3) # 将标签值转换为独热码格式，方便计算loss和accuracy loss = tf.reduce_mean(tf.square(y_ - y)) # 采用均方误差损失函数mse = mean(sum(y-out)^2) loss_all += loss.numpy() # 将每个step计算出的loss累加，为后续求loss平均值提供数据，这样计算的loss更准确 # 计算loss对各个参数的梯度 grads = tape.gradient(loss, [w1, b1]) # 实现梯度更新 w1 = w1 - lr * w1_grad b = b - lr * b_grad w1.assign_sub(lr * grads[0]) # 参数w1自更新 b1.assign_sub(lr * grads[1]) # 参数b自更新 # 每个epoch，打印loss信息 print("Epoch {}, loss: {}".format(epoch, loss_all/4)) train_loss_results.append(loss_all / 4) # 将4个step的loss求平均记录在此变量中 loss_all = 0 # loss_all归零，为记录下一个epoch的loss做准备 # 测试部分 # total_correct为预测对的样本个数, total_number为测试的总样本数，将这两个变量都初始化为0 total_correct, total_number = 0, 0 for x_test, y_test in test_db: # 使用更新后的参数进行预测 y = tf.matmul(x_test, w1) + b1 y = tf.nn.softmax(y) pred = tf.argmax(y, axis=1) # 返回y中最大值的索引，即预测的分类 # 将pred转换为y_test的数据类型 pred = tf.cast(pred, dtype=y_test.dtype) # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int型 correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32) # 将每个batch的correct数加起来 correct = tf.reduce_sum(correct) # 将所有batch中的correct数加起来 total_correct += int(correct) # total_number为测试的总样本数，也就是x_test的行数，shape[0]返回变量的行数 total_number += x_test.shape[0] # 总的准确率等于total_correct/total_number acc = total_correct / total_number test_acc.append(acc) print("Test_acc:", acc) print("--------------------------") # 绘制 loss 曲线 plt.title('Loss Function Curve') # 图片标题 plt.xlabel('Epoch') # x轴变量名称 plt.ylabel('Loss') # y轴变量名称 plt.plot(train_loss_results, label="$Loss$") # 逐点画出trian_loss_results值并连线，连线图标是Loss plt.legend() # 画出曲线图标 plt.show() # 画出图像 # 绘制 Accuracy 曲线 plt.title('Acc Curve') # 图片标题 plt.xlabel('Epoch') # x轴变量名称 plt.ylabel('Acc') # y轴变量名称 plt.plot(test_acc, label="$Accuracy$") # 逐点画出test_acc值并连线，连线图标是Accuracy plt.legend() plt.show()

基础知识区

tensorflow介绍

它是什么

用数据流图用于数值计算且支持多平台的工具

特性

1.高灵活性 2.可移植性 3.产品和科研结合 4.自动求微分 5.多语言支撑 6.性能最优化

架构

开发流程

核

keras

介绍

tf.keras

联系

区别

选择

人工智能三学派

行为主义

基于控制论目的：构建感知—动作控制系统 (控制如平衡、行走、避障等自适应控制系统)

符号主义

基于算数逻辑表达式流程：求解问题先把问题描述为表达式，再求解表达式目的：实现理性思维，构建专家系统

连接主义

基于仿生学，模仿神经元链接关系目的：实现感性思维，如神经网络

神经网络MP模型

两位科学家将大脑的计算方式归纳为MP模型特征，然后求和

神经网络复杂度NN

空间复杂度：层数 = 隐藏层 + 1个输出层下图为2层总参数 = 总W +总b 下图第一层：3*4（W） + 4（b）第二层：4*2(W) + 2(b) 共26

时间复杂度：定义：乘加运算次数（权重线个数）下图 3*4 + 4*2 = 20

指数衰减学习率

代码实敲

import tensorflow as tf w = tf.Variable(tf.constant(5, dtype=tf.float32)) epoch = 40 LR_BASE = 0.2 # 最初学习率 LR_DECAY = 0.99 # 学习率衰减率 LR_STEP = 1 # 喂入多少轮BATCH_SIZE后，更新一次学习率 for epoch in range(epoch): # for epoch 定义顶层循环，表示对数据集循环epoch次，此例数据集数据仅有1个w,初始化时候constant赋值为5，循环100次迭代。 lr = LR_BASE * LR_DECAY ** (epoch / LR_STEP) with tf.GradientTape() as tape: # with结构到grads框起了梯度的计算过程。 loss = tf.square(w + 1) grads = tape.gradient(loss, w) # .gradient函数告知谁对谁求导 w.assign_sub(lr * grads) # .assign_sub 对变量做自减即：w -= lr*grads 即 w = w - lr*grads print("After %s epoch,w is %f,loss is %f,lr is %f" % (epoch, w.numpy(), loss, lr))

应用

先用较大学习率，快速得到较优解，然后逐步减小学习率，使模型在后期稳定这样会节省迭代时间

过拟合与欠拟合

子主题

激活函数

sigmoid

tf.nn.sigmoid(x)

Tanh

tf.math.tanh(x)

relu

tf.nn.relu(x)

注：dead情况是激活值为负数时，梯度 = 0，意味着不更新，也就是神经元死亡解决： 1.改变随机初始化，避免过多负数送入relu函数 2.减少学习率，减少参数的巨大变化，避免训练中产生过多负数进入relu

leeky relu

tf.nn.leaky_relu(x)

专为解决负数过多设计的

建议

损失函数

均方误差MSE loss_mse = tf.reduce_mean(tf.square(y_-y))

ce(Cross Entropy)交叉熵

标准版： tf.losses.categorical_crossentropy(y_,y)

softmax版： tf.nn.softmax_cross_entropy_with_logits(y_,y)

自定义损失函数

子主题

sklearm中的三种误差

from sklearn.metrics import mean_squared_error, mean_absolute_error #引入模块 # calculate MSE 均方误差 ---> E[(预测值-真实值)^2] (预测值减真实值求平方后求均值) mse = mean_squared_error(predicted_stock_price, real_stock_price) # calculate RMSE 均方根误差--->sqrt[MSE] (对均方误差开方) rmse = math.sqrt(mean_squared_error(predicted_stock_price, real_stock_price)) # calculate MAE 平均绝对误差----->E[|预测值-真实值|](预测值减真实值求绝对值后求均值） mae = mean_absolute_error(predicted_stock_price, real_stock_price)

优化器

总纲 1.计算 t 时刻损失函数关于当前参数的梯度g 2.计算 t 时刻一阶动量 m 和二阶动量 V 3.计算 t 时刻下降梯度 n = lr * m/(v**0.5) 4.计算 t + 1 时刻参数 w = w - n

SGD 描述：随机梯度下降 m = g v = 1 n = lr * g w = w - lr * g

代码

w1.assign_sub(lr * grads[0]) # 参数w1自更新 b1.assign_sub(lr * grads[1]) # 参数b自更新等等参数

SGDM 描述：在SGD上增加一阶动量 #m表示各时刻梯度方向的指数滑动平均值 β默认0.9

代码

m_w,m_b = 0,0 #初始值都要设置为0 beta = 0.9 #默认比较好的参数 m_w = beta * m_w + (1 - beta) * grads[0] m_b = beta * m_b + (1 - beta) * grads[1] w1.assign_sub(lr * m_w) b1.assign_sub(lr * m_b)

Adagrad 描述：在SGD基础上增加二阶动量 #v 是从开始到现在，梯度累计的平方和

代码

v_w,v_b = 0,0 # adagrad v_w += tf.square(grads[0]) v_b += tf.square(grads[1]) w1.assign_sub(lr * grads[0] / tf.sqrt(v_w)) b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))

RMSP 描述：SGD基础上增加二阶动量 #v ：计算方式 → 指数滑动平均值计算表征 → 过去一段时间的平均值

代码

v_w , v_b = 0,0 beta = 0.9 # rmsprop v_w = beta * v_w + (1 - beta) * tf.square(grads[0]) v_b = beta * v_b + (1 - beta) * tf.square(grads[1]) w1.assign_sub(lr * grads[0] / tf.sqrt(v_w)) b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))

Adam 描述：一阶动量和二阶动量相结合默认值 β1 = 0.9 β2 = 0.999

代码

m_w , m_b = 0 , 0 v_w , v_b = 0 , 0 beta1 , beta2 = 0 , 0 delta_w , delta_b = 0 , 0 global_step = 0 #训练部分双层循环 global_step += 1 with结构 # adam #动量计算部分 m_w = beta1 * m_w + (1 - beta1) * grads[0] m_b = beta1 * m_b + (1 - beta1) * grads[1] v_w = beta2 * v_w + (1 - beta2) * tf.square(grads[0]) v_b = beta2 * v_b + (1 - beta2) * tf.square(grads[1]) #修正部分 m_w_correction = m_w / (1 - tf.pow(beta1, int(global_step))) m_b_correction = m_b / (1 - tf.pow(beta1, int(global_step))) v_w_correction = v_w / (1 - tf.pow(beta2, int(global_step))) v_b_correction = v_b / (1 - tf.pow(beta2, int(global_step))) #更新部分 w1.assign_sub(lr * m_w_correction / tf.sqrt(v_w_correction)) b1.assign_sub(lr * m_b_correction / tf.sqrt(v_b_correction))

基础函数区

Tensor张量

介绍

张量：多维数组（列表）阶：张量的维数判断阶数看 [ 有几个，几个就是几阶

数据类型

创建

直接创建

tf.constant(张量内容，dtype=数据类型（可选）)

shape()中逗号隔开几个数字，就是几维张量

NP转化

tf.convert_to_tensor(数据名，dtype=数据类型)

numpy格式转化

创建全部为m的数组

tf.zeros(维度)全0 tf.ones(维度)全1 tf.fill(维度，指定值K)全K

维度注意

实例

随机初始化数组

正态分布随机数 tf.random.normal(维度,mean=均值，stddev=标准差)

正态分布的随机数(随机数更集中一些) tf.random.truncated_normal(维度，mean=均值，stddev=标准差)

子主题

均匀分布随机数范围：【min,max） tf.ranom.uniform(维度，minval=最小值，maxval=最大值)

常用函数

基本数学运算

+ : tf.add(x,y) - : tf.subtract(x,y) * : tf.multiply(x,y) / : tf.divide(x,y) (需要维度相同) 平方: tf.square(x) n次方: tf.pow(x,n) 开方: tf.sqrt(x) 矩阵乘：tf.matmul(x,y) 类似dot

转化类型/最大最小值

强制转换张量数据类型 tf.cast(张量名，dtype=数据类型)

计算张量维度上元素的最小值 tf.reduce_min(张量名)

计算张量维度上元素的最大值 tf.reduce_max(张量名)

指定维度平均值/和

指定维度平均值 tf.reduce_mean(张量名，axis=轴)

指定维度和 tf.reduce_sum(张量名，axis=轴)

Variable

可训练参数Variable tf.Variable() 将变量标记为可训练被标记的变量会在反向传播中记录梯度信息常用于标记带训练参数 w = tf.Variable(初始值)

特征标签配对

函数体 dataset = tf.data.Dataset.from_tensor_slices((features, labels))

求导

tf.GradientTape（）

格式： with tf.GradientTape() as tape: 若干计算过程 grad = tape.gradient(函数, 对谁求导)

枚举

seq = ['one', 'two', 'three'] for i, element in enumerate(seq): print(i, element) # i 接收索引 element接收元素

可以枚举每个元素并配上索引号，常在for循环中使用

独热编码

tf.one_hot（待转换数据，几分类）

softmax

tf.nn.softmax(y) 使输出符合概率分布

自更新

w = tf.Variable(4) #要先变为可训练类型 w.assign_sub(1) #等价于w-=1 即 w = w-1

某维度最大值的索引

tf.argmax(张量名，axis=操作轴)

axis理解

=0 纵向操作 =1 横向操作不指定全部元素参与计算

条件语句

条件where

tf.where(条件语句，真返回A，假返回B)

tf.greater(a,b)指判断a,b各维度大小

网络八股

六步法提纲Sequential

import #引入模块 train,test #告知训练集、测试集 model = tf.keras.models.Sequential #网络结构（前向传播） model.compile #优化器、损失函数、评测指标选择 model.fit #训练告知test和train特征和标签、batch、迭代次数 model.summary #打印出网络的结构和参数统计

Sequential(连续的)结构设置

model = tf.keras.models.Sequential(网络结构)#描述各层网络

结构举例

拉直层： tf.keras.layers.Flatten() #不含计算，只是形状转换输入：特征输出：拉直后的一维数组

全连接层： tf.keras.layers.Dense(神经元个数,activation = "激活函数"， kernl_regularizer = "正则化类型") activation(字符串给出)可选：relu、softmax、sigmoid、tanh、 kernel_regularizer 可选：tf.keras.regularizers.l1()、tf.keras.regularizers.l2()

卷积层： tf.keras.layers.Conv2D(filters = 卷积核个数，kernel_size = 卷积核尺寸 strides = 卷积步长，padding = "valid" or "same")

LSTM层： tf.keras.layers.LSTM()

compile(编制)设置

model.compile(optimizer = 优化器，loss = 损失函数，metrics = ["准确率"])

优化器可选

字符串类参数

"sgd" "adagrad" "adadelta" "adam"

精细控制类参数

tf.keras.optimizers.SGD(lr = 学习率，momentum = 动量参数) tf.keras.optimizers.Adagrad(lr = 学习率） tf.keras.optimizers.Adadelta(lr = 学习率） tf.keras.optimizers.Adam(lr = 学习率,beta_1 = 0.9, beta_2 = 0.999）

loss可选

字符串类

"mes" "sparse_categorical_crossentropy"

精细控制类

tf.keras.losses.MeanSquaredError() tf.keras.losses.SparseCategoricalCrossentropy(from_logits = False) #False = 经过概率分布（如softmax）的输出 Ture = 没有经过概率分布的输出 #应用提示：如果在十分类问题上正确率只有1/10，很有可能是这个参数错了

metrics评测指标

字符串类

"accuracy" : y_真实答案和y预测答案都是数值，如y_1 = [1] y = [1] "categorical_accuracy" : y_和y都是独热码(概率分布) #绝对准确率 "sparse_categorical_accuracy": y_是数值，y是独热码（概率分布）

fit 训练设置

model.fit(训练集输入特征，训练集的标签，batch_size = , epoch = , validation_data =(测试集的输入特征，测试集的标签), validation_split = 从训练集划分多少比例给测试集，#data和split 二者选一 validation_freq = 多少次epoch用测试集测试一次)

详细参数

fit( x, y, batch_size=32, epochs=10, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0)

summary总览

model.summary()

代码示例（鸢尾花预测）

import tensorflow as tf from sklearn import datasets import numpy as np #第一步 x_train = datasets.load_iris().data y_train = datasets.load_iris().target #第二步 np.random.seed(116) np.random.shuffle(x_train) np.random.seed(116) np.random.shuffle(y_train) tf.random.set_seed(116)#数据乱序 model = tf.keras.models.Sequential([ tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2()) ]) #第三步 model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy'])#上层用了softmax 所以这是False #第四步 model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20) #第五步 model.summary() #第六步

特点：上层输出就是下层输入

class八股

特点：可以带有跳连的非顺序网络结构

import train,test class MyModel(Model)model = MyModel model.compile model.fit model.summary

类框架代码

class MyModel(Model):#表示继承了TF的Model类 def _init_(self):#准备积木 super(MyModel,self)._init_() 定义网络结构块 def call(self,x):#调用积木调用网络结构块，实现前向传播 return y model = MyModel()

八股增强功能

自制数据集

应用场景：本领域的数据集加载与处理

实例代码

import numpy as np import os import tensorflow as tf from PIL import Image #给定各种数据的存放位置 train_path = './mnist_image_label/mnist_train_jpg_60000/' train_txt = './mnist_image_label/mnist_train_jpg_60000.txt' x_train_savepath = './mnist_image_label/mnist_x_train.npy' y_train_savepath = './mnist_image_label/mnist_y_train.npy' test_path = './mnist_image_label/mnist_test_jpg_10000/' test_txt = './mnist_image_label/mnist_test_jpg_10000.txt' x_test_savepath = './mnist_image_label/mnist_x_test.npy' y_test_savepath = './mnist_image_label/mnist_y_test.npy' #数据集制作函数 def generateds(path,txt): f = open(txt,"r")#只读模式打开txt文本类型的原始数据 contents = f.readlines()#内容 = 读入所有行，每行为元素 f.close() #关闭文件避免占用资源 x,y_ = [],[]#准备好x_train和y_train存放的地方 for content in contents:#遍历每一行 value = content.split()#空格分开图片名和标签 img_path = path + value[0]#该图的索引路径=图片路径+图片名 img = Image.open(img_path)#读入图片 img = np.array(img.convert("L"))#图片变为8位宽度的灰度值 img = img/255 #数据归一化 x.append(img)#加入列表x y_.append(value[1])#标签加入列表y_ print("loading:"+content)#打印状态提示 x = np.array(x) y_ = np.array(y_) y_ = y_.astype(np.int64) return x,y_ #判定如果已存在制作好的数据集则直接读取，没有的话就根据txt制作数据集 if os.path.exists(x_train_savepath) and os.path.exists(y_train_savepath) and os.path.exists( x_test_savepath) and os.path.exists(y_test_savepath): print('-------------Load Datasets-----------------') x_train_save = np.load(x_train_savepath) y_train = np.load(y_train_savepath) x_test_save = np.load(x_test_savepath) y_test = np.load(y_test_savepath) x_train = np.reshape(x_train_save, (len(x_train_save), 28, 28)) x_test = np.reshape(x_test_save, (len(x_test_save), 28, 28)) else: print('-------------Generate Datasets-----------------') x_train, y_train = generateds(train_path, train_txt) x_test, y_test = generateds(test_path, test_txt) print('-------------Save Datasets-----------------') x_train_save = np.reshape(x_train, (len(x_train), -1)) x_test_save = np.reshape(x_test, (len(x_test), -1)) #-1代表让程序自己根据原来的维度和给定的维度len(x_train)来判断剩余维度 np.save(x_train_savepath, x_train_save) np.save(y_train_savepath, y_train) np.save(x_test_savepath, x_test_save) np.save(y_test_savepath, y_test) #TF深度学习部分 model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1) model.summary()

数据增强

应用场景：在数据集不够的情况下进行得到数据扩充

实例代码

import tensorflow as tf from tensorflow.keras.preprocessing.image import ImageDataGenerator mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 x_train = x_train.reshape(x_train.shape[0], 28, 28, 1) # 给数据增加一个维度,从(60000, 28, 28)reshape为(60000, 28, 28, 1),是数据和网络结构匹配 image_gen_train = ImageDataGenerator( rescale=1. / 1., # 如为图像，分母为255时，可归至0～1 rotation_range=45, # 随机45度旋转 width_shift_range=.15, # 宽度偏移 height_shift_range=.15, # 高度偏移 horizontal_flip=False, # 水平翻转 zoom_range=0.5 # 将图像随机缩放阈量50％ ) image_gen_train.fit(x_train) model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) model.fit(image_gen_train.flow(x_train, y_train, batch_size=32), epochs=5, validation_data=(x_test, y_test), validation_freq=1)#将增强后的数据以flow形式按照batch打包后训练 model.summary()

关键函数

image_gen_train = ImageDataGenerator( rescale=1. / 1., #数据归一化，如为图像，分母为255时，可归至0～1 rotation_range=45, # 随机45度旋转 width_shift_range=.15, # 宽度偏移 height_shift_range=.15, # 高度偏移 horizontal_flip=False, # 水平翻转 zoom_range=0.5 # 将图像随机缩放阈量50％ ) image_gen_train.fit(x_train)

断点续训

应用场景：存取模型介绍：在进行神经网络训练过程中由于一些因素导致训练无法进行，需要保存当前的训练结果下次接着训练

代码

import tensorflow as tf import os mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) checkpoint_save_path = "./checkpoint/mnist.ckpt"#路径+文件名 if os.path.exists(checkpoint_save_path + '.index'):#因为生成ckpt文件时候会生成索引表，所以通过判断是不是有了索引表，就可以判断有没有保存过模型参数了，如果有，就直接读取 print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True,#是否只保留模型参数 save_best_only=True)#是否只保留最优结果 history = model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) model.summary()

输出

参数提取

应用场景：刚刚保存的参数是多少，我想看看过程：把参数存入文本

#为什么设置print输出格式？因为不设置会有很多省略号

代码

#手写数字识别 + 断点续训 + 查看/保存参数 import tensorflow as tf import os import numpy as np np.set_printoptions(threshold=np.inf)#打印所有内容 mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) #断点续训 checkpoint_save_path = "./checkpoint/mnist.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True) history = model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) model.summary() #打印所有可训练参数 print(model.trainable_variables) #保存参数 file = open('./weights.txt', 'w') for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close()

acc/loss可视化

子主题

关键代码

# 显示训练集和验证集的acc和loss曲线 history = model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) acc = history.history['sparse_categorical_accuracy']#训练集准确率 val_acc = history.history['val_sparse_categorical_accuracy']#测试集准确率 loss = history.history['loss']#训练集损失 val_loss = history.history['val_loss']#测试集损失 plt.subplot(1, 2, 1)#分为1行两列并选中第一列 plt.plot(acc, label='Training Accuracy') plt.plot(val_acc, label='Validation Accuracy') plt.title('Training and Validation Accuracy') plt.legend()#画出图例 plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.plot(val_loss, label='Validation Loss') plt.title('Training and Validation Loss') plt.legend() plt.show()

完整代码

import tensorflow as tf import os import numpy as np from matplotlib import pyplot as plt np.set_printoptions(threshold=np.inf) mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) checkpoint_save_path = "./checkpoint/mnist.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True) history = model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) model.summary() print(model.trainable_variables) file = open('./weights.txt', 'w') for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ############################################### show ############################################### # 显示训练集和验证集的acc和loss曲线 acc = history.history['sparse_categorical_accuracy'] val_acc = history.history['val_sparse_categorical_accuracy'] loss = history.history['loss'] val_loss = history.history['val_loss'] plt.subplot(1, 2, 1) plt.plot(acc, label='Training Accuracy') plt.plot(val_acc, label='Validation Accuracy') plt.title('Training and Validation Accuracy') plt.legend() plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.plot(val_loss, label='Validation Loss') plt.title('Training and Validation Loss') plt.legend() plt.show()

给图识物

代码

from PIL import Image import numpy as np import tensorflow as tf model_save_path = './checkpoint/mnist.ckpt' model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax')]) model.load_weights(model_save_path) preNum = int(input("input the number of test pictures:"))#输入多少次识别任务 #数据预处理 for i in range(preNum): image_path = input("the path of test picture:") img = Image.open(image_path) img = img.resize((28, 28), Image.ANTIALIAS)#转化为神经网络能消化的尺寸28*28 img_arr = np.array(img.convert('L')) #颜色突出因为训练时是黑底白字图，而现在输入则是白纸黑字图 for i in range(28):#双层循环，遍历每个像素点 for j in range(28): if img_arr[i][j] < 200:#像素值小于200的，设置为黑色 img_arr[i][j] = 255 else: img_arr[i][j] = 0 #img_arr = 255 - img_arr 或者采取这个颜色取反 img_arr = img_arr / 255.0#数据归一化更适合神经网络计算 x_predict = img_arr[tf.newaxis, ...]#前边添加一个1维度，因为数据训练前都是按照batch送入网络 result = model.predict(x_predict)#输出softmax概率值 pred = tf.argmax(result, axis=1)#取最大值索引 print('\n') tf.print(pred) plt.pause(1) plt.close()

+1维度注释图

反转注释图

手写数字识别完整代码

总训练代码

#引入模块 import tensorflow as tf import os import numpy as np from matplotlib import pyplot as plt np.set_printoptions(threshold=np.inf)#设置打印参数无限多 #加载数据 mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 #网络结构 model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) #模型配置 model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) #断点续训 checkpoint_save_path = "./checkpoint/mnist.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True) #训练 history = model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) #总结 model.summary() #print(model.trainable_variables) #保存参数 file = open('./weights.txt', 'w') for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ############################################### show ############################################### #可视化 # 显示训练集和验证集的acc和loss曲线 acc = history.history['sparse_categorical_accuracy'] val_acc = history.history['val_sparse_categorical_accuracy'] loss = history.history['loss'] val_loss = history.history['val_loss'] plt.subplot(1, 2, 1) plt.plot(acc, label='Training Accuracy') plt.plot(val_acc, label='Validation Accuracy') plt.title('Training and Validation Accuracy') plt.legend() plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.plot(val_loss, label='Validation Loss') plt.title('Training and Validation Loss') plt.legend() plt.show()

总应用代码

from PIL import Image import numpy as np import tensorflow as tf import matplotlib.pyplot as plt model_save_path = './checkpoint/mnist.ckpt' model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.load_weights(model_save_path) preNum = int(input("input the number of test pictures:"))#调用次数 for i in range(preNum): image_path = input("the path of test picture:")#输入图片位置和名字 img = Image.open(image_path)#打开图片 image = plt.imread(image_path) plt.set_cmap('gray') plt.imshow(image) img = img.resize((28, 28), Image.ANTIALIAS) img_arr = np.array(img.convert('L')) for i in range(28): for j in range(28): if img_arr[i][j] < 220: img_arr[i][j] = 255 else: img_arr[i][j] = 0 #img_arr = 255 - img_arr img_arr = img_arr / 255.0 x_predict = img_arr[tf.newaxis, ...] result = model.predict(x_predict) pred = tf.argmax(result, axis=1) print('\n') tf.print(pred) plt.pause(1) plt.close()

序列模型

循环核

介绍

特点：参数时间共享，循环层提取时间信息作用：通过不同时刻的参数共享，实现对时间序列的信息提取

图示

计算过程

刷新状态

前向传播：记忆体内存储的状态ht ，在每个时刻都被刷新三个参数wxh,whh,why固定不变

反向传播：三个参数矩阵wxh whh why被梯度下降法更新

时间步展开图

每个时刻记忆信息ht被刷新

循环神经网络

介绍

借助循环核提取时间特征后，送入全连接网络

层数=核数

TF rnn函数

F.循环计算层

tf.keras.layer.SimpleRNN(记忆体个数， activation = "激活函数", return_sequences = 是否每个时刻输出ht到下一层)

参数可选 activation = "激活函数"（不写，默认tanh） return_sequences = True 各时间步输出ht return_sequences =False 仅最后时间步输出ht（默认）例：SimpleRNN(3,return_sequences = True)

True时的情况

False

x_train格式要求： [送入样本数，循环核时间展开步数，每个时间步输入特征个数]

例解：图1 数据2样本 1时间步每步3特征图2 数据1样本 4时间步每步2特征

计算过程图示

一个循环核的前向传播计算过程

实例代码

一对一预测

任务：使模型在给出abcde五个字母中任意一个时，预测出它的下一个字母如输入a,输出b，输入e，输出a

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dense, SimpleRNN import matplotlib.pyplot as plt import os input_word = "abcde" w_to_id = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4} # 单词映射到数值id的词典 id_to_onehot = {0: [1., 0., 0., 0., 0.], 1: [0., 1., 0., 0., 0.], 2: [0., 0., 1., 0., 0.], 3: [0., 0., 0., 1., 0.], 4: [0., 0., 0., 0., 1.]} # id编码为one-hot x_train = [id_to_onehot[w_to_id['a']], id_to_onehot[w_to_id['b']], id_to_onehot[w_to_id['c']], id_to_onehot[w_to_id['d']], id_to_onehot[w_to_id['e']]] y_train = [w_to_id['b'], w_to_id['c'], w_to_id['d'], w_to_id['e'], w_to_id['a']] #引导模型看到输入a,则输出b，看到b则输出c np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 使x_train符合SimpleRNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。 # 此处整个数据集送入，送入样本数为len(x_train)；输入1个字母出结果，循环核时间展开步数为1; 表示为独热码有5个输入特征，每个时间步输入特征个数为5 x_train = np.reshape(x_train, (len(x_train), 1, 5)) y_train = np.array(y_train) model = tf.keras.Sequential([ SimpleRNN(3), Dense(5, activation='softmax') ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01),#学习率为0.01 loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy'])#y_数值，y预测为独热码 #断点续训路径 checkpoint_save_path = "./checkpoint/rnn_onehot_1pre1.ckpt" #如果以前有训练过的参数则加载参数继续训练 if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='loss') # 由于fit没有给出测试集，不计算测试集准确率，根据loss，保存最优模型 history = model.fit(x_train, y_train, batch_size=32, epochs=100, callbacks=[cp_callback]) model.summary() # print(model.trainable_variables) file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ############################################### show ############################################### # 显示训练集和验证集的acc和loss曲线 acc = history.history['sparse_categorical_accuracy'] loss = history.history['loss'] plt.subplot(1, 2, 1) plt.plot(acc, label='Training Accuracy') plt.title('Training Accuracy') plt.legend() plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.title('Training Loss') plt.legend() plt.show() ############### predict ############# preNum = int(input("input the number of test alphabet:"))#输入次数 for i in range(preNum): alphabet1 = input("input test alphabet:")#输入字母 alphabet = [id_to_onehot[w_to_id[alphabet1]]]#字母变为机器能理解的独热码 # 使alphabet符合SimpleRNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。此处验证效果送入了1个样本，送入样本数为1；输入1个字母出结果，所以循环核时间展开步数为1; 表示为独热码有5个输入特征，每个时间步输入特征个数为5 alphabet = np.reshape(alphabet, (1, 1, 5)) #因为是一个字母，所以1 #因为一步出结果，所以1 #因为独热码有五个热证，所以5 result = model.predict([alphabet])#装入列表进行预测 pred = tf.argmax(result, axis=1)#取概率值最大的那个下标 pred = int(pred)#变为整数类型 tf.print(alphabet1 + '->' + input_word[pred])#“abcde”中索引那个下标

词嵌入解决代码

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dense, SimpleRNN, Embedding import matplotlib.pyplot as plt import os input_word = "abcde" w_to_id = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4} # 单词映射到数值id的词典 x_train = [w_to_id['a'], w_to_id['b'], w_to_id['c'], w_to_id['d'], w_to_id['e']] y_train = [w_to_id['b'], w_to_id['c'], w_to_id['d'], w_to_id['e'], w_to_id['a']] np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 使x_train符合Embedding输入要求：[送入样本数，循环核时间展开步数] ， # 此处整个数据集送入所以送入，送入样本数为len(x_train)；输入1个字母出结果，循环核时间展开步数为1。 x_train = np.reshape(x_train, (len(x_train), 1))#送入5个样本，输入1个字母出结果 y_train = np.array(y_train)#变为np格式 #结构： model = tf.keras.Sequential([ Embedding(5, 2),#词汇表大小为5（abcde），2个数字表示一个字母 #上一行会生成一个[5,2]的可训练参数矩阵，实现编码可训练 SimpleRNN(3),#三个循环核 Dense(5, activation='softmax')#最终是五个字母的预测概率值 ]) #编制 model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) #断点续训 checkpoint_save_path = "./checkpoint/run_embedding_1pre1.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='loss') # 由于fit没有给出测试集，不计算测试集准确率，根据loss，保存最优模型 #训练 history = model.fit(x_train, y_train, batch_size=32, epochs=100, callbacks=[cp_callback]) #总结 model.summary() #存储参数 # print(model.trainable_variables) file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ############################################### show ############################################### # 显示训练集和验证集的acc和loss曲线 acc = history.history['sparse_categorical_accuracy'] loss = history.history['loss'] plt.subplot(1, 2, 1) plt.plot(acc, label='Training Accuracy') plt.title('Training Accuracy') plt.legend() plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.title('Training Loss') plt.legend() plt.show() ############### predict ############# preNum = int(input("input the number of test alphabet:")) for i in range(preNum): alphabet1 = input("input test alphabet:") alphabet = [w_to_id[alphabet1]] # 使alphabet符合Embedding输入要求：[送入样本数，循环核时间展开步数]。 # 此处验证效果送入了1个样本，送入样本数为1；输入1个字母出结果，循环核时间展开步数为1。 alphabet = np.reshape(alphabet, (1, 1)) result = model.predict(alphabet) pred = tf.argmax(result, axis=1) pred = int(pred) tf.print(alphabet1 + '->' + input_word[pred])

多对一预测

任务：

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dense, SimpleRNN import matplotlib.pyplot as plt import os input_word = "abcde" w_to_id = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4} # 单词映射到数值id的词典 id_to_onehot = {0: [1., 0., 0., 0., 0.], 1: [0., 1., 0., 0., 0.], 2: [0., 0., 1., 0., 0.], 3: [0., 0., 0., 1., 0.], 4: [0., 0., 0., 0., 1.]} # id编码为one-hot x_train = [ [id_to_onehot[w_to_id['a']], id_to_onehot[w_to_id['b']], id_to_onehot[w_to_id['c']], id_to_onehot[w_to_id['d']]], [id_to_onehot[w_to_id['b']], id_to_onehot[w_to_id['c']], id_to_onehot[w_to_id['d']], id_to_onehot[w_to_id['e']]], [id_to_onehot[w_to_id['c']], id_to_onehot[w_to_id['d']], id_to_onehot[w_to_id['e']], id_to_onehot[w_to_id['a']]], [id_to_onehot[w_to_id['d']], id_to_onehot[w_to_id['e']], id_to_onehot[w_to_id['a']], id_to_onehot[w_to_id['b']]], [id_to_onehot[w_to_id['e']], id_to_onehot[w_to_id['a']], id_to_onehot[w_to_id['b']], id_to_onehot[w_to_id['c']]], ] y_train = [w_to_id['e'], w_to_id['a'], w_to_id['b'], w_to_id['c'], w_to_id['d']] np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 使x_train符合SimpleRNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。 # 此处整个数据集送入，送入样本数为len(x_train)；输入4个字母出结果，循环核时间展开步数为4; 表示为独热码有5个输入特征，每个时间步输入特征个数为5 x_train = np.reshape(x_train, (len(x_train), 4, 5))#[5,4,5] #送入样本数 5个字母序列 #输入4个字母出结果所以4 #每个时间步特征为5个所以5 y_train = np.array(y_train) model = tf.keras.Sequential([ SimpleRNN(3),#循环核越多，记忆力越好，占用资源也越大 Dense(5, activation='softmax')#因为最终要5个字母的输出概率 ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy'])#答案为数值，预测值为独热码 checkpoint_save_path = "./checkpoint/rnn_onehot_4pre1.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='loss') # 由于fit没有给出测试集，不计算测试集准确率，根据loss，保存最优模型 history = model.fit(x_train, y_train, batch_size=32, epochs=100, callbacks=[cp_callback]) model.summary() # print(model.trainable_variables) file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ############################################### show ############################################### # 显示训练集和验证集的acc和loss曲线 acc = history.history['sparse_categorical_accuracy'] loss = history.history['loss'] plt.subplot(1, 2, 1) plt.plot(acc, label='Training Accuracy') plt.title('Training Accuracy') plt.legend() plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.title('Training Loss') plt.legend() plt.show() ############### predict ############# preNum = int(input("input the number of test alphabet:")) for i in range(preNum): alphabet1 = input("input test alphabet:") alphabet = [id_to_onehot[w_to_id[a]] for a in alphabet1]#遍历这四个字母 # 使alphabet符合SimpleRNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。此处验证效果送入了1个样本，送入样本数为1；输入4个字母出结果，所以循环核时间展开步数为4; 表示为独热码有5个输入特征，每个时间步输入特征个数为5 alphabet = np.reshape(alphabet, (1, 4, 5))#此时单字母样本送入，所以1 #4字母出结果，所以4 #每步5特征，所以5 result = model.predict([alphabet])#装入列表预测 pred = tf.argmax(result, axis=1) pred = int(pred) tf.print(alphabet1 + '->' + input_word[pred])

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dense, SimpleRNN, Embedding import matplotlib.pyplot as plt import os input_word = "abcdefghijklmnopqrstuvwxyz" w_to_id = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25} # 单词映射到数值id的词典 training_set_scaled = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25] x_train = [] y_train = [] for i in range(4, 26): x_train.append(training_set_scaled[i - 4:i]) y_train.append(training_set_scaled[i]) np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 使x_train符合Embedding输入要求：[送入样本数，循环核时间展开步数] ， # 此处整个数据集送入所以送入，送入样本数为len(x_train)；输入4个字母出结果，循环核时间展开步数为4。 x_train = np.reshape(x_train, (len(x_train), 4)) y_train = np.array(y_train) model = tf.keras.Sequential([ Embedding(26, 2), SimpleRNN(10), Dense(26, activation='softmax') ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False), metrics=['sparse_categorical_accuracy']) checkpoint_save_path = "./checkpoint/rnn_embedding_4pre1.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='loss') # 由于fit没有给出测试集，不计算测试集准确率，根据loss，保存最优模型 history = model.fit(x_train, y_train, batch_size=32, epochs=100, callbacks=[cp_callback]) model.summary() file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ############################################### show ############################################### # 显示训练集和验证集的acc和loss曲线 acc = history.history['sparse_categorical_accuracy'] loss = history.history['loss'] plt.subplot(1, 2, 1) plt.plot(acc, label='Training Accuracy') plt.title('Training Accuracy') plt.legend() plt.subplot(1, 2, 2) plt.plot(loss, label='Training Loss') plt.title('Training Loss') plt.legend() plt.show() ################# predict ################## preNum = int(input("input the number of test alphabet:")) for i in range(preNum): alphabet1 = input("input test alphabet:") alphabet = [w_to_id[a] for a in alphabet1] # 使alphabet符合Embedding输入要求：[送入样本数，时间展开步数]。 # 此处验证效果送入了1个样本，送入样本数为1；输入4个字母出结果，循环核时间展开步数为4。 alphabet = np.reshape(alphabet, (1, 4)) result = model.predict([alphabet]) pred = tf.argmax(result, axis=1) pred = int(pred) tf.print(alphabet1 + '->' + input_word[pred])

股票预测

F.获取实时股价

import tushare as ts import matplotlib.pyplot as plt df1 = ts.get_k_data('600519', ktype='D', start='2010-04-26', end='2020-04-26') datapath1 = "./SH600519.csv" df1.to_csv(datapath1)

任务：茅台数据股价预测输入：60天的以往数据输出：第61天的股票行情

普通RNN

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dropout, Dense, SimpleRNN import matplotlib.pyplot as plt import os import pandas as pd from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error, mean_absolute_error import math maotai = pd.read_csv('./SH600519.csv') # 读取股票文件 training_set = maotai.iloc[0:2426 - 300, 2:3].values # 前(2426-300=2126)天的开盘价作为训练集,表格从0开始计数，2:3 是提取[2:3)列，前闭后开,故提取出C列开盘价 test_set = maotai.iloc[2426 - 300:, 2:3].values # 后300天的开盘价作为测试集 # 归一化 sc = MinMaxScaler(feature_range=(0, 1)) #实例化定义归一化：归一化到(0，1)之间 training_set_scaled = sc.fit_transform(training_set) # 求得训练集的最大值，最小值这些训练集固有的属性，并在训练集上进行归一化 test_set = sc.transform(test_set) # 利用训练集的属性对测试集进行归一化 x_train = [] y_train = [] x_test = [] y_test = [] # 测试集：csv表格中前2426-300=2126天数据 #做训练集 # 利用for循环，遍历整个训练集，提取训练集中连续60天的开盘价作为输入特征x_train，第61天的数据作为标签，for循环共构建2426-300-60=2066组数据。 for i in range(60, len(training_set_scaled)):#2126-60=2066次循环，所以生成2066组数据 x_train.append(training_set_scaled[i - 60:i, 0]) y_train.append(training_set_scaled[i, 0]) # 对训练集进行打乱 np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 将训练集由list格式变为array格式 x_train, y_train = np.array(x_train), np.array(y_train) # 使x_train符合RNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。 # 此处整个数据集送入，送入样本数为x_train.shape[0]即2066组数据；输入60个开盘价，预测出第61天的开盘价，循环核时间展开步数为60; 每个时间步送入的特征是某一天的开盘价，只有1个数据，故每个时间步输入特征个数为1 x_train = np.reshape(x_train, (x_train.shape[0], 60, 1)) #做测试集 # 测试集：csv表格中后300天数据 # 利用for循环，遍历整个测试集，提取测试集中连续60天的开盘价作为输入特征x_train，第61天的数据作为标签，for循环共构建300-60=240组数据。 for i in range(60, len(test_set)): x_test.append(test_set[i - 60:i, 0]) y_test.append(test_set[i, 0]) # 测试集变array并reshape为符合RNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数] x_test, y_test = np.array(x_test), np.array(y_test) x_test = np.reshape(x_test, (x_test.shape[0], 60, 1)) model = tf.keras.Sequential([ SimpleRNN(80, return_sequences=True),#80个循环核，各时间步输出记忆值ht Dropout(0.2),#随机失活 SimpleRNN(100), Dropout(0.2), Dense(1)#因为输出值第61天的开盘价只有一个数值，所以是1 ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='mean_squared_error') # 损失函数用均方误差 # 该应用只观测loss数值，不观测准确率，所以删去metrics选项，一会在每个epoch迭代显示时只显示loss值 checkpoint_save_path = "./checkpoint/rnn_stock.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='val_loss') history = model.fit(x_train, y_train, batch_size=64, epochs=50, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) model.summary() file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() loss = history.history['loss'] val_loss = history.history['val_loss'] plt.plot(loss, label='Training Loss') plt.plot(val_loss, label='Validation Loss') plt.title('Training and Validation Loss') plt.legend() plt.show() ################## predict ###################### # 测试集输入模型进行预测 predicted_stock_price = model.predict(x_test) # 对预测数据还原---从（0，1）反归一化到原始范围 predicted_stock_price = sc.inverse_transform(predicted_stock_price) # 对真实数据还原---从（0，1）反归一化到原始范围 real_stock_price = sc.inverse_transform(test_set[60:])#索引60以后的都是真实值 # 画出真实数据和预测数据的对比曲线 plt.plot(real_stock_price, color='red', label='MaoTai Stock Price') plt.plot(predicted_stock_price, color='blue', label='Predicted MaoTai Stock Price') plt.title('MaoTai Stock Price Prediction') plt.xlabel('Time') plt.ylabel('MaoTai Stock Price') plt.legend() plt.show() ##########evaluate############## # calculate MSE 均方误差 ---> E[(预测值-真实值)^2] (预测值减真实值求平方后求均值) mse = mean_squared_error(predicted_stock_price, real_stock_price) # calculate RMSE 均方根误差--->sqrt[MSE] (对均方误差开方) rmse = math.sqrt(mean_squared_error(predicted_stock_price, real_stock_price)) # calculate MAE 平均绝对误差----->E[|预测值-真实值|](预测值减真实值求绝对值后求均值） mae = mean_absolute_error(predicted_stock_price, real_stock_price) print('均方误差: %.6f' % mse) print('均方根误差: %.6f' % rmse) print('平均绝对误差: %.6f' % mae)

LSTM

#在普通RNN代码基础上改动这两处 1.引入模块加入LSTM 2.seq模块LSTM层替换RNN层

实际代码

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dropout, Dense, LSTM import matplotlib.pyplot as plt import os import pandas as pd from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error, mean_absolute_error import math maotai = pd.read_csv('./SH600519.csv') # 读取股票文件 training_set = maotai.iloc[0:2426 - 300, 2:3].values # 前(2426-300=2126)天的开盘价作为训练集,表格从0开始计数，2:3 是提取[2:3)列，前闭后开,故提取出C列开盘价 test_set = maotai.iloc[2426 - 300:, 2:3].values # 后300天的开盘价作为测试集 # 归一化 sc = MinMaxScaler(feature_range=(0, 1)) # 定义归一化：归一化到(0，1)之间 training_set_scaled = sc.fit_transform(training_set) # 求得训练集的最大值，最小值这些训练集固有的属性，并在训练集上进行归一化 test_set = sc.transform(test_set) # 利用训练集的属性对测试集进行归一化 x_train = [] y_train = [] x_test = [] y_test = [] # 测试集：csv表格中前2426-300=2126天数据 # 利用for循环，遍历整个训练集，提取训练集中连续60天的开盘价作为输入特征x_train，第61天的数据作为标签，for循环共构建2426-300-60=2066组数据。 for i in range(60, len(training_set_scaled)): x_train.append(training_set_scaled[i - 60:i, 0]) y_train.append(training_set_scaled[i, 0]) # 对训练集进行打乱 np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 将训练集由list格式变为array格式 x_train, y_train = np.array(x_train), np.array(y_train) # 使x_train符合RNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。 # 此处整个数据集送入，送入样本数为x_train.shape[0]即2066组数据；输入60个开盘价，预测出第61天的开盘价，循环核时间展开步数为60; 每个时间步送入的特征是某一天的开盘价，只有1个数据，故每个时间步输入特征个数为1 x_train = np.reshape(x_train, (x_train.shape[0], 60, 1)) # 测试集：csv表格中后300天数据 # 利用for循环，遍历整个测试集，提取测试集中连续60天的开盘价作为输入特征x_train，第61天的数据作为标签，for循环共构建300-60=240组数据。 for i in range(60, len(test_set)): x_test.append(test_set[i - 60:i, 0]) y_test.append(test_set[i, 0]) # 测试集变array并reshape为符合RNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数] x_test, y_test = np.array(x_test), np.array(y_test) x_test = np.reshape(x_test, (x_test.shape[0], 60, 1)) model = tf.keras.Sequential([ LSTM(80, return_sequences=True), Dropout(0.2), LSTM(100), Dropout(0.2), Dense(1) ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='mean_squared_error') # 损失函数用均方误差 # 该应用只观测loss数值，不观测准确率，所以删去metrics选项，一会在每个epoch迭代显示时只显示loss值 checkpoint_save_path = "./checkpoint/LSTM_stock.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='val_loss') history = model.fit(x_train, y_train, batch_size=64, epochs=50, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) model.summary() file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() loss = history.history['loss'] val_loss = history.history['val_loss'] plt.plot(loss, label='Training Loss') plt.plot(val_loss, label='Validation Loss') plt.title('Training and Validation Loss') plt.legend() plt.show() ################## predict ###################### # 测试集输入模型进行预测 predicted_stock_price = model.predict(x_test) # 对预测数据还原---从（0，1）反归一化到原始范围 predicted_stock_price = sc.inverse_transform(predicted_stock_price) # 对真实数据还原---从（0，1）反归一化到原始范围 real_stock_price = sc.inverse_transform(test_set[60:]) # 画出真实数据和预测数据的对比曲线 plt.plot(real_stock_price, color='red', label='MaoTai Stock Price') plt.plot(predicted_stock_price, color='blue', label='Predicted MaoTai Stock Price') plt.title('MaoTai Stock Price Prediction') plt.xlabel('Time') plt.ylabel('MaoTai Stock Price') plt.legend() plt.show() ##########evaluate############## # calculate MSE 均方误差 ---> E[(预测值-真实值)^2] (预测值减真实值求平方后求均值) mse = mean_squared_error(predicted_stock_price, real_stock_price) # calculate RMSE 均方根误差--->sqrt[MSE] (对均方误差开方) rmse = math.sqrt(mean_squared_error(predicted_stock_price, real_stock_price)) # calculate MAE 平均绝对误差----->E[|预测值-真实值|](预测值减真实值求绝对值后求均值） mae = mean_absolute_error(predicted_stock_price, real_stock_price) print('均方误差: %.6f' % mse) print('均方根误差: %.6f' % rmse) print('平均绝对误差: %.6f' % mae)

GRU

#在普通RNN代码基础上改动 1.引入模块加入GRU 2.seq模块GRU层替换RNN层

子主题

F.词嵌入

tf.keras.layers.Embedding(词汇表大小，编码维度) 编码维度就是用几个数字表示一个单词例： tf.keras.layers.Embedding(100,3) 对1-100进行编码，其中的数字4编码为[0.25 , 0.1 , 0.11,]

x_train格式要求 [ 送入样本数，循环核时间展开步数 ]

F.LSTM

开发背景

RNN可以用过记忆体实现短期极致进行连续数据的预测，但连续数据的序列变长时，会使展开时间步过长，在反向传播更新参数时，梯度要按照时间步连续相乘，会导致梯度消失

计算过程与解释

解析：如我现在在看第45页PPT 细胞态（长期记忆）：旧知识(过去的44页)*遗忘门 + 新知识(现在的第45页)*输入门记忆体（短期记忆）：在我复述给别人这些内容时，调用的就是ht ht = 输出门 * tanh(长期记忆里全部PPT内容) 候选态（归纳出的新知识）： tanh(Wc*[上一页PPT，当前页PPT] + bc)

F.LSTM

tf.keras.layer.LSTM(记忆体个数，return_sequences = 是否返回输出)

经验：中间层用True，最后一层用False return_sequences = True 各时间步输出ht return_sequences = False 仅最后时间步输出ht (默认)

例： model = tf.keras.Sequential([LSTM(80,return_sequences = True), Dropout(0.2), LSTM(100), Dropout(0.2), Dense(1)])

代码

LSTM

#在普通RNN代码基础上改动这两处 1.引入模块加入LSTM 2.seq模块LSTM层替换RNN层

实际代码

import numpy as np import tensorflow as tf from tensorflow.keras.layers import Dropout, Dense, LSTM import matplotlib.pyplot as plt import os import pandas as pd from sklearn.preprocessing import MinMaxScaler from sklearn.metrics import mean_squared_error, mean_absolute_error import math maotai = pd.read_csv('./SH600519.csv') # 读取股票文件 training_set = maotai.iloc[0:2426 - 300, 2:3].values # 前(2426-300=2126)天的开盘价作为训练集,表格从0开始计数，2:3 是提取[2:3)列，前闭后开,故提取出C列开盘价 test_set = maotai.iloc[2426 - 300:, 2:3].values # 后300天的开盘价作为测试集 # 归一化 sc = MinMaxScaler(feature_range=(0, 1)) # 定义归一化：归一化到(0，1)之间 training_set_scaled = sc.fit_transform(training_set) # 求得训练集的最大值，最小值这些训练集固有的属性，并在训练集上进行归一化 test_set = sc.transform(test_set) # 利用训练集的属性对测试集进行归一化 x_train = [] y_train = [] x_test = [] y_test = [] # 测试集：csv表格中前2426-300=2126天数据 # 利用for循环，遍历整个训练集，提取训练集中连续60天的开盘价作为输入特征x_train，第61天的数据作为标签，for循环共构建2426-300-60=2066组数据。 for i in range(60, len(training_set_scaled)): x_train.append(training_set_scaled[i - 60:i, 0]) y_train.append(training_set_scaled[i, 0]) # 对训练集进行打乱 np.random.seed(7) np.random.shuffle(x_train) np.random.seed(7) np.random.shuffle(y_train) tf.random.set_seed(7) # 将训练集由list格式变为array格式 x_train, y_train = np.array(x_train), np.array(y_train) # 使x_train符合RNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数]。 # 此处整个数据集送入，送入样本数为x_train.shape[0]即2066组数据；输入60个开盘价，预测出第61天的开盘价，循环核时间展开步数为60; 每个时间步送入的特征是某一天的开盘价，只有1个数据，故每个时间步输入特征个数为1 x_train = np.reshape(x_train, (x_train.shape[0], 60, 1)) # 测试集：csv表格中后300天数据 # 利用for循环，遍历整个测试集，提取测试集中连续60天的开盘价作为输入特征x_train，第61天的数据作为标签，for循环共构建300-60=240组数据。 for i in range(60, len(test_set)): x_test.append(test_set[i - 60:i, 0]) y_test.append(test_set[i, 0]) # 测试集变array并reshape为符合RNN输入要求：[送入样本数，循环核时间展开步数，每个时间步输入特征个数] x_test, y_test = np.array(x_test), np.array(y_test) x_test = np.reshape(x_test, (x_test.shape[0], 60, 1)) model = tf.keras.Sequential([ LSTM(80, return_sequences=True), Dropout(0.2), LSTM(100), Dropout(0.2), Dense(1) ]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='mean_squared_error') # 损失函数用均方误差 # 该应用只观测loss数值，不观测准确率，所以删去metrics选项，一会在每个epoch迭代显示时只显示loss值 checkpoint_save_path = "./checkpoint/LSTM_stock.ckpt" if os.path.exists(checkpoint_save_path + '.index'): print('-------------load the model-----------------') model.load_weights(checkpoint_save_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_save_path, save_weights_only=True, save_best_only=True, monitor='val_loss') history = model.fit(x_train, y_train, batch_size=64, epochs=50, validation_data=(x_test, y_test), validation_freq=1, callbacks=[cp_callback]) model.summary() file = open('./weights.txt', 'w') # 参数提取 for v in model.trainable_variables: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() loss = history.history['loss'] val_loss = history.history['val_loss'] plt.plot(loss, label='Training Loss') plt.plot(val_loss, label='Validation Loss') plt.title('Training and Validation Loss') plt.legend() plt.show() ################## predict ###################### # 测试集输入模型进行预测 predicted_stock_price = model.predict(x_test) # 对预测数据还原---从（0，1）反归一化到原始范围 predicted_stock_price = sc.inverse_transform(predicted_stock_price) # 对真实数据还原---从（0，1）反归一化到原始范围 real_stock_price = sc.inverse_transform(test_set[60:]) # 画出真实数据和预测数据的对比曲线 plt.plot(real_stock_price, color='red', label='MaoTai Stock Price') plt.plot(predicted_stock_price, color='blue', label='Predicted MaoTai Stock Price') plt.title('MaoTai Stock Price Prediction') plt.xlabel('Time') plt.ylabel('MaoTai Stock Price') plt.legend() plt.show() ##########evaluate############## # calculate MSE 均方误差 ---> E[(预测值-真实值)^2] (预测值减真实值求平方后求均值) mse = mean_squared_error(predicted_stock_price, real_stock_price) # calculate RMSE 均方根误差--->sqrt[MSE] (对均方误差开方) rmse = math.sqrt(mean_squared_error(predicted_stock_price, real_stock_price)) # calculate MAE 平均绝对误差----->E[|预测值-真实值|](预测值减真实值求绝对值后求均值） mae = mean_absolute_error(predicted_stock_price, real_stock_price) print('均方误差: %.6f' % mse) print('均方根误差: %.6f' % rmse) print('平均绝对误差: %.6f' % mae)

F.GRU

简介

介绍：简化后的LSTM 特点：使记忆体ht融合了长期记忆和短期记忆

计算过程

更新门：取值范围[0-1] 重置门：取值范围[0-1] 记忆体：ht = 多大程度不更新 * 上一页PPT + 多大程度更新 * 这一页PPT 候选隐藏层：新知识 = tanh(W * [ 重置度 * 上一页PPT，当前输入 ])

F.GRU

tf.keras.layers.GRU(记忆体个数 , return_sequences = 是否返回输出)

经验：一般中间层True 最后一层False return_sequences = True 各时间步输出ht return_sequences = False 仅最后时间步输出ht（默认）

例： model = tf.keras.Sequential([GRU(80,return_sequences=True), Dropout(0.2), GRU(100), Dropout(0.2), Dense(1) ])

代码

GRU

#在普通RNN代码基础上改动 1.引入模块加入GRU 2.seq模块GRU层替换RNN层

子主题

快速生成独热码代码

re正则库

函数

findall( )

search( )

match( )

>>> m =re.match(r"(\w+) (\w+)", "Isaac Newton, physicist") >>> m.group(0) # The entire match 'Isaac Newton' >>> m.group(1) # The first parenthesized subgroup. 'Isaac' >>> m.group(2) # The second parenthesized subgroup. 'Newton' >>> m.group(1, 2) # Multiple arguments give us a tuple. ('Isaac', 'Newton')

split( )

>>> re.split(r'\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split(r'(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split(r'\W+', 'Words, words, words.', 1) ['Words', 'words, words.'] >>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE) ['0', '3', '9']

>>> re.split(r'(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']

>>> re.split(r'\b', 'Words, words, words.') ['', 'Words', ', ', 'words', ', ', 'words', '.'] >>> re.split(r'\W*', '...words...') ['', '', 'w', 'o', 'r', 'd', 's', '', ''] >>> re.split(r'(\W*)', '...words...') ['', '...', '', '', 'w', '', 'o', '', 'r', '', 'd', '', 's', '...', '', '', '']

sub( )

subn( )

基础知识

元字符

\W 取反，匹配非单词字符

匹配中间的空格符

重复限定符

分组

字符功能 | 匹配左右任意一个表达式 (ab) 将括号中字符作为一个分组 \num 引用分组num匹配到的字符串 (?P<name>) 分组起别名 (?P=name) 引用别名为name分组匹配到的字符串

子主题

转义

条件或

^:匹配字符串开始（）：条件或 \d : 匹配数字 {8}：重复8次 $ ：匹配字符串结尾

可以匹配多个相同字符特征

区间

边界

字符功能 ^ 匹配字符串开头 $ 匹配字符串结尾 \b 匹配一个单词的边界 \B 匹配非单词边界

#定义规则匹配str="ho ve r" #1. 以字母开始 ^\w #2. 中间有空字符 \s #3. \b的两种解释是： #'\b', 如果前面不加r, 那么解释器认为是转义字符“退格键backspace”; #r'\b', 如果前面加r, 那么解释器不会进行转义，\b 解释为正则表达式模式中的字符串边界。 #4. ve两边分别限定匹配单词边界 >>> import re >>> str ="dasdho ve rgsdf" >>> pattern =r"^\w+\s\bve\b\sr" #加r表示边界，^\w+表示开头有1个或多个字母。\s空格 \b 边界以此类推 >>> result =re.match(pattern, str) >>> result.group() 'dasdho ve r'

方括号

#首先清楚手机号的规则 #1.都是数字 2.长度为11 3.第一位是1 4.第二位是35678中的一位 >>> import re >>> pattern ="1[35678]\d{9}" >>> phoneStr ="18230092223" >>> result =re.match(pattern,phoneStr) >>> result.group() '18230092223'

进阶知识

零宽断言

定义

断言：正则可以指明在指定的内容前面或后边会出现满足指定规则的内容零宽：没有宽度，在正则中，断言只匹配位置，不占字符，也就是说，匹配结果里是不会返回断言本身

正向先行断言（正前瞻）

语法：（？ = pattern）作用：匹配pattern 表达式的前面内容，不返回本身

例：匹配文章阅读数假设我们要用爬虫抓取csdn里的文章阅读量。通过查看源代码可以看到文章阅读量这个内容是这样的结构

表示我知道在这个字符前是多个数字，你给我找找

正向后行断言（正后顾）

语法：（？<=pattern）作用：匹配pattern表达式的后边的内容，不返回本身

（）=pattern 是参照字符表示在阅读数：后边有几个数字你都给我找来

负向先行断言（负前瞻）

语法：（？！pattern）作用：匹配非pattern表达式的前边内容，不返回本身

例

#(?<=abc)def ，并不是从 a 开始搜索，而是从 d 往回看的。你可能更加愿意使用 search() 函数，而不是 match() 函数： >>> import re >>> m =re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def' #搜索一个跟随在连字符后的单词 >>> m =re.search(r'(?<=-)\w+', 'spam-egg') >>> m.group(0) 'egg'

捕获和非捕获

数字编号捕获组

命名编号捕获组

>>> m =re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds") >>> m.group('first_name') 'Malcolm' >>> m.group('last_name') 'Reynolds' #命名组合同样可以通过索引值引用 >>> m.group(1) 'Malcolm' >>> m.group(2) 'Reynolds'

非捕获组

反向引用

子主题

贪婪

定义

例

在第一串数字中，只需要返回617就可以了，但是它贪婪的匹配到了最大能匹配的字符，即617628

一个量词如此贪婪，多个量词凑一起，如何支配自己的匹配权？答：如果字符串能满足它们最大程度的匹配，就互不干扰如果不能满足，根据深度优先原则，也就是从左到右的每一个贪婪量词，优先最大数量的满足，剩余再分配下一个量词匹配

优先满足前边的

与懒惰对比

从字母i开始到o结束找最大长度的字符下图为贪婪

懒惰会少个o

懒惰

语法

前边能少匹配就少匹配，后边能多匹配就多匹配

反义

就是不想匹配某些字符

非数字的匹配

非数字，字母，下划线，汉字

非空字符

不是l的字符

例

单个字符匹配

1.写出字符本身

需求：匹配l 解决：写l

2.通配符

. 代表任意字符故能匹配到所有字符

3.方括号匹配

[ ]里边是“或”的关系即有里边任意字符都会被匹配

反方括号匹配就不匹配方括号里的 [^d] 可以看到只有d没有匹配到

匹配所有大小写字符

[a-z]

[A-Z]

匹配所有数字

[0-9]

综合使用

[a-zA-Z0-9] #除了空格都被匹配到了

高效工具

\w 匹配所有单词字符

\d 匹配所有数字

条件匹配

#匹配出0-100之间的数字 #首先:正则是从左往又开始匹配 #经过分析: 可以将0-100分为三部分 #1. 0 "0$" #2. 100 "100$" #3. 1-99 "[1-9]\d{0,1}$" #所以整合如下 >>> import re >>> pattern =r"0$|100$|[1-9]\d{0,1}$" >>> result = re.match(pattern,"27") >>> result.group() '27' >>> result =re.match(pattern,"212") >>> result.group() Traceback (most recent call last): File "<stdin>", line 1, in<module> AttributeError: 'NoneType'object has no attribute 'group' #将0考虑到1-99上,上述pattern还可以简写为:pattern=r"100$|[1-9]?\d{0,1}$"

工具网站

正则表达式教程大纲：https://gist.github.com/JavaCS3/e36e494e78a02049950bfa7c7ebeb929 工具：https://regex101.com

自动生成的代码

文章

https://blog.csdn.net/yunweimao/article/details/106688046?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163585413416780271535208%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163585413416780271535208&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-106688046.pc_search_mgc_flag&utm_term=re%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F&spm=1018.2226.3001.4187

string库

函数

头文件：#include<string.h>

找特定字符

函数：char * strstr()

倒腾文件

shutil

原文链接：https://blog.csdn.net/weixin_41261833/article/details/108050152

Pyuserinput

安装

pip install pymouse

鼠标命令

鼠标控制click 左右键参数叫button

键盘命令

import pykeyboard --引用 k = pykeyboard.PyKeyboard( ) --实例化 k.type_string('abcdefg') --输入内容 k.press_key('a') --按a键 k.release_key('a') --松开a键 k.tap_key('a') --点击a键 k.tap_key('a', n=2, interval=5) --点击a键2次，每次间隔5秒 k.tap_key(k.function_keys[5]) --功能键F5 k.press_keys([k.alt_key, 'a']) --组合按键，试验不成功

OS

创建目录

创建多层目录

os.makedirs(name,mode=0o777,exist_ok=False)

什么叫多层

sklearn

文档地址：https://scikit-learn.org/

准确率metrics

sklearn.metrics.accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None)[source]

normalize=False时返回预测正确个数

注意

不支持一个batch的iter进去如Y_hat是[bs128,seq_len150] Y_true也是[bs128,seq_len150] 但可以分批计算，但分批不如最后一行省事