def my_cnn_network(width, dicom_path, masks_path, prag, train_dim, test_dim): x_train, y_train = train_the_network(dicom_path, masks_path) x_train = x_train.reshape(train_dim, width, width, 1) y_train = y_train.reshape(train_dim, width, width, 1) # arhitectura inp = Input((width, width, 1)) l = Conv2D(32, (2, 2), padding='same')(inp) l = BatchNormalization()(l) l = Activation('relu')(l) l = AveragePooling2D((2, 2))(l) l = Conv2D(64, (3, 3), padding='same')(l) l = BatchNormalization()(l) l = Activation('relu')(l) l = AveragePooling2D((2, 2))(l) l = Conv2D(256, (3, 3), padding='same')(l) l = BatchNormalization()(l) l = Activation('relu')(l) l = AveragePooling2D((2, 2))(l) l = Conv2DTranspose(128, (3, 3), strides=2, padding='same')(l) l = BatchNormalization()(l) l = Activation('relu')(l) l = Conv2DTranspose(64, (3, 3), strides=2, padding='same')(l) l = BatchNormalization()(l) l = Activation('relu')(l) l = Conv2DTranspose(32, (3, 3), padding='same')(l) l = BatchNormalization()(l) l = Activation('relu')(l) l = Conv2DTranspose(32, (3, 3), strides=2, padding='same')(l) l = BatchNormalization()(l) l = Activation('relu')(l) decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(l) l = BatchNormalization()(l) l = Activation('softmax')(l) MyModel = Model(inp, decoded) MyModel.summary() print() MyModel.compile(optimizer='adagrad', loss=losses.mse, metrics=[ 'accuracy', metrics.Recall(), metrics.Precision(), metrics.TruePositives(), metrics.TrueNegatives(), metrics.FalseNegatives(), metrics.FalsePositives() ]) MyModel.fit(x_train, y_train, batch_size=32, epochs=1000) MyModel.save('model.h5')
def test_unweighted_all_incorrect(self): r_obj = metrics.Recall(thresholds=[0.5]) inputs = np.random.randint(0, 2, size=(100, 1)) y_pred = K.constant(inputs) y_true = K.constant(1 - inputs) result = r_obj(y_true, y_pred) assert np.isclose(0, K.eval(result))
def my_model(self): input_shape = (self.dim, self.dim, 3) nclass = self.nclass input_ = Input(shape=input_shape) conv1 = self.conv2d_bn(input_, 64, kernel_size=(3, 3), strides=(2, 2)) pool1 = MaxPool2D(pool_size=(3, 3), strides=(2, 2), padding='same')(conv1) conv2 = self.basic_block(64, 2, is_first_layer=False)(pool1) pool2 = GlobalAvgPool2D()(conv2) output_ = Dense(nclass, activation='softmax')(pool2) model = Model(inputs=input_, outputs=output_) model.compile(loss="categorical_crossentropy", optimizer="adagrad", metrics=[ "accuracy", metrics.AUC(), metrics.Precision(), metrics.Recall() ]) return model
def train_model(dataset, model): epochs = 15 # epochs = 0 lr = 1e-4 size = 300 wd = 1e-2 bs = 8 # reduce this if you are running out of GPU memory pretrained = True alpha_fl = [0.4, 0.4, 0.15, 0.05] gamma_fl = 2 config = { 'epochs': epochs, 'lr': lr, 'size': size, 'wd': wd, 'bs': bs, 'alpha_fl': alpha_fl, 'gamma_fl': gamma_fl, 'pretrained': pretrained } wandb.config.update(config) model.compile( optimizer=optimizers.Adam(lr=lr), loss=[categorical_focal_loss(alpha=alpha_fl, gamma=gamma_fl)], metrics=[ metrics.Precision(top_k=1, name='precision'), metrics.Recall(top_k=1, name='recall'), metrics.Accuracy(name='accuracy') ]) early_stop = EarlyStopping(monitor='loss', min_delta=0.01, patience=7, mode='min', verbose=1) reduce_on_plateau = ReduceLROnPlateau(monitor='loss', factor=0.1, patience=2, verbose=1, mode='min', epsilon=0.01, cooldown=0, min_lr=0) train_data, valid_data = datasets_keras.load_dataset(dataset, bs) _, ex_data = datasets_keras.load_dataset(dataset, 10) model.fit_generator(train_data, validation_data=valid_data, epochs=epochs, callbacks=[ early_stop, reduce_on_plateau, WandbCallback(input_type='image', output_type='segmentation_mask', validation_data=ex_data[0]) ])
def test_unweighted_top_k_and_threshold(self): r_obj = metrics.Recall(thresholds=.7, top_k=2) y_pred = K.constant([0.2, 0.8, 0.6, 0, 0.2], shape=(1, 5)) y_true = K.constant([1, 1, 1, 0, 1], shape=(1, 5)) result = r_obj(y_true, y_pred) assert np.isclose(0.25, K.eval(result)) assert np.isclose(1, K.eval(r_obj.true_positives)) assert np.isclose(3, K.eval(r_obj.false_negatives))
def test_recall(self, distribution): # True positive is 2, false negative 1, precision is 2/3 = 0.6666667 label_prediction = ([0, 1, 1, 1], [1, 0, 1, 1]) with distribution.scope(): recall = metrics.Recall() self.evaluate([v.initializer for v in recall.variables]) updates = distribution.run(recall, args=label_prediction) self.evaluate(updates) self.assertAllClose(recall.result(), 0.6666667)
def test_weighted_with_threshold(self): r_obj = metrics.Recall(thresholds=[0.5, 1.]) y_true = K.constant([[0, 1], [1, 0]], shape=(2, 2)) y_pred = K.constant([[1, 0], [0.6, 0]], shape=(2, 2), dtype='float32') weights = K.constant([[1, 4], [3, 2]], shape=(2, 2), dtype='float32') result = r_obj(y_true, y_pred, sample_weight=weights) weighted_tp = 0 + 3. weighted_positives = (0 + 3.) + (4. + 0.) expected_recall = weighted_tp / weighted_positives assert np.allclose([expected_recall, 0], K.eval(result), 1e-3)
def __init__(self): self.num_conv2d_layers=1 self.filters_2d=[16,32] self.kernel_size_2d=[[3,3], [3,3]] self.mpool_size_2d=[[2,2], [2,2]] self.metric_type_map = { 'precision' : metrics.Precision(), 'recall' : metrics.Recall(), 'AUC' : metrics.AUC(), 'accuracy' : metrics.Accuracy(), }
def compile_model(self): learning_rate = 0.000625 # initial learning rate self.model.compile( optimizer=Adam(learning_rate=learning_rate), loss="binary_crossentropy", metrics=["accuracy", metrics.Precision(), metrics.Recall(), f1] #, # sample_weight_mode="temporal" )
def test_weighted(self): r_obj = metrics.Recall() y_pred = K.constant([[1, 0, 1, 0], [0, 1, 0, 1]]) y_true = K.constant([[0, 1, 1, 0], [1, 0, 0, 1]]) result = r_obj(y_true, y_pred, sample_weight=K.constant([[1, 2, 3, 4], [4, 3, 2, 1]])) weighted_tp = 3.0 + 1.0 weighted_t = (2.0 + 3.0) + (4.0 + 1.0) expected_recall = weighted_tp / weighted_t assert np.isclose(expected_recall, K.eval(result))
def __init__(self, X_train, y_train, X_val, y_val, X_test, y_test, **kwargs): self.model_dir = MODEL_DIR (self.X_train, self.y_train) = (X_train, y_train) (self.X_val, self.y_val) = (X_val, y_val) (self.X_test, self.y_test) = (X_test, y_test) self.metrics = [metrics.Recall(), metrics.Precision(), metrics.AUC()] self.model = self.set_architecture() self.callback = self.compile_model()
def build_model(): model = Sequential() model.add(layers.Dense(30, activation='relu', input_shape=[30])) model.add(layers.Dropout(0.8)) model.add(layers.Dense(16, activation='relu')) model.add(layers.Dropout(0.8)) model.add(layers.Dense(2, activation='sigmoid')) model.compile(optimizer=optimizers.Adam(), loss=losses.binary_crossentropy, metrics=['accuracy', metrics.Precision(), metrics.Recall(), metrics.F1]) model.summary() return model
def initializeNN(): from keras.models import Sequential from keras.layers import Dense from keras.layers import LeakyReLU from keras.layers import Dropout from keras import regularizers from keras import metrics #import tensorflow_addons as tfa ### Define metrics metrics = [ metrics.CategoricalAccuracy(name="accuracy"), metrics.FalseNegatives(name="fn"), metrics.FalsePositives(name="fp"), metrics.TrueNegatives(name="tn"), metrics.TruePositives(name="tp"), metrics.Precision(name="precision"), metrics.Recall(name="recall"), metrics.AUC(name='auc') #, #tfa.metrics.CohenKappa(name='kappa') ] # define the keras model nn = Sequential() nn.add(Dense(256, input_dim=102, kernel_regularizer='l1')) #, activation='relu')) nn.add(LeakyReLU(alpha=0.1)) nn.add(Dropout(0.1)) nn.add(Dense(128)) #, activation='relu'))#,kernel_regularizer='l1')) nn.add(LeakyReLU(alpha=0.1)) nn.add(Dropout(0.1)) nn.add(Dense(64)) #, activation='relu'))#,kernel_regularizer='l1')) nn.add(LeakyReLU(alpha=0.1)) nn.add(Dropout(0.1)) nn.add(Dense(64)) #, activation='relu'))#,kernel_regularizer='l1')) nn.add(LeakyReLU(alpha=0.1)) nn.add(Dropout(0.1)) nn.add(Dense(31, activation='softmax')) nn.compile(loss='categorical_crossentropy', optimizer='Adamax', metrics=metrics) return nn
def test_unweighted_top_k_and_class_id(self): r_obj = metrics.Recall(class_id=2, top_k=2) y_pred = K.constant([0.2, 0.6, 0.3, 0, 0.2], shape=(1, 5)) y_true = K.constant([0, 1, 1, 0, 0], shape=(1, 5)) result = r_obj(y_true, y_pred) assert np.isclose(1, K.eval(result)) assert np.isclose(1, K.eval(r_obj.true_positives)) assert np.isclose(0, K.eval(r_obj.false_negatives)) y_pred = K.constant([1, 1, 0.9, 1, 1], shape=(1, 5)) y_true = K.constant([0, 1, 1, 0, 0], shape=(1, 5)) result = r_obj(y_true, y_pred) assert np.isclose(0.5, K.eval(result)) assert np.isclose(1, K.eval(r_obj.true_positives)) assert np.isclose(1, K.eval(r_obj.false_negatives))
def test_weighted_top_k(self): r_obj = metrics.Recall(top_k=3) y_pred1 = K.constant([0.2, 0.1, 0.4, 0, 0.2], shape=(1, 5)) y_true1 = K.constant([0, 1, 1, 0, 1], shape=(1, 5)) K.eval( r_obj(y_true1, y_pred1, sample_weight=K.constant([[1, 4, 2, 3, 5]]))) y_pred2 = K.constant([0.2, 0.6, 0.4, 0.2, 0.2], shape=(1, 5)) y_true2 = K.constant([1, 0, 1, 1, 1], shape=(1, 5)) result = r_obj(y_true2, y_pred2, sample_weight=K.constant(3)) tp = (2 + 5) + (3 + 3) positives = (4 + 2 + 5) + (3 + 3 + 3 + 3) expected_recall = float(tp) / positives assert np.isclose(expected_recall, K.eval(result))
def train_cnn_model(x_train, y_train): x_train = array(x_train) x_train = x_train.reshape((len(x_train), 3, int(len(x_train[0])/3), 1)) y_train = array(y_train) #create model cnn_model = Sequential() cnn_model.add(Conv2D(64, kernel_size=3, activation='relu', input_shape=(3,21,1), padding='same')) cnn_model.add(layers.BatchNormalization(1)) cnn_model.add(Conv2D(64, kernel_size=3, activation='relu', padding='same')) cnn_model.add(layers.BatchNormalization(1)) cnn_model.add(MaxPooling2D(2,2)) cnn_model.add(Flatten()) cnn_model.add(Dense(512, activation = 'relu')) cnn_model.add(Dense(1, activation='sigmoid')) # compile and fit cnn_model.compile(optimizer='Adam', loss='binary_crossentropy', metrics=['acc', metrics.AUC(), metrics.FalseNegatives(), metrics.Recall(), metrics.Precision(), metrics.FalseNegatives(), metrics.TrueNegatives(), metrics.FalsePositives(), metrics.TruePositives()]) cnn_history = cnn_model.fit(x_train, y_train, epochs=100, batch_size=16, validation_split=0.2, callbacks=[callbacks.EarlyStopping(monitor='val_loss', patience=5), callbacks.LearningRateScheduler(scheduler)]) print("finish training cnn model") return cnn_model, cnn_history
def train_model(dataset, model): epochs = 40 # epochs = 0 lr = 1e-4 size = 300 wd = 1e-2 bs = 8 # reduce this if you are running out of GPU memory pretrained = True """For Focal Loss we need alpha and gamma initialized """ alpha = [[.25, .25, .25, .25, .25, .25]] gamma = 2 config = { 'epochs': epochs, 'lr': lr, 'size': size, 'wd': wd, 'bs': bs, 'pretrained': pretrained, } wandb.config.update(config) model.compile(optimizer=optimizers.Adam(lr=lr), loss=[categorical_focal_loss(alpha, gamma)], metrics=[ metrics.Precision(top_k=1, name='precision'), metrics.Recall(top_k=1, name='recall'), FBeta(name='f_beta') ]) train_data, valid_data = datasets_keras.load_dataset(dataset, bs) _, ex_data = datasets_keras.load_dataset(dataset, 10) model.fit_generator(train_data, validation_data=valid_data, epochs=epochs, callbacks=[ WandbCallback(input_type='image', output_type='segmentation_mask', validation_data=ex_data[0]) ])
def test_config(self): r_obj = metrics.Recall(name='my_recall', thresholds=[0.4, 0.9], top_k=15, class_id=12) assert r_obj.name == 'my_recall' assert len(r_obj.weights) == 2 assert ([v.name for v in r_obj.weights ] == ['true_positives:0', 'false_negatives:0']) assert r_obj.thresholds == [0.4, 0.9] assert r_obj.top_k == 15 assert r_obj.class_id == 12 # Check save and restore config r_obj2 = metrics.Recall.from_config(r_obj.get_config()) assert r_obj2.name == 'my_recall' assert len(r_obj2.weights) == 2 assert r_obj2.thresholds == [0.4, 0.9] assert r_obj2.top_k == 15 assert r_obj2.class_id == 12
def create_model(self, activation_function, alpha): # create the model self.activation_function = activation_function self.model = Sequential() self.alpha = alpha hidden_nodes = int( len(self.training_traces) / (alpha * (len(self.labels) + self.num_target))) self.hidden_nodes = hidden_nodes self.model.add(LSTM(hidden_nodes)) self.model.add(Dense(1, activation=activation_function)) self.model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[ 'accuracy', metrics.AUC(), metrics.Precision(), metrics.Recall() ])
def train_lstm_model(x_train, y_train): x_train = array(x_train) x_train = x_train.reshape((len(x_train), 1, len(x_train[0]))) print("x_train.shape", x_train.shape) print(x_train[0]) y_train = array(y_train) print("y_train.shape", y_train.shape) # imrpove log: use batch size 16 and add one more lstm layer lstm_model = Sequential() lstm_model.add(LSTM(16, input_shape=(1, 63), return_sequences=True)) lstm_model.add(LSTM(16, )) lstm_model.add(layers.Dense(1, activation='sigmoid')) lstm_model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc', metrics.AUC(), metrics.FalseNegatives(), metrics.Recall(), metrics.Precision(), metrics.FalseNegatives(), metrics.TrueNegatives(), metrics.FalsePositives(), metrics.TruePositives()]) lstm_history = lstm_model.fit(x_train, y_train, epochs=100, batch_size=16, validation_split=0.2, callbacks=[callbacks.EarlyStopping(monitor='val_loss', patience=5), callbacks.LearningRateScheduler(scheduler)]) print("finish training lstm model") return lstm_model, lstm_history
def set_model_prediction_multi_label(model_path, test_set, custom_objects, with_f1=False): """Compute metrics of a set of models for multilabel model. Computed metrics are : Loss, Accuracy, F1-Score, Macro F1-Score. Args: model_path (string): path of folder that contains models. test_set (pandas.DataFrame): DataFrame with column path for images path and label. custom_objects (dict): Dict of custom objects to load with model. with_f1 (bool, optional): True if the model is train with F1-Score metrics, otherwise False. Defaults to False. """ test_generator = generator(test_set['path'].to_numpy(), test_set[['label_culture','label_coffee']].to_numpy(), eurosat_params['mean'], eurosat_params['std'], batch_size=len(test_set)) prediction_set = [] evaluate = [] X, y = next(test_generator) for path in os.listdir(model_path): if path.split(".")[1] == 'h5': restored_model = None if with_f1: restored_model = load_model(os.path.join(model_path, path), custom_objects, compile=False) restored_model.compile(optimizer=Adam(learning_rate=0.00001), loss='binary_crossentropy',metrics=[metrics.BinaryAccuracy(name='accuracy'),metrics.Precision(name='precision'),metrics.Recall(name='recall'),f1_score_keras]) else : restored_model = load_model(os.path.join(model_path, path), custom_objects) evaluate.append(restored_model.evaluate(test_generator, steps=1)) prediction_set.append(np.where(restored_model.predict(X) > 0.5, 1, 0)) predictions = [] for pred in zip(*prediction_set): culture_pred, coffee_pred = zip(*pred) predictions.append(np.array([np.argmax(np.bincount(culture_pred)), np.argmax(np.bincount(coffee_pred))])) cm = multilabel_confusion_matrix(y, predictions) plot_confusion_matrix(cm[0], ["Culture", "No-Culture"],"Confusion Matrix\nCulture vs No-Culture\nDenseNet 64x64") plot_confusion_matrix(cm[1], ["Coffee", "Other"],"Confusion Matrix\nCoffee vs other\nDenseNet 64x64") if with_f1: losses, accs, precisions, recalls, f1 = zip(*evaluate) else : losses, accs, precisions, recalls = zip(*evaluate) print("Global metrics") print(f"Mean accuracy : {round(np.mean(accs),4)}") print(f"Stdev accuracy : {round(np.std(accs),4)}") print("\n") print(f"Mean loss : {round(np.mean(losses),4)}") print(f"Stdev loss : {round(np.std(losses),4)}") print("\n") culture_pred, coffee_pred = zip(*predictions) culture_true, coffee_true = zip(*y) print("Culture vs no-culture") print(f"F1-Score Culture: {round(f1_score(culture_true, culture_pred, pos_label=0),4)}") print(f"F1-Score No culture: {round(f1_score(culture_true, culture_pred, pos_label=1),4)}") print(f"Macro F1-Score : {round(f1_score(culture_true, culture_pred, average='macro'),4)}") print(f"\n") print("Coffee vs other") print(f"F1-Score Coffee: {round(f1_score(coffee_true, coffee_pred, pos_label=0),4)}") print(f"F1-Score Other: {round(f1_score(coffee_true, coffee_pred, pos_label=1),4)}") print(f"Macro F1-Score : {round(f1_score(coffee_true, coffee_pred, average='macro'),4)}")
model.add(Dense(units_10, activation=activation_10)) model.add(Dropout(dropout_10)) model.add(Dense(units_11, activation=activation_11)) model.add(Dropout(dropout_11)) model.add(Dense(units_12, activation=activation_12)) model.add(Dropout(dropout_12)) model.add(Dense(nb_classes, activation='sigmoid')) METRICS = [ metrics.BinaryAccuracy(name='ACCURACY'), metrics.Precision(name='PRECISION'), metrics.Recall(name='RECALL'), metrics.AUC(name='AUC'), metrics.TruePositives(name='TP'), metrics.TrueNegatives(name='TN'), metrics.FalsePositives(name='FP'), metrics.FalseNegatives(name='FN')] model.compile(loss='binary_crossentropy', optimizer=compile_optimizer, metrics=METRICS) # GENERATORS train_datagen = ImageDataGenerator( rescale=1. / 255, shear_range=0.2, zoom_range=0.2,
def test_unweighted_top_k(self): r_obj = metrics.Recall(top_k=3) y_pred = K.constant([0.2, 0.1, 0.5, 0, 0.2], shape=(1, 5)) y_true = K.constant([0, 1, 1, 0, 0], shape=(1, 5)) result = r_obj(y_true, y_pred) assert np.isclose(0.5, K.eval(result))
def test_unweighted_with_threshold(self): r_obj = metrics.Recall(thresholds=[0.5, 0.7]) y_pred = K.constant([1, 0, 0.6, 0], shape=(1, 4)) y_true = K.constant([0, 1, 1, 0], shape=(1, 4)) result = r_obj(y_true, y_pred) assert np.allclose([0.5, 0.], K.eval(result), 0)
def f1_score(y_true, y_pred): return 2 * ( (metrics.Precision(y_true, y_pred) * metrics.Recall(y_true, y_pred)) / (metrics.Precision(y_true, y_pred) + metrics.Recall(y_true, y_pred))) + k.epsilo()
def set_model_prediction(model_path, test_set, custom_objects, with_f1=False, labels=["Coffee", "Other"], title="title"): """Compute metrics of a set of models. Computed metrics are : Loss, Accuracy, F1-Score, Macro F1-Score. Args: model_path (string): path of folder that contains models. test_set (pandas.DataFrame): DataFrame with column path for images path and label. custom_objects (dict): Dict of custom objects to load with model. with_f1 (bool, optional): True if the model is train with F1-Score metrics, otherwise False. Defaults to False. labels (list, optional): Label for confusion Matrix. Defaults to ["Coffee", "Other"]. title (str, optional): Title of confusion matrix. Defaults to "title". """ test_generator = generator(test_set['path'].to_numpy(), test_set['label'].to_numpy(), eurosat_params['mean'], eurosat_params['std'], batch_size=len(test_set)) prediction_set = [] evaluate = [] X, y = next(test_generator) for path in os.listdir(model_path): if path.split(".")[1] == 'h5': restored_model = None if with_f1: restored_model = load_model(os.path.join(model_path, path), custom_objects, compile=False) restored_model.compile(optimizer=Adam(learning_rate=0.00001), loss='binary_crossentropy',metrics=[metrics.BinaryAccuracy(name='accuracy'),metrics.Precision(name='precision'),metrics.Recall(name='recall'),f1_score_keras]) else : restored_model = load_model(os.path.join(model_path, path), custom_objects) evaluate.append(restored_model.evaluate(test_generator, steps=1)) prediction_set.append(np.where(restored_model.predict(X) > 0.5, 1, 0).reshape(-1).tolist()) predictions = [] for pred in zip(*prediction_set): predictions.append(np.argmax(np.bincount(pred))) cm = confusion_matrix(y, predictions) plot_confusion_matrix(cm, labels,title) if with_f1: losses, accs, precisions, recalls, f1 = zip(*evaluate) else : losses, accs, precisions, recalls = zip(*evaluate) print(f"Mean accuracy : {round(np.mean(accs),4)}") print(f"Stdev accuracy : {round(np.std(accs),4)}") print("\n") print(f"Mean loss : {round(np.mean(losses),4)}") print(f"Stdev loss : {round(np.std(losses),4)}") print("\n") print(f"F1-Score {labels[0]}: {round(f1_score(y, predictions, pos_label=0),4)}") print(f"F1-Score {labels[1]}: {round(f1_score(y, predictions, pos_label=1),4)}") print(f"Macro F1-Score : {round(f1_score(y, predictions, average='macro'),4)}")
model.add(Dense(100, activation='relu')) model.add(Dropout(0.4)) model.add(Dense(4, activation='softmax')) opt = optimizers.Adam(learning_rate=0.0001) epoch_number = 30 # Initiate tool for logging the results and scores during the run name = 'Training_Results_Epochs_' + \ str(epoch_number)+'_5Fold_Run_FastText_Detection-'+str(run)+'.csv' csv_logger = CSVLogger('results/' + name) # Compile the ML model) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=[km.Recall()], sample_weight_mode='temporal') print('Compilation successful.') # Fit the model in XY epochs (see variable above) model.fit(x_train, y_train, batch_size=32, epochs=epoch_number, verbose=1, validation_split=0.1, shuffle=True, sample_weight=sample_weights, callbacks=[csv_logger])
def run(model_name, train_file, val_file, num_classes, filename, dropout, input_shape_arg = (224,224,3)): """ fit dataset and run training process Arguments:\n train_file --> h5 file, fit to model\n val_file --> h5 file, for validation\n num_classes --> int, total classes \n dropout_value --> float, range 0 - 1 for dropout\n epoch --> int\n batch_size --> int, [8, 16, 32, 64, 128, 256, etc.]\n input_shape_arg --> shape of image (W,H,C)\n lr_value --> learning rate value\n optimizer --> Adam, SGD\n Returns:\n model\n x_test\n y_test """ # preprocessing data X_train, Y_train, X_val, Y_val = dataset_preprocess(num_classes, train_file, val_file) _epoch = 80 lr_value_array = [1e-3, 1e-4] if model_name == "resnet50": batch_size_array = [8, 16, 32] LABEL = ["e-3(8)", "e-3(16)", "e-3(32)", "e-4(8)", "e-4(16)", "e-4(32)"] elif model_name == "resnet18": batch_size_array = [16, 32, 64] LABEL = ["e-3(16)", "e-3(32)", "e-3(64)", "e-4(16)", "e-4(32)", "e-4(64)"] HP = [] for lr in lr_value_array: for bs in batch_size_array: hp = Hyperparameter("adam", lr, bs, dropout) HP.append(hp) HISTORY = [] ROC = [] for hp in HP: K.clear_session() model = None # compile model if model_name == "resnet50": print("resnet50") model = ResNet50(input_shape=input_shape_arg, classes=int(num_classes), dropout_value=hp.dropout) model.compile(optimizer=hp.get_optimizer(), loss='categorical_crossentropy', metrics=['accuracy', metrics.AUC(), metrics.Precision(), metrics.Recall()]) elif model_name == "resnet18": print("resnet18") model = ResNet18(input_shape=input_shape_arg, classes=int(num_classes), dropout_value=hp.dropout) model.compile(optimizer=hp.get_optimizer(), loss='categorical_crossentropy', metrics=['accuracy', metrics.AUC(), metrics.Precision(), metrics.Recall()]) elif model_name == "vgg19": print("VGG19") # configure model input base_model = applications.vgg19.VGG19(weights= None, include_top=False, input_shape= input_shape_arg) # configure model output x = base_model.output x = GlobalAveragePooling2D()(x) x = Dropout(hp.dropout(x)) out = Dense(int(num_classes), activation= 'softmax')(x) # combine model then compile model = Model(inputs = base_model.input, outputs = out) model.compile(optimizer= hp.get_optimizer(), loss='categorical_crossentropy', metrics=['accuracy']) elif model_name == "vgg16": print("VGG16") # configure model input base_model = applications.vgg16.VGG16(weights= None, include_top=False, input_shape= input_shape_arg) # configure model output x = base_model.output x = GlobalAveragePooling2D()(x) x = Dropout(hp.dropout(x)) out = Dense(int(num_classes), activation= 'softmax')(x) # combine model then compile model = Model(inputs = base_model.input, outputs = out) model.compile(optimizer= hp.get_optimizer(), loss='categorical_crossentropy', metrics=['accuracy']) # optimizer == adam # train the model history = model.fit(X_train, Y_train, epochs = _epoch, batch_size = hp.batch_size, validation_data=(X_val, Y_val), shuffle=True) HISTORY.append(history) del model print(f"DONE for: {hp.optim}-{hp.lr_value}-{hp.batch_size}-{hp.dropout}") plt.figure(1) mpl.style.use('seaborn') i = 0 for history in HISTORY: plt.plot(history.history["val_accuracy"], f"C{i}", label=LABEL[i]) i = i+1 plt.ylabel('val_acc') plt.xlabel('epoch') plt.title(f"Accuracy {filename}") plt.legend() plt.savefig(f"ACC-{filename}.png") print("VAL ACC:") i = 0 for history in HISTORY: print(LABEL[i]) i = i + 1 print("auc: {}" .format(statistics.mean( history.history["val_auc_1"] )) ) print("recall: {}" .format(statistics.mean( history.history["val_recall_1"] )) ) print("Prec: {}" .format(statistics.mean( history.history["val_precision_1"] )) ) print("MEAN: {}" .format(statistics.mean( history.history["val_accuracy"] )) ) print("STD: {}" .format(statistics.pstdev( history.history['val_accuracy'] )) )
def test_unweighted(self): r_obj = metrics.Recall() y_pred = K.constant([1, 0, 1, 0], shape=(1, 4)) y_true = K.constant([0, 1, 1, 0], shape=(1, 4)) result = r_obj(y_true, y_pred) assert np.isclose(0.5, K.eval(result))
print(imerg.shape, label.shape,goes.shape, flush=True) model=UNet() print(model.summary(),flush=True) model = multi_gpu_model(model,gpus=2) metrics = [ metrics.FalseNegatives(name="fn"), metrics.FalsePositives(name="fp"), metrics.TrueNegatives(name="tn"), metrics.TruePositives(name="tp"), metrics.Precision(name="precision"), metrics.Recall(name="recall"), ] model.compile(optimizer="Adam", loss='binary_crossentropy', metrics=metrics) epochs=500 batch_size=16 earlystopper = EarlyStopping(patience=50,verbose=1, monitor='val_loss') checkpointer = ModelCheckpoint('model_ck_mse_new.h5', save_best_only=True, verbose=1) history=model.fit([goes,imerg], label, epochs=epochs, batch_size=batch_size, validation_split=0.3, callbacks=[earlystopper,checkpointer], verbose=2) results=pd.DataFrame(history.history) print(results, flush=True)