PyTorch实战：深度学习在艺术领域的应用

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torchvision import models, transforms
    from PIL import Image
    
    # 加载图像
    def load_image(image_path, device):
    image = Image.open(image_path)
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
    image = transform(image).unsqueeze(0).to(device)
    return image
    
    # 风格迁移
    def style_transfer(content_image_path, style_image_path, output_image_path, device):
    # 加载图像
    content_image = load_image(content_image_path, device)
    style_image = load_image(style_image_path, device)
    
    # 加载预训练的VGG-19模型
    vgg = models.vgg19(pretrained=True).features.to(device).eval()
    
    # 定义内容损失和风格损失
    content_loss = nn.MSELoss()
    style_loss = nn.MSELoss()
    
    # 定义生成图像并将其设置为可训练
    generated_image = content_image.clone().requires_grad_(True)
    
    # 定义优化器
    optimizer = optim.Adam([generated_image], lr=0.01)
    
    # 训练
    for step in range(500):
        # 提取特征表示
        content_features = vgg(content_image)
        style_features = vgg(style_image)
        generated_features = vgg(generated_image)
    
        # 计算内容损失
        content_loss_value = content_loss(generated_features, content_features)
    
        # 计算风格损失
        style_loss_value = style_loss(generated_features, style_features)
    
        # 计算总损失
        total_loss = content_loss_value + style_loss_value
    
        # 更新生成图像
        optimizer.zero_grad()
        total_loss.backward()
        optimizer.step()
    
    # 保存生成图像
    generated_image = generated_image.detach().cpu().squeeze(0)
    output_image = transforms.ToPILImage()(generated_image)
    output_image.save(output_image_path)
    
    # 使用示例
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import torch
    import torch.nn as nn
    import torch.optim as optim
    from torchvision import datasets, transforms
    
    # 定义生成器
    class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 784),
            nn.Tanh()
        )
    
    def forward(self, x):
        return self.model(x)
    
    # 定义判别器
    class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        return self.model(x)
    
    # 训练
    def train_gan(generator, discriminator, device):
    # 加载数据集
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))
    ])
    dataset = datasets.MNIST(root="data", train=True, transform=transform, download=True)
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=64, shuffle=True)
    
    # 定义损失函数和优化器
    criterion = nn.BCELoss()
    optimizer_G = optim.Adam(generator.parameters(), lr=0.0002)
    optimizer_D = optim.Adam(discriminator.parameters(), lr=0.0002)
    
    # 训练
    for epoch in range(100):
        for i, (real_images, _) in enumerate(dataloader):
            real_images = real_images.view(-1, 784).to(device)
            real_labels = torch.ones(real_images.size(0), 1).to(device)
    
            # 训练判别器
            optimizer_D.zero_grad()
            real_outputs = discriminator(real_images)
            real_loss = criterion(real_outputs, real_labels)
    
            noise = torch.randn(real_images.size(0), 100).to(device)
            fake_images = generator(noise)
            fake_labels = torch.zeros(real_images.size(0), 1).to(device)
            fake_outputs = discriminator(fake_images.detach())
            fake_loss = criterion(fake_outputs, fake_labels)
    
            d_loss = real_loss + fake_loss
            d_loss.backward()
            optimizer_D.step()
    
            # 训练生成器
            optimizer_G.zero_grad()
            fake_outputs = discriminator(fake_images)
            g_loss = criterion(fake_outputs, real_labels)
            g_loss.backward()
            optimizer_G.step()
    
            # 打印损失
            if (i + 1) % 100 == 0:
                print("Epoch [{}/{}], Step [{}/{}], d_loss: {:.4f}, g_loss: {:.4f}".format(
                    epoch + 1, 100, i + 1, len(dataloader), d_loss.item(), g_loss.item()))
    
    # 使用示例
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    generator = Generator().to(device)
    discriminator = Discriminator().to(device)
    train_gan(generator, discriminator, device)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读