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, 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 loss_funcxpos2(y_reco, y_true, re=False): from tensorflow.math import sin, cos, acos, abs, reduce_mean, subtract, square # Energy loss loss_energy = reduce_mean(abs(subtract(y_reco[:,0], y_true[:,0]))) #this works well but could maybe be improved zeni = [cos(y_true[:,1]) - y_reco[:,1] , sin(y_true[:,1]) - y_reco[:,2]] azi = [cos(y_true[:,2]) - y_reco[:,3] , sin(y_true[:,2]) - y_reco[:,4]] loss_angle = reduce_mean(square(azi[0]))+reduce_mean(square(azi[1]))+reduce_mean(square(zeni[0]))+reduce_mean(square(zeni[1])) if not re: return loss_energy+loss_angle else: return float(loss_energy+loss_angle), [float(loss_energy), float(loss_angle)]
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 __call__(self, y_true, y_pred): from numpy import square, mean, reshape, concatenate, expand_dims assert (y_true.shape[-1] == 3 * 2) assert (y_pred.shape[-1] == 3 * 2) y_true = reshape(y_true, [-1, 3]) y_pred = reshape(y_pred, [-1, 3]) if self._use_pxyz: y_true = self._convert_to_pxyz(y_true) y_pred = self._convert_to_pxyz(y_pred) return mean(square(y_true - y_pred)) else: d_sq = square(y_true - y_pred) d_phi = square(_delta_phi_np(y_true[:, 2], y_pred[:, 2])) d_phi = expand_dims(d_phi, axis=-1) diff = concatenate([d_sq[:, 0:2], d_phi], axis=-1) return mean(diff)
def rbf(self, v, l2): if self.options.kernel_exponential: v = tf.exp(v) l2 = tf.exp(l2) sq_dist = tf.divide(tfm.square(self.t_dist), tf.reshape(2 * l2, (-1, 1, 1))) K = tf.reshape(v, (-1, 1, 1)) * tfm.exp(-sq_dist) m = tf.zeros((self.N_p), dtype='float64') return m, K
def compute_gaussian_kl(z_log_var, z_mean): """ Compute the KL divergence between a Gaussian and a Normal distribution. Based on Locatello et al. implementation (https://github.com/google-research/disentanglement_lib) :param z_log_var: the log variance of the Gaussian :param z_mean: the mean of the Gaussian :return: the KL divergence """ kl_loss = tfm.square(z_mean) + tfm.exp(z_log_var) - z_log_var - 1 return 0.5 * tfm.reduce_sum(kl_loss, [1])
def compute_gaussian_log_pdf(z, z_mean, z_log_var): """ Compute the log probability density of a Gaussian distribution. Based on Locatello et al. implementation (https://github.com/google-research/disentanglement_lib) :param z: the sampled values :param z_mean: the mean of the Gaussian :param z_log_var: the log variance of the Gaussian :return: the log probability density """ log2pi = tfm.log(2. * tf.constant(pi)) return -0.5 * (tfm.square(z - z_mean) * tfm.exp(-z_log_var) + z_log_var + log2pi)
def __call__(self, y_true, y_pred): from tensorflow.math import square, reduce_mean from tensorflow import reshape, concat, expand_dims from tensorflow.keras import backend as K assert (K.int_shape(y_true)[-1] == 3 * 2) assert (K.int_shape(y_pred)[-1] == 3 * 2) y_true = reshape(y_true, [-1, 3]) y_pred = reshape(y_pred, [-1, 3]) if self._use_pxyz: y_true = self._convert_to_pxyz(y_true) y_pred = self._convert_to_pxyz(y_pred) return reduce_mean(square(y_true - y_pred)) else: d_sq = square(y_true - y_pred) d_phi = square(_delta_phi_tf(y_true[:, 2], y_pred[:, 2])) d_phi = expand_dims(d_phi, axis=-1) diff = concat([d_sq[:, 0:2], d_phi], axis=-1) return reduce_mean(diff)
def _genes(self, fbar, kbar, k_fbar, wbar, w_0bar, σ2_m, Δ): m_pred = self.predict_m(kbar, k_fbar, wbar, fbar, w_0bar, Δ) sq_diff = tfm.square(self.data.m_obs - tf.transpose( tf.gather(tf.transpose(m_pred), self.data.common_indices))) variance = tf.reshape(σ2_m, (-1, 1)) if self.preprocessing_variance: variance = logit( variance) + self.data.σ2_m_pre # add PUMA variance log_lik = -0.5 * tfm.log(2 * PI * variance) - 0.5 * sq_diff / variance log_lik = tf.reduce_sum(log_lik) return log_lik
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): 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 tfs(self, σ2_f, fbar): ''' Computes log-likelihood of the transcription factors. ''' # assert self.options.tf_mrna_present if not self.preprocessing_variance: variance = tf.reshape(σ2_f, (-1, 1)) else: variance = self.data.σ2_f_pre f_pred = inverse_positivity(fbar) sq_diff = tfm.square(self.data.f_obs - tf.transpose( tf.gather(tf.transpose(f_pred), self.data.common_indices))) log_lik = -0.5 * tfm.log(2 * PI * variance) - 0.5 * sq_diff / variance log_lik = tf.reduce_sum(log_lik) return log_lik
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 mappable_mse_loss(self, y_true, y_pred): """ a mappable tensorflow function that calculates the loss caused by mse (non PC errors :param y_true: true y :param y_pred: predicted y :return: mse loss of the function """ H, W, C = y_true.shape output_channels = C // self.anchor_boxes # compute the log loss log_error = self.log_error(y_true, y_pred) squared_error = math.square(y_pred - y_true) # mask out the log error and mse log_mask = tf.concat([tf.zeros((H, W, 1)), tf.ones((H, W, 2)), tf.zeros((H, W, 2)), tf.ones((H, W, output_channels - 5))], axis=-1) mse_mask = tf.concat([tf.zeros((H, W, 1)), tf.zeros((H, W, 2)), tf.ones((H, W, 2)), tf.zeros((H, W, output_channels - 5))], axis=-1) log_mask = tf.concat([log_mask for i in range(self.anchor_boxes)], axis=-1) mse_mask = tf.concat([mse_mask for i in range(self.anchor_boxes)], axis=-1) error = tf.math.multiply_no_nan(squared_error, mse_mask) + \ tf.math.multiply_no_nan(log_error, log_mask) # remove the first term of the error # reshape y y_true_first_term = tf.reshape(y_true, shape=y_true.shape + (1,)) raw_squared_error = tf.multiply(error, y_true_first_term[:, :, 0, :]) # tf.print(raw_squared_error) return self.mse_lambda * raw_squared_error
def gaussian_log_likelihood(x, mu_x, log_sig_sq_x, SMALL_CONSTANT=1e-5): ''' Element-wise Gaussian log likelihood INPUTS: x = points mu_x - means of Gaussians log_sig_sq_x - log variance of Gaussian OPTIONAL INPUTS: SMALL_CONSTANT - small constant to avoid taking the log of 0 or dividing by 0 OUTPUTS: log_lik - element-wise log likelihood ''' # -E_q(z|x) log(p(x|z)) normalising_factor = -0.5 * tfm.log( SMALL_CONSTANT + tfm.exp(log_sig_sq_x)) - 0.5 * np.log(2.0 * np.pi) square_diff_between_mu_and_x = tfm.square(mu_x - x) inside_exp = -0.5 * tfm.divide(square_diff_between_mu_and_x, SMALL_CONSTANT + tfm.exp(log_sig_sq_x)) log_lik = normalising_factor + inside_exp return log_lik
def __call__(self, x, probes): """Propagate forward in time for the length of the input. Parameters ---------- x : Input sequence(s), batched in first dimension probe_output : bool Defines whether the output is the probe vector or the entire spatial distribution of the scalar wave field in time """ # hacky way of figuring out if we're on the GPU from inside the model device = "cuda" if next(self.parameters()).is_cuda else "cpu" # First dim is batch batch_size = x.shape[0] # init hidden states y1 = tf.zeros([batch_size, self.Nx, self.Ny], dtype=tf.dtypes.float32) y2 = tf.zeros([batch_size, self.Nx, self.Ny], dtype=tf.dtypes.float32) y_all = [] for xi in x: y, y1 = self.time_step(xi, y1, y2) y_all.append(y) y = tf.stack(y_all, axis=1) total_sum = 0 y_outs = [] for probe_crd in probes: px, py = probe_crd y_out = math.reduce_sum(math.square(y[:,:,px,py])) total_sum += y_out y_outs.append(y_out) y_outs = tf.constant(y_outs) / total_sum return y_outs
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 m_sq_diff_fn(all_states): fbar, k_fbar, kbar, wbar, w_0bar, σ2_m, Δ = self.likelihood.get_parameters_from_state(all_states, self.state_indices) m_pred = self.likelihood.predict_m(kbar, k_fbar, wbar, fbar, w_0bar, Δ) sq_diff = tfm.square(self.data.m_obs - tf.transpose(tf.gather(tf.transpose(m_pred),self.data.common_indices))) return tf.reduce_sum(sq_diff, axis=0)
def f_sq_diff_fn(all_states): f_pred = inverse_positivity(all_states[self.state_indices['latents']][0]) sq_diff = tfm.square(self.data.f_obs - tf.transpose(tf.gather(tf.transpose(f_pred),self.data.common_indices))) return tf.reduce_sum(sq_diff, axis=0)
def disc_train_step( real_batch, label, noise_batch, step, eps=EPS, ): """ Discriminator training step. So far only supports the relavg_gp loss. # TODO: abstract out loss and support more types of losses. Args: real_batch: np.array (batch_size, x, y, ch) Batch of randomly sampled real images. label: (batch_size, n_classes) Batch of labels corresponding to the randomly sampled reals above. noise_batch: np.array (batch_size, latent_dim) Batch of random latents. eps: tf float Constant to keep the log function happy. """ gp_strength = tf.constant(args.gp_wt, dtype=tf.float32) with tf.GradientTape() as disc_tape: # Generate fake images to feed discriminator: fake_batch = generator([noise_batch, label], training=True) # Get discriminator logits on real images and fake images: # Could use different labels for fakes too. Doesn't make a # noticeable difference. disc_opinion_real = discriminator([real_batch, label], training=True) disc_opinion_fake = discriminator([fake_batch, label], training=True) # Get output for relativistic average losses: real_fake_rel_avg_opinion = (disc_opinion_real - tf.reduce_mean(disc_opinion_fake, axis=0)) fake_real_rel_avg_opinion = (disc_opinion_fake - tf.reduce_mean(disc_opinion_real, axis=0)) # Get loss: disc_loss = tf.reduce_mean(-tf.reduce_mean( tfm.log(tfm.sigmoid(real_fake_rel_avg_opinion) + eps), axis=0, ) - tf.reduce_mean( tfm.log(1 - tfm.sigmoid(fake_real_rel_avg_opinion) + eps), axis=0, )) # Get gradient penalty: new_real_batch = 1.0 * real_batch new_label = 1.0 * label with tf.GradientTape() as gp_tape: gp_tape.watch(new_real_batch) disc_opinion_real_new = discriminator( [new_real_batch, new_label], training=True, ) grad = gp_tape.gradient(disc_opinion_real_new, new_real_batch) grad_sqr = tfm.square(grad) grad_sqr_sum = tf.reduce_sum( grad_sqr, axis=np.arange(1, len(grad_sqr.shape)), ) gradient_penalty = (gp_strength / 2.0) * tf.reduce_mean(grad_sqr_sum) total_disc_loss = disc_loss + gradient_penalty # Get gradients and update discriminator: discriminator_gradients = disc_tape.gradient( total_disc_loss, discriminator.trainable_variables, ) doptim.apply_gradients( zip(discriminator_gradients, discriminator.trainable_variables), ) with summary_writer.as_default(): tf.summary.scalar('losses/d_loss', disc_loss, step=step) tf.summary.scalar('regularizers/GP', gradient_penalty, step=step)
def cart2pol(x, y): theta = tfm.atan2(y, x) rho = tfm.sqrt(tfm.add(tfm.square(x), tfm.square(y))) return (theta, rho)
def snake_(X, beta): return X + (1 / beta) * math.square(math.sin(beta * X))