變分自編碼器（VAE）在深度學習領域中扮演著重要的角色，尤其在生成模型方面表現出色。VAE 的核心概念是將輸入資料編碼到一個低維度的潛在空間，並從這個空間中學習資料的分佈，進而生成新的資料。不同於傳統的自編碼器，VAE 並非直接學習資料的編碼，而是學習資料在潛在空間中的機率分佈。這種方法使得 VAE 能夠生成更具多樣性和創造性的樣本，並有效避免過擬合問題。VAE 的訓練過程涉及到編碼器和解碼器兩個網路的協同最佳化，以及變分推斷技術的應用，以確保學習到的潛在空間分佈能夠有效地捕捉資料的特性。
解碼器（Decoder）實作
解碼器的主要功能是將壓縮的潛在表示（latent representation）重新構建回原始輸入資料的形狀和尺寸。以下是解碼器的實作程式碼：
class Decoder(nn.Module):
def __init__(self, out_channels, latent_dims):
super().__init__()
self.linear = nn.Linear(latent_dims, 1024 * 4 * 4)
self.t_conv_layers = nn.Sequential(
conv_transpose_block(1024, 512),
conv_transpose_block(512, 256, output_padding=1),
conv_transpose_block(256, out_channels, output_padding=1, with_act=False)
)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
bs = x.shape[0]
x = self.linear(x)
x = x.reshape((bs, 1024, 4, 4))
x = self.t_conv_layers(x)
x = self.sigmoid(x)
return x
在這個實作中，解碼器首先使用一個全連線層（nn.Linear）將壓縮的潛在表示轉換為一個較大的特徵圖。然後，使用一系列的轉置卷積層（conv_transpose_block）將特徵圖重新構建回原始輸入資料的形狀和尺寸。最後，使用sigmoid啟用函式將輸出限制在[0, 1]範圍內。
自動編碼器（AutoEncoder）實作
自動編碼器是由編碼器（Encoder）和解碼器（Decoder）組成的，它們共同工作以壓縮和重新構建輸入資料。以下是自動編碼器的實作程式碼：
class AutoEncoder(nn.Module):
def __init__(self, out_channels, latent_dims):
super().__init__()
self.encoder = Encoder(out_channels, latent_dims)
self.decoder = Decoder(out_channels, latent_dims)
def forward(self, x):
z = self.encoder(x)
x_recon = self.decoder(z)
return x_recon
在這個實作中，自動編碼器首先使用編碼器將輸入資料壓縮為一個較小的潛在表示。然後，使用解碼器將壓縮的潛在表示重新構建回原始輸入資料的形狀和尺寸。
圖表翻譯
以下是使用Mermaid語法繪製的自動編碼器架構圖：
graph LR
A[輸入資料] -->|壓縮|> B[編碼器]
B -->|潛在表示|> C[解碼器]
C -->|重新構建|> D[輸出資料]
style A fill:#f9f,stroke:#333,stroke-width:2px
style B fill:#f9f,stroke:#333,stroke-width:2px
style C fill:#f9f,stroke:#333,stroke-width:2px
style D fill:#f9f,stroke:#333,stroke-width:2px
這個圖表展示了自動編碼器的基本架構，包括編碼器、解碼器和輸入/輸出資料。
圖表翻譯：
此圖表展示了自動編碼器的工作流程。首先，輸入資料被壓縮為一個較小的潛在表示。然後，潛在表示被重新構建回原始輸入資料的形狀和尺寸。最後，輸出資料被生成。這個過程可以用於無監督學習和生成模型中，以學習資料的內在結構和模式。
實作自編碼器模型
class Autoencoder(nn.Module):
def __init__(self, in_channels, latent_dims):
super().__init__()
self.encoder = Encoder(in_channels, latent_dims)
self.decoder = Decoder(in_channels, latent_dims)
def encode(self, x):
return self.encoder(x)
def decode(self, x):
return self.decoder(x)
def forward(self, x):
return self.decode(self.encode(x))
圖表翻譯：
flowchart TD
A[輸入] --> B[編碼器]
B --> C[潛在空間]
C --> D[解碼器]
D --> E[輸出]
內容解密：
上述程式碼定義了一個自編碼器模型，該模型由編碼器和解碼器兩部分組成。編碼器負責將輸入資料壓縮到潛在空間，而解碼器則負責將潛在空間的資料還原為原始資料。
訓練迴圈實作
def train(model, num_epochs=10, lr=1e-4):
optimizer = torch.optim.AdamW(model.parameters(), lr=lr, eps=1e-5)
model.train() # 將模型設定為訓練模式
losses = []
for _ in (progress := trange(num_epochs, desc="訓練")):
for _, batch in (inner := tqdm(enumerate(train_dataloader), total=len(train_dataloader))):
batch = batch.to(device)
preds = model(batch)
# 計算損失和最佳化模型
圖表翻譯：
flowchart TD
A[訓練迴圈] --> B[初始化最佳化器]
B --> C[設定訓練模式]
C --> D[迭代訓練]
D --> E[計算損失和最佳化]
內容解密：
訓練迴圈的實作包括初始化最佳化器、設定訓練模式和迭代訓練。最佳化器使用 AdamW 演算法，學習率設定為 1e-4。模型在訓練模式下執行，然後迭代地計算損失和最佳化模型引數。
執行訓練
model = Autoencoder(in_channels=3, latent_dims=128)
train(model, num_epochs=10, lr=1e-4)
圖表翻譯：
flowchart TD
A[模型定義] --> B[訓練函式]
B --> C[執行訓練]
內容解密：
最後，定義一個自編碼器模型例項，並傳遞給 train 函式執行訓練。這個過程包括初始化模型、設定超引數和執行訓練迴圈，以完成模型的訓練。
深度學習模型的訓練與評估
在深度學習中，模型的訓練與評估是非常重要的步驟。以下是使用 PyTorch 框架訓練一個簡單的 AutoEncoder 模型的過程。
訓練模型
首先，我們需要定義模型的結構和損失函式。假設我們要訓練一個 AutoEncoder 模型，該模型具有兩個隱藏層，分別為編碼器（encoder）和解碼器（decoder）。
class AutoEncoder(nn.Module):
def __init__(self, in_channels, latent_dims):
super(AutoEncoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(in_channels, 128),
nn.ReLU(),
nn.Linear(128, latent_dims)
)
self.decoder = nn.Sequential(
nn.Linear(latent_dims, 128),
nn.ReLU(),
nn.Linear(128, in_channels)
)
def forward(self, x):
z = self.encoder(x)
reconstructed_x = self.decoder(z)
return reconstructed_x
接下來，我們需要定義損失函式和最佳化器。假設我們使用均方差（MSE）作為損失函式，Adam 作為最佳化器。
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
然後，我們可以開始訓練模型了。
for epoch in range(100):
for x in train_loader:
x = x.to(device)
optimizer.zero_grad()
reconstructed_x = model(x)
loss = criterion(reconstructed_x, x)
loss.backward()
optimizer.step()
print(f'Epoch {epoch+1}, Loss: {loss.item()}')
評估模型
在訓練完成後，我們可以評估模型的效能。假設我們使用均方差（MSE）作為評估指標。
model.eval()
with torch.no_grad():
total_loss = 0
for x in test_loader:
x = x.to(device)
reconstructed_x = model(x)
loss = criterion(reconstructed_x, x)
total_loss += loss.item()
print(f'Test Loss: {total_loss / len(test_loader)}')
視覺化結果
最後，我們可以視覺化模型的重構結果。
import matplotlib.pyplot as plt
with torch.no_grad():
reconstructed_x = model(test_data)
plt.figure(figsize=(10, 10))
for i in range(10):
plt.subplot(2, 5, i+1)
plt.imshow(test_data[i].squeeze(), cmap='gray')
plt.title(f'Original {i+1}')
plt.subplot(2, 5, i+6)
plt.imshow(reconstructed_x[i].squeeze(), cmap='gray')
plt.title(f'Reconstructed {i+1}')
plt.show()
這樣就完成了簡單的 AutoEncoder 模型的訓練與評估。
自動編碼器的潛在空間視覺化
在之前的實驗中，我們使用了只有兩個浮點數的潛在空間來表示 28x28的手寫影像。現在，我們想探索這個潛在空間的結構，並將所有從測試資料集編碼的向量使用不同的顏色表示每個類別。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
import numpy as np
import matplotlib.pyplot as plt
# 載入 MNIST 資料集
from torchvision.datasets import MNIST
from torchvision import transforms
# 定義資料轉換
transform = transforms.Compose([transforms.ToTensor()])
# 載入 MNIST 資料集
train_dataset = MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = MNIST(root='./data', train=False, download=True, transform=transform)
# 定義資料載入器
batch_size = 512
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 定義自動編碼器模型
class AutoEncoder(nn.Module):
def __init__(self):
super(AutoEncoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(28*28, 128),
nn.ReLU(),
nn.Linear(128, 2)
)
self.decoder = nn.Sequential(
nn.Linear(2, 128),
nn.ReLU(),
nn.Linear(128, 28*28),
nn.Sigmoid()
)
def forward(self, x):
x = x.view(-1, 28*28)
encoded = self.encoder(x)
decoded = self.decoder(encoded)
return decoded
def encode(self, x):
x = x.view(-1, 28*28)
return self.encoder(x)
# 初始化模型、最佳化器和損失函式
model = AutoEncoder()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 訓練模型
for epoch in range(10):
for batch in train_dataloader:
images, _ = batch
images = images.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, images)
loss.backward()
optimizer.step()
print(f'Epoch {epoch+1}, Loss: {loss.item()}')
# 將所有測試資料集的影像編碼並儲存到 DataFrame
import pandas as pd
df = pd.DataFrame({
'x': [],
'y': [],
'label': []
})
for batch in test_dataloader:
images, labels = batch
images = images.to(device)
encoded = model.encode(images).cpu()
new_items = {
'x': [t.item() for t in encoded[:, 0]],
'y': [t.item() for t in encoded[:, 1]],
'label': labels
}
df = pd.concat([df, pd.DataFrame(new_items)], ignore_index=True)
# 繪製潛在空間
plt.figure(figsize=(10, 8))
for label in range(10):
points = df[df['label'] == label]
plt.scatter(points['x'], points['y'], label=label, marker='.')
plt.legend()
plt.show()
# 生成新影像
N = 16
z = torch.randn(N, 2).to(device)
generated_images = model.decoder(z).view(-1, 1, 28, 28)
內容解密：
上述程式碼使用 PyTorch 實作了一個簡單的自動編碼器，將 28x28的手寫影像編碼為 2 個浮點數，然後再解碼回原始影像。程式碼包括資料載入、模型定義、訓練和測試。最後，程式碼使用生成的潛在空間向量生成新影像。
圖表翻譯：
潛在空間的視覺化結果表明，自動編碼器成功地將不同類別的影像分開，並且在潛在空間中形成了不同的區域。然而，潛在空間的結構並不對稱，且有一些空白區域。這使得選擇合適的潛在空間區域來生成新影像變得具有挑戰性。
Variational AutoEncoders（VAE）簡介
Variational AutoEncoders（VAE）是一種深度學習模型，旨在學習高維度資料的低維度表示，並能夠生成新的、合理的樣本。與傳統的AutoEncoders不同，VAE使用高斯分佈來表示每個特徵，從而捕捉資料中的變異性。
VAE的優點
- 能夠生成新的、合理的樣本
- 能夠學習高維度資料的低維度表示
- 能夠捕捉資料中的變異性
VAE的結構
VAE由兩部分組成：編碼器（Encoder）和解碼器（Decoder）。
- 編碼器：負責將輸入資料對映到低維度的潛在空間
- 解碼器：負責將低維度的潛在空間映射回高維度的原始空間
VAE的訓練過程
VAE的訓練過程涉及以下步驟：
- 對輸入資料進行編碼，得到低維度的潛在空間表示
- 從潛在空間中取樣，得到新的樣本
- 對新的樣本進行解碼，得到重構的原始資料
- 計算重構誤差和KL散度，得到損失函式
- 更新模型引數，降低損失函式
VAE的應用
VAE可以應用於各種領域，例如：
- 影像生成
- 文字生成
- 音訊生成
- 時序預測
Python實作
以下是VAE的Python實作：
import torch
import torch.nn as nn
import torch.optim as optim
class VAEEncoder(nn.Module):
def __init__(self, input_dim, latent_dim):
super(VAEEncoder, self).__init__()
self.fc1 = nn.Linear(input_dim, 128)
self.fc2 = nn.Linear(128, latent_dim * 2)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
mean, log_var = x.chunk(2, dim=1)
return mean, log_var
class VAEDecoder(nn.Module):
def __init__(self, latent_dim, input_dim):
super(VAEDecoder, self).__init__()
self.fc1 = nn.Linear(latent_dim, 128)
self.fc2 = nn.Linear(128, input_dim)
def forward(self, z):
z = torch.relu(self.fc1(z))
z = self.fc2(z)
return z
class VAE(nn.Module):
def __init__(self, input_dim, latent_dim):
super(VAE, self).__init__()
self.encoder = VAEEncoder(input_dim, latent_dim)
self.decoder = VAEDecoder(latent_dim, input_dim)
def forward(self, x):
mean, log_var = self.encoder(x)
z = self.reparameterize(mean, log_var)
x_recon = self.decoder(z)
return x_recon, mean, log_var
def reparameterize(self, mean, log_var):
std = torch.exp(0.5 * log_var)
eps = torch.randn_like(std)
z = mean + eps * std
return z
# 初始化模型和最佳化器
vae = VAE(input_dim=784, latent_dim=10)
optimizer = optim.Adam(vae.parameters(), lr=0.001)
# 訓練模型
for epoch in range(100):
for x in dataset:
x_recon, mean, log_var = vae(x)
loss = ((x - x_recon) ** 2).sum() + 0.5 * (mean ** 2 + torch.exp(log_var) - 1 - log_var).sum()
optimizer.zero_grad()
loss.backward()
optimizer.step()
這個實作包括了VAE的編碼器、解碼器和整體模型，以及訓練過程中的損失函式計算和最佳化器更新。
Variational AutoEncoders 的實作
在這個章節中，我們將實作 Variational AutoEncoders (VAE)，它是一種可以學習資料分佈的神經網路模型。VAE 的目的是學習一個連續的潛在空間（latent space），使得輸入資料可以被編碼成該空間中的點，並且可以從該點重構回原始輸入資料。
Encoder 的實作
VAE 的 Encoder 部分負責將輸入資料編碼成潛在空間中的點。以下是 Encoder 的實作：
class VAEEncoder(nn.Module):
def __init__(self, in_channels, latent_dims):
super().__init__()
self.conv_block1 = nn.Sequential(
nn.Conv2d(in_channels, 128, kernel_size=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2)
)
self.conv_block2 = nn.Sequential(
nn.Conv2d(128, 256, kernel_size=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2)
)
self.conv_block3 = nn.Sequential(
nn.Conv2d(256, 512, kernel_size=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2)
)
self.conv_block4 = nn.Sequential(
nn.Conv2d(512, 1024, kernel_size=3),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2)
)
self.mu = nn.Linear(1024, latent_dims)
self.logvar = nn.Linear(1024, latent_dims)
def forward(self, x):
x = self.conv_block1(x)
x = self.conv_block2(x)
x = self.conv_block3(x)
x = self.conv_block4(x)
x = x.view(x.size(0), -1)
mu = self.mu(x)
logvar = self.logvar(x)
return mu, logvar
Encoder 的輸出是兩個值：mu 和 logvar，它們分別代表了潛在空間中的均值和對數變異數。
Decoder 的實作
VAE 的 Decoder 部分負責將潛在空間中的點重構回原始輸入資料。以下是 Decoder 的實作：
class Decoder(nn.Module):
def __init__(self, in_channels, latent_dims):
super().__init__()
self.fc1 = nn.Linear(latent_dims, 1024)
self.fc2 = nn.Linear(1024, 512)
self.fc3 = nn.Linear(512, 256)
self.fc4 = nn.Linear(256, in_channels)
def forward(self, z):
z = self.fc1(z)
z = self.fc2(z)
z = self.fc3(z)
z = self.fc4(z)
return z
Decoder 的輸出是重構的原始輸入資料。
VAE 的實作
以下是 VAE 的實作：
class VAE(nn.Module):
def __init__(self, in_channels, latent_dims):
super().__init__()
self.encoder = VAEEncoder(in_channels, latent_dims)
self.decoder = Decoder(in_channels, latent_dims)
def encode(self, x):
mu, logvar = self.encoder(x)
return mu, logvar
def reparameterize(self, mu, logvar):
std = torch.exp(0.5 * logvar)
eps = torch.randn_like(std)
z = mu + eps * std
return z
def forward(self, x):
mu, logvar = self.encode(x)
z = self.reparameterize(mu, logvar)
return self.decoder(z)
VAE 的 forward 方法首先呼叫 encode 方法得到 mu 和 logvar，然後呼叫 reparameterize 方法得到 z，最後呼叫 decoder 方法得到重構的原始輸入資料。
內容解密：
在這個章節中，我們實作了 Variational AutoEncoders (VAE)，它是一種可以學習資料分佈的神經網路模型。VAE 的目的是學習一個連續的潛在空間（latent space），使得輸入資料可以被編碼成該空間中的點，並且可以從該點重構回原始輸入資料。VAE 的 Encoder 部分負責將輸入資料編碼成潛在空間中的點，Decoder 部分負責將潛在空間中的點重構回原始輸入資料。VAE 的 forward 方法首先呼叫 encode 方法得到 mu 和 logvar，然後呼叫 reparameterize 方法得到 z，最後呼叫 decoder 方法得到重構的原始輸入資料。
圖表翻譯：
以下是 VAE 的架構圖：
graph LR
A[Input] -->|x|> B[Encoder]
B -->|mu, logvar|> C[Reparameterize]
C -->|z|> D[Decoder]
D -->|reconstructed_x|> E[Output]
這個圖表展示了 VAE 的架構，包括 Encoder、Reparameterize、Decoder 和 Output。Encoder 負責將輸入資料編碼成潛在空間中的點，Reparameterize 負責得到 z，Decoder 負責將潛在空間中的點重構回原始輸入資料，Output 是重構的原始輸入資料。
變分自編碼器（VAE）技術深入分析
從技術架構視角來看，變分自編碼器（VAE）巧妙地融合了深度學習和貝氏統計的思想，相較於傳統自編碼器，它並非學習單個資料點的潛在表示，而是學習資料分佈的引數。透過編碼器網路輸出高斯分佈的均值和方差，VAE 將資料對映到一個連續的潛在空間，並利用重新引數化技巧使網路可訓練。解碼器網路則負責從潛在空間取樣，重建原始資料。這種機率生成模型的特性，賦予了 VAE 生成新資料的能力，使其在影像生成、藥物發現等領域展現出巨大潛力。然而，VAE 的訓練過程也面臨一些挑戰。KL 散度項的引入，旨在促使潛在空間符合先驗分佈，但實際操作中，KL 散度消失或後驗當機等問題可能影響模型的生成多樣性。此外，VAE 的重建損失通常根據畫素級別的差異，導致生成的影像有時不夠清晰或細節模糊。對於追求高保真生成的應用場景，需要進一步探索更精細的損失函式和訓練策略。玄貓認為，VAE 作為一種重要的生成模型，其理論框架和技術路線已趨於成熟，但仍需在特定應用領域針對資料特性和效能需求進行調優，才能充分釋放其潛力。未來，結合更強大的深度學習架構和更精細的機率建模方法，VAE 有望在更多領域取得突破性進展。
