def _get_output(self, X, train=False):
mean, logsigma = self.get_mean_logsigma(X)
if train:
if K._BACKEND == 'theano':
eps = K.random_normal((X.shape[0], self.output_dim))
else:
eps = K.random_normal((self.batch_size, self.output_dim))
return mean + K.exp(logsigma) * eps
else:
return mean
def _get_output(self, X, train=False):
mean, logsigma = self.get_mean_logsigma(X)
if train:
### Temporary change, scale down size of noise
if K._BACKEND == 'theano':
eps = K.random_normal((X.shape[0], self.output_dim), std=self.regularizer_scale)
else:
eps = K.random_normal((self.batch_size, self.output_dim))
### Temporary change, multiply by regularizer_scale
return mean + self.regularizer_scale * K.exp(logsigma) * eps
else:
return mean
def _get_output(self, X, train=False):
mean, logsigma = self.get_mean_logsigma(X)
if train:
# infer batch size for theano backend
if K._BACKEND == 'theano':
eps = K.random_normal((X.shape[0], self.output_dim))
else:
sizes = K.concatenate([K.shape(X)[0:1],
np.asarray([self.output_dim, ])])
eps = K.random_normal(sizes)
# return sample : mean + std * noise
return mean + K.exp(logsigma) * eps
else:
# for testing, the sample is deterministic
return mean
def sampling(args):
"""Reparameterization trick by sampling fr an isotropic unit Gaussian.
# Arguments:
args (tensor): mean and log of variance of Q(z|X)
# Returns:
z (tensor): sampled latent vector
"""
print("args")
print(args)
# print("z_mean")
# print(z_mean)
# print("z_log_var")
# print(z_log_var)
z_mean, z_log_var = args
batch = K.shape(z_mean)[0]
print("batch")
print(z_mean.shape[0])
print(batch)
dim = K.int_shape(z_mean)[1]
print("dim")
print(z_mean.shape[1])
print(dim)
# by default, random_normal has mean=0 and std=1.0
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
def _get_output(self, X, train=False):
mean, logsigma = self.get_mean_logsigma(X)
if train:
eps = K.random_normal((self.batch_size, self.output_dim))
return mean + K.exp(logsigma) * eps
else:
return mean
def sampling(args):
z_mean, z_log_var = args
batch = K.shape(z_mean)[0]
dim = K.int_shape(z_mean)[1]
# by default, random_normal has mean=0 and std=1.0
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
def call(self, x):
# sample from noise distribution
e_i = K.random_normal((self.input_dim, self.units))
e_j = K.random_normal((self.units,))
# We use the factorized Gaussian noise variant from Section 3 of Fortunato et al.
eW = K.sign(e_i) * (K.sqrt(K.abs(e_i))) * K.sign(e_j) * (K.sqrt(K.abs(e_j)))
eB = K.sign(e_j) * (K.abs(e_j) ** (1 / 2))
noise_injected_weights = K.dot(x, self.mu_weight + (self.sigma_weight * eW))
noise_injected_bias = self.mu_bias + (self.sigma_bias * eB)
output = K.bias_add(noise_injected_weights, noise_injected_bias)
if self.activation is not None:
output = self.activation(output)
return output
def sampling(args):
mean, std = args
eps = K.random_normal(
shape=(batch_size,latent_dim),
mean=0.0,
std=epsilon
)
return mean + std * eps
def normal_latent_sampling(latent_shape):
"""
Sample from normal distribution
:param latent_shape: batch shape
:return: normal samples, shape=(n,)+latent_shape
"""
return Lambda(lambda x: K.random_normal((K.shape(x)[0],) + latent_shape),
output_shape=lambda x: ((x[0],) + latent_shape))
def build(self, input_shape):
input_dim = input_shape[1]
shape = [input_dim, self.output_dim]
self.W = K.random_normal(shape)
v = 1.0 # np.sqrt(6.0 / (input_dim + self.output_dim))
self.mean = K.variable(np.random.uniform(low=-v, high=v, size=shape))
self.log_stdev = K.variable(np.random.uniform(low=-v, high=v, size=shape))
self.bias = K.variable(np.random.uniform(low=-v, high=v, size=[self.output_dim]))
self.trainable_weights = [self.mean, self.bias, self.log_stdev]
def build(self, input_shape):
input_dim = input_shape[1]
shape = [input_dim, self.output_dim]
self.epsilon = K.random_normal(shape, mean=self.mean_prior, std=self.std_prior)
v = np.sqrt(6.0 / (input_dim + self.output_dim))
self.mean = K.variable(np.random.uniform(low=-v, high=v, size=shape), name='mean')
self.log_std = K.variable(np.random.uniform(low=-v, high=v, size=shape), name='log_std')
self.bias = K.variable(np.random.uniform(low=-v, high=v, size=[self.output_dim]), name='bias')
self.W = self.epsilon*K.log(1.0 + K.exp(self.log_std)) + self.mean
self.trainable_weights = [self.mean, self.log_std, self.bias]
def model_encoder(latent_dim, input_shape, hidden_dim=512, reg=lambda: l1(1e-7)):
x = Input(input_shape, name="x")
h = Flatten()(x)
h = Dense(hidden_dim, name="encoder_h1", W_regularizer=reg())(h)
h = LeakyReLU(0.2)(h)
h = Dense(hidden_dim, name="encoder_h2", W_regularizer=reg())(h)
h = LeakyReLU(0.2)(h)
mu = Dense(latent_dim, name="encoder_mu", W_regularizer=reg())(h)
log_sigma_sq = Dense(latent_dim, name="encoder_log_sigma_sq", W_regularizer=reg())(h)
z = merge([mu, log_sigma_sq], mode=lambda p: p[0] + K.random_normal(K.shape(p[0])) * K.exp(p[1] / 2),
output_shape=lambda p: p[0])
return Model(x, z, name="encoder")
def build(self, input_shape):
if self.dim_ordering == 'th':
stack_size = input_shape[1]
self.W_shape = (self.nb_filter, stack_size, self.nb_row, self.nb_col)
elif self.dim_ordering == 'tf':
stack_size = input_shape[3]
self.W_shape = (self.nb_row, self.nb_col, stack_size, self.nb_filter)
else:
raise Exception('Invalid dim_ordering: ' + self.dim_ordering)
# self.W = self.init(self.W_shape, name='{}_W'.format(self.name))
input_dim, output_dim = initializations.get_fans(self.W_shape)
v = np.sqrt(6.0 / (input_dim + output_dim))
values = np.random.uniform(low=-v, high=v, size=self.W_shape)
self.mean = K.variable(values, name='mean')
values = np.random.uniform(low=-v, high=v, size=self.W_shape)
self.log_std = K.variable(values, name='log_std')
self.epsilon = K.random_normal(self.W_shape,
mean=self.mean_prior, std=self.std_prior)
self.W = self.epsilon*K.log(1.0 + K.exp(self.log_std)) + self.mean
if self.bias:
self.b = K.zeros((self.nb_filter,), name='{}_b'.format(self.name))
self.trainable_weights = [self.mean, self.log_std, self.b]
else:
self.trainable_weights = [self.mean, self.log_std]
self.regularizers = []
if self.W_regularizer:
self.W_regularizer.set_param(self.W)
self.regularizers.append(self.W_regularizer)
if self.bias and self.b_regularizer:
self.b_regularizer.set_param(self.b)
self.regularizers.append(self.b_regularizer)
if self.activity_regularizer:
self.activity_regularizer.set_layer(self)
self.regularizers.append(self.activity_regularizer)
self.constraints = {}
if self.W_constraint:
self.constraints[self.W] = self.W_constraint
if self.bias and self.b_constraint:
self.constraints[self.b] = self.b_constraint
if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights
def sampling(args): ''' Reparameterization trick by sampling from an isotropic unit Gaussian. Args: args(tensor): mean and log of variance of Q(z|X) Returns: z(tensor): sampled latent vector ''' z_mean, z_log_var = args batch = K.shape(z_mean)[0] dim = K.int_shape(z_mean)[1] # By default, random_normal has mean=0 and std=1.0 epsilon = K.random_normal(shape=(batch, dim)) return z_mean + K.exp(0.5 * z_log_var) * epsilon
def build_encoder(self):
# Encoder
img = Input(shape=self.img_shape)
h = Flatten()(img)
h = Dense(512)(h)
h = LeakyReLU(alpha=0.2)(h)
h = Dense(512)(h)
h = LeakyReLU(alpha=0.2)(h)
mu = Dense(self.latent_dim)(h)
log_var = Dense(self.latent_dim)(h)
latent_repr = merge([mu, log_var],
mode=lambda p: p[0] + K.random_normal(K.shape(p[0])) * K.exp(p[1] / 2),
output_shape=lambda p: p[0])
return Model(img, latent_repr)
def model_encoder(latent_dim, input_shape, hidden_dim=1024, reg=lambda: l1(1e-5), batch_norm_mode=2):
x = Input(input_shape, name="x")
h = Flatten()(x)
h = Dense(hidden_dim, name="encoder_h1", W_regularizer=reg())(h)
h = BatchNormalization(mode=batch_norm_mode)(h)
h = LeakyReLU(0.2)(h)
h = Dense(hidden_dim / 2, name="encoder_h2", W_regularizer=reg())(h)
h = BatchNormalization(mode=batch_norm_mode)(h)
h = LeakyReLU(0.2)(h)
h = Dense(hidden_dim / 4, name="encoder_h3", W_regularizer=reg())(h)
h = BatchNormalization(mode=batch_norm_mode)(h)
h = LeakyReLU(0.2)(h)
mu = Dense(latent_dim, name="encoder_mu", W_regularizer=reg())(h)
log_sigma_sq = Dense(latent_dim, name="encoder_log_sigma_sq", W_regularizer=reg())(h)
z = merge([mu, log_sigma_sq], mode=lambda p: p[0] + K.random_normal(p[0].shape) * K.exp(p[1] / 2),
output_shape=lambda x: x[0])
return Model(x, z, name="encoder")
def model_encoder(latent_dim, input_shape,
hidden_dim=100,
reg=lambda: l1l2(1e-7, 0)):
x = Input(input_shape, name="x")
h = GRU(hidden_dim, return_sequences=True)(x)
h = GRU(hidden_dim)(h)
h = Dense(hidden_dim, activation=activation,
name="encoder_h3",
W_regularizer=reg())(h)
mu = Dense(latent_dim, name="encoder_mu", W_regularizer=reg())(h)
log_sigma_sq = Dense(latent_dim, name="encoder_log_sigma_sq",
W_regularizer=reg())(h)
z = merge([mu, log_sigma_sq],
mode=lambda p: p[0] + K.random_normal(K.shape(p[0])) * K.exp(p[1] / 2),
output_shape=lambda p: p[0])
return Model(x, z, name="encoder")
def sampling(args):
"""Reparameterization trick by sampling fr an isotropic unit Gaussian.
# Arguments:
args (tensor): mean and log of variance of Q(z|X)
# Returns:
z (tensor): sampled latent vector
"""
z_mean, z_log_var = args
print('z_mean shape')
print(z_mean.shape)
print('z_log_var shape')
print(z_log_var.shape)
# time.sleep(2)
batch = K.shape(z_mean)[0]
dim = K.int_shape(z_mean)[1]
# by default, random_normal has mean=0 and std=1.0
epsilon = K.random_normal(shape=(batch, dim))
f = K.exp(0.5*z_log_var)
print('f shape')
print(K.shape(f))
# time.sleep(20)
return z_mean + K.exp(0.5 * z_log_var) * epsilon
def model_encoder(latent_dim, input_shape, units=512, reg=lambda: l1l2(l1=1e-7, l2=1e-7), dropout=0.5):
k = 5
x = Input(input_shape)
h = Convolution2D(units / 4, k, k, border_mode='same', W_regularizer=reg())(x)
# h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h)
h = LeakyReLU(0.2)(h)
h = Convolution2D(units / 2, k, k, border_mode='same', W_regularizer=reg())(h)
# h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h)
h = LeakyReLU(0.2)(h)
h = Convolution2D(units / 2, k, k, border_mode='same', W_regularizer=reg())(h)
# h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h)
h = LeakyReLU(0.2)(h)
h = Convolution2D(units, k, k, border_mode='same', W_regularizer=reg())(h)
# h = SpatialDropout2D(dropout)(h)
h = LeakyReLU(0.2)(h)
h = Flatten()(h)
mu = Dense(latent_dim, name="encoder_mu", W_regularizer=reg())(h)
log_sigma_sq = Dense(latent_dim, name="encoder_log_sigma_sq", W_regularizer=reg())(h)
z = Lambda(lambda (_mu, _lss): _mu + K.random_normal(K.shape(_mu)) * K.exp(_lss / 2),
output_shape=lambda (_mu, _lss): _mu)([mu, log_sigma_sq])
return Model(x, z, name="encoder")
def sampling(args):
z_mean_, z_log_var_ = args
batch_size = K.shape(z_mean_)[0]
epsilon = K.random_normal(
shape=(batch_size, latent_rep_size), mean=0., std=epsilon_std)
return z_mean_ + K.exp(z_log_var_ / 2) * epsilon
def sample_z(args):
mu, log_sigma = args
eps = K.random_normal(shape=(batch_size, latent_dim),
mean=epsilon_mean,
stddev=epsilon_std)
return mu + K.exp(log_sigma / 2) * eps
def sample(m):
m, log_var = m
norm = K.random_normal(shape=(32, LATENT_DIM, 32, 32), mean=0., std=1.)
return norm * K.exp(log_var / 2) + m
def sample_z(args):
mu, log_sigma = args
batch = K.shape(mu)[0]
dim = K.int_shape(mu)[1]
eps = K.random_normal(shape=(batch, dim), mean=0, stddev=1.)
return mu + K.exp(log_sigma / 2) * eps
def gen(in_):
z_mean, z_log_sigma = in_
epsilon = K.random_normal(shape=(batch_size, LATENT_DIM))
ex = K.exp(0.5 * z_log_sigma)
return z_mean + ex * epsilon
padding='SAME')(z_)
z_ = BatchNormalization()(z_)
z_ = Activation('relu')(z_)
z_ = Conv2D(K.int_shape(z_)[-1],
kernel_size=(1, 1),
padding='SAME',
kernel_initializer='zeros')(z_)
z = Add()([z, z_])
z = fl.UnSqueeze()(z)
z = Activation('tanh')(z)
decoder = Model(z_in, z)
decoder.summary()
u = Lambda(lambda z: K.random_normal(shape=K.shape(z)))(x) # 留着，不能动
z = Reshape(K.int_shape(u)[1:] + (1, ))(u)
z = fl.Actnorm(use_shift=False)(z)
z = Reshape(K.int_shape(z)[1:-1])(z)
z = Add()([z, x])
x_recon = decoder(z)
x_recon = Subtract()([x_recon, x_in])
x_recon = Reshape(K.int_shape(x_recon)[1:] + (1, ))(x_recon)
x_recon = fl.Actnorm(use_shift=False)(x_recon)
x_recon = Reshape(K.int_shape(x_recon)[1:-1])(x_recon)
recon_loss = 0.5 * K.sum(K.mean(x_recon**2, 0)) + 0.5 * np.log(
2 * np.pi) * np.prod(K.int_shape(x_recon)[1:])
depth = 12
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], Z_DIM), mean=0.,stddev=1.)
return z_mean + K.exp(z_log_var / 2) * epsilon
def sampling(args):
z_mean, z_log_std = args
batch = K.shape(z_mean)[0]
dim = K.int_shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + K.exp(z_log_std) * epsilon
def sampling(args):
z_mean, z_log_var = args
return z_mean + K.exp(0.5 * z_log_var) * K.random_normal(
K.shape(z_mean), seed=0)
def sampling(args):
z_mean, z_log_var = args
batch = K.shape(z_mean)[0]
dim = K.int_shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim), seed=0)
return z_mean + K.exp(0.5 * z_log_var) * epsilon
def sampling(args):
latent_mean, laten_log_value = args
batch = K.shape(latent_mean)[0]
dimension = K.int_shape(latent_mean)[1]
epsilon = K.random_normal(shape = (batch, dimension))
return latent_mean + K.exp(0.5 * laten_log_value) * epsilon
def dropped_inputs():
if 'max' == self.agg_method:
x_agg = bk.max(inputs, axis=0)
if self.smooth_rate > 0:
x_agg = self.smooth_rate * bk.mean(
inputs, axis=0) + (1 - self.smooth_rate) * x_agg
elif 'extreme' == self.agg_method:
x_mean = bk.mean(inputs, axis=0)
x_agg = tf.where(x_mean >= 0, bk.max(inputs, axis=0),
bk.min(inputs, axis=0))
if self.smooth_rate > 0:
x_agg = self.smooth_rate * x_mean + (
1 - self.smooth_rate) * x_agg
else:
x_agg = bk.mean(inputs, axis=0)
x_min, x_max = bk.min(x_agg), bk.max(x_agg)
x_agg_int = bk.cast(
input_shape[-1] * (x_agg - x_min) / (x_max - x_min),
'int32')
if self.unique_supported:
_, idx, counts = tf.unique_with_counts(x_agg_int)
dr = self.rate**(
1. / (self.anneal * bk.cast(counts, inputs.dtype)))
dr = tf.where(1 == counts, self.rate * bk.ones_like(dr),
dr)
else:
def _seg_dr(ele):
_cnt = bk.sum(bk.cast(ele == x_agg_int, inputs.dtype))
_dr = self.rate if 1 == _cnt else self.rate**(
1. / (self.anneal * _cnt))
return _dr
dr = bk.map_fn(_seg_dr, x_agg_int, dtype=inputs.dtype)
idx = bk.arange(0, x_agg_int.shape[0])
if 'gaussian' == self.noise_type:
sigma = (dr / (1. - dr))**.5
noise_tensor = bk.gather(sigma, idx) * bk.random_normal(
x_agg_int.shape, dtype=inputs.dtype) + 1.
return inputs * noise_tensor
else:
dr_tensor = bk.random_uniform(noise_shape,
seed=self.seed,
dtype=inputs.dtype)
ret = inputs * bk.cast(dr_tensor >= bk.gather(dr, idx),
inputs.dtype)
if 'abs' == self.keep_amp_type:
old_amps = bk.sum(bk.abs(inputs),
axis=-1,
keepdims=True)
cur_amps = bk.sum(bk.stop_gradient(bk.abs(ret)),
axis=-1,
keepdims=True)
ret = ret * old_amps / (cur_amps + self.epsilon)
elif self.keep_amp_type is not None:
old_amps = bk.sum(inputs, axis=-1, keepdims=True)
cur_amps = bk.sum(bk.stop_gradient(ret),
axis=-1,
keepdims=True)
ret = ret * old_amps / (cur_amps + self.epsilon)
return ret
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(encoder_layers[-1], ), mean=0.)
return z_mean + K.exp(z_log_var / 2) * epsilon
def build(self):
model = self.net.model
mu_model = self.net.mu_model
log_std_model = self.net.log_std_model
q_model = self.net.q_model
target_model = self.net.target_model
target_mu_model = self.net.target_mu_model
target_log_std_model = self.net.target_log_std_model
target_q_model = self.net.target_q_model
self.states = tf.placeholder(tf.float32,
shape=(None, self.in_dim),
name='states')
self.actions = tf.placeholder(tf.float32,
shape=[None, self.action_dim],
name='actions')
self.rewards = tf.placeholder(tf.float32, shape=[None], name='rewards')
self.next_states = tf.placeholder(tf.float32,
shape=[None, self.in_dim],
name='next_states')
self.ys = tf.placeholder(tf.float32, shape=[None])
# There are other implementations about how can we take aciton.
# Taking next action version or using only mu version or searching action which maximize Q.
target_mu = target_mu_model(self.states)
target_log_std = target_log_std_model(self.states)
target_action = target_mu + K.random_normal(
K.shape(target_mu), dtype=tf.float32) * K.exp(target_log_std)
self.target_q = K.sum(target_q_model(
Concatenate()([target_model(self.states), target_action])),
axis=-1)
self.q = K.sum(q_model(
Concatenate()([model(self.states), self.actions])),
axis=-1)
self.q_loss = K.mean(K.square(self.ys - self.q))
self.mu = mu_model(self.states)
self.log_std = log_std_model(self.states)
self.eta = (self.actions - self.mu) / K.exp(self.log_std)
inferred_action = self.mu + K.stop_gradient(self.eta) * K.exp(
self.log_std)
self.pi_loss = -K.mean(
q_model(Concatenate()([model(self.states), inferred_action])))
self.q_updater = self.q_optimizer.minimize(self.q_loss,
var_list=self.net.var_q)
self.pi_updater = self.pi_opimizer.minimize(self.pi_loss,
var_list=self.net.var_pi)
self.soft_updater = [
K.update(t_p,
t_p * (1 - self.tau) + p * self.tau)
for p, t_p in zip(self.net.var_all, self.net.var_target_all)
]
self.sync = [
K.update(t_p, p)
for p, t_p in zip(self.net.var_all, self.net.var_target_all)
]
self.sess.run(tf.global_variables_initializer())
self.built = True
def _sampling(args):
z_mean = args
batch = K.shape(z_mean)[0]
dim = K.int_shape(z_mean)[1]
epsilon = K.random_normal(shape=(batch, dim))
return z_mean + float(std) * epsilon
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim), mean=0.,
stddev=epsilon_std)
return z_mean + K.exp(z_log_var / 2) * epsilon
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], input_shape),
mean=0.,
stddev=1.)
return z_mean + K.exp(z_log_var / 2) * epsilon
def _conv_kernel_initializer(shape, dtype=None):
fan_in, fan_out = _compute_fans(shape)
stddev = np.sqrt(2. / fan_in)
return K.random_normal(shape, 0., stddev, dtype)
def model_encoder(self,
units=512,
reg=lambda: regularizers.l1_l2(l1=1e-7, l2=1e-7),
dropout=0.5):
k = 5
x = Input(shape=self.img_shape)
h = Conv2D(units // 4, (k, k),
padding='same',
kernel_regularizer=reg())(x)
# h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h) # 32 x 32
#h = LeakyReLU(0.2)(h)
h = PReLU()(h)
h = Conv2D(units // 2, (k, k),
padding='same',
kernel_regularizer=reg())(h)
# h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h) # 16 x 16
#h = LeakyReLU(0.2)(h)
h = PReLU()(h)
h = Conv2D(units // 2, (k, k),
padding='same',
kernel_regularizer=reg())(h)
# h = SpatialDropout2D(dropout)(h)
h = MaxPooling2D(pool_size=(2, 2))(h) # 8 x 8
#h = LeakyReLU(0.2)(h)
h = PReLU()(h)
h = Conv2D(units, (k, k), padding='same', kernel_regularizer=reg())(h)
# h = SpatialDropout2D(dropout)(h)
#h = LeakyReLU(0.2)(h)
h = PReLU()(h)
h = Flatten()(h)
x2 = Input(shape=self.bathy_shape)
h2 = ZeroPadding2D(padding=((6, 5), (6,
5)))(x2) # from 21x21 to 32 x 32
h2 = Conv2D(units // 4, (k, k),
padding='same',
kernel_regularizer=reg())(h2)
# h = SpatialDropout2D(dropout)(h)
h2 = MaxPooling2D(pool_size=(2, 2))(h2) # 16 x 16
#h = LeakyReLU(0.2)(h)
h2 = PReLU()(h2)
h2 = Conv2D(units // 2, (k, k),
padding='same',
kernel_regularizer=reg())(h2)
# h = SpatialDropout2D(dropout)(h)
h2 = MaxPooling2D(pool_size=(2, 2))(h2) # 8 x 8
#h = LeakyReLU(0.2)(h)
h2 = PReLU()(h2)
h2 = Conv2D(units // 2, (k, k),
padding='same',
kernel_regularizer=reg())(h2)
# h = SpatialDropout2D(dropout)(h)
h2 = MaxPooling2D(pool_size=(2, 2))(h2) # 4 x 4
#h = LeakyReLU(0.2)(h)
h2 = PReLU()(h2)
h2 = Conv2D(units, (k, k), padding='same',
kernel_regularizer=reg())(h2)
# h = SpatialDropout2D(dropout)(h)
#h = LeakyReLU(0.2)(h)
h2 = PReLU()(h2)
h2 = Flatten()(h2)
hcomb = Concatenate()([h, h2])
mu = Dense(self.latent_dim,
name="encoder_mu",
kernel_regularizer=reg())(hcomb)
log_sigma_sq = Dense(self.latent_dim,
name="encoder_log_sigma_sq",
kernel_regularizer=reg())(hcomb)
# z = Lambda(lambda (_mu, _lss): _mu + K.random_normal(K.shape(_mu)) * K.exp(_lss / 2),output_shape=lambda (_mu, _lss): _mu)([mu, log_sigma_sq])
z = Lambda(lambda ml: ml[0] + K.random_normal(K.shape(ml[0])) * K.exp(
ml[1] / 2),
output_shape=lambda ml: ml[0])([mu, log_sigma_sq])
return Model([x, x2], z, name="encoder")
def sampling(self, args):
z_mean, z_sigma = args
epsilon = K.random_normal(shape=(self.z_dim, ),
mean=0.,
stddev=epsilon_std)
return z_mean + z_sigma * epsilon
# 重参数技巧
def call(self, inputs):
z, shift, log_scale = inputs
z = K.exp(log_scale) * z + shift
logdet = -K.sum(K.mean(log_scale, 0))
self.add_loss(logdet)
return z
# 算p(Z|X)的均值和方差
z_shift = Dense(z_dim)(x)
z_log_scale = Dense(z_dim)(x)
# 重参数层，相当于给输入加入噪声
u = Lambda(lambda z: K.random_normal(shape=K.shape(z)))(z_shift)
z = ScaleShift()([u, z_shift, z_log_scale])
x_recon = decoder(z)
x_out = Subtract()([x_in, x_recon])
# xent_loss是重构loss，z_loss是KL loss
recon_loss = 0.5 * K.sum(K.mean(x_out**2, 0)) + 0.5 * np.log(
2 * np.pi) * np.prod(K.int_shape(x_out)[1:])
z_loss = 0.5 * K.sum(K.mean(z**2, 0)) - 0.5 * K.sum(K.mean(u**2, 0))
vae_loss = recon_loss + z_loss
vae = Model(x_in, x_out)
vae.add_loss(vae_loss)
vae.compile(optimizer=Adam(1e-4))
def sampling(z_par):
z_mu, z_var = z_par
epsilon = K.random_normal(shape=z_mu.shape)
return z_mu + K.sqrt(z_var) * epsilon
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(batch_size, latent_dim),
mean=0.,
stddev=epsilon_std)
return z_mean + K.exp(z_log_var) * epsilon
def hlms_initializer(shape, dtype=None, std=0.2):
return K.random_normal(shape, dtype=dtype)
def __sampling(self, args):
sample_mean, sample_log_std = args
epsilon = K.random_normal(shape=(self.batch_size, self.latent_size))
return sample_mean + K.exp(sample_log_std) * epsilon
def sample_z( args ):
z_mean, z_log_var = args
epsilon = K.random_normal( shape=( latent_dim, ),\
mean = 0., stddev=1 )
return z_mean + K.exp( z_log_var / 2 ) * epsilon
def gaussian_noise(x, mean=0.0, std=0.1, random_state=1234):
return x + K.random_normal(
K.shape(x), mean=mean, std=std, seed=random_state)
def gaussian_noise(x, mean=0.0, std=0.1, random_state=1234):
return x + K.random_normal(K.shape(x), mean=mean, std=std, seed=random_state)
def sample_z(args):
self.mu, self.sigma = args
batch = K.shape(self.mu)[0]
dim = K.int_shape(self.mu)[1]
eps = K.random_normal(shape=(batch, dim))
return self.mu + K.exp(self.sigma / 2) * eps
def sample_z(args): global m, n_z mu, log_sigma = args eps = K.random_normal(shape=(m, n_z), mean=0., stddev=1.) return mu + K.exp(log_sigma / 2) * eps
def norm(x):
return (x-np.min(x))/(np.max(x)-np.min(x))
part=8
thre=1
## Certo é 256
recog=Sequential()
recog.add(Dense(64,activation='relu',input_shape=(784,),init='glorot_uniform'))
recog_left=recog
recog_left.add(Dense(64,input_shape=(64,),activation='relu'))
recog_right=recog
recog_right.add(Dense(64,input_shape=(64,),activation='relu'))
recog_right.add(Lambda(lambda x: x + K.exp(x / 2) * K.random_normal(shape=(1, 64), mean=0.,
std=epsilon_std), output_shape=(64,)))
recog_right.add(Highway())
recog_right.add(Activation('sigmoid'))
recog1=Sequential()
recog1.add(Merge([recog_left,recog_right],mode = 'ave'))
recog1.add(Dense(784))
#### HERE***
recog11=Sequential()
layer=Dense(64,init='glorot_uniform',input_shape=(784,))
layer.trainable=False
recog11.add(layer)
layer2=Dense(784, activation='sigmoid',init='glorot_uniform')
layer2.trainable=False
recog11.add(layer2)
def sampling(args):
z_mean, z_log_sigma = args
epsilon = K.random_normal(shape=(64, noise_dim,),
mean=0., std=0.01)
return z_mean + K.exp(z_log_sigma) * epsilon
def sample(self, n):
return K.random_normal(shape=(n, self.d))
def sampling(args):
z_mean, z_log_std = args
epsilon = K.random_normal(shape=(batch_size, latent_dim),
mean=0., std=epsilon_std)
return z_mean + K.exp(z_log_std) * epsilon
def _sampling(self, args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], self.n_z),
mean=0.,
stddev=self.epsilon_std)
return z_mean + K.sqrt(K.exp(z_log_var)) * epsilon
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim),
mean=0.,
stddev=epsilon_std)
return z_mean + K.exp(z_log_var / 2) * epsilon
def sample_z(args):
mu, log_sigma = args
eps = K.random_normal(shape=(m, latent_dim))
return mu + K.exp(log_sigma / 2) * eps
def sampling(self, args):
mu, log_var = args
epsilon = K.random_normal(shape=K.shape(mu), mean=0, stddev=1.)
return mu + K.exp(log_var / 2) * epsilon
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape = (K.shape(z_mean)[0], latent_dim), \
mean = 0, stddev = 1)
return z_mean + K.exp(0.5 * z_log_var) * epsilon
def sample_z(args): z_mu, z_sigma = args eps = K.random_normal(shape=(K.shape(z_mu)[0], K.int_shape(z_mu)[1])) return z_mu + K.exp(z_sigma / 2) * eps
part = 8
thre = 1
## Certo é 256
recog = Sequential()
recog.add(
Dense(64, activation='relu', input_shape=(784, ), init='glorot_uniform'))
recog_left = recog
recog_left.add(Dense(64, input_shape=(64, ), activation='relu'))
recog_right = recog
recog_right.add(Dense(64, input_shape=(64, ), activation='relu'))
recog_right.add(
Lambda(lambda x: x + K.exp(x / 2) * K.random_normal(
shape=(1, 64), mean=0., std=epsilon_std),
output_shape=(64, )))
recog_right.add(Highway())
recog_right.add(Activation('sigmoid'))
recog1 = Sequential()
recog1.add(Merge([recog_left, recog_right], mode='ave'))
recog1.add(Dense(64, init='glorot_uniform'))
recog1.add(Dense(784, activation='sigmoid', init='glorot_uniform'))
recog1.compile(loss='mean_squared_error', optimizer=sgd, metrics=['mae'])
recog1.fit(x_train[0].reshape((1, 784)),
x_train[0].reshape((1, 784)),
nb_epoch=150,
batch_size=30,
