TensorFlow07 神经网络-自定义网络

阅读目录

• 1 keras.Sequential
• 2 model.trainable_variables
• 3 Layer/Model
• 4 具体实现

 

▪ keras.Sequential
▪ keras.layers.Layer
▪ keras.Model

回到顶部

1 keras.Sequential

这样就完成了五层的神经网络的一个搭建，然后我们在activation中也可以指定每一层的激活函数

回到顶部

2 model.trainable_variables

▪ model.trainable_variables
▪ model.call()

model.trainable_variables
我们之前做的时候,都是定义一个variable类型的w1,w2,--b1,b2,但是现在我们都是用Sequential来定义的这个神经网络，但是后面求梯度的时候我们需要用到这些值，所以我们后面求梯度的时候我们可以用这个grads = tape.gradient(loss_ce, model.trainable_variables)

回到顶部

3 Layer/Model

▪ Inherit from keras.layers.Layer/keras.Model
▪ __ init__
▪ call
▪ Model: compile/fit/evaluate/predict
其中这个__ init__和call()方法是layer.Layer所必须实现的。

所以我们在使用这个这些方法的时候我们必须继承自keras.model。

—— inint__这个类似于一个初始化函数，然后自己的逻辑在call函数里面，如果我们调用model(x)的时候其实就是调用了model.call()方法,也就是我们自己写的这个逻辑call()中的东西
其中我们的Sequential也是继承自keras.Model所以可以很方便的使用compile/fit/evaluate/predical这些函数。所以我们如果想使用compile/fit/evaluate/predical这些函数，我们必须继承自keras.Model这个大类

如果我们需要自定义一个神经网络我们需要继承自layers.Layer就行，然后我们自定义__init__和call方法。其中自己的逻辑在call方法中。

这里注意一下这个__init__需要super().init()。
这里我们的__init__更像是自定义一些变量，然后这个call()中可以实现自己的逻辑，下面那个具体实现1中可以很好的体现。

回到顶部

4 具体实现

1.之前如果是layers.Dense(512)，之后再build([none,784]),之后我们的这个w就是:[784,512]。
b就是一个[512]。

其中这个self.kernel和self.bias是通过add.variable来创建的，并不是通过tf.constant()。然后这个里面的名字'w','b'是可以换名字的，尽量取一个有意义的名字。

其中这两个部分都是自己写的。

然后这个层就创建完了，我们如果需要通过这个定义的层来定义一个神经网络的话。

首先这个__init__中是我们定义的5层神经网络，然后在call中实现自己的具体实现。这里我们可以通过Sequential进行绑定起来。

然后这个是自定义网络层的代码：

import  tensorflow as tf
from    tensorflow.keras import datasets, layers, optimizers, Sequential, metrics
from 	tensorflow import keras

def preprocess(x, y):
    """
    x is a simple image, not a batch
    """
    x = tf.cast(x, dtype=tf.float32) / 255.
    x = tf.reshape(x, [28*28])
    y = tf.cast(y, dtype=tf.int32)
    y = tf.one_hot(y, depth=10)
    return x,y


batchsz = 128
(x, y), (x_val, y_val) = datasets.mnist.load_data()
print('datasets:', x.shape, y.shape, x.min(), x.max())



db = tf.data.Dataset.from_tensor_slices((x,y))
db = db.map(preprocess).shuffle(60000).batch(batchsz)
ds_val = tf.data.Dataset.from_tensor_slices((x_val, y_val))
ds_val = ds_val.map(preprocess).batch(batchsz) 

sample = next(iter(db))
print(sample[0].shape, sample[1].shape)


network = Sequential([layers.Dense(256, activation='relu'),
                     layers.Dense(128, activation='relu'),
                     layers.Dense(64, activation='relu'),
                     layers.Dense(32, activation='relu'),
                     layers.Dense(10)])
network.build(input_shape=(None, 28*28))
network.summary()


class MyDense(layers.Layer):

	def __init__(self, inp_dim, outp_dim):
		super(MyDense, self).__init__()

		self.kernel = self.add_weight('w', [inp_dim, outp_dim])
		self.bias = self.add_weight('b', [outp_dim])

	def call(self, inputs, training=None):

		out = inputs @ self.kernel + self.bias

		return out 

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)
 
network.evaluate(ds_val)

sample = next(iter(ds_val))
x = sample[0]
y = sample[1] # one-hot
pred = network.predict(x) # [b, 10]
# convert back to number 
y = tf.argmax(y, axis=1)
pred = tf.argmax(pred, axis=1)

print(pred)
print(y)