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 loss_function_ratio_regression(y_true, y_pred): r_loss = losses.mean_squared_error(K.exp(K.clip(y_true[:, 1], -10., 10.)), K.exp(K.clip(y_pred[:, 1], -10., 10.))) inverse_r_loss = losses.mean_squared_error( K.exp(-K.clip(y_true[:, 1], -10., 10.)), K.exp(-K.clip(y_pred[:, 1], -10., 10.))) return y_true[:, 0] * r_loss + (1. - y_true[:, 0]) * inverse_r_loss
def custom_metroc_TRP(y_true, y_pred): #K.transpose( T_true = y_true[:, 0] R_true = y_true[:, 1] P_true = y_true[:, 2] T_pred = y_pred[:, 0] R_pred = y_pred[:, 1] P_pred = y_pred[:, 2] mask = K.tf.cast(K.greater(R_pred, P_pred), tf.float32) non_valid = 100 * tf.reduce_sum(mask) / tf.reduce_sum( K.tf.ones_like(P_pred)) smapeT = smape(T_true, T_pred) smapeR = smape(R_true, R_pred) smapeP = smape(P_true, P_pred) mseT = Losses.mean_squared_error(T_true, T_pred) mseP = Losses.mean_squared_error(P_true, P_pred) mseR = Losses.mean_squared_error(R_true, R_pred) mse = Losses.mean_squared_error(y_true, y_pred) result = non_valid + mseT + mseP * 10 + mseR return result
def mse_mse(y_true, y_pred): y_true_temp = (tf.concat([y_true[:, :, 1:, :], y_true[:, :, 0:1, :]], 2)) - y_true y_pred_temp = (tf.concat([y_pred[:, :, 1:, :], y_pred[:, :, 0:1, :]], 2)) - y_pred loss = losses.mean_squared_error(y_true, y_pred) + losses.mean_squared_error(y_true_temp, y_pred_temp) 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 loss_function_ratio_regression(y_true, y_pred): """ ROLR loss function. :param y_true: ndarray with shape (n_samples, 2 + n_parameters) where the first column are the y_i (0 if from numerator, 1 if from denominator), the second column are the true log r(x, z | theta0, theta1), and the remaining columns are the true t(x, z | theta0). :param y_pred: ndarray with shape (n_samples, 2 + n_parameters) where the first column is the classifier decision function \hat{s}_i, the second column are the estimated log \hat{r}(x | theta0, theta1), and the remaining columns are the estimated \hat{t}(x | theta0). :return: Squared error on r (for the y=1 samples) plus squared error on 1/r (for the y=0 samples). """ r_loss = losses.mean_squared_error(K.exp(K.clip(y_true[:, 1], -settings.log_r_clip_value, settings.log_r_clip_value)), K.exp(K.clip(y_pred[:, 1], -settings.log_r_clip_value, settings.log_r_clip_value))) inverse_r_loss = losses.mean_squared_error(K.exp(-K.clip(y_true[:, 1], -settings.log_r_clip_value, settings.log_r_clip_value)), K.exp(-K.clip(y_pred[:, 1], -settings.log_r_clip_value, settings.log_r_clip_value))) return y_true[:, 0] * r_loss + (1. - y_true[:, 0]) * inverse_r_loss
def main(data: np.ndarray, m: int, units: int, epochs: int, spec_n: int): # 切割訓練資料、產生模型並訓練 x, y = split_data(data, m) model = make_model(units) history = model.fit(x, y, batch_size=m, epochs=epochs, verbose=0) # 預測和推測訓練資料,並得出個別的損失 y_pred = model.predict(x) y_pred_loss = K.eval(mean_squared_error(y.flatten(), y_pred.flatten())) y_spec = speculate(model, x[0], len(y)) y_spec_loss = K.eval(mean_squared_error(y.flatten(), y_spec.flatten())) print(f'm={m} units={units} epochs={epochs} - loss: ' f'pred={y_pred_loss:.4f} spec={y_spec_loss:.4f}') # 如果使用推測訓練資料產生出來的結果與正確答案差太多,則直接跳過 if y_spec_loss >= 0.2: return # 儲存結果 dir_name = (f'results/{m}_{units}_{epochs}_{spec_n}' f'-{y_pred_loss:.4f}-{y_spec_loss:.4f}') os.makedirs(dir_name) spec = speculate(model, data[-m:], spec_n) save_model_and_spec(dir_name, model, spec) data_pred = np.concatenate((x[0], y_pred)) data_spec = np.concatenate((x[0], y_spec, spec)) result = (data, data_pred, data_spec, m, m + len(x), len(data)) save_history_plot(dir_name, history.history) save_results_plot(dir_name, result)
def __call__(self, y_true, y_pred): result = None if self.loss_type == LossType.mae: result = objectives.mean_absolute_error(y_true, y_pred) elif self.loss_type == LossType.mse: result = objectives.mean_squared_error(y_true, y_pred) elif self.loss_type == LossType.rmse: result = K.sqrt(objectives.mean_squared_error(y_true, y_pred)) elif self.loss_type == LossType.variance: result = K.sqrt(objectives.mean_squared_error( y_true, y_pred)) - objectives.mean_absolute_error( y_true, y_pred) elif self.loss_type == LossType.weighted_mae_mse: loss1 = objectives.mean_absolute_error(y_true, y_pred) loss2 = objectives.mean_squared_error(y_true, y_pred) result = self.loss_ratio * loss1 + (1.0 - self.loss_ratio) * loss2 elif self.loss_type == LossType.weighted_mae_rmse: loss1 = objectives.mean_absolute_error(y_true, y_pred) loss2 = K.sqrt(objectives.mean_squared_error(y_true, y_pred)) result = self.loss_ratio * loss1 + (1.0 - self.loss_ratio) * loss2 elif self.loss_type == LossType.binary_crossentropy: result = objectives.binary_crossentropy(y_true, y_pred) elif self.loss_type == LossType.weighted_tanhmse_mse: loss1 = losses.mean_squared_error( K.tanh(self.data_input_scale * y_true), K.tanh(self.data_input_scale * y_pred)) loss2 = losses.mean_squared_error(y_true, y_pred) result = self.loss_ratio * loss1 + (1.0 - self.loss_ratio) * loss2 else: assert False, ("Loss function not supported") return result
def seq2seq_recurrent_loss(y_true, y_pred): # Reconstruction loss predicted_frames_loss = K.mean(losses.mean_squared_error(y_true, y_pred)) # Embedding loss predicted_emb_loss = K.mean(losses.mean_squared_error(y_true_z, y_pred_z)) return loss_weights['predicted_frames']*predicted_frames_loss + loss_weights['predicted_emb']*predicted_emb_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 _mse(y_true, y_pred): # keras cost = losses.mean_squared_error(y_true, y_pred) if cfg.add_xyz_sum1: ux = y_pred[:, :, :, 0][:, :, :, np.newaxis] uy = y_pred[:, :, :, 1][:, :, :, np.newaxis] uz = y_pred[:, :, :, 2][:, :, :, np.newaxis] reg = losses.mean_squared_error(1, ux**2 + uy**2 + uz**2) cost += 0.5 * reg return cost
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_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_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 loss(y_true, y_pred): zeronan = 0 isMask_ol = nearby_hole(x,6) isMask_ol = K.cast(isMask_ol,dtype=K.floatx()) isMask = K.equal(x,zeronan) # mask in the region with hole (integer) isMask_square = K.cast(isMask,dtype=K.floatx()) # mask for the pixel where the hole is isMask_out = 1 - isMask_square # mask for the pixels not considering the hole loss_square = losses.mean_squared_error(y_true*isMask_square,y_pred*isMask_square) #loss_out = losses.mean_squared_error(y_true*isMask_out,y_pred*isMask_out) loss_ol = losses.mean_squared_error(y_true*isMask_ol,y_pred*isMask_ol) return loss_square*weight_hole + loss_ol*weight_ol # loss outputs sum
def mean_squared_loss(y_true, y_pred): if "activation" in y_pred.name: return mean_squared_error(y_true, y_pred) * 0 true_max = K.mean(y_true) if true_max != 0: y_true /= true_max pred_max = K.mean(y_pred) if pred_max != 0: y_pred /= pred_max loss = mean_squared_error(y_true, y_pred) return loss
def seq2seq_recurrent_loss(y_true, y_pred): # Reconstruction loss predicted_frames_loss = losses.mean_squared_error(y_true, y_pred) # Embedding loss predicted_emb_loss = losses.mean_squared_error(y_true_z, y_pred_z) print('y_true:', y_true.shape, 'y_pred:', y_pred.shape) print('y_true_z:', y_true_z.shape, 'y_pred_z:', y_pred_z.shape) print('predicted_frames_loss:', predicted_frames_loss.shape, 'predicted_emb_loss:', predicted_emb_loss.shape) return loss_weights['predicted_frames']*predicted_frames_loss #+ loss_weights['predicted_emb']*predicted_emb_loss
def pit_loss(y_true, y_pred): cost1 = mean_squared_error(y_pred[x], y_true[x]) def c1(): return tf.reduce_mean(cost1) cost2 = mean_squared_error(y_pred[x - 1], y_true[x]) def c2(): return tf.reduce_mean(cost2) result = tf.cond(tf.less(tf.reduce_mean(cost1), tf.reduce_mean(cost2)), c1, c2) return result
def ewc_loss(y_true, y_pred, prev_model_layers, curr_model_layers, outputTensor, lambda_const): fisher_reg = l2_diff(prev_model_layers, curr_model_layers, y_pred, outputTensor) reg_term = (lambda_const / 2) * fisher_reg loss = losses.mean_squared_error(y_true, y_pred) + reg_term return loss
def on_epoch_end(self, epoch, logs={}): if epoch % self.interval == 0: y_pred = self.model.predict(self.model.validation_data[0], verbose=0) score = mean_squared_error(self.model.validation_data[1], y_pred) #print("mean_squared_error - epoch: {:d} - score: {:.6f}".format(epoch + 1, score)) self.scores.append(score)
def train_step(self, data): #print(data) data = data[0] data_1 = data[1] true = data[2] with tf.GradientTape() as tape: encoder_output = encoder(data) encoder_2_output = encoder_2(data_1) reconstruction = decoder( tf.concat([encoder_output, encoder_2_output], 2)) reconstruction_loss = tf.reduce_mean( mean_squared_error(true, reconstruction)) cross_recon_loss = tf.reduce_mean(true - reconstruction) #trip_s_loss = encoder(data)-encoder(data_from_subject) - encoder(data)-encoder(data_other_subject) + alpha #trip_p_loss = encoder(data)-encoder(data_from_beattype) - encoder(data)-encoder(data_other_beattype) + alpha total_loss = reconstruction_loss + cross_recon_loss #total_loss = reconstruction_loss + trip_s_loss + trip_p_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) return { "loss": total_loss, "reconstruction_loss": reconstruction_loss, "cross_recon_loss": cross_recon_loss #"trip_s_loss": trip_s_loss, #"trip_p_loss": trip_p_loss }
def vae_loss(x, x_dec): #recon_loss + kl_loss recon_loss = losses.mean_squared_error(x, x_dec) kl_loss = - 0.5 * K.mean(1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma), axis = -1) vae_loss = recon_loss + kl_loss return vae_loss
def masked_mse(y_true,y_pred): nanval = -1e5 isMask = K.equal(y_true,nanval) isMask = 1 - K.cast(isMask,dtype=K.floatx()) y_true = y_true*isMask y_pred = y_pred*isMask return (losses.mean_squared_error(y_true,y_pred))
def primary_loss(y_true, y_pred): # 3 separate loss calculations based on if note is played or not played = y_true[:, :, :, 0] bce_note = losses.binary_crossentropy(y_true[:, :, :, 0], y_pred[:, :, :, 0]) bce_replay = losses.binary_crossentropy(y_true[:, :, :, 1], tf.multiply(played, y_pred[:, :, :, 1]) + tf.multiply(1 - played, y_true[:, :, :, 1])) mse = losses.mean_squared_error(y_true[:, :, :, 2], tf.multiply(played, y_pred[:, :, :, 2]) + tf.multiply(1 - played, y_true[:, :, :, 2])) return bce_note + bce_replay + mse
def custom_loss(g_xy, grot_xy): #Multiple patches print(g_xy.shape) print(grot_xy.shape) #return mean_squared_error(g_xy , grot_xy) return -K.mean(20 * K.log(K.max(g_xy))) + 10 * K.log( mean_squared_error(g_xy, tf.transpose(grot_xy, [1, 0, 2])))
def loss(self, y_true, y_pred): # It's the policy_loss if it has two dims. if y_pred.shape.as_list()[-2:] == list(BOARD_SHAPE): loss = categorical_crossentropy(y_true, y_pred) else: loss = mean_squared_error(y_true, y_pred) return loss
def __init__(self, tensors: MDPTensors, scale=None, **kwargs): super().__init__(tensors, name='reward_prediction', scale=scale) if self.loss is None: state_rep = tf.keras.Input( shape=self.tensors.state_representation.shape[1:], name='state_representation_input') act_in = tf.keras.Input(shape=self.tensors.action.shape[1:], name='action_input') rewards = tf.keras.Input(shape=self.tensors.reward.shape[1:], name='rewards_input') if kwargs['discrete_actions']: act = layers.Lambda(lambda x: tf.cast(x, tf.int32))(act_in) act = layers.Lambda(lambda x: tf.one_hot( x, depth=kwargs['n_actions'], dtype=tf.float32))(act) else: act = act_in merged = layers.concatenate([state_rep, act]) merged, = self.optional_gradient_stop(merged) x = layers.Dense(32, activation='elu')(merged) pred = layers.Dense(1, activation=None)(x) mse = layers.Lambda(lambda x: mean_squared_error(x[0], x[1]))( (rewards, pred)) mse = layers.Lambda(lambda x: backend.mean(x))(mse) scaled_mse = layers.Lambda(lambda x: x * self.scale)(mse) self.model = Model(inputs=[state_rep, act_in, rewards], outputs=[scaled_mse]) self.loss = self.model([ self.tensors.state_representation, self.tensors.action, self.tensors.reward ])
def primary_loss(y_true, y_pred): # 3 separate loss calculations based on if note is played or not played = y_true[:, :, :, 0] bce_note = losses.binary_crossentropy(y_true[:, :, :, 0], y_pred[:, :, :, 0]) bce_replay = losses.binary_crossentropy(y_true[:, :, :, 1], tf.multiply(played, y_pred[:, :, :, 1]) + tf.multiply(1 - played, y_true[:, :, :, 1])) mse = losses.mean_squared_error(y_true[:, :, :, 2], tf.multiply(played, y_pred[:, :, :, 2]) + tf.multiply(1 - played, y_true[:, :, :, 2])) return bce_note + bce_replay + mse
def train_step(self, data): data = data[0] data_1 = data[1] true = data[2] data_p = data[3] data_s = data[4] data_r = data[5] with tf.GradientTape() as tape: encoder_output = encoder(data) encoder_2_output = encoder_2(data_1) reconstruction = decoder( tf.concat([encoder_output, encoder_2_output], 2)) cross_recon_loss = tf.reduce_mean( mean_squared_error(true, reconstruction)) alpha = 0.2 trip_p_loss = tf.reduce_mean( abs(encoder(data) - encoder(data_p)) - abs(encoder(data) - encoder(data_r)) + alpha) trip_s_loss = tf.reduce_mean( abs(encoder_2(data_1) - encoder_2(data_s)) - abs(encoder_2(data_1) - encoder_2(data_r)) + alpha) total_loss = cross_recon_loss + trip_s_loss + trip_p_loss grads = tape.gradient(total_loss, self.trainable_weights) self.optimizer.apply_gradients(zip(grads, self.trainable_weights)) return { "loss": total_loss, "cross_recon_loss": cross_recon_loss, "trip_s_loss": trip_s_loss, "trip_p_loss": trip_p_loss }
def compute_benchmark(): data, validation_data = get_data() mean = np.mean([y for x, y in data]) benchmark_loss = K.eval( K.mean(mean_squared_error([y for x, y in data], mean * len(data)))) print("Guesing Mean MSE:") print(benchmark_loss) # 13051.012331730903
def get_loss(y_pred, y_true): # y_true = tf.cast(y_true, 'int32') loss = mean_squared_error(y_pred, y_true) mask = src_mask loss = tf.reduce_sum(loss * mask, -1) / tf.reduce_sum(mask, -1) loss = K.mean(loss) return loss
def objective_function_for_value(y_true, y_pred): return mean_squared_error(y_true, y_pred)
def l2(y_true, y_pred): """ L2 metric (MSE) """ return losses.mean_squared_error(y_true, y_pred)
def rmse(y_true, y_pred): return (1. - alpha) * K.sqrt(mean_squared_error(y_true, y_pred))
from keras.losses import mean_squared_error def my_loss(y_pred, y_true, weights): x = y_true - y_pred loss = tf.square(x) * weights return tf.reduce_sum(loss, axis=-1) def my_loss2(y_pred, y_true): x = y_true - y_pred loss = tf.square(x) return tf.reduce_sum(loss, axis=-1) y_pred = tf.Variable([[1.1, 2.3, 3.],[1.2, 2.5, 10.]]) y_true = tf.Variable([[1., 2., 4.],[2., 2., 3.]]) weights = tf.Variable([[0.8],[0.7]]) sess = tf.InteractiveSession() sess.run(tf.initialize_all_variables()) loss = mean_squared_error(y_pred, y_true) loss2 = my_loss(y_pred, y_true, weights) loss3 = my_loss2(y_pred, y_true) loss_val, loss2_val, loss3_val = sess.run([loss, loss2, loss3]) print (loss_val, loss2_val, loss3_val)