tensorflow2.0实现复杂神经网络(多输入多输出nn，Resnet)

常见的‘融合'操作

复杂神经网络模型的实现离不开"融合"操作。常见融合操作如下：

（1）求和，求差

1. # 求和
2. layers.Add(inputs)
3. # 求差
4. layers.Subtract(inputs)

inputs: 一个输入张量的列表（列表大小至少为 2）,列表的shape必须一样才能进行求和(求差)操作。

例子：

1. input1 = keras.layers.Input(shape=(16,))
2. x1 = keras.layers.Dense(8, activation='relu')(input1)
3. input2 = keras.layers.Input(shape=(32,))
4. x2 = keras.layers.Dense(8, activation='relu')(input2)
5. added = keras.layers.add([x1, x2])
6.  
7. out = keras.layers.Dense(4)(added)
8. model = keras.models.Model(inputs=[input1, input2], outputs=out)

（2）乘法

1. # 输入张量的逐元素乘积(对应位置元素相乘，输入维度必须相同)
2. layers.multiply(inputs)
3. # 输入张量样本之间的点积
4. layers.dot(inputs, axes, normalize=False)

dot即矩阵乘法，例子1：

1. x = np.arange(10).reshape(1, 5, 2)
2.  
3. y = np.arange(10, 20).reshape(1, 2, 5)
4.  
5. # 三维的输入做dot通常像这样指定axes,表示矩阵的第一维度和第二维度参与矩阵乘法，第0维度是batchsize
6. tf.keras.layers.Dot(axes=(1, 2))([x, y])
7. # 输出如下：
8. <tf.Tensor: shape=(1, 2, 2), dtype=int64, numpy=
9. array([[[260, 360],
10. [320, 445]]])>

例子2：

1. x1 = tf.keras.layers.Dense(8)(np.arange(10).reshape(5, 2))
2. x2 = tf.keras.layers.Dense(8)(np.arange(10, 20).reshape(5, 2))
3. dotted = tf.keras.layers.Dot(axes=1)([x1, x2])
4. dotted.shape
5. TensorShape([5, 1])

（3）联合：

1. # 所有输入张量通过 axis 轴串联起来的输出张量。
2. layers.add(inputs,axis=-1)

• inputs: 一个列表的输入张量（列表大小至少为 2）。
• axis: 串联的轴。

例子：

1. x1 = tf.keras.layers.Dense(8)(np.arange(10).reshape(5, 2))
2. x2 = tf.keras.layers.Dense(8)(np.arange(10, 20).reshape(5, 2))
3. concatted = tf.keras.layers.Concatenate()([x1, x2])
4. concatted.shape
5. TensorShape([5, 16])

（4）统计操作

求均值layers.Average()

1. input1 = tf.keras.layers.Input(shape=(16,))
2. x1 = tf.keras.layers.Dense(8, activation='relu')(input1)
3. input2 = tf.keras.layers.Input(shape=(32,))
4. x2 = tf.keras.layers.Dense(8, activation='relu')(input2)
5. avg = tf.keras.layers.Average()([x1, x2])
6. # x_1 x_2 的均值作为输出
7. print(avg)
8. # <tf.Tensor 'average/Identity:0' shape=(None, 8) dtype=float32>
9.  
10. out = tf.keras.layers.Dense(4)(avg)
11. model = tf.keras.models.Model(inputs=[input1, input2], outputs=out)

layers.Maximum()用法相同。

具有多个输入和输出的模型

假设要构造这样一个模型：

（1）模型具有以下三个输入

工单标题（文本输入），工单的文本正文（文本输入），以及用户添加的任何标签（分类输入）

（2）模型将具有两个输出：

• 介于 0 和 1 之间的优先级分数（标量 Sigmoid 输出）
• 应该处理工单的部门（部门范围内的 Softmax 输出）。

模型大概长这样：

接下来开始创建这个模型。

（1）模型的输入

1. num_tags = 12
2. num_words = 10000
3. num_departments = 4
4.  
5. title_input = keras.Input(shape=(None,), name="title") # Variable-length sequence of ints
6. body_input = keras.Input(shape=(None,), name="body") # Variable-length sequence of ints
7. tags_input = keras.Input(shape=(num_tags,), name="tags") # Binary vectors of size `num_tags`

（2）将输入的每一个词进行嵌入成64-dimensional vector

1. title_features = layers.Embedding(num_words,64)(title_input)
2. body_features = layers.Embedding(num_words,64)(body_input)

（3）处理结果输入LSTM模型，得到 128-dimensional vector

1. title_features = layers.LSTM(128)(title_features)
2. body_features = layers.LSTM(32)(body_features)

（4）concatenate融合所有的特征

1. x = layers.concatenate([title_features, body_features, tags_input])

（5）模型的输出

1. # 输出1，回归问题
2. priority_pred = layers.Dense(1,name="priority")(x)
3.  
4. # 输出2，分类问题
5. department_pred = layers.Dense(num_departments,name="department")(x)

（6）定义模型

1. model = keras.Model(
2. inputs=[title_input, body_input, tags_input],
3. outputs=[priority_pred, department_pred],
4. )

（7）模型编译

编译此模型时，可以为每个输出分配不同的损失。甚至可以为每个损失分配不同的权重，以调整其对总训练损失的贡献。

1. model.compile(
2. optimizer=keras.optimizers.RMSprop(1e-3),
3. loss={
4. "priority": keras.losses.BinaryCrossentropy(from_logits=True),
5. "department": keras.losses.CategoricalCrossentropy(from_logits=True),
6. },
7. loss_weights=[1.0, 0.2],
8. )

（8）模型的训练

1. # Dummy input data
2. title_data = np.random.randint(num_words, size=(1280, 10))
3. body_data = np.random.randint(num_words, size=(1280, 100))
4. tags_data = np.random.randint(2, size=(1280, num_tags)).astype("float32")
5.  
6. # Dummy target data
7. priority_targets = np.random.random(size=(1280, 1))
8. dept_targets = np.random.randint(2, size=(1280, num_departments))
9.  
10. # 通过字典的形式将数据fit到模型
11. model.fit(
12. {"title": title_data, "body": body_data, "tags": tags_data},
13. {"priority": priority_targets, "department": dept_targets},
14. epochs=2,
15. batch_size=32,
16. )

ResNet 模型

通过add来实现融合操作，模型的基本结构如下：

1. # 实现第一个块
2. _input = keras.Input(shape=(32,32,3))
3. x = layers.Conv2D(32,3,activation='relu')(_input)
4. x = layers.Conv2D(64,3,activation='relu')(x)
5. block1_output = layers.MaxPooling2D(3)(x)
6.  
7. # 实现第二个块
8. x = layers.Conv2D(64,3,padding='same',activation='relu')(block1_output)
9. x = layers.Conv2D(64,3,padding='same',activation='relu')(x)
10. block2_output = layers.add([x,block1_output])
11.  
12. # 实现第三个块
13. x = layers.Conv2D(64, 3, activation="relu", padding="same")(block2_output)
14. x = layers.Conv2D(64, 3, activation="relu", padding="same")(x)
15. block_3_output = layers.add([x, block2_output])
16.  
17. # 进入全连接层
18. x = layers.Conv2D(64,3,activation='relu')(block_3_output)
19. x = layers.GlobalAveragePooling2D()(x)
20. x = layers.Dense(256, activation="relu")(x)
21. x = layers.Dropout(0.5)(x)
22. outputs = layers.Dense(10)(x)

模型的定义与编译：

1. model = keras.Model(_input,outputs,name='resnet')
2.  
3. model.compile(
4. optimizer=keras.optimizers.RMSprop(1e-3),
5. loss='sparse_categorical_crossentropy',
6. metrics=["acc"],
7. )

模型的训练

1. (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
2. # 归一化
3. x_train = x_train.astype("float32") / 255
4. x_test = x_test.astype("float32") / 255
5. model.fit(tf.expand_dims(x_train,-1), y_train, batch_size=64, epochs=1, validation_split=0.2)

注：当loss = =keras.losses.CategoricalCrossentropy(from_logits=True)时，需对标签进行one-hot：

1. y_train = keras.utils.to_categorical(y_train, 10)

到此这篇关于tensorflow2.0实现复杂神经网络(多输入多输出nn，Resnet)的文章就介绍到这了,更多相关tensorflow2.0复杂神经网络内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/zhong_ddbb/article/details/108912753