目录
一、深度学习基础
1.1 神经网络简介
神经网络模仿生物神经系统，由许多互联的神经元（人工神经元）组成。主要分为以下几部分：
神经网络通过调整各层之间的连接权重，学习数据中的模式和特征。
1.2 激活函数
激活函数引入非线性，使神经网络能够拟合复杂的函数。常用的激活函数包括：
import torch.nn.functional as F
# ReLU激活函数
x = torch.tensor([-1.0, 0.0, 1.0])
relu = F.relu(x)
print(relu) # tensor([0., 0., 1.])1.3 损失函数
损失函数用于衡量模型预测值与真实值的差距，是模型优化的目标。常见的损失函数包括：
# MSE Loss
mse_loss = nn.MSELoss()
output = torch.tensor([1.0, 2.0, 3.0])
target = torch.tensor([1.5, 2.5, 3.5])
loss = mse_loss(output, target)
print(loss) # tensor(0.2500)1.4 优化算法
# Adam优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
优化算法用于调整模型参数，以最小化损失函数。常见的优化算法包括：
二、PyTorch基础
2.1 PyTorch简介
PyTorch是一个开源的深度学习框架，具有以下特点：
-
import torch # 创建张量 x = torch.tensor([[1, 2], [3, 4]]) y = torch.tensor([[5, 6], [7, 8]]) # 张量运算 z = x + y print(z) # tensor([[ 6, 8], [10, 12]]) # 自动求导 x = torch.tensor(2.0, requires_grad=True) y = x**2 y.backward() print(x.grad) # tensor(4.)
2.2 张量操作
张量是PyTorch的基本数据结构，类似于Numpy的多维数组，但支持GPU加速。常见的张量操作包括创建、索引、运算和自动求导。
2.3 构建神经网络
在PyTorch中，神经网络可以通过继承nn.Module类来定义。模型的各层通过nn模块提供的预定义层（如nn.Linear、nn.Conv2d等）构建，forward方法定义了前向传播过程。
PyTorch中的神经网络可以通过继承nn.Module类来定义
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(1, 10)
self.fc2 = nn.Linear(10, 1)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
net = Net()
print(net)2.4训练模型
以一个简单的回归任务为例，介绍模型的训练过程
# 生成数据
x = torch.linspace(0, 10, 100).view(-1, 1)
y = 2 * x + 1 + torch.randn(x.size()) * 0.5
# 定义模型、损失函数和优化器
model = Net()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):
model.train()
optimizer.zero_grad()
outputs = model(x)
loss = criterion(outputs, y)
loss.backward()
optimizer.step()
# 打印模型参数
for param in model.parameters():
print(param.data)2.5 模型评估
模型训练完成后，需要对模型进行评估。常用的评估指标包括准确率、精确率、召回率等
# 生成测试数据
x_test = torch.linspace(0, 10, 100).view(-1, 1)
y_test = 2 * x_test + 1 + torch.randn(x_test.size()) * 0.5
# 预测
model.eval()
with torch.no_grad():
predictions = model(x_test)
# 可视化
import matplotlib.pyplot as plt
plt.scatter(x_test.numpy(), y_test.numpy(), label='True Data')
plt.plot(x_test.numpy(), predictions.numpy(), label='Predictions', color='red')
plt.legend()
plt.show()三、PyTorch实战
3.1 数据加载与预处理
PyTorch提供了torchvision和torchtext等库，用于处理常见的数据集。数据加载器（DataLoader）可以帮助我们高效地批量加载和预处理数据。
3.2 模型定义与训练
模型定义包括选择合适的层结构和激活函数。训练过程包括以下步骤：
3.3 模型评估与调优
训练完成后，需要对模型进行评估。常用的评估指标包括准确率、精确率、召回率和F1分数等。根据评估结果，可以调整模型结构、参数和训练策略，以提高模型性能。
3.4 模型保存与加载
训练好的模型可以保存下来，以便后续使用或部署。PyTorch提供了简单的接口来保存和加载模型，包括保存模型参数和完整模型结构。
四、深度学习的实际应用
4.1 图像分类
图像分类是计算机视觉中的一个基本任务。通过卷积神经网络（CNN）可以高效地提取图像特征并进行分类。经典的数据集包括MNIST、CIFAR-10和ImageNet等。
4.1.1 数据集
我们将使用MNIST数据集，这是一个手写数字的图像数据集。
from torchvision import datasets, transforms
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)4.1 .2构建模型
我们将构建一个简单的卷积神经网络（CNN）来进行图像分类。
class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.fc1 = nn.Linear(64*7*7, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = x.view(-1, 64*7*7)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
model = CNN()4.1.3 训练模型
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
num_epochs = 10
for epoch in range(num_epochs):
model.train()
for images, labels in train_loader:
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')4.1.4 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f'Accuracy: {100 * correct / total:.2f}%')4.1.5 可视化
# 取一些测试数据
images, labels = iter(test_loader).next()
outputs = model(images)
_, predicted = torch.max(outputs, 1)
# 显示图片和预测结果
fig = plt.figure(figsize=(10, 4))
for idx in np.arange(20):
ax = fig.add_subplot(2, 10, idx+1, xticks=[], yticks=[])
img = images[idx].numpy().squeeze()
ax.imshow(img, cmap='gray')
ax.set_title(f'{predicted[idx].item()}', color='green' if predicted[idx] == labels[idx] else 'red')
plt.show()4.1.6 模型保存与加载
在训练完模型后，我们可以将其保存下来以便后续使用。PyTorch提供了简单的接口来保存和加载模型。
# 保存模型
torch.save(model.state_dict(), 'cnn_model.pth')
# 加载模型
model = CNN()
model.load_state_dict(torch.load('cnn_model.pth'))4.2 自然语言处理（NLP）
在自然语言处理领域，深度学习用于文本分类、情感分析、机器翻译等任务。常用的模型包括循环神经网络（RNN）、长短期记忆网络（LSTM）和Transformer等。
import torchtext
from torchtext.data import Field, LabelField, TabularDataset, BucketIterator
# 数据预处理
TEXT = Field(tokenize='spacy', tokenizer_language='en_core_web_sm', lower=True)
LABEL = LabelField(dtype=torch.float)
datafields = [("text", TEXT), ("label", LABEL)]
train_data, test_data = TabularDataset.splits(
path="./data", train='train.csv', test='test.csv', format='csv', skip_header=True, fields=datafields)
TEXT.build_vocab(train_data, max_size=10000, vectors="glove.6B.100d")
LABEL.build_vocab(train_data)
train_iterator, test_iterator = BucketIterator.splits(
(train_data, test_data), batch_size=64, sort_within_batch=True, sort_key=lambda x: len(x.text), device='cuda')
# 构建模型
class RNN(nn.Module):
def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
super(RNN, self).__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.rnn = nn.LSTM(embedding_dim, hidden_dim)
self.fc = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
embedded = self.embedding(x)
output, (hidden, cell) = self.rnn(embedded)
hidden = torch.squeeze(hidden[-1, :, :])
return self.fc(hidden)
# 初始化模型
vocab_size = len(TEXT.vocab)
embedding_dim = 100
hidden_dim = 256
output_dim = 1
model = RNN(vocab_size, embedding_dim, hidden_dim, output_dim)
# 使用预训练的词向量
pretrained_embeddings = TEXT.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)
# 定义损失函数和优化器
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()
# 训练模型
model = model.to('cuda')
criterion = criterion.to('cuda')
num_epochs = 5
for epoch in range(num_epochs):
model.train()
for batch in train_iterator:
optimizer.zero_grad()
predictions = model(batch.text).squeeze(1)
loss = criterion(predictions, batch.label)
loss.backward()
optimizer.step()
# 评估模型
model.eval()
with torch.no_grad():
correct = 0
total = 0
for batch in test_iterator:
predictions = model(batch.text).squeeze(1)
rounded_preds = torch.round(torch.sigmoid(predictions))
correct += (rounded_preds == batch.label).float().sum()
total += batch.label.size(0)
accuracy = correct / total
print(f'Accuracy: {accuracy.item():.4f}')4.3 生成对抗网络（GAN）
生成对抗网络（GAN）通过生成器和判别器的对抗性训练，可以生成逼真的图像、文本和其他数据。GAN在图像生成、图像修复、数据增强等方面有广泛应用。
import torch
import torch.nn as nn
import torch.optim as optim
# 定义生成器
class Generator(nn.Module):
def __init__(self, input_dim, output_dim):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_dim, 128),
nn.ReLU(),
nn.Linear(128, output_dim),
nn.Tanh()
)
def forward(self, x):
return self.model(x)
# 定义判别器
class Discriminator(nn.Module):
def __init__(self, input_dim):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_dim, 128),
nn.LeakyReLU(0.2),
nn.Linear(128, 1),
nn.Sigmoid()
)
def forward(self, x):
return self.model(x)
# 初始化模型
latent_dim = 100
img_dim = 28 * 28
generator = Generator(latent_dim, img_dim)
discriminator = Discriminator(img_dim)
# 定义损失函数和优化器
adversarial_loss = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=0.0002)
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002)
# 训练GAN
num_epochs = 20000
for epoch in range(num_epochs):
# 训练判别器
real_imgs = torch.randn(64, img_dim) # 使用随机数据代替真实图像
valid = torch.ones(64, 1)
fake = torch.zeros(64, 1)
optimizer_D.zero_grad()
real_loss = adversarial_loss(discriminator(real_imgs), valid)
z = torch.randn(64, latent_dim)
gen_imgs = generator(z)
fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_D.step()
# 训练生成器
optimizer_G.zero_grad()
g_loss = adversarial_loss(discriminator(gen_imgs), valid)
g_loss.backward()
optimizer_G.step()
if epoch % 1000 == 0:
print(f'Epoch {epoch}, D loss: {d_loss.item()}, G loss: {g_loss.item()}')五、总结