def _init_params(self):
"""
Initialize parameters for the layers in this generator module.
"""
if self.use_rand:
# random values will be stacked on exogenous input
self.w1 = self.init_func(
(self.out_chans, (self.in_chans + self.rand_chans),
self.filt_dim, self.filt_dim), "{}_w1".format(self.mod_name))
else:
# random values won't be stacked on exogenous input
self.w1 = self.init_func(
(self.out_chans, self.in_chans, self.filt_dim, self.filt_dim),
"{}_w1".format(self.mod_name))
self.w2 = self.init_func(
(self.out_chans, self.out_chans, self.filt_dim, self.filt_dim),
"{}_w2".format(self.mod_name))
self.params = [self.w1, self.w2]
# make gains and biases for transforms that will get batch normed
if self.apply_bn_1:
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
self.g1 = gain_ifn((self.out_chans), "{}_g1".format(self.mod_name))
self.b1 = bias_ifn((self.out_chans), "{}_b1".format(self.mod_name))
self.params.extend([self.g1, self.b1])
if self.apply_bn_2:
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
self.g2 = gain_ifn((self.out_chans), "{}_g2".format(self.mod_name))
self.b2 = bias_ifn((self.out_chans), "{}_b2".format(self.mod_name))
self.params.extend([self.g2, self.b2])
return
def _init_params(self):
"""
Initialize parameters for the layers in this discriminator module.
"""
self.w1 = self.init_func(
(self.out_chans, self.in_chans, self.filt_dim, self.filt_dim),
"{}_w1".format(self.mod_name))
self.w2 = self.init_func(
(self.out_chans, self.out_chans, self.filt_dim, self.filt_dim),
"{}_w2".format(self.mod_name))
self.wd = self.init_func(
(1, self.out_chans, self.filt_dim, self.filt_dim),
"{}_wd".format(self.mod_name))
self.params = [self.w1, self.w2, self.wd]
# make gains and biases for transforms that will get batch normed
if self.apply_bn_1:
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
self.g1 = gain_ifn((self.out_chans), "{}_g1".format(self.mod_name))
self.b1 = bias_ifn((self.out_chans), "{}_b1".format(self.mod_name))
self.params.extend([self.g1, self.b1])
if self.apply_bn_2:
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
self.g2 = gain_ifn((self.out_chans), "{}_g2".format(self.mod_name))
self.b2 = bias_ifn((self.out_chans), "{}_b2".format(self.mod_name))
self.params.extend([self.g2, self.b2])
return
def __init__(self,
rand_dim,
out_dim,
fc_dim,
apply_bn_1=True,
apply_bn_2=True,
init_func=None,
rand_type='normal',
final_relu=True,
mod_name='dm_fc'):
self.rand_dim = rand_dim
self.out_dim = out_dim
self.fc_dim = fc_dim
self.apply_bn_1 = apply_bn_1
self.apply_bn_2 = apply_bn_2
self.mod_name = mod_name
self.rand_type = rand_type
self.final_relu = final_relu
self.rng = RandStream(123)
if init_func is None:
self.init_func = inits.Normal(scale=0.02)
else:
self.init_func = init_func
self._init_params() # initialize parameters
return
def __init__(self,
filt_shape,
in_chans,
out_chans,
rand_chans,
use_rand=True,
apply_bn_1=True,
apply_bn_2=True,
us_stride=2,
use_pooling=True,
init_func=None,
mod_name='gm_conv',
rand_type='normal'):
assert ((filt_shape[0] % 2) > 0), "filter dim should be odd (not even)"
self.filt_dim = filt_shape[0]
self.in_chans = in_chans
self.out_chans = out_chans
self.rand_chans = rand_chans
self.use_rand = use_rand
self.apply_bn_1 = apply_bn_1
self.apply_bn_2 = apply_bn_2
self.us_stride = us_stride
self.use_pooling = use_pooling
self.mod_name = mod_name
self.rand_type = rand_type
self.rng = RandStream(123)
if init_func is None:
self.init_func = inits.Normal(scale=0.02)
else:
self.init_func = init_func
self._init_params() # initialize parameters
return
def __init__(self,
filt_shape,
in_chans,
out_chans,
apply_bn_1=True,
apply_bn_2=True,
ds_stride=2,
use_pooling=True,
init_func=None,
mod_name='dm_conv'):
assert ((filt_shape[0] % 2) > 0), "filter dim should be odd (not even)"
self.filt_dim = filt_shape[0]
self.in_chans = in_chans
self.out_chans = out_chans
self.apply_bn_1 = apply_bn_1
self.apply_bn_2 = apply_bn_2
self.ds_stride = ds_stride
self.use_pooling = use_pooling
self.mod_name = mod_name
if init_func is None:
self.init_func = inits.Normal(scale=0.02)
else:
self.init_func = init_func
self._init_params() # initialize parameters
return
def _init_params(self):
"""
Initialize parameters for the layers in this generator module.
"""
self.w1 = self.init_func((self.rand_dim, self.out_dim),
"{}_w1".format(self.mod_name))
self.params = [self.w1]
# make gains and biases for transforms that will get batch normed
if self.apply_bn:
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
self.g1 = gain_ifn((self.out_dim), "{}_g1".format(self.mod_name))
self.b1 = bias_ifn((self.out_dim), "{}_b1".format(self.mod_name))
self.params.extend([self.g1, self.b1])
return
def __init__(self,
fc_dim,
in_dim,
apply_bn=True,
init_func=None,
mod_name='dm_fc'):
self.fc_dim = fc_dim
self.in_dim = in_dim
self.apply_bn = apply_bn
self.mod_name = mod_name
if init_func is None:
self.init_func = inits.Normal(scale=0.02)
else:
self.init_func = init_func
self._init_params() # initialize parameters
return
def __init__(self,
filt_shape,
in_chans,
out_chans,
apply_bn=True,
act_func='lrelu',
init_func=None,
mod_name='dm_conv'):
assert ((filt_shape[0] % 2) > 0), "filter dim should be odd (not even)"
self.filt_dim = filt_shape[0]
self.in_chans = in_chans
self.out_chans = out_chans
self.apply_bn = apply_bn
self.act_func = act_func
self.mod_name = mod_name
if init_func is None:
self.init_func = inits.Normal(scale=0.02)
else:
self.init_func = init_func
self._init_params() # initialize parameters
return
desc = 'matronet_1'
model_dir = "{}/models/{}".format(EXP_DIR, desc)
sample_dir = "{}/samples/{}".format(EXP_DIR, desc)
log_dir = "{}/logs".format(EXP_DIR)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
if not os.path.exists(sample_dir):
os.makedirs(sample_dir)
sigmoid = activations.Sigmoid()
bce = T.nnet.binary_crossentropy
gifn = inits.Normal(scale=0.02)
difn = inits.Normal(scale=0.02)
#
# Define some modules to use in the generator
#
gen_module_1 = \
GenFCModule(
rand_dim=nz0,
out_dim=(ngf*2*7*7),
fc_dim=ngfc,
apply_bn_1=True,
apply_bn_2=True,
init_func=gifn,
rand_type='normal',
mod_name='gen_mod_1'
means = labels.mean(axis=0)
print('labels ', labels.shape, means, means[0] / means[1])
vaY, labels = tr_data.get_data(tr_handle, slice(10000, min(ntrain, 20000)))
vaY = transform(vaY)
va_nnd_1k = nnd_score(vaY.reshape((len(vaY), -1)),
vaX.reshape((len(vaX), -1)),
metric='euclidean')
print 'va_nnd_1k = %.2f' % (va_nnd_1k)
means = labels.mean(axis=0)
print('labels ', labels.shape, means, means[0] / means[1])
#####################################
# shared variables
gifn = inits.Normal(scale=0.02)
difn = inits.Normal(scale=0.02)
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
gw = gifn((nz, ngf * 8 * 4 * 4), 'gw')
gg = gain_ifn((ngf * 8 * 4 * 4), 'gg')
gb = bias_ifn((ngf * 8 * 4 * 4), 'gb')
gw2 = gifn((ngf * 8, ngf * 4, 5, 5), 'gw2')
gg2 = gain_ifn((ngf * 4), 'gg2')
gb2 = bias_ifn((ngf * 4), 'gb2')
gw3 = gifn((ngf * 4, ngf * 2, 5, 5), 'gw3')
gg3 = gain_ifn((ngf * 2), 'gg3')
gb3 = bias_ifn((ngf * 2), 'gb3')
gw4 = gifn((ngf * 2, ngf, 5, 5), 'gw4')
gg4 = gain_ifn((ngf), 'gg4')
niter_decay = 30 # # of iter to linearly decay learning rate to zero
lr = 0.0002 # initial learning rate for adam
ntrain = 25000 # # of examples to train on
relu = activations.Rectify()
sigmoid = activations.Sigmoid()
lrelu = activations.LeakyRectify()
tanh = activations.Tanh()
bce = T.nnet.binary_crossentropy
def mse(x, y):
return T.sum(T.pow(x - y, 2), axis=1)
gifn = inits.Normal(scale=0.02)
difn = inits.Normal(scale=0.02)
sigma_ifn = inits.Normal(loc=-100., scale=0.02)
gain_ifn = inits.Normal(loc=1., scale=0.02)
bias_ifn = inits.Constant(c=0.)
def target_transform(X):
return floatX(X).transpose(0, 3, 1, 2) / 127.5 - 1.
def input_transform(X):
return target_transform(X)
def make_conv_layer(X,
