在深度学习领域,PyTorch和TensorFlow是两个非常流行的框架,它们各自有着独特的优势和特点。对于AI小白来说,掌握这两个框架是迈向深度学习高手的关键一步。本文将为你盘点PyTorch与TensorFlow的实战应用案例,帮助你更好地理解和应用这两个框架。
PyTorch实战案例
1. 图像分类
案例描述:使用PyTorch实现一个简单的图像分类器,对CIFAR-10数据集进行分类。
代码示例:
import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim
# 数据加载
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2)
# 网络结构
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(nn.functional.relu(self.conv1(x)))
x = self.pool(nn.functional.relu(self.conv2(x)))
x = torch.flatten(x, 1) # flatten all dimensions except batch
x = nn.functional.relu(self.fc1(x))
x = nn.functional.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# 训练
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
2. 生成对抗网络(GAN)
案例描述:使用PyTorch实现一个简单的GAN,生成手写数字图片。
代码示例:
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
import numpy as np
# 数据加载
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
# 网络结构
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.fc1 = nn.Linear(100, 256)
self.fc2 = nn.Linear(256, 512)
self.fc3 = nn.Linear(512, 28*28)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = torch.sigmoid(self.fc3(x))
x = x.view(-1, 1, 28, 28)
return x
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.fc1 = nn.Linear(28*28, 512)
self.fc2 = nn.Linear(512, 256)
self.fc3 = nn.Linear(256, 1)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = torch.sigmoid(self.fc3(x))
return x
# 实例化网络
generator = Generator()
discriminator = Discriminator()
# 损失函数和优化器
criterion = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=0.002)
optimizer_D = optim.Adam(discriminator.parameters(), lr=0.002)
# 训练
for epoch in range(100):
for i, (images, _) in enumerate(trainloader):
# 训练生成器
z = torch.randn(images.size(0), 100)
generated_images = generator(z)
g_loss = criterion(discriminator(generated_images), torch.ones_like(discriminator(generated_images)))
# 训练判别器
real_loss = criterion(discriminator(images), torch.ones_like(discriminator(images)))
fake_loss = criterion(discriminator(generated_images.detach()), torch.zeros_like(discriminator(generated_images.detach())))
d_loss = (real_loss + fake_loss) / 2
# 更新参数
optimizer_G.zero_grad()
g_loss.backward()
optimizer_G.step()
optimizer_D.zero_grad()
d_loss.backward()
optimizer_D.step()
if i % 100 == 99:
print(f"Epoch {epoch}, Iteration {i}, G Loss: {g_loss.item()}, D Loss: {d_loss.item()}")
TensorFlow实战案例
1. 卷积神经网络(CNN)
案例描述:使用TensorFlow实现一个简单的CNN,对MNIST数据集进行分类。
代码示例:
import tensorflow as tf
from tensorflow.keras import datasets, layers, models
# 数据加载
(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()
# 数据预处理
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
train_labels = train_labels.astype('int32')
test_labels = test_labels.astype('int32')
# 构建模型
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
# 添加全连接层
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))
# 编译模型
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
# 训练模型
model.fit(train_images, train_labels, epochs=5, batch_size=64)
# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)
2. 循环神经网络(RNN)
案例描述:使用TensorFlow实现一个简单的RNN,对时间序列数据进行分类。
代码示例:
import tensorflow as tf
from tensorflow.keras import layers, models
# 数据加载
import numpy as np
import pandas as pd
# 生成时间序列数据
data = pd.DataFrame(np.random.randn(1000, 1), columns=['value'])
data['value'] = data['value'].cumsum()
# 数据预处理
train_data = data.iloc[:800]
test_data = data.iloc[800:]
train_images = train_data.values.reshape((800, 1, 1))
train_labels = train_data.values[1:].reshape((800, 1, 1))
test_images = test_data.values.reshape((200, 1, 1))
test_labels = test_data.values[1:].reshape((200, 1, 1))
# 构建模型
model = models.Sequential()
model.add(layers.SimpleRNN(50, activation='relu', input_shape=(1, 1)))
model.add(layers.Dense(1))
# 编译模型
model.compile(optimizer='adam',
loss='mse')
# 训练模型
model.fit(train_images, train_labels, epochs=10, batch_size=32)
# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest loss:', test_loss)
通过以上案例,我们可以看到PyTorch和TensorFlow在深度学习领域的广泛应用。掌握这两个框架,可以帮助你更好地解决实际问题。希望本文能对你有所帮助!
