def time_step(self, x, y1, y2):
"""Take a step through time.
Parameters
----------
x : Input value(s) at current time step, batched in first dimension
y1 : Scalar wave field one time step ago (part of the hidden state)
y2 : Scalar wave field two time steps ago (part of the hidden state)
"""
dt = self.dt
c = self.c
b = self.b
term_a = 2 + dt**2*math.multiply(c.pow(2), self.compute_laplacian(y1))
term_two = math.multiply(-1 - dt * b, y2)
denominator = dt ** (-2) + b * 0.5 * dt ** (-1)
y = math.multiply(denominator.pow(-1),
math.add(term_a, term_two))
# Insert the source
y_out = y[:, self.src_x, self.src_y]
y_out = y_out + tf.broadcast_to(x, tf.shape(y_out))
return y_out, y1
def trainModel(self, infos):
with self.graph.as_default():
states = tf.constant([i["state"].tolist() for i in infos],
shape=[infos.size, 24])
rewards = tf.constant([i["reward"] for i in infos],
dtype=tf.float32,
shape=[infos.size, 1])
# next_states = tf.constant([i["next_state"].tolist() for i in infos], shape=[infos.size, 24])
actions = tf.constant([i["action"] for i in infos],
dtype=tf.float32,
shape=[infos.size, 12])
# Qtargets = tf.constant(self.model.predict(next_states, steps=1), shape=[infos.size, 12])
# Recupere l'etat actuel
targets = tf.constant(self.model.predict(states, steps=1),
shape=[infos.size, 12])
# Calcure le mask negatif
mask = tf.ones([infos.size, 12], dtype=tf.float32)
mask = tfm.subtract(mask, actions)
# Applique le mask négatif
targets = tfm.multiply(targets, mask)
# Calcure le mask positif
mask = tfm.multiply(rewards, actions)
# Applique le mask positif
targets = tfm.add(targets, mask)
self.model.fit(states, targets, steps_per_epoch=200) # 1000
def _loss_fn(y_true, y_pred):
# Mask the predictions to ignore padded records
mask = kwargs.get("mask")
y_true = math.multiply(tf.cast(mask, tf.float32),
tf.cast(y_true, tf.float32))
y_pred = math.multiply(tf.cast(mask, tf.float32),
tf.cast(y_pred, tf.float32))
return cce(y_true, y_pred)
def actor_predictive_clustering_loss(y_true,
y_pred,
cluster_assignment_probs,
y_type='categorical',
name='actor_pred_clus_L'):
"""
Compute prediction clustering loss between predicted output and true output with probability weights
from cluster assignments.
Inputs have shape (batch_size, T, num_classes) for y_pred and (batch_size, num_classes) for y_true
or (batch_size, num_cluster) for cluster_assignment_probs.
There are a variety of different settings, all weighted sample-wise by assignment probability:
- Binary: Computes Binary Cross Entropy. Class/Event occurence is matched with a dimension.
y_true with entries in [0,1], and y_pred with value between (0,1)
- Categorical: Computes Cross Entropy Loss. Class assigned by highest value dimension.
y_true is a one-hot encoding, and y_pred is a probabilistic vector.
- Continuous: Computes L2 loss. Similar to the Binary case, but class attributes are continuous.
y_true and y_pred both with real-value entries.
Returns: Loss value between sample true y and predicted y based on y_type of shape (batch_size)
"""
y_true_temp_ = tf.repeat(tf.expand_dims(y_true, axis=1),
repeats=y_pred.shape[1],
axis=1,
name='true_y_time')
if y_type == 'binary':
# Compute Binary Cross Entropy weighted by cluster assignment probabilities.
sample_loss = multiply(
tf.reduce_sum(y_true_temp_ * log(y_pred) +
(1 - y_true_temp_) * log(y_pred),
axis=-1), cluster_assignment_probs)
batch_loss = -tf.reduce_mean(sample_loss, name=name)
return batch_loss
elif y_type == 'categorical':
# Compute Categorical Cross Entropy weighted by cluster assignment probabilities.
sample_loss = multiply(
tf.reduce_sum(y_true_temp_ * log(y_pred), axis=-1),
cluster_assignment_probs)
batch_loss = -tf.reduce_mean(sample_loss, name=name)
return batch_loss
elif y_type == 'continuous':
# Compute L2 Loss weighted by cluster assigment probabilities.
sample_loss = multiply(tf.reduce_sum((y_true - y_pred)**2, axis=-1),
cluster_assignment_probs)
batch_loss = tf.reduce_mean(sample_loss, name=name)
return batch_loss
def call(self, x, beta):
if self.res == 1:
h_stack, v_stack = tf.unstack(x, axis=-1)
else:
h_stack = x
v_stack = x
#Vertical stack is acted by a vertical convolution
#equivalent to a masked one
v_stack = self.ver_cropping(v_stack)
v_stack = self.ver_padding(v_stack)
v_stack = self.ver_conv(v_stack)
v_stack += self.ver_seq(beta)
#Horizontal stack is acted by a horizontal convolution
#equivalent to a masked one- h_stack2 is kept for later
h_stack2 = h_stack
h_stack = self.hor_cropping(h_stack)
h_stack = self.hor_padding(h_stack)
h_stack = self.hor_conv(h_stack)
h_stack = tfm.add(h_stack, self.hor_seq(beta))
#Add v_stack to h_stack
h_stack = tfm.add(h_stack, v_stack)
#"Gating" performed on horizontal stack
h_stack0, h_stack1 = tf.split(h_stack, 2, axis=-1)
h_stack0 = tfk.activations.tanh(h_stack0)
h_stack1 = tfk.activations.sigmoid(h_stack1)
h_stack = tfm.multiply(h_stack0, h_stack1)
#"Gating" and convolving vertical stack
if not self.last_layer:
v_stack0, v_stack1 = tf.split(v_stack, 2, axis=-1)
v_stack0 = tfk.activations.tanh(v_stack0)
v_stack1 = tfk.activations.sigmoid(v_stack1)
v_stack = tfm.multiply(v_stack0, v_stack1)
v_stack = self.ver_conv2(v_stack)
#Convolve h_stack2, h_stack and connect them
h_stack = self.hor_conv2(h_stack)
if self.res:
h_stack2 = self.res_conv(h_stack2)
h_stack = tfm.add(h_stack, h_stack2)
if self.last_layer:
output = h_stack
else:
output = tf.stack([h_stack, v_stack], axis=-1)
return output
def calculate_protein(self, fbar, k_fbar, Δ): # Calculate p_i vector
τ = self.data.τ
f_i = inverse_positivity(fbar)
δ_i = tf.reshape(logit(k_fbar), (-1, 1))
if self.options.delays:
# Add delay
Δ = tf.cast(Δ, 'int32')
for r in range(self.num_replicates):
f_ir = rotate(f_i[r], -Δ)
mask = ~tf.sequence_mask(Δ, f_i.shape[2])
f_ir = tf.where(mask, f_ir, 0)
mask = np.zeros((self.num_replicates, 1, 1), dtype='float64')
mask[r] = 1
f_i = (1 - mask) * f_i + mask * f_ir
# Approximate integral (trapezoid rule)
resolution = τ[1] - τ[0]
sum_term = tfm.multiply(tfm.exp(δ_i * τ), f_i)
cumsum = 0.5 * resolution * tfm.cumsum(
sum_term[:, :, :-1] + sum_term[:, :, 1:], axis=2)
integrals = tf.concat([
tf.zeros((self.num_replicates, self.num_tfs, 1), dtype='float64'),
cumsum
],
axis=2)
exp_δt = tfm.exp(-δ_i * τ)
p_i = exp_δt * integrals
return p_i
def augmentation(img, msk):
# Call in skimage package, which will be used for transformations.
import tensorflow.math as Math
# Create some random floats, which will be used in augmentation steps.
tilt = tf.random.uniform(shape=[], minval=-30, maxval=30, dtype=tf.float32)
dx = tf.random.uniform(shape=[], minval=-5, maxval=5, dtype=tf.float32)
dy = tf.random.uniform(shape=[], minval=-5, maxval=5, dtype=tf.float32)
# Use TensforFlow-style if conditionals, used to flip image and mask.
img = tf.cond(tilt > 0, lambda: tf.image.flip_left_right(img),
lambda: tf.image.flip_up_down(img))
msk = tf.cond(tilt > 0, lambda: tf.image.flip_left_right(msk),
lambda: tf.image.flip_up_down(msk))
# Rotate the image and mask to some degree.
# img = rotate(img, angle = tilt, mode = 'reflect')
# msk = rotate(msk, angle = tilt, mode = 'reflect')
toRads = Math.multiply(Math.divide(tilt, 180), tf.constant(math.pi))
img = tfa.image.rotate(img, toRads)
msk = tfa.image.rotate(msk, toRads)
# Affine transformation
img = tfa.image.translate(img, [dx, dy], 'BILINEAR')
msk = tfa.image.translate(msk, [dx, dy], 'BILINEAR')
# Convert the inputs back into tensors, put back into a tuple.
finalTuple = (img, msk)
return finalTuple
def reloss(y_true, y_pred):
"""
Custom loss to not penalize when the prediction is negative (dissimilar) and true label is 0.
"""
loss_filter = maximum(y_true, y_pred)
loss_filter = divide_no_nan(
loss_filter, loss_filter) # normalize any positive value to 1
return multiply(loss_filter, MAE(y_true, y_pred))
def call(self, x):
for i in range(self.net_depth + 1):
x = self.custom_layers[i](x)
if self.z2 and x.shape[1] == self.L:
x_hat = tfm.multiply(x, self.x_hat_mask)
x_hat = tfm.add(x_hat, self.x_hat_bias)
else:
x_hat = x
return x_hat
def call(self, inputs):
# Generate random value matrix (newly generated with each call) - vector version
self.kernel_epsilon = K.random_normal(shape=(self.input_dim,
self.units))
w = self.kernel + math.multiply(self.kernel_sigma, self.kernel_epsilon)
output = K.dot(inputs, w)
if self.use_bias:
# Generate random bias vector
self.bias_epsilon = K.random_normal(shape=(self.units, ))
bias = self.bias + math.multiply(self.bias_sigma,
self.bias_epsilon)
output = output + bias
if self.activation is not None:
output = self.activation(output)
return output
def call(self , input):
shape = list(self.shape[1:])
shape.append(1)
x = Reshape(shape)(input)
return multiply(x , self.kernel)
def call(self, x):
rank = len(x.shape)
X = [0] * x.shape[-1]
for i in range(self.n_activations):
# Broadcasting is required for the inputs.
X[i] = tfm.tanh(tfm.multiply(self.alphas[i], x[:, :, i:i + 1]))
X = K.concatenate(X, axis=2)
return X
def predict_m(self, kbar, k_fbar, wbar, fbar, w_0bar, Δ):
# Take relevant parameters out of log-space
if self.options.kinetic_exponential:
kin = (tf.reshape(tf.exp(logit(kbar[:, i])), (-1, 1))
for i in range(kbar.shape[1]))
else:
kin = (tf.reshape(logit(kbar[:, i]), (-1, 1))
for i in range(kbar.shape[1]))
if self.options.initial_conditions:
a_j, b_j, d_j, s_j = kin
else:
b_j, d_j, s_j = kin
w = (wbar)
w_0 = tf.reshape((w_0bar), (-1, 1))
τ = self.data.τ
N_p = self.data.τ.shape[0]
p_i = inverse_positivity(fbar)
if self.options.translation:
p_i = self.calculate_protein(fbar, k_fbar, Δ)
# Calculate m_pred
resolution = τ[1] - τ[0]
interactions = tf.matmul(w, tfm.log(p_i + 1e-100)) + w_0
G = tfm.sigmoid(interactions) # TF Activation Function (sigmoid)
sum_term = G * tfm.exp(d_j * τ)
integrals = tf.concat(
[
tf.zeros((self.num_replicates, self.num_genes, 1),
dtype='float64'), # Trapezoid rule
0.5 * resolution *
tfm.cumsum(sum_term[:, :, :-1] + sum_term[:, :, 1:], axis=2)
],
axis=2)
exp_dt = tfm.exp(-d_j * τ)
integrals = tfm.multiply(exp_dt, integrals)
m_pred = b_j / d_j + s_j * integrals
if self.options.initial_conditions:
m_pred += tfm.multiply((a_j - b_j / d_j), exp_dt)
return m_pred
def call(self, inputs, mask=None):
# Builds input
x, y = tf.split(inputs, num_or_size_splits=2, axis=1)
x2 = tfm.square(x)
y2 = tfm.square(y)
xy = tfm.multiply(x, y)
quad_inputs = tf.stack(
[x2, xy, y2, x, y, tf.ones((tf.shape(x)))], axis=1)
quad_outputs = tf.squeeze(tf.matmul(self.coeffs, quad_inputs),
axis=[1])
return quad_outputs
def call(self, inputs):
# add noise to kernel
self.kernel_epsilon = K.random_normal(shape=self.kernel_shape)
w = self.kernel + math.multiply(self.kernel_sigma, self.kernel_epsilon)
outputs = K.conv2d(inputs,
w,
strides=self.strides,
padding=self.padding,
data_format=self.data_format,
dilation_rate=self.dilation_rate)
if self.use_bias:
self.bias_epsilon = K.random_normal(shape=(self.filters, ))
b = self.bias + math.multiply(self.bias_sigma, self.bias_epsilon)
outputs = K.bias_add(outputs, b, data_format=self.data_format)
if self.activation is not None:
return self.activation(outputs)
return outputs
def call(self, inputs, mask=None):
# Builds input
x, y = tf.split(inputs, num_or_size_splits=2, axis=1)
x2 = tfm.square(x)
y2 = tfm.square(y)
xy = tfm.multiply(x, y)
quad_inputs = tf.stack(
[x2, xy, y2, x, y, tf.ones((tf.shape(x)))], axis=1)
quad_outputs = tf.reduce_sum(
tf.multiply(self.coeffs, tf.transpose(quad_inputs,
perm=(0, 2, 1))), 2)
return quad_outputs
def compute_angle_tensor(pts1, pts2):
""" Compute the angle between pt1 and pt2 with respect to the origin
Input:
pts1: batch_size x 1 x 3 tensor
pts2: batch_size x 1 x 3 tensor
"""
b = tf.constant([0.,0.,0.])
angle_diff = []
for pt1, pt2 in zip(pts1, pts2):
ba = tf.subtract(pt1, b)
bc = tf.subtract(pt2, b)
cosine_angle = tm.divide(tf.tensordot(ba, bc, 1), tm.multiply(tf.norm(ba), tf.norm(bc)))
angle = tm.acos(cosine_angle)
angle_diff.append(tf.cast(angle, tf.float32))
return tf.stack(angle_diff, axis=0)
def psnr(y_label, y_pred):
"""
PSNR is Peek Signal to Noise Ratio, which is similar to mean squared error.
It can be calculated as
PSNR = 20 * log10(MAXp) - 10 * log10(MSE)
When providing an unscaled input, MAXp = 255. Therefore 20 * log10(255)== 48.1308036087.
However, since we are scaling our input, MAXp = 1. Therefore 20 * log10(1) = 0.
Thus we remove that component completely and only compute the remaining MSE component.
"""
_result = subtract(y_label, y_pred)
_result = square(_result)
_result = tf_mean(_result)
_result = multiply(-10., log(_result, 10.))
return _result
def call(self, x, beta):
if self.res:
l_stack, m_stack, r_stack = tf.unstack(x, axis=-1)
m_stack2 = m_stack
else:
l_stack = x
r_stack = x
m_stack = tf.zeros_like(x)
#Left stack is cropped, padded followed by convolution
l_stack = self.l_cropping(l_stack)
l_stack = self.l_padding(l_stack)
l_stack = self.l_conv(l_stack)
#Conditioning on beta
l_stack += self.l_seq(beta)
#Right stack is cropped, padded followed by convolution
r_stack = self.r_cropping(r_stack)
r_stack = self.r_padding(r_stack)
r_stack = self.r_conv(r_stack)
#Conditioning on beta
r_stack += self.r_seq(beta)
#Update/initialise m_stack
m_stack = self.m_conv(m_stack)
m_stack += tfm.add(l_stack, r_stack)
#Gating operation on m_stack
m_stack0, m_stack1 = tf.split(m_stack, 2, axis=-1)
m_stack0 = tfk.activations.tanh(m_stack0)
m_stack1 = tfk.activations.sigmoid(m_stack1)
m_stack = tfm.multiply(m_stack0, m_stack1)
if not self.last_layer:
l_stack = self.l_conv2(l_stack)
r_stack = self.r_conv2(r_stack)
#Convolve m_stack2, m_stack and connect them
m_stack = self.m_conv2(m_stack)
if self.res:
m_stack2 = self.m_res_conv(m_stack2)
m_stack = tfm.add(m_stack, m_stack2)
if self.last_layer:
output = m_stack
else:
output = tf.stack([l_stack, m_stack, r_stack], axis=-1)
return output
def reparameterisation_trick(mu, log_sig_sq):
'''
Sample from Gaussian such that it stays differentiable
INPUTS:
mu - mean of distribution
log_sig_sq - log variance of diatribution
OUTPUTS:
samp - sample from distribution
'''
eps = tf.random.normal([tf.shape(mu)[0], tf.shape(mu)[1]],
0,
1.,
dtype=tf.float32)
samp = tfm.add(mu, tfm.multiply(tfm.sqrt(tfm.exp(log_sig_sq)), eps))
return samp
def PST(I, LPF, Phase_strength, Warp_strength, Threshold_min, Threshold_max):
#inverting Threshold_min to simplyfy optimization porcess, so we can clip all variable between 0 and 1
LPF = ops.convert_to_tensor_v2(LPF)
Phase_strength = ops.convert_to_tensor_v2(Phase_strength)
Warp_strength = ops.convert_to_tensor_v2(Warp_strength)
I = ops.convert_to_tensor_v2(I)
Threshold_min = ops.convert_to_tensor_v2(Threshold_min)
Threshold_max = ops.convert_to_tensor_v2(Threshold_max)
Threshold_min = -Threshold_min
L = 0.5
x = tf.linspace(-L, L, I.shape[0])
y = tf.linspace(-L, L, I.shape[1])
[X1, Y1] = (tf.meshgrid(x, y))
X = tf.transpose(X1)
Y = tf.transpose(Y1)
[THETA, RHO] = cart2pol(X, Y)
# Apply localization kernel to the original image to reduce noise
Image_orig_f = sig.fft2d(tf.dtypes.cast(I, tf.complex64))
tmp6 = (LPF**2.0) / tfm.log(2.0)
tmp5 = tfm.sqrt(tmp6)
tmp4 = (tfm.divide(RHO, tmp5))
tmp3 = -tfm.pow(tmp4, 2)
tmp2 = tfm.exp(tmp3)
expo = fftshift(tmp2)
Image_orig_filtered = tfm.real(
sig.ifft2d((tfm.multiply(tf.dtypes.cast(Image_orig_f, tf.complex64),
tf.dtypes.cast(expo, tf.complex64)))))
# Constructing the PST Kernel
tp1 = tfm.multiply(RHO, Warp_strength)
PST_Kernel_1 = tfm.multiply(
tp1, tfm.atan(tfm.multiply(RHO, Warp_strength))
) - 0.5 * tfm.log(1.0 + tfm.pow(tf.multiply(RHO, Warp_strength), 2.0))
PST_Kernel = PST_Kernel_1 / tfm.reduce_max(PST_Kernel_1) * Phase_strength
# Apply the PST Kernel
temp = tfm.multiply(
fftshift(
tfm.exp(
tfm.multiply(tf.dtypes.complex(0.0, -1.0),
tf.dtypes.cast(PST_Kernel,
tf.dtypes.complex64)))),
sig.fft2d(tf.dtypes.cast(Image_orig_filtered, tf.dtypes.complex64)))
Image_orig_filtered_PST = sig.ifft2d(temp)
# Calculate phase of the transformed image
PHI_features = tfm.angle(Image_orig_filtered_PST)
out = PHI_features
out = (out / tfm.reduce_max(out)) * 3
return out
def call(self, x, beta):
"""Produces the network output for a sample
Args:
x (float32): A sample configuration of Ising model
beta (float32): Inverse temperature
Returns:
float32: Probabilities of +1 value at every lattice site
"""
for i in range(self.net_depth):
x = self.custom_layers[i](x, beta)
x = self.custom_layers[self.net_depth](x)
if self.z2 and x.shape[1] == self.L:
x_hat = tfm.multiply(x, self.x_hat_mask)
x_hat = tfm.add(x_hat, self.x_hat_bias)
else:
x_hat = x
return x_hat
def call(self, inputs, mask=None):
# Saves dimensions to make code nicer
batch_size = inputs.shape[0]
height = inputs.shape[1]
width = inputs.shape[2]
num_filters = inputs.shape[3]
# Reshapes so last 2 dimensions are a single filter
inputs = tf.transpose(inputs, [0, 3, 1, 2])
# Reshapes into columns for x,y
inputs = tf.reshape(inputs, [batch_size, num_filters, -1, 2])
# Transposes to get correct dimensions for matmul
inputs = tf.transpose(inputs, [0, 1, 3, 2])
# Splits tensor into x & y
x, y = tf.split(inputs, 2, 2)
# Calculates other components of quadratic input
x2 = tfm.square(x)
y2 = tfm.square(y)
xy = tfm.multiply(x, y)
# Builds quadratic input
quad_input = tf.concat(
[x2, xy, y2, x, y, tf.ones((tf.shape(x)))], axis=2)
# Matmul -> Quadratic output
quad_output = tf.matmul(self.coeffs, quad_input)
# Reshapes back to original size with width / 2
quad_output = tf.reshape(
quad_output, [batch_size, num_filters, height,
int(width / 2)])
# Rearranges axis to have num_filters last (as CONV2D expects)
quad_output = tf.transpose(quad_output, [0, 2, 3, 1])
return quad_output
def call(self, x):
X = []
for i in range(self.n_activations):
self.i = i
frame = x[:, :, i:i + 1]
sigma1 = K.variable(
np.zeros((self.batch, frame.shape[1], frame.shape[2])))
for j in range(self.v_order):
j_fact = math.factorial(j)
p = tfm.divide(K.pow(frame, j), j_fact)
sigma1 = tfm.add(sigma1, tfm.multiply(self.v[i][j], p))
sigma2 = K.variable(
np.zeros((self.batch, frame.shape[1], frame.shape[2])))
for j in range(1, self.w_order + 1):
self.k = j
sigma2 = tfm.add(sigma2, K.map_fn(self.basis2, frame))
X.append(tfm.add(sigma1, sigma2))
output = K.concatenate(X, axis=2)
return output
def basis2(self, x):
# b_2_k = K.variable(np.zeros(x.shape[0], ))
k_1 = tf.constant(self.breakpoints[self.k - 1], dtype=tf.float32)
# print(k_1.shape)
k = tf.constant(self.breakpoints[self.k], dtype=tf.float32)
def f1():
return tfm.add(
tfm.subtract(tfm.divide(tfm.multiply(x, x), 2),
tfm.multiply(k_1, x)),
tfm.divide(tfm.multiply(k_1, k_1), 2))
def f2():
val1 = tfm.divide(
tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(k, k_1)), 2)
val2 = tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(x, k))
val = tfm.add(val1, val2)
return val
b2ks = [0] * x.shape[0]
for i in range(x.shape[0]):
b2ks[i] = tf.cond(
tfm.logical_and(tfm.greater(x[i, 0], k_1),
tfm.less(x[i, 0], k)), lambda: f1(),
lambda: f2())
# print(b2ks[i].shape)
b_2_k = K.concatenate(b2ks)
# if tfm.greater(x, k_1) and tfm.less(x, k):
# elif tfm.less(k, x):
return tfm.multiply(self.w[self.i][self.k - 1], b_2_k)
def __buildProducts(self, Labels: TF, Predictions: TF) -> TF:
return multiply(self.__NormalizedCosts, multiply(
Labels,
Predictions,
))
def f2():
val1 = tfm.divide(
tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(k, k_1)), 2)
val2 = tfm.multiply(tfm.subtract(k, k_1), tfm.subtract(x, k))
val = tfm.add(val1, val2)
return val
def tf_ssim(x, y, is_normalized=False):
"""
k1 = 0.01
k2 = 0.03
L = 1.0 if is_normalized else 255.0
c1 = np.power(k1 * L, 2)
c2 = np.power(k2 * L, 2)
c3 = c2 / 2
"""
k1 = 0.01
k2 = 0.03
L = 1.0 if is_normalized else 255.0
c1 = tf_pow(multiply(k1, L), 2.0)
c2 = tf_pow(multiply(k2, L), 2.0)
c3 = divide(c2, 2.0)
# if type(x) is np.ndarray:
# x = tf.convert_to_tensor(x, dtype=tf.float32)
# if type(y) is np.ndarray:
# y = tf.convert_to_tensor(y, dtype=tf.float32)
"""
ux = x.mean()
uy = y.mean()
"""
ux = tf_mean(x)
uy = tf_mean(y)
"""
std_x = x.std()
std_y = y.std()
"""
std_x = tf_std(x)
std_y = tf_std(y)
"""
xy = (x - ux) * (y - uy)
std_xy = xy.mean()
"""
xy = multiply(subtract(x, ux), subtract(y, uy))
std_xy = tf_mean(xy)
"""
l_xy = (2 * ux * uy + c1) / (np.power(ux, 2) + np.power(uy, 2) + c1)
"""
l_son = add(multiOperation(multiply, 2.0, ux, uy), c1)
l_mom = multiOperation(add, tf_pow(ux, 2.0), tf_pow(uy, 2.0), c1)
l_xy = divide(l_son, l_mom)
"""
c_xy = (2 * std_x * std_y + c2) / (np.power(std_x, 2) + np.power(std_y, 2) + c2)
"""
c_son = add(multiOperation(multiply, 2.0, std_x, std_y), c2)
c_mom = multiOperation(add, tf_pow(std_x, 2.0), tf_pow(std_y, 2.0), c2)
c_xy = divide(c_son, c_mom)
"""
s_xy = (std_xy + c3) / (std_x * std_y + c3)
"""
s_son = add(std_xy, c3)
s_mom = add(multiply(std_x, std_y), c3)
s_xy = divide(s_son, s_mom)
one = tf.constant(1.0)
_ssim = multiOperation(multiply, l_xy, c_xy, s_xy)
_result = tf.cond(greater(_ssim, one), lambda: one, lambda: _ssim)
return _result
def call(self, x):
x_hat = self.net(x)
if self.z2:
x_hat = tfm.multiply(x_hat, self.x_hat_mask)
x_hat = tfm.add(x_hat, self.x_hat_bias)
return x_hat
def f1():
return tfm.add(
tfm.subtract(tfm.divide(tfm.multiply(x, x), 2),
tfm.multiply(k_1, x)),
tfm.divide(tfm.multiply(k_1, k_1), 2))
