pytorch实现VAE

一、VAE的具体结构

二、VAE的pytorch实现

1加载并规范化MNIST

import相关类:

from __future__ import print_function
import argparse
import torch
import torch.utils.data
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
from torchvision import datasets, transforms

设置参数:

parser = argparse.ArgumentParser(description=‘PyTorch MNIST Example‘)
parser.add_argument(‘--batch-size‘, type=int, default=128, metavar=‘N‘,
                    help=‘input batch size for training (default: 128)‘)
parser.add_argument(‘--epochs‘, type=int, default=10, metavar=‘N‘,
                    help=‘number of epochs to train (default: 10)‘)
parser.add_argument(‘--no-cuda‘, action=‘store_true‘, default=False,
                    help=‘enables CUDA training‘)
parser.add_argument(‘--seed‘, type=int, default=1, metavar=‘S‘,
                    help=‘random seed (default: 1)‘)
parser.add_argument(‘--log-interval‘, type=int, default=10, metavar=‘N‘,
                    help=‘how many batches to wait before logging training status‘)
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
print(args)

#Sets the seed for generating random numbers. And returns a torch._C.Generator object.
torch.manual_seed(args.seed)
if args.cuda:
    torch.cuda.manual_seed(args.seed)    

输出结果:

Namespace(batch_size=128, cuda=True, epochs=10, log_interval=10, no_cuda=False, seed=1)

下载数据集到./data/目录下:

kwargs = {‘num_workers‘: 1, ‘pin_memory‘: True} if args.cuda else {}
trainset = datasets.MNIST(‘../data‘, train=True, download=True,transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(
    trainset,
    batch_size=args.batch_size, shuffle=True, **kwargs)
testset= datasets.MNIST(‘../data‘, train=False, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(
    testset,
    batch_size=args.batch_size, shuffle=True, **kwargs)
image, label = trainset[0]
print(len(trainset))
print(image.size())
image, label = testset[0]
print(len(testset))
print(image.size())

输出结果:

60000
torch.Size([1, 28, 28])
10000
torch.Size([1, 28, 28])

2定义VAE

class VAE(nn.Module):
    def __init__(self):
        super(VAE, self).__init__()

        self.fc1 = nn.Linear(784, 400)
        self.fc21 = nn.Linear(400, 20)
        self.fc22 = nn.Linear(400, 20)
        self.fc3 = nn.Linear(20, 400)
        self.fc4 = nn.Linear(400, 784)

        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def encode(self, x):
        h1 = self.relu(self.fc1(x))
        return self.fc21(h1), self.fc22(h1)

    def reparametrize(self, mu, logvar):
        std = logvar.mul(0.5).exp_()
        eps = Variable(std.data.new(std.size()).normal_())
        return eps.mul(std).add_(mu)

    def decode(self, z):
        h3 = self.relu(self.fc3(z))
        return self.sigmoid(self.fc4(h3))

    def forward(self, x):
        mu, logvar = self.encode(x.view(-1, 784))
        z = self.reparametrize(mu, logvar)
        return self.decode(z), mu, logvar

model = VAE()
if args.cuda:
    model.cuda()

3.定义一个损失函数



reconstruction_function = nn.BCELoss()
reconstruction_function.size_average = False

def loss_function(recon_x, x, mu, logvar):
    BCE = reconstruction_function(recon_x, x.view(-1, 784))

    # see Appendix B from VAE paper:
    # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014
    # https://arxiv.org/abs/1312.6114
    # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)
    KLD_element = mu.pow(2).add_(logvar.exp()).mul_(-1).add_(1).add_(logvar)
    KLD = torch.sum(KLD_element).mul_(-0.5)

    return BCE + KLD

optimizer = optim.Adam(model.parameters(), lr=1e-3)

4.在训练数据上训练神经网络

我们只需要对数据迭代器进行循环,并将输入反馈到网络并进行优化。

for epoch in range(1, args.epochs + 1):
    train(epoch)
    test(epoch)

其中

def train(epoch):
    model.train()
    train_loss = 0
    for batch_idx, (data, _) in enumerate(train_loader):
        data = Variable(data)
        if args.cuda:
            data = data.cuda()
        optimizer.zero_grad()
        recon_batch, mu, logvar = model(data)
        loss = loss_function(recon_batch, data, mu, logvar)
        loss.backward()
        train_loss += loss.data[0]
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print(‘Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}‘.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader),
                loss.data[0] / len(data)))

    print(‘====> Epoch: {} Average loss: {:.4f}‘.format(
          epoch, train_loss / len(train_loader.dataset)))

def test(epoch):
    model.eval()
    test_loss = 0
    for data, _ in test_loader:
        if args.cuda:
            data = data.cuda()
        data = Variable(data, volatile=True)
        recon_batch, mu, logvar = model(data)
        test_loss += loss_function(recon_batch, data, mu, logvar).data[0]

    test_loss /= len(test_loader.dataset)
    print(‘====> Test set loss: {:.4f}‘.format(test_loss))
时间: 2024-10-07 17:26:28

pytorch实现VAE的相关文章

Variational Auto-encoder(VAE)变分自编码器-Pytorch

import os import torch import torch.nn as nn import torch.nn.functional as F import torchvision from torchvision import transforms from torchvision.utils import save_image # 配置GPU或CPU设置 # Device configuration device = torch.device('cuda' if torch.cud

(转) The Incredible PyTorch

转自:https://github.com/ritchieng/the-incredible-pytorch The Incredible PyTorch What is this? This is inspired by the famous Awesome TensorFlow repository where this repository would hold tutorials, projects, libraries, videos, papers, books and anythi

库、教程、论文实现,这是一份超全的PyTorch资源列表(Github 2.2K星)

项目地址:https://github.com/bharathgs/Awesome-pytorch-list 列表结构: NLP 与语音处理 计算机视觉 概率/生成库 其他库 教程与示例 论文实现 PyTorch 其他项目 自然语言处理和语音处理 该部分项目涉及语音识别.多说话人语音处理.机器翻译.共指消解.情感分类.词嵌入/表征.语音生成.文本语音转换.视觉问答等任务,其中有一些是具体论文的 PyTorch 复现,此外还包括一些任务更广泛的库.工具集.框架. 这些项目有很多是官方的实现,其中

VAE代码学习

1.pytorch中给出的例子 https://github.com/pytorch/examples/blob/master/vae/main.py 实现过程非常简单: class VAE(nn.Module): def __init__(self): super(VAE, self).__init__() self.fc1 = nn.Linear(784, 400)#第一层,推断 self.fc21 = nn.Linear(400, 20)#对应均值 self.fc22 = nn.Linea

pytorch 学习笔记之编写 C 扩展,又涨姿势了

pytorch利用CFFI 进行 C 语言扩展.包括两个基本的步骤(docs): 编写 C 代码: python 调用 C 代码,实现相应的 Function 或 Module. 在之前的文章中,我们已经了解了如何自定义 Module.至于 [py]torch 的 C 代码库的结构,我们留待之后讨论: 这里,重点关注,如何在 pytorch C 代码库高层接口的基础上,编写 C 代码,以及如何调用自己编写的 C 代码. 官方示例了如何定义一个加法运算(见 repo).这里我们定义ReLU函数(见

解决运行pytorch程序多线程问题

当我使用pycharm运行  (https://github.com/Joyce94/cnn-text-classification-pytorch )  pytorch程序的时候,在Linux服务器上会开启多个进程,占用服务器的大量的CPU,在windows10上运行此程序的时候,本机的CPU和内存会被吃光,是因为在train.py中有大量的数据训练处理,会开启多个进程,占用大量的CPU和进程. 本机window10 linux服务器开启了多个进程 Linux服务器占用大量CPU 在pytor

PyTorch学习笔记之nn的简单实例

method 1 1 import torch 2 from torch.autograd import Variable 3 4 N, D_in, H, D_out = 64, 1000, 100, 10 5 x = Variable(torch.randn(N, D_in)) 6 y = Variable(torch.randn(N, D_out), requires_grad=False) 7 8 # define our model as a sequence of layers 9 m

pytorch中设定使用指定的GPU

转自:http://www.cnblogs.com/darkknightzh/p/6836568.html PyTorch默认使用从0开始的GPU,如果GPU0正在运行程序,需要指定其他GPU. 有如下两种方法来指定需要使用的GPU. 1. 类似tensorflow指定GPU的方式,使用CUDA_VISIBLE_DEVICES. 1.1 直接终端中设定: CUDA_VISIBLE_DEVICES=1 python main.py 1.2 python代码中设定: import os os.env

一线开发者在Reddit上讨论深度学习框架:PyTorch和TensorFlow到底哪个更好?

本文标签:   机器学习 TensorFlow Google深度学习框架 分布式机器学习 PyTorch   近日,Reddit用户 cjmcmurtrie 发了一个主题为「PyTorch vs. TensorFlow」的讨论帖,想要了解这两大流行的框架之间各自有什么优势. 原帖地址:https://redd.it/5w3q74 帖子一楼写道: 我还没有从 Torch7 迁移到 TensorFlow.我玩过 TensorFlow,但我发现 Torch7 更加直观(也许是我玩得不够?).我也尝试了