def pearson_correlation(y_true, y_pred):
# Pearson's correlation coefficient = covariance(X, Y) / (stdv(X) * stdv(Y))
fs_pred = y_pred - K.mean(y_pred)
fs_true = y_true - K.mean(y_true)
covariance = K.mean(fs_true * fs_pred)
stdv_true = K.std(y_true)
stdv_pred = K.std(y_pred)
return covariance / (stdv_true * stdv_pred)
def mvn(tensor):
"""Per row mean-variance normalization."""
epsilon = 1e-6
mean = K.mean(tensor, axis=1, keepdims=True)
std = K.std(tensor, axis=1, keepdims=True)
mvn = (tensor - mean) / (std + epsilon)
return mvn
def call(self, inputs):
if not self.norm_method:
outputs = inputs
elif self.norm_method == 'whole_image':
reduce_axes = [3, 4] if self.data_format == 'channels_first' else [
2, 3
]
outputs = inputs - tf.reduce_mean(
inputs, axis=reduce_axes, keepdims=True)
outputs /= K.std(inputs, axis=reduce_axes, keepdims=True)
elif self.norm_method == 'std':
outputs = inputs - self._average_filter(inputs)
outputs /= self._window_std_filter(outputs)
elif self.norm_method == 'max':
outputs = inputs / tf.reduce_max(inputs)
outputs -= self._average_filter(outputs)
elif self.norm_method == 'median':
reduce_axes = list(range(len(inputs.shape)))[1:]
reduce_axes.remove(self.channel_axis)
# mean = self._reduce_median(inputs, axes=reduce_axes)
mean = tf.contrib.distributions.percentile(inputs, 50.)
outputs = inputs / mean
outputs -= self._average_filter(outputs)
else:
raise NotImplementedError('"{}" is not a valid norm_method'.format(
self.norm_method))
return outputs
def call(self, inputs, training=None):
class_labels = K.squeeze(inputs[1], axis=1)
inputs = inputs[0]
input_shape = K.int_shape(inputs)
reduction_axes = list(range(0, len(input_shape)))
if self.axis is not None:
del reduction_axes[self.axis]
del reduction_axes[0]
mean = K.mean(inputs, reduction_axes, keepdims=True)
stddev = K.std(inputs, reduction_axes, keepdims=True) + self.epsilon
normed = (inputs - mean) / stddev
broadcast_shape = [1] * len(input_shape)
broadcast_shape[0] = K.shape(inputs)[0]
if self.axis is not None:
broadcast_shape[self.axis] = input_shape[self.axis]
if self.scale:
broadcast_gamma = K.reshape(K.gather(self.gamma, class_labels),
broadcast_shape)
normed = normed * broadcast_gamma
if self.center:
broadcast_beta = K.reshape(K.gather(self.beta, class_labels),
broadcast_shape)
normed = normed + broadcast_beta
return normed
def sample_variance(self, x, y):
_, _, decoder_lambda, decoder_dense = self.decoder.layers
input1 = K.random_normal(shape=(1000, self.latent_dim))
input2 = K.random_normal(shape=(1000, self.latent_dim))
z = decoder_lambda([input1, input2])
x_decoded_mean = decoder_dense(z)
return K.mean(K.std(x_decoded_mean, axis=0))
def _merge_function(self, inputs):
# Check exception.
x = inputs
if isinstance(x, list) != True or len(x) != 2:
raise ValueError('Input must be a list of two tensors.')
assert K.int_shape(x[0]) == K.int_shape(x[1]) #?
if self.axis < 0:
assert K.ndim(x[0]) + self.axis >= 0
self.axis = K.ndim(x[0]) + self.axis #?
reduce_axes = tuple(
[i for i in range(1, K.ndim(x[0])) if i != self.axis])
c = x[0] # Content image tensor.
s = x[1] # Style image tensor.
# Calculate mean and variance.
c_mean = K.mean(c, axis=reduce_axes, keepdims=True)
c_std = K.std(c, axis=reduce_axes, keepdims=True) + self.epsilon
s_mean = K.mean(s, axis=reduce_axes, keepdims=True)
s_std = K.std(s, axis=reduce_axes, keepdims=True)
return s_std * ((c - c_mean) / c_std) + s_mean # Broadcasting?
def call(self, x, mask=None):
def image_expand(tensor):
return K.expand_dims(K.expand_dims(tensor, -1), -1)
def batch_image_expand(tensor):
return image_expand(K.expand_dims(tensor, 0))
input_shape = K.int_shape(x)
reduction_axes = list(range(0, len(input_shape)))
del reduction_axes[3]
del reduction_axes[0]
mean = K.mean(x, reduction_axes, keepdims=True)
stddev = K.std(x, reduction_axes, keepdims=True) + 1e-3
normed = (x - mean) / stddev
broadcast_shape = [1] * len(input_shape)
broadcast_shape[3] = input_shape[3]
broadcast_gamma = K.reshape(self.gamma, broadcast_shape)
normed = normed * broadcast_gamma
broadcast_beta = K.reshape(self.beta, broadcast_shape)
normed = normed + broadcast_beta
return normed
def call(self, inputs):
if not self.norm_method:
outputs = inputs
elif self.norm_method == 'whole_image':
axes = [3, 4] if self.channel_axis == 1 else [2, 3]
outputs = inputs - K.mean(inputs, axis=axes, keepdims=True)
outputs = outputs / K.std(inputs, axis=axes, keepdims=True)
elif self.norm_method == 'std':
outputs = inputs - self._average_filter(inputs)
outputs = outputs / self._window_std_filter(outputs)
elif self.norm_method == 'max':
outputs = inputs / K.max(inputs)
outputs = outputs - self._average_filter(outputs)
else:
raise NotImplementedError('"{}" is not a valid norm_method'.format(
self.norm_method))
return outputs
def call(self, inputs, training=None):
input_shape = K.int_shape(inputs)
reduction_axes = list(range(0, len(input_shape)))
if self.axis is not None:
del reduction_axes[self.axis]
del reduction_axes[0]
mean = K.mean(inputs, reduction_axes, keepdims=True)
stddev = K.std(inputs, reduction_axes, keepdims=True) + self.epsilon
normed = (inputs - mean) / stddev
def noised():
eps = K.random_uniform(shape=[1], maxval=self.alpha)
return inputs + K.random_normal(
shape=K.shape(inputs), mean=0., stddev=eps)
get_noised = K.in_train_phase(noised, normed, training=training)
retrived = stddev * get_noised + mean
return retrived
def call(self, inputs):
# Check exception.
x = inputs
if isinstance(x, list) != True or len(x) != 2:
raise ValueError('Input must be a list of two tensors.')
assert len(K.int_shape(x[1])) == 2
if self.axis < 0:
assert K.ndim(x[0]) + self.axis >= 0
self.axis = K.ndim(x[0]) + self.axis #?
reduce_axes = tuple(
[i for i in range(1, K.ndim(x[0])) if i != self.axis])
c = x[0] # Content image tensor.
s = x[1] # Style dlatent tensor.
# Calculate mean and variance.
c_mean = K.mean(c, axis=reduce_axes, keepdims=True)
c_std = K.std(c, axis=reduce_axes, keepdims=True) + self.epsilon
s = K.reshape(s, [-1, 2, 1, 1, c.shape[-1]]) #?
return (s[:, 0] + 1) * ((c - c_mean) / c_std) + s[:, 1]
def call(self, x):
mean = K.mean(x, axis=self.axis, keepdims=True)
std = K.std(x, axis=self.axis, keepdims=True)
out = self.gamma * (x - mean) / (std + self.eps) + self.beta
return out
def corr_loss(act,pred):
cov=(K.mean((act-K.mean(act))*(pred-K.mean(pred))))
return 1-(cov/(K.std(act)*K.std(pred)+K.epsilon()))
def call(self, inputs):
mean = K.mean(inputs, axis=self.axis, keepdims=True)
std = K.std(inputs, axis=self.axis, keepdims=True)
return self.gamma * (inputs - mean) / (std + self.eps) + self.beta
def call(self, x):
mean = K.mean(x, axis=-1, keepdims=True)
std = K.std(x, axis=-1, keepdims=True)
return self.gamma * (x - mean) / (std + self.eps) + self.beta
def data_variance(self, x, y):
_, encoder_mean, encoder_logvar = self.encoder.layers
z_mean = encoder_mean(x)
z_logvar = encoder_logvar(x)
return K.mean(K.std(z_mean, axis=0))
def std_if_not_int(val):
if val.dtype.is_integer:
return 0
else:
return tf.stop_gradient(K.std(val, keepdims=True))
