keras构建网络的方式

一、利用 Sequential 构建

# 创建模型
model = Sequential([
    layers.Dense(256, activation=tf.nn.relu), # [b, 784] => [b, 256]
    layers.Dense(128, activation=tf.nn.relu), # [b, 256] => [b, 128]
    layers.Dense(64, activation=tf.nn.relu),  # [b, 128] => [b, 64]
    layers.Dense(32, activation=tf.nn.relu),  # [b, 64] => [b, 32]
    layers.Dense(10) # [b, 32] => [b, 10], 330 = 32*10 + 10
]) # 最后一层不添加激活函数，需要在运行时添加softmax层

# 模型输入与查看模型信息
model.build(input_shape=[None, 28*28])       # 模型输入信息
model.summary()

# 模型编译：=> 选择适合的优化器与损失函数以及衡量标准
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# 模型训练
model.fit(train_images, train_labels, epochs=10)

# 测试集评估
test_loss, test_acc = model.evaluate(test_images,test_labels, verbose=2) # 'verbose=2'是指每行输出日志信息

# 模型预测
probability_model = tf.keras.Sequential([model,tf.keras.layers.Softmax()]) # 添加softmax层
predictions = probability_model.predict(test_images)                       # 预测的得到的结果

二、利用Model类来创建

# 导入库
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, Flatten, Conv2D # 导入层的信息

# 利用Model类来添加网络层
# 创建模型层
class MyModel(Model):
    def __init__(self):
        super(MyModel,self).__init__()                  # 继承父类函数
        self.conv1 = Conv2D(32,3,activation = 'relu')   
        self.flatten = Flatten()
        self.d1 = Dense(128,activation='relu')
        self.d2 = Dense(10,activation='softmax')
    def call(self,x):
        x = self.conv1(x)
        x = self.flatten(x)
        x = self.d1(x)
        return self.d2(x)

model = MyModel()   # 实例化对象

# 选择衡量标准
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')

# 训练模型
def train_step(image,labels):
    with tf.GradientTape() as tape:
        predictions = model(image)
        loss = loss_object(labels,predictions)
    gradients = tape.gradient(loss,model.trainable_variables)
    optimizer.apply_gradients(zip(gradients,model.trainable_variables))  # zip()函数用来将两个列表的对应序号元素打包成新的元组，数量最少的列表有多少元素，就有多少个元组。

    train_loss(loss)
    train_accuracy(labels, predictions)

for epoch in range(EPOCHS):
  # 在下一个epoch开始时，重置评估指标
  train_loss.reset_states()
  train_accuracy.reset_states()

  for images, labels in train_ds:
    train_step(images, labels)

三、利用layers.Layer类

# 定义自己需要的网络层
# 创建MyDense类，用来实例化层的信息
class MyDense(layers.Layer):
	def __init__(self, inp_dim, outp_dim):
		super(MyDense, self).__init__()
		self.kernel = self.add_variable('w', [inp_dim, outp_dim])
		self.bias = self.add_variable('b', [outp_dim])
	def call(self, inputs, training=None):
		out = inputs @ self.kernel + self.bias
		return out 
 
# 利用Model来添加网络层
class MyModel(keras.Model):
	def __init__(self):
		super(MyModel, self).__init__()
		self.fc1 = MyDense(28*28, 256) 
		self.fc2 = MyDense(256, 128)
		self.fc3 = MyDense(128, 64)
		self.fc4 = MyDense(64, 32)
		self.fc5 = MyDense(32, 10)
	
    def call(self, inputs, training=None):
		x = self.fc1(inputs)
		x = tf.nn.relu(x)
		x = self.fc2(x)
		x = tf.nn.relu(x)
		x = self.fc3(x)
		x = tf.nn.relu(x)
		x = self.fc4(x)
		x = tf.nn.relu(x)
		x = self.fc5(x) 
		return x
    
network = MyModel()  # 实例化模型

# 编译网络
network.compile(optimizer=optimizers.Adam(lr=0.01),
		loss=tf.losses.CategoricalCrossentropy(from_logits=True),
		metrics=['accuracy']
	)

# 拟合网络
network.fit(db, epochs=5, validation_data=ds_val,validation_freq=2)
# 在训练训练集的同时，训练验证集，且每2个epoch显示准确性

# 进行预测
pred = network.predict(x) # [b, 10]