Giới thiệu

Sinh thành đối kháng internet ( Generative Adversarial Networks, GAN ) là một loại chiều sâu học tập mô hình giá cấu, từ Ian Goodfellow đám người với 2014 năm đưa ra. GAN từ hai cái mạng lưới thần kinh tạo thành: Sinh thành khí ( Generator ) cùng phân biệt khí ( Discriminator ). Sinh thành khí ý đồ sinh thành rất thật số liệu hàng mẫu, mà phân biệt khí tắc nếm thử phân chia này đó sinh thành số liệu cùng chân thật số liệu.


Ứng dụng sử dụng cảnh tượng

Hình ảnh sinh thành: Như sinh thành cao chất lượng hình ảnh, tác phẩm nghệ thuật chờ.

Hình ảnh siêu độ phân giải: Tăng lên thấp độ phân giải hình ảnh rõ ràng độ.

Hình ảnh chữa trị: Chữa trị tàn khuyết hoặc hư hao hình ảnh.

Phong cách di chuyển: Đem một loại nghệ thuật phong cách ứng dụng đến một khác trương hình ảnh thượng.

Số liệu tăng cường: Vì huấn luyện máy móc học tập mô hình sinh thành càng đa dạng bổn số liệu.

Văn bản sinh thành: Sinh thành rất thật tự nhiên ngôn ngữ văn bản, như GPT hệ liệt mô hình.


Nguyên lý giải thích

GAN trung tâm tư tưởng là thông qua hai cái internet đánh cờ tới cải tiến sinh thành khí sinh thành năng lực:

Sinh thành khí ( G ): Đưa vào một cái tùy cơ tiếng ồn vector, sinh thành rất thật số liệu hàng mẫu.

Phân biệt khí ( D ): Đưa vào số liệu hàng mẫu ( chân thật hàng mẫu hoặc sinh thành hàng mẫu ), phát ra nên hàng mẫu vì chân thật số liệu xác suất.


Thuật toán nguyên lý lưu trình đồ

A[ tùy cơ tiếng ồn z] --> B[ sinh thành khí G]
B --> C[ sinh thành hàng mẫu ]
D[ chân thật hàng mẫu ] --> E[ phân biệt khí D]
C --> E
E --> F[ phán đoán thật giả ]
F --> G{ đổi mới phân biệt khí }
G -->| là | H[ phản hồi cấp sinh thành khí ]
H --> B

subgraph sinh thành đối kháng quá trình
A --> B --> C --> E --> F --> G --> H
D --> E
end


Thuật toán nguyên lý giải thích

Tùy cơ tiếng ồn z: Sinh thành khí tiếp thu một cái tùy cơ tiếng ồn vector làm đưa vào.

Sinh thành khí G: Sinh thành khí căn cứ tiếng ồn vector sinh thành giả hàng mẫu.

Chân thật hàng mẫu: Từ chân thật số liệu tập trung rút ra hàng mẫu.

Phân biệt khí D: Phân biệt khí tiếp thu chân thật hàng mẫu cùng sinh thành hàng mẫu, phát ra thật giả xác suất.

Phân biệt thật giả: Phân biệt khí cấp ra hàng mẫu vì chân thật số liệu xác suất.

Đổi mới phân biệt khí: Căn cứ phân biệt kết quả, đổi mới phân biệt khí, làm này có thể càng chuẩn xác khu vực phần thật giả hàng mẫu.

Phản hồi cấp sinh thành khí: Đổi mới sau phân biệt khí đem tin tức phản hồi cấp sinh thành khí, sinh thành khí điều chỉnh tham số lấy sinh thành càng rất thật hàng mẫu.


Ứng dụng cảnh tượng số hiệu thí dụ mẫu thực hiện

Dưới thí dụ mẫu triển lãm sử dụng PyTorch thực hiện một cái đơn giản GAN kiếp sau thành viết tay con số ( MNIST số liệu tập ).

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# siêu tham số thiết trí
latent_dim = 100
batch_size = 64
num_epochs = 50
learning_rate = 0.0002

# số liệu dự xử lý
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])

# thêm tái số liệu tập
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# sinh thành khí định nghĩa
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(latent_dim, 128),
nn.ReLU(True),
nn.Linear(128, 256),
nn.ReLU(True),
nn.Linear(256, 512),
nn.ReLU(True),
nn.Linear(512, 784),
nn.Tanh()
)

def forward(self, x):
return self.model(x).view(-1, 1, 28, 28)

# phân biệt khí định nghĩa
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(784, 512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 1),
nn.Sigmoid()
)

def forward(self, x):
return self.model(x.view(-1, 784))

# khởi động lại mô hình
generator = Generator()
discriminator = Discriminator()

# tổn thất hàm số cùng ưu hoá khí
criterion = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=learning_rate)
optimizer_D = optim.Adam(discriminator.parameters(), lr=learning_rate)

# huấn luyện GAN
for epoch in range(num_epochs):
for i, (imgs, _) in enumerate(train_loader):
# chuẩn bị chân thật cùng ngụy nhãn
real_labels = torch.ones(batch_size, 1)
fake_labels = torch.zeros(batch_size, 1)

# huấn luyện phân biệt khí
optimizer_D.zero_grad()
real_outputs = discriminator(imgs)
d_loss_real = criterion(real_outputs, real_labels)

z = torch.randn(batch_size, latent_dim)
fake_imgs = generator(z)
fake_outputs = discriminator(fake_imgs.detach())
d_loss_fake = criterion(fake_outputs, fake_labels)

d_loss = d_loss_real + d_loss_fake
d_loss.backward()
optimizer_D.step()

# huấn luyện sinh thành khí
optimizer_G.zero_grad()
fake_outputs = discriminator(fake_imgs)
g_loss = criterion(fake_outputs, real_labels)

g_loss.backward()
optimizer_G.step()

print(f "Epoch [{epoch+1}/{num_epochs}] Loss D: {d_loss.item():.4f}, loss G: {g_loss.item():.4f}" )

# sinh thành một ít hàng mẫu cũng triển lãm
import matplotlib.pyplot as plt

z = torch.randn(16, latent_dim)
fake_imgs = generator(z).detach().cpu()
grid_img = torchvision.utils.make_grid(fake_imgs, nrow=4, normalize=True)
plt.imshow(grid_img.permute(1, 2, 0))
plt.show()


Sinh thành khí: Sinh thành rất thật số liệu hàng mẫu

Sinh thành khí ( Generator ) tiếp thu một cái tùy cơ tiếng ồn vector, sinh thành rất thật số liệu hàng mẫu. Dưới là một cái đơn giản sinh thành khí mô hình định nghĩa:


import torch.nn as nn

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(True),
nn.Linear(128, 256),
nn.ReLU(True),
nn.Linear(256, 512),
nn.ReLU(True),
nn.Linear(512, output_dim),
nn.Tanh()
)

def forward(self, x):
return self.model(x)


Phân biệt khí: Phân chia chân thật số liệu cùng sinh thành số liệu

Phân biệt khí ( Discriminator ) tiếp thu số liệu hàng mẫu, phát ra nên hàng mẫu vì chân thật số liệu xác suất. Dưới là phân biệt khí mô hình định nghĩa:


class Discriminator(nn.Module):
def __init__(self, input_dim):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_dim, 512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 1),
nn.Sigmoid()
)

def forward(self, x):
return self.model(x)


Đối kháng huấn luyện: Sinh thành khí cùng phân biệt khí lẫn nhau cạnh tranh, cộng đồng tăng lên tính năng

Đối kháng huấn luyện trong quá trình, sinh thành khí ý đồ lừa gạt phân biệt khí, mà phân biệt khí tắc nỗ lực phân chia chân thật cùng sinh thành số liệu. Dưới là hoàn chỉnh huấn luyện số hiệu thí dụ mẫu:


import torch
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# siêu tham số thiết trí
latent_dim = 100
img_shape = 28 * 28
batch_size = 64
num_epochs = 50
learning_rate = 0.0002

# số liệu dự xử lý
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])

# thêm tái số liệu tập
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# khởi động lại sinh thành khí cùng phân biệt khí
generator = Generator(latent_dim, img_shape)
discriminator = Discriminator(img_shape)

# tổn thất hàm số cùng ưu hoá khí
criterion = nn.BCELoss()
optimizer_G = optim.Adam(generator.parameters(), lr=learning_rate)
optimizer_D = optim.Adam(discriminator.parameters(), lr=learning_rate)

# bắt đầu huấn luyện
for epoch in range(num_epochs):
for i, (imgs, _) in enumerate(train_loader):

# chuẩn bị chân thật cùng ngụy nhãn
real_labels = torch.ones(batch_size, 1)
fake_labels = torch.zeros(batch_size, 1)

# huấn luyện phân biệt khí
optimizer_D.zero_grad()

imgs_flat = imgs.view(batch_size, -1)
real_outputs = discriminator(imgs_flat)
d_loss_real = criterion(real_outputs, real_labels)

z = torch.randn(batch_size, latent_dim)
fake_imgs = generator(z)
fake_outputs = discriminator(fake_imgs.detach())
d_loss_fake = criterion(fake_outputs, fake_labels)

d_loss = d_loss_real + d_loss_fake
d_loss.backward()
optimizer_D.step()

# huấn luyện sinh thành khí
optimizer_G.zero_grad()

fake_outputs = discriminator(fake_imgs)
g_loss = criterion(fake_outputs, real_labels)

g_loss.backward()
optimizer_G.step()

print(f "Epoch [{epoch+1}/{num_epochs}] Loss D: {d_loss.item():.4f}, loss G: {g_loss.item():.4f}" )

# sinh thành một ít hàng mẫu cũng triển lãm
import matplotlib.pyplot as plt

z = torch.randn(16, latent_dim)
fake_imgs = generator(z).detach().cpu()
fake_imgs = fake_imgs.view(-1, 1, 28, 28)
grid_img = torchvision.utils.make_grid(fake_imgs, nrow=4, normalize=True)
plt.imshow(grid_img.permute(1, 2, 0))
plt.show()


Số hiệu thuyết minh

Sinh thành khí: Đem đưa vào tùy cơ tiếng ồn vector thông qua nhiều toàn liên tiếp tầng cùng kích hoạt hàm số sinh thành rất thật hình ảnh.

Phân biệt khí: Đem đưa vào hình ảnh thông qua nhiều toàn liên tiếp tầng cùng kích hoạt hàm số tính toán này vì chân thật số liệu xác suất.

Đối kháng huấn luyện:

Phân biệt khí trước tiếp thu chân thật hình ảnh, đổi mới này tham số lấy đề cao phân chia thật giả hình ảnh năng lực.

Sau đó phân biệt khí tiếp thu từ sinh thành khí sinh thành giả hình ảnh, lại lần nữa đổi mới này tham số lấy đề cao phân chia thật giả hình ảnh năng lực.

Tiếp theo đổi mới sinh thành khí tham số, làm này sinh thành hình ảnh có thể càng tốt mà lừa gạt phân biệt khí.


Bố trí thí nghiệm cảnh tượng

Bản địa bố trí: Ở bản địa máy tính thượng trang bị torch cùng torchvision, vận hành kể trên số hiệu tiến hành mô hình huấn luyện cùng thí nghiệm.

Docker vật chứa hóa: Đem sở hữu ỷ lại đóng gói đến Docker vật chứa trung, bảo đảm vượt ngôi cao nhất trí tính bố trí.

Đám mây bố trí: Đem mô hình bố trí đến AWS SageMaker hoặc GCP AI Platform, thực hiện đại quy mô tại tuyến trinh thám phục vụ.

Đằng trước tổng thể: Kết hợp Flask hoặc Django xây dựng API phục vụ, đằng trước thông qua AJAX thỉnh cầu thuyên chuyển mô hình công năng.


Tài liệu

PyTorch phía chính phủ hồ sơ

TensorFlow phía chính phủ hồ sơ

Ian Goodfellow GAN luận văn (Goodfellow et al., 2014)

OpenAI Gym phía chính phủ hồ sơ

Deep Convolutional GAN (DCGAN) luận văn (Radford et al., 2015)


Tổng kết

Sinh thành đối kháng internet (GAN) là một loại cường đại sinh thành mô hình, thông qua sinh thành khí cùng phân biệt khí đánh cờ, có thể sinh thành cao chất lượng hình ảnh, văn bản chờ nhiều loại loại hình số liệu. Ở thực tế khai phá trung, GAN có thể dùng cho hình ảnh sinh thành, hình ảnh chữa trị, số liệu tăng cường chờ nhiều lĩnh vực, trí tuệ nhân tạo sinh thành nội dung (AIGC) cung cấp cường hữu lực kỹ thuật duy trì.


Tương lai triển vọng

Đề cao sinh thành chất lượng: Thông qua cải tiến internet kết cấu ( như DCGAN, WGAN, StyleGAN chờ ), tiến thêm một bước tăng lên sinh thành nội dung chất lượng.

Ứng dụng mở rộng: Đem GAN kỹ thuật ứng dụng với càng nhiều lĩnh vực, như âm nhạc sinh thành, video sinh thành chờ.

Nửa giám sát cùng vô giám sát học tập kết hợp: Thăm dò GAN ở nửa giám sát cùng vô giám sát học tập trung ứng dụng, đề cao mô hình huấn luyện hiệu suất cùng tính năng.

Vượt mô thái sinh thành: Thăm dò bất đồng mô thái số liệu gian thay đổi cùng sinh thành, như văn bản sinh thành hình ảnh, âm tần sinh thành hình ảnh chờ.

Theo GAN kỹ thuật phát triển cùng ứng dụng mở rộng, AIGC hệ thống đem ở các loại sinh thành nhiệm vụ trung phát huy càng ngày càng quan trọng tác dụng, vì các ngành sản xuất mang đến càng nhiều sáng tạo cùng khả năng tính