DARLA 源码解析

最新推荐文章于 2020-02-01 18:29:20 发布
最新推荐文章于 2020-02-01 18:29:20 发布
阅读量408 收藏
点赞数
分类专栏： 强化学习 文章标签： 源码 强化学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Charel_CHEN/article/details/78612266
版权

DARLA 源码解析

标签（空格分隔）： 增强学习算法 源码


'''

Implementation of DARLA preprocessing, as found in DARLA: Improving Zero-Shot Transfer in Reinforcement Learning
by Higgins and Pal et al (https://arxiv.org/pdf/1707.08475.pdf):


DAE:

X_noisy --J--> Z ----> X_hat

minimizing (X_noisy-X_hat)^2


Beta VAE:

X ----> Z ----> X_hat

minimizing (J(X) - J(X_hat))^2 + beta*KL(Q(Z|X) || P(Z))


Right now this just trains the model using MNIST dataset

pytorch version

'''

import torch
import torch.nn as nn
import torchvision.datasets as dsets
from torchvision import datasets, transforms
from torch.autograd import Variable
from utils import *
from torch.nn import functional as F


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

        self.image_dim = 28 # a 28x28 image corresponds to 4 on the FC layer, a 64x64 image corresponds to 13
                            # can calculate this using output_after_conv() in utils.py
        self.latent_dim = 100  #论文中的特征表示
        self.noise_scale = 0.001
        self.batch_size = 50   

        #########编码器#################
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=4, stride=1),
            nn.ReLU(),
            nn.Conv2d(32, 32, kernel_size=4, stride=1),
            nn.ReLU(),
            nn.Conv2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.Conv2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU())
        self.fc1 = nn.Linear(32*4*4, self.latent_dim)

        ###########解码器################
        self.fc2 = nn.Linear(self.latent_dim, 32*4*4)
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 32, kernel_size=4, stride=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 1, kernel_size=4, stride=1),
            nn.ReLU())

    def forward(self, x):
    #encode-decode 前向传播 返回特征表示和解码输出值
        x = torch.add(x, Variable(self.noise_scale*torch.randn(self.batch_size, 1, self.image_dim, self.image_dim)))#
        z = self.encoder(x)
        z = z.view(-1, 32*4*4)
        z = self.fc1(z)
        x_hat = self.fc2(z)
        x_hat = x_hat.view(-1, 32, 4, 4)
        x_hat = self.decoder(x_hat)

        return z, x_hat

    def encode(self, x):
    #返回特征表示
        #x = x.unsqueeze(0)
        z, x_hat = self.forward(x)

        return z


def train_dae(num_epochs = 1, batch_size = 128, learning_rate = 1e-3):
    train_dataset = dsets.MNIST(root='./data/',         #### testing that it works with MNIST data
                                train=True,
                                transform=transforms.ToTensor(),
                                download=True)

    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('../data', train=True, download=True,
                       transform=transforms.ToTensor()), batch_size=batch_size, shuffle=True)

    dae = DAE()
    dae.batch_size = batch_size

    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(dae.parameters(), lr=learning_rate)

    for epoch in range(num_epochs):
        for i, (images, labels) in enumerate(train_loader):
            x = Variable(images)

            # Forward + Backward + Optimize
            optimizer.zero_grad()
            z, x_hat = dae(x)
            loss = criterion(x_hat, x)# 解码后与原图像的差别
            loss.backward()
            optimizer.step()

            if (i + 1) % 1 == 0:
                print('Epoch [%d/%d], Iter [%d/%d] Loss: %.4f'
                      % (epoch + 1, num_epochs, i + 1, len(train_dataset) // batch_size, loss.data[0]))

        torch.save(dae.state_dict(), 'dae-test-model.pkl')

#在编码过程中输出两个值，一个是特征表示的均值，一个是特征表示的方差
class BetaVAE(nn.Module):
    def __init__(self):
        super(BetaVAE, self).__init__()

        self.image_dim = 28 # a 28x28 image corresponds to 4 on the FC layer, a 64x64 image corresponds to 13
                            # can calculate this using output_after_conv() in utils.py
        self.latent_dim = 100
        self.batch_size = 50

        self.encoder = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=4, stride=1),
            nn.ReLU(),
            nn.Conv2d(32, 32, kernel_size=4, stride=1),
            nn.ReLU(),
            nn.Conv2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.Conv2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU())
        self.fc_mu = nn.Linear(32*4*4, self.latent_dim)
        self.fc_sigma = nn.Linear(32 * 4 * 4, self.latent_dim)
        self.fc_up = nn.Linear(self.latent_dim, 32*4*4)
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 32, kernel_size=4, stride=2),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 32, kernel_size=4, stride=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 1, kernel_size=4, stride=1),
            nn.ReLU())

    def forward(self, x):
        z = self.encoder(x)
        z = z.view(-1, 32*4*4)
        mu_z = self.fc_mu(z)
        log_sigma_z = self.fc_sigma(z)

        #通过方差和均值加上随机噪声进行采样，当作特征表示
        sample_z = mu_z + log_sigma_z.exp()*Variable(torch.randn(self.batch_size, self.latent_dim))
        x_hat = self.fc_up(sample_z)
        x_hat = x_hat.view(-1, 32, 4, 4)
        x_hat = self.decoder(x_hat)

        return mu_z, log_sigma_z, x_hat


def bvae_loss_function(z_hat, z, mu, logvar, beta=1, batch_size=128):
    RCL = F.mse_loss(z, z_hat) #reconstruction loss dae 和bave特征表示之间的loss

    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) #KL divergence
    # Normalise by same number of elements as in reconstruction
    KLD /= batch_size

    return RCL + beta*KLD

def train_bvae(num_epochs = 100, batch_size = 128, learning_rate = 1e-4):
    train_dataset = dsets.MNIST(root='./data/',  #### testing that it works with MNIST data
                                train=True,
                                transform=transforms.ToTensor(),
                                download=True)

    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('../data', train=True, download=True,
                       transform=transforms.ToTensor()), batch_size=batch_size, shuffle=True)

    bvae = BetaVAE()
    bvae.batch_size = batch_size

    dae = DAE()
    dae.load_state_dict(torch.load('dae-test-model.pkl'))
    dae.batch_size = batch_size
    dae.eval()

    optimizer = torch.optim.Adam(bvae.parameters(), lr=learning_rate)

    for epoch in range(num_epochs):
        for i, (images, labels) in enumerate(train_loader):
            x = Variable(images)

            # Forward + Backward + Optimize
            optimizer.zero_grad()
            mu_z, log_sigma_z, x_hat = bvae(x)
            #bvae 的损失函数
            loss = bvae_loss_function(dae.encode(x_hat), dae.encode(x), mu_z, 2*log_sigma_z, batch_size=batch_size)
            loss.backward()
            optimizer.step()

            if (i + 1) % 1 == 0:
                print('Epoch [%d/%d], Iter [%d/%d] Loss: %.4f'
                      % (epoch + 1, num_epochs, i + 1, len(train_dataset) // batch_size, loss.data[0]))

        torch.save(bvae.state_dict(), 'bvae-test-model.pkl')

if __name__ == '__main__':
    train_dae()   #预训练 DAE(普通自编码器)
    train_bvae()  #训练bave网络
    dae = DAE()
    dae.load_state_dict(torch.load('dae-test-model.pkl'))
    x = Variable(torch.randn(1, 1, 28, 28))
    bvae = BetaVAE()
    m,s,x_hat = bvae(x)

    print(m.size())
    z = dae.encode(x)
    print(z.size())
    print(x_hat.size())
    dae = DAE()
    x = Variable(torch.randn(1,1,28,28))
    z, x_hat = dae(x)
Charel_CHEN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手把手写C++服务器(39)：《Effective C++》读后感和一些思考
沉迷单车的追风少年
04-18 1038
《Effiective C++》是我最喜欢的书籍之一(或许没有之一)，里面详细介绍了改善程序设计的55种具体做法，对于C++程序员来说是一笔宝贵的财富，同时也是面试的高频考点，值得每隔一段时间就拿出来复习！！
linux-2.6.32.6源码目录结构分析及其driver所占比重
走南闯北的专栏
08-22 5975
linux-2.6.32.6源码目录结构分析及其driver所占比重
读论文-DARLA:Improving Zero-Shot Transfer in Reinforcement Learning
半个王子
02-26 726
DARLA:Improving Zero-Shot Transfer in Reinforcement Learning这篇文章发表于ICML2017，主要讲Reinforement learning算法在不同数据分布上的迁移。鉴于实验室讲论文讨论的要求，将该论文做成了ppt，供大家分享。总结，这篇文章关键点在于使用DAE将real world的state转换为latent state。另外，DA...
DARLA: Improving Zero-Shot Transfer in Reinforcement Learning 阅读笔记
Charel_CHEN的博客
11-23 1566
DARLA: Improving Zero-Shot Transfer in Reinforcement Learning标签（空格分隔）： 论文笔记 增强学习算法DARLA Improving Zero-Shot Transfer in Reinforcement Learning 目的和意义 训练领域和应用领域source domain and target domain 算法细则 该论文主要讲
Pytorch入门实战-----LSTM识别手写数据集
rongpeisheng666的博客
06-01 3251
LSTM长短期记忆网络，听说用来识别手写数据集有点大材小做，不过一直对语音、序列模型等等没怎么实践过，以后有空了再玩玩。 跑了一个epoch，正确率为97。 完整代码： import torch import torch.nn as nn import torchvision.transforms as transforms import torchvision.datasets as...
Effective Modern C++42招独家技巧助你改善C++11和C++14的高效用法笔记
网络资源是无限的
02-01 9631
Scott Meyers大师Effective三部曲：Effective C++、More Effective C++、Effective STL，这三本书出版已很多年，后来又出版了Effective Modern C++。 Effective C++的笔记见：https://blog.csdn.net/fengbingchun/article/details/102761542 More E...
【刷题记录】 UVA400 Unix is 命令
Hello World!
02-01 415
题意：输入正整数N以及N个文件名，按照A码排序后按照列优先的方式左对齐输出，假设最长文件名有M字符，其他列都是M+2字符，最右列为M字符。 Sample Input 10 tiny 2short4me very_long_file_name shorter size-1 size2 size3 much_longer_name 12345678.123 mid_size_name 12 W
Item26 Avoid overloading on universal references
zyfforlinux
12-27 1267
这个系列的文章来自于Effective Modern C++的读书笔记，我抽取了其中比较重要的，不容易理解的，平常我们开发过程中也不太在意的一些Item进行分析。 ​ 在正式进入本文主题之前先来看一段代码，这段代码的目的是纪录下当前的日期和时间，并纪录一下名字到全局的数据结构中，代码如下:std::multiset<std::string> names; void logAndAdd(const
usc imba 资料
06-18
南卡罗来纳大学的国际工商管理硕士（International MBA，简称IMBA）项目是位于Darla Moore商学院的一个特别的课程，这个课程的重点是培养那些有志于在国际市场中生活、学习、领导和成功的学生。项目不仅提供传统的...
dlm_plock.rar_translation
09-23
1. darla20_dsp.c：这看起来是一个与数字信号处理（DSP）相关的源代码文件，"darla20"可能是某种特定的硬件或软件模块的名称，"dsp"代表数字信号处理器或与之相关的算法。 2. dacnv50.c：此文件名暗示它可能涉及到...
OpenAI_gym的官网案例
Charel_CHEN的博客
11-23 7158
OpenAI_gym的官网案例Tags: openAI_gym创建，渲染，随机选择动作当然这只是gym的一个游戏，还有一些如： MountainCar-v0, MsPacman-v0 (requires the Atari dependency), or Hopper-v1 (requires the MuJoCo dependencies). Environments all descend fr
FeUdal Networks for Hierarchical Reinforcement Learning 阅读笔记
Charel_CHEN的博客
11-23 4979
FeUdal Networks for Hierarchical Reinforcement Learning标签（空格分隔）： 论文笔记 增强学习算法FeUdal Networks for Hierarchical Reinforcement Learning Abstract Introduction model Learning Transition Policy Gradients Arch
A2C Advantage Actor-Critic源码
Charel_CHEN的博客
11-23 4430
A2C Advantage Actor-Critic (离散空间)标签（空格分隔）： 增强学习算法 源码import numpy as np import tensorflow as tf import gymnp.random.seed(2) tf.set_random_seed(2) # reproducible# Superparameters OUTPUT_GRAPH = False #
Asynchronous Methods for Deep Reinforcement Learning 阅读笔记
Charel_CHEN的博客
11-23 2944
Asynchronous Methods for Deep Reinforcement Learning 阅读笔记标签（空格分隔）： 增强学习算法 论文笔记本文的贡献在于提出了异步学习的算法，并应用在A2C Q-learning等算法中 该论文作者提出了异步训练（Asynchronous Methods）的方法应用到强化学习的各个算法中（Sarsa,one-step Q-learning n-ste
Dynamic Programming - reinforcement learning
Charel_CHEN的博客
11-21 589
Dynamic Programming标签（空格分隔）： Reinforcement Learning: An Introduction Dynamic Programming Dynamic Programming Policy Evaluation Policy Improvement Policy Iteration Value Iteration Asynchronous Dynamic P
常用芯片手册芯片资料MAX260常用芯片手册芯片资料MAX260
最新发布
08-31
常用芯片手册芯片资料MAX260常用芯片手册芯片资料MAX260提取方式是百度网盘分享地址
常用芯片手册芯片资料82530常用芯片手册芯片资料82530
08-31
常用芯片手册芯片资料82530常用芯片手册芯片资料82530提取方式是百度网盘分享地址
如何通过CLRC663读取身份证信息？
04-24
4. 解析身份证信息，获取姓名、性别、出生日期、民族、地址、身份证号码等内容。 需要注意的是，使用CLRC663读取身份证信息需要遵守相关的法律法规和隐私保护原则，确保身份信息的安全和保密。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值