使用tf.keras搭建mnist手写数字识别网络

阳光穿透心脏的1/2处 2022-03-21 06:39 568阅读 0赞

使用tf.keras搭建mnist手写数字识别网络

目录

使用tf.keras搭建mnist手写数字识别网络

1.使用tf.keras.Sequential搭建序列模型

1.1 tf.keras.Sequential 模型

1.2 搭建mnist手写数字识别网络（序列模型）

1.3 完整的训练代码

2.构建高级模型

2.1 函数式 API

2.2 搭建mnist手写数字识别网络（函数式 API）

2.3 完整的训练代码

  1. tf.keras高级应用：回调 tf.keras.callbacks.Callback

  2. tf.keras高级应用：自定义层tf.keras.layers.Layer

1.使用tf.keras.Sequential搭建序列模型

1.1 tf.keras.Sequential 模型

在 Keras 中，您可以通过组合层来构建模型。模型（通常）是由层构成的图。最常见的模型类型是层的堆叠：tf.keras.Sequential 模型。要构建一个简单的全连接网络（即多层感知器），请运行以下代码：

  1. model = keras.Sequential()
  2. # Adds a densely-connected layer with 64 units to the model:
  3. model.add(keras.layers.Dense(64, activation='relu'))
  4. # Add another:
  5. model.add(keras.layers.Dense(64, activation='relu'))
  6. # Add a softmax layer with 10 output units:
  7. model.add(keras.layers.Dense(10, activation='softmax'))

图文例子：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1eXVlYWxpYW4_size_16_color_FFFFFF_t_70

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1eXVlYWxpYW4_size_16_color_FFFFFF_t_70 1

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1eXVlYWxpYW4_size_16_color_FFFFFF_t_70 2

1.2 搭建mnist手写数字识别网络（序列模型）

  1. def mnist_cnn(input_shape):
  2.     '''
  3.     构建一个CNN网络模型
  4.     :param input_shape: 指定输入维度
  5.     :return:
  6.     '''
  7.     model=keras.Sequential()
  8.     model.add(keras.layers.Conv2D(filters=32,kernel_size = 5,strides = (1,1),
  9.                                   padding = 'same',activation = tf.nn.relu,input_shape = input_shape))
  10.     model.add(keras.layers.MaxPool2D(pool_size=(2,2), strides = (2,2), padding = 'valid'))
  11.     model.add(keras.layers.Conv2D(filters=64,kernel_size = 3,strides = (1,1),padding = 'same',activation = tf.nn.relu))
  12.     model.add(keras.layers.MaxPool2D(pool_size=(2,2), strides = (2,2), padding = 'valid'))
  13.     model.add(keras.layers.Dropout(0.25))
  14.     model.add(keras.layers.Flatten())
  15.     model.add(keras.layers.Dense(units=128,activation = tf.nn.relu))
  16.     model.add(keras.layers.Dropout(0.5))
  17.     model.add(keras.layers.Dense(units=10,activation = tf.nn.softmax))
  18.     return model

1.3 完整的训练代码

  1. # -*-coding: utf-8 -*-
  2. """
  3.     @Project: tensorflow-yolov3
  4.     @File   : keras_mnist.py
  5.     @Author : panjq
  6.     @E-mail : pan_jinquan@163.com
  7.     @Date   : 2019-01-31 09:30:12
  8. """
  9. import tensorflow as tf
  10. from tensorflow import keras
  11. import matplotlib.pyplot as plt
  12. import numpy as np
  13. mnist=keras.datasets.mnist
  15. def get_train_val(mnist_path):
  16.     # mnist下载地址：https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
  17.     (train_images, train_labels), (test_images, test_labels) = mnist.load_data(mnist_path)
  18.     print("train_images nums:{}".format(len(train_images)))
  19.     print("test_images nums:{}".format(len(test_images)))
  20.     return train_images, train_labels, test_images, test_labels
  22. def show_mnist(images,labels):
  23.     for i in range(25):
  24.         plt.subplot(5,5,i+1)
  25.         plt.xticks([])
  26.         plt.yticks([ ])
  27.         plt.grid(False)
  28.         plt.imshow(images[i],cmap=plt.cm.gray)
  29.         plt.xlabel(str(labels[i]))
  30.     plt.show()
  32. def one_hot(labels):
  33.     onehot_labels=np.zeros(shape=[len(labels),10])
  34.     for i in range(len(labels)):
  35.         index=labels[i]
  36.         onehot_labels[i][index]=1
  37.     return onehot_labels
  39. def mnist_net(input_shape):
  40.     '''
  41.     构建一个简单的全连接层网络模型：
  42.     输入层为28x28=784个输入节点
  43.     隐藏层120个节点
  44.     输出层10个节点
  45.     :param input_shape: 指定输入维度
  46.     :return:
  47.     '''
  49.     model = keras.Sequential()
  50.     model.add(keras.layers.Flatten(input_shape=input_shape))           #输出层
  51.     model.add(keras.layers.Dense(units=120, activation=tf.nn.relu)) #隐含层
  52.     model.add(keras.layers.Dense(units=10, activation=tf.nn.softmax))#输出层
  53.     return model
  55. def mnist_cnn(input_shape):
  56.     '''
  57.     构建一个CNN网络模型
  58.     :param input_shape: 指定输入维度
  59.     :return:
  60.     '''
  61.     model=keras.Sequential()
  62.     model.add(keras.layers.Conv2D(filters=32,kernel_size = 5,strides = (1,1),
  63.                                   padding = 'same',activation = tf.nn.relu,input_shape = input_shape))
  64.     model.add(keras.layers.MaxPool2D(pool_size=(2,2), strides = (2,2), padding = 'valid'))
  65.     model.add(keras.layers.Conv2D(filters=64,kernel_size = 3,strides = (1,1),padding = 'same',activation = tf.nn.relu))
  66.     model.add(keras.layers.MaxPool2D(pool_size=(2,2), strides = (2,2), padding = 'valid'))
  67.     model.add(keras.layers.Dropout(0.25))
  68.     model.add(keras.layers.Flatten())
  69.     model.add(keras.layers.Dense(units=128,activation = tf.nn.relu))
  70.     model.add(keras.layers.Dropout(0.5))
  71.     model.add(keras.layers.Dense(units=10,activation = tf.nn.softmax))
  72.     return model
  75. def trian_model(train_images,train_labels,test_images,test_labels):
  76.     # re-scale to 0~1.0之间
  77.     train_images=train_images/255.0
  78.     test_images=test_images/255.0
  79.     # mnist数据转换为四维
  80.     train_images=np.expand_dims(train_images,axis = 3)
  81.     test_images=np.expand_dims(test_images,axis = 3)
  82.     print("train_images :{}".format(train_images.shape))
  83.     print("test_images :{}".format(test_images.shape))
  85.     train_labels=one_hot(train_labels)
  86.     test_labels=one_hot(test_labels)
  88.     # 建立模型
  89.     # model = mnist_net(input_shape=(28,28))
  90.     model=mnist_cnn(input_shape=(28,28,1))
  91.     model.compile(optimizer=tf.train.AdamOptimizer(),loss="categorical_crossentropy",metrics=['accuracy'])
  92.     model.fit(x=train_images,y=train_labels,epochs=5)
  94.     test_loss,test_acc=model.evaluate(x=test_images,y=test_labels)
  95.     print("Test Accuracy %.2f"%test_acc)
  97.     # 开始预测
  98.     cnt=0
  99.     predictions=model.predict(test_images)
  100.     for i in range(len(test_images)):
  101.         target=np.argmax(predictions[i])
  102.         label=np.argmax(test_labels[i])
  103.         if target==label:
  104.             cnt +=1
  105.     print("correct prediction of total : %.2f"%(cnt/len(test_images)))
  107.     model.save('mnist-model.h5')
  109. if __name__=="__main__":
  110.     mnist_path = 'D:/MyGit/tensorflow-yolov3/data/mnist.npz'
  111.     train_images, train_labels, test_images, test_labels=get_train_val(mnist_path)
  112.     # show_mnist(train_images, train_labels)
  113.     trian_model(train_images, train_labels, test_images, test_labels)

2.构建高级模型

2.1 函数式 API

tf.keras.Sequential 模型是层的简单堆叠，无法表示任意模型。使用 Keras 函数式 API 可以构建复杂的模型拓扑，例如：

多输入模型，
多输出模型，
具有共享层的模型（同一层被调用多次），
具有非序列数据流的模型（例如，剩余连接）

使用函数式 API 构建的模型具有以下特征：

层实例可调用并返回张量。
输入张量和输出张量用于定义 tf.keras.Model 实例。
此模型的训练方式和 Sequential 模型一样。

以下示例使用函数式 API 构建一个简单的全连接网络：

  1. inputs = keras.Input(shape=(32,))  # Returns a placeholder tensor
  2. # A layer instance is callable on a tensor, and returns a tensor.
  3. x = keras.layers.Dense(64, activation='relu')(inputs)
  4. x = keras.layers.Dense(64, activation='relu')(x)
  5. predictions = keras.layers.Dense(10, activation='softmax')(x)
  7. # Instantiate the model given inputs and outputs.
  8. model = keras.Model(inputs=inputs, outputs=predictions)
  10. # The compile step specifies the training configuration.
  11. model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
  12.               loss='categorical_crossentropy',
  13.               metrics=['accuracy'])
  15. # Trains for 5 epochs
  16. model.fit(data, labels, batch_size=32, epochs=5)

2.2 搭建mnist手写数字识别网络（函数式 API）

  1. def mnist_cnn():
  2.     """
  3.     使用keras定义mnist模型
  4.     """
  5.     # define a truncated_normal initializer
  6.     tn_init = keras.initializers.truncated_normal(0, 0.1, SEED, dtype=tf.float32)
  7.     # define a constant initializer
  8.     const_init = keras.initializers.constant(0.1, tf.float32)
  9.     # define a L2 regularizer
  10.     l2_reg = keras.regularizers.l2(5e-4)
  12.     """ 
  13.     输入占位符。如果输入图像的shape是(28, 28, 1)，输入的一批图像(16张图)的shape
  14.     是(16, 28, 28, 1)；那么，在定义Input时，shape参数只需要一张图像的大小，也就
  15.     是(28, 28, 1)，而不是(16, 28, 28, 1)。
  16.     input placeholder. the Input's parameter shape should be a image's 
  17.     shape (28, 28, 1) rather than a batch of image's shape (16, 28, 28, 1).
  18.     """
  19.     # inputs: shape(None, 28, 28, 1)
  20.     inputs = layers.Input(shape=(IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS), dtype=tf.float32)
  22.     """
  23.     卷积，输出shape为(None, 28,18,32)。Conv2D的第一个参数为卷积核个数；第二个参数为卷积
  24.     核大小，和tensorflow不同的是，卷积核的大小只需指定卷积窗口的大小，例如在tensorflow中，
  25.     卷积核的大小为(BATCH_SIZE, 5, 5, 1)，那么在Keras中，只需指定卷积窗口的大小(5, 5)，
  26.     最后一维的大小会根据之前输入的形状自动推算，假如上一层的shape为(None, 28, 28, 1)，那
  27.     么最后一维的大小为1；第三个参数为strides，和上一个参数同理。其他参数可查阅Keras的官方文档。
  28.     """
  29.     # conv1: shape(None, 28, 28, 32)
  30.     conv1 = layers.Conv2D(32, (5, 5), strides=(1, 1), padding='same',
  31.                           activation='relu', use_bias=True,
  32.                           kernel_initializer=tn_init, name='conv1')(inputs)
  33.     # pool1: shape(None, 14, 14, 32)
  34.     pool1 = layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same', name='pool1')(conv1)
  35.     # conv2: shape(None, 14, 14, 64)
  36.     conv2 = layers.Conv2D(64, (5, 5), strides=(1, 1), padding='same',
  37.                           activation='relu', use_bias=True,
  38.                           kernel_initializer=tn_init,
  39.                           bias_initializer=const_init, name='conv2')(pool1)
  40.     # pool2: shape(None, 7, 7, 64)
  41.     pool2 = layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same', name='pool2')(conv2)
  42.     # flatten: shape(None, 3136)
  43.     flatten = layers.Flatten(name='flatten')(pool2)
  44.     # fc1: shape(None, 512)
  45.     fc1 = layers.Dense(512, 'relu', True, kernel_initializer=tn_init,
  46.                        bias_initializer=const_init, kernel_regularizer=l2_reg,
  47.                        bias_regularizer=l2_reg, name='fc1')(flatten)
  48.     # dropout
  49.     dropout1 = layers.Dropout(0.5, seed=SEED)(fc1)
  50.     # dense2: shape(None, 10)
  51.     fc2 = layers.Dense(NUM_LABELS, activation=None, use_bias=True,
  52.                        kernel_initializer=tn_init, bias_initializer=const_init, name='fc2',
  53.                        kernel_regularizer=l2_reg, bias_regularizer=l2_reg)(dropout1)
  54.     # softmax: shape(None, 10)
  55.     softmax = layers.Softmax(name='softmax')(fc2)
  56.     # make new model
  57.     model = keras.Model(inputs=inputs, outputs=softmax, name='nmist')
  58.     return model

2.3 完整的训练代码

  1. # -*-coding: utf-8 -*-
  2. """
  3.     @Project: tensorflow-yolov3
  4.     @File   : mnist_cnn2.py
  5.     @Author : panjq
  6.     @E-mail : pan_jinquan@163.com
  7.     @Date   : 2019-01-31 10:59:33
  8. """
  10. # 从tensorflow里导入keras和keras.layer
  11. from tensorflow import keras
  12. from tensorflow.keras import layers
  13. import tensorflow as tf
  14. import matplotlib.pyplot as plt
  15. import numpy as np
  16. mnist=keras.datasets.mnist
  18. # 图像的大小
  19. IMAGE_SIZE = 28
  20. # 图像的通道数，为1,即为灰度图像
  21. NUM_CHANNELS = 1
  22. # 图像想素值的范围
  23. PIXEL_DEPTH = 255
  24. # 分类数目，0~9总共有10类
  25. NUM_LABELS = 10
  26. # 验证集大小
  27. VALIDATION_SIZE = 5000  # Size of the validation set.
  28. # 种子
  29. SEED = 66478  # Set to None for random seed.
  30. # 批次大小
  31. BATCH_SIZE = 64
  32. # 训练多少个epoch
  33. NUM_EPOCHS = 10
  34. EVAL_BATCH_SIZE = 64
  36. def mnist_cnn():
  37.     """
  38.     使用keras定义mnist模型
  39.     """
  40.     # define a truncated_normal initializer
  41.     tn_init = keras.initializers.truncated_normal(0, 0.1, SEED, dtype=tf.float32)
  42.     # define a constant initializer
  43.     const_init = keras.initializers.constant(0.1, tf.float32)
  44.     # define a L2 regularizer
  45.     l2_reg = keras.regularizers.l2(5e-4)
  47.     """ 
  48.     输入占位符。如果输入图像的shape是(28, 28, 1)，输入的一批图像(16张图)的shape
  49.     是(16, 28, 28, 1)；那么，在定义Input时，shape参数只需要一张图像的大小，也就
  50.     是(28, 28, 1)，而不是(16, 28, 28, 1)。
  51.     input placeholder. the Input's parameter shape should be a image's 
  52.     shape (28, 28, 1) rather than a batch of image's shape (16, 28, 28, 1).
  53.     """
  54.     # inputs: shape(None, 28, 28, 1)
  55.     inputs = layers.Input(shape=(IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS), dtype=tf.float32)
  57.     """
  58.     卷积，输出shape为(None, 28,18,32)。Conv2D的第一个参数为卷积核个数；第二个参数为卷积
  59.     核大小，和tensorflow不同的是，卷积核的大小只需指定卷积窗口的大小，例如在tensorflow中，
  60.     卷积核的大小为(BATCH_SIZE, 5, 5, 1)，那么在Keras中，只需指定卷积窗口的大小(5, 5)，
  61.     最后一维的大小会根据之前输入的形状自动推算，假如上一层的shape为(None, 28, 28, 1)，那
  62.     么最后一维的大小为1；第三个参数为strides，和上一个参数同理。其他参数可查阅Keras的官方文档。
  63.     """
  64.     # conv1: shape(None, 28, 28, 32)
  65.     conv1 = layers.Conv2D(32, (5, 5), strides=(1, 1), padding='same',
  66.                           activation='relu', use_bias=True,
  67.                           kernel_initializer=tn_init, name='conv1')(inputs)
  68.     # pool1: shape(None, 14, 14, 32)
  69.     pool1 = layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same', name='pool1')(conv1)
  70.     # conv2: shape(None, 14, 14, 64)
  71.     conv2 = layers.Conv2D(64, (5, 5), strides=(1, 1), padding='same',
  72.                           activation='relu', use_bias=True,
  73.                           kernel_initializer=tn_init,
  74.                           bias_initializer=const_init, name='conv2')(pool1)
  75.     # pool2: shape(None, 7, 7, 64)
  76.     pool2 = layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='same', name='pool2')(conv2)
  77.     # flatten: shape(None, 3136)
  78.     flatten = layers.Flatten(name='flatten')(pool2)
  79.     # fc1: shape(None, 512)
  80.     fc1 = layers.Dense(512, 'relu', True, kernel_initializer=tn_init,
  81.                        bias_initializer=const_init, kernel_regularizer=l2_reg,
  82.                        bias_regularizer=l2_reg, name='fc1')(flatten)
  83.     # dropout
  84.     dropout1 = layers.Dropout(0.5, seed=SEED)(fc1)
  85.     # dense2: shape(None, 10)
  86.     fc2 = layers.Dense(NUM_LABELS, activation=None, use_bias=True,
  87.                        kernel_initializer=tn_init, bias_initializer=const_init, name='fc2',
  88.                        kernel_regularizer=l2_reg, bias_regularizer=l2_reg)(dropout1)
  89.     # softmax: shape(None, 10)
  90.     softmax = layers.Softmax(name='softmax')(fc2)
  91.     # make new model
  92.     model = keras.Model(inputs=inputs, outputs=softmax, name='nmist')
  93.     return model
  95. def get_train_val(mnist_path):
  96.     # mnist下载地址：https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
  97.     (train_images, train_labels), (test_images, test_labels) = mnist.load_data(mnist_path)
  98.     print("train_images nums:{}".format(len(train_images)))
  99.     print("test_images nums:{}".format(len(test_images)))
  100.     return train_images, train_labels, test_images, test_labels
  102. def show_mnist(images,labels):
  103.     for i in range(25):
  104.         plt.subplot(5,5,i+1)
  105.         plt.xticks([])
  106.         plt.yticks([ ])
  107.         plt.grid(False)
  108.         plt.imshow(images[i],cmap=plt.cm.gray)
  109.         plt.xlabel(str(labels[i]))
  110.     plt.show()
  112. def one_hot(labels):
  113.     onehot_labels=np.zeros(shape=[len(labels),10])
  114.     for i in range(len(labels)):
  115.         index=labels[i]
  116.         onehot_labels[i][index]=1
  117.     return onehot_labels
  119. def trian_model(train_images,train_labels,test_images,test_labels):
  120.     # re-scale to 0~1.0之间
  121.     train_images=train_images/255.0
  122.     test_images=test_images/255.0
  123.     # mnist数据转换为四维
  124.     train_images=np.expand_dims(train_images,axis = 3)
  125.     test_images=np.expand_dims(test_images,axis = 3)
  126.     print("train_images :{}".format(train_images.shape))
  127.     print("test_images :{}".format(test_images.shape))
  129.     train_labels=one_hot(train_labels)
  130.     test_labels=one_hot(test_labels)
  132.     # 建立模型
  133.     model=mnist_cnn()
  134.     model.compile(optimizer=tf.train.AdamOptimizer(),loss="categorical_crossentropy",metrics=['accuracy'])
  135.     model.fit(x=train_images,y=train_labels,epochs=5)
  137.     test_loss,test_acc=model.evaluate(x=test_images,y=test_labels)
  138.     print("Test Accuracy %.2f"%test_acc)
  140.     # 开始预测
  141.     cnt=0
  142.     predictions=model.predict(test_images)
  143.     for i in range(len(test_images)):
  144.         target=np.argmax(predictions[i])
  145.         label=np.argmax(test_labels[i])
  146.         if target==label:
  147.             cnt +=1
  148.     print("correct prediction of total : %.2f"%(cnt/len(test_images)))
  149.     model.save('mnist-model.h5')
  151. if __name__=="__main__":
  152.     mnist_path = 'D:/MyGit/tensorflow-yolov3/data/mnist.npz'
  153.     train_images, train_labels, test_images, test_labels=get_train_val(mnist_path)
  154.     # show_mnist(train_images, train_labels)
  155.     trian_model(train_images, train_labels, test_images, test_labels)

3. tf.keras高级应用：回调 tf.keras.callbacks.Callback

回调是传递给模型的对象，用于在训练期间自定义该模型并扩展其行为。您可以编写自定义回调，也可以使用包含以下方法的内置 tf.keras.callbacks：

  1. tf.keras.callbacks.ModelCheckpoint：定期保存模型的检查点。
  2. tf.keras.callbacks.LearningRateScheduler：动态更改学习速率。
  3. tf.keras.callbacks.EarlyStopping：在验证效果不再改进时中断训练。
  4. tf.keras.callbacks.TensorBoard：使用 TensorBoard 监控模型的行为。

要使用 tf.keras.callbacks.Callback，请将其传递给模型的 fit 方法：

  1. callbacks = [
  2.   # Interrupt training if `val_loss` stops improving for over 2 epochs
  3.   keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
  4.   # Write TensorBoard logs to `./logs` directory
  5.   keras.callbacks.TensorBoard(log_dir='./logs')
  6. ]
  7. model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
  8.           validation_data=(val_data, val_targets))

将mnist训练代码增加回调打印模型的信息：

  1. def trian_model(train_images,train_labels,test_images,test_labels):
  2.     # re-scale to 0~1.0之间
  3.     train_images=train_images/255.0
  4.     test_images=test_images/255.0
  5.     # mnist数据转换为四维
  6.     train_images=np.expand_dims(train_images,axis = 3)
  7.     test_images=np.expand_dims(test_images,axis = 3)
  8.     print("train_images :{}".format(train_images.shape))
  9.     print("test_images :{}".format(test_images.shape))
  11.     train_labels=one_hot(train_labels)
  12.     test_labels=one_hot(test_labels)
  14.     # 建立模型
  15.     model=mnist_cnn()
  17.     # 打印模型的信息
  18.     model.summary()
  19.     # 编译模型；第一个参数是优化器；第二个参数为loss，因为是多元分类问题，固为
  20.     # 'categorical_crossentropy'；第三个参数为metrics，就是在训练的时候需
  21.     # 要监控的指标列表。
  22.     # compile model
  23.     model.compile(optimizer=tf.train.AdamOptimizer(),loss="categorical_crossentropy",metrics=['accuracy'])
  24.     # model.compile(optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, decay=1e-5),loss='categorical_crossentropy', metrics=['accuracy'])
  26.     # 设置回调
  27.     # setting callbacks
  28.     callbacks = [
  29.         # 把TensorBoard的日志写入文件夹'./logs'
  30.         # write TensorBoard' logs to directory 'logs'
  31.         keras.callbacks.TensorBoard(log_dir='./logs'),
  32.     ]
  34.     # 开始训练
  35.     # start training
  36.     model.fit(train_images, train_labels, BATCH_SIZE, epochs=5,
  37.               validation_data=(test_images, test_labels), callbacks=callbacks)
  39.     # evaluate
  40.     print('', 'evaluating on test sets...')
  41.     loss, accuracy = model.evaluate(test_images, test_labels)
  42.     print('test loss:', loss)
  43.     print('test Accuracy:', accuracy)
  45.     # save model
  46.     model.save('mnist-model.h5')

4. tf.keras高级应用：自定义层tf.keras.layers.Layer

通过对 tf.keras.layers.Layer 进行子类化并实现以下方法来创建自定义层：

build：创建层的权重。使用 add_weight 方法添加权重。
call：定义前向传播。
compute_output_shape：指定在给定输入形状的情况下如何计算层的输出形状。
或者，可以通过实现 get_config 方法和 from_config 类方法序列化层。

下面是一个使用核矩阵实现输入 matmul 的自定义层示例：

  1. class MyLayer(keras.layers.Layer):
  3.   def __init__(self, output_dim, **kwargs):
  4.     self.output_dim = output_dim
  5.     super(MyLayer, self).__init__(**kwargs)
  7.   def build(self, input_shape):
  8.     shape = tf.TensorShape((input_shape[1], self.output_dim))
  9.     # Create a trainable weight variable for this layer.
  10.     self.kernel = self.add_weight(name='kernel',
  11.                                   shape=shape,
  12.                                   initializer='uniform',
  13.                                   trainable=True)
  14.     # Be sure to call this at the end
  15.     super(MyLayer, self).build(input_shape)
  17.   def call(self, inputs):
  18.     return tf.matmul(inputs, self.kernel)
  20.   def compute_output_shape(self, input_shape):
  21.     shape = tf.TensorShape(input_shape).as_list()
  22.     shape[-1] = self.output_dim
  23.     return tf.TensorShape(shape)
  25.   def get_config(self):
  26.     base_config = super(MyLayer, self).get_config()
  27.     base_config['output_dim'] = self.output_dim
  29.   @classmethod
  30.   def from_config(cls, config):
  31.     return cls(**config)
  33. # Create a model using the custom layer
  34. model = keras.Sequential([MyLayer(10),
  35.                           keras.layers.Activation('softmax')])
  37. # The compile step specifies the training configuration
  38. model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
  39.               loss='categorical_crossentropy',
  40.               metrics=['accuracy'])
  42. # Trains for 5 epochs.
  43. model.fit(data, targets, batch_size=32, epochs=5)

发表评论

表情：
评论列表 （有 0 条评论，568人围观）

还没有评论，来说两句吧...

相关阅读