import torch的使用指南

一、簡介

import torch是深度學習領域最為流行的Python庫之一。它是一個用於創建和運行深度神經網路的開源機器學習框架，同時也為GPU加速計算提供了便捷的介面。torch包含了眾多豐富的模塊和函數，可以在Tensor、autograd、nn、optim等方面，為深度學習應用提供全面的支持。在本篇文章中，我們將從使用入手，詳細闡述import torch的使用指南，並且通過幾個簡單示例，幫助讀者更好地理解如何使用該庫。

二、Tensor

Tensor是torch中最重要的數據類型之一。與NumPy中的ndarray類似，它能夠支持GPU加速，並且提供了大量的數學操作介面。通過Tensor，我們可以有效地實現各種神經網路結構，包括卷積、循環神經網路等。下面我們給出一個簡單的示例，以說明如何使用Tensor實現矩陣乘法。

import torch

x = torch.randn(3, 4)
y = torch.randn(4, 5)

z = torch.matmul(x, y)

print(z)

在上面的示例中，我們使用了randn函數生成兩個隨機矩陣x和y，分別為3×4和4×5的矩陣。隨後，我們使用matmul函數實現了矩陣乘法，並將結果保存在了變數z中。最後，我們將結果列印出來。正如我們所見，使用Tensor非常簡單方便。

三、autograd

autograd模塊是torch中自動求導的核心模塊，它能夠自動計算並記錄執行過的所有操作，並構建一張計算圖來進行求導。通過autograd，我們可以快速高效地進行模型優化，並得到高質量的結果。為了展示其應用，我們給出了在一元函數上求導數值的示例代碼。

import torch

x = torch.tensor([2.0], requires_grad=True)

y = 3*x**2 + 2*x + 1

y.backward()

print(x.grad)

在這個示例中，我們使用tensor函數創建了一個初始值為2.0的張量，並將requires_grad參數設置為True。這表示需要對這個張量求梯度。我們隨後使用這個張量計算函數y=3x^2+2x+1，並調用backward函數計算其梯度。最後，我們使用grad屬性得到了x的梯度。通過這個示例，我們可以看到，使用autograd非常簡單。

四、nn

nn模塊是torch中的神經網路模塊。它提供了各種內置的模型和函數，可以快速地創建和訓練神經網路模型。我們可以利用nn模塊構建自己的模型，並通過反向傳播演算法來計算梯度並進行優化。下面是一個使用nn模塊訓練MNIST數據集的示例代碼。

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms

# Hyper Parameters
input_size = 784
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# MNIST Dataset
train_dataset = dsets.MNIST(root='./data/', 
                            train=True, 
                            transform=transforms.ToTensor(),  
                            download=True)

test_dataset = dsets.MNIST(root='./data/', 
                           train=False, 
                           transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=batch_size, 
                                          shuffle=False)

# Logistic Regression Model
model = nn.Linear(input_size, num_classes)

# Loss and Optimizer
criterion = nn.CrossEntropyLoss()  
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  

# Training the Model
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        images = images.reshape(-1, 28*28)
        
        # Forward + Backward + Optimize
        optimizer.zero_grad()  
        outputs = model(images)  
        loss = criterion(outputs, labels)  
        loss.backward()  
        optimizer.step()  

        if (i+1) % 100 == 0:
            print ('Epoch [%d/%d], Step [%d/%d], Loss: %.4f' 
                   % (epoch+1, num_epochs, i+1, len(train_dataset)//batch_size, loss.item()))

# Testing the Model
correct = 0
total = 0
for images, labels in test_loader:
    images = images.reshape(-1, 28*28)
    outputs = model(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the model on the 10000 test images: %d %%' % (100 * correct / total))

在這個示例中，我們首先定義了MNIST數據集，並通過數據載入器將數據劃分為訓練集和測試集。接著我們定義了一個簡單的神經網路模型，並使用交叉熵損失函數進行優化。在訓練過程中，我們對訓練集進行批次訓練，並進行權重更新。在測試階段，我們計算模型在測試集上的準確率，並輸出結果。通過這個示例，我們可以看到，使用nn模塊可以快速方便地構建神經網路模型。

五、optim

optim模塊是torch中的優化模塊。它提供了各種優化演算法，包括隨機梯度下降、Adam等，可以快速高效地優化模型參數。下面是一個簡單的使用optim模塊進行優化的示例代碼。

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms

# Hyper Parameters
input_size = 784
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001

# MNIST Dataset
train_dataset = dsets.MNIST(root='./data/', 
                            train=True, 
                            transform=transforms.ToTensor(),  
                            download=True)

test_dataset = dsets.MNIST(root='./data/', 
                           train=False, 
                           transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=batch_size, 
                                          shuffle=False)

# Logistic Regression Model
model = nn.Linear(input_size, num_classes)

# Loss and Optimizer
criterion = nn.CrossEntropyLoss()  
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  

# Training the Model
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):  
        images = images.reshape(-1, 28*28)
        
        # Forward + Backward + Optimize
        optimizer.zero_grad()  
        outputs = model(images)  
        loss = criterion(outputs, labels)  
        loss.backward()  
        optimizer.step()  

        if (i+1) % 100 == 0:
            print ('Epoch [%d/%d], Step [%d/%d], Loss: %.4f' 
                   % (epoch+1, num_epochs, i+1, len(train_dataset)//batch_size, loss.item()))

# Testing the Model
correct = 0
total = 0
for images, labels in test_loader:
    images = images.reshape(-1, 28*28)
    outputs = model(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum()

print('Accuracy of the model on the 10000 test images: %d %%' % (100 * correct / total))

在這個示例中，我們首先定義了MNIST數據集，並通過數據載入器將數據劃分為訓練集和測試集。接著我們定義了一個簡單的神經網路模型，並使用交叉熵損失函數進行優化。在訓練過程中，我們對訓練集進行批次訓練，並使用Adam演算法對權重進行更新。在測試階段，我們計算模型在測試集上的準確率，並輸出結果。通過這個示例，我們可以看到，使用optim模塊可以快速高效地優化模型參數。