How to conduct deep learning in PyTorch under CentOS

Using PyTorch for deep learning on CentOS system requires step-by-step operation:

1. PyTorch installation

You can choose Anaconda or pip to install PyTorch.

A. Anaconda installation

1. Download Anaconda: Download the Anaconda3 installation package for CentOS system from the official Anaconda website . Follow the installation wizard to complete the installation.

2. Create a virtual environment: Open the terminal, create a virtual environment named pytorch and activate:

    conda create -n pytorch python=3.8
   conda activated pytorch

3. Install PyTorch: In the activated pytorch environment, use conda to install PyTorch. If you need GPU acceleration, make sure you have CUDA and cuDNN installed and select the corresponding PyTorch version. The following command installs PyTorch containing CUDA 11.8 support:

    conda install pytorch torchvision torchaudio cudatoolkit=11.8 -c pytorch

4. Verify installation: Start the Python interactive environment, run the following code to verify that PyTorch is installed successfully, and check GPU availability:

    import torch
   print(torch.__version__)
   print(torch.cuda.is_available())

B. pip installation

1. Install pip: If your system does not have pip installed, please install it first:

    sudo yum install python3-pip

2. Install PyTorch: Use pip to install PyTorch and use Tsinghua University mirror source to speed up downloading:

    pip install torch torchvision torchaudio -f https://pypi.tuna.tsinghua.edu.cn/simple

3. Verify installation: Same as Anaconda method, run the following code to verify installation:

    import torch
   print(torch.__version__)
   print(torch.cuda.is_available())

2. Deep learning practice

Here is a simple MNIST handwritten numeric recognition example that demonstrates how to use PyTorch for deep learning:

1. Import library:

    import torch
   import torch.nn as nn
   import torch.optim as optim
   import torchvision
   import torchvision.transforms as transforms

2. Defining the model: This is a simple convolutional neural network (CNN):

    class SimpleCNN(nn.Module):
       def __init__(self):
           super(SimpleCNN, self).__init__()
           self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
           self.pool = nn.MaxPool2d(2, 2)
           self.fc1 = nn.Linear(32 * 14 * 14, 10) #Adjust the input dimension of the fully connected layer def forward(self, x):
           x = self.pool(torch.relu(self.conv1(x)))
           x = torch.flatten(x, 1) # Flatten x = self.fc1(x)
           Return x

3. Prepare the data: Download the MNIST dataset and preprocess it:

    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
   train_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
   test_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
   train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
   test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1000, shuffle=False)

4. Initialize the model, loss function, and optimizer:

    model = SimpleCNN()
   criteria = nn.CrossEntropyLoss()
   optimizer = optim.Adam(model.parameters(), lr=0.001) # Use Adam Optimizer

5. Training the model:

    epochs = 2
   for epoch in range(epochs):
       running_loss = 0.0
       for i, data in enumerate(train_loader, 0):
           inputs, labels = data
           optimizer.zero_grad()
           outputs = model(inputs)
           loss = criteria(outputs, labels)
           loss.backward()
           optimizer.step()
           running_loss = loss.item()
           if i % 100 == 99:
               print(f'[{epoch 1}, {i 1}] loss: {running_loss / 100:.3f}')
               running_loss = 0.0
   print('Finished Training')

6. Model evaluation:

    correct = 0
   total = 0
   with torch.no_grad():
       for data in test_loader:
           images, labels = data
           outputs = model(images)
           _, predicted = torch.max(outputs.data, 1)
           total = labels.size(0)
           correct = (predicted == labels).sum().item()
   
   print(f'Accuracy: {100 * correct / total}%')

This example provides a basic framework. You can modify the model structure, dataset, and hyperparameters according to your needs. Remember to create the ./data directory before running. This example uses the Adam optimizer and generally converges faster than SGD. The input size of the fully connected layer is also adjusted to suit the output after the pooling layer.

The above is the detailed content of How to conduct deep learning in PyTorch under CentOS. For more information, please follow other related articles on the PHP Chinese website!