动手学深度学习怎么高效入门？基础到进阶教材 + PyTorch 代码示例

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

# 生成模拟数据
x = torch.randn(, ) * 
y = x +  * torch.randn(, )

# 定义模型
class LinearRegression(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(, )  # 输入输出都是1维
    
    def forward(self, x):
        return self.linear(x)

model = LinearRegression()
criterion = nn.MSELoss()  # 均方误差损失
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降优化器

# 训练模型
for epoch in range():
    # 前向传播
    pred = model(x)
    loss = criterion(pred, y)
    
    # 反向传播和优化
    optimizer.zero_grad()  # 梯度清零
    loss.backward()  # 反向传播计算梯度
    optimizer.step()  # 更新参数
    
    if (epoch + ) %  == :
        print(f'Epoch [{epoch+}/1000], Loss: {loss.item():.4f}')

# 可视化结果
predicted = model(x).detach().numpy()
plt.scatter(x.numpy(), y.numpy(), label='Original data')
plt.plot(x.numpy(), predicted, 'r-', label='Fitted line')
plt.legend()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# 生成非线性可分的数据
X, y = make_moons(n_samples=, noise=0.1, random_state=)
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.float32).view(-, )

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=)

# 定义神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(, )  # 输入层到隐藏层
        self.layer2 = nn.Linear(, )  # 隐藏层到输出层
        self.activation = nn.ReLU()  # 激活函数
    
    def forward(self, x):
        x = self.activation(self.layer1(x))
        x = torch.sigmoid(self.layer2(x))  # 输出层用sigmoid激活，得到0-1之间的概率
        return x

model = SimpleNN()
criterion = nn.BCELoss()  # 二元交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.01)  # Adam优化器

# 训练模型
for epoch in range():
    # 前向传播
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch + ) %  == :
        # 计算准确率
        with torch.no_grad():
            predicted = outputs.round()
            accuracy = (predicted == y_train).float().mean()
        print(f'Epoch [{epoch+}/1000], Loss: {loss.item():.4f}, Accuracy: {accuracy:.4f}')