def PDF_gen_Si_func(costk, costl , phi, Fl, S3, S4, S5, AFB, S7, S8, S9):
##sint2k: square of sin(thetak); sin2tk: sin(2thetak); sintk: sin(thetak);
cost2k = costk * costk
sint2k = 1 - cost2k
sintk = sqrt(sint2k)
sin2tk = 2 * sintk * costk
cost2l = costl * costl
sint2l = 1 - cost2l
sintl = sqrt(sint2l)
sin2tl = 2 * sintl * costl
cos2tl = 2 * cost2l - 1
sinphi = sin(phi)
cosphi = cos(phi)
cos2phi = cos(2*phi)
sin2phi = sin(2*phi)
dcrate = (0.75 * (1 - Fl) * sint2k + Fl * cost2k
+ 0.25 * (1 - Fl) * sint2k * cos2tl - Fl * cost2k * cos2tl
+ S3 * sint2k * sint2l * cos2phi + S4 * sin2tk * sin2tl * cosphi
+ S5 * sin2tk * sintl * cosphi + 4/3 * AFB * sint2k * costl
+ S7 * sin2tk * sintl * sinphi + S8 * sin2tk * sin2tl * sinphi
+ S9 * sint2k * sint2l * sin2phi)
return 9 / (32 * 3.14159265) * dcrate
def inference(images, hidden1_units, hidden2_units):
# Hidden 1
with tf.name_scope('hidden1'):
weights = tf.Variable(tf.truncated_normal(
[IMAGE_PIXELS, hidden1_units],
stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
name='weights')
biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')
hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)
with tf.name_scope('hidden2'):
weights = tf.Variable(tf.truncated_normal(
[hidden1_units, hidden2_units],
stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
name='weights')
biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')
hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)
with tf.name_scope('softmax_linear'):
weights = tf.Variable(tf.truncated_normal(
[hidden2_units, NUM_CLASSES],
stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
name='weights')
biases = tf.Variable(tf.zeros([NUM_CLASSES]), name='biases')
logits = tf.matmul(hidden2, weights) + biases
return logits
def pdf_1D(z, density_name=''):
assert density_name in AVAILABLE_1D_DISTRIBUTIONS, "Incorrect density name."
if density_name == '':
return 1
elif density_name == 'two_hills':
y = 0.5
sigma2 = 0.1
likelihood = (1 / math.sqrt(2 * pi * sigma2)) * math.exp(-(
(y - (z**2))**2) / (2 * sigma2))
prior = (1 / math.sqrt(2 * pi))**math.exp(-(z**2) / 2)
return likelihood * prior
def xavier_init(fan_in, fan_out, constant=1):
low = -constant * tfm.sqrt(6.0 / (tf.cast(fan_in, dtype=tf.float32) +
tf.cast(fan_out, dtype=tf.float32)))
high = constant * tfm.sqrt(6.0 / (tf.cast(fan_in, dtype=tf.float32) +
tf.cast(fan_out, dtype=tf.float32)))
# low = -constant * np.sqrt(6.0 / (np.float32(fan_in) + np.float32(fan_out)))
# high = constant * np.sqrt(6.0 / (np.float32(fan_in) + np.float32(fan_out)))
# low = -constant * np.sqrt(6.0 / (fan_in +fan_out))
# high = constant * np.sqrt(6.0 / (fan_in +fan_out))
return tf.random.uniform((fan_in, fan_out),
minval=low,
maxval=high,
dtype=tf.float32)
def mlp(self, w, b):
w = tf.reshape(w, (-1, 1, 1))
b = tf.reshape(b, (-1, 1, 1))
denom = tfm.sqrt((w * self.t2 + b + 1) * (w * self.tprime2 + b + 1))
K = tfm.asin((w * self.tt + b) / denom)
m = tf.zeros((self.N_p), dtype='float64')
return m, K
def _k_xx(self, X, j, k):
S_square = tf.matmul(tf.reshape(self.S, (-1, 1)),
tf.reshape(self.S, (1, -1)))
S_square = broadcast_tile(S_square, 7, 7)
mult = S_square * self.lengthscale * 0.5 * tfm.sqrt(PI)
return self.kervar**2 * mult * (self.h(X, k, j) +
self.h(X, j, k, primefirst=False))
def attention(query, key, value):
score = matmul(query, key, transpose_b=True)
dim_key = cast(shape(key)[-1], float32)
scaled_score = score / math.sqrt(dim_key)
weights = softmax(scaled_score, axis=-1)
output = matmul(weights, value)
return output
def integralPi_costl(x, limits, norm_range, params, model):
costk, phi = x.unstack_x()
Fl = params['Fl']
P1 = params['P1']
P3 = params['P3']
P5p = params['P5p']
P6p = params['P6p']
K00 = assoc_legendre_tf(0, 0, costk)
K20 = assoc_legendre_tf(2, 0, costk)
K21 = assoc_legendre_tf(2, 1, costk)
K22 = assoc_legendre_tf(2, 2, costk)
return 9. / (32 * 3.14159265) * (
(4.0 / 9.0) * K00 + (4.0 * Fl / 3.0 - 4.0 / 9.0) * K20 +
(1 - Fl) / 18.0 * P1 * K22 * cos(2 * phi) * 2 +
(Fl - 1) / 9.0 * P3 * K22 * sin(2 * phi) * 2 +
(2.0 / 3.0) * sqrt(Fl - Fl * Fl) * P5p * K21 * cos(phi) * pi / 4 +
(-2.0 / 3.0) * sqrt(Fl - Fl * Fl) * P6p * K21 * sin(phi) * pi / 4) * (
2)
def root_sum_squared_error(inputs):
#if K.ndim(y_true) > 2:
# return K.mean(K.sqrt(K.sum(K.square(y_true - y_pred),
# axis=K.arange(1, K.ndim(y_true)) )))
#else:
return tf_math.sqrt(
tf_math.reduce_sum(tf_math.square(inputs[0] - inputs[1]),
axis=(1, 2, 3, 4)))
def k_xf(self, j, X, X2):
t_prime, t_, t_dist = self.get_distance_matrix(
t_x=tf.reshape(X[:self.block_size], (-1, )),
t_y=tf.reshape(X2, (-1, )))
l = self.lengthscale
erf_term = tfm.erf(t_dist / l - self.gamma(j)) + tfm.erf(t_ / l +
self.gamma(j))
return self.S[j] * l * 0.5 * tfm.sqrt(PI) * tfm.exp(
self.gamma(j)**2) * tfm.exp(-self.D[j] * t_dist) * erf_term
def angle_loss_fn_batch(y_true, y_pred):
x_p = math.sin(y_pred[:, 0]) * math.cos(y_pred[:, 1])
y_p = math.sin(y_pred[:, 0]) * math.sin(y_pred[:, 1])
z_p = math.cos(y_pred[:, 0])
x_t = math.sin(y_true[:, 0]) * math.cos(y_true[:, 1])
y_t = math.sin(y_true[:, 0]) * math.sin(y_true[:, 1])
z_t = math.cos(y_true[:, 0])
norm_p = math.sqrt(x_p * x_p + y_p * y_p + z_p * z_p)
norm_t = math.sqrt(x_t * x_t + y_t * y_t + z_t * z_t)
dot_pt = x_p * x_t + y_p * y_t + z_p * z_t
angle_value = dot_pt / (norm_p * norm_t)
angle_value = tf.clip_by_value(angle_value, -0.99999, 0.99999)
loss_val = (math.acos(angle_value))
return loss_val
def hybrid_correlation_tf(img1_fft, img2_fft):
"""Unsure if this actually the hybrid correlation Ophus refers to.
Works on images already in fourier space.
"""
m = img1_fft * conj(img2_fft)
M = sqrt(tf.abs(m))
magnitude = tf.complex(M, M * 0.0)
theta = angle(m)
euler = tf.exp(tf.complex(theta * 0.0, theta))
D = magnitude * euler
Icorr = real(ifft2(D))
return Icorr
def PDF_gen_Pi_func(costk, costl, phi, Fl, P1, P2, P3, P4p, P5p, P6p, P8p):
##sint2k: square of sin(thetak); sin2tk: sin(2thetak); sintk: sin(thetak);
cost2k = costk * costk
sint2k = 1 - cost2k
sintk = sqrt(sint2k)
sin2tk = 2 * sintk * costk
cost2l = costl * costl
sint2l = 1 - cost2l
sintl = sqrt(sint2l)
sin2tl = 2 * sintl * costl
cos2tl = 2 * cost2l - 1
sinphi = sin(phi)
cosphi = cos(phi)
cos2phi = cos(2 * phi)
sin2phi = sin(2 * phi)
Ft = 1 - Fl
dcrate = (0.75 * Ft * sint2k + Fl * cost2k + 0.25 * Ft * sint2k * cos2tl -
Fl * cost2k * cos2tl +
0.5 * P1 * Ft * sint2k * sint2l * cos2phi +
sqrt(Fl * Ft) * 0.5 * P4p * sin2tk * sin2tl * cosphi +
sqrt(Fl * Ft) * P5p * sin2tk * sintl * cosphi -
sqrt(Fl * Ft) * P6p * sin2tk * sintl * sinphi +
0.5 * sqrt(Fl * Ft) * P8p * sin2tk * sin2tl * sinphi +
2 * P2 * Ft * sint2k * costl -
P3 * Ft * sint2k * sint2l * sin2phi)
return 9 / (32 * 3.14159265) * dcrate
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):
input_shape = x.shape.as_list()
axis = tuple(
range(0 if self.batch else 1,
len(input_shape) if input_shape else 4))
if self.mean:
x = x - tfm.reduce_mean(x, axis=axis, keepdims=True)
if self.std:
std = tfm.sqrt(
tfm.reduce_mean(tfm.square(x), axis=axis, keepdims=True))
elif self.std:
std = tfm.reduce_std(x, axis=axis, keepdims=True)
return x / ((self.eps + std) if self.eps else std) if self.std else x
def kl_normal(mu_1, log_sig_sq_1, mu_2, log_sig_sq_2):
'''
Element-wise KL divergence between two normal distributions
INPUTS:
mu_1 - mean of firat distribution
log_sig_sq_1 - log variance of first diatribution
mu_2 - mean of second distribution
log_sig_sq_2 - log variance of second diatribution
OUTPUTS:
KL - element-wise KL divergence
'''
v_mean = mu_2 #2
aux_mean = mu_1 #1
v_log_sig_sq = log_sig_sq_2 #2
aux_log_sig_sq = log_sig_sq_1 #1
v_log_sig = tfm.log(tfm.sqrt(tfm.exp(v_log_sig_sq))) #2
aux_log_sig = tfm.log(tfm.sqrt(tfm.exp(aux_log_sig_sq))) #1
KL = v_log_sig - aux_log_sig + tf.divide(
tfm.exp(aux_log_sig_sq) + tfm.square(aux_mean - v_mean),
2.0 * tfm.exp(v_log_sig_sq)) - 0.5
return KL
def angle_loss_fn(self, y_true, y_pred):
x_p = math.sin(y_pred[:, 0]) * math.cos(y_pred[:, 1])
y_p = math.sin(y_pred[:, 0]) * math.sin(y_pred[:, 1])
z_p = math.cos(y_pred[:, 0])
x_t = math.sin(y_true[:, 0]) * math.cos(y_true[:, 1])
y_t = math.sin(y_true[:, 0]) * math.sin(y_true[:, 1])
z_t = math.cos(y_true[:, 0])
norm_p = math.sqrt(x_p * x_p + y_p * y_p + z_p * z_p)
norm_t = math.sqrt(x_t * x_t + y_t * y_t + z_t * z_t)
dot_pt = x_p * x_t + y_p * y_t + z_p * z_t
angle_value = dot_pt / (norm_p * norm_t)
angle_value = tf.clip_by_value(angle_value, -0.99999, 0.99999)
loss_val = (math.acos(angle_value))
# tf.debugging.check_numerics(
# loss_val, "Vse propalo", name=None
# )
# print(loss_val.shape)
return loss_val
def gradAndSq3D(x):
"""@return |dx|, dx^2"""
knl = np.zeros([2, 2, 2, 1, 1], dtype=np.float32)
knl[0, 0, 0] = -1
dz = np.array(knl)
dz[1, 0, 0] = 1
dz = tf.nn.conv3d(x, dz, [1] * 5, "SAME")
dy = np.array(knl)
dy[0, 1, 0] = 1
dy = tf.nn.conv3d(x, dy, [1] * 5, "SAME")
dx = np.array(knl)
dx[0, 0, 1] = 1
dx = tf.nn.conv3d(x, dx, [1] * 5, "SAME")
gradSq = tfm.abs(dz**2 + dy**2 + dx**2)
grad = tfm.sqrt(gradSq)
return grad, gradSq
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 rmse(y_true, y_pred):
mask = y_true[:, :, :, 1]
y_true = y_true[:, :, :, 0]
output = ((y_true - y_pred)**2) * mask
return tf_maths.sqrt(
tf_maths.reduce_sum(output) / tf_maths.reduce_sum(mask))
def cart2pol(x, y):
theta = tfm.atan2(y, x)
rho = tfm.sqrt(tfm.add(tfm.square(x), tfm.square(y)))
return (theta, rho)
def gradAndSq2D(x):
"""@return |dx|, dx^2"""
dy, dx = tf.image.image_gradients(x)
gradSq = tfm.abs(dy**2 + dx**2)[:, :-1, :-1]
grad = tfm.sqrt(gradSq)
return grad, gradSq
def k_xx(self, X, j, k, t_y=None):
'''k_xx(t, tprime)'''
mult = self.S[j] * self.S[k] * self.lengthscale * 0.5 * tfm.sqrt(PI)
return self.kervar**2 * mult * (self.h(X, k, j, t_y=t_y) + self.h(
X, j, k, t_y=t_y, primefirst=False))
def two_hills_log_pdf(z):
likelihood = tfd.Normal(loc=z**2, scale=math.sqrt(two_hills_sigma2))
prior = tfd.Normal(loc=0, scale=1)
return likelihood.log_prob(two_hills_y) + prior.log_prob(z)
def result(self):
return math.sqrt(math.divide_no_nan(self.total, self.count))
def nrmse(y_true, y_pred):
return tfm.sqrt(
tfm.reduce_mean(tfm.squared_difference(y_true, y_pred)) /
tfm.reduce_mean(y_true**2))
