相信很多新手小白在才开始初学时就想要搭建自己的深度学习模型，但在看到每个风格不同的算法时，又会把前向传播，反向传播，和模型的搭建过程混淆，我总结了一下几种基于Tensorflow2.x搭建模型的代码。
1.学习过程中最常见的数据切片，载入并预处理，这一部分呢模型运用Sequential搭建，好处是方便简洁，但是前向传播的顺序是固定的，且在训练过程和优化过程中都调用了API。
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets,layers,optimizers,Sequential,metrics,losses
def prrocess(x,y):
x = tf.cast(x,dtype=tf.float32)/255
y = tf.cast(y,dtype=tf.int32)
return x,y
(x,y),(x_test,y_test) = datasets.fashion_mnist.load_data()
print(x.shape,y.shape)
batchsz = 128
db = tf.data.Dataset.from_tensor_slices((x,y))
db = db.map(prrocess).shuffle(10000).batch(batchsz)
db_test = tf.data.Dataset.from_tensor_slices((x_test,y_test))
db_test = db.map(prrocess).shuffle(10000).batch(batchsz)
db_iter = iter(db)
sample = next(db_iter)
model = Sequential([
layers.Dense(256,activation=tf.nn.relu),
layers.Dense(128,activation=tf.nn.relu),
layers.Dense(64,activation=tf.nn.relu),
layers.Dense(32,activation=tf.nn.relu),
layers.Dense(10)
])
model.built(input_shape=[None,28*28])
model.summary()
optimizer = optimizers.Adam(lr=1e-3)
def main():
for epoch in range(30):
for step,(x,y) in enumerate(db):
# x -> [b,784]
x = tf.reshape(x,[-1,28*28])
with tf.GradientTape() as tape:
logits = model(x)
y_onehot = tf.one_hot(y,depth=10)
loss_mes = tf.reduce_mean(tf.losses.MSE(y_onehot,logits))
loss_ce =tf.reduce_mean(tf.losses.categorical_crossentropy(y_onehot,logits,from_logits=True))
grads = tape.gradient(loss_ce,model.trainable_variables)
optimizer.apply_gradients(zip(grads,model.trainable_variables))# zip Lian jie
if step % 100 ==0:
print(epoch,step,'loss:',float(loss_ce),float(loss_mes)).
total_correct=0
total_num=0
for x,y in db_test:
x = tf.reshape(x,[-1,28*28])
logits = model(x)
prob = tf.nn.softmax(logits,axis=1)
pred = tf.argmax(prob,axis=1)
pred = tf.cast(pred,dtype=tf.int32)
correct = tf.equal(pred,y)
correct = tf.reduce_sum(tf.cast(correct,dtype=tf.int32))
total_correct += int(correct)
total_num += x.shape[0]
2.在这种代码类型中，没有调用API，而是从最底层的w1，w2...每个神经元的参数和计算方式着手，在梯度计算个更新中都能代入自己的损失函数和优化过程。
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets,metrics
#[60k,28,28]
(x, y), (x_val, y_val)= datasets.mnist.load_data()
#
x = tf.convert_to_tensor(x,dtype=tf.float32)/255.
y = tf.convert_to_tensor(y,dtype=tf.int32)
x_val = tf.convert_to_tensor(x_val,dtype=tf.float32)/255
y_val = tf.convert_to_tensor(y_val,dtype=tf.int32)
print(x.shape,y.shape)
print(tf.reduce_max(x))
train_db = tf.data.Dataset.from_tensor_slices((x,y)).batch(128)
test_db = tf.data.Dataset.from_tensor_slices((x_val,y_val)).batch(128)
# train_iter = iter(train_db)
# sample = next(train_iter)
# print('batch=',sample[0].shape)
w1 =tf.Variable(tf.random.truncated_normal([784,256],stddev=0.1)) #均值为0 方差为0 不会梯度爆炸
b1 =tf.Variable (tf.zeros([256]))
w2 =tf.Variable( tf.random.truncated_normal([256,128],stddev=0.1))
b2 =tf.Variable(tf.zeros([128]))
w3 =tf.Variable( tf.random.truncated_normal([128,10],stddev=0.1))
b3 =tf.Variable (tf.zeros([10]))
lr = 1e-3
acc_meter = metrics.Accuracy() # 新建accuracy测量器
for step,(x,y) in enumerate(train_db):
with tf.GradientTape() as tape:
x = tf.reshape(x, [-1, 28 * 28])
h1 = x @ w1 + b1
h1 = tf.nn.relu(h1)
h2 = h1 @ w2 + b2
h2 = tf.nn.relu(h2)
h3 = h2 @ w3 + b3
h3 = tf.nn.softmax(h3)
y_onehot = tf.one_hot(y, depth=10)
loss = tf.square(y_onehot - h3)
loss = tf.reduce_mean(loss) / 128
grads = tape.gradient(loss,[w1,b1,w2,b2,w3,b3])
w1.assign_sub(lr * grads[0])
b1.assign_sub(lr * grads[1])
w2.assign_sub(lr * grads[2])
b2.assign_sub(lr * grads[3])
w3.assign_sub(lr * grads[4])
b3.assign_sub(lr * grads[5])
acc_meter.update_state(tf.argmax(h3, axis=1), y)
if step % 100 ==0:
print(step,'loss:',float(loss))
acc_meter.reset_states()
#val
total_correct ,total_num = 0,0
for step, (x, y) in enumerate(test_db):
x = tf.reshape(x,[-1,28 * 28])
hi = tf.nn.relu(x@w1 + b1)
h2 = tf.nn.relu(h1@w2 + b2)
print(h2.shape)
out = (h2 @ w3 + b3)
print(out.shape)
prob = tf.nn.softmax(out,axis=1)
print(prob.shape)
pred = tf.argmax(prob,axis=1)
print(pred.dtype,y.dtype)
pred = tf.cast(pred,dtype=tf.int32)
print(pred.dtype, y.dtype,pred.shape,y.shape)
correct = tf.cast(tf.equal(pred,y),dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_correct +=int(correct)
total_num += x.shape[0]
acc = total_correct/total_num
print('test acc ',acc)
3.在搭建更深层的网路时，我们可以将多次重复使用的部分创建为一个class，调用tensorflow里的layers，在class的初始中写入网络的构建，在call中写入前向传播过程。是比较常用的类型。如下为GAN网络中判别器的代码。
class Discriminator(keras.Model):
def __init__(self):
super(Discriminator, self).__init__()
self.conv1 = layers.Conv2D(64, 5, 3, 'valid')
self.conv2 = layers.Conv2D(128, 5, 3, 'valid')
self.bn2 = layers.BatchNormalization()
self.conv3 = layers.Conv2D(256, 5, 3, 'valid')
self.bn3 = layers.BatchNormalization()
self.flatten = layers.Flatten()
self.fc = layers.Dense(1)
# [b, 64, 64, 3] => [b, 1]
def call(self, inputs, training=None):
x = self.conv1(inputs)
x = tf.nn.leaky_relu(x)
x = self.conv2(x)
x = self.bn2(x, training=training)
x = tf.nn.leaky_relu(x)
x = self.conv3(x)
x = self.bn3(x, training=training)
x = tf.nn.leaky_relu(x)
x = self.flatten(x)
x = self.fc(x)
return x
