pytorch 实现简单的卷积神经网络并训练

定义数据

import numpy as np

    # 定义特征和目标
    X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # 4 x 2 的矩阵，每一行表示一个数据点
    y = np.array([[0], [1], [1], [0]])  # 4 x 1 的矩阵，每一行表示一个目标

定义模型

# 定义模型
class MyNet(torch.nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.layer1 = torch.nn.Linear(2, 3)
        self.layer2 = torch.nn.Linear(3, 1)
        self.activation = torch.nn.Sigmoid()

    def forward(self, x):
        x = self.layer1(x)
        x = self.activation(x)
        x = self.layer2(x)
        x = self.activation(x)
        return x

定义损失函数和优化器

    model = MyNet()
    # 定义损失函数和优化器
    criterion = torch.nn.BCELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

训练

    #  训练模型
    X = torch.Tensor(X)
    y = torch.Tensor(y)

    for epoch in range(1000):
        #  前向传播
        y_pred = model(X)

        #  计算损失
        loss = criterion(y_pred, y)

        # 反向传播并优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if epoch % 100 == 0:
            print(f"Epoch {epoch}: Loss = {loss:.4f}")

在原始数据集上进行与预测

predictions = model(X)
print(predictions.detach().numpy())

完整代码

import numpy as np
import torch

print(torch.__version__)


# 定义模型
class MyNet(torch.nn.Module):
    def __init__(self):
        super(MyNet, self).__init__()
        self.layer1 = torch.nn.Linear(2, 3)
        self.layer2 = torch.nn.Linear(3, 1)
        self.activation = torch.nn.Sigmoid()

    def forward(self, x):
        x = self.layer1(x)
        x = self.activation(x)
        x = self.layer2(x)
        x = self.activation(x)
        return x


if __name__ == '__main__':

    # 定义特征和目标dingy
    X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  # 4 x 2 的矩阵，每一行表示一个数据点
    y = np.array([[0], [1], [1], [0]])  # 4 x 1 的矩阵，每一行表示一个目标

    model = MyNet()
    # 定义损失函数和优化器
    criterion = torch.nn.BCELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

    #  训练模型
    X = torch.Tensor(X)
    y = torch.Tensor(y)

    for epoch in range(1000):
        #  前向传播
        y_pred = model(X)

        #  计算损失
        loss = criterion(y_pred, y)

        # 反向传播并优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if epoch % 100 == 0:
            print(f"Epoch {epoch}: Loss = {loss:.4f}")

# 在数据集上进行预测
predictions = model(X)
print(predictions.detach().numpy())

'''在这个 PyTorch 实现中，首先定义了一个 NeuralNet 类来表示我们的神经网络模型。在 __init__ 方法中定义了两个全连接层，每个层都有一些隐藏单元和一个 Sigmoid 激活函数。

在 forward 方法中，将输入数据传递给第一层，然后应用 Sigmoid 激活函数。然后将输出传递给第二层，并再次应用 Sigmoid 激活函数。

接下来，定义了一个损失函数和优化器。使用二元交叉熵损失函数和 Adam 优化器。

然后，对模型进行训练。在每个 epoch 中，首先进行前向传播以计算预测输出。然后，计算损失并执行反向传播。最后，使用优化器来更新模型参数。

最后，在数据集上进行预测，并将预测打印到控制台中。注意，在 PyTorch 中，我们需要调用 detach() 方法来将张量从计算图中分离出来，然后再调用 numpy() 方法将其转换为 NumPy 数组。'''