def stft_losses_dec_x(x, _): rmse_x = losses.mean_squared_error(x, x_hat_m) mae_x = losses.mean_absolute_error(x, x_hat_m) loss_x = rmse_x + mae_x rmse_neg_x = losses.mean_squared_error(x, d_hat_m) mae_neg_x = losses.mean_absolute_error(x, d_hat_m) loss_neg_x = rmse_neg_x + mae_neg_x total_loss = loss_x# - 0.01*loss_neg_x return total_loss
def stft_losses_NMF_x(x, _): rmse_x = losses.mean_squared_error(x, x_NMF) mae_x = losses.mean_absolute_error(x, x_NMF) loss_x = mae_x + rmse_x rmse_neg_x = losses.mean_squared_error(x, d_NMF) mae_neg_x = losses.mean_absolute_error(x, d_NMF) loss_neg_x = mae_neg_x + rmse_neg_x total_loss = K.abs(loss_x - 0.01*loss_neg_x) return total_loss
def stft_losses_NMF_d(d, _): rmse_d = losses.mean_squared_error(d, d_NMF) mae_d = losses.mean_absolute_error(d, d_NMF) loss_d = mae_d + rmse_d rmse_neg_d = losses.mean_squared_error(d, x_NMF) mae_neg_d = losses.mean_absolute_error(d, x_NMF) loss_neg_d = mae_neg_d + rmse_neg_d total_loss = K.abs(loss_d - 0.01*loss_neg_d) return total_loss
def stft_losses_dec_d(d, _): rmse_d = losses.mean_squared_error(d, d_hat_m) mae_d = losses.mean_absolute_error(d, d_hat_m) loss_d = rmse_d + mae_d rmse_neg_d = losses.mean_squared_error(d, x_hat_m) mae_neg_d = losses.mean_absolute_error(d, x_hat_m) loss_neg_d = rmse_neg_d + mae_neg_d total_loss = loss_d# - 0.01*loss_neg_d return total_loss
def L1_loss(y_true, y_pred): y_fg_true = y_true[:, :, :, :3] y_bg_true = y_true[:, :, :, 3:] y_fg_pred = y_pred[:, :, :, :3] y_bg_pred = y_pred[:, :, :, 3:] l1_fg_loss = losses.mean_absolute_error(y_fg_true, y_fg_pred) l1_bg_loss = losses.mean_absolute_error(y_bg_true, y_bg_pred) total_loss = 0.8 * l1_fg_loss + 0.2 * l1_bg_loss return total_loss
def iou_with_mse(y_true, y_pred): # split the bounding boxes into individual tensors xmin_true, xmax_true, ymin_true, ymax_true, zmin_true, zmax_true = tf.split( y_true, 6, axis=1) xmin_pred, xmax_pred, ymin_pred, ymax_pred, zmin_pred, zmax_pred = tf.split( y_pred, 6, axis=1) dx = K.minimum(xmax_true, xmax_pred) - K.maximum(xmin_true, xmin_pred) dy = K.minimum(ymax_true, ymax_pred) - K.maximum(ymin_true, ymin_pred) dz = K.minimum(zmax_true, zmax_pred) - K.maximum(zmin_true, zmin_pred) intersection = dx * dy * dz intersection = K.relu(intersection) # find the total volume and then find the union vol_true = tf.abs((xmax_true - xmin_true) * (ymax_true - ymin_true) * (ymax_true - ymin_true)) vol_pred = tf.abs((xmax_pred - xmin_pred) * (ymax_pred - ymin_pred) * (ymax_pred - ymin_pred)) # find the union now union = vol_true + vol_pred - intersection iou = intersection / union return (-1000 * iou) + mean_absolute_error(y_true, y_pred)
def test_loss(y_true, y_pred): return sd_weights[0] * dice_coef_loss( y_true, y_pred) + sd_weights[0] * seg_crossentropy_weighted( y_true, y_pred) + sd_weights[3] * mean_absolute_error( y_true, y_pred) + sd_weights[0] * vol_diff( y_true, y_pred) + sd_weights[4] * recall_loss( y_true, y_pred)
def mae(self, hr, sr): margin = (tf.shape(hr)[1] - tf.shape(sr)[1]) // 2 hr_crop = tf.cond(tf.equal(margin, 0), lambda: hr, lambda: hr[:, margin:-margin, margin:-margin, :]) hr = K.in_train_phase(hr_crop, hr) hr.uses_learning_phase = True return mean_absolute_error(hr, sr)
def perceptual_loss(y_true_256, y_pred_256): mse_loss = K.mean(mean_squared_error(y_true_256, y_pred_256)) mae_loss = K.mean(mean_absolute_error(y_true_256, y_pred_256)) img_nrows, img_ncols = 256, 256 y_pred = y_pred_256 #tf.image.central_crop(y_pred_256, 0.875) y_true = y_true_256 #tf.image.central_crop(y_true_256, 0.875) e = VGG_16() layers = [l for l in e.layers] eval_pred = y_pred for i in range(len(layers)): eval_pred = layers[i](eval_pred) eval_true = y_true for i in range(len(layers)): eval_true = layers[i](eval_true) perceptual_loss = K.mean(mean_squared_error(eval_true, eval_pred)) #Total variation loss https://github.com/keras-team/keras/blob/master/examples/neural_style_transfer.py a = K.square(y_pred[:, :img_nrows - 1, :img_ncols - 1, :] - y_pred[:, 1:, :img_ncols - 1, :]) b = K.square(y_pred[:, :img_nrows - 1, :img_ncols - 1, :] - y_pred[:, :img_nrows - 1, 1:, :]) tv_loss = K.sum(K.pow(a + b, 1.25)) loss = perceptual_loss + tf.scalar_mul( 0.1, mse_loss) #+ tf.scalar_mul(0.1, tv_loss) #perceptual_psnr = - tf.image.psnr(eval_true, eval_pred, K.max(eval_true)) return loss
def custom_loss_2(y_true, y_pred): # scaled cosine_distance with MSE + MAE cosine = losses.cosine_proximity(y_true, y_pred) mse = losses.mean_squared_error(y_true, y_pred) mle = losses.mean_absolute_error(y_true, y_pred) l = (1 + cosine) * mse + mle return l
def syn_loss(self, inputs): img_tgt, img_syn = inputs img_tgt_cropped = K.slice(img_tgt, (0, 40, 40, 0), (-1, 400, 560, -1)) img_syn_cropped = K.slice(img_syn, (0, 40, 40, 0), (-1, 400, 560, -1)) loss = K.mean(mean_absolute_error(img_tgt_cropped, img_syn_cropped)) return loss
def __call__(self, y_true, y_pred): # 目的音とモデリング音 (バッチ数, timesteps) self.batch_size = tf.shape(y_true)[0] # バッチサイズを取得 _, self.timesteps, _ = y_pred.shape # タイムステップを取得 y_true_ = K.reshape (y_true, (self.batch_size, self.timesteps) ) y_pred_ = K.reshape (y_pred, (self.batch_size, self.timesteps) ) # 波形の損失関数 if self.wave_loss == "None": wave = K.variable(0) elif self.wave_loss == "MAE": wave = mean_absolute_error(y_true_, y_pred_) elif self.wave_loss == "MSE": wave = mean_squared_error(y_true_, y_pred_) elif self.wave_loss == "MSE_PE": y_true_ = Pre_Emphasis(y_true_, self.timesteps, self.batch_size, p) y_pred_ = Pre_Emphasis(y_pred_, self.timesteps, self.batch_size, p) wave = mean_squared_error(y_true_, y_pred_) elif self.wave_loss == "ESR": wave = esr0(y_true_, y_pred_) elif self.wave_loss == "ESR_PE": y_true_ = Pre_Emphasis(y_true_, self.timesteps, self.batch_size, p) y_pred_ = Pre_Emphasis(y_pred_, self.timesteps, self.batch_size, p) wave = esr0(y_true_, y_pred_) else: raise ValueError("wave_loss value Error") wave = K.mean(wave) return wave
def recon_loss_combi(y_true, y_pred): mask_value = 0 mask = K.cast(K.not_equal(y_true, mask_value), K.floatx()) return lamb * mse(y_true * mask, y_pred * mask) + ( 1 - lamb) * mean_absolute_error(y_true * mask, y_pred * mask)
def acc_loss(y_true, y_pred): if mean is not None: a = (K.mean( (y_pred - mean_tensor) * (y_true - mean_tensor)) / K.sqrt( K.mean(K.square((y_pred - mean_tensor))) * K.mean(K.square((y_true - mean_tensor))))) else: a = (K.mean(y_pred * y_true) / K.sqrt(K.mean(K.square(y_pred)) * K.mean(K.square(y_true)))) if regularize_mean is not None: if regularize_mean == 'global': m = K.abs((K.mean(y_true) - K.mean(y_pred)) / K.mean(y_true)) elif regularize_mean == 'spatial': m = K.mean( K.abs((K.mean(y_true, axis=[-2, -1]) - K.mean(y_pred, axis=[-2, -1])) / K.mean(y_true, axis=[-2, -1]))) elif regularize_mean == 'mse': m = mean_squared_error(y_true, y_pred) elif regularize_mean == 'mae': m = mean_absolute_error(y_true, y_pred) if reverse: if regularize_mean is not None: return m - a else: return -a else: if regularize_mean: return a - m else: return a
def customized_loss(self, y_true, y_pred, alpha=0.0001, beta=3): """ linear combination of MSE and KL divergence. """ loss1 = losses.mean_absolute_error(y_true, y_pred) loss2 = losses.kullback_leibler_divergence(y_true, y_pred) #(alpha/2) * return loss1 + beta * loss2
def average_precision(y_true, y_pred): loss = K.floatx(0) loss = mean_absolute_error(y_true=y_true, y_pred=y_pred) print('size of y_true: ', K.int_shape(y_true)) print('size of y_pred: ', K.int_shape(y_pred)) print('size of loss: ', K.int_shape(loss)) return loss
def _vae_loss(self, x, x_decoded_mean): # xent_loss = losses.binary_crossentropy(x, x_decoded_mean) / self._sigma xent_loss = losses.mean_absolute_error(x, x_decoded_mean) / self._sigma # xent_loss = objectives.binary_crossentropy(x, x_decoded_mean) # xent_loss = self._input_dim * objectives.poisson(x, x_decoded_mean) kl_loss = -0.5 * K.mean(1 + self._z_log_var - K.square(self._z_mean) - K.exp(self._z_log_var), axis=-1) return xent_loss + 1.0 * kl_loss
def __call__(self, y_true, y_pred): ae_pred = y_pred ae_grad_pred = jacobian_with_time_layer(y_pred, is_3d=self.is_3d) ae_true = y_true ae_grad_true = jacobian_with_time_layer(y_true, is_3d=self.is_3d) result = 0.0 if self.use_mse: result = losses.mean_squared_error( ae_pred, ae_true) + losses.mean_squared_error( ae_grad_pred, ae_grad_true) else: result = losses.mean_absolute_error( ae_pred, ae_true) + losses.mean_absolute_error( ae_grad_pred, ae_grad_true) return result
def __call__(self, y_true, y_pred): # 目的音とモデリング音 (バッチ数, timesteps) y_true_ = K.reshape (y_true, (self.batch_size, self.timesteps) ) y_pred_ = K.reshape (y_pred, (self.batch_size, self.timesteps) ) if set_float == "float16": y_true_ = K.cast(y_true_, tf.float32) y_pred_ = K.cast(y_pred_, tf.float32) " スペクトログラムの計算 " if ( self.freq_loss != None ) and ( spectrogram_type == "CQT" ): true_freq, _ = self.cqt.calc_cqt(y_true_) pred_freq, _ = self.cqt.calc_cqt(y_pred_) # 振幅スペクトログラム true_freq = K.abs(true_freq) pred_freq = K.abs(pred_freq) elif self.freq_loss != None and ( spectrogram_type == "STFT" ): # 目標音とモデリング音の振幅スペクトログラムの取得 true_freq = K.abs( tf.signal.stft(signals=y_true_, frame_length=frame_length, frame_step=frame_step, fft_length=N, pad_end=True) ) pred_freq = K.abs( tf.signal.stft(signals=y_pred_, frame_length=frame_length, frame_step=frame_step, fft_length=N, pad_end=True) ) # パワースペクトログラム if power == True: true_freq = K.square( true_freq) pred_freq = K.square( pred_freq ) # メル周波数スペクトログラム(MFS) if mel == True: # メルフィルタバンク linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(num_mel_bins_mel, int(N/2+1), Fs, lower_hz_mel, upper_hz_mel) # 目的音源のMFS true_freq = tf.tensordot(true_freq, linear_to_mel_weight_matrix, 1) true_freq.set_shape(true_freq.shape[:-1].concatenate(linear_to_mel_weight_matrix.shape[-1:])) # モデリング音源のMFS pred_freq = tf.tensordot(pred_freq, linear_to_mel_weight_matrix, 1) pred_freq.set_shape(pred_freq.shape[:-1].concatenate(linear_to_mel_weight_matrix.shape[-1:])) else: raise ValueError("spectrogram type value Error") # 周波数の損失関数 if self.freq_loss == "None": freq = K.variable(0) elif self.freq_loss == "MAE": freq = mean_absolute_error(true_freq, pred_freq) elif self.freq_loss == "MSE": freq = mean_squared_error(true_freq, pred_freq) elif self.freq_loss == "KL": freq = I_divergence(true_freq, pred_freq) elif self.freq_loss == "IS": freq = IS_divergence(true_freq, pred_freq) else: raise ValueError("freq_loss value Error") freq = K.mean(freq) if set_float == "float16": freq = K.cast( freq, dtype=tf.float16) return freq
def customized_loss(y_true, y_pred, alpha=0.0001, beta=3): """ Create a customized loss for the stacked AE. Linear combination of MSE and KL divergence. """ #customize your own loss components loss1 = losses.mean_absolute_error(y_true, y_pred) loss2 = losses.kullback_leibler_divergence(y_true, y_pred) #adjust the weight between loss components return (alpha / 2) * loss1 + beta * loss2
def nn_stats(clf, trainX, trainY, multi_input=False, name="Train"): if multi_input: train_images = trainX.return_images() train_fc = trainX.return_fc() y_pred = clf.predict([train_fc, train_images]) else: y_pred = clf.predict(trainX) train_mae = eval(mean_absolute_error(trainY, y_pred)).mean() print("{} performance average MAE: {}".format(name, round(train_mae, 2)))
def dssim_loss(y_true, y_pred): """Structural dissimilarity loss + L1 loss DSSIM is defined as (1-SSIM)/2 https://en.wikipedia.org/wiki/Structural_similarity :param tensor y_true: Labeled ground truth :param tensor y_pred: Predicted labels, potentially non-binary :return float: 0.8 * DSSIM + 0.2 * L1 """ mae = mean_absolute_error(y_true, y_pred) return 0.8 * (1.0 - metrics.ssim(y_true, y_pred) / 2.0) + 0.2 * mae
def mae_mse_combined_loss(y_true, y_pred): y_true_myo = relu(y_true - 1.0 / 3.0) + 1.0 / 3.0 y_pred_myo = relu(y_pred - 1.0 / 3.0) + 1.0 / 3.0 y_true_myi = relu(y_true - 2.0 / 3.0) + 2.0 / 3.0 y_pred_myi = relu(y_pred - 2.0 / 3.0) + 2.0 / 3.0 # myo_error = mean_squared_error(y_true_myo,y_pred_myo) # myi_error = mean_absolute_error(y_true_myi,y_pred_myi) loss_types = loss_type.split('+') if loss_types[0] == 'mse': loss1 = mean_squared_error(y_true_myo, y_pred_myo) elif loss_types[0] == 'mae': loss1 = mean_absolute_error(y_true_myo, y_pred_myo) if loss_types[1] == 'mse': loss2 = mean_squared_error(y_true_myi, y_pred_myi) elif loss_types[1] == 'mae': loss2 = mean_absolute_error(y_true_myi, y_pred_myi) return (loss1 + loss2 * infarction_weight) / restrict_chn
def getGradientsPerEpisode(model, samples, targets): gradients_per_episode = [] rewards = getRewardsWithBaselinePerEpisode(samples, targets) for i in range(samples.shape[0]): loss = losses.mean_absolute_error(targets, samples[i]) gradients = K.gradients(loss, model.trainable_weights) for g in gradients: with tf.Session() as sess: print(g, rewards[i].eval()) rewardedGradients.append(tf.multipy(g, rewards[i][0])) gradients_per_episode.append(rewardedGradients) return gradients_per_episode
def bump_mse(heatmap_true, spikes_pred): # generate the heatmap corresponding to the predicted spikes heatmap_pred = K.conv2d(spikes_pred, gfilter, strides=(1, 1), padding='same') # heatmaps MSE loss_heatmaps = losses.mean_squared_error(heatmap_true, heatmap_pred) # l1 on the predicted spikes loss_spikes = losses.mean_absolute_error(spikes_pred, tf.zeros(input_shape)) return loss_heatmaps + loss_spikes
def donut_model(input_shape, intermediate_dim, z_dim, x_dim): input = Input(input_shape, name='encoder_input') # encoder dense_z1 = Dense(intermediate_dim, activation='relu', kernel_regularizer=regularizers.l2(0.001)) dense_z2 = Dense(intermediate_dim, activation='relu', kernel_regularizer=regularizers.l2(0.001)) z_mean = Dense(z_dim, name='z_mean') z_log_var = Dense(z_dim, activation='softplus', name='z_log_var') z = Lambda(sampling, output_shape=(z_dim, ), name='z') # decoder dense_x1 = Dense(intermediate_dim, activation='relu', kernel_regularizer=regularizers.l2(0.001)) dense_x2 = Dense(intermediate_dim, activation='relu', kernel_regularizer=regularizers.l2(0.001)) zx_mean = Dense(x_dim, name='zx_mean') zx_log_var = Dense(x_dim, activation='softplus', name='zx_log_var') z_x = Lambda(sampling, output_shape=(x_dim, ), name='z_x') # build model denx1 = dense_x1(input) denx2 = dense_x2(denx1) z_mean_ = z_mean(denx2) z_log_var_ = z_log_var(denx2) z_out = z([z_mean_, z_log_var_]) denxz1 = dense_z1(z_out) denxz2 = dense_z2(denxz1) zx_mean_d = zx_mean(denxz2) zx_log_var_d = zx_log_var(denxz2) z_x_d = z_x([zx_mean_d, zx_log_var_d]) model = Model(input, z_x_d, name='vae_donut') reconstruction_loss = mean_absolute_error(input, z_x_d) reconstruction_loss *= x_dim kl_loss = 1 + z_log_var_ - K.square(z_mean_) - K.exp(z_log_var_) kl_loss = K.sum(kl_loss, axis=-1) kl_loss *= -0.5 vae_loss = K.mean(reconstruction_loss + kl_loss) model.add_loss(vae_loss) model.compile(optimizer='sgd', metrics=['loss', 'acc']) return model
def __call__(self, y_true, y_pred): ae_pred = y_pred ae_grad_pred, _ = jacobian_layer(y_pred, is_3d=self.is_3d) ae_true = y_true ae_grad_true, _ = jacobian_layer(y_true, is_3d=self.is_3d) velo_dim = 3 if self.is_3d else 2 # MAE on velo result = losses.mean_absolute_error(ae_pred[..., 0:velo_dim], ae_true[..., 0:velo_dim]) # Gradient Loss result += losses.mean_absolute_error(ae_grad_pred, ae_grad_true) if self.sqrd_diff_loss: result += self.sqrd_diff_loss_op(ae_true[..., 0:velo_dim], ae_pred[..., 0:velo_dim]) if self.density: result += losses.mean_squared_error( ae_pred[..., velo_dim:velo_dim + 1], ae_true[..., velo_dim:velo_dim + 1]) return result
def calc_MAPE_of_liu(lane, df_liu_results): ground_truth = df_liu_results.loc[:, (lane, 'ground-truth')] liu_estimations = df_liu_results.loc[:, (lane, 'estimated hybrid')] ground_truth = np.reshape(ground_truth.values, (ground_truth.values.shape[0])) liu_estimations = np.reshape(liu_estimations.values, (liu_estimations.values.shape[0])) MAPE_liu = K.eval(mean_absolute_percentage_error(ground_truth, liu_estimations)) print('MAPE liu:', MAPE_liu) MAE_liu = K.eval(mean_absolute_error(ground_truth, liu_estimations)) print('MAE liu:', MAE_liu) return MAPE_liu, MAE_liu
def vae_loss(self, x_input, x_decoded): #per sample reconstruction_loss = original_dim * losses.mean_absolute_error(x_input, x_decoded) kl_loss = - 0.5 * K.sum(1 + z_log_var_encoded - K.square(z_mean_encoded) - K.exp(z_log_var_encoded), axis=-1) # #per data point #reconstruction_loss = losses.mean_absolute_error(x_input, x_decoded) #kl_loss = - 0.5 * K.sum(1 + z_log_var_encoded - K.square(z_mean_encoded) - # K.exp(z_log_var_encoded), axis=-1) / latent_dim return K.mean(reconstruction_loss + alpha * (kl_loss))#K.mean(reconstruction_loss + (K.get_value(beta) * kl_loss))
def calc_MAPE_of_predictions(lane, df_predictions): ground_truth_queue = df_predictions.loc[:, (lane, 'ground-truth queue')] prediction_queue = df_predictions.loc[:, (lane, 'prediction queue')] ground_truth_queue = np.reshape(ground_truth_queue.values, (ground_truth_queue.values.shape[0])) prediction_queue = np.reshape(prediction_queue.values, (prediction_queue.values.shape[0])) MAPE_queue = K.eval(mean_absolute_percentage_error(ground_truth_queue, prediction_queue)) print('MAPE queue:', MAPE_queue) MAE_queue = K.eval(mean_absolute_error(ground_truth_queue, prediction_queue)) print('MAE queue:', MAE_queue) ground_truth_nVehSeen = df_predictions.loc[:, (lane, 'ground-truth nVehSeen')] prediction_nVehSeen = df_predictions.loc[:, (lane, 'prediction nVehSeen')] ground_truth_nVehSeen = np.reshape(ground_truth_nVehSeen.values, (ground_truth_nVehSeen.values.shape[0])) prediction_nVehSeen = np.reshape(prediction_nVehSeen.values, (prediction_nVehSeen.values.shape[0])) MAPE_nVehSeen = K.eval(mean_absolute_percentage_error(ground_truth_nVehSeen, prediction_nVehSeen)) print('MAPE nVehSeen:', MAPE_nVehSeen) MAE_nVehSeen = K.eval(mean_absolute_error(ground_truth_nVehSeen, prediction_nVehSeen)) print('MAE nVehSeen:', MAE_nVehSeen) return MAPE_queue, MAE_queue, MAPE_nVehSeen, MAE_nVehSeen
def l1(y_true, y_pred): """ L1 metric (MAE) """ return losses.mean_absolute_error(y_true, y_pred)