def compile(self, generator_G_opt: optimizer_v2.OptimizerV2, generator_F_opt: optimizer_v2.OptimizerV2, discriminator_X_opt: optimizer_v2.OptimizerV2, discriminator_Y_opt: optimizer_v2.OptimizerV2, generator_loss_fn, discriminator_loss_fn) -> None: super(CycleGAN, self).compile() self.generator_G_opt = generator_G_opt self.generator_F_opt = generator_F_opt self.discriminator_X_opt = discriminator_X_opt self.discriminator_Y_opt = discriminator_Y_opt self.generator_loss_fn = generator_loss_fn self.discriminator_loss_fn = discriminator_loss_fn self.cycle_loss_fn: Loss = MeanAbsoluteError() self.identity_loss_fn: Loss = MeanAbsoluteError()
def main(): batch = 8 epoch = 20 loss = MeanAbsoluteError() learning_rate = PiecewiseConstantDecay(boundaries=[100000], values=[1e-4, 5e-5]) res_blocks = [ 15, 15, 15, 15, 15, 9, 9, 9, 9, 9, 5, 5, 5, 5, 5, 3, 3, 3, 3, 3 ] checkpoint_dir = './ckpt/edsr' # 데이터 가져오기 ds_train = VCTK(subset='train').dataset() ds_valid = VCTK(subset='valid').dataset() # 모델 빌딩 edsr_model = edsr2(scale=4, res_blocks=res_blocks, res_block_scaling=0.7) # 훈련 edsr_trainer = EDSRTrainer(model=edsr_model, loss=loss, learning_rate=learning_rate, checkpoint_dir=checkpoint_dir) edsr_trainer.train(train_dataset=ds_train, valid_dataset=ds_valid, batch=batch, epoch=epoch) edsr_model.save_weights( f'./weights/EDSR_16000_{len(res_blocks)}res_{batch}batch_{epoch}epochs_tanh_entropy_glorot_uniform.h5' )
def __init__(self, model, loss, checkpoint_dir, learning_rate=PiecewiseConstantDecay(boundaries=[200000], values=[1e-3, 5e-4])): if loss == 'MAE': loss = MeanAbsoluteError() elif loss == 'MSE': loss = MeanSquaredError() else: raise ValueError("loss specified incorrectly") super().__init__(model, loss=MeanAbsoluteError(), learning_rate=learning_rate, checkpoint_dir=checkpoint_dir)
def __init__(self, model, loss=MeanAbsoluteError(), learning_rate=PiecewiseConstantDecay(boundaries=[200000], values=[1e-4, 5e-5]), checkpoint_dir='./ckpt/edsr'): super().__init__(model, loss, learning_rate, checkpoint_dir)
def get_mean_baseline(train: pd.DataFrame, val: pd.DataFrame) -> float: """Calculates the mean MAE and MAPE baselines by taking the mean values of the training data as prediction for the validation target feature. Parameters ---------- train : pd.DataFrame Pandas DataFrame containing your training data. val : pd.DataFrame Pandas DataFrame containing your validation data. Returns ------- float MAPE value. """ y_hat = train["price"].mean() val["y_hat"] = y_hat mae = MeanAbsoluteError() mae = mae(val["price"], val["y_hat"]).numpy() # type: ignore mape = MeanAbsolutePercentageError() mape = mape(val["price"], val["y_hat"]).numpy() # type: ignore print(mae) print("mean baseline MAPE: ", mape) return mape
def __init__(self, dim_input=(50,200,1), channel=1, num_inner_updates=1, inner_update_lr=0.4, k_shot=5, learn_inner_update_lr=False): super(MAML, self).__init__() self.dim_input = (50,200,1) # self.dim_output = dim_output self.inner_update_lr = inner_update_lr self.loss_func = MeanAbsoluteError() self.channels = channel # self.img_size = int(np.sqrt(self.dim_input/self.channels)) # outputs_ts[i] and losses_ts_post[i] are the output and loss after i+1 inner gradient updates losses_tr_pre, outputs_tr, losses_ts_post, outputs_ts = [], [], [], [] accuracies_tr_pre, accuracies_ts = [], [] # for each loop in the inner training loop outputs_ts = [[]]*num_inner_updates losses_ts_post = [[]]*num_inner_updates accuracies_ts = [[]]*num_inner_updates # Define the weights - these should NOT be directly modified by the # inner training loop tf.random.set_seed(seed) self.Unet = MuskensNet(channel, NUM_DOWNCOV_BLOCKS) # TO DO: update when learning the the learning rate self.learn_inner_update_lr = learn_inner_update_lr if self.learn_inner_update_lr: self.inner_update_lr_dict = {} for key in self.Unet.layer_weights.keys(): if(isinstance(self.Unet.layer_weights[key],list)): self.inner_update_lr_dict[key] = [[tf.Variable(self.inner_update_lr, name='inner_update_lr_%s_%d_%d' % (key, number, j)) for number in range(len(self.Unet.layer_weights[key]))] for j in range(num_inner_updates)] else: self.inner_update_lr_dict[key] = [tf.Variable(self.inner_update_lr, name='inner_update_lr_%s_%d' % (key, j)) for j in range(num_inner_updates)]
def run_model( model_name: str, model_function: Model, lr: float, train_generator: Iterator, validation_generator: Iterator, test_generator: Iterator, ) -> History: """This function runs a keras model with the Ranger optimizer and multiple callbacks. The model is evaluated within training through the validation generator and afterwards one final time on the test generator. Parameters ---------- model_name : str The name of the model as a string. model_function : Model Keras model function like small_cnn() or adapt_efficient_net(). lr : float Learning rate. train_generator : Iterator keras ImageDataGenerators for the training data. validation_generator : Iterator keras ImageDataGenerators for the validation data. test_generator : Iterator keras ImageDataGenerators for the test data. Returns ------- History The history of the keras model as a History object. To access it as a Dict, use history.history. For an example see plot_results(). """ callbacks = get_callbacks(model_name) model = model_function model.summary() plot_model(model, to_file=model_name + ".jpg", show_shapes=True) radam = tfa.optimizers.RectifiedAdam(learning_rate=lr) ranger = tfa.optimizers.Lookahead(radam, sync_period=6, slow_step_size=0.5) optimizer = ranger model.compile(optimizer=optimizer, loss="mean_absolute_error", metrics=[MeanAbsoluteError(), MeanAbsolutePercentageError()]) history = model.fit( train_generator, epochs=100, validation_data=validation_generator, callbacks=callbacks, workers= 6, # adjust this according to the number of CPU cores of your machine ) model.evaluate( test_generator, callbacks=callbacks, ) return history # type: ignore
def LSTM(self, input_shape=None, dropout_p=0.2, n_output=2, learning_rate=1e-3): log.log("LSTM Model Initilaizing...") if input_shape != None: self.input_shape = input_shape self.dropout_p = dropout_p self.n_output = n_output self.learning_rate = learning_rate self.model.add( LSTM(16, dropout=self.dropout_p, input_shape=self.input_shape, return_sequences=True)) self.model.add( LSTM(32, dropout=self.dropout_p, return_sequences=True)) self.model.add( LSTM(64, dropout=self.dropout_p, return_sequences=True)) self.model.add(Flatten()) self.model.add(Dense(units=32, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=16, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=8, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=self.n_output)) #print(self.model.summary()) self.model.compile( optimizer=Adam(learning_rate=self.learning_rate), loss=MeanAbsoluteError(), metrics=[MeanSquaredError()]) log.log("LSTM Model Initialized!")
def nonzero_MAE(y_true,y_pred): f = MeanAbsoluteError() where = tf.not_equal(y_pred,0) #idx = tf.boolean_mas(where) yt_mask = tf.boolean_mask(y_true,where) yp_mask = tf.boolean_mask(y_pred,where) return f(yt_mask,yp_mask) # class nonzero_MAE(Callback): # """ # metric callback inspired by # https://stackoverflow.com/questions/51728648/how-do-masked-values-affect-the-metrics-in-keras # """ # def on_train_begin(self, logs={}): # self.loss_f = MeanAbsoluteError() # self.val_res = [] # def on_epoch_end(self, epoch, logs={}): # val_predict = (np.asarray(self.model.predict(self.model.validation_data[0]))).round() # val_targ = self.model.validation_data[1] # indx = np.where(~val_targ.any(axis=2))[0] #find where all targets are zero. That are the masked once as we masked the target with 0 and the data with 666 # y_true_nomask = np.delete(val_targ, indx, axis=0) # y_pred_nomask = np.delete(val_predict, indx, axis=0) # result = self.loss_f(y_true_nomask, y_pred_nomask) # self.val_res.append(result) # print (f'— non-zero MAE: {result}') # return
def __init__(self, model, ckpt_path, args): super().__init__(model=model, loss=MeanAbsoluteError(), learning_rate=ExponentialDecay(args.lr_init, args.lr_decay_step, args.lr_decay_ratio, staircase=True), checkpoint_path=ckpt_path, args=args)
def __init__(self, model, checkpoint_dir, learning_rate=PiecewiseConstantDecay(boundaries=[200000], values=[1e-3, 5e-4])): super().__init__(model, loss=MeanAbsoluteError(), learning_rate=learning_rate, checkpoint_dir=checkpoint_dir)
def fitness_func(solution, sol_idx): global data_inputs, data_outputs, kerasGA, model predictions = predict(model=model, solution=solution, data=data_inputs) mae = MeanAbsoluteError() abs_error = mae(y_true=data_outputs, y_pred=predictions).numpy() + 0.00000001 solution_fitness = 1.0 / abs_error return solution_fitness
def fitness_func(solution, sol_idx): global data_inputs, data_outputs, keras_ga, model predictions = pygad.kerasga.predict(model=model, solution=solution, data=data_inputs) mae = MeanAbsoluteError() solution_fitness = (mae(data_outputs, predictions)) return solution_fitness
def __init__(self, model, learning_rate, checkpoint_dir='./ckpt/'): self.now = None self.loss = MeanAbsoluteError() self.checkpoint = tf.train.Checkpoint(step=tf.Variable(0), psnr=tf.Variable(-1.0), optimizer=Adam(learning_rate), model=model) self.checkpoint_manager = tf.train.CheckpointManager( checkpoint=self.checkpoint, directory=checkpoint_dir, max_to_keep=3) self.restore()
def run( change_idx: int, study_data: np.ndarray, control_data: np.ndarray, ts: np.ndarray = None ) -> Tuple[Union[float, np.ndarray], float, np.ndarray]: """ Recommendation: >>> len(study_data) == len(control_data) >>> True """ assert len(study_data) == len( control_data ), f"expected study_data and control_data to have the same length, but got {len(study_data)} and {len(control_data)}" # split data study_before, study_after, control_before, control_after, litmus_window_size = Litmus.split_data( change_idx, study_data, control_data) # data train_data = tf.data.Dataset.from_tensor_slices( ([control_before], [study_before])).batch(litmus_window_size) control_before_data = tf.data.Dataset.from_tensor_slices( [control_before]).batch(litmus_window_size) control_after_data = tf.data.Dataset.from_tensor_slices( [control_after]).batch(litmus_window_size) # train and test litmus = Litmus(out_dim=litmus_window_size) sgd = SGD(1e-3, momentum=0.2) loss = MeanAbsoluteError() litmus.compile(sgd, loss) litmus.fit(train_data, epochs=2000) pred_control_before = litmus.predict(control_before_data)[ 0] # first batch pred_control_after = litmus.predict(control_after_data)[ 0] # first batch diff_before = Litmus.compute_diff(pred_control_before, study_before) diff_after = Litmus.compute_diff(pred_control_after, study_after) _, u_yx, vx = Litmus.compute_mean_placements(diff_after, diff_before) _, u_xy, vy = Litmus.compute_mean_placements(diff_before, diff_after) critical_score = Litmus.critical_value(u_yx, u_xy, vx, vy, litmus_window_size) return critical_score, Litmus.THRESHOLD, np.concatenate( [pred_control_before, pred_control_after], axis=0)
def __init__(self, generator, discriminator, cycle_loss_weight, identity_loss_weight, gradient_penalty_weight, learning_rate=PiecewiseConstantDecay(boundaries=[100], values=[2e-4, 2e-5]), beta_1=0.5): self.A2B_G = generator self.B2A_G = generator self.A_D = discriminator self.B_D = discriminator self.generator_optimizer = Adam(learning_rate=learning_rate, beta_1=beta_1) self.discriminator_optimizer = Adam(learning_rate=learning_rate, beta_1=beta_1) self.cycle_loss_weight = cycle_loss_weight self.identity_loss_weight = identity_loss_weight self.gradient_penalty_weight = gradient_penalty_weight self.mean_squared_error = MeanSquaredError() self.mean_absolute_error = MeanAbsoluteError()
def __get_loss(loss, num_of_classes): if loss == 'cross_entropy': # default value. return CategoricalCrossentropy( ) # if num_of_classes != 2 else BinaryCrossentropy() elif loss == 'binary_cross_entropy"': return BinaryCrossentropy() elif loss == 'cosine_similarity': return CosineSimilarity() elif loss == 'mean_absolute_error': return MeanAbsoluteError() elif loss == 'mean_squared_error': return MeanSquaredError() elif loss == 'huber': return Huber() else: raise ValueError('loss type does not exist.')
def create_model(num_rows_df: int, num_output_fields: int, window_size: int = 10, look_ahead_size: int = 5, num_neurons: int = 40, weight_decay_kernel: float = 1e-4, weight_decay_recurrent: float = 1e-3, kernel_dropout: float = 0.1, recurrent_dropout: float = 0.3, second_lstm_layer: bool = False, learning_rate: float = 0.01, loss: str = 'mse'): input_layer = Input(shape=(window_size, num_rows_df)) norm = keras.layers.LayerNormalization()(input_layer) encoder = LSTM( num_neurons, recurrent_regularizer=regularizers.l2(weight_decay_recurrent), kernel_regularizer=regularizers.l2(weight_decay_kernel), recurrent_dropout=recurrent_dropout, dropout=kernel_dropout, return_sequences=second_lstm_layer)(norm) if second_lstm_layer: encoder = LSTM( num_neurons // 2, recurrent_regularizer=regularizers.l2(weight_decay_recurrent), kernel_regularizer=regularizers.l2(weight_decay_kernel), recurrent_dropout=recurrent_dropout, dropout=kernel_dropout)(encoder) repeat = RepeatVector(look_ahead_size)(encoder) decoder = LSTM(num_neurons, return_sequences=True)(repeat) pred = TimeDistributed(Dense(num_output_fields, activation='relu'))(decoder) model = Model(inputs=input_layer, outputs=pred) model.compile( optimizer=Adam(learning_rate=learning_rate), loss=loss, metrics=[ MeanAbsoluteError(reduction=tf.keras.losses.Reduction.SUM), 'accuracy' ]) model.summary() return model
def calculate_G_loss(self, discriminator_b_false, real_target, generated_b): """Calculate the G loss. Args: discriminator_b_false (tf.tensor): Discriminator prediction for generated B image. real_target (tf.tensor): Real B images. generated_b (tf.tensor): Generated B image. Returns: Tensors containing gan loss and l1 loss. """ MAE = MeanAbsoluteError() gan_loss = (self.disc_loss_function(self.create_label(True), discriminator_b_false) * self.gan_loss_coeff) l1_loss = MAE(generated_b, real_target) * self.L1_loss_coeff return gan_loss, l1_loss
def build(self, hp): model = Sequential() model.add( Dense(units=hp.Int('units', min_value=50, max_value=200, step=50, default=50), activation=hp.Choice('dense_activation', values=['relu', 'tanh', 'sigmoid'], default='relu'), input_dim=self.input_shape)) for i in range(hp.Int('num_layers', 1, 6)): model.add( Dense( units=hp.Int('units_' + str(i), min_value=5, max_value=200, step=20), activation=hp.Choice('dense_activation', values=['relu', 'tanh', 'sigmoid'], default='relu'), )) model.add( Dropout(rate=hp.Float('dropout' + str(i), min_value=0.0, max_value=0.5, default=0.25, step=0.05))) model.add( Dense(self.num_classes, activation=hp.Choice('dense_activation_final', values=['relu', 'tanh', 'sigmoid'], default='sigmoid'))) optimizer = hp.Choice('optimizer', ['adam', 'sgd']) model.compile(optimizer, loss=MeanAbsoluteError(), metrics=['mape']) return model
'adam': Adam(), 'sdg': SGD(), 'adagrad': Adagrad(), 'adamax': Adamax(), 'ftrl': Ftrl(), 'nadam': Nadam(), 'rmsprop': RMSprop() } # These are the only loss currently supported loss_dict = { 'binary_cross_entropy': BinaryCrossentropyL(), 'cross_entropy': BinaryCrossentropyL(), 'categorical_cross_entropy': CategoricalCrossentropyL(), 'mean_squared_error': MeanSquaredError(), 'mean_absolute_error': MeanAbsoluteError() } # this one has to be inside because of the arguments inside the class: num_classes=num_classes, **model_parameters models_dict = { 'Unet': { 'model_class': Unet, 'compatible_backbones': [ 'vgg16', 'vgg19', 'resnet18', 'seresnet18', 'inceptionv3', 'mobilenet', 'efficientnetb0' ] }, 'FPN': { 'model_class': FPN,
parent_selection_type='rank', fitness_func=fitness_func, # initial_population=kerasGA.population_weights, sol_per_pop=9, num_genes=9, init_range_low=0.01, init_range_high=10.00, crossover_type='single_point', mutation_type='random', mutation_num_genes=2, save_best_solutions=True, save_solutions=True, allow_duplicate_genes=True, stop_criteria='saturate_10', on_generation=callback_generation) # Run the Genetic algorithm ga_instance.run() # Plot the fitness value ga_instance.plot_fitness(title='Iteration vs. Fitness', xlabel='Generation', ylabel='Fitness', linewidth=4) # To get the details about the best solution found by PyGAD solution, solution_fitness, solution_idx = ga_instance.best_solution() print(f'Fitness value of the best solution = ' f'{solution_fitness}'.format(solution_fitness=solution_fitness)) print(f'Index of the best solution: {solution_idx}'.format(solution_idx=solution_idx)) # Make prediction based on the trained model's best solution. predictions = predict(model=model, solution=solution, data=data_inputs) print('Predictions: \n', predictions) # Measure the trained model error. mae = MeanAbsoluteError() abs_error = mae(y_true=data_outputs, y_pred=predictions).numpy() print('Absolute Error:', abs_error)
from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, InputLayer import pygad.kerasga import numpy as np from tensorflow.keras.losses import mean_squared_error, MeanAbsoluteError model = Sequential([InputLayer(input_shape=[2, ]), Dense(units=2, activation='sigmoid', use_bias=True, bias_initializer='ones'), Dense(units=1, activation='sigmoid', use_bias=True, bias_initializer='ones')]) keras_genetic_algorithm = pygad.kerasga.KerasGA(model=model, num_solutions=9) training_data = np.array([[1, 1], [1, 0], [0, 1], [0, 0]]) labels = np.array([[0], [1], [1], [0]]) history = mean_absolute_error = MeanAbsoluteError() loss = mean_absolute_error(y_true=labels, y_pred=)
def CNN(self, input_shape=None, stride=(1, 1), dilation=(1, 1), kernel_n=3, pooling_size=(2, 2), dropout_p=0.2, n_output=2, learning_rate=1e-3): log.log("CNN Model Initilaizing...") if input_shape != None: self.kernel_n = kernel_n self.input_shape = input_shape self.stride = stride # skips, kernel makes at every convolution self.dilation = dilation # kernel coverage self.pooling_size = pooling_size self.dropout_p = dropout_p self.n_output = n_output self.learning_rate = learning_rate self.model.add( Conv2D(filters=16, kernel_size=self.kernel_n, activation='relu', padding='same', input_shape=self.input_shape, strides=self.stride, dilation_rate=self.dilation)) #self.model.add(MaxPool2D(pool_size=self.pooling_size)) self.model.add( Conv2D(filters=32, kernel_size=self.kernel_n, activation='relu', padding='same', strides=self.stride, dilation_rate=self.dilation)) #self.model.add(MaxPool2D(pool_size=self.pooling_size)) self.model.add( Conv2D(filters=64, kernel_size=self.kernel_n, activation='relu', padding='same', strides=self.stride, dilation_rate=self.dilation)) #self.model.add(MaxPool2D(pool_size=self.pooling_size)) self.model.add( Conv2D(filters=128, kernel_size=self.kernel_n, activation='relu', padding='same', strides=self.stride, dilation_rate=self.dilation)) #self.model.add(MaxPool2D(pool_size=self.pooling_size)) self.model.add(Flatten()) self.model.add( Dense(units=self.input_shape[0] * 128, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=128, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=64, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=32, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=16, activation='relu')) self.model.add(Dropout(self.dropout_p)) self.model.add(Dense(units=self.n_output)) self.model.compile( optimizer=Adam(learning_rate=self.learning_rate), loss=MeanAbsoluteError(), metrics=[MeanSquaredError()]) log.log("CNN Model Initialized!")
def decoding_L1_loss(y_true, y_pred): return MeanAbsoluteError()(y_true, y_pred)
econv3, epool3 = encoder_block(epool2, 128) econv4, epool4 = encoder_block(epool3, 256) econv5, epool5 = encoder_block(epool4, 512) econv6 = Conv2D(512, 3, padding='same', kernel_initializer='he_normal')(epool5) econv6 = LeakyReLU(0.1)(econv6) decoder_input = econv6 net = decoder_block(decoder_input, econv5, 512) net = decoder_block(net, econv4, 256) net = decoder_block(net, econv3, 128) net = decoder_block(net, econv2, 64) net = decoder_block(net, econv1, 32) net = Conv2D(output_channel, 3, padding='same', kernel_initializer='he_normal')(net) model = Model(inputs=inputs, outputs=net) return model, econv6 if __name__ == "__main__": model, _ = unet() model.compile(optimizer=Adam(lr=1e-4), loss=MeanAbsoluteError(), metrics=['accuracy']) print(model.summary())
def my_loss(y_batch, pred_batch, eff_batch): mae = MeanAbsoluteError() loss = 0 for i in range(y_batch.shape[0]): loss += 0.6 / (1.0 - eff_batch[i])**1 * mae(y_batch[i], pred_batch[i]) return loss
optimizer = Adam(lr=LEARNING_RATE, epsilon=1e-7, amsgrad=True) #use the sinusoidal annealing lr scheduler scheduler = LearningRateScheduler(lr_max=LEARNING_RATE, div_factor=LR_DIV_FACTOR, pct_start=PCT_START) def my_loss(y_batch, pred_batch, eff_batch): mae = MeanAbsoluteError() loss = 0 for i in range(y_batch.shape[0]): loss += 0.6 / (1.0 - eff_batch[i])**1 * mae(y_batch[i], pred_batch[i]) return loss loss_fn = MeanAbsoluteError() #compile the model with MAE loss model.compile(optimizer, loss_fn) print("model compiled") # data loading # load training data, ground truth Hy and efficiency import gc input_imgs_120k = np.load(data_folder + '\\' + 'grating_pattern_UNet_reshaped_sub.npy', mmap_mode='r') input_imgs_120k = np.swapaxes(input_imgs_120k, 1, 2) Hy_forward_120k = np.load(data_folder + '\\' + 'Hy_out_forward_RI.npy', mmap_mode='r') Hy_forward_120k = np.swapaxes(Hy_forward_120k, 1, 2) efficiency_120k = np.load(data_folder + '\\' + 'efficiency_reverse.npy',
def compute_l1_loss(fake_outputs, ground_truth): return MeanAbsoluteError(reduction=keras.losses.Reduction.NONE)( ground_truth, fake_outputs)
def construct_and_compile_model(model_type, model_name, task, checkpoint_file, checkpoints_dir, model_params={}): """Construct and compile a model of a specific type Args: model_type (str): The type of model to be constructed model_name (str): The name of model to be constructed task (str): Either 'regression' or 'classification' checkpoint_file (str): Name of a checkpoint file checkpoints_dir (str): Path to the checkpoints directory model_params (dict): Possible hyper-parameters for the model to be constructed Returns: model (tf.keras.Model): Constructed and compiled model """ n_cells = model_params['n_cells'] input_dimension = model_params['input_dimension'] output_dimension = model_params['output_dimension'] dropout = model_params['dropout'] global_dropout = model_params['global_dropout'] hid_dimension = model_params['hidden_dimension'] multiplier = model_params['multiplier'] if task == 'classification': loss_fn = SparseCategoricalCrossentropy() metrics = ['accuracy'] elif task == 'regression': loss_fn = MeanAbsoluteError() metrics = ['mse'] output_dimension = 1 else: raise ValueError('Argument "task" must be one of "classification" ' \ 'or "regression"') if model_type == 'lstm' or model_type == 'gru': model = construct_rnn(input_dimension, output_dimension, model_type, n_cells, dropout, hid_dimension, model_name) elif model_type == 'lstm_cw' or model_type == 'gru_cw': model = construct_channel_wise_rnn(input_dimension, output_dimension, model_type, dropout, global_dropout, hid_dimension, multiplier, model_name) elif model_type == 'fcn': model = construct_fcn(input_dimension, output_dimension, dropout, model_name) elif model_type == 'lstm_fcn': model = construct_lstm_fcn(input_dimension, output_dimension, dropout, hid_dimension, model_name) else: raise ValueError(f'Model type {model_type} is not supported.') if checkpoint_file: print(f"=> Loading weights from checkpoint: {checkpoint_file}") model.load_weights(os.path.join(checkpoints_dir, checkpoint_file)) model.compile(optimizer=Adam(), loss=loss_fn, metrics=metrics) model.summary() return model