微信
手机版
网站地图

激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程

2019-05-16 11:45:17 投稿人 : admin 围观 : 262 次 0 评论

VAE精心解说

变分自编码器(Variational Auto Encoder(VAE))是生成建为无名山增高一米模中最闻名和最根底的模型之一。在本文中,我将经过一个在PyTorch中完成的模型的小比如来解说背面的数学。

生成建模

生成建模是机器学习的一个分支,触及能够生成具有某些所需特征的新数据的模型。它在2015年开端盛行,其时Ian Goodfellow闻名的生成对抗性模型(Generative Adversarial Modeploicel)开端发生明显的作用。生成建模并不意味着运用某些详细类型的神经网络(RNN,CNN等),而是运用这些根本构建块来拟定生成数据的办法(GAN,VAE等)。

让咱们扼要概述判别模型和生成模型之间的差异。常见的判别模型需求一些输入来回来某些信号的概率。生成的进程没有被考虑,咱们仅有感兴趣的是 - 检测输入中的满文军前妻高晓莹图片一些形式以给出信号的猜测值。在大多数常见情况下,此进程从:(|)给出成果概率

在生成建模的情况下,天鹅劫咱们有一些从生成进程中发生的数据点。这一进程能够看作是从不同视点、从人的言语等视点调查某一物体的进程。这个生成进程能够从散布的视点来看。例如,猫的图画看起来像猫是由于每个像素以其自己的特定办法散布。咱们期望咱们的模型以这种办法“了解”这种散布,以生成包括猫的新图画。每个数据点都存在于一些M维空间中。咱们还期望标签运用这些常识,而练习直接皇后生长方案攻略李四生成模型需求彻底和怎么。生成进程能够看作是 (,) 。关于生成模型的两个首要进程是

  1. 咱们练习咱们的模型对参数输出样本散布Pmodel(咱们生成模型)与练习数据的散布Pdata(())
  2. 稍后咱们从Pmodel中采样点,这些点看起来与Pdata以相同的办法散布

学习生成模型应该从给定的散布中生成新的样本,而不仅仅是仿制和张贴现有的样本。为完成这一方针,咱们需求场景中的随机成分。引进它的最常用办法是在练习进程中运用一些噪声。

一些能够运用生成模型的场景:

  • 对杂乱的高维散布进行建模
  • 经过生成传神的组成样原本履行数据增强
  • 添补数据中的空白

生成模型遍及的原因,现在咱们有满足的数据和核算才能来构建杂乱的生成模型,杂乱到足以给出十分有期望的成果。

学习概率密度函数的模型大致可分为两类。

首要显式地学习pdf( 概率散布函数 ),因而咱们增加一个已知的丢失函数。

其次隐式学习pdf,丢失函数能够是不知道的。

VAE是榜首种办法的比如,GAN是第二种办法中最为人所知的。

自编码器神经网络

在VAE入门之前,让咱们从简略的模型,通用自编码器开端。自编码器在输出端猜测相同的输入数据。它由两部分组成:编码器承受输入数据并将其编码为潜在维度,这通常远小于原始数据的维度。解码器将生成的潜在维度表明为等于输入的维度,使得输出数据尽或许挨近输入样本。自编码器不需求标签,可用于进步图画质量(去除噪声),下降维度等。咱们能够说这种模型能够从头生成数据,但它不是生成模型。原因是模型没有随机成分来生成一些新的样本,它是彻底确认性的,仅仅重复输入信号。

变分自编码器

从VAE开端的要害思维触及到自编码器短少的成分。为了引进缺失的随机性成分,咱们在Z中增加了一个约束,使得咱们的样本在特定概率密度函数之后散布在潜在空间Z中。

换句话说,咱们履行一些特定的形状,运用编码器将原始样本映射到某些散布下的高档特征,并运用解码器重建图画。咱们将从小的(即来自某些散布的样本,通常是正常的样本)进行采样,而不是从原始的大像素维度采样,并将咱们的样本小z和解码z放到一些实践的样本中。然后咱们能够采样来生成新的数据点。

在这样的模型中,咱们将确认性神经网络称为(在练习进程完成后进行确认),而且运用非确认性的神经网络来对新图画进行采样。神经网络的方针是学习这样的参数的生成进程下以最大化每个的概率: ()=∫(|; )()

早年面的等式咱们得到一个最大似然问题,咱们想要知道(|)和()。咱们不想核算积分,所以让咱们将(|)引进样本值从或许发生,而不是整个()的或许性,从核算的视点来看太难了。可是(|)也是不知道的。现在,变分推理的作用是用(|)近似(|)。因而,背面的要害思维是找到一个足以表明实在函数的近似函数(这便是咱们的优化问题的界说)。

近似函数将是咱们的神经编码器,从练习数据点X到(|)之后的或许点Z,模型是(|)

为了得到(|), 咱们核算KL散度与真实的散布(|)

运用贝叶斯规矩于(|):

让咱们更改一下符号把右边的等式从头排列一下:

现在将期望扩大到第二项,并注意到新的K项呈现了

因而,VAE方针函数是

这意味着为了模仿咱们数据的对数似然(log()),咱们有必要考虑一些不行核算和非负的近似差错([(|)||(|)]) 。方程的右侧等于咱们数据的重构丢失,给定潜在空间(神经解码器重构丢失),减去咱们潜在表明的正则化(神经编码器表达超越先验)。

接下来要做的是界说(|)形状来核算它与先验的散度(咱们期望以恰当的办法在表面上制作映射样本)。所提出的方草遛社区法是在正态散布上散布猜测时间()和 ()。在这样的设置中,咱们的(|)变成N((),())和()变成N(0,1),这答应咱们核算KL-散度如下

考虑到这一点,咱们的VAE设置将如下所示

该模型使编码器猜测挨近先验散布的平均值和标准偏差(从咱们的样本中提取的特征应该挨近散布),然后咱们从样本Z采样,将其提供给解码器并重构样本(有一普济一城些差错)。稍后咱们将能够从先验的散布中移除编码器和样本,假定解码器能够再生好像合理的样本。总结,变分办法学通知咱们能够将项目Z映射到新的样本,并从原始样本中得到一些差错。此差错表明为下限,或ELBO(差错下限优化)。

但是,在上面的设置中,有一件事让咱们无法完成它。由于神经网络选用反向传达算法进行练习,因而需求具有上升梯度的成分。一起,不清楚怎么将梯度与[((),())|| N(0,1)]衔接,由于该项不是可微函数。这个问题的解霓裳记决办法是经过运用以下技巧使采样进程不同来完成的

这称为从头参数化技巧。它答应咱们以变分办法练习端到端体系。

在练习模型之后,咱们能够经过挑选的激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程随机平均值和标准偏差来生成新样本并对其进行解码(丢掉编码器成分)。

PyTorch激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程 VAE的比如

在现代结构中施行VAE模型并不太难,如下所示

class VAE(nn.Module):
def __init__(self, data_dim=784, z_dim=10, hidden_dim=500):
"""
VAE basic mode保止法l.
Args:
data_dim (int): dimension of flatten input
z_dim (int): dimension of manifold
hidden_dim (int): dimension of hidden layers between input and manifold
"""
super(VAE, self).__init__()
self.fc1 = nn.Linear(data_dim, hidden_dim)
self.hidden2mu = nn.Linear(hidden_dim, z_dim)
self.hidden2log_var = nn.Linear(hidden_dim, z_dim)
self.fc3 = nn.Linear(z_dim, hidden_dim)
self.fc4 = nn.Linear(hidden_dim, data_dim)
self.sigmoid = nn.Sigmoid()
def encode(self, x):
h1 = F.relu(self.fc1(x))
return self.hidden2mu(h1), self.hidden2log_var(h1)
def decode(self, z):
h3 = F.relu(self.fc3(z))
return self.sigmoid(051095510self.fc4(h3))
def reparam(self, mu, log_var):
std = torch.exp(0.5*log_var)
eps = torch.randn_like(std)
return mu + eps * std
def forward(self, x):
mu, log_var = self.encode(x.view(-1, 784))
z = self.reparam(mu, log_var)
return self.decode(z), mu, log_var

上面的示例代码片段界说了模型,该模型将输入展平数据表明,然后经过给定巨细的一个色皇宫躲藏层将其映射到潜在表明。从到解码器输出的转化也运用与编码器中的躲藏层相同巨细的一个躲藏层来履行。办法提出榜首个得到对数均值和方差核算,并经过在prepram办法中完成的从头参数化技巧来核算 。

模型的丢失函数如下所示

 def loss_func(x_reconstructed, x, mu, log_var):
"""
Loss function for VAE
Args:
x_reconstructed (torch.Tenor): decoder output [batch_size, input_size]
x (torch.Tensor): input data [batch_size, input_size]
mu (torch.Tensor): [batch_size, z_dim]
log_var (torch.Tensor): [batch_size, z_dim]
Returns (torch.Tensor): tensor of single loss value
"""
# Reconstruction loss
bce = F.binary_cross_entropy(x_reconstructed, x.view(-1, input_dim), reduction="sum")
# KL divergence
kld = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())
return bce + kld

咱们首要用二元穿插熵核算重构丢失,然后用KL散度项核算重构丢失。

因而模型学习后到大约25个周期时生成传神的图画(MNIST示例):

完好代码如下所示:

import os
import numpy as np
import torch
from torch import nn, optim
from torch.nn import functional as F
from torchvision import datasets, transforms
from torchvision.utils import save_image
device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu")
class VAE(nn.Module):
def __init__(self, data_dim=784, z_dim=10, hidden_dim=500):
"""
VAE basic model.
Args:
data_dim (int): dimension of flatten input
z_dim (int): dimension of manifold
hidden_dim (int): dimension of hidden layers between input and manifold
"""
super(VAE, self).__init__()
self.fc1 = nn.Linear(data_dim, hidden_dim)
self.hidden2mu = nn.Linear(hidden_dim, z_dim)
self.hidden2log_var = nn.Linear(hidden_dim, z_dim)
self.fc3 = nn.Linear(z_dim, hidden_dim)
self.fc4 = nn.Linear(hidden_dim, data_dim)
self.sigmoid = nn.Sigmoid()
def encod激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程e(self, x):
h1 = F.relu(sel激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程f.fc1(x))
return self.hidden2mu(h1), self.hidden2log_var(h1)
def decode(self, z):
h3 = F.relu(self.fc3(z))
return self.sigmoid(self.fc4(h3))
def reparam(self, mu, log_var):
std = torch.exp(0.5*log_var)
eps = torch.randn_like(std)
return mu + eps * std
def forward(self, x):
mu, log_var = self.encode(x.view(-1, 784))
z = self.repa巧织馆织造视频全集ram(mu, log_var)
return self.decode(z), mu, log_var
def train(data_loader, model, loss_func黑陨石炸鸡, epoch):
model.train()
train_loss = 0
for batch_i, (data, _) in enumerate(data_loader):
data = data.to(device)
optimizer.zero_grad()
recon_batch, mu, log_var = model(data)
loss = loss_func(recon_batch, data, mu, log_var)
loss.backward()
train_loss += loss.item()
optimizer.step()
if batch_i % 50 == 0:
print('Tr激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程ain Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
epoch, batch_i * len(data), len(data_loader.dataset),
100. * batch_i / len(data_loader),
loss.item() / len(data)))
print('====> Epoch: {} Average loss: {:.4f}'.format(
epoch, train_loss / len(data_loader.dataset)))
def test(data_loader, model, loss_func):
model.eval()
test_loss = 0
with torch.no_grad():
for i, (data, _) in enumerate(data_loader):
data = data.to(device)
recon_batc激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程h, mu, log_var = model(data)
test_loss += loss_func(recon_batch, data, mu, log_var).item()
test_los里见莉芳s /= len(data_loader.dataset)
print('====> Test set loss: {:.4f}'.format(test_loss))
if __name__ == "__main__":
np.random.seed(2019)
torch.manual_seed(2019)
config = {
'epochs': 50,
'z_dim': 30,
'input_dim': 784,
'hidden_dim': 200,
'batch_size': 128,
'lr': 0.001,
}
epochs = config['epochs']
batch_size = config['batch_size']
input_dim = config['input_dim']
z_dim = config['z_dim']
hidden_dim = config['hidden_dim']
lr = config['lr']
# Create directory for resulting images
if not os.path.exists('results/reconstruction'):
os.makedirs('results/reconstruction')
model = VAE(input_dim, z_di美国少女m, hidden_dim).to(device)
optimizer = optim.Adam(model.parameters(), lr=lr)
def loss_func(x_reconstructed, x, mu, log_var):
"""
Loss function for VAE
Args:
x_reconstructed (torch.Tenor): dec消失的爱人深度解析oder output [batch_size, input_size]
x (torch.Tensor): input data [batch_size, input_size]
mu (torch.Tensor): [batch_size, z_dim]
log_var (torch.Tensor): [batch_size, z_dim]
Returns (torch.Tensor): tensor of single loss value
"""
# Reconstruction loss
bce = F.binary_cross激光祛斑,全本小说-王者荣耀中的骚走位,游戏走位教程_entropy(x_reconstructed, x.view(-1, input_dim), reduction="sum")
# KL divergence
kld = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())
return bce + kld
# Load data
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=True, download=True,
transform=transforms.ToTensor()),
batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
datasets.MNIST('../data', train=False,
transform=transforms.ToTens姐姐的男朋友or()),
batch_size=batch_size, shuffle=True)
for epoch in range(1, epochs+1):
train(train_loader, model, loss_func, epoch)
test(test_loader, model, loss_func)
w电磁除铁器ccscdith torch.no_grad():
sample = torch.randn(20, z_dim).to(device)
sample = model.decode(sample).cpu()
save_image(sample.view(20, 1, 28, 28), f'results/sample_{epoch}.png', nro鲜胎活剥w=10)

相关文章

标签列表