TensorFlow实战 前向传播_tensorflow中手动实现前向传播

导入模块

import os 
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets,layers,optimizers
1
2
3
4

数据加载

(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)
1
2
3

创建数据集

train_dataset = tf.data.Dataset.from_tensor_slices((x,y)).batch(200)
train_iter = iter(train_dataset)
sample = next(train_iter)
1
2
3

维度变换

#[b,784] => [b,512] => [b,256] => [b,10]
w1 = tf.random.truncated_normal([784,512])
b1 = tf.zeros([512])
w2 = tf.random.truncated_normal([512,256])
b2 = tf.zeros([256])
w3 = tf.random.truncated_normal([256,10])
b3 = tf.zeros([10])
for (x,y) in train_dataset:
    x = tf.reshape(x,[-1,28*28])
    #h = x@w + b
    #[b,784]@[784,512]+[512] => [b,512]+[512] => [b,512]+[b,512]
    h1 = x@w1 + b1
    h1 = tf.nn.relu(h1) #非线性转化
    h2 = h1@w2 + b2
    h2 = tf.nn.relu(h2) #非线性转化
    out = h2@w3 + b3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

计算误差

y_onehot = tf.one_hot(y,depth=10)
        loss = tf.square(y_onehot-out)
        loss = tf.reduce_mean(loss)
1
2
3

计算梯度

 with tf.GradientTape() as tape:
            #h = x@w + b
            #[b,784]@[784,512]+[512] => [b,512]+[512] => [b,512]+[b,512]
            h1 = x@w1 + b1
            h1 = tf.nn.relu(h1) #非线性转化
            h2 = h1@w2 + b2
            h2 = tf.nn.relu(h2) 
            out = h2@w3 + b3

            y_onehot = tf.one_hot(y,depth=10)
            loss = tf.square(y_onehot-out)
            loss = tf.reduce_mean(loss)
        grads = tape.gradient(loss,[w1,b1,w2,b2,w3,b3])
1
2
3
4
5
6
7
8
9
10
11
12
13

更新权值和偏置项

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])
1
2
3
4
5

完整代码

import os
from random import sample 
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets,layers,optimizers

os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
#数据加载
(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)
print(tf.reduce_max(x),tf.reduce_min(x))
print(tf.reduce_max(y),tf.reduce_min(y))
train_dataset = tf.data.Dataset.from_tensor_slices((x,y)).batch(200)
train_iter = iter(train_dataset)
sample = next(train_iter)

#[b,784] => [b,512] => [b,256] => [b,10]
w1 = tf.Variable(tf.random.truncated_normal([784,512],stddev=0.1))
b1 = tf.Variable(tf.zeros([512]))
w2 = tf.Variable(tf.random.truncated_normal([512,256],stddev=0.1))
b2 = tf.Variable(tf.zeros([256]))
w3 = tf.Variable(tf.random.truncated_normal([256,10],stddev=0.1))
b3 = tf.Variable(tf.zeros([10]))
lr = 0.001
for epoch in range(30):
    for step,(x,y) in enumerate(train_dataset):
        x = tf.reshape(x,[-1,28*28])#维度变换
        with tf.GradientTape() as tape:
            #h = x@w + b
            #[b,784]@[784,512]+[512] => [b,512]+[512] => [b,512]+[b,512]
            h1 = x@w1 + b1
            h1 = tf.nn.relu(h1) #非线性转化
            h2 = h1@w2 + b2
            h2 = tf.nn.relu(h2) 
            out = h2@w3 + b3

            y_onehot = tf.one_hot(y,depth=10)
            loss = tf.square(y_onehot-out)
            loss = tf.reduce_mean(loss)
        grads = tape.gradient(loss,[w1,b1,w2,b2,w3,b3])
        #w = w-lr*grads
        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])
        if step%100==0:
            print(epoch,loss.numpy())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50