Tensorflow2.0学习笔记（一）北大曹健老师教学视频1-4讲
返回目录
这个笔记现在是主要根据北京大学曹健老师的视频写的，这个视频超级棒，非常推荐。
第一讲 常用函数的使用（包含了很多琐碎的函数，还有第二讲的部分）
这里把视频中的给的常用的函数都罗列出来了，我也刚学，以后就没事看这个复习熟悉吧
import tensorflow as tf
import numpy as np
from sklearn.datasets import load_iris
#####################################################################
import osdd
# 1.3张量生成
'''
Tensor：多维数组 阶：张量的维数
数字左边的[ 有几个就是几阶
0-D 0阶 标量 s=1 2 3
1-D 1阶 向量 v=[1,2,3]
2-D 2阶 矩阵 m = [[1,2,3],[4,5,6],[7,8,9]]
数据类型
tf.int 32,tf.float 32,tf.float 64
tf.bool
tf.constan([True,False])
tf.string
'''
a = tf.constant([1,5],dtype=tf.int64) # 张量内容，dtype=数据类型
# numpy的数据类型转换为Tensor数据类型
a = np.arange(0,5)
b = tf.convert_to_tensor(a,dtype=tf.int64) #数据名，dtype=
# 特殊创建方法
dim = 5 # dim为维度
c = tf.zeros(dim) # 创建全为0
d = tf.ones(dim) # 创建维度为dim的全为1的张量
e = tf.fill(dim,4) # 创建维度为dim的全为指定数目（这里为4）的张量
f = tf.random.normal(dim,mean=2,stddev=1) # 生成dim维，均值为2，标准差为1的整天分布随机数
g = tf.random.truncated_normal(dim,mean=2,stddev=1) # 生成截断式正态分布随机数，该函数保证生成数据在（±均值-2*标准差之外）就重新生成，保证生成值在均值附近
h = tf.random.uniform(dim,minval=0,maxval=1) # 生成均匀分布的随机数
#####################################################################
# 1.4常用函数
a = tf.constant([1.,2.,3.],dtype=tf.float64)
print(a)
a1 = tf.cast(a,tf.int32) # 强制tensor转换为该数据类型
print(a1)
a2 = tf.reduce_max(a1) # 计算张量维度上元素的最大值
a3 = tf.reduce_min(a1) # 计算张量维度上元素的最小值
# 取平均值
# axis ,在二维张量或数组中，axis=0表示跨行，axis=1表示跨列
a4 = tf.reduce_mean(a1,axis=0)
a5 = tf.reduce_mean(a1)
a6 = tf.reduce_sum(a1,axis=0)
a7 = tf.reduce_sum(a1)
# 把内部初始化变量标记为可训练，被标记的变量会再反向传播中记录梯度信息，神经网络训练中，
# 常用该函数标记待训练参数
w = tf.Variable(a1)
######################################################
#TensorFlow中的数学运算
'''
tf.add tf.subtract tf.multiply tf.divide 为对应元素的四则运算
tf.square tf.pow tf.sqrt 为平方 次方 开发操作
矩阵乘 tf.matmul
要保证俩个操作的维度相同
'''
a = tf.ones([1,3])
b = tf.fill([1,3],3.)
print(a)
print(b)
print(tf.add(a,b))
print(tf.subtract(a,b))
print(tf.multiply(a,b))
print(tf.divide(b,a))
print(tf.fill([1,2],3.))
print(tf.pow(a,3))
print(tf.square(a))
print(tf.sqrt(a))
a = tf.ones([3,2])
b = tf.fill([2,3],3.)
print(tf.matmul(a,b))
#########################################
# 吧标签和特征配对的函数
train_data = tf.constant([12,23,10,17])
train_label = tf.constant([0,1,1,0])
# 下面的函数就是把元组形式输入的特征，标签配对，对numpy或tensor格式都适用
data = tf.data.Dataset.from_tensor_slices((train_data,train_label))
########################################################
# 1.5 常用函数
'''
这个函数来记录计算过程
with tf.GradientTape() as tape:
若干个计算过程
grad = tape.gradient(函数，对谁求导)
'''
with tf.GradientTape() as tape:
w = tf.Variable(tf.constant(3.0))
loss = tf.pow(w,2)
grad = tape.gradient(loss,w)
print(grad)
# python内建函数enumerate 可以遍历每个元素，组合为 索引 元素
seq = ['one','two','three']
for i,element in enumerate(seq):
print(i,element)
# 独热编码 常用这个做标签 1表是，0表非，
classes = 3 # 结果为3类
labels = tf.constant([1,0,2]) # 输入的元素最小0，最大为2
output = tf.one_hot(labels,depth=classes)
print(output)
# tf.nn.softmax函数，如命，就是吧n分类的n个输出通过softmax符合概率分布
y = tf.constant([1.01,2.01,-0.66])
y_pro = tf.nn.softmax(y)
print("After softmax,y_pro is ",y_pro)
# assign_sub 赋值操作，更新参数的值并返回；更新前先定义变量为可训练
w = tf.Variable(4)
w.assign_sub(1) # 相当于w = w-1
print(w)
# tf.armax 返回张量沿指定维度最大值的索引
test = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(test)
# 分别返回每列、行最大值的索引 若不指定就返回全部的最大值的索引
print(tf.argmax(test,axis=0))
print(tf.argmax(test,axis=1))
#########################################################
# 2.1 预备知识
# tf.where(条件语句，真返回A，假返回B）
a = tf.constant([1,2,3,1,1])
b = tf.constant([0,1,3,4,5])
c = tf.where(tf.greater(a,b),a,b) # 若a>b 返回a对应位置的元素，不然返回b对应位置 元素
print("c:",c)
# np.random.RandomState.rand() 返回一个[0,1)之间的随机数
rdm = np.random.RandomState(seed=1) # seed=常数每次生成随机数相同
a = ram.rand() # 返回一个随机标量
b = rdm.rand(2,3) # 返回维度为2行3列随机数矩阵
print("a:",a)
print("b:",b)
# np.vstack() 将俩个数组按垂直方向叠加
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.vstack((a,b))
print("c:\n",c)
'''
np.mgrid[] .ravel() .c_[] 总在一起使用，去生成网格
# np.mgrid[起始值：结束值：步长，起始值：结束值：步长，。。。]
x.ravel() 吧x变为一维数组，把。前变量拉直
np.c_[]使返回的间隔数值点配对
np.c_[数组1，数组2....]
'''
x,y = np.mgrid[1:3:1,2:4:0.5]
grid = np.c_[x.ravel(),y.ravel()]
print("x:",x)
print("y:",y)
print('grid:\n',grid)
1.7 鸢尾花分类（老师说要会背）
# -*- coding: UTF-8 -*-
# 利用鸢尾花数据集，实现前向传播、反向传播，可视化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()
第二讲
2.2神经网络复杂度
**空间复杂度：**层数=隐藏层数+输出层数
总参数： w+b
指数衰减学习率： 可以先用较大的学习率，快速得到较优解，然后逐步减小学习率，使模型在训练后期稳定。
指数衰减学习率=初始学习率*学习率衰减率^(当前轮数/多少轮衰减一次)
时间复杂度：乘加运算次数
2.3激活函数建议
首选relu激活函数;
学习率设置较小值;
输入特征标准化，即让输入特征满足以0为均值，1为标准差的正态分布;
初始参数中心化，即让随机生成的参数满足以0为均值，sqrt(2/当前层输入特征的个数）为标准差的正态分布。
#2.3 激活函数
tf.nn.softmax() # Sigmoid函数
tf.nn.relu() # Relu 函数
tf.math.tanh() # Tanh 函数
tf.nn.leaky_relu() # Leak RRelu函数 改进了 relu
2.4损失函数
# 2.4损失函数
#MSE均方误差
loss_mse = tf.reduce_mean(tf.square(y_-y))
#自定义损失函数
#这里只是演示一下稍微，不能直接运行
loss_zdy = tf.reduce_sum(tf.where(tf.greater(y,y_),COST * (y-y_),PROFIT * (y_-y)))
#CE交叉熵损失函数CE，表征俩个概率分布之间的距离
tf.losses.categorical_crossentropy(y_,y)
2.5缓解过拟合
| 欠拟合的解决方法 | 过拟合的解决方法 |
|---|---|
| 增加输入特征项 | 数据清洗 |
| 减少正则化参数 | 增大训练集 |
| 增加网络参数 | 采用正则化 |
| 增大正则化参数 |
L2正则化代码
# 添加l2正则化
loss_regularization = []
# tf.nn.l2_loss(w)=sum(w ** 2) / 2
loss_regularization.append(tf.nn.l2_loss(w1))
loss_regularization.append(tf.nn.l2_loss(w2))
# 求和
# 例：x=tf.constant(([1,1,1],[1,1,1]))
# tf.reduce_sum(x)
# >>>6
# loss_regularization = tf.reduce_sum(tf.stack(loss_regularization))
loss_regularization = tf.reduce_sum(loss_regularization)
loss = loss_mse + 0.03 * loss_regularization #REGULARIZER = 0.03
2.6优化器
# 2.6优化器
#SGD
#对于单层网络
# 实现梯度更新 w1 = w1 - lr * w1_grad b = b - lr * b_grad
w1.assign_sub(lr * grads[0]) # 参数w1自更新
b1.assign_sub(lr * grads[1]) # 参数b自更新
#SGDM 就是指数平滑法
# sgd-momentun
m_w, m_b = 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
v_w, v_b = 0, 0
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))
#rmsprop
v_w, v_b = 0, 0
beta = 0.9
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
m_w, m_b = 0, 0
v_w, v_b = 0, 0
beta1, beta2 = 0.9, 0.999
delta_w, delta_b = 0, 0
global_step = 0
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))
第三讲
想讲八股
3.1搭建网络八股sequential
sequential可搭建出上层输出就是下层输入的顺序结构而不能搭建非顺序结构
#3.1搭建网络八股
model = tf.keras.models.Sequential([net struct]) # 描述各层网络
#网络结构举例
'''
拉直层：tf.keras.layers.Flatten() # 这一层只是形状变换，无计算，把输入特征拉直成一维数组
全连接层:tf.keras.layers.Dense(神经元个数，activation="激活函数",kernel_regularizer=哪种正则化) # 这一层告知了神经元个数、激活函数、正则化方式等
activation（字符串给出):relu、softmax、sigmoid、tanh
kernel_regularizer:tf.keras.regularizers.l1()、tf.keras.regularizers.l2()
卷积层
'''
model.compile()
#配置方法
'''
建议入门时先使用左边的字符串形式来用，然后用熟了之后再在官网查询函数怎么用，参数什么的用第二种形式
model.compile(optimizer = 优化器,loss = 损失函数, metrics=["准确率"])
优化器可选：
'sgd' or tf.keras.optimizers.SGD(lr=学习率,momentum=动量参数)
'adagrad' or tf.keras.optimizers.Adagrad(lr=学习率)
'adadelta' or tf.keras.optimizers.Adadelta(lr=学习率)
'adam' or tf.keras.optimizers.Adam(lr=学习率，beta_1=0.9,beta_2=0.999）
损失函数可选：
‘mse' or tf.keras.losses.MeanSquaredError()
'sparse_categorical_crossentropy' or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False) #如果输出前经过概率分布这里填False，注意这个参数，因为可能会因为这个参数出现错误
评测指标可选：
'accuracy':y_和y都是数值，如y_=[1],y=[1]
'categorical_accuracy':y_和y都是独热码（概率分布），如y_=[0,1,0],y=[0.256,0.695,0.048]
'sparse_categorical_accuracy':y_是数值，y是独热码（概率分布），如y_=[1],y=[0.256,0.695,0.048]
'''
model.fit()
'''
validation_data与validation_split这俩参数选一个
model.fit(训练集的输入特征、训练集的标签、batch_size= 每次输入神经网络的样本数,epochs = 迭代次数,
validation_data = (测试集的输入特征，测试集的标签），
validation_split=从训练集划分多少比例给测试集，
validation_freq = 多少次迭代后在测试集测试一次正确率
'''
model.summary() #打印网络的结构与参数统计
3.2搭建网络八股class
用自己写的类的方法，就可以避免3.1的缺点了。
# 3.2 搭建网络八股class
class MyModel(Model): # 这里的Model表示继承了tf的Model类
def __init__(self):
super(MyModel,self).__init__()
#定义网络结构块
def call(self,x):
#调用网络结构块,实现前向传播
return y
model = MyModel()
#例如鸢尾花的Model
class IrisModel(Model):
def __init__(self):
super(IrisModel, self).__init__()
self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
def call(self, x):
y = self.d1(x)
return y
model = IrisModel()
3.3MNIST数据集
这个完整代码自己下载吧，就给出一些图片可视化的方法的笔记
#3.3MNIST数据集 手写的那个，7万一共，其中6万训练，1万测试
# 导入数据集
mnist = tf.keras.datasets.mnist
(x_train,y_train),(x_test,y_test) = mnist.load_data()
# 作为输入特征输入神经网络时要将数据拉伸为1维数组
tf.keras.layers.Flatten()
#把训练集第一个样本可视化
plt.imshow(x_train[0],cmap='gray') # 绘制灰度图
plt.show()
print("x_train[0]:\n",x_train[0]) # 打印第一个数组
print("x_test.shpe:",x_test.shape) # 打印出形状
第四讲
4.2自制数据集的处理
在一个文档中存放要使用的训练集和测试集图片，就去保证他们都是灰度图，同时格式相同，大小相同，然后有俩个txt文件去存放标签图片信息：
0_5.jpg 5
1_0.jpg 0
2_4.jpg 4
3_1.jpg 1
4_9.jpg 9
如上面，先写图片名，再写图片内的数字，（这里是以手写识别图字为例，别的就写别的特征），可以这么自己写个函数去替换load.data
#4.2自制数据集
def generateds(path,txt):
f = open(txt,'r')
contents = f.readlines()
f.close()
x,y_ = [],[]
for content in contents:
value = content.split()
img_path = path + value[0]
img = Image.open(img_path)
img = np.array(img.convert('L')) # 为灰度图像，每个像素用8个bit表示,然后再转换为array形势
img = img / 255.
x.append(img)
y_.append(value[1])
print('loading : ' + content)
x = np.array(x)
y_ = np.array(y_)
y_ = y_.astype(np.int64)
return x,y_
#在主程序中加载数据的写法：
'''
if 判断是否存在相关的训练测试文件：
# 如果存在
读取数据操作
else:
# 不存在
创造数据集操作，调用上面的generateds()函数
然后载入数据
'''
4.3数据增强
# 4.3数据增强
x_train = x_train.reshape(x_train[0],28,28,1) # 这是是把图片变为4维，最后一个1为RGB通道表示灰色图像。
image_gen_train = tf.keras.preprocessing.image.ImageDataGenerator()
'''
其包含参数：
rescale = 所有数据将乘以该数值
rotation_range = 随机旋转角度数范围
width_shift_range = 随机宽度偏移量
height_shift_range = 随机高度偏移量
水平翻转： horizontal_flip = 是否随机水平翻转
随即缩放: zoom_range = 随机缩放的范围[1-n,1+n]
'''
model.fit(image_gen_train.flow(x_train,y_train,batch_size=32))
4.4 断点续训
在进行神经网络训练过程中，由于一些因素道之训练无法进行，需要保存当前的训练结果下次解者训练
# 4.4 断点续训
# 读取模型：
load_weights(路径文件名)
# -----------------------老师习惯的操作：------------------------------------
checkpoint_save_path = "./checkpoint/mnist.ckpt"
if os.path.exists(checkpoint_save_path + '.index'):
print('-------------------load the model------------------------------')
model.load_weights(checkpoint_save_path)
# 保存模型
tf.keras.callbacks.ModelCheckpoint(
filepath=路径文件名,
save_weights_only=True/False, # 是否只保留模型参数
save_best_only=True/False # 是否只保留最优模型
)
history = model，fit(callbacks = [cp_callback]) # 这个是加入了回调选项
# -----------------------老师习惯的操作：------------------------------------
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])
4.5参数提取
# 4.5 参数提取
model.trainable_variables # 返回模型中可训练的参数
# 设置print的输出格式，如果不设置直接打印的化，就会导致省略很多显示
np.set_printoptions(threshold=np.inf) # 无限大，表示不省略
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() # 到这里，把参数全都保存了下来
4.6acc/loss可视化
可视化步骤：
这个是提取数字的步骤，想要画图，还要写画图的程序。
# 4.6 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])
# 在执行上面的函数时，同步记录了训练集loss，测试集loss，训练集，测试集准确率，可用history.history提取出来
acc = history.history['sparse_categorical_accuracy']
val_acc = history.history['val_sparse_categorical_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
下面这个代码也要会背，会背就会写出来自己的神经网络了：
这个代码是识别手写数字的完整代码。
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()
4.7 给图识物
这里给的代码只是去了解步骤，学习“八股”，不能直接使用。
#4.7 给图识物
# 第一步，浮现模型
model = tf.keras.model.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128,activation='relujjo'),
tf.keras.layers.Dense(10,activation='softmax')
])
# 第二步，加载参数
model.load_weights(model_save_path)
# 中间操作：读入要预测的图片，这时要预处理成网络的标准形式，还有图像转化为灰度图
'''
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] < 200:
img_arr[i][j] = 255
else:
img_arr[i][j] = 0
'''
img_arr = img_arr / 255.0 # 归一化
x_predict = img_arr[tf.newaxis, ...] # 处理为[batch_size,height,weight]的模式，因为网络是按照batch_size的方式输入的
# 第三步，预测结果
result = model.predict(x_predict)
pred = tf.argmax(result, axis=1)
完
2020年7月7日上午
返回目录
452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
