def log_ggd(x, p, mu, alpha): cp = tf.cast( log(p) - ((p + 1) / p) * tf.cast(log(2.0), settings.float_type) - lgamma(1 / p), settings.float_type) res = tf.cast( cp - log(alpha) - pow(abs(x - mu), p) / (2 * pow(alpha, p)), settings.float_type) return res
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 adaptive_wing_loss(labels, output): alpha = 2.1 omega = 14 epsilon = 1 theta = 0.5 with tf.name_scope('adaptive_wing_loss'): x = output - labels theta_over_epsilon_tensor = tf.fill(tf.shape(labels), theta/epsilon) A = omega*(1/(1+pow(theta_over_epsilon_tensor, alpha-labels)))*(alpha-labels)*pow(theta_over_epsilon_tensor, alpha-labels-1)*(1/epsilon) C = theta*A-omega*log(1+pow(theta_over_epsilon_tensor, alpha-labels)) absolute_x = abs(x) losses = tf.where(greater(theta, absolute_x), omega*log(1+pow(absolute_x/epsilon, alpha-labels)), A*absolute_x-C) loss = reduce_mean(reduce_sum(losses, axis=[1, 2]), axis=0) return loss
def train_bound(t): """Trains the model to equalize values and spatial derivatives at boundaries x=5 and x=-5 to enforce periodic boundary condition Args: t : A tf.Tensor of shape (batch_size,). """ x1 = 5 * tf.ones(t.shape) x2 = -5 * tf.ones(t.shape) with tf.GradientTape(True, False) as tape: tape.watch(PINN.trainable_weights) with tf.GradientTape(True, False) as grtape1: grtape1.watch([t, x1, x2]) #Automatic differentiation of complex functions is weird in tensorflow #so we differentiate real and imaginary parts seperately h_real_1 = tfm.real(PINN(tf.stack([t, x1], -1))) h_imag_1 = tfm.imag(PINN(tf.stack([t, x1], -1))) h_real_2 = tfm.real(PINN(tf.stack([t, x2], -1))) h_imag_2 = tfm.imag(PINN(tf.stack([t, x2], -1))) #First order derivatives h_x1_real = grtape1.gradient(h_real_1, x1) h_x1_imag = grtape1.gradient(h_imag_1, x1) h_x2_real = grtape1.gradient(h_real_2, x2) h_x2_imag = grtape1.gradient(h_imag_2, x2) #h1_real and h1_imag have shape (batch_size,2) del grtape1 h1 = tf.complex(h_real_1, h_imag_1) h1_x = tf.complex(h_x1_real, h_x1_imag) h2 = tf.complex(h_real_2, h_imag_2) h2_x = tf.complex(h_x2_real, h_x2_imag) MSE = tfm.reduce_mean( tfm.pow(tfm.abs(h1 - h2), 2) + tfm.pow(tfm.abs(h1_x - h2_x), 2)) grads = tape.gradient(MSE, PINN.trainable_weights) sgd_opt.apply_gradients(zip(grads, PINN.trainable_weights)) return MSE
def sample_batch(n_samples, max_dim, max_power, dtype): """ Calculate a sum of distance samples for various dimensions and norms Generates a batch of *n_samples* of pairs of points, and uses those points to build a table of 1 to *max_dim* rows and 1 to *max_power* columns, where each entry is the sum across all samples of the distance metric with the given power for pairs of points in the given dimensional hypercube. """ # create two lists of random points and their vector difference, # where the first dimension is the sample number and the second the # coordinates for the sample zero = tf.zeros((), dtype=dtype) # used to pass in dtype to Uniform x1s = tfd.Uniform(low=zero).sample((n_samples, max_dim)) x2s = tfd.Uniform(low=zero).sample((n_samples, max_dim)) vector_difference = x2s - x1s # add a third dimension to the tensor which is the vector coordinate # raised to ascending powers (eg x, x^2, x^3...) sum_terms = tf.abs( tfm.cumprod(tf.tile( tf.reshape(vector_difference, (n_samples, max_dim, 1)), (1, 1, max_power)), axis=2)) # generate cumulative sums along the coordinate (second) dimension # and raise the sum to the 1/n power (where n is the third dimension) # to generate a new tensor where the first dimension is the samples, # the second the dimension of the hypercube, and the third the power # of the norm. norm = tfm.pow( tfm.cumsum(sum_terms, axis=1), tf.reshape(1 / tf.cast(tf.range(1, max_power + 1), dtype=dtype), (1, 1, max_power))) # return the sum of the norms return tf.reduce_sum(norm, axis=0)
def gelu_(X): return 0.5 * X * (1.0 + math.tanh(0.7978845608028654 * (X + 0.044715 * math.pow(X, 3))))
def conditional_variance(self, F): alpha = self.alpha p = self.p tmp = 4 * pow(alpha, 2) * exp(lgamma(3 / p) - lgamma(1 / p)) return tf.fill(tf.shape(F), tf.squeeze(tmp))