1.步驟

第一步：import 相關模組，如 import tensorflow as tf

第二步：指定輸入網路的訓練集和測試集，如指定訓練集的輸入 x_train 和標籤y_train，測試集的輸入 x_test 和標籤 y_test。

第三步：逐層搭建網路結構，model = tf.keras.models.Sequential()。

第四步：在 model.compile()中配置訓練方法，選擇訓練時使用的優化器、損失函式和最終評價指標。

第五步：在 model.fit()中執行訓練過程，告知訓練集和測試集的輸入值和標籤、每個 batch 的大小（batchsize）和資料集的迭代次數（epoch）。

第六步：使用 model.summary()列印網路結構，統計引數數目。

2.函式用法介紹

tf.keras.models.Sequential()： Sequential 函式是一個容器，描述了神經網路的網路結構，在 Sequential函式的輸入引數中描述從輸入層到輸出層的網路結構。

Model.compile( optimizer = 優化器, loss = 損失函式, metrics = [“準確率”]) Compile 用於配置神經網路的訓練方法，告知訓練時使用的優化器、損失函數和準確率評測標準。

其中：

optimizer 可以是字串形式給出的優化器名字，也可以是函式形式，使用函式

可選項包括：
‘sgd’or tf.optimizers.SGD( lr=學習率, decay=學習率衰減率, momentum=動量引數)
‘adagrad’or tf.keras.optimizers.Adagrad(lr=學習率, decay=學習率衰減率)
‘adadelta’or tf.keras.optimizers.Adadelta(lr=學習率, decay=學習率衰減率)
‘adam’or tf.keras.optimizers.Adam (lr=學習率, decay=學習率衰減率)

Loss 可以是字串形式給出的損失函式的名字，也可以是函式形式。

可選項包括：

‘mse’or tf.keras.losses.MeanSquaredError()‘sparse_categorical_crossentropyor tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)

損失函式常需要經過 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]。

model.fit(訓練集的輸入特徵， 訓練集的標籤， batch_size, epochs, validation_data = (測試集的輸入特徵，測試集的標籤)， validataion_split = 從測試集劃分多少比例給訓練集， validation_freq = 測試的 epoch 間隔次數) fit 函式用於執行訓練過程

model.summary() summary 函式用於列印網路結構和引數統計

3.搭建網路訓練iris 資料集如下：

 1 import tensorflow as tf
 2 from sklearn import datasets
 3 import numpy as np
 4 
 5 x_train = datasets.load_iris().data
 6 y_train = datasets.load_iris().target
 7 
 8 np.random.seed(116)
 9 np.random.shuffle(x_train)
10 np.random.seed(116)
11 np.random.shuffle(y_train)
12 tf.random.set_seed(116)
13 
14 model = tf.keras.models.Sequential([
15     tf.keras.layers.Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
16 ])
17 
18 model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
19               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
20               metrics=['sparse_categorical_accuracy'])
21 
22 model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
23 
24 model.summary()

 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
 6 
 7 x_train = datasets.load_iris().data
 8 y_train = datasets.load_iris().target
 9 
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)
15 
16 class IrisModel(Model):
17     def __init__(self):
18         super(IrisModel, self).__init__()
19         self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())
20 
21     def call(self, x):
22         y = self.d1(x)
23         return y
24 
25 model = IrisModel()
26 
27 model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
28               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
29               metrics=['sparse_categorical_accuracy'])
30 
31 model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
32 model.summary()

以上兩段程式碼的不同之處是，第一段是用Sequential搭建網路，第二段是自定義網路。

4.搭建網路訓練MNIST 資料集如下：

 1 import tensorflow as tf
 2 
 3 mnist = tf.keras.datasets.mnist
 4 (x_train, y_train), (x_test, y_test) = mnist.load_data()
 5 x_train, x_test = x_train / 255.0, x_test / 255.0
 6 
 7 model = tf.keras.models.Sequential([
 8     tf.keras.layers.Flatten(),
 9     tf.keras.layers.Dense(128, activation='relu'),
10     tf.keras.layers.Dense(10, activation='softmax')
11 ])
12 
13 model.compile(optimizer='adam',
14               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
15               metrics=['sparse_categorical_accuracy'])
16 
17 model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
18 model.summary()

 1 import tensorflow as tf
 2 from tensorflow.keras.layers import Dense, Flatten
 3 from tensorflow.keras import Model
 4 
 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
 8 
 9 
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')
16 
17     def call(self, x):
18         x = self.flatten(x)
19         x = self.d1(x)
20         y = self.d2(x)
21         return y
22 
23 
24 model = MnistModel()
25 
26 model.compile(optimizer='adam',
27               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
28               metrics=['sparse_categorical_accuracy'])
29 
30 model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
31 model.summary()

不同之處也是在搭建網路時使用的方法不同