nn.Sequential与tensorflow的Sequential对比

nn.Sequential() 是 PyTorch 深度学习框架中的一个类，用于按顺序容器化模块。nn.Sequential 是一个有序的容器，它包含多个网络层，数据会按照在构造函数中传入顺序依次通过每个层。在 nn.Sequential 中，不需要定义 forward 方法，因为当你调用它时，会按照顺序调用每个子模块。

import torch  
import torch.nn as nn  
  
# 创建一个简单的神经网络  
model = nn.Sequential(  
    nn.Linear(784, 128),  # 输入层到隐藏层，784个输入节点，128个输出节点  
    nn.ReLU(),           # 激活函数  
    nn.Linear(128, 10)   # 隐藏层到输出层，128个输入节点，10个输出节点  
)  
  
# 创建一个随机的输入张量  
input_tensor = torch.randn(1, 784)  
  
# 将输入张量传递给模型  
output_tensor = model(input_tensor)  
  
print(output_tensor.size())  # 输出应为 torch.Size([1, 10])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import tensorflow as tf  
from tensorflow.keras.datasets import mnist  
from tensorflow.keras.models import Sequential  
from tensorflow.keras.layers import Dense, Flatten  
from tensorflow.keras.losses import SparseCategoricalCrossentropy  
from tensorflow.keras.optimizers import Adam  
  
# 加载MNIST数据集  
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()  
  
# 归一化像素值到0-1之间  
train_images = train_images / 255.0  
test_images = test_images / 255.0  
  
# 将图像的形状展平，以便可以输入到神经网络中  
train_images = train_images[..., tf.newaxis]  
test_images = test_images[..., tf.newaxis]  
  
# 创建Sequential模型  
model = Sequential([  
    Flatten(input_shape=(28, 28, 1)),  # 将28x28像素的图像展平为一维张量  
    Dense(128, activation='relu'),      # 全连接层，128个神经元，使用ReLU激活函数  
    Dense(10)                           # 输出层，10个神经元（对应10个数字类别）  
])  
  
# 编译模型  
model.compile(optimizer=Adam(),  
              loss=SparseCategoricalCrossentropy(from_logits=True),  
              metrics=['accuracy'])  
  
# 训练模型  
model.fit(train_images, train_labels, epochs=5)  
  
# 评估模型  
test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)  
  
print('\nTest accuracy:', test_acc)
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

self.conv 通常指的是类的一个属性，这个属性通常是一个卷积层（Convolutional Layer）

import torch  
import torch.nn as nn  
import torch.nn.functional as F  
  
class SimpleCNN(nn.Module):  
    def __init__(self):  
        super(SimpleCNN, self).__init__()  
        # 定义一个卷积层，输入通道数为3（例如RGB图像），输出通道数为16，卷积核大小为3x3  
        self.conv = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)  
        # 可以添加其他层...  
  
    def forward(self, x):  
        # 在前向传播中使用卷积层  
        x = self.conv(x)  
        # 可以添加其他操作，例如激活函数、池化等...  
        x = F.relu(x)  
        # 返回处理后的输出  
        return x  
  
# 创建模型实例  
model = SimpleCNN()  
  
# 假设我们有一个输入张量 input_tensor，其形状为 [batch_size, 3, height, width]  
# 我们可以将其传递给模型进行前向传播  
output_tensor = model(input_tensor)
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