绘制训练集准确度曲线和失函数曲线pytorch代码

### 回答1：
以下是绘制训练集准确度曲线和损失函数曲线的 PyTorch 代码：

import matplotlib.pyplot as plt
import numpy as np

# 训练集准确度和损失函数数据
train_acc = [0.6, 0.7, 0.8, 0.85, 0.9, 0.92, 0.94, 0.95, 0.96, 0.97]
train_loss = [1.2, 1.0, 0.8, 0.6, 0.5, 0.4, 0.3, 0.25, 0.2, 0.15]

# 绘制训练集准确度曲线
plt.plot(np.arange(len(train_acc)), train_acc)
plt.title('Training Accuracy Curve')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.show()

# 绘制损失函数曲线
plt.plot(np.arange(len(train_loss)), train_loss)
plt.title('Training Loss Curve')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.show()

希望这个代码对你有所帮助！

### 回答2：
在PyTorch中，可以使用Matplotlib库来绘制训练集准确度曲线和损失函数曲线。下面是一个示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt


# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc = nn.Linear(10, 2)
    
    def forward(self, x):
        x = self.fc(x)
        return x


# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)

# 初始化训练集准确度和损失函数列表
train_accuracy = []
losses = []

# 训练模型
for epoch in range(100):
    optimizer.zero_grad()
    output = net(input_data)  # 假设input_data为输入数据
    loss = criterion(output, target)  # 假设target为目标数据
    loss.backward()
    optimizer.step()
    
    # 计算准确度和记录损失函数值
    _, predicted = torch.max(output, 1)
    accuracy = (predicted == target).sum().item() / target.size(0)
    train_accuracy.append(accuracy)
    losses.append(loss.item())

# 绘制训练集准确度曲线和损失函数曲线
plt.plot(train_accuracy, label='Train Accuracy')
plt.plot(losses, label='Loss')
plt.xlabel('Epoch')
plt.legend()
plt.show()

在上述代码中，我们首先定义了一个简单的神经网络模型，接着定义了损失函数和优化器。然后我们使用一个循环来迭代训练模型，并在每个epoch中计算训练集的准确度和损失函数值，将其分别保存到`train_accuracy`和`losses`列表中。最后，我们使用Matplotlib库来绘制训练集准确度曲线和损失函数曲线。

### 回答3：
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 定义模型
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__()
self.fc = nn.Linear(1, 1)

def forward(self, x):
out = self.fc(x)
return out

# 创建训练集
x_train = torch.tensor([[1.0], [2.0], [3.0], [4.0], [5.0]])
y_train = torch.tensor([[2.0], [4.0], [6.0], [8.0], [10.0]])

# 初始化模型、损失函数和优化器
model = Model()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型并记录准确度和损失函数值
num_epochs = 100
train_acc = []
train_loss = []

for epoch in range(num_epochs):
# 前向传播
outputs = model(x_train)
loss = criterion(outputs, y_train)

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

# 计算准确度和损失函数值
predicted = model(x_train)
acc = torch.mean(torch.abs(predicted - y_train) / y_train)
train_acc.append(acc.item())
train_loss.append(loss.item())

# 绘制训练集准确度曲线
plt.plot(range(num_epochs), train_acc)
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Training Accuracy Curve')
plt.show()

# 绘制损失函数曲线
plt.plot(range(num_epochs), train_loss)
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Training Loss Curve')
plt.show()