实现创意 AI 艺术生成的扩散模型

由柏拉图重新发布

关注： 0

介绍

的合并人工智能（人工智能）和艺术揭示了创意数字艺术的新途径，尤其是通过扩散模型。这些模型在创意人工智能艺术中脱颖而出，提供了与传统神经网络不同的方法。本文将带您踏上扩散模型深度的探索之旅，阐明其在制作视觉上令人惊叹且创意丰富的艺术品时的独特机制。了解扩散模型的细微差别，并通过先进的人工智能技术深入了解它们在重新定义艺术表达方面的作用。

学习目标

了解人工智能中扩散模型的基本概念。
探索艺术生成中扩散模型和传统神经网络之间的区别。
使用扩散模型分析艺术创作的过程。
评估人工智能在数字艺术中的创意和美学影响。
讨论人工智能生成的艺术作品中的道德考虑。

这篇文章是作为数据科学博客马拉松。

了解扩散模型

扩散模型彻底改变了生成式人工智能，提出了一种不同于生成对抗网络 (GAN) 等传统技术的独特图像创建方法。这些模型从随机噪声开始，逐渐对其进行细化，就像艺术家对绘画进行微调一样，从而产生复杂且连贯的图像。

这种渐进的细化过程反映了扩散的有条不紊的本质。在这里，每次迭代都会巧妙地改变噪音，使其更接近最终的艺术愿景。输出不仅仅是随机性的产物，而且是一件进化的艺术品，其进程和完成都截然不同。

扩散模型的编码需要深入掌握神经网络和机器学习框架，例如 TensorFlow 或 PyTorch。由此产生的代码非常复杂，需要对广泛的数据集进行广泛的训练才能实现人工智能生成的艺术中观察到的微妙效果。

稳定扩散在艺术中的应用

稳定扩散模型等人工智能艺术生成器的出现需要在 TensorFlow 或 PyTorch 等平台内进行复杂的编码。这些模型因其能够有条不紊地将随机性转化为结构而脱颖而出，就像艺术家将初步草图打磨成生动的杰作一样。

稳定的扩散模型通过从随机性中塑造有序图像来重塑人工智能艺术场景，避开 GAN 的竞争动态特征。他们擅长将概念提示解释为视觉艺术，促进人工智能能力和人类创造力之间的协同舞蹈。通过利用 PyTorch，我们观察这些模型如何迭代地将混乱提炼为清晰，反映了艺术家从萌芽想法到精美创作的旅程。

尝试人工智能生成的艺术

该演示使用称为“ 卷积扩散模型。该模型接受了各种艺术图像的训练，包括素描、绘画、雕塑和雕刻，来源自这个 Kaggle 数据集。我们的目标是探索模型捕捉和再现这些艺术品的复杂美学的能力。

模型架构和训练

建筑设计

ConvDiffusionModel 的核心是神经工程的奇迹，具有专为艺术生成的需求而定制的复杂的编码器-解码器架构。该模型的结构是一个复杂的神经网络，集成了专门为艺术生成而磨练的精细编码器-解码器机制。通过附加的卷积层和模拟艺术直觉的跳跃连接，该模型可以通过对构图和风格的敏锐理解来剖析和重新组合艺术。

编码器： 编码器是模型的分析眼睛，仔细检查每个输入图像的微小细节。当图像通过编码器的卷积层时，它们逐渐被压缩到一个潜在空间——原始艺术品的紧凑的编码表示。我们的编码器不仅仔细检查输入图像，而且现在通过附加层和批量归一化技术增强了感知深度。这种扩展的检查可以在潜在空间中提供更丰富、更浓缩的表现，反映艺术家对某个主题的深刻思考。
解码器： 相比之下，解码器充当模型的创意之手，从编码器获取抽象草图并为其注入生命。它从潜在的空间中逐层、逐个细节地重建艺术品，直到出现完整的图像。我们的解码器受益于跳过连接，并且可以更精确地重建艺术品。它重新审视输入的抽象本质并逐步对其进行修饰，从而实现更忠实于源材料的再现。增强层协同工作，确保最终图像生动、复杂，反映了输入的艺术性。

训练过程

ConvDiffusionModel 的训练是一次跨越 150 个时代的艺术景观之旅。每个时期代表对整个数据集的完整遍历，模型努力完善其理解并提高其生成图像的保真度。

混合损失函数： 训练的核心是均方误差（MSE）损失函数。该函数量化了原始杰作和模型重建之间的差异，提供了一个明确的指标来最小化。我们将引入一个源自预训练 VGG 网络的感知损失组件，它补充了均方误差 (MSE) 指标。这种双重损失策略推动模型尊重原件的艺术完整性，同时完善其细节的技术再现。
优化器： Adam 优化器通过调度程序动态调整学习率，以更高的智慧指导模型的学习。这种适应性方法确保模型在学习复制和创新艺术方面的进展既稳定又稳健。
迭代和细化： 训练迭代是保留艺术本质和追求技术复制之间的舞蹈。在每个周期中，模型都更接近保真度和创造力的综合。
进度可视化：训练过程中定期保存图像，以可视化模型的进度。这些快照为了解模型的学习曲线提供了一个窗口，展示了其生成的艺术如何演变，变得更清晰、更详细，并且在艺术上与每个时代更加一致。

上述内容通过以下代码进行演示：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torchvision.utils import save_image
from torchvision.models import vgg16
from PIL import Image

# Defining a function to check for valid images
def is_valid_image(image_path):
    try:
        with Image.open(image_path) as img:
            img.verify()
        return True
    except (IOError, SyntaxError) as e:
      # Printing out the names of all corrupt files
        print(f'Bad file:', image_path)
        return False

# Defining the neural network
class ConvDiffusionModel(nn.Module):
    def __init__(self):
        super(ConvDiffusionModel, self).__init__()
        # Encoder
        self.enc1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=3, 
        stride=1, padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(64),
                                  nn.MaxPool2d(kernel_size=2, 
                                  stride=2))
        self.enc2 = nn.Sequential(nn.Conv2d(64, 128, 
        kernel_size=3, padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(128),
                                  nn.MaxPool2d(kernel_size=2, 
                                  stride=2))
        self.enc3 = nn.Sequential(nn.Conv2d(128, 256, kernel_size=3, 
        padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(256),
                                  nn.MaxPool2d(kernel_size=2, 
                                  stride=2))
        
        # Decoder
        self.dec1 = nn.Sequential(nn.ConvTranspose2d(256, 128, 
        kernel_size=3, stride=2, padding=1, output_padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(128))
        self.dec2 = nn.Sequential(nn.ConvTranspose2d(128, 64, 
        kernel_size=3, stride=2, padding=1, output_padding=1),
                                  nn.ReLU(),
                                  nn.BatchNorm2d(64))
        self.dec3 = nn.Sequential(nn.ConvTranspose2d(64, 3, 
        kernel_size=3, stride=2, padding=1, output_padding=1),
                                  nn.Sigmoid())

    def forward(self, x):
        # Encoder
        enc1 = self.enc1(x)
        enc2 = self.enc2(enc1)
        enc3 = self.enc3(enc2)
        
        # Decoder with skip connections
        dec1 = self.dec1(enc3) + enc2
        dec2 = self.dec2(dec1) + enc1
        dec3 = self.dec3(dec2)
        return dec3

# Using a pre-trained VGG16 model to compute perceptual loss
class VGGLoss(nn.Module):
    def __init__(self):
        super(VGGLoss, self).__init__()
        self.vgg = vgg16(pretrained=True).features[:16].cuda()
        .eval()  # Only the first 16 layers
        for param in self.vgg.parameters():
            param.requires_grad = False

    def forward(self, input, target):
        input_vgg = self.vgg(input)
        target_vgg = self.vgg(target)
        loss = torch.nn.functional.mse_loss(input_vgg, 
        target_vgg)
        return loss

# Checking if CUDA is available and set device to GPU if it is.
device = torch.device("cuda" if torch.cuda.is_available() 
else "cpu")

# Initializing the model and perceptual loss
model = ConvDiffusionModel().to(device)
vgg_loss = VGGLoss().to(device)
mse_loss = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, 
gamma=0.1)

# Dataset and DataLoader setup
transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
    std=[0.229, 0.224, 0.225]),
])

dataset = datasets.ImageFolder(root='/content/Images', 
transform=transform, is_valid_file=is_valid_image)
dataloader = DataLoader(dataset, batch_size=32, 
shuffle=True)

# Training loop
num_epochs = 150
for epoch in range(num_epochs):
    for i, (inputs, _) in enumerate(dataloader):
        inputs = inputs.to(device)
        
        # Zero the parameter gradients
        optimizer.zero_grad()

        # Forward pass
        outputs = model(inputs)
        
        # Calculate losses
        mse = mse_loss(outputs, inputs)
        perceptual = vgg_loss(outputs, inputs)
        loss = mse + perceptual

        # Backward pass and optimize
        loss.backward()
        optimizer.step()

        if (i + 1) % 100 == 0:
            print(f'Epoch [{epoch+1}/{num_epochs}], 
            Step [{i+1}/{len(dataloader)}], Loss: {loss.item()}, 
            Perceptual Loss: {perceptual.item()}, MSE Loss: 
            {mse.item()}')
            # Saving the generated image for visualization
            save_image(outputs, f'output_epoch_{epoch+1}
            _step_{i+1}.png')

    # Updating the learning rate
    scheduler.step()

    # Saving model checkpoints
    if (epoch + 1) % 10 == 0:
        torch.save(model.state_dict(), 
        f'/content/model_epoch_{epoch+1}.pth')

print('Training Complete')

可视化生成的艺术作品

展现人工智能艺术

随着 ConvDiffusionModel 现已经过全面训练，焦点从抽象转移到具体，从潜力转移到实现人工智能制作的艺术。随后的代码片段具体化了模型所学到的艺术能力，将输入数据转换为表达的数字画布。

import os
import matplotlib.pyplot as plt

# Loading the trained model
model = ConvDiffusionModel().to(device)
model.load_state_dict(torch.load('/content/model_epoch_150.pth'))
model.eval()  # Set the model to evaluation mode

# Transforming for the input image
transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
    std=[0.229, 0.224, 0.225]),
])

# Function to de-normalize the image for viewing
def denormalize(tensor):
    mean = torch.tensor([0.485, 0.456, 0.406]).
    to(device).view(-1, 1, 1)
    std = torch.tensor([0.229, 0.224, 0.225]).
    to(device).view(-1, 1, 1)
    tensor = tensor * std + mean  # De-normalize
    tensor = tensor.clamp(0, 1)  # Clamp to the valid image range
    return tensor

# Loading and transforming the image
input_image_path = '/content/Validation/0006.jpg'  
input_image = Image.open(input_image_path).convert('RGB')
input_tensor = transform(input_image).unsqueeze(0).to(device)  
# Adding a batch dimension

# Generating the image
with torch.no_grad():
    generated_tensor = model(input_tensor)

# Converting the generated image tensor to an image
generated_image = denormalize(generated_tensor.squeeze(0))  
# Removing the batch dimension and de-normalizing
generated_image = generated_image.cpu()  # Move to CPU

# Saving the generated image
save_image(generated_image, '/content/generated_image.png')
print("Generated image saved to '/content/generated_image.png'")

# Displaying the generated image using matplotlib
plt.figure(figsize=(8, 8))
plt.imshow(generated_image.permute(1, 2, 0))  
# Rearrange the channels for plotting
plt.axis('off')  # Hide the axes
plt.show()

艺术品生成代码演练

模型复活： 艺术作品生成的第一步是恢复我们训练过的 ConvDiffusionModel。模型的学习权重被加载并进入评估模式，为创建奠定了基础，而无需进一步更改其参数。
图像转换： 为了确保与训练机制的一致性，输入图像通过相同的变换序列进行处理。这包括调整大小以匹配模型的输入维度、用于 PyTorch 兼容性的张量转换以及基于训练数据的统计配置文件的标准化。
非规范化实用程序： 自定义函数可反转预处理效果，将张量重新缩放到原始图像的颜色范围。此步骤对于将生成的输出渲染为视觉上准确的表示至关重要。
输入准备： 加载图像并进行上述转换。值得注意的是，这张图像是人工智能从中汲取灵感的缪斯——无声的低语点燃了模型的合成想象力。
艺术品合成： 在前向传播的微妙舞蹈中，模型解释输入张量，使其各层协作产生新的艺术视觉。执行此过程时无需跟踪梯度，因为我们现在处于应用领域，而不是训练领域。
图像转换： 模型的张量输出现在保存着数字生成的艺术品，被非规范化，将模型的创作转换回我们眼睛可以欣赏的熟悉的颜色和光线空间。
艺术品启示： 转换后的张量被放置在数字画布上，最终形成保存的图像文件。该文件是了解人工智能创造性灵魂的窗口，是赋予其生命的动态过程的静态回声。
艺术品检索： 该脚本最后将生成的图像保存到指定路径并宣布其完成。保存的图像是所学艺术原理和新兴创造力的综合体，可供展示和思考。

分析输出

ConvDiffusionModel 的输出呈现出一个明确向历史艺术致敬的图形。人工智能渲染的图像身着精致的服装，与古典肖像的宏伟相呼应，但又具有独特的现代风格。拍摄对象的服装质感丰富，将模特习得的图案与新颖的诠释融为一体。精致的面部特征和微妙的光影相互作用展示了人工智能对传统艺术技巧的细致入微的理解。这件艺术品证明了模型经过复杂的训练，通过先进的机器学习棱镜反映了历史艺术的优雅综合。从本质上讲，它是用现在的算法精心制作的对过去的数字致敬。