def test_BFL(): output = 40*(torch.randint(0,2,(1,1,32,32,32))-0.5) target = torch.zeros_like(output) target[output>0] = 1 # target = torch.randint(0,2,(1,1,32,32,32)) criterion = BinaryFocalLoss() loss = criterion(output,target) print(loss.item())
def test_train_dummy_binary_classifier(): """Train a simple model to make sure that BinaryFocalLoss works.""" # Data/model parameters n_examples = 100 n_features = 16 epochs = 3 random_state = np.random.RandomState(0) # Generate some fake data x = random_state.binomial(n=1, p=0.5, size=(n_examples, n_features)) x = 2.0 * x.astype(np.float32) - 1.0 weights = 100 * np.ones(shape=(n_features, 1)).astype(np.float32) y = (x.dot(weights) > 0).astype(np.int8) # Number of positive and negative examples n_pos = y.sum() n_neg = n_examples - n_pos for pos_weight in (None, (n_neg / n_pos)): for gamma, label_smoothing in product((0, 2), (None, 0.1)): for from_logits in (True, False): if from_logits: activation = None else: activation = 'sigmoid' # Just a linear classifier (without bias term) model = tf.keras.Sequential(layers=[ tf.keras.layers.Input(shape=n_features), tf.keras.layers.Dense(units=1, use_bias=False, activation=activation), ]) model.compile( optimizer='sgd', loss=BinaryFocalLoss(gamma=gamma, pos_weight=pos_weight, from_logits=from_logits, label_smoothing=label_smoothing), metrics=['accuracy'], ) stop_on_nan = tf.keras.callbacks.TerminateOnNaN() history = model.fit(x, y, batch_size=n_examples, epochs=epochs, callbacks=[stop_on_nan]) history = history.history # Check that we didn't stop early: if we did then we # encountered NaNs during training, and that shouldn't happen assert len(history['loss']) == epochs # Check that BinaryFocalLoss and binary_focal_loss agree (at # least when averaged) model_loss, *_ = model.evaluate(x, y) y_pred = model.predict(x) loss = binary_focal_loss(y_true=y, y_pred=y_pred, gamma=gamma, pos_weight=pos_weight, from_logits=from_logits, label_smoothing=label_smoothing) loss = tf.math.reduce_mean(loss) tf.debugging.assert_near(loss, model_loss)
def _test_reduce_to_keras_loss(self, y_true, y_pred, from_logits: bool, label_smoothing: Optional[float]): """Focal loss with gamma=0 should be the same as cross-entropy.""" y_pred = tf.dtypes.cast(y_pred, dtype=tf.dtypes.float32) keras_loss = tf.keras.losses.BinaryCrossentropy( from_logits=from_logits, label_smoothing=(0 if label_smoothing is None else label_smoothing), ) focal_loss = BinaryFocalLoss(gamma=0, from_logits=from_logits, label_smoothing=label_smoothing) self.assertAllClose(keras_loss(y_true, y_pred), focal_loss(y_true, y_pred))
def __init__(self, backbone=ResNetBackbone()): self.backbone = backbone self.input = self.backbone.input last_layer = _create_pyramid_features( backbone_layers=self.backbone.backbone_layers, feature_size=256) regression_model = default_regression_model(pyramid_feature_size=256, feature_size=256, output_size=1) output = regression_model(last_layer) self.model = keras.models.Model(inputs=self.input, outputs=output) adam = keras.optimizers.Adam(learning_rate=5e-4) self.model.compile(optimizer=adam, loss=BinaryFocalLoss(gamma=2.0), metrics=[])
def build_anchor_model(inp_shape, anchor_counts): inp = Input(shape=inp_shape) headModel = Conv2D(32, (3, 3), activation="relu", padding='same')(inp) headModel = Conv2D(32, (3, 3), activation="relu", padding='same')(headModel) headModel = MaxPooling2D((2, 2))(headModel) headModel = Conv2D(64, (3, 3), activation="relu", padding='same')(headModel) headModel = Conv2D(64, (3, 3), activation="relu", padding='same')(headModel) headModel = MaxPooling2D((2, 2))(headModel) headModel = Conv2D(128, (3, 3), activation="relu", padding='same')(headModel) headModel = Conv2D(128, (3, 3), activation="relu", padding='same')(headModel) headModel = MaxPooling2D((2, 2))(headModel) headModel = Conv2D(256, (3, 3), activation="relu", padding='same')(headModel) headModel = Conv2D(256, (3, 3), activation="relu", padding='same')(headModel) headModel = MaxPooling2D((2, 2))(headModel) headModel = Conv2D(512, (3, 3), activation="relu", padding='same')(headModel) headModel = Conv2D(512, (3, 3), activation="relu", padding='same')(headModel) headModel = MaxPooling2D((2, 2))(headModel) headModel = Flatten(name="flatten")(headModel) headModel = Dropout(0.2)(headModel) headModel = Dense(4 * 1024, activation="relu")(headModel) headModel = Dropout(0.2)(headModel) headModel = Dense(anchor_counts[0] * anchor_counts[1], activation="sigmoid")(headModel) headModel = Reshape((anchor_counts[0], anchor_counts[1]))(headModel) model = Model(inputs=inp, outputs=headModel) model.compile( # loss="binary_crossentropy", loss=BinaryFocalLoss(gamma=3), # , # "mean_absolute_error", optimizer=Adam(lr=0.001), metrics=["accuracy"], ) return model
def test_save_and_restore(): """Check whether models compiled with BinaryFocalLoss can be saved/loaded. """ n_features = 10 for gamma, pos_weight in product((0, 1, 2), (None, 0.5)): for from_logits, label_smoothing in product((True, False), (None, 0.1)): if from_logits: activation = None else: activation = 'sigmoid' # Just a linear classifier model = tf.keras.Sequential(layers=[ tf.keras.layers.Input(shape=n_features), tf.keras.layers.Dense(units=1, activation=activation), ]) model.compile( optimizer='sgd', loss=BinaryFocalLoss(gamma=gamma, pos_weight=pos_weight, from_logits=from_logits, label_smoothing=label_smoothing), metrics=['accuracy'], ) weights = model.weights # Try to save the model to the HDF5 format h5_filepath = 'model.h5' model.save(h5_filepath, save_format='h5') h5_restored_model = tf.keras.models.load_model(h5_filepath) h5_restored_weights = h5_restored_model.weights for weight, h5_restored_weight in zip(weights, h5_restored_weights): tf.debugging.assert_equal(weight, h5_restored_weight) # Delete the created HDF5 file os.unlink(h5_filepath) # Try to save the model to the SavedModel format sm_filepath = 'model' model.save(sm_filepath, save_format='tf') sm_restored_model = tf.keras.models.load_model(sm_filepath) sm_restored_weights = sm_restored_model.weights for weight, sm_restored_weight in zip(weights, sm_restored_weights): tf.debugging.assert_equal(weight, sm_restored_weight) # Delete the created SavedModel directory shutil.rmtree(sm_filepath, ignore_errors=True)
def test_get_config(self, gamma, pos_weight, from_logits, label_smoothing): """Check the get_config() method.""" loss1 = BinaryFocalLoss(gamma=gamma, pos_weight=pos_weight, from_logits=from_logits, label_smoothing=label_smoothing, name='binary_focal_loss') config1 = loss1.get_config() loss2 = BinaryFocalLoss(**config1) config2 = loss2.get_config() self.assertEqual(config1, config2)
def test_get_config(): """Check the get_config() method.""" for gamma, pos_weight in product((0, 1, 2), (None, 0.5)): for from_logits, label_smoothing in product((True, False), (None, 0.1)): loss1 = BinaryFocalLoss(gamma=gamma, pos_weight=pos_weight, from_logits=from_logits, label_smoothing=label_smoothing, name='binary_focal_loss') config1 = loss1.get_config() loss2 = BinaryFocalLoss(**config1) config2 = loss2.get_config() assert config1 == config2
def get_dummy_binary_classifier(n_features, gamma, pos_weight, label_smoothing, from_logits): activation = None if from_logits else 'sigmoid' # Just a linear classifier (without bias term) model = tf.keras.Sequential(layers=[ tf.keras.layers.Input(shape=n_features), tf.keras.layers.Dense(units=1, use_bias=False, activation=activation), ]) model.compile( optimizer='sgd', loss=BinaryFocalLoss(gamma=gamma, pos_weight=pos_weight, from_logits=from_logits, label_smoothing=label_smoothing), metrics=['accuracy'], ) return model
from parser import parser from tensorflow.keras import backend as K args = parser.parse_args() tol = args.tol save_weights = args.save_weights HEIGHT = args.HEIGHT WIDTH = args.WIDTH BATCH_SIZE = args.batch_size FRAME_STACK = args.frame_stack pre_trained = args.pre_trained optimizer = keras.optimizers.Adadelta(lr=args.lr) if not pre_trained: model = ResNet_Track(input_shape=(FRAME_STACK, HEIGHT, WIDTH)) model.compile(loss=BinaryFocalLoss(gamma=2), optimizer=optimizer, metrics=[keras.metrics.BinaryAccuracy()]) else: model = ResNet_Track(input_shape=(FRAME_STACK, HEIGHT, WIDTH)) model.load_weights(args.load_weights) model.compile(loss=BinaryFocalLoss(gamma=2), optimizer=optimizer, metrics=[keras.metrics.BinaryAccuracy()]) print('Beginning training......') match_path = args.match_folder match_list = [ os.sep.join([os.getcwd(), match_path, match]) for match in os.listdir(match_path) ]
#FOCAL LOSS AND DICE METRIC #Focal loss helps focus more on tough to segment classes. from focal_loss import BinaryFocalLoss ############################################################################### #Try various models: Unet, Attention_UNet, and Attention_ResUnet #Rename original python file from 224_225_226_models.py to models.py from models import Attention_ResUNet, UNet, Attention_UNet, dice_coef, dice_coef_loss, jacard_coef ''' UNet ''' unet_model = UNet(input_shape) unet_model.compile(optimizer=Adam(lr=1e-2), loss=BinaryFocalLoss(gamma=2), metrics=['accuracy', jacard_coef]) print(unet_model.summary()) start1 = datetime.now() unet_history = unet_model.fit(X_train, y_train, verbose=1, batch_size=batch_size, validation_data=(X_test, y_test), shuffle=False, epochs=50) stop1 = datetime.now() #Execution time of the model
train_data = tf.data.Dataset.from_tensor_slices((X_train, y_train)) train_data = train_data.shuffle(1000).batch(64) test_data = tf.data.Dataset.from_tensor_slices((X_test, y_test)) test_data = test_data.batch(64) model = ks.Sequential([ L.Flatten(), L.Dense(32, activation="relu"), L.Dense(1, activation="sigmoid") ]) model.compile( # ks.optimizers.SGD(1e-3, momentum=0.9), ks.optimizers.Adam(0.5e-3), loss=BinaryFocalLoss(3), # loss=focal_loss(), # loss='categorical_crossentropy', metrics=["accuracy", ks.metrics.Precision(), ks.metrics.Recall()], ) model.fit_generator( generator=train_data, # steps_per_epoch=steps_per_epoch, epochs=100, # validation_data=(X_test, y_test) validation_data=test_data, )
dense.add(tf.keras.layers.BatchNormalization(axis=1)) dense.add(tf.keras.layers.ReLU()) dense.add(tf.keras.layers.Dropout(rate=0.5)) dense.add(tf.keras.layers.Dense(units=128, activation='linear')) dense.add(tf.keras.layers.BatchNormalization(axis=1)) dense.add(tf.keras.layers.ReLU()) dense.add(tf.keras.layers.Dropout(rate=0.5)) encoded_left = dense(shot_1) encoded_right = dense(shot_2) combine = tf.keras.layers.concatenate([encoded_left, encoded_right], axis = 1) #flat = tf.keras.layers.Flatten()(combine) #output size (None, 1536) d1 = tf.keras.layers.Dropout(rate=0.5)(combine) d2 = tf.keras.layers.Dense(50, activation='relu')(d1) d2r = tf.keras.layers.Dropout(rate=0.5)(d2) d3 = tf.keras.layers.Dense(50, activation='relu')(d2r) d3r = tf.keras.layers.Dropout(rate=0.5)(d3) output = tf.keras.layers.Dense(1, activation = 'softmax')(d3r) model = tf.keras.Model(inputs = inputs, outputs = output) opt = tf.keras.optimizers.Adam(learning_rate = 0.01) model.compile(optimizer = opt, loss = BinaryFocalLoss(pos_weight = 9, gamma=2.5), metrics=[tf.keras.metrics.Accuracy()]) model.summary() tf.keras.utils.plot_model(model, to_file='Dense_FL128.png', dpi=100) training_log = 'crossval_fold_' + '.txt' csv_logger = tf.keras.callbacks.CSVLogger(training_log, append = True, separator=' ') metrics = model.fit(X, Y_gt, epochs=100, validation_split= 0.2, verbose=2, batch_size = 128)
#d2r = tf.keras.layers.Dropout(rate=0.3)(d2) d2d = tf.keras.layers.BatchNormalization(axis=1)(d2) d3 = tf.keras.layers.Dense(10, activation='relu', kernel_regularizer='l1', bias_regularizer='l1')(d2d) #d3r = tf.keras.layers.Dropout(rate=0.3)(d3) d3d = tf.keras.layers.BatchNormalization(axis=1)(d3) output = tf.keras.layers.Dense(2, activation='softmax')(d3d) model = tf.keras.Model(inputs=inputs, outputs=output) opt = tf.keras.optimizers.Adam(learning_rate=0.001) model.compile(optimizer=opt, loss=BinaryFocalLoss(pos_weight=9, gamma=2.5), metrics=[tf.keras.metrics.Accuracy() ]) #BinaryFocalLoss(pos_weight=7, gamma=4) model.summary() image_out = directory + '/' + 'softmax_final_1.png' print(image_out) tf.keras.utils.plot_model(model, to_file=image_out, dpi=100) training_log = directory + '/' + 'softmax_final_1' + '.txt' print(training_log) csv_logger = tf.keras.callbacks.CSVLogger(training_log, append=True, separator=' ') metrics = model.fit(X1, tf.one_hot(Y1, depth=2),
def predict(X, Y, flag, batch_size=32, epochs=200): """ Predicts labels for X given and compares predictions to ground truth Y Arguments: (X,Y) data and corresponding labels, X dim = (number of samples, number of timesteps, number of features = 75) Y dim = (number of samples, number of timesteps, number of labels = 8) flag: model to use batch_size : should be set to 1 if only 1 sample repeats: the averaged scores are computed over #number of repeats since stochastic approach Prints scores and downloads prediction """ ##RESHAPE GROUND TRUTH Y y_te = reshape(Y, (Y.shape[0] * Y.shape[1], Y.shape[2])) if flag == "LSTM": ## LOAD MODEL loaded_model = load_model('Results/opt_LSTM_model') print("Loaded model from disk") loaded_model.compile(loss=BinaryFocalLoss(2), optimizer='adam', metrics=[ BinaryAccuracy(), Precision(), Recall(), FalseNegatives(), FalsePositives() ]) #predict and reshape predictions y_pred = loaded_model.predict(X, batch_size=batch_size) y_pred = reshape(y_pred, (y_pred.shape[0] * y_pred.shape[1], 8)) #build-in predictions loss, accuracy, P, R, FN, FP = loaded_model.evaluate( X, Y, batch_size=batch_size) if flag == "TCN": loaded_model = load_model('Results/opt_TCN_model') print("Loaded model from disk") loaded_model.compile(optimizer='adam', loss=BinaryFocalLoss(5), metrics=[ BinaryAccuracy(), Precision(), Recall(), FalseNegatives(), FalsePositives() ]) #predict and reshape predictions y_pred = loaded_model.predict(X, batch_size=batch_size) y_pred = reshape(y_pred, (y_pred.shape[0] * y_pred.shape[1], 8)) #build-in predictions loss, accuracy, P, R, FN, FP = loaded_model.evaluate( X, Y, batch_size=batch_size) if flag == "Random_Forest": ##Load MODEL loaded_rf = joblib.load("Results/opt_random_forest_model.joblib") #feature expansion X_expanded = feature_expansion(X) #time window flattening X_expanded, Y = time_window_sample(X_expanded, Y, 120) #reshape into one video X_reshaped = np.reshape( X_expanded, (X_expanded.shape[0] * X_expanded.shape[1], X_expanded.shape[2])) y_te = np.reshape(Y, (Y.shape[0] * Y.shape[1], Y.shape[2])) ##prediction y_pred = loaded_rf.predict(X_reshaped) #customed predictions wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab = custom_scoring(y_te, y_pred) Tab = perf_measure(y_te, y_pred) print("F1 score per label: ", F1_tab) print("Precision per label: ", Ptab) print("Recall per label: ", Rtab) print("Macro F1 score: ", mf1, " ; Weighted F1 score: ", wf1, " ; Proportional F1 score: ", pf1) for name, tab in zip([ "True Positive ", "True Negative ", "False Positive ", "False Negatives " ], Tab): for i, t in enumerate(tab): print(name, "number for label ", i, " :", t) y_pred = y_pred > 0.5 tf.cast(y_pred, tf.int32) print("Prediction will be saved into Results/") name = 'Results/' + flag + '_Annotation.csv' pd.DataFrame(tf.get_static_value(y_pred), columns=[ "arch", "burrow + arch", "drag + arch", "groom", "tap + arch", "egg", "proboscis", "idle" ]).to_csv(name)
def evaluate_model_TCN(x_tr, y_tr, x_te, y_te, gamma=2, epochs=200, verbose=0, plot=0, single_run=0): """Training function, to evaluate train set against test set or train set againts validation set Arguments: (x_tr, y_tr) training data (x_te, y_te) testing/validation data gamma: focal loss parameter epochs= number of times, it passes through the training dataset. verbose: if true, print all the metrics plot: if true, print built in plot single_run: fix random seed to ensure reproducibility Returns: loss: Last binary focal loss value on test/validation set accuracy: accuracy on test/validation set wf1: weighted F1 score wf1_: custom weighted F1 score (with proportional weights) mf1: macro F1 score F1_tab: F1 score per label Ptab: precision per label Rtab: recall per label""" batch_size = 1 w = class_weights(y_tr) clear_session() if single_run: np.random.seed(123) python_random.seed(123) tf.random.set_seed(1234) #-------------------------------------model definition---------------------------# #Creation TCN object Tcn = TCN(nb_filters=64, kernel_size=2, nb_stacks=1, dilations=(8, 16, 32, 64, 128, 256, 512, 1024), return_sequences=True, activation=LeakyReLU(0.01), kernel_initializer='he_normal') i = Input(batch_shape=(1, None, x_tr.shape[2])) o = Tcn(i) o = Dense(200, activation=LeakyReLU(0.01), kernel_regularizer=keras.regularizers.l1_l2(0.00001))(o) o = Dense(8, activation='sigmoid')(o) model = Model(inputs=[i], outputs=[o]) model.compile(optimizer='adam', loss=BinaryFocalLoss(gamma), metrics=[ BinaryAccuracy(), Precision(), Recall(), FalseNegatives(), FalsePositives() ]) model.summary() #---------------------fit network---------------------------------------------# hist = model.fit(x_tr, y_tr, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(x_te, y_te)) #---------------------------------evaluate model----------------------------------------------# #evaluate model on test set (over all classes) loss, accuracy, P, R, FN, FP = model.evaluate(x_te, y_te, batch_size=batch_size, verbose=verbose) #save model if single_run: model.save('Results/opt_TCN_model') print("Model saved to Results") y_pred = model.predict(x_te, batch_size=batch_size, verbose=0) y_pred[y_pred < 0.5] = 0. y_pred[y_pred > 0.5] = 1. y_pred = reshape(y_pred, (y_pred.shape[0] * y_pred.shape[1], 8)) y_te = reshape(y_te, (y_te.shape[0] * y_te.shape[1], 8)) #evaluate F1 score for each label F1_tab, Ptab, Rtab, wf1_ = F1_score(y_te, y_pred, w) #evaluate accuracy per label acc_tab = Acc(y_te, y_pred) print("-> F1 score per label: ", F1_tab) print("-> y_pred ", y_pred[:, 4]) #test f1 score built in f = F1Score(8, threshold=0.5, average='weighted') f.update_state(y_te, y_pred) wf1 = f.result().numpy() print("weighted F1 score built in: ", wf1) f.reset_states() f = F1Score(8, threshold=0.5, average='macro') f.update_state(y_te, y_pred) mf1 = f.result().numpy() print("macro F1 score built in: ", mf1) f.reset_states() #-----------------------------------------print---------------------------------------------# #print all if verbose: print(" -> Accuracy: ", accuracy, "; Mean of labelwise accuracy: ", np.mean(acc_tab)) print("Per label accuracy: ", acc_tab) print("-> Weighted F1 score: ", wf1_) print("-> F1 score per label: ", F1_tab) print("-> Precision: ", P, "; Recall: ", R) print("-> Precision per label: ", Ptab) print("-> Recall per label: ", Rtab) print("-> Loss: ", loss) if plot: plot_history(hist.history) return hist, loss, accuracy, wf1, wf1_, mf1, F1_tab, Ptab, Rtab
def evaluate_model(x_tr, y_tr, x_te, y_te, model_type=1, gamma=2, nodes_nb=600, drop=0.1, epochs=200, reg=0, verbose=0, plot=0, single_run=0): """Training function, to evaluate train set against test set or train set againts validation set Arguments: (x_tr, y_tr) training data (x_te, y_te) testing/validation data model_type: type of model to train/evaluate (on LSTM layers) 0: 1 LSTM layer model 1: 1 bidirectional LSTM layer model 2: 2 bidirectional LSTM layer model gamma: focal loss parameter nodes_nb: number of neurons in the LSTM layers drop: dropout value verbose: if true, print all the metrics plot: if true, print built in plot single_run: fix random seed to ensure reproducibility Returns: loss: Last binary focal loss value on test/validation set accuracy: accuracy on test/validation set wf1: weighted F1 score wf1_: custom weighted F1 score (with proportional weights) mf1: macro F1 score F1_tab: F1 score per label Ptab: precision per label Rtab: recall per label""" batch_size = 32 n_features, n_outputs = x_tr.shape[2], y_tr.shape[2] w = class_weights(y_tr) clear_session() if single_run: np.random.seed(2020) python_random.seed(2020) tf.random.set_seed(2020) #-------------------------------------model definition-------------------------------------# model = Sequential() #model types if model_type == 0: model.add( LSTM(nodes_nb, input_shape=(None, n_features), return_sequences=True)) model.add(Dropout(drop)) model.add(Dense(n_outputs, activation='sigmoid')) if model_type == 1: model.add( Bidirectional( LSTM(nodes_nb, input_shape=(None, n_features), return_sequences=True))) model.add(Dropout(drop)) model.add(Dense(n_outputs, activation='sigmoid')) if model_type == 2: model.add( Bidirectional( LSTM(nodes_nb, input_shape=(None, n_features), return_sequences=True))) model.add(Dropout(drop)) model.add( Bidirectional( LSTM(nodes_nb, input_shape=(None, n_features), return_sequences=True))) model.add(Dropout(drop)) model.add(Dense(n_outputs, activation='sigmoid')) model.compile(loss=BinaryFocalLoss(gamma), optimizer='adam', metrics=[ BinaryAccuracy(), Precision(), Recall(), FalseNegatives(), FalsePositives() ]) #------------------------------------fit network---------------------------------------------# hist = model.fit(x_tr, y_tr, epochs=epochs, batch_size=batch_size, verbose=0, validation_data=(x_te, y_te)) if verbose: model.summary() #---------------------------------evaluate model----------------------------------------------# #evaluate model on test set (over all classes) loss, accuracy, P, R, FN, FP = model.evaluate(x_te, y_te, batch_size=batch_size, verbose=verbose) #save model if single_run: model.save('Results/opt_LSTM_model') print("Model saved to Results") y_pred = model.predict(x_te, batch_size=batch_size, verbose=0) y_pred = reshape(y_pred, (y_pred.shape[0] * y_pred.shape[1], 8)) y_te = reshape(y_te, (y_te.shape[0] * y_te.shape[1], 8)) #evaluate F1 score for each label F1_tab, Ptab, Rtab, wf1_ = F1_score(y_te, y_pred, w) #evaluate accuracy per label acc_tab = Acc(y_te, y_pred) #test f1 score built in f = F1Score(8, threshold=0.5, average='weighted') f.update_state(y_te, y_pred) wf1 = f.result().numpy() f.reset_states() f = F1Score(8, threshold=0.5, average='macro') f.update_state(y_te, y_pred) mf1 = f.result().numpy() f.reset_states() #-----------------------------------------print---------------------------------------------# #print all if verbose: print(" -> Accuracy: ", accuracy, "; Mean of labelwise accuracy: ", np.mean(acc_tab)) print("Per label accuracy: ", acc_tab) print("-> Proportional F1 score: ", wf1_, "; Weighted F1 score: ", wf1, "; Macro F1 score: ", mf1) print("-> F1 score per label: ", F1_tab) print("-> Precision: ", P, "; Recall: ", R) print("-> Precision per label: ", Ptab) print("-> Recall per label: ", Rtab) print("-> Loss: ", loss) if plot: plot_history(hist.history) return hist, loss, accuracy, wf1, wf1_, mf1, F1_tab, Ptab, Rtab
encode2 = conv2(x2) encode3 = conv3(x3) encode4 = conv4(x4) shot1 = tf.keras.layers.Concatenate(axis = 1)([encode1, encode2, encode3, encode4]) print(shot1.shape) # Dense part of the network starts here shot_d1 = tf.keras.layers.Dense(50, activation='linear', kernel_regularizer='l1', bias_regularizer='l1')(shot1) shot_r1 = tf.keras.layers.Dropout(0.4)(shot_d1) shot_b1 = tf.keras.layers.BatchNormalization(axis = 1)(shot_d1) output = tf.keras.layers.Dense(1, activation = 'sigmoid')(shot_b1) model = tf.keras.Model(inputs = inputs, outputs = output) opt = tf.keras.optimizers.SGD(learning_rate = 0.001) model.compile(optimizer = opt, loss = BinaryFocalLoss(pos_weight = 9, gamma = 2.5), metrics=[tf.keras.losses.BinaryCrossentropy()]) #BinaryFocalLoss(pos_weight=7, gamma=4) model.summary() image_out = 'drive/MyDrive/Eluvio-MLChallenge/lasso' + '/' + 'separable_lasso2.png' print(image_out) tf.keras.utils.plot_model(model, to_file=image_out, dpi=100) training_log = 'drive/MyDrive/Eluvio-MLChallenge/lasso' + '/' + 'separable_lasso2' + '.txt' print(training_log) csv_logger = tf.keras.callbacks.CSVLogger(training_log, append = True, separator=' ') metrics = model.fit(X1, Y1, epochs = 50, validation_split= 0.2, verbose=2, batch_size = 64, callbacks=[csv_logger]) model_ID = 'drive/MyDrive/Eluvio-MLChallenge/lasso' + '/' + 'separable_lasso2' + '.h5' print(model_ID) tf.keras.models.save_model(model,model_ID)
) model = Sequential([base_model, Dense(2, activation='softmax')]) """ base_model = tf.keras.applications.VGG16(weights='imagenet', input_shape=(224,224,3), include_top = False) model = Sequential([base_model]) model.add(Conv2D(filters = 32,kernel_size = (5,5), activation = 'relu')) model.add(MaxPooling2D(pool_size = (2,2))) model.add(Flatten()) model.add(Dense(units = 64, activation = 'relu')) model.add(Dense(units = 2 , activation = 'softmax')) model.compile(Adam(lr=.00001), loss=[BinaryFocalLoss(gamma=0.25)], metrics=[AUC()]) model.fit(train_batches,batch_size=32, validation_data=validation_batches, epochs=10,workers=2, verbose=1,callbacks=[learning_rate_reduction]) model.save("Transfer-LearninENb0.model") def load_image(img_path): img = image.load_img(img_path, target_size=(224, 224)) img2 = image.img_to_array(img) img2 = np.expand_dims(img2, axis=0) img2 /= 255. return img2 csv = pd.read_csv('C:/Users/14oka/Desktop/test.csv')
factor=0.5, min_lr=1e-7) model = Sequential() # VGG16 KULLANILDI 0.8356 base_model = tf.keras.applications.VGG16(weights='imagenet', input_shape=(224, 224, 3), include_top=False) model = Sequential( [base_model, GlobalAveragePooling2D(), Dense(2, activation='softmax')]) model.compile(Adam(lr=.00001), loss=[BinaryFocalLoss(gamma=0.25)], metrics=[AUC()]) model.fit(train_batches, batch_size=32, validation_data=validation_batches, validation_batch_size=32, epochs=10, workers=4, verbose=1, callbacks=[learning_rate_reduction]) model.save("Transfer-Learning.model") def load_image(img_path): img = image.load_img(img_path, target_size=(224, 224))