【深度学习笔记】task3 神经网络八股

依依旧是跟着曹健老师的课程学习，终于来到精华部分了，之前又臭又长的代码们get out
https://www.bilibili.com/video/BV1B7411L7Qt?p=1
原码见 https://github.com/jlff/tf2_notes
目录

3.1搭建神经网络八股sequential

六步法

1. import相关模块，import
2. 指定训练集测试集的输入和其对应特征，train,test
3. 在Sequential()中搭建神经网络，逐层描述每层网络，相当于走一遍前向传播model=tf.keras.models.Sequential
4. 在compile中配置训练方法，告知训练时使用哪种优化器，那个损失函数，选择哪种评价指标，model.compile
5. 在fit中执行训练过程，告知训练集和测试集的输入标签和特征，告知每个batch是多少，告知要迭代多少此数据集，model.fit
6. 用summary打印出网络结构和参数统计，model.summary
   下面学习上述各种函数用法

3.1.1 Sequential

在Sequential中要描述从输入层到输出层每一层的网络结构，其语法格式为

model=tf.kears.models.Sequentiak([网络结构]) #描述各层网络

每一层的网络结构可以是

• 拉直层Flatten()：tf.keras.layers.Flatten()，这一层中不含计算，只是形状转换，把输入特征拉直变为一维数组
• 全连接层Dense():tf.kears.layers.Dense(神经元个数,activation='激活函数',kernel_regularizer=哪种正则化)
  其中激活函数activation可以选择relu、softmax、sigmoid、ranh，正则化kernel_regularizer可选tf.keras.regularizer.l1()、tf.keras.regularizer.l2()
• 卷积层：tf.keras.layers.Conv2D(filers=卷积核个数,kernel_size=卷积核尺寸,strides=卷积步长,padding='valid'or 'same'
• LSTM循环神经网络层tf.kears.layers.LSTM()

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

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

建议入门时候先试用最左边优化器的名字

• Optimizer优化器可选
  • ‘sgd’ or tf.keras.optimizers.SGD(lr=学习率,momentum=动量参数)
  • ‘adagrad’ or f.keras.optimizers.Adagrad (lr=学习率)
  • ‘adadelta’ or tf.keras.optimizers.Adadelta (Ir=学习率)
  • 'adam’or tf.keras.optimizers.Adam (Ir=学习率, 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)
• Metrics可选（注意使用情况,y_为真实标签，y为输出结果）：
  ‘accuracy’：y_和y都是数值，与y_=[1],y=[1]
  ‘categorical_accuracy’:y_和y都是独热码（概率分布），如y_=[0,1,0] y=[0.256,-.695,0.048]
  ‘sparse_categorical_accuracy’:y_是数值,y是独热码(概率分布)，如y_[1] y=[0.256,-.695,0.048]

3.1.3 fit函数

fit函数用来执行训练过程
batch_size每次喂入神经网络的大小，epochs每次要迭代多少次数据集，validation_data和validation_split两者选其一即可

model.fit(训练集的输入特征，训练集的标签,batch_size=, epochs= ,validation_data=(测试集的输入特征,测试集的标签),validation_split=从训练集划分多少比例给测试集,validation_freq=多少次epoch测试一次)

3.1.4 summary

用于打印结果和参数统计

3.1.5 使用六步法复现鸢尾花数据集的训练过程

##1.import相关模块
import tensorflow as tf 
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model 
from sklearn import datasets
import numpy as np 
import warnings
warnings.filterwarnings('ignore')

##2.指定训练集和测试集的输入极其对应标签
#对于本例从后面训练集中划分，所以这里没有再定义测试集
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)

##3.在Sequential中搭建网络结构
model=tf.keras.models.Sequential([
    #建立了一个全连接层，神经元个数为3,activation激活函数softmax,
    tf.keras.layers.Dense(3,
                          activation='softmax',
                          kernel_regularizer=tf.keras.regularizers.l2())
])

##4.compile配置神经网络训练方法，model.compile(optimizer=优化器,loss=损失函数,metrics=['准确率']
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              #由于神经网络末端选用了softmax函数，使得输出是概率分布而不是原始输出，所以from_logits是afalse
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
             metrics=['sparse_categorical_accuracy'])

##5.fit函数用来执行训练过程
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
#validation_freq每迭代多少次训练集要在测试集中验证一次准确率

##6.使用summary打印出网络结构和参数统计
model.summary()

---

3.2 搭建网络八股class

使用Sequential可以搭建出上层输出就是下层输入的顺序网络结构，但是无法写出一些带有跳连的非顺序网络结构，为了解决这个问题，可以使用class来封装一个网络结构
#使用class来封装一个神经网络从而
#避免了使用Sequential无法写出一些带有跳连的非顺序网络结构的问题

class MyModel(Model): #model表示继承了tensorflow的model类
    def __init__(self):
        super(MyModel,self).__init__() 
        定义网络模块 
    def call(self,x):
        调用网络模块，实现前向传播
        return y
model=MyModel()

__init__()定义所需网络结构块
call 写出前向传播
比如定义的单层鸢尾花网络

class IrisModel(Model): #model表示继承了tensorflow的model类
    def __init__(self):
        super(IrisModel,self).__init__() 
        self.d1=Dense(3) #这里只定义了一个全连接层所以只有d1=Dense(3)，如果还有别的层就接着往下写，每一层都要用self.引导 
    def call(self,x):
        y=self.d1(x)
        return y
model=IrisModel()

完整代码如下

##1.import相关模块
import tensorflow as tf 
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model 
from sklearn import datasets
import numpy as np 
import warnings
warnings.filterwarnings('ignore')

##2.指定训练集和测试集的输入极其对应标签
#对于本例从后面训练集中划分，所以这里没有再定义测试集
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)


##3.在class总定义神经网络结构
class IrisModel(Model):
    def __init__(self):
        super(IrisModel,self).__init__()
        self.d1=Dense(3,activation='sigmoid',
                     kernel_regularizer=tf.keras.regularizers.l2())
    def call (self,x):
        y=self.d1(x)
        return y 
model=IrisModel()

##4.compile配置神经网络训练方法，model.compile(optimizer=优化器,loss=损失函数,metrics=['准确率']
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              #由于神经网络末端选用了softmax函数，使得输出是概率分布而不是原始输出，所以from_logits是afalse
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
             metrics=['sparse_categorical_accuracy'])

##5.fit函数用来执行训练过程
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
#validation_freq每迭代多少次训练集要在测试集中验证一次准确率

##6.使用summary打印出网络结构和参数统计
model.summary()

---

3.3 MNIST数据集

minst数据共有七万张图片，都是28*28的像素点的手写数字图片，其中六万张用于训练，一万张用于测试

• 导入MNIST数据集

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

• 作为输入特征，输入神经网络时，将数据拉伸为一维数组
  即对于单张图片而言，共有28*28=284个像素点的灰度值作为输入特征送入神经网络

tf.keras.layers.Flatten()

import tensorflow as tf 
import  matplotlib.pyplot as plt 
%matplotlib inline

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

我这里没显示全，显示全了应该是这个样子，即手写数字5的28行28列个像素值，0表示纯黑色，255表示纯白色

# 打印出整个训练集输入特征形状
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)

结果为
x_train.shape:
 (60000, 28, 28)
y_train.shape:
 (60000,)
x_test.shape:
 (10000, 28, 28)
y_test.shape:
 (10000,)

使用Sequential实现手写数字识别

#使用Sequential实现手写数字代码
##1.import相关模块
import tensorflow as tf 

##2.指定训练集和测试集
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

##3.在Sequential中搭建网络结构
model=tf.keras.models.Sequential([
    #一个拉直层
    tf.keras.layers.Flatten(),
    #全连接层1
    tf.keras.layers.Dense(128,activation='relu'),
    #全连接层2
    tf.keras.layers.Dense(10,activation='softmax')
])

##4.compile中配置训练方法，指定优化器、损失函数、评价指标
model.compile(optimizer='adam',
              #如果输出不满不概率分布，from_logits=True
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

##5.fit中训练模型
model.fit(x_train, y_train, batch_size=32, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          validation_freq=1)

##6.summary中打印
model.summary()

注意，我们所最后评估模型用的是测试集的准确率即结果中的val_sparse_categorical_accuracy: 0.9770

使用class定义神经网络实现手写数字识别

#使用class实现手写数字代码
##1.import相关模块
import tensorflow as tf 
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model

##2.指定训练集和测试集
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

##3.在class中搭建网络结构
class MnistModel(Model):
    def __init__(self): #定义了call函数中所用的层
        super(MnistModel,self).__init__()
        self.flatten=Flatten()
        self.d1=Dense(128,activation='relu')
        self.d2=Dense(10,activation='softmax')
    
    def call(self,x): #从输入x到输出y，走过一次前向传播，返回输出y
        x=self.flatten(x)
        x=self.d1(x)
        y=self.d2(x)
        return y 
    
model=MnistModel()

##4.compile中配置训练方法，指定优化器、损失函数、评价指标
model.compile(optimizer='adam',
              #如果输出不满不概率分布，from_logits=True
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

##5.fit中训练模型
model.fit(x_train, y_train, batch_size=32, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          validation_freq=1)

##6.summary中打印
model.summary()

3.4 Fashion数据集

#查看数据集
import tensorflow as tf 
import matplotlib.pyplot as plt 
%matplotlib inline

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

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

##使用Sequential实现fashion数据集识别

##1.import相关函数
import tensorflow as tf

##2.指定测试集和训练集
fashion=tf.keras.datasets.fashion_mnist
(x_train,y_train),(x_test,y_test)=fashion.load_data()
#对输入特征进行归一化
x_train,x_test=x_train/255,x_test/255 

##3.在Sequential中搭建网络结构
model=tf.keras.models.Sequential([
    #一个拉直层
    tf.keras.layers.Flatten(),
    #全连接层1
    tf.keras.layers.Dense(128,activation='relu'),
    #全连接层2
    tf.keras.layers.Dense(10,activation='softmax')
])

##4.compile中配置训练方法，指定优化器、损失函数、评价指标
model.compile(optimizer='adam',
              #如果输出不满不概率分布，from_logits=True
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

##5.fit中训练模型
model.fit(x_train, y_train, batch_size=32, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          validation_freq=1)

##6.summary中打印
model.summary()

#使用class实现手写数字代码
##1.import相关模块
import tensorflow as tf 
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model

##2.指定训练集和测试集
fashion=tf.keras.datasets.fashion_mnist
(x_train,y_train),(x_test,y_test)=fashion.load_data()
#对输入特征进行归一化
x_train,x_test=x_train/255,x_test/255 

##3.在class中搭建网络结构
class MnistModel(Model):
    def __init__(self): #定义了call函数中所用的层
        super(MnistModel,self).__init__()
        self.flatten=Flatten()
        self.d1=Dense(128,activation='relu')
        self.d2=Dense(10,activation='softmax')
    
    def call(self,x): #从输入x到输出y，走过一次前向传播，返回输出y
        x=self.flatten(x)
        x=self.d1(x)
        y=self.d2(x)
        return y 
    
model=MnistModel()

##4.compile中配置训练方法，指定优化器、损失函数、评价指标
model.compile(optimizer='adam',
              #如果输出不满不概率分布，from_logits=True
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

##5.fit中训练模型
model.fit(x_train, y_train, batch_size=32, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          validation_freq=1)

##6.summary中打印
model.summary()