def gruModel(embeddingMatrix, maxDataLenght, embeddingVectorLength, numAttributes, numNeurons): model = Sequential() model.add( Embedding(input_dim=numAttributes, output_dim=embeddingVectorLength, weights=[embeddingMatrix], input_length=maxDataLenght, trainable=False)) model.add(GRU(numNeurons, return_sequences=False)) model.add(Dropout(0.2)) model.add( Dense(1, activation='sigmoid', kernel_regularizer=regularizers.l2(0.001))) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[ 'accuracy', km.binary_f1_score(), km.binary_precision(), km.binary_recall() ]) return model
def transferlearn_model(trainX, trainY, valX, valY, params): # initialize the training data augmentation object trainAug = ImageDataGenerator(rotation_range=15, fill_mode="nearest") # PRINT SUMMARY OF MODEL # baseModel.summary() # construct the head of the model that will be placed on top of the # the base model headModel = baseModel.output headModel = AveragePooling2D(pool_size=(4, 4))(headModel) headModel = Flatten(name="flatten")(headModel) headModel = Dense(64, activation="relu")(headModel) headModel = Dropout(params['dropout'])(headModel) headModel = Dense(2, activation="softmax")(headModel) # place the head FC model on top of the base model (this will become # the actual model we will train) model = Model(inputs=baseModel.input, outputs=headModel) # loop over all layers in the base model and freeze them so they will # not be updated during the first training process for layer in baseModel.layers: layer.trainable = False # compile our model print("[INFO] compiling model...") opt = params['optimizer'](lr=params['lr'], decay=params['lr'] / params['epochs']) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy", km.binary_f1_score()]) # train the head of the network print("[INFO] training head...") out = model.fit_generator( trainAug.flow(trainX, trainY, batch_size=params['batch_size']), steps_per_epoch=len(trainX) // params['batch_size'], validation_data=(valX, valY), validation_steps=len(valX) // params['batch_size'], epochs=params['epochs'], class_weight=d_class_weights, verbose=0) return out, model
def Lstm(dataInput, maxDataLength): train, test = train_test_split(dataInput, test_size=0.2) xTrain, yTrain = list(zip(*train)) xTest, yTest = list(zip(*test)) yTrain = np.array(yTrain) yTest = np.array(yTest) xTrain = sequence.pad_sequences(xTrain, maxlen=maxDataLength) xTest = sequence.pad_sequences(xTest, maxlen=maxDataLength) embedding_vector_length = 32 model = Sequential() model.add( Embedding(NUM_OF_ATTRIBUTES, embedding_vector_length, input_length=maxDataLength)) model.add(Bidirectional(LSTM(NUM_OF_NEURONS, return_sequences=False))) model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[ 'accuracy', km.binary_f1_score(), km.binary_precision(), km.binary_recall() ]) model.fit(xTrain, yTrain, validation_data=(xTest, yTest), epochs=NUM_OF_EPOCHS, batch_size=512, verbose=0) scores = model.evaluate(xTest, yTest, verbose=0) for i in range(1, 5): print("%s : %.2f%%" % (model.metrics_names[i], scores[i] * 100)) print("========================================================")
def Build_Model_RNN_Text(word_index, embedding_index, number_of_classes, MAX_SEQUENCE_LENGTH, EMBEDDING_DIM, sparse_categorical, min_hidden_layer_rnn, max_hidden_layer_rnn, min_nodes_rnn, max_nodes_rnn, random_optimizor, dropout, use_cuda=True, use_bidirectional=True, _l2=0.01, lr=1e-3): """ def buildModel_RNN(word_index, embedding_index, number_of_classes, MAX_SEQUENCE_LENGTH, EMBEDDING_DIM, sparse_categorical): word_index in word index , embedding_index is embeddings index, look at data_helper.py number_of_classes is number of classes, MAX_SEQUENCE_LENGTH is maximum lenght of text sequences """ Recurrent = CuDNNGRU if use_cuda else GRU model = Sequential() values = list(range(min_nodes_rnn, max_nodes_rnn + 1)) values_layer = list(range(min_hidden_layer_rnn - 1, max_hidden_layer_rnn)) layer = random.choice(values_layer) print(layer) embedding_matrix = np.zeros((len(word_index) + 1, EMBEDDING_DIM)) for word, i in word_index.items(): embedding_vector = embedding_index.get(word) if embedding_vector is not None: # words not found in embedding index will be all-zeros. embedding_matrix[i] = embedding_vector else: embedding_matrix[i] = embedding_index['UNK'] model.add( Embedding(len(word_index) + 1, EMBEDDING_DIM, weights=[embedding_matrix], input_length=MAX_SEQUENCE_LENGTH, trainable=True)) gru_node = random.choice(values) print(gru_node) for i in range(0, layer): if use_bidirectional: model.add( Bidirectional( Recurrent(gru_node, return_sequences=True, kernel_regularizer=l2(_l2)))) else: model.add( Recurrent(gru_node, return_sequences=True, kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) if use_bidirectional: model.add( Bidirectional(Recurrent(gru_node, kernel_regularizer=l2(_l2)))) else: model.add(Recurrent(gru_node, kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) model.add(Dense(256, activation='relu', kernel_regularizer=l2(_l2))) if number_of_classes == 2: model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(_l2))) model_tmp = model model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: model.add( Dense(number_of_classes, activation='softmax', kernel_regularizer=l2(_l2))) model_tmp = model if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) return model, model_tmp
def Build_Model_RNN_Image(shape, number_of_classes, sparse_categorical, min_nodes_rnn, max_nodes_rnn, random_optimizor, dropout): """ def Image_model_RNN(num_classes,shape): num_classes is number of classes, shape is (w,h,p) """ values = list(range(min_nodes_rnn - 1, max_nodes_rnn)) node = random.choice(values) x = Input(shape=shape) # Encodes a row of pixels using TimeDistributed Wrapper. encoded_rows = TimeDistributed(CuDNNLSTM(node, recurrent_dropout=dropout))(x) node = random.choice(values) # Encodes columns of encoded rows. encoded_columns = CuDNNLSTM(node, recurrent_dropout=dropout)(encoded_rows) # Final predictions and model. #prediction = Dense(256, activation='relu')(encoded_columns) if number_of_classes == 2: prediction = Dense(1, activation='sigmoid')(encoded_columns) else: prediction = Dense(number_of_classes, activation='softmax')(encoded_columns) model = Model(x, prediction) model_tmp = model if number_of_classes == 2: model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) return model, model_tmp
def Build_Model_CNN_Image(shape, number_of_classes, sparse_categorical, min_hidden_layer_cnn, max_hidden_layer_cnn, min_nodes_cnn, max_nodes_cnn, random_optimizor, dropout): """"" def Image_model_CNN(num_classes,shape): num_classes is number of classes, shape is (w,h,p) """ "" model = Sequential() values = list(range(min_nodes_cnn, max_nodes_cnn)) Layers = list(range(min_hidden_layer_cnn, max_hidden_layer_cnn)) Layer = random.choice(Layers) Filter = random.choice(values) model.add(Conv2D(Filter, (3, 3), padding='same', input_shape=shape)) model.add(Activation('relu')) model.add(Conv2D(Filter, (3, 3))) model.add(Activation('relu')) for i in range(0, Layer): Filter = random.choice(values) model.add(Conv2D(Filter, (3, 3), padding='same')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(dropout)) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dropout(dropout)) if number_of_classes == 2: model.add(Dense(1, activation='sigmoid', kernel_constraint=maxnorm(3))) model_tmp = model model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: model.add( Dense(number_of_classes, activation='softmax', kernel_constraint=maxnorm(3))) model_tmp = model if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) return model, model_tmp
def Build_Model_DNN_Text(shape, number_of_classes, sparse_categorical, min_hidden_layer_dnn, max_hidden_layer_dnn, min_nodes_dnn, max_nodes_dnn, random_optimizor, dropout, _l2=0.01, lr=1e-3): """ buildModel_DNN_Tex(shape, number_of_classes,sparse_categorical) Build Deep neural networks Model for text classification Shape is input feature space number_of_classes is number of classes """ model = Sequential() layer = list(range(min_hidden_layer_dnn, max_hidden_layer_dnn)) node = list(range(min_nodes_dnn, max_nodes_dnn)) Numberof_NOde = random.choice(node) nLayers = random.choice(layer) Numberof_NOde_old = Numberof_NOde model.add( Dense(Numberof_NOde, input_dim=shape, activation='relu', kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) for i in range(0, nLayers): Numberof_NOde = random.choice(node) model.add( Dense(Numberof_NOde, input_dim=Numberof_NOde_old, activation='relu', kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) Numberof_NOde_old = Numberof_NOde if number_of_classes == 2: model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(_l2))) model_tmp = model model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: model.add( Dense(number_of_classes, activation='softmax', kernel_regularizer=l2(_l2))) model_tmp = model if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) return model, model_tmp
callback = ModelSaveBestAvgAcc(filepath="model-{epoch:02d}-{avgacc:.2f}.hdf5", verbose=True, cond=filter_val_f1score) losses = [] for i in range(0, 6): losses.append(binary_focal_loss(gamma=2.)) model = get_model(input_shape) model.compile(optimizer=opt.Adam(lr=1e-4), loss=losses, metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score() ]) model.summary() model.fit_generator(gen_train, steps_per_epoch=len(dataset_train.image_ids) // batch_size, epochs=epochs, validation_data=gen_val, validation_steps=len(dataset_val.image_ids) // batch_size, callbacks=[callback], verbose=2) print('fine')
x = Flatten()(x) x = Dense(1024, activation="relu")(x) x = Dropout(0.5)(x) x = layers.Dense(num_classes, activation='softmax')(x) model_final = keras.models.Model(base_model.input, x) model_final.summary() # install keras_metrics to use f1 score metric !pip install keras_metrics import keras_metrics opt = Adam(lr=0.000001) #opt = Adam(lr=0.0000001) #opt = optimizers.RMSprop(lr=0.000001) model_final.compile(loss='categorical_crossentropy', optimizer = opt, metrics=['accuracy', keras_metrics.precision(), keras_metrics.binary_f1_score(), keras_metrics.recall()]) model_final.summary() """### balancer les donnees""" import numpy as np y_train_new = np.argmax(y_train, axis=1) from sklearn.utils import class_weight from keras.callbacks import EarlyStopping y_train_new = np.argmax(y_train, axis=1) #Deal with unbalanced Data class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train_new),y_train_new) class_weights = dict(enumerate(class_weights)) class_weights
def __init__(self, inputs, buffer, sess_id, sess, **kwargs): self.util = Utility() self.sess = sess self.sess_id = sess_id game = inputs['game'] agnt = inputs['agent'] sess = agnt['session'] eps = sess['episode'] mod = inputs['model'] trn = mod['training'] sv = mod['save'] mem = inputs['memory'] '''---Environment Paramters---''' self.env_name = game['name'] self.fps = game['fps'] self.mode = game['difficulty'] self.target = game['target'] self.tick = game['tick'] '''---Episode Parameters---''' self.nb_episodes = sess['max_ep'] self.nb_max_episode_steps = game['fps'] * 60 * eps['max_time'] self.nb_steps = self.nb_max_episode_steps * self.nb_episodes self.nb_steps_warmup = trn['warmup'] self.nb_max_start_steps = trn['max_ep_observe'] self.max_start_steps = trn['warmup'] self.keep_gif_score = eps['keep_gif_score'] '''---Agent / Model Parameters---''' self.name = agnt['name'] self.nb_actions = agnt['action_size'] self.delta_clip = agnt['delta_clip'] self.training = trn['training'] self.verbose = trn['verbose'] self.lr = trn['learn_rate'] self.eps = trn['initial_epsilon'] self.value_max = trn['initial_epsilon'] self.value_min = trn['terminal_epsilon'] self.anneal = trn['anneal'] self.shuffle = trn['shuffle'] self.train_interval = trn['interval'] self.validate = trn['validate'] self.split = trn['split'] self.action_repetition = trn['action_repetition'] self.epochs = trn['epochs'] self.epoch = 1 prec = km.binary_precision() re = km.binary_recall() f1 = km.binary_f1_score() self.metrics = ['accuracy', 'mse', prec, re, f1] self.H = mod['filter_size'] self.alpha = mod['alpha'] self.gamma = mod['gamma'] self.momentum = mod['momentum'] self.decay = mod['decay'] self.target_model_update = mod['target_update'] self.type = mod['type'] self.enable_double_dqn = mod['double_dqn'] self.enable_dueling_network = mod['dueling_network'] self.dueling_type = mod['dueling_type'] self.limit = mem['limit'] self.batch_size = mem['batch_size'] self.window_length = mem['state_size'] self.memory_interval = mem['interval'] self.ftype = sv['ftype'] self.vizualize = sv['visualize'] self.save_full = sv['save_full'] self.save_weights = sv['save_weights'] self.save_json = sv['save_json'] self.save_plot = sv['save_plot'] self.save_interval = sv['save_n'] self.log_interval = sv['log_n'] self.saves = sv['save_path'] self.save_path = self.util.get_save_dir_struct(self.saves, self.env_name) self.logs = sv['log_path'] self.util.display_status('Hyperparameters Successfully Loaded') '''Reference/Excerpt: keras-rl DQN Atari Example https://github.com/keras-rl/keras-rl/blob/master/examples/dqn_atari.py # Select a policy. # We use eps-greedy action selection, which means that a random action # is selected with probability eps. We anneal eps from init to term over # the course of (anneal) steps. This is done so that the agent initially # explores the environment (high eps) and then gradually sticks to # what it knows (low eps). We also set a dedicated eps value that is # used during testing. Note that we set it to 0.05 so that the agent # still performs some random actions. # This ensures that the agent cannot get stuck. # ''' self.custom_model_objects = { 'S': self.window_length, 'A': self.nb_actions, 'H': self.H, 'lr': self.lr, 'name': self.name, 'batch_size': self.batch_size, 'sess': self.sess, #dueling_network=self.enable_dueling_network, #dueling_type=self.dueling_type, } with tf.device(gpu): self.policy = LinearAnnealedPolicy( inner_policy=EpsGreedyQPolicy(eps=self.value_max), attr='eps', value_max=self.value_max, value_min=self.value_min, value_test=self.alpha, nb_steps=self.anneal) self.test_policy = GreedyQPolicy() if mod['optimizer'].lower() == 'adamax': self.optimizer = Adamax(lr=self.lr) elif mod['optimizer'].lower() == 'adadelta': self.optimizer = Adadelta() elif mod['optimizer'].lower() == 'rmsprop': self.optimizer = RMSprop() elif mod['optimizer'].lower() == 'sgd': self.optimizer = SGD( lr=self.lr, momentum=self.momentum, decay=self.decay, ) else: self.optimizer = Adam(lr=self.lr) self.memory = buffer self.log_path = self.util.get_log_dir_struct(self.sess_id, self.logs, self.ftype) self.util.display_status('Keras GPU Session {} Beginning'.format( self.sess_id)) nn = NeuralNet( S=self.window_length, A=self.nb_actions, H=self.H, lr=self.lr, name=self.name, batch_size=self.batch_size, dueling_network=self.enable_dueling_network, dueling_type=self.dueling_type, sess=self.sess, ) with tf.device(gpu): self.model = nn.get_model() self.util.display_status( '{} Keras Agent with {} Optimizer Built'.format( self.name, mod['optimizer'])) '''---Compile the model with chosen optimizer loss is calculated with lamba function based on model type selections (dueling, or double dqn)''' with tf.device(gpu): self.compile( optimizer=self.optimizer, metrics=self.metrics, ) self.util.display_status( '{} Agent Fully Initialized with Compiled Model'.format(self.name)) super(BetaFlapDQN, self).__init__( model=self.model, nb_actions=self.nb_actions, memory=self.memory, policy=self.policy, test_policy=self.test_policy, enable_double_dqn=self.enable_double_dqn, enable_dueling_network=self.enable_dueling_network, dueling_type=self.dueling_type, **kwargs)
callback = ModelSaveBestAvgAcc( filepath="model-{epoch:02d}-{avgacc:.2f}.hdf5", verbose=True, cond=filter_val_f1score ) losses = [] for i in range(0, 1): losses.append(binary_focal_loss(gamma=2.)) model = get_model(input_shape) model.compile( optimizer=opt.Adam(lr=1e-4), loss=losses, metrics=['accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score()] ) model.summary() model.fit_generator( gen_train, steps_per_epoch=len(dataset_train.image_ids) // batch_size, epochs=epochs, validation_data=gen_val, validation_steps=len(dataset_val.image_ids) // batch_size, callbacks=[callback], verbose=1 ) print('fine')
def crossValidation1(dataInput, maxDataLength): seed = 7 np.random.seed(seed) # split data and label X, Y = list(zip(*dataInput)) Y = np.array(Y) # set k value for cross validation split = 10 kfold = StratifiedKFold(n_splits=split, shuffle=True, random_state=seed) cvscores = [] for i in range(0, 5): cvscores.append([]) # cross validation process for train, test in kfold.split(X, Y): # build model model = Sequential() model.add( Embedding(input_dim=NUM_OF_ATTRIBUTES, output_dim=32, input_length=maxDataLength)) model.add(Bidirectional(LSTM(NUM_OF_NEURONS, return_sequences=False))) model.add(Dropout(0.2)) model.add( Dense(1, activation='sigmoid', kernel_regularizer=regularizers.l2(0.001))) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[ 'accuracy', km.binary_f1_score(), km.binary_precision(), km.binary_recall() ]) # print(model.summary()) model.fit(X[train], Y[train], validation_data=(X[test], Y[test]), epochs=NUM_OF_EPOCHS, batch_size=256, verbose=0) # evaluate the model # 1 = accuracy # 2 = f1_score # 3 = precission # 4 = recall # model = load_model('model.weights.best.hdf5', custom_objects={'f1_m':cm.f1_m, 'precision_m':cm.precision_m, 'recall_m':cm.recall_m}) scores = model.evaluate(X[train], Y[train], verbose=0) for i in range(1, 5): logFile += "%s : %.2f%%\n" % (model.metrics_names[i], scores[i] * 100) print("%s : %.2f%%" % (model.metrics_names[i], scores[i] * 100)) cvscores[i].append(scores[i] * 100) print("========================================================") print("Mean : ") for i in range(1, 5): metricName = '' if i == 1: metricName = 'acc' elif i == 2: metricName = 'f1_score' elif i == 3: metricName = 'precision' elif i == 4: metricName = 'recall' print("%s : %.2f%% (+/- %.2f%%)" % (metricName, np.mean(cvscores[i]), np.std(cvscores[i]))) # show result to matplotlib plt.style.use('classic') fig, axs = plt.subplots(2, 2, gridspec_kw={'hspace': 0.5, 'wspace': 0.5}) iteration = [*range(1, 11)] fig.suptitle('Result Data') (ax1, ax2), (ax3, ax4) = axs ax1.plot(iteration, cvscores[1]) ax1.set_ylabel('Accuracy (%)') ax2.plot(iteration, cvscores[2], 'tab:green') ax2.set_ylabel('F1 Measurement (%)') ax3.plot(iteration, cvscores[3], 'tab:orange') ax3.set_ylabel('Precission (%)') ax4.plot(iteration, cvscores[4], 'tab:red') ax4.set_ylabel('Recall (%)') plt.show()
gen_train = prepare(dataset_train, epochs, batch_size, os.path.join(coco_path, 'train_output')) callback = ModelSaveBestAvgAcc(filepath="model-{epoch:02d}-{acc:.2f}.hdf5", verbose=True) losses = [] for i in range(0, dataset_val.num_classes): losses.append(binary_focal_loss(gamma=2., alpha=0.9995)) for i in range(0, 3): losses.append(binary_focal_loss(gamma=2., alpha=0.8)) # model = unet(input_shape=input_shape) model = get_model(input_shape, dataset_val.num_classes) model.compile(optimizer=opt.Adam(lr=1e-4), loss=losses, metrics=['accuracy', km.binary_f1_score()]) model.summary() # import ipdb; ipdb.set_trace() model.fit_generator(gen_train, steps_per_epoch=len(dataset_train.image_ids) // batch_size, epochs=epochs, validation_data=gen_val, validation_steps=len(dataset_val.image_ids) // batch_size, callbacks=[callback], verbose=1) print('fine')
if define_inception: model = TransferLearning(input_shape=(75, 75, 3), output=2, model='inception', fineTune=define_finetune, tuneLayers=define_tuneLayers) # Definir el optimizador: adam = Adam() # Compilar el modelo: model.compile(loss='binary_crossentropy', optimizer=adam, metrics=[ 'binary_accuracy', km.binary_f1_score(label=1), km.binary_precision(label=1), km.binary_recall(label=1) ]) callback_list = [LearningRateScheduler(step_decay)] # Entrenar: history = model.fit(X_train, y_train_ohe, batch_size=BATCH, epochs=EPOCHS, class_weight=class_weights, callbacks=callback_list, validation_data=(X_val, y_val_ohe), verbose=2)
def Build_Model_CNN_Text(word_index, embedding_index, number_of_classes, MAX_SEQUENCE_LENGTH, EMBEDDING_DIM, sparse_categorical, min_hidden_layer_cnn, max_hidden_layer_cnn, min_nodes_cnn, max_nodes_cnn, random_optimizor, dropout, simple_model=False, _l2=0.01, lr=1e-3): """ def buildModel_CNN(word_index,embedding_index,number_of_classes,MAX_SEQUENCE_LENGTH,EMBEDDING_DIM,Complexity=0): word_index in word index , embedding_index is embeddings index, look at data_helper.py number_of_classes is number of classes, MAX_SEQUENCE_LENGTH is maximum lenght of text sequences, EMBEDDING_DIM is an int value for dimention of word embedding look at data_helper.py Complexity we have two different CNN model as follows F=0 is simple CNN with [1 5] hidden layer Complexity=2 is more complex model of CNN with filter_length of range [1 10] """ model = Sequential() if simple_model: embedding_matrix = np.zeros((len(word_index) + 1, EMBEDDING_DIM)) for word, i in word_index.items(): embedding_vector = embedding_index.get(word) if embedding_vector is not None: # words not found in embedding index will be all-zeros. embedding_matrix[i] = embedding_vector else: embedding_matrix[i] = embedding_index['UNK'] model.add( Embedding(len(word_index) + 1, EMBEDDING_DIM, weights=[embedding_matrix], input_length=MAX_SEQUENCE_LENGTH, trainable=True)) values = list(range(min_nodes_cnn, max_nodes_cnn)) Layer = list(range(min_hidden_layer_cnn, max_hidden_layer_cnn)) Layer = random.choice(Layer) for i in range(0, Layer): Filter = random.choice(values) model.add( Conv1D(Filter, 5, activation='relu', kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) model.add(MaxPooling1D(5)) model.add(Flatten()) Filter = random.choice(values) model.add(Dense(Filter, activation='relu', kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) Filter = random.choice(values) model.add(Dense(Filter, activation='relu', kernel_regularizer=l2(_l2))) model.add(Dropout(dropout)) if number_of_classes == 2: model.add( Dense(1, activation='sigmoid', kernel_regularizer=l2(_l2))) model_tmp = model model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: model.add( Dense(number_of_classes, activation='softmax', kernel_regularizer=l2(_l2))) model_tmp = model if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) else: embedding_matrix = np.zeros((len(word_index) + 1, EMBEDDING_DIM)) for word, i in word_index.items(): embedding_vector = embedding_index.get(word) if embedding_vector is not None: # words not found in embedding index will be all-zeros. embedding_matrix[i] = embedding_vector else: embedding_matrix[i] = embedding_index['UNK'] embedding_layer = Embedding(len(word_index) + 1, EMBEDDING_DIM, weights=[embedding_matrix], input_length=MAX_SEQUENCE_LENGTH, trainable=True) # applying a more complex convolutional approach convs = [] values_layer = list(range(min_hidden_layer_cnn, max_hidden_layer_cnn)) filter_sizes = [] layer = random.choice(values_layer) print("Filter ", layer) for fl in range(0, layer): filter_sizes.append((fl + 2)) values_node = list(range(min_nodes_cnn, max_nodes_cnn)) node = random.choice(values_node) print("Node ", node) sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH, ), dtype='int32') embedded_sequences = embedding_layer(sequence_input) for fsz in filter_sizes: l_conv = Conv1D(node, kernel_size=fsz, activation='relu')(embedded_sequences) l_pool = MaxPooling1D(5)(l_conv) #l_pool = Dropout(0.25)(l_pool) convs.append(l_pool) l_merge = Concatenate(axis=1)(convs) l_cov1 = Conv1D(node, 5, activation='relu')(l_merge) l_cov1 = Dropout(dropout)(l_cov1) l_pool1 = MaxPooling1D(5)(l_cov1) l_cov2 = Conv1D(node, 5, activation='relu')(l_pool1) l_cov2 = Dropout(dropout)(l_cov2) l_pool2 = MaxPooling1D(30)(l_cov2) l_flat = Flatten()(l_pool2) l_dense = Dense(1024, activation='relu')(l_flat) l_dense = Dropout(dropout)(l_dense) l_dense = Dense(512, activation='relu')(l_dense) l_dense = Dropout(dropout)(l_dense) if number_of_classes == 2: preds = Dense(1, activation='sigmoid')(l_dense) else: preds = Dense(number_of_classes, activation='softmax')(l_dense) model = Model(sequence_input, preds) model_tmp = model if number_of_classes == 2: model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor, lr), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) return model, model_tmp
### ENTRENAMIENTO ### BATCH = 64 EPOCHS = 100 # Definir el modelo: model = GlandsDetector(input_shape=(32,32,6), output=2) # Definir el optimizador: adam = Adam() # Compilar el modelo: model.compile( loss='binary_crossentropy', optimizer=adam, metrics=['binary_accuracy', km.binary_f1_score(label=1), km.binary_precision(label=1), km.binary_recall(label=1)] ) callback_list = [LearningRateScheduler(step_decay)] # Entrenar: history = model.fit( X_train, y_train_ohe, batch_size=BATCH, epochs=EPOCHS, validation_data=(X_val, y_val_ohe), class_weight=class_weights, callbacks=callback_list, verbose=2
def Build_Model_DNN_Image(shape, number_of_classes, sparse_categorical, min_hidden_layer_dnn, max_hidden_layer_dnn, min_nodes_dnn, max_nodes_dnn, random_optimizor, dropout): ''' buildModel_DNN_image(shape, number_of_classes,sparse_categorical) Build Deep neural networks Model for text classification Shape is input feature space number_of_classes is number of classes ''' model = Sequential() values = list(range(min_nodes_dnn, max_nodes_dnn)) Numberof_NOde = random.choice(values) Lvalues = list(range(min_hidden_layer_dnn, max_hidden_layer_dnn)) nLayers = random.choice(Lvalues) print(shape) model.add(Flatten(input_shape=shape)) model.add(Dense(Numberof_NOde, activation='relu')) model.add(Dropout(dropout)) for i in range(0, nLayers - 1): Numberof_NOde = random.choice(values) model.add(Dense(Numberof_NOde, activation='relu')) model.add(Dropout(dropout)) if number_of_classes == 2: model.add(Dense(1, activation='sigmoid')) model_tmp = model model.compile(loss='binary_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.binary_precision(), km.binary_recall(), km.binary_f1_score(), km.binary_true_positive(), km.binary_true_negative(), km.binary_false_positive(), km.binary_false_negative() ]) else: model.add(Dense(number_of_classes, activation='softmax')) model_tmp = model if sparse_categorical: model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.sparse_categorical_precision(), km.sparse_categorical_recall(), km.sparse_categorical_f1_score(), km.sparse_categorical_true_positive(), km.sparse_categorical_true_negative(), km.sparse_categorical_false_positive(), km.sparse_categorical_false_negative() ]) else: model.compile(loss='categorical_crossentropy', optimizer=optimizors(random_optimizor), metrics=[ 'accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score(), km.categorical_true_positive(), km.categorical_true_negative(), km.categorical_false_positive(), km.categorical_false_negative() ]) return model, model_tmp
def loss(y_true, y_pred): print(y_true.shape, y_pred.shape) weight = np.ones_like(y_true) weight = weight * 10 return K.mean( K.mean(-y_true * K.log(y_pred + 0.000001) - (1 - y_true + 0.000001) * K.log(1 - y_pred), axis=1)) model = load_model(PRETRAIN_PATH, custom_objects={ 'loss': loss, 'binary_precision': km.binary_precision(), 'binary_recall': km.binary_recall(), 'binary_f1_score': km.binary_f1_score() }) # model.summary() def predict(x): x = x.swapaxes(0, 1) x = np.expand_dims(x, axis=0) preds = model.predict(x) return preds.reshape(-1) def check_keyword(preds, chunk_duration, feed_duration, threshold=0.5): preds = preds > threshold chunk_sample = int(len(preds) * chunk_duration / feed_duration)