def masked():
# pick cval
beta = K.sigmoid(self.beta)
cval = self.min_value * beta + self.max_value * (1 - beta)
# determine a mask
ratio = K.sigmoid(self.ratio)
size = K.random_uniform([], maxval=0.2, dtype='float32')
offset = K.random_uniform([], maxval=1 - size, dtype='float32')
'''
ratio = K.concatenate([self.ratio, [0.]])
ratio = ratio + K.random_normal([3,], dtype='float32')
ratio = K.softmax(ratio)
'''
mask = K.arange(0., 1., 1 / freq, dtype='float32')
ge = K.cast(K.greater_equal(mask, offset), dtype='float32')
le = K.cast(K.less_equal(mask, size + offset), dtype='float32')
mask = 1 - ge * le
mask = K.reshape(mask, broadcast_shape)
outputs = inputs * mask + cval * (1 - mask)
return outputs
def random_combine_images(X):
batch_size = K.shape(X[0])[0]
if self.dimensionality == 2:
alpha = K.random_uniform(shape=(batch_size, 1, 1, 1))
else:
alpha = K.random_uniform(shape=(batch_size, 1, 1, 1, 1))
return(alpha * X[0] + (1.0 - alpha) * X[1])
def call(self,
inputs: tf.Tensor,
mask: Optional[tf.Tensor] = None,
n_symbols: Optional[int] = None):
"""
Args:
inputs (tf.Tensor[ndims=2, int]): Tensor of values to mask
mask (Optional[tf.Tensor[bool]]): Locations in the inputs to that are valid
(i.e. not padding, start tokens, etc.)
Returns:
masked_inputs (tf.Tensor[ndims=2, int]): Tensor of masked values
bert_mask: Locations in the input that were masked
"""
discrete = inputs.dtype not in [tf.float16, tf.float32, tf.float64]
mask_shape = K.shape(inputs) if discrete else K.shape(inputs)[:-1]
if n_symbols is None:
n_symbols = self.n_symbols
bert_mask = K.random_uniform(mask_shape) < self.percentage
if mask is not None:
bert_mask &= mask
if not discrete:
bert_mask = tf.expand_dims(bert_mask, -1)
masked_inputs = inputs * \
tf.cast(~bert_mask, inputs.dtype) # type: ignore
token_bert_mask = K.random_uniform(K.shape(bert_mask)) < 0.8
random_bert_mask = (K.random_uniform(K.shape(bert_mask)) <
0.1) & ~token_bert_mask
true_bert_mask = ~token_bert_mask & ~random_bert_mask
token_bert_mask = tf.cast(token_bert_mask & bert_mask, inputs.dtype)
random_bert_mask = tf.cast(random_bert_mask & bert_mask, inputs.dtype)
true_bert_mask = tf.cast(true_bert_mask & bert_mask, inputs.dtype)
masked_inputs += self.mask_token * token_bert_mask # type: ignore
if discrete:
assert n_symbols is not None
masked_inputs += K.random_uniform(
K.shape(bert_mask), 0, n_symbols,
dtype=inputs.dtype) * random_bert_mask
else:
masked_inputs += (K.random_normal(K.shape(masked_inputs)) +
inputs) * random_bert_mask
masked_inputs += inputs * true_bert_mask
return masked_inputs, bert_mask
def call(self, inputs):
# Implement Eq.(9)
perturbed_kernel = self.kernel + \
self.sigma_kernel * K.random_uniform(shape=self.kernel_shape)
outputs = K.dot(inputs, perturbed_kernel)
if self.use_bias:
perturbed_bias = self.bias + \
self.sigma_bias * K.random_uniform(shape=self.bias_shape)
outputs = K.bias_add(outputs, perturbed_bias)
if self.activation is not None:
outputs = self.activation(outputs)
return outputs
def call(self, inputs):
assert inputs[0].shape[1:] == inputs[1].shape[
1:], "Inputs must have same shape!"
if len(inputs[0].shape[1:]) == 4:
weights = K.random_uniform((self.batch_size, 1, 1, 1, 1))
elif len(inputs[0].shape[1:]) == 3:
weights = K.random_uniform((self.batch_size, 1, 1, 1))
else:
raise ValueError("Wrong input shape.")
return (weights * inputs[0]) + ((1 - weights) * inputs[1])
def train_mask(self):
W2 = self.kernel * self.kernel
n_filter_weights = np.product(self.kernel_size)
if self.hamiltonian == 'unstructured':
Qp = tfp.stats.percentile(K.flatten(W2), self.p*100, interpolation='linear')
P0 = 1/(1+K.exp(self.beta*(W2-Qp)))
R = K.random_uniform(K.shape(P0))
return K.cast(R > P0, 'float32')
elif self.hamiltonian == 'kernel':
# Prune kernels by finding A and B for hamiltonian H(x) = x^TAx +
# b^Tx, and sampling directly for each kernel
flat_W2 = K.reshape(W2, (n_filter_weights, self.n_channels, self.filters))
Qp = tfp.stats.percentile(K.sum(flat_W2,axis=0)/n_filter_weights, self.p*100, interpolation='linear')
b = Qp - flat_W2
A = -self.c * K.constant(np.ones((n_filter_weights, n_filter_weights, self.n_channels, self.filters)))
A_mask = np.ones((n_filter_weights,n_filter_weights))
np.fill_diagonal(A_mask, False)
A = A * A_mask[:,:,None,None]
M = K.reshape(tf_sample_gibbs(A, b, self.beta, n_filter_weights), K.shape(W2))
return (M+1)/2
elif self.hamiltonian == 'filter':
# Prune filters with chromatic gibbs sampling
flat_W2 = K.reshape(W2, (n_filter_weights, self.n_channels, self.filters))
Qp = tfp.stats.percentile(tf.reduce_sum(flat_W2,axis=[0,1])/n_filter_weights/self.n_channels, self.p*100, interpolation='linear')
b = Qp - flat_W2
A = -self.c * K.constant(np.ones((n_filter_weights, n_filter_weights, self.n_channels, self.filters)))
A_mask = np.ones((n_filter_weights,n_filter_weights))
np.fill_diagonal(A_mask, False)
A = A * A_mask[:,:,None,None]
filt_avgs = tf.reduce_sum(flat_W2,axis=[0,1])/n_filter_weights/self.n_channels
x_cvg = K.cast(filt_avgs > Qp, 'float32')
colour_b = b - self.c * (self.n_channels//2) * n_filter_weights * (x_cvg*2-1)[None,None,:]
split = self.n_channels//2
colour_b = colour_b[:,0:split,:]
for i in range(self.mcmc_steps):
P0 = 1/(1+K.exp(-self.beta*colour_b))
R = K.random_uniform(K.shape(P0))
M0 = K.cast(R > P0, 'float32')*2-1
filter_sums = tf.reduce_sum(M0, axis=[0,1])
colour_b = b[:,split:,:] - self.c*filter_sums[None,None,:]
P0 = 1/(1+K.exp(-self.beta*colour_b))
R = K.random_uniform(K.shape(P0))
M1 = K.cast(R > P0, 'float32')*2-1
filter_sums = tf.reduce_sum(M1, axis=[0,1])
colour_b = b[:,0:split,:] - self.c*filter_sums[None,None,:]
M = K.reshape(K.concatenate((M0,M1), axis=1), K.shape(W2))
return (M+1)/2
def concrete_dropout(self, x):
"""Concrete dropout
Args:
x:
Returns:
A
"""
eps = K.cast_to_floatx(K.epsilon())
# Unifrom noise
u = K.random_uniform(shape=K.shape(x))
# the Concrete distribution relaxation
z_tilde = (K.log(self.p + eps) - K.log(1.0 - self.p + eps) +
K.log(u + eps) - K.log(1.0 - u + eps))
z_tilde = K.sigmoid(z_tilde / self.temperature)
# Random tensor
random_tensor = 1.0 - drop_prob
retain_prob = 1.0 - self.p
x *= random_tensor
x /= retain_prob
return x
def call(self, inputs, training=None):
"""
The function that takes the inputs of the layer and conducts the
Dense layer multiplication with concrete dropout.
Parameters:
inputs (tf.Keras.Layer): The inputs to the Dense layer.
training (bool): A required input for call. Setting training to
true or false does nothing because concrete dropout behaves the
same way in both cases.
Returns:
(tf.Keras.Layer): The output of the Dense layer.
"""
# Small epsilon parameter needed for stable optimization
eps = K.cast_to_floatx(K.epsilon())
# Build the random tensor for dropout from uniform noise. This
# formulation allows for a derivative with respect to p.
input_shape = K.shape(inputs)
noise_shape = (input_shape[0], 1, 1, input_shape[3])
unif_noise = K.random_uniform(shape=noise_shape, seed=self.random_seed)
drop_prob = (K.log(K.sigmoid(self.p_logit) + eps) -
K.log(1.0 - K.sigmoid(self.p_logit) + eps) +
K.log(unif_noise + eps) - K.log(1.0 - unif_noise + eps))
drop_prob = K.sigmoid(drop_prob / self.temp)
inputs *= (1.0 - drop_prob)
inputs /= (1.0 - K.sigmoid(self.p_logit))
# Now just carry out the basic operations of a Dense layer.
return super(SpatialConcreteDropout, self).call(inputs)
def evaluate_lip_const(model: Model, x, eps=1e-4, seed=None):
"""
Evaluate the Lipschitz constant of a model, with the naive method.
Please note that the estimation of the lipschitz constant is done locally around
input sample. This may not correctly estimate the behaviour in the whole domain.
Args:
model: built keras model used to make predictions
x: inputs used to compute the lipschitz constant
eps: magnitude of noise to add to input in order to compute the constant
seed: seed used when generating the noise ( can be set to None )
Returns:
the empirically evaluated lipschitz constant. The computation might also be
inaccurate in high dimensional space.
"""
y_pred = model.predict(x)
# x = np.repeat(x, 100, 0)
# y_pred = np.repeat(y_pred, 100, 0)
x_var = x + K.random_uniform(
shape=x.shape, minval=eps * 0.25, maxval=eps, seed=seed
)
y_pred_var = model.predict(x_var)
dx = x - x_var
dfx = y_pred - y_pred_var
ndx = K.sqrt(K.sum(K.square(dx), axis=range(1, len(x.shape))))
ndfx = K.sqrt(K.sum(K.square(dfx), axis=range(1, len(y_pred.shape))))
lip_cst = K.max(ndfx / ndx)
print("lip cst: %.3f" % lip_cst)
return lip_cst
def func(val):
val_name = val.op.name
if '/W' in val_name and 'conv1' not in val_name and 'fct' not in val_name:
name_scope, device_scope = x.op.name.split('/W')
with tf.variable_scope(name_scope, reuse=tf.AUTO_REUSE):
if eval(self.quantizer_config['W_opts']['fix_max']) ==True:
max_x = tf.stop_gradient(
tf.get_variable('maxW', shape=(), initializer=tf.ones_initializer, dtype=tf.float32))
max_x *= float(self.quantizer_config['W_opts']['max_scale'])
else:
max_x = tf.stop_gradient(tf.reduce_max(tf.abs(x)))
mask = tf.get_variable('maskW', shape=val.shape, initializer=tf.zeros_initializer, dtype=tf.float32)
probThreshold = (1 + gamma * get_global_step_var()) ** -1
# Determine which filters shall be updated this iteration
random_number = K.random_uniform(shape=(1, 1, 1, int(mask.shape[-1])))
random_number1 = K.cast(random_number < probThreshold, dtype='float32')
random_number2 = K.cast(random_number < (probThreshold * 0.1), dtype='float32')
thresh = max_x * ratio * 0.999
# Incorporate hysteresis into the threshold
alpha = thresh
beta = 1.2 * thresh
# Update the significant weight mask by applying the threshold to the unmasked weights
abs_kernel = K.abs(x=val)
new_mask = mask - K.cast(abs_kernel < alpha, dtype='float32') * random_number1
new_mask = new_mask + K.cast(abs_kernel > beta, dtype='float32') * random_number2
new_mask = K.clip(x=new_mask, min_value=0., max_value=1.)
return tf.assign(mask, new_mask, use_locking=False).op
def train_discriminator(self, real_images, conditions=None):
with tf.GradientTape() as discriminator_tape, tf.GradientTape() as gp_tape:
discriminator_tape.watch(real_images)
gp_tape.watch(real_images)
noise = tf.random.normal(shape=(tf.shape(real_images)[0], self.latent_dim), mean=0, stddev=1)
if self.is_conditional:
fake_images = self.generator([noise, conditions])
fake_images = K.clip(fake_images + self.noise_multiplier * tf.random.normal(tf.shape(fake_images), 0, 1), -1, 1)
real_images = K.clip(real_images + self.noise_multiplier * tf.random.normal(tf.shape(fake_images), 0, 1) - 1, 1)
discriminator_output_real = self.discriminator([real_images, conditions])
discriminator_output_fake = self.discriminator([fake_images, conditions])
else:
fake_images = self.generator(noise)
discriminator_output_real = self.discriminator(real_images)
discriminator_output_fake = self.discriminator(fake_images)
epsilon = K.random_uniform(shape=[tf.shape(real_images)[0], 1, 1, 1], minval=0, maxval=1)
interpolated_images = epsilon * real_images + (1 - epsilon) * fake_images
discriminator_output_interpolated_images = self.discriminator(interpolated_images)
dis_gp = gp_tape.gradient(discriminator_output_interpolated_images, interpolated_images)
dis_gp = K.sqrt(K.sum(K.square(dis_gp), axis=[1, 2, 3])) # norm of gradients for every image
dis_gp = K.mean(K.square(dis_gp - 1 * K.ones_like(dis_gp))) # force norm of every gradient to 1
discriminator_loss = self.dis_loss(discriminator_output_real, discriminator_output_fake) + self.gp_weight * dis_gp
discriminator_gradients = discriminator_tape.gradient(discriminator_loss, self.discriminator.trainable_weights)
self.discriminator_optimizer.apply_gradients(zip(discriminator_gradients, self.discriminator.trainable_weights))
return discriminator_loss, dis_gp
def call(self, x, training=None):
mask = K.random_uniform(K.shape(x)[:-1], 0.0, 1.0)
mask = K.expand_dims(mask, -1)
mask = K.repeat_elements(mask, K.int_shape(x)[-1], -1)
rand_x = K.switch(K.less(mask, self.rate),
K.random_normal(K.shape(x), 0.0, 1.0), x)
return K.in_train_phase(rand_x, x, training=training)
def dlt_coefs(vandermonde, weights=None, returned_type: str = "numpy"):
"""
compute coefficients of a conic through direct linear mapping.
vandermonde and weights arguments should be or both np.ndarrays or both tf.tensors
:param vandermonde: (number of points, number of monomials),np.array or tf.tensor. each row contains monomials (e.g. for a conic: x^2 xy y^2 x y 1) of the corresponding point
:param weights: (number of points,) np.array or tf.tensor. probability of belonging to the model for each row in the vandermonde matrix.
if all points belong to the model don't specify its value.
:param returned_type: str, "numpy" returns an np.ndarray; "tensorflow" returns a tf.tensor
:return: np.ndarray or tf.tensor (depending on the value of the parameter "type"), (number of monomials,), the coefficients computed via dlt
"""
# tmp
"""
if type(vandermonde) is not tf.constant:
vandermonde = tf.constant(vandermonde)
if type(weights) is not tf.constant and weights is not None:
weights = tf.constant(weights)
# this line is inserted only because in my project weights are np.ndarrays, and it conflicts with vandermonde (which is a tensor)
weights = tf.constant(weights)
"""
npps = weights.shape[0]
if returned_type == "numpy":
print("cani")
print("{}\n{}".format(type(weights), type(vandermonde)))
# preprocess weights
weights = tf.cast(weights, dtype=tf.float64)
weights = weights + K.random_uniform(
(npps, ), 0, 1e-9, dtype=tf.float64) # --> (npps, nm)
weights = tf.linalg.normalize(weights, axis=0)[0]
weights = tf.linalg.diag(weights)
weighted_vander = tf.matmul(weights, vandermonde)
U, S, V = tf.linalg.svd(
weighted_vander
) # pay attention. tf.linals.svd returns directly V!! not V tranposed!
elif returned_type == "tensorflow":
weights = weights + np.random.normal(0, 1e-9)
weights = weights / np.linalg.norm(weights)
weights = np.diag(weights)
weighted_vander = np.matmul(weights, vandermonde)
U, S, VT = np.linalg.svd(weighted_vander)
V = np.transpose(VT)
else:
raise Exception("Invalid argument for return_type")
dlt_coefficients = V[:, -1]
dlt_coefficients = dlt_coefficients * (
1.0 / dlt_coefficients[0]
) # want the x^2 and y^2 terms to be close to 1
return dlt_coefficients
def thiscall(self, y, M):
M_prime = tf.concat([M[1:], tf.expand_dims(M[0], 0)],
0) # (b,24, 24, 128)
y_exp = Reshape((1, 1, 64))(y) # b 1,1,64
y_exp = tf.tile(y_exp, [1, 24, 24, 1]) # b 24,24 64,
y_M = tf.concat((M, y_exp), -1) # b 24,24 192
y_M_prime = tf.concat((M_prime, y_exp), -1) # b 24,24 192
Ej = -K.mean(softplus(-self.LocalD(y_M)))
Em = K.mean(softplus(self.LocalD(y_M_prime)))
LOCAL = (Em - Ej) * self.beta
Ej = -K.mean(softplus(-self.GlobalD(y, M)))
Em = K.mean(softplus(self.GlobalD(y, M_prime)))
GLOBAL = (Em - Ej) * self.alpha
prior = K.random_uniform(shape=(K.shape(y)[0], K.shape(y)[1]))
term_a = K.mean(K.log(self.PriorD(prior)))
term_b = K.mean(K.log(1.0 - self.PriorD(y)))
PRIOR = -(term_a + term_b) * self.gamma
return GLOBAL, LOCAL, PRIOR
def dropped_mask():
drop_mask = K.switch(
K.random_uniform(K.shape(inputs)) < self.drop_rate,
K.ones_like(inputs, K.floatx()),
K.zeros_like(inputs, K.floatx()),
)
return target_mask * drop_mask
def discriminator_train_step(self, batch):
'''
A discriminator train step. Returns losses.
'''
c = batch[1]
data = tf.one_hot(batch[0], depth=seq_dim, axis=-1, on_value=1, off_value=0)
data = tf.cast(data, dtype=tf.dtypes.float32)
data_size = data.shape[0]
e_shape = (data_size,)
for i in data.shape[1:]:
e_shape = e_shape + (1,)
z = self.sample_z(data_size)
with tf.GradientTape() as disc_tape:
generated_data = self.generator([z,c], training=True)
real_output, real_label_output = self.discriminator([data,c], training=True)
fake_output, fake_label_output = self.discriminator([generated_data,c], training=True)
epsilon = K.random_uniform(e_shape, dtype=tf.dtypes.float32)
random_weighted_average = (epsilon * data) + ((1 - epsilon) * generated_data)
# calculate gradient for penalty
with tf.GradientTape() as norm_tape:
norm_tape.watch(random_weighted_average)
average_output = self.discriminator([random_weighted_average,c], training=True)
gradient = norm_tape.gradient(average_output, random_weighted_average)
disc_loss, w_loss, ac_loss = self.discriminator_loss(real_output, fake_output, real_label_output, fake_label_output, c, gradient, L=10)
gradients_of_discriminator = disc_tape.gradient(disc_loss, self.discriminator.trainable_variables)
self.discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, self.discriminator.trainable_variables))
return (disc_loss, w_loss, ac_loss)
def call(self, layer, inputs, *args, **kwargs):
output = K.in_train_phase(
K.switch(
K.random_uniform([]) > self.rate,
layer(inputs, *args, **kwargs), inputs),
layer(inputs, *args, **kwargs))
return output
def call(self,
inputs: tf.Tensor,
mask: Optional[tf.Tensor] = None):
"""
Args:
inputs (tf.Tensor[ndims=2, int]): Tensor of values to mask
mask (Optional[tf.Tensor[bool]]): Locations in the inputs to that are valid
(i.e. not padding, start tokens, etc.)
Returns:
masked_inputs (tf.Tensor[ndims=2, int]): Tensor of masked values
bert_mask: Locations in the input that were masked
"""
random_mask = self._generate_bert_mask(inputs)
if mask is not None:
random_mask &= mask
masked_inputs = inputs * tf.cast(~random_mask, inputs.dtype)
random_mask = tf.cast(random_mask, inputs.dtype)
masked_inputs += K.random_uniform(
K.shape(random_mask), 0, self.n_symbols, dtype=inputs.dtype) * random_mask
return masked_inputs
def spatial_concrete_dropout(self, x):
'''
Concrete dropout - used at training time (gradients can be propagated)
:param x: input
:return: approx. dropped out input
'''
eps = K.cast_to_floatx(K.epsilon())
temp = 2. / 3.
#temp = 0.1
input_shape = K.shape(x)
if self.data_format == 'channels_first':
noise_shape = (input_shape[0], input_shape[1], 1, 1)
else:
noise_shape = (input_shape[0], 1, 1, input_shape[3])
unif_noise = K.random_uniform(shape=noise_shape)
drop_prob = (K.log(self.p + eps) - K.log(1. - self.p + eps) +
K.log(unif_noise + eps) - K.log(1. - unif_noise + eps))
drop_prob = K.sigmoid(drop_prob / temp)
random_tensor = 1. - drop_prob
retain_prob = 1. - self.p
x *= random_tensor
x /= retain_prob
return x
def train_on_batch(self, epoch, iteration, batch):
self.global_step.assign_add(1)
loss_d, loss_g = None, None
with tf.GradientTape() as tape_generator, tf.GradientTape(
) as tape_discriminator:
z = K.random_uniform(
(K.int_shape(batch)[0], self.config.input_dim))
generated = self.generator(z, training=True)
logits_generated = self.discriminator(generated, training=True)
logits_real = self.discriminator(batch, training=True)
loss_d = self.config.discriminator_loss_fn(logits_generated,
logits_real, generated,
batch,
self.discriminator)
if self.global_step.numpy() % self.config.training_ratio == 0:
loss_g = self.config.generator_loss_fn(logits_generated,
logits_real, generated,
batch, self.generator)
_update(loss_d, self.discriminator, self.optimizer_discriminator,
tape_discriminator)
_update(loss_g, self.generator, self.optimizer_generator,
tape_generator)
return loss_g, loss_d
def call(self, inputs, **kwargs):
# Generate random uniform tensor between [1-alpha, 1+alpha] for training and ones tensor for test (ReLU)
k = K.in_train_phase(
K.random_uniform(inputs.shape[1:], 1 - self.alpha, 1 + self.alpha),
K.ones(inputs.shape[1:]))
return keras.activations.relu(inputs * k)
def call(self, x):
x1 = self.conv1(x)
x2 = self.conv2(x)
# create alpha and beta
batch_size = backend.shape(x1)[0]
alpha = backend.random_uniform((batch_size, 1, 1, 1))
beta = backend.random_uniform((batch_size, 1, 1, 1))
# shake-shake during training phase
def x_shake():
return beta * x1 + (1 - beta) * x2 + backend.stop_gradient((alpha - beta) * x1 + (beta - alpha) * x2)
# even-even during testing phase
def x_even():
return 0.5 * x1 + 0.5 * x2
return self.activation(backend.in_train_phase(x_shake, x_even))
def call(self, x):
# unpack x1 and x2
assert isinstance(x, list)
x1, x2 = x
# create alpha and beta
batch_size = K.shape(x1)[0]
alpha = K.random_uniform((batch_size, 1, 1, 1))
beta = K.random_uniform((batch_size, 1, 1, 1))
# shake-shake during training phase
def x_shake():
return beta * x1 + (1 - beta) * x2 + K.stop_gradient((alpha - beta) * x1 + (beta - alpha) * x2)
# even-even during testing phase
def x_even():
return 0.5 * x1 + 0.5 * x2
return K.in_train_phase(x_shake, x_even)
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))
thre = K.random_uniform(shape=(batch, 1))
return z_mean + K.exp(0.5 * z_log_var) * epsilon
def gradient_penalty(self,generated_samples,real_images,half_batch):
alpha = backend.random_uniform(shape=[half_batch,1,1,1],minval=0.0,maxval=1.0)
differences = generated_samples - real_images
interpolates = real_images + (alpha * differences)
gradients = tf.gradients(self.critic(interpolates),[interpolates])[0]
slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients),axis=[1,2,3]))
gradient_p = tf.reduce_mean((slopes-1.)**2)
return gradient_p
def noiseAndLatentC(self):
noise = normal([self.batchSize, self.noiseDim - 1])
rC = random_uniform(shape=(self.batchSize, 1), minval=0, maxval=9, dtype='int32')
cForLoss = to_categorical(rC, num_classes=10)
cForLoss = transpose(cForLoss)
rC = cast(rC, dtype='float')
noiseAndC = concat([rC, noise], axis=1)
return (cForLoss, noiseAndC)
def call(self, inputs: tf.Tensor, delay: tf.Tensor = None) -> tf.Tensor:
debug_tensor(LOGGER, inputs, 'Del.in')
if delay is None:
delay: tf.Tensor = K.random_uniform([self._taps], -1.0, 1.0)
debug_tensor(LOGGER, delay, 'Del.del')
result: tf.Tensor = conv1d(inputs, delay)
debug_tensor(LOGGER, result, 'Del.rslt')
return result
def test_Dense(self):
inputs = K.random_uniform([2, 16])
model = Sequential([Dense(32, input_shape=K.int_shape(inputs)[1:])])
self.assertEqual(model.output_shape, (None, 32))
outputs = model(inputs)
self.assertEqual(K.int_shape(outputs), (2, 32))
def sampling_concrete(alpha,temperature=0.67):
batch=K.shape(alpha)[0]
dim=K.int_shape(alpha)[1]
uniform = K.random_uniform(shape=(batch,dim))
gumbel = - K.log(- K.log(uniform + EPSILON) + EPSILON)
fenshi=tf.reduce_logsumexp((K.log(alpha+EPSILON)+gumbel)/temperature,1,keep_dims=True)
logit = (K.log(alpha + EPSILON) + gumbel) / temperature -fenshi
return logit
def channel(self, zMean):
batch = K.shape(zMean)[0]
# Generate Laplace r.v.
# Source: https://en.wikipedia.org/wiki/Laplace_distribution#Generating_random_variables_according_to_the_Laplace_distribution
# Code: https://stackoverflow.com/questions/56691436/how-can-one-add-laplacian-noise-to-a-tensor-in-keras
u = K.random_uniform((batch, self.latent_dim), minval=-0.5, maxval=0.5)
epsilon = K.sign(u) * K.log(1 - 2 * K.abs(u) + K.epsilon())
return zMean + self.n0 / self.latent_dim * epsilon
