TensorFlow2.0学习笔记2-tf2.0两种方式搭建神经网络

目录

一，TensorFlow2.0搭建神经网络八股

1）import  【引入相关模块】

2）train,test  【告知喂入网络的训练集测试集以及相应的标签】

3）model=tf.keras.models.Sequential  【在Sequential中搭建网络结构，相当于走一遍前向传播】

4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】

5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】

6）model.summary  【打印网络结构和参数统计】

二，用TensorFlow2.0实现iris分类

1）使用keras的Sequential方式实现

         2）使用keras的class类搭建神经网络结构

三，用TensorFlow2.0训练MNIST数据集

1）使用keras的Sequential方式实现

2）使用keras的class类搭建神经网络结构

四，用TensorFlow2.0训练Fashion数据集

1）使用keras的Sequential方式实现

2）使用keras的class类搭建神经网络结构

---

 

一，TensorFlow2.0搭建神经网络八股

六步法：

1）import  【引入相关模块】

2）train,test  【告知喂入网络的训练集测试集以及相应的标签】

3）model=tf.keras.models.Sequential  【在Sequential中搭建网络结构，相当于走一遍前向传播】

• model=tf.keras.models.Sequential([]网络结构)   # 描述各层网络结构，网络结构举例：
• 拉直层：tf.keras.layers.Flatten()
• 全连接层：tf.keras.layers.Dense(神经元个数，activation=“激活函数”，kernal_regularizer=哪种正则化）， activation（字    符串给出），可选 relu、softmax、sigmoid、tanh； kernel_regularizer，可选tf.keras.regularizers.l1()、       tf.keras.regularizers.l2()
• 卷积层：tf.keras.layers.Conv2D(flters=卷积核个数，kernel_size=卷积核尺寸,strides=卷积步长，padding="valid" or "same")
• LSTM层：tf.keras.layers.LSTM()

4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】

• model.compile(optimizer=优化器，loss=损失函数，metrics=【“准确率”】)
• Optimizer可选：

       ‘sgd’ or 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.losser.MeanSquareeError()

        'sparse_categorical_crossentropy'  or tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)

• 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_=[0,1,0], y=[0.256,0.695,0.048]

5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】

model.fit(训练集的输入特征，训练集的标签，

               batch_size=,epochs=,

               validation_data=(测试集的输入特征，测试集的标签),

               validation_split=从测试集划分多少比例给测试集，

               validation_freq=多少次epoch测试一次）

6）model.summary  【打印网络结构和参数统计】

 

二，用TensorFlow2.0实现iris分类

1）使用keras的Sequential方式实现

# 1）import  【引入相关模块】
import tensorflow as tf
from sklearn import datasets
import numpy as np

# 2）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)

# 3）model=tf.keras.models.Sequential  【在Sequential中搭建网络结构，相当于走一遍前向传播】
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
])

# 4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# 5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

# 6）model.summary  【打印网络结构和参数统计】
model.summary()

代码执行结果：

2）使用keras的class类搭建神经网络结构

class类模板：

#class MyModel(Model) model=MyModel

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

model=MyModel()

Iris实例：

#class MyModel(Model) model=MyModel

class IrisModel(Model):
  def __init__(self):
    super(IrisModel,self).__init__()
    self.dl=Dense(3)
  def call(self,x):
    y=self.dl(x)     # 输入特征4，直接采用1层网络结构
    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

# 2）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)

# 3) class MyModel()
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）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# 5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】
model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)

# 6）model.summary  【打印网络结构和参数统计】
model.summary()

运行结果和上面的类似：

三，用TensorFlow2.0训练MNIST数据集

1）使用keras的Sequential方式实现

# 1）import  【引入相关模块】
import tensorflow as tf

# 2）train,test  【告知喂入网络的训练集测试集以及相应的标签】
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

# 3）model=tf.keras.models.Sequential  【在Sequential中搭建网络结构，相当于走一遍前向传播】
model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

# 4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# 5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】
model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)

# 6）model.summary  【打印网络结构和参数统计】
model.summary()

代码执行结果： 

2）使用keras的class类搭建神经网络结构

# 1）import  【引入相关模块】
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model

# 2）train,test  【告知喂入网络的训练集测试集以及相应的标签】
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

# 3) class MyModel()
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()

# 4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# 5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】
model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)

# 6）model.summary  【打印网络结构和参数统计】
model.summary()

 执行结果：

四，用TensorFlow2.0训练Fashion数据集

另一个版本的TensorFlow2.0训练Fashion数据集：Fashion MNIST实战

1）使用keras的Sequential方式实现

# 1）import  【引入相关模块】
import tensorflow as tf

# 2）train,test  【告知喂入网络的训练集测试集以及相应的标签】
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

# 3）model=tf.keras.models.Sequential  【在Sequential中搭建网络结构，相当于走一遍前向传播】
model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

# 4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# 5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】
model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)

# 6）model.summary  【打印网络结构和参数统计】
model.summary()

 执行结果： 

2）使用keras的class类搭建神经网络结构

# 1）import  【引入相关模块】
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model

# 2）train,test  【告知喂入网络的训练集测试集以及相应的标签】
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

# 3) class MyModel()
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()

# 4）model.compile  【告知训练时选择哪种优化器，选择哪个损失函数，选择哪种评测指标】
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

# 5）model.fit 【在fit()中执行训练过程，告知训练集合测试集的输入特征和标签，告知batch大小，告知要迭代多少次数据集】
model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)

# 6）model.summary  【打印网络结构和参数统计】
model.summary()

 执行结果：