Der Implementierungsprozess der Bildkomprimierung: Variations-Autoencoder

Variational Autoencoder (VAE) ist ein unbeaufsichtigt lernendes neuronales Netzwerk, das zur Bildkomprimierung und -generierung verwendet wird. Im Vergleich zu herkömmlichen Autoencodern kann VAE Eingabebilder rekonstruieren und ihnen ähnliche neue Bilder generieren. Die Kernidee besteht darin, das Eingabebild in eine Verteilung latenter Variablen zu kodieren und daraus Stichproben zu ziehen, um neue Bilder zu erzeugen. VAE ist einzigartig in der Verwendung von Variationsinferenz zum Trainieren des Modells und erreicht Parameterlernen durch Maximierung der Untergrenze zwischen beobachteten und generierten Daten. Diese Methode ermöglicht es VAE, die zugrunde liegende Struktur der Daten zu erlernen und neue Stichproben zu generieren. VAE hat in vielen Bereichen bemerkenswerte Erfolge erzielt, darunter Aufgaben wie Bildgenerierung, Attributbearbeitung und Bildrekonstruktion.

VAE (Variational Autoencoder) hat eine ähnliche Struktur wie ein Autoencoder und besteht aus einem Encoder und einem Decoder. Der Encoder komprimiert das Eingabebild in eine Verteilung latenter Variablen, einschließlich eines Mittelwertvektors und eines Varianzvektors. Der Decoder tastet die latenten Variablen ab, um neue Bilder zu erzeugen. Um die Verteilung latenter Variablen sinnvoller zu gestalten, führt VAE den Regularisierungsterm der KL-Divergenz ein, um die Verteilung latenter Variablen näher an die Standardnormalverteilung heranzuführen. Dadurch können die Ausdruckskraft und die Generierungsfähigkeiten des Modells verbessert werden.

Im Folgenden wird der handschriftliche Zifferndatensatz von MNIST als Beispiel verwendet, um den Implementierungsprozess von VAE vorzustellen.

Zuerst müssen wir die notwendigen Bibliotheken und Datensätze importieren.

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.autograd import Variable

# 加载数据集
transform = transforms.Compose([
    transforms.ToTensor(),
])
train_dataset = datasets.MNIST(root='./data/', train=True, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True)

Als nächstes definieren Sie die Netzwerkstruktur des Encoders und Decoders.

# 定义编码器
class Encoder(nn.Module):
    def __init__(self):
        super(Encoder, 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=2, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
        self.fc1 = nn.Linear(128 * 7 * 7, 256)
        self.fc21 = nn.Linear(256, 20) # 均值向量
        self.fc22 = nn.Linear(256, 20) # 方差向量

    def forward(self, x):
        x = nn.functional.relu(self.conv1(x))
        x = nn.functional.relu(self.conv2(x))
        x = nn.functional.relu(self.conv3(x))
        x = x.view(-1, 128 * 7 * 7)
        x = nn.functional.relu(self.fc1(x))
        mean = self.fc21(x)
        log_var = self.fc22(x)
        return mean, log_var


# 定义解码器
class Decoder(nn.Module):
    def __init__(self):
        super(Decoder, self).__init__()
        self.fc1 = nn.Linear(20, 256)
        self.fc2 = nn.Linear(256, 128 * 7 * 7)
        self.conv1 = nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.conv2 = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.conv3 = nn.ConvTranspose2d(32, 1, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.relu(self.fc2(x))
        x = x.view(-1, 128, 7, 7)
        x = nn.functional.relu(self.conv1(x))
        x = nn.functional.relu(self.conv2(x))
        x = nn.functional.sigmoid(self.conv3(x))
        return x


# 定义VAE模型
class VAE(nn.Module):
    def __init__(self):
        super(VAE, self).__init__()
        self.encoder = Encoder()
        self.decoder = Decoder()

    def reparameterize(self, mean, log_var):
        std = torch.exp(0.5 * log_var)
        eps = torch.randn_like(std)
        return eps * std + mean

    def forward(self, x):
        mean, log_var = self.encoder(x)

Der nächste Schritt ist der Vorwärtsausbreitungsprozess des VAE-Modells, der das Abtasten latenter Variablen zur Generierung neuer Bilder und die Berechnung der Regularisierungsterme des Rekonstruktionsfehlers und der KL-Divergenz umfasst.

z = self.reparameterize(mean, log_var)
x_recon = self.decoder(z)
return x_recon, mean, log_var

def loss_function(self, x_recon, x, mean, log_var):
    recon_loss = nn.functional.binary_cross_entropy(x_recon, x, size_average=False)
    kl_loss = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())
    return recon_loss + kl_loss

def sample(self, num_samples):
    z = torch.randn(num_samples, 20)
    samples = self.decoder(z)
    return samples

Schließlich definieren wir den Optimierer und beginnen mit dem Training des Modells.

# 定义优化器
vae = VAE()
optimizer = optim.Adam(vae.parameters(), lr=1e-3)

# 开始训练模型
num_epochs = 10
for epoch in range(num_epochs):
for batch_idx, (data, _) in enumerate(train_loader):
data = Variable(data)
optimizer.zero_grad()
x_recon, mean, log_var = vae(data)
loss = vae.loss_function(x_recon, data, mean, log_var)
loss.backward()
optimizer.step()

    if batch_idx % 100 == 0:
        print('Epoch [{}/{}], Batch [{}/{}], Loss: {:.4f}'.format(
            epoch+1, num_epochs, batch_idx+1, len(train_loader), loss.data.item()))

Nach Abschluss des Trainings können wir VAE verwenden, um neue handschriftliche Ziffernbilder zu generieren.

# 生成手写数字图像
samples = vae.sample(10)
fig, ax = plt.subplots(1, 10, figsize=(10, 1))
for i in range(10):
ax[i].imshow(samples[i].detach().numpy().reshape(28, 28), cmap='gray')
ax[i].axis('off')
plt.show()

VAE ist ein leistungsstarkes Bildkomprimierungs- und generatives Modell, das die Bildkomprimierung erreicht, indem es Eingabebilder in eine Verteilung latenter Variablen kodiert und diese dann abtastet, um neue Bilder zu generieren. Im Gegensatz zu herkömmlichen Autoencodern führt VAE auch den Regularisierungsterm der KL-Divergenz ein, um die Verteilung latenter Variablen sinnvoller zu gestalten. Bei der Implementierung von VAE ist es erforderlich, die Netzwerkstruktur des Encoders und Decoders zu definieren und die Regularisierungsterme des Rekonstruktionsfehlers und der KL-Divergenz zu berechnen. Durch das Training des VAE-Modells kann die latente Variablenverteilung des Eingabebildes erlernt und daraus neue Bilder generiert werden.

Das Obige ist der grundlegende Einführungs- und Implementierungsprozess von VAE. Ich hoffe, dass es für die Leser hilfreich sein wird.

Das obige ist der detaillierte Inhalt vonDer Implementierungsprozess der Bildkomprimierung: Variations-Autoencoder. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!