人工智能实践：Tensorflow笔记——使用八股搭建神经网络

发布于 | 更新于 | 分类于 人工智能| 0
本文已收录于 人工智能实践：Tensorflow笔记 系列，共计 7 篇，本篇是第 3 篇

本文已收录到：人工智能实践：Tensorflow笔记 专题
文章目录 隐藏
1 搭建网络sequenial
1.1 Sequential()容器
1.2 compile配置神经网络的训练方法
1.3 fit()执行训练过程
1.4 model.summary()打印和统计
1.5 鸢尾花示例
2 搭建网络class
3 MNIST数据集
3.1 Sequential实现手写数字识别训练
3.2 calss实现手写数字识别训练

为了验证是否掌握了八股搭建神经网络，特提供了Fashion数据集供测试。

搭建网络sequenial

用 Tensorflow 的API tf. keras 快速搭建神经网络。

使用六步法搭建神经网络：

  • 第一步：import相关模块，如import tensorflow as tf。
  • 第二步：指定输入网络的训练集和测试集，如指定训练集的输入 x_train 和标签 y_train，测试集的输入 x_test 和标签 y_test 。
  • 第三步：在 Sequential 中逐层搭建网络结构，model = tf.keras.models.Sequential()，相当于走了一遍前向传播。
  • 第四步：在 model.compile() 中配置训练方法，选择训练时使用的优化器、损失函数和最终评价指标。
  • 第五步：在 model.fit() 中执行训练过程，告知训练集和测试集的输入值和标签、每个 batch 的大小（batchsize）和数据集的迭代次数（epoch）。
  • 第六步：使用 model.summary() 打印网络结构，统计参数数目。

Sequential()容器

Sequential() 是个容器，这个容器里封装了一个神经网络结构。

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

在Sequential()中，要描述从输入层到输出层每一层的网络结构。每一层的网络结构可以是：

  • 拉直层：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.12()
  • 卷积层：tf.keras.layers.Conv2D(filters =卷积核个数，kernel size=卷积核尺寸，strides=卷积步长，padding = "valid" or "same")
  • LSTM层；tf.keras.layers.LSTM()

compile配置神经网络的训练方法

告知训练时选择的优化器、损失函数和评测指标

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

优化器可以是以字符串形式给出的优化器名字

Optimizer（优化器）可选:

  • '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)

loss（损失函数）可选:

  • 'mse' or tf.keras losses MeanSquaredError()
  • 'sparse_ categorical_crossentropy or tf.keras.losses.SparseCategoricalCrossentropy(from_logits =False)
    • from_logits参数：有些神经网络的输出是经过了softmax等函数的概率分布，有些则不经概率分布直接输出，from_logits参数是在询问是否是原始输出，即没有经概率分布的输出。
    • 如果神经网络预测结果输出前经过了概率分布，这里是False。
    • 如果神经网络预测结果输出前没有经过了概率分布，直接输出，这里是True。

Metrics（评测指标）可选:

'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]

Ps：我们后续的例子都是以数值形式给出标签，以概率分布形式输出。所以应该选择'sparse_ categorical_accuracy'作为评价指标。

fit()执行训练过程

  1. model.fit (训练集的输入特征，训练集的标签，
  2. batch_size= ，epochs=,
  3. validation_data=(测试集的输入特征，测试集的标签),
  4. validation_split=从训练集划分多少比例给测试集，
  5. validation_freq =多少次epoch测试一次)
model.fit (训练集的输入特征，训练集的标签，
           batch_size= ，epochs=,
           validation_data=(测试集的输入特征，测试集的标签),
           validation_split=从训练集划分多少比例给测试集，
           validation_freq =多少次epoch测试一次)
  • batch_ size：每次喂入神经网络的样本数，推荐个数为：2^n
  • epochs：要迭代多少次数据集
  • validation_data和validation_split二选一
  • validation_freq：每多少次epoch迭代使用测试集验证一次结果

model.summary()打印和统计

summary()可以打印出网络的结构和参数统计。

鸢尾花示例

  1. """
  2. import
  3. """
  4. import tensorflow as tf
  5. from sklearn import datasets
  6. import numpy as np
  8. """
  9. train test
  10. """
  11. x_train = datasets.load_iris().data
  12. y_train = datasets.load_iris().target
  14. # 数据集乱序
  15. np.random.seed(116)
  16. np.random.shuffle(x_train)
  17. np.random.seed(116)
  18. np.random.shuffle(y_train)
  19. tf.random.set_seed(116)
  21. """
  22. models.Sequential
  23. """
  24. model = tf.keras.models.Sequential([
  25. tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
  26. ])
  28. """
  29. model.compile
  30. """
  31. model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
  32. loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
  33. metrics=['sparse_categorical_accuracy'])
  35. """
  36. model.fitcompile
  37. """
  38. model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
  40. """
  41. model.summary
  42. """
  43. model.summary()
"""
import
"""
import tensorflow as tf
from sklearn import datasets
import numpy as np

"""
train test
"""
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)

"""
models.Sequential
"""
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

"""
model.compile
"""
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

"""
model.fitcompile
"""
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

"""
model.summary
"""
model.summary()

运行结果





搭建网络class


用 Sequential 可以搭建出上层输出就是下层输入的顺序网络结构，但是无法写出一些带有跳连的非顺序网络结构。这个时候我们可以选择用类 class 搭建神经网络结构。


六步法搭建神经网络










代码示例






  1. import tensorflow as tf
  2. from tensorflow.keras.layers import Dense
  3. from tensorflow.keras import Model
  4. from sklearn import datasets
  5. import numpy as np
  7. x_train = datasets.load_iris().data
  8. y_train = datasets.load_iris().target
  10. np.random.seed(116)
  11. np.random.shuffle(x_train)
  12. np.random.seed(116)
  13. np.random.shuffle(y_train)
  14. tf.random.set_seed(116)
  16. class IrisModel(Model):     # 这里的Model表示继承了TensorFlow的Model类
  18.     def __init__(self):
  19.         super(IrisModel, self).__init__()
  20.         # 定义网络结构块
  21.         self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
  23.     def call(self, x):
  24.         # 调用网络结构块，实现前向传播
  25.         y = self.d1(x)
  26.         return y
  28. model = IrisModel()
  30. model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
  31.               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
  32.               metrics=['sparse_categorical_accuracy'])
  34. model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
  35. model.summary()
import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
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)

class IrisModel(Model):     # 这里的Model表示继承了TensorFlow的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()

model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
model.summary()




运行结果








MNIST数据集


提供6万张28*28像素点的手写数字图片和标签，用于测试。


代码示例：




  1. import tensorflow as tf
  2. from matplotlib import pyplot as plt
  4. mnist = tf.keras.datasets.mnist
  5. (x_train, y_train), (x_test, y_test) = mnist.load_data()
  7. # 可视化训练集输入特征的第一个元素
  8. plt.imshow(x_train[0], cmap='gray')  # 绘制灰度图
  9. plt.show()
  11. # 打印出训练集输入特征的第一个元素
  12. print("x_train[0]:\n", x_train[0])
  13. # 打印出训练集标签的第一个元素
  14. print("y_train[0]:\n", y_train[0])
  16. # 打印出整个训练集输入特征形状
  17. print("x_train.shape:\n", x_train.shape)
  18. # 打印出整个训练集标签的形状
  19. print("y_train.shape:\n", y_train.shape)
  20. # 打印出整个测试集输入特征的形状
  21. print("x_test.shape:\n", x_test.shape)
  22. # 打印出整个测试集标签的形状
  23. print("y_test.shape:\n", y_test.shape)
import tensorflow as tf
from matplotlib import pyplot as plt

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 可视化训练集输入特征的第一个元素
plt.imshow(x_train[0], cmap='gray')  # 绘制灰度图
plt.show()

# 打印出训练集输入特征的第一个元素
print("x_train[0]:\n", x_train[0])
# 打印出训练集标签的第一个元素
print("y_train[0]:\n", y_train[0])

# 打印出整个训练集输入特征形状
print("x_train.shape:\n", x_train.shape)
# 打印出整个训练集标签的形状
print("y_train.shape:\n", y_train.shape)
# 打印出整个测试集输入特征的形状
print("x_test.shape:\n", x_test.shape)
# 打印出整个测试集标签的形状
print("y_test.shape:\n", y_test.shape)




运行结果








 




Sequential实现手写数字识别训练




  1. import tensorflow as tf
  3. mnist = tf.keras.datasets.mnist
  4. (x_train, y_train), (x_test, y_test) = mnist.load_data()
  5. # 对输入网络的输入特征进行归一化
  6. # 使原本0到255之间的灰度值，变为0到1之间的数值
  7. # 把输入特征的数值变小更适合神经网络吸收
  8. x_train, x_test = x_train / 255.0, x_test / 255.0
  10. model = tf.keras.models.Sequential([
  11.     tf.keras.layers.Flatten(),
  12.     tf.keras.layers.Dense(128, activation='relu'),
  13.     tf.keras.layers.Dense(10, activation='softmax')
  14. ])
  16. model.compile(optimizer='adam',
  17.               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
  18.               metrics=['sparse_categorical_accuracy'])
  20. model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
  21. model.summary()
import tensorflow as tf

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 对输入网络的输入特征进行归一化
# 使原本0到255之间的灰度值，变为0到1之间的数值
# 把输入特征的数值变小更适合神经网络吸收
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'])

model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
model.summary()




运行结果








对于结果，后半部部分才是测试集中运行结果。


3s 58us/sample – loss: 0.0464 – sparse_categorical_accuracy: 0.9856 – val_loss: 0.0918 – val_sparse_categorical_accuracy: 0.9723

Model: “sequential”


calss实现手写数字识别训练






  1. import tensorflow as tf
  2. from tensorflow.keras.layers import Dense, Flatten
  3. from tensorflow.keras import Model
  5. mnist = tf.keras.datasets.mnist
  6. (x_train, y_train), (x_test, y_test) = mnist.load_data()
  7. x_train, x_test = x_train / 255.0, x_test / 255.0
  10. class MnistModel(Model):
  11.     def __init__(self):
  12.         super(MnistModel, self).__init__()
  13.         self.flatten = Flatten()
  14.         self.d1 = Dense(128, activation='relu')
  15.         self.d2 = Dense(10, activation='softmax')
  17.     def call(self, x):
  18.         x = self.flatten(x)
  19.         x = self.d1(x)
  20.         y = self.d2(x)
  21.         return y
  24. model = MnistModel()
  26. model.compile(optimizer='adam',
  27.               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
  28.               metrics=['sparse_categorical_accuracy'])
  30. model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
  31. model.summary()
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model

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


class MnistModel(Model):
    def __init__(self):
        super(MnistModel, self).__init__()
        self.flatten = Flatten()
        self.d1 = Dense(128, activation='relu')
        self.d2 = Dense(10, activation='softmax')

    def call(self, x):
        x = self.flatten(x)
        x = self.d1(x)
        y = self.d2(x)
        return y


model = MnistModel()

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()




运行结果










	

			


	

		
作者： 高志远


		

			高志远，24岁，男生			
		

	



            

                        
        


        

                            

                    

    






	
	
		

		
发表评论 
			

				
邮箱地址不会被公开。