code stringlengths 17 6.64M |
|---|
class MixtureODELayer(nn.Module):
'Produces a mixture of experts where output = sigma(t) * f(t, x).\n Time-dependent weights sigma(t) help learn to blend the experts without resorting to a highly stiff f.\n Supports both regular and diffeq experts.\n '
def __init__(self, experts):
super(Mixt... |
class ResNet(container.SequentialDiffEq):
def __init__(self, dim, intermediate_dim, n_resblocks, conv_block=None):
super(ResNet, self).__init__()
if (conv_block is None):
conv_block = basic.ConcatCoordConv2d
self.dim = dim
self.intermediate_dim = intermediate_dim
... |
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, dim, conv_block=None):
super(BasicBlock, self).__init__()
if (conv_block is None):
conv_block = basic.ConcatCoordConv2d
self.norm1 = nn.GroupNorm(NGROUPS, dim, eps=0.0001)
self.relu1 = nn.ReLU(inplace=Tr... |
class DiffEqWrapper(nn.Module):
def __init__(self, module):
super(DiffEqWrapper, self).__init__()
self.module = module
if (len(signature(self.module.forward).parameters) == 1):
self.diffeq = (lambda t, y: self.module(y))
elif (len(signature(self.module.forward).paramet... |
def diffeq_wrapper(layer):
return DiffEqWrapper(layer)
|
class ReshapeDiffEq(nn.Module):
def __init__(self, input_shape, net):
super(ReshapeDiffEq, self).__init__()
assert (len(signature(net.forward).parameters) == 2), 'use diffeq_wrapper before reshape_wrapper.'
self.input_shape = input_shape
self.net = net
def forward(self, t, x)... |
def reshape_wrapper(input_shape, layer):
return ReshapeDiffEq(input_shape, layer)
|
class ZeroMeanTransform(nn.Module):
def __init__(self):
nn.Module.__init__(self)
def forward(self, x, logpx=None, reverse=False):
if reverse:
x = (x + 0.5)
if (logpx is None):
return x
return (x, logpx)
else:
x = (x - 0.... |
class LogitTransform(nn.Module):
'\n The proprocessing step used in Real NVP:\n y = sigmoid(x) - a / (1 - 2a)\n x = logit(a + (1 - 2a)*y)\n '
def __init__(self, alpha=_DEFAULT_ALPHA):
nn.Module.__init__(self)
self.alpha = alpha
def forward(self, x, logpx=None, reverse=False):... |
class SigmoidTransform(nn.Module):
'Reverse of LogitTransform.'
def __init__(self, alpha=_DEFAULT_ALPHA):
nn.Module.__init__(self)
self.alpha = alpha
def forward(self, x, logpx=None, reverse=False):
if reverse:
return _logit(x, logpx, self.alpha)
else:
... |
def _logit(x, logpx=None, alpha=_DEFAULT_ALPHA):
s = (alpha + ((1 - (2 * alpha)) * x))
y = (torch.log(s) - torch.log((1 - s)))
if (logpx is None):
return y
return (y, (logpx - _logdetgrad(x, alpha).view(x.size(0), (- 1)).sum(1, keepdim=True)))
|
def _sigmoid(y, logpy=None, alpha=_DEFAULT_ALPHA):
x = ((torch.sigmoid(y) - alpha) / (1 - (2 * alpha)))
if (logpy is None):
return x
return (x, (logpy + _logdetgrad(x, alpha).view(x.size(0), (- 1)).sum(1, keepdim=True)))
|
def _logdetgrad(x, alpha):
s = (alpha + ((1 - (2 * alpha)) * x))
logdetgrad = ((- torch.log((s - (s * s)))) + math.log((1 - (2 * alpha))))
return logdetgrad
|
class BruteForceLayer(nn.Module):
def __init__(self, dim):
super(BruteForceLayer, self).__init__()
self.weight = nn.Parameter(torch.eye(dim))
def forward(self, x, logpx=None, reverse=False):
if (not reverse):
y = F.linear(x, self.weight)
if (logpx is None):
... |
class PlanarFlow(nn.Module):
def __init__(self, nd=1):
super(PlanarFlow, self).__init__()
self.nd = nd
self.activation = torch.tanh
self.register_parameter('u', nn.Parameter(torch.randn(self.nd)))
self.register_parameter('w', nn.Parameter(torch.randn(self.nd)))
sel... |
class MovingBatchNormNd(nn.Module):
def __init__(self, num_features, eps=0.0001, decay=0.1, bn_lag=0.0, affine=True):
super(MovingBatchNormNd, self).__init__()
self.num_features = num_features
self.affine = affine
self.eps = eps
self.decay = decay
self.bn_lag = bn_... |
def stable_var(x, mean=None, dim=1):
if (mean is None):
mean = x.mean(dim, keepdim=True)
mean = mean.view((- 1), 1)
res = torch.pow((x - mean), 2)
max_sqr = torch.max(res, dim, keepdim=True)[0]
var = (torch.mean((res / max_sqr), 1, keepdim=True) * max_sqr)
var = var.view((- 1))
var... |
class MovingBatchNorm1d(MovingBatchNormNd):
@property
def shape(self):
return [1, (- 1)]
|
class MovingBatchNorm2d(MovingBatchNormNd):
@property
def shape(self):
return [1, (- 1), 1, 1]
|
class BasicBlock(nn.Module):
expansion = 1
def __init__(self, dim):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(dim, dim, kernel_size=3, padding=1, bias=False)
self.bn1 = nn.GroupNorm(2, dim, eps=0.0001)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.C... |
class ResNeXtBottleneck(nn.Module):
'\n RexNeXt bottleneck type C (https://github.com/facebookresearch/ResNeXt/blob/master/models/resnext.lua)\n '
def __init__(self, dim, cardinality=4, base_depth=32):
' Constructor\n Args:\n in_channels: input channel dimensionality\n ... |
class SqueezeLayer(nn.Module):
def __init__(self, downscale_factor):
super(SqueezeLayer, self).__init__()
self.downscale_factor = downscale_factor
def forward(self, x, logpx=None, reverse=False):
if reverse:
return self._upsample(x, logpx)
else:
return... |
def unsqueeze(input, upscale_factor=2):
'\n [:, C*r^2, H, W] -> [:, C, H*r, W*r]\n '
(batch_size, in_channels, in_height, in_width) = input.size()
out_channels = (in_channels // (upscale_factor ** 2))
out_height = (in_height * upscale_factor)
out_width = (in_width * upscale_factor)
input... |
def squeeze(input, downscale_factor=2):
'\n [:, C, H*r, W*r] -> [:, C*r^2, H, W]\n '
(batch_size, in_channels, in_height, in_width) = input.size()
out_channels = (in_channels * (downscale_factor ** 2))
out_height = (in_height // downscale_factor)
out_width = (in_width // downscale_factor)
... |
class MultiscaleParallelCNF(nn.Module):
'\n CNF model for image data.\n\n Squeezes the input into multiple scales, applies different conv-nets at each scale\n and adds the resulting gradients\n\n Will downsample the input until one of the\n dimensions is less than or equal to 4.\n\n Args:\n ... |
class ParallelSumModules(nn.Module):
def __init__(self, models):
super(ParallelSumModules, self).__init__()
self.models = nn.ModuleList(models)
self.cpu = (not torch.cuda.is_available())
def forward(self, t, y):
out = sum((model(t, y) for model in self.models))
return... |
class ParallelCNFLayers(layers.SequentialFlow):
def __init__(self, initial_size, idims=(32,), scales=4, init_layer=None, n_blocks=1, time_length=1.0):
strides = tuple(([1] + [1 for _ in idims]))
chain = []
if (init_layer is not None):
chain.append(init_layer)
get_size ... |
class Uniform(nn.Module):
def __init__(self, a=0, b=1):
super(Normal, self).__init__()
self.a = Variable(torch.Tensor([a]))
self.b = Variable(torch.Tensor([b]))
def _check_inputs(self, size, params):
if ((size is None) and (params is None)):
raise ValueError('Eith... |
class Normal(nn.Module):
'Samples from a Normal distribution using the reparameterization trick.\n '
def __init__(self, mu=0, sigma=1):
super(Normal, self).__init__()
self.normalization = Variable(torch.Tensor([np.log((2 * np.pi))]))
self.mu = Variable(torch.Tensor([mu]))
s... |
class Laplace(nn.Module):
'Samples from a Laplace distribution using the reparameterization trick.\n '
def __init__(self, mu=0, scale=1):
super(Laplace, self).__init__()
self.normalization = Variable(torch.Tensor([(- math.log(2))]))
self.mu = Variable(torch.Tensor([mu]))
se... |
class SpectralNorm(object):
def __init__(self, name='weight', dim=0, eps=1e-12):
self.name = name
self.dim = dim
self.eps = eps
def compute_weight(self, module, n_power_iterations):
if (n_power_iterations < 0):
raise ValueError('Expected n_power_iterations to be n... |
def inplace_spectral_norm(module, name='weight', dim=None, eps=1e-12):
'Applies spectral normalization to a parameter in the given module.\n\n .. math::\n \\mathbf{W} = \\dfrac{\\mathbf{W}}{\\sigma(\\mathbf{W})} \\\\\n \\sigma(\\mathbf{W}) = \\max_{\\mathbf{h}: \\mathbf{h} \\ne 0} \\dfrac{\\|\\... |
def remove_spectral_norm(module, name='weight'):
'Removes the spectral normalization reparameterization from a module.\n\n Args:\n module (nn.Module): containing module\n name (str, optional): name of weight parameter\n\n Example:\n >>> m = spectral_norm(nn.Linear(40, 10))\n >>> ... |
def makedirs(dirname):
if (not os.path.exists(dirname)):
os.makedirs(dirname)
|
def get_logger(logpath, filepath, package_files=[], displaying=True, saving=True, debug=False):
logger = logging.getLogger()
if debug:
level = logging.DEBUG
else:
level = logging.INFO
logger.setLevel(level)
if saving:
info_file_handler = logging.FileHandler(logpath, mode='a... |
class AverageMeter(object):
'Computes and stores the average and current value'
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += (val... |
class RunningAverageMeter(object):
'Computes and stores the average and current value'
def __init__(self, momentum=0.99):
self.momentum = momentum
self.reset()
def reset(self):
self.val = None
self.avg = 0
def update(self, val):
if (self.val is None):
... |
def inf_generator(iterable):
'Allows training with DataLoaders in a single infinite loop:\n for i, (x, y) in enumerate(inf_generator(train_loader)):\n '
iterator = iterable.__iter__()
while True:
try:
(yield iterator.__next__())
except StopIteration:
itera... |
def save_checkpoint(state, save, epoch):
if (not os.path.exists(save)):
os.makedirs(save)
filename = os.path.join(save, ('checkpt-%04d.pth' % epoch))
torch.save(state, filename)
|
def isnan(tensor):
return (tensor != tensor)
|
def logsumexp(value, dim=None, keepdim=False):
'Numerically stable implementation of the operation\n value.exp().sum(dim, keepdim).log()\n '
if (dim is not None):
(m, _) = torch.max(value, dim=dim, keepdim=True)
value0 = (value - m)
if (keepdim is False):
m = m.squeez... |
def add_noise(x):
'\n [0, 1] -> [0, 255] -> add noise -> [0, 1]\n '
if args.add_noise:
noise = x.new().resize_as_(x).uniform_()
x = ((x * 255) + noise)
x = (x / 256)
return x
|
def update_lr(optimizer, itr):
iter_frac = min((float((itr + 1)) / max(args.warmup_iters, 1)), 1.0)
lr = (args.lr * iter_frac)
for param_group in optimizer.param_groups:
param_group['lr'] = lr
|
def get_train_loader(train_set, epoch):
if (args.batch_size_schedule != ''):
epochs = ([0] + list(map(int, args.batch_size_schedule.split('-'))))
n_passed = sum((np.array(epochs) <= epoch))
current_batch_size = int((args.batch_size * n_passed))
else:
current_batch_size = args.b... |
def get_dataset(args):
trans = (lambda im_size: tforms.Compose([tforms.Resize(im_size), tforms.ToTensor(), add_noise]))
if (args.data == 'mnist'):
im_dim = 1
im_size = (28 if (args.imagesize is None) else args.imagesize)
train_set = dset.MNIST(root='./data', train=True, transform=trans... |
def compute_bits_per_dim(x, model):
zero = torch.zeros(x.shape[0], 1).to(x)
(z, delta_logp) = model(x, zero)
logpz = standard_normal_logprob(z).view(z.shape[0], (- 1)).sum(1, keepdim=True)
logpx = (logpz - delta_logp)
logpx_per_dim = (torch.sum(logpx) / x.nelement())
bits_per_dim = ((- (logpx_... |
def create_model(args, data_shape, regularization_fns):
hidden_dims = tuple(map(int, args.dims.split(',')))
strides = tuple(map(int, args.strides.split(',')))
if args.multiscale:
model = odenvp.ODENVP((args.batch_size, *data_shape), n_blocks=args.num_blocks, intermediate_dims=hidden_dims, nonlinea... |
def batch_iter(X, batch_size=args.batch_size, shuffle=False):
'\n X: feature tensor (shape: num_instances x num_features)\n '
if shuffle:
idxs = torch.randperm(X.shape[0])
else:
idxs = torch.arange(X.shape[0])
if X.is_cuda:
idxs = idxs.cuda()
for batch_idxs in idxs.sp... |
def update_lr(optimizer, n_vals_without_improvement):
global ndecs
if ((ndecs == 0) and (n_vals_without_improvement > (args.early_stopping // 3))):
for param_group in optimizer.param_groups:
param_group['lr'] = (args.lr / 10)
ndecs = 1
elif ((ndecs == 1) and (n_vals_without_imp... |
def load_data(name):
if (name == 'bsds300'):
return datasets.BSDS300()
elif (name == 'power'):
return datasets.POWER()
elif (name == 'gas'):
return datasets.GAS()
elif (name == 'hepmass'):
return datasets.HEPMASS()
elif (name == 'miniboone'):
return datasets... |
def build_model(input_dim):
hidden_dims = tuple(map(int, args.dims.split('-')))
chain = []
for i in range(args.depth):
if args.glow:
chain.append(layers.BruteForceLayer(input_dim))
chain.append(layers.MaskedCouplingLayer(input_dim, hidden_dims, 'alternate', swap=((i % 2) == 0))... |
def compute_loss(x, model):
zero = torch.zeros(x.shape[0], 1).to(x)
(z, delta_logp) = model(x, zero)
logpz = standard_normal_logprob(z).view(z.shape[0], (- 1)).sum(1, keepdim=True)
logpx = (logpz - delta_logp)
loss = (- torch.mean(logpx))
return loss
|
def restore_model(model, filename):
checkpt = torch.load(filename, map_location=(lambda storage, loc: storage))
model.load_state_dict(checkpt['state_dict'])
return model
|
def construct_model():
if args.nf:
chain = []
for i in range(args.depth):
chain.append(layers.PlanarFlow(2))
return layers.SequentialFlow(chain)
else:
chain = []
for i in range(args.depth):
if args.glow:
chain.append(layers.BruteF... |
def get_transforms(model):
if args.nf:
sample_fn = None
else:
def sample_fn(z, logpz=None):
if (logpz is not None):
return model(z, logpz, reverse=True)
else:
return model(z, reverse=True)
def density_fn(x, logpx=None):
if (... |
def compute_loss(args, model, batch_size=None):
if (batch_size is None):
batch_size = args.batch_size
x = toy_data.inf_train_gen(args.data, batch_size=batch_size)
x = torch.from_numpy(x).type(torch.float32).to(device)
zero = torch.zeros(x.shape[0], 1).to(x)
(z, delta_logp) = model(x, zero)... |
def sample_data(data=None, rng=None, batch_size=200):
'data and rng are ignored.'
inds = np.random.choice(int(probs.shape[0]), int(batch_size), p=probs)
m = means[inds]
samples = ((np.random.randn(*m.shape) * std) + m)
return samples
|
def get_transforms(model):
def sample_fn(z, logpz=None):
if (logpz is not None):
return model(z, logpz, reverse=True)
else:
return model(z, reverse=True)
def density_fn(x, logpx=None):
if (logpx is not None):
return model(x, logpx, reverse=False)
... |
def compute_loss(args, model, batch_size=None):
if (batch_size is None):
batch_size = args.batch_size
x = sample_data(args.data, batch_size=batch_size)
x = torch.from_numpy(x).type(torch.float32).to(device)
zero = torch.zeros(x.shape[0], 1).to(x)
(z, delta_logp) = model(x, zero)
logpz ... |
def standard_normal_logprob(z):
logZ = ((- 0.5) * math.log((2 * math.pi)))
return (logZ - (z.pow(2) / 2))
|
def set_cnf_options(args, model):
def _set(module):
if isinstance(module, layers.CNF):
module.solver = args.solver
module.atol = args.atol
module.rtol = args.rtol
if (args.step_size is not None):
module.solver_options['step_size'] = args.ste... |
def override_divergence_fn(model, divergence_fn):
def _set(module):
if isinstance(module, layers.ODEfunc):
if (divergence_fn == 'brute_force'):
module.divergence_fn = divergence_bf
elif (divergence_fn == 'approximate'):
module.divergence_fn = diverg... |
def count_nfe(model):
class AccNumEvals(object):
def __init__(self):
self.num_evals = 0
def __call__(self, module):
if isinstance(module, layers.ODEfunc):
self.num_evals += module.num_evals()
accumulator = AccNumEvals()
model.apply(accumulator)
... |
def count_parameters(model):
return sum((p.numel() for p in model.parameters() if p.requires_grad))
|
def count_total_time(model):
class Accumulator(object):
def __init__(self):
self.total_time = 0
def __call__(self, module):
if isinstance(module, layers.CNF):
self.total_time = (self.total_time + (module.sqrt_end_time * module.sqrt_end_time))
accumula... |
def add_spectral_norm(model, logger=None):
'Applies spectral norm to all modules within the scope of a CNF.'
def apply_spectral_norm(module):
if ('weight' in module._parameters):
if logger:
logger.info('Adding spectral norm to {}'.format(module))
spectral_norm.... |
def spectral_norm_power_iteration(model, n_power_iterations=1):
def recursive_power_iteration(module):
if hasattr(module, spectral_norm.POWER_ITERATION_FN):
getattr(module, spectral_norm.POWER_ITERATION_FN)(n_power_iterations)
model.apply(recursive_power_iteration)
|
def append_regularization_to_log(log_message, regularization_fns, reg_states):
for (i, reg_fn) in enumerate(regularization_fns):
log_message = (((log_message + ' | ') + INV_REGULARIZATION_FNS[reg_fn]) + ': {:.8f}'.format(reg_states[i].item()))
return log_message
|
def create_regularization_fns(args):
regularization_fns = []
regularization_coeffs = []
for (arg_key, reg_fn) in six.iteritems(REGULARIZATION_FNS):
if (getattr(args, arg_key) is not None):
regularization_fns.append(reg_fn)
regularization_coeffs.append(eval(('args.' + arg_ke... |
def get_regularization(model, regularization_coeffs):
if (len(regularization_coeffs) == 0):
return None
acc_reg_states = tuple(([0.0] * len(regularization_coeffs)))
for module in model.modules():
if isinstance(module, layers.CNF):
acc_reg_states = tuple(((acc + reg) for (acc, r... |
def build_model_tabular(args, dims, regularization_fns=None):
hidden_dims = tuple(map(int, args.dims.split('-')))
def build_cnf():
diffeq = layers.ODEnet(hidden_dims=hidden_dims, input_shape=(dims,), strides=None, conv=False, layer_type=args.layer_type, nonlinearity=args.nonlinearity)
odefunc... |
def batch_iter(X, batch_size=args.batch_size, shuffle=False):
'\n X: feature tensor (shape: num_instances x num_features)\n '
if shuffle:
idxs = torch.randperm(X.shape[0])
else:
idxs = torch.arange(X.shape[0])
if X.is_cuda:
idxs = idxs.cuda()
for batch_idxs in idxs.sp... |
def update_lr(optimizer, n_vals_without_improvement):
global ndecs
if ((ndecs == 0) and (n_vals_without_improvement > (args.early_stopping // 3))):
for param_group in optimizer.param_groups:
param_group['lr'] = (args.lr / 10)
ndecs = 1
elif ((ndecs == 1) and (n_vals_without_imp... |
def load_data(name):
if (name == 'bsds300'):
return datasets.BSDS300()
elif (name == 'power'):
return datasets.POWER()
elif (name == 'gas'):
return datasets.GAS()
elif (name == 'hepmass'):
return datasets.HEPMASS()
elif (name == 'miniboone'):
return datasets... |
def compute_loss(x, model):
zero = torch.zeros(x.shape[0], 1).to(x)
(z, delta_logp) = model(x, zero)
logpz = standard_normal_logprob(z).view(z.shape[0], (- 1)).sum(1, keepdim=True)
logpx = (logpz - delta_logp)
loss = (- torch.mean(logpx))
return loss
|
def restore_model(model, filename):
checkpt = torch.load(filename, map_location=(lambda storage, loc: storage))
model.load_state_dict(checkpt['state_dict'])
return model
|
def get_transforms(model):
def sample_fn(z, logpz=None):
if (logpz is not None):
return model(z, logpz, reverse=True)
else:
return model(z, reverse=True)
def density_fn(x, logpx=None):
if (logpx is not None):
return model(x, logpx, reverse=False)
... |
def compute_loss(args, model, batch_size=None):
if (batch_size is None):
batch_size = args.batch_size
x = toy_data.inf_train_gen(args.data, batch_size=batch_size)
x = torch.from_numpy(x).type(torch.float32).to(device)
zero = torch.zeros(x.shape[0], 1).to(x)
(z, delta_logp) = model(x, zero)... |
def run(args, kwargs):
args.model_signature = str(datetime.datetime.now())[0:19].replace(' ', '_')
args.model_signature = args.model_signature.replace(':', '_')
snapshots_path = os.path.join(args.out_dir, (('vae_' + args.dataset) + '_'))
snap_dir = (snapshots_path + args.flow)
if (args.flow != 'no... |
def binary_loss_function(recon_x, x, z_mu, z_var, z_0, z_k, ldj, beta=1.0):
'\n Computes the binary loss function while summing over batch dimension, not averaged!\n :param recon_x: shape: (batch_size, num_channels, pixel_width, pixel_height), bernoulli parameters p(x=1)\n :param x: shape (batchsize, num... |
def multinomial_loss_function(x_logit, x, z_mu, z_var, z_0, z_k, ldj, args, beta=1.0):
'\n Computes the cross entropy loss function while summing over batch dimension, not averaged!\n :param x_logit: shape: (batch_size, num_classes * num_channels, pixel_width, pixel_height), real valued logits\n :param x... |
def binary_loss_array(recon_x, x, z_mu, z_var, z_0, z_k, ldj, beta=1.0):
'\n Computes the binary loss without averaging or summing over the batch dimension.\n '
batch_size = x.size(0)
if (len(ldj.size()) > 1):
ldj = ldj.view(ldj.size(0), (- 1)).sum((- 1))
bce = (- log_bernoulli(x.view(ba... |
def multinomial_loss_array(x_logit, x, z_mu, z_var, z_0, z_k, ldj, args, beta=1.0):
'\n Computes the discritezed logistic loss without averaging or summing over the batch dimension.\n '
num_classes = 256
batch_size = x.size(0)
x_logit = x_logit.view(batch_size, num_classes, args.input_size[0], a... |
def cross_entropy(input, target, weight=None, size_average=True, ignore_index=(- 100), reduce=True):
'\n Taken from the master branch of pytorch, accepts (N, C, d_1, d_2, ..., d_K) input shapes\n instead of only (N, C, d_1, d_2) or (N, C).\n This criterion combines `log_softmax` and `nll_loss` in a singl... |
def nll_loss(input, target, weight=None, size_average=True, ignore_index=(- 100), reduce=True):
'\n Taken from the master branch of pytorch, accepts (N, C, d_1, d_2, ..., d_K) input shapes\n instead of only (N, C, d_1, d_2) or (N, C).\n The negative log likelihood loss.\n See :class:`~torch.nn.NLLLoss... |
def calculate_loss(x_mean, x, z_mu, z_var, z_0, z_k, ldj, args, beta=1.0):
'\n Picks the correct loss depending on the input type.\n '
if (args.input_type == 'binary'):
(loss, rec, kl) = binary_loss_function(x_mean, x, z_mu, z_var, z_0, z_k, ldj, beta=beta)
bpd = 0.0
elif (args.input... |
def calculate_loss_array(x_mean, x, z_mu, z_var, z_0, z_k, ldj, args):
'\n Picks the correct loss depending on the input type.\n '
if (args.input_type == 'binary'):
loss = binary_loss_array(x_mean, x, z_mu, z_var, z_0, z_k, ldj)
elif (args.input_type == 'multinomial'):
loss = multino... |
def train(epoch, train_loader, model, opt, args, logger):
model.train()
train_loss = np.zeros(len(train_loader))
train_bpd = np.zeros(len(train_loader))
num_data = 0
beta = min([((epoch * 1.0) / max([args.warmup, 1.0])), args.max_beta])
logger.info('beta = {:5.4f}'.format(beta))
end = time... |
def evaluate(data_loader, model, args, logger, testing=False, epoch=0):
model.eval()
loss = 0.0
batch_idx = 0
bpd = 0.0
if (args.input_type == 'binary'):
loss_type = 'elbo'
else:
loss_type = 'bpd'
if (testing and ('cnf' in args.flow)):
override_divergence_fn(model, ... |
def log_normal_diag(x, mean, log_var, average=False, reduce=True, dim=None):
log_norm = ((- 0.5) * (log_var + (((x - mean) * (x - mean)) * log_var.exp().reciprocal())))
if reduce:
if average:
return torch.mean(log_norm, dim)
else:
return torch.sum(log_norm, dim)
els... |
def log_normal_normalized(x, mean, log_var, average=False, reduce=True, dim=None):
log_norm = ((- (x - mean)) * (x - mean))
log_norm *= torch.reciprocal((2.0 * log_var.exp()))
log_norm += ((- 0.5) * log_var)
log_norm += ((- 0.5) * torch.log((2.0 * PI)))
if reduce:
if average:
r... |
def log_normal_standard(x, average=False, reduce=True, dim=None):
log_norm = (((- 0.5) * x) * x)
if reduce:
if average:
return torch.mean(log_norm, dim)
else:
return torch.sum(log_norm, dim)
else:
return log_norm
|
def log_bernoulli(x, mean, average=False, reduce=True, dim=None):
probs = torch.clamp(mean, min=MIN_EPSILON, max=MAX_EPSILON)
log_bern = ((x * torch.log(probs)) + ((1.0 - x) * torch.log((1.0 - probs))))
if reduce:
if average:
return torch.mean(log_bern, dim)
else:
r... |
def load_static_mnist(args, **kwargs):
'\n Dataloading function for static mnist. Outputs image data in vectorized form: each image is a vector of size 784\n '
args.dynamic_binarization = False
args.input_type = 'binary'
args.input_size = [1, 28, 28]
def lines_to_np_array(lines):
re... |
def load_freyfaces(args, **kwargs):
args.input_size = [1, 28, 20]
args.input_type = 'multinomial'
args.dynamic_binarization = False
TRAIN = 1565
VAL = 200
TEST = 200
with open('data/Freyfaces/freyfaces.pkl', 'rb') as f:
data = pickle.load(f, encoding='latin1')[0]
data = (data /... |
def load_omniglot(args, **kwargs):
n_validation = 1345
args.input_size = [1, 28, 28]
args.input_type = 'binary'
args.dynamic_binarization = True
def reshape_data(data):
return data.reshape(((- 1), 28, 28)).reshape(((- 1), (28 * 28)), order='F')
omni_raw = loadmat(os.path.join('data', ... |
def load_caltech101silhouettes(args, **kwargs):
args.input_size = [1, 28, 28]
args.input_type = 'binary'
args.dynamic_binarization = False
def reshape_data(data):
return data.reshape(((- 1), 28, 28)).reshape(((- 1), (28 * 28)), order='F')
caltech_raw = loadmat(os.path.join('data', 'Caltec... |
def load_dataset(args, **kwargs):
if (args.dataset == 'mnist'):
(train_loader, val_loader, test_loader, args) = load_static_mnist(args, **kwargs)
elif (args.dataset == 'caltech'):
(train_loader, val_loader, test_loader, args) = load_caltech101silhouettes(args, **kwargs)
elif (args.dataset ... |
def calculate_likelihood(X, model, args, logger, S=5000, MB=500):
N_test = X.size(0)
X = X.view((- 1), *args.input_size)
likelihood_test = []
if (S <= MB):
R = 1
else:
R = (S // MB)
S = MB
end = time.time()
for j in range(N_test):
x_single = X[j].unsqueeze(0... |
def plot_training_curve(train_loss, validation_loss, fname='training_curve.pdf', labels=None):
'\n Plots train_loss and validation loss as a function of optimization iteration\n :param train_loss: np.array of train_loss (1D or 2D)\n :param validation_loss: np.array of validation loss (1D or 2D)\n :par... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.