def make_inference_net():
shared = torch.nn.Sequential(torch.nn.Linear(dim_x, 512), torch.nn.ReLU())
return NormalNet(mu_net=torch.nn.Sequential(shared,
torch.nn.Linear(512, dim_z)),
sigma_net=torch.nn.Sequential(
shared, torch.nn.Linear(512, dim_z),
Lambda(lambda x: torch.exp(0.5 * x))))
def make_almost_generative_net(self, dim_x):
return NormalNet(
torch.nn.Linear(self.generative_net_input_dim, dim_x),
torch.nn.Sequential(
torch.nn.Linear(self.generative_net_input_dim, dim_x),
Lambda(lambda x: torch.exp(0.5 * x + self.
generative_sigma_adjustment))))
def make_almost_inference_net(self, dim_x):
ndf = self.inference_net_num_filters
model = torch.nn.Sequential(
# input is (nc) x 64 x 64
torch.nn.Conv2d(1, ndf, 4, 2, 1, bias=False),
torch.nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf) x 32 x 32
torch.nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
torch.nn.BatchNorm2d(ndf * 2),
torch.nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*2) x 16 x 16
torch.nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
torch.nn.BatchNorm2d(ndf * 4),
torch.nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*4) x 8 x 8
# Flatten the filter channels
Lambda(lambda x: x.view(x.size(0), -1)),
torch.nn.Linear((ndf * 4) * 8 * 8, self.inference_net_output_dim),
torch.nn.LeakyReLU(0.2, inplace=True)
# This is the rest of the DCGAN discriminator
# torch.nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
# torch.nn.BatchNorm2d(ndf * 8),
# torch.nn.LeakyReLU(0.2, inplace=True),
# # state size. (ndf*8) x 4 x 4
# torch.nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
# torch.nn.Sigmoid()
)
return (model.cuda() if self.use_gpu else model)
def make_almost_generative_net(self, dim_x):
# We learn a std dev for each pixel which is not a function of the input.
# Note that this Variable is NOT going to show up in `net.parameters()` and
# therefore it is implicitly free from the ridge penalty/p(theta) prior.
init_log_sigma = torch.log(1e-2 * torch.ones(1, 1, 64, 64))
# See https://github.com/pytorch/examples/blob/master/dcgan/main.py#L107
dim_in = self.generative_net_input_dim
ngf = self.generative_net_num_filters
model = torch.nn.Sequential(
Lambda(lambda x: x.view(-1, dim_in, 1, 1)),
torch.nn.ConvTranspose2d( dim_in, ngf * 8, 4, 1, 0, bias=False),
torch.nn.BatchNorm2d(ngf * 8),
torch.nn.ReLU(inplace=True),
# state size. (ngf*8) x 4 x 4
torch.nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
torch.nn.BatchNorm2d(ngf * 4),
torch.nn.ReLU(inplace=True),
# state size. (ngf*4) x 8 x 8
torch.nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
torch.nn.BatchNorm2d(ngf * 2),
torch.nn.ReLU(inplace=True),
# state size. (ngf*2) x 16 x 16
torch.nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False),
torch.nn.BatchNorm2d(ngf),
torch.nn.ReLU(inplace=True),
# state size. (ngf) x 32 x 32
torch.nn.ConvTranspose2d( ngf, 1, 4, 2, 1, bias=False),
# state size. 1 x 64 x 64
torch.nn.Tanh()
)
if self.use_gpu:
model = model.cuda()
init_log_sigma = init_log_sigma.cuda()
log_sigma = Variable(init_log_sigma, requires_grad=True)
return NormalNet(
model,
Lambda(
lambda x, log_sigma: torch.exp(log_sigma.expand(x.size(0), -1, -1, -1)) + 1e-3,
extra_args=(log_sigma,)
)
)
def make_almost_generative_net(self, dim_x):
return NormalNet(
torch.nn.Sequential(
torch.nn.ReLU(),
torch.nn.Linear(self.generative_net_input_dim, dim_x)),
torch.nn.Sequential(
torch.nn.ReLU(),
torch.nn.Linear(self.generative_net_input_dim, dim_x),
# Learn the log variance
Lambda(lambda x: torch.exp(0.5 * x))))
def make_generative_net(self, dim_x):
hidden_size = 16
shared = torch.nn.Sequential(torch.nn.Linear(self.dim_z, hidden_size),
torch.nn.ReLU())
return NormalNet(
torch.nn.Sequential(shared, torch.nn.Linear(hidden_size, dim_x)),
torch.nn.Sequential(
shared,
torch.nn.Linear(hidden_size, dim_x),
# Learn the log variance
Lambda(lambda x: torch.exp(0.5 * x))))
def make_inference_net(shared):
# return NormalNet(
# mu_net=torch.nn.Sequential(
# shared,
# torch.nn.Linear(dim_shared, dim_z)
# ),
# sigma_net=torch.nn.Sequential(
# shared,
# torch.nn.Linear(dim_shared, dim_z),
# Lambda(lambda x: torch.exp(0.5 * x))
# )
# )
return Normal_MeanPrecisionNet(
torch.nn.Sequential(shared, torch.nn.Linear(dim_shared, dim_z)),
torch.nn.Sequential(shared, torch.nn.Linear(dim_shared, dim_z),
Lambda(lambda x: torch.exp(0.5 * x))))
def make_generative_net():
return BernoulliNet(rate_net=torch.nn.Sequential(
torch.nn.Linear(dim_z, 512), torch.nn.ReLU(),
torch.nn.Linear(512, dim_x), Lambda(torch.sigmoid)))