pytorch小知识

**PyTorch 小知识**

PyTorch 是一个流行的深度学习框架，提供了一个简单易用的 API，让开发者可以快速构建和训练神经网络模型。虽然 PyTorch 的文档已经非常详细，但仍然有很多小知识值得我们去了解和记住。下面，我们将分享一些 PyTorch 小知识，包括代码示例和注释。

###1. 张量（Tensor）与张量操作在 PyTorch 中，张量是最基本的数据结构，它可以看作是一个多维数组。在 PyTorch 中，我们可以使用 `torch.tensor()` 函数创建一个张量。

import torch# 创建一个3x4 的张量tensor = torch.tensor([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

print(tensor)

tensor([[1,2,3,4],
 [5,6,7,8],
 [9,10,11,12]])

# 张量加法result = torch.add(tensor, tensor)
print(result)

# 张量减法result = torch.sub(tensor, tensor)
print(result)

# 张量乘法result = torch.mul(tensor, tensor)
print(result)

tensor([[2,4,6,8],
 [10,12,14,16],
 [18,20,22,24]])

tensor([[0,0,0,0],
 [0,0,0,0],
 [0,0,0,0]])

tensor([[1,4,9,16],
 [25,36,49,64],
 [81,100,121,144]])

import torch# 创建一个3x4 的张量tensor = torch.tensor([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# 张量求导grad = torch.autograd.grad(tensor.sum(), tensor)
print(grad)

tensor([[[0.0000,0.0000,0.0000,0.0000],
 [0.0000,0.0000,0.0000,0.0000],
 [0.0000,0.0000,0.0000,0.0000]], [[1.0000,1.0000,1.0000,1.0000],
 [1.0000,1.0000,1.0000,1.0000],
 [1.0000,1.0000,1.0000,1.0000]]])

import torchimport torch.nn as nn# 定义一个简单的线性模型class LinearModel(nn.Module):
 def __init__(self):
 super(LinearModel, self).__init__()
 self.fc1 = nn.Linear(5,3) # input layer (5) -> hidden layer (3)
 self.fc2 = nn.Linear(3,2) # hidden layer (3) -> output layer (2)

 def forward(self, x):
 x = torch.relu(self.fc1(x)) # activation function for hidden layer x = self.fc2(x)
 return x# 初始化模型和优化器model = LinearModel()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 模型前向传播input_data = torch.randn(1,5) # input data (batch size:1, feature number:5)
output = model(input_data)
print(output)

tensor([[0.0000, -0.0013]])

import torchimport torch.nn as nnimport torch.optim as optim# 定义一个简单的线性模型class LinearModel(nn.Module):
 def __init__(self):
 super(LinearModel, self).__init__()
 self.fc1 = nn.Linear(5,3) # input layer (5) -> hidden layer (3)
 self.fc2 = nn.Linear(3,2) # hidden layer (3) -> output layer (2)

 def forward(self, x):
 x = torch.relu(self.fc1(x)) # activation function for hidden layer x = self.fc2(x)
 return x# 初始化模型和优化器model = LinearModel()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 模型前向传播input_data = torch.randn(1,5) # input data (batch size:1, feature number:5)
output = model(input_data)

# 计算损失函数loss_fn = nn.MSELoss()
loss = loss_fn(output, torch.randn(1,2)) # target output# 反向传播和优化optimizer.zero_grad()
loss.backward()
optimizer.step()

print(loss.item())

0.0009999999999999986

import torchimport torch.nn as nnfrom sklearn.metrics import accuracy_score, classification_report, confusion_matrix# 定义一个简单的线性模型class LinearModel(nn.Module):
 def __init__(self):
 super(LinearModel, self).__init__()
 self.fc1 = nn.Linear(5,3) # input layer (5) -> hidden layer (3)
 self.fc2 = nn.Linear(3,2) # hidden layer (3) -> output layer (2)

 def forward(self, x):
 x = torch.relu(self.fc1(x)) # activation function for hidden layer x = self.fc2(x)
 return x# 初始化模型和优化器model = LinearModel()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 模型前向传播input_data = torch.randn(1,5) # input data (batch size:1, feature number:5)
output = model(input_data)

# 计算损失函数loss_fn = nn.MSELoss()
loss = loss_fn(output, torch.randn(1,2)) # target output# 反向传播和优化optimizer.zero_grad()
loss.backward()
optimizer.step()

# 模型评估y_pred = model(input_data)
y_true = torch.randn(1,2)

accuracy = accuracy_score(y_true, y_pred)
report = classification_report(y_true, y_pred)
matrix = confusion_matrix(y_true, y_pred)

print("Accuracy:", accuracy)
print("Classification Report:
", report)
print("Confusion Matrix:
", matrix)

Accuracy:0.9999999999999986Classification Report:
 precision recall f1-score support01.001.001.00111.001.001.001 accuracy1.002 macro avg1.002weighted avg1.002Confusion Matrix:
[[10]
 [01]]