使用八股搭建神经网络（tensorflow，keras）_3

1.神经网络搭建八股
2.iris代码复现
3.mnist数据集
4.训练mnist数据集
5.fashion数据集

搭建神经网络八股六步法：

1.import：导入模块

2.train，test：告知训练集和测试集

3.model=tf.keras.models.Sequential：在Sequential中搭建网络，走一遍前向传播

4.model.compile：在compile()中配置训练方法，选择优化器，选择损失函数，选择评测指标

5.model.fit：在fit()中训练，训练集和测试集喂入网络，告知每个batch是多少，要迭代多少epochs

6.model.summary：打印网络的结构和参数统计

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

拉直层：tf.keras.layers.Flatten() 不含计算，把输入特征拉直成一维数组
全连接层：tf.keras.layers.Dense(神经元个数，activation=“激活函数”，kernel_regularizer=哪种正则化)
activation（字符串给出）可选：relu，softmax，sigmoid，tanh
kernel_regularizer可选：tf.keras.regularizer.l1()、tf.keras.regularizer.l2()
卷积层：tf.keras.layers.Conv2D(…)
lstm层：tf.keras.layers.LSTM()

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

optimizer可选：
'sgd’或tf.kears.optimizers.SGD(lr=学习率，momentum=动量参数)
'adagrad’或tf.kears.optimizers.Adagrad(lr=学习率)
'adadelta’或tf.kears.optimizers.Adadelta(lr=学习率)
'adam’或tf.kears.optimizers.Adam(lr=学习率，beta_1=0.9，beta_2=0.999)
loss可选：
'mse’或tf.kears.losses.MeanSquaredError()
'sparse_categorical_crossentropy’或tf.kears.losses.SparseCategoricalCrossentropy(from_logits=False)
Metrics可选：
‘accuracy’，‘categorical_accuracy’(y和y_是独热编码)，‘sparse_categorical_accuracy’(y_是数值，y是独热编码)

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

validation_data和validation_split二选一

model.summary()：打印网络结构

自定义网络结构搭建神经网络六步法：

1.import：导入模块
2.train，test：告知训练集和测试集
3.class MyModel(Model)，model=MyModel() (自定义网络结构）
4.model.compile：在compile()中配置训练方法，选择优化器，选择损失函数，选择评测指标
5.model.fit：在fit()中训练，训练集和测试集喂入网络，告知每个batch是多少，要迭代多少epochs
6.model.summary：打印网络的结构和参数统计

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        # 定义网络结构块
    def call(self,x):
        # 调用网络结构块，实现前向传播
        return y
    
model = MyModel() # 实例化一个model

如

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.d1 = Dense(3)  # d1是这一层起的名字，每一层用self.引导
    def call(self,x):
        y = self.d1(x)  # 调用网络结构，实现一次前向传播
        return y

model = MyModel() # 实例化一个model

案例：使用mnist数据集进行识别

六步法：

import tensorflow as tf

fashion = tf.keras.datasets.fashion_mnist
(x_train, y_train),(x_test, y_test) = fashion.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'])

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.layers import Flatten, Dense
from tensorflow.keras.models import Model

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

class FashionMedol(Model):
    def __init__(self):
        super(FashionMedol, self).__init__()
        self.flatten = Flatten()
        self.dense1 = Dense(128, activation='relu')
        self.dense2 = Dense(10, activation='softmax')
    def call(self, x):
        x = self.flatten(x)
        x = self.dense1(x)
        y = self.dense2(x)
        return y
model = FashionMedol()

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