Show List
Tutorials > Neural Networks > Implementing Neural Networks with PyTorch

Implementing Neural Networks with PyTorch

PyTorch is a popular open-source machine learning library for Python that is widely used for implementing neural networks. Here are some examples of how to implement neural networks with PyTorch:

  • Defining a basic neural network architecture
python
Copy code
import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 10)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = x.view(-1, 784)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
print(net)

In this example, we define a basic neural network architecture with three fully connected layers and a ReLU activation function. The forward method defines how data flows through the network, and the Net class inherits from the nn.Module class provided by PyTorch.

  • Training the neural network on a dataset
scss
Copy code
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms

transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.5,), (0.5,))])
train_set = datasets.MNIST(root='./data', train=True,
                           download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if i % 100 == 99:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

In this example, we train the previously defined neural network on the MNIST dataset using stochastic gradient descent (SGD) as the optimizer and cross-entropy loss as the loss function. We also define a data loader to load the data in batches, normalize the input data, and iterate over the training data for a specified number of epochs.

  • Saving and loading a trained model
scss
Copy code
PATH = './mnist_net.pth'
torch.save(net.state_dict(), PATH)

net = Net()
net.load_state_dict(torch.load(PATH))

Once a neural network has been trained, we can save its parameters to a file using the torch.save function. We can then load the trained parameters into a new instance of the neural network class using the torch.load function.

These are just a few examples of how to implement neural networks with PyTorch. PyTorch offers many more features and modules that can be used to build and train more complex networks, such as convolutional neural networks and recurrent neural networks.

    Leave a Comment

  • captcha text