def compile_model(self, model=None): f1_score = km.categorical_f1_score(label=1) self.earlyStopping = EarlyStopping(monitor='val_f1_score', restore_best_weights=True, patience=patience, verbose=0, mode='max' ,min_delta=0.01 ) adam = optimizers.Adam(lr=self.lr, decay=self.lr_decay) loss = weighted_categorical_crossentropy(weights) self.model.compile(optimizer=adam, loss=loss def create_model(self): self.model = KerasClassifier(build_fn=self.build_model, epochs=self.epoch, batch_size=self.batch_size, verbose=1) def make_report(self,i, y_true, y_pred,city,method): data_frame = classification_report(y_true.argmax(axis=-1), y_pred.argmax(axis=-1), output_dict=True) df = pd.DataFrame(data_frame) df = df.reset_index() roc_dict = self.roc_auc(i,y_true, y_pred,city,method) df = df.append({'index': 'auc', '0': roc_dict[0], '1': roc_dict[1], 'micro avg': roc_dict['micro'], 'macro avg': roc_dict['macro']}, ignore_index=True) df = df.set_index('index') return df def roc_auc(self,i, y_test, y_score,city,method): fpr, tpr, roc_auc = roc_auc_compute(y_test, y_score) return roc_auc
def hybridModel(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(Dropout(0.2)) model.add(Conv1D(64, 5, activation='relu')) model.add(MaxPooling1D(pool_size=4)) model.add( Bidirectional(LSTM(numNeurons, return_sequences=False), merge_mode="sum")) model.add( Dense(2, activation='softmax', kernel_regularizer=regularizers.l2(0.001))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=[ 'accuracy', km.categorical_f1_score(), km.categorical_precision(), km.categorical_recall() ]) return model
def get_custom_metrics(): custom_metrics = [] custom_metrics.append(keras_metrics.categorical_f1_score()) custom_metrics.append(keras_metrics.categorical_precision()) custom_metrics.append(keras_metrics.categorical_recall()) custom_metrics = {m.__name__: m for m in custom_metrics} custom_metrics["sin"] = K.sin custom_metrics["abs"] = K.abs return custom_metrics
def compile_model(self, model=None): f1_score = km.categorical_f1_score(label=1) self.earlyStopping = EarlyStopping(monitor='val_f1_score', restore_best_weights=True, patience=patience, verbose=0, mode='max') adam = optimizers.Adam(lr=self.lr, decay=self.lr_decay) loss = weighted_categorical_crossentropy(weights) self.model.compile(optimizer=adam, loss=loss, metrics=[f1_score])
def test_on_images(network, images_dir, models_dir, *args): """""" print('Testing on images...') # Extract parameters from args img_width, img_height, batch_size, models_dir, figures_dir = args # Get image generators num_images_val, num_classes_val, val_gen = get_image_generator( network, images_dir, 'val', img_width, img_height, batch_size) num_images_test, num_classes_test, test_gen = get_image_generator( network, images_dir, 'test', img_width, img_height, batch_size) # Make sure val/test have the same number of classes assert num_classes_val == num_classes_test # Get network model for an image input shape input_shape = (img_width, img_height, 3) main_input = Input(shape=input_shape) base_model, last_layer_number = get_cnn_model(network, input_shape, main_input) x = base_model.output x = GlobalAveragePooling2D()(x) predictions = Dense(num_classes_val, activation='softmax')(x) model = Model(base_model.input, outputs=predictions) path = f'{models_dir}/{network}' models_list = glob(f'{path}/A*', ) net_id = f'{os.path.basename(models_dir)}A_' print('Loading model...') for h5_model in models_list: if gpu_number > 1: multi_gpu_model = load_model(h5_model, custom_objects={ 'categorical_f1_score': km.categorical_f1_score() }) model = multi_gpu_model.layers[-2] else: model.load_weights(h5_model) print('Validation') get_report(val_gen, num_images_val, num_classes_val, batch_size, model, 'val', network, net_id, figures_dir) print('Test') get_report(test_gen, num_images_test, num_classes_test, batch_size, model, 'test', network, net_id, figures_dir)
def load_model(model_path): precision = km.categorical_precision() recall = km.categorical_recall() f1_score = km.categorical_f1_score() model = keras.models.load_model(model_path, custom_objects={ 'AdaBound': AdaBound, 'categorical_precision': precision, 'categorical_recall': recall, 'categorical_f1_score': f1_score }) decay = LR_FINAL / EPOCHS optm = AdaBound(lr=0.001, final_lr=LR_FINAL, gamma=1e-03, weight_decay=decay, amsbound=False) return model
def get_metrics_fresh(metrics, nr_classes): """ Function takes a list of metrics and creates fresh tensors accordingly. This is necessary, after re-compiling the model because the placeholder has to be updated """ f1 = any(["f1_score" in str(a) for a in metrics]) precision = any(["precision" in str(a) for a in metrics]) recall = any(["recall" in str(a) for a in metrics]) Metrics = [] if f1 == True: for class_ in range(nr_classes): Metrics.append(keras_metrics.categorical_f1_score(label=class_)) if precision == True: for class_ in range(nr_classes): Metrics.append(keras_metrics.categorical_precision(label=class_)) if recall == True: for class_ in range(nr_classes): Metrics.append(keras_metrics.categorical_recall(label=class_)) metrics = ['accuracy'] + Metrics return metrics
def get_model(): input_tensor = Input(shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3)) base_model = Xception(input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3), include_top=False, weights=None, input_tensor=input_tensor, pooling='avg', classes=N_CLASSES) x = base_model.output predictions = Dense(N_CLASSES, activation='softmax')(x) model = keras.models.Model(inputs=base_model.input, outputs=predictions) decay = LR_FINAL / EPOCHS optm = AdaBound(lr=0.01, final_lr=LR_FINAL, gamma=1e-03, weight_decay=decay, amsbound=False) precision = km.categorical_precision() recall = km.categorical_recall() f1_score = km.categorical_f1_score() model.compile(optimizer=optm, loss='categorical_crossentropy', metrics=['accuracy', precision, recall, f1_score]) return model
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
def __init__(self, opts, output_size=1, filter_length=50, hidden_size=128, kernel_size=2): self.model = tf.keras.models.Sequential() loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction=tf.losses.Reduction.NONE) self.model.add(tf.keras.Input(opts['input_shape'])) self.model.add(tf.keras.layers.Reshape([1, opts['input_shape']])) self.model.add(tf.keras.layers.Conv1D(filter_length, kernel_size, padding='valid', activation='relu', strides=1, data_format='channels_first')) self.model.add(tf.keras.layers.GlobalMaxPooling1D(data_format='channels_first')) self.model.add(tf.keras.layers.Dense(hidden_size)) self.model.add(tf.keras.layers.Dropout(0.2)) self.model.add(tf.keras.layers.Dense(32, activation='relu')) self.model.add(tf.keras.layers.Dense(output_size, activation='softmax')) self.model.compile(loss=loss, optimizer='adam', metrics=['accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score()])
def test_combined(network, images_dir, csv_dir, csv_data, models_dir, *args): # Extract parameters from args img_width, img_height, batch_size, models_dir, figures_dir = args # Get image generators num_images_val, num_classes_val, features, val_gen = get_combined_generator( network, images_dir, csv_dir, csv_data, 'val', img_width, img_height, batch_size) num_images_test, num_classes_test, features, test_gen = get_combined_generator( network, images_dir, csv_dir, csv_data, 'test', img_width, img_height, batch_size) # Make sure val/test have the same number of classes assert num_classes_val == num_classes_test # Get network model for an image input shape input_shape = (img_width, img_height, 3) main_input = Input(shape=input_shape) base_model, last_layer_number = get_cnn_model(network, input_shape, main_input) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(512, activation='relu')(x) # Load Simple MLP aux_input = Input(shape=(features, )) aux = Dense(512, activation='relu')(aux_input) aux = Dropout(0.3)(aux) aux = Dense(512, activation='relu')(aux) aux = Dropout(0.3)(aux) aux = Dense(512, activation='relu')(aux) # Merge input models merge = concatenate([x, aux]) predictions = Dense(num_classes_val, activation='softmax')(merge) model = Model(inputs=[main_input, aux_input], outputs=predictions) path = f'{models_dir}/{network}' models_list = glob(f'{path}/B*', ) net_id = f'{os.path.basename(models_dir)}B_' for h5_model in models_list: if gpu_number > 1: multi_gpu_model = load_model( h5_model, custom_objects={ 'categorical_f1_score': km.categorical_f1_score() }, ) model = multi_gpu_model.layers[-2] else: model.load_weights(h5_model) get_report(val_gen, num_images_val, num_classes_val, batch_size, model, 'val', network, net_id, figures_dir) get_report(test_gen, num_images_val, num_classes_val, batch_size, model, 'test', network, net_id, figures_dir)
def apply_CNN(): # Importing the Keras libraries and packages from keras.models import Sequential from keras.layers import Convolution2D, BatchNormalization, Dropout from keras.layers import MaxPooling2D from keras.layers import Flatten from keras.layers import Dense #Imports for collecting metrics import keras_metrics as km import tensorflow as tf #import tensorflow.keras as keras # Initialising the CNN classifier = Sequential() # Step 1 - Convolution classifier.add( Convolution2D(32, 3, 3, input_shape=(64, 64, 3), activation='relu')) classifier.add(BatchNormalization()) # Step 2 - Pooling classifier.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) classifier.add(Dropout(0.2)) # Adding a second convolutional layer classifier.add(Convolution2D(32, 3, 3, activation='relu')) classifier.add(BatchNormalization()) classifier.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) classifier.add(Dropout(0.5)) classifier.add(Flatten()) # Step 4 - Full connection classifier.add(Dense(output_dim=128, activation='relu')) classifier.add(BatchNormalization()) classifier.add(Dropout(0.2)) classifier.add(Dense(output_dim=3, activation='softmax')) # catgorical # SET METRICS precision = km.categorical_precision() recall = km.categorical_recall() f1 = km.categorical_f1_score() classifier.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy', precision, recall, f1]) # Part 2 - Fitting the CNN to the images from keras.preprocessing.image import ImageDataGenerator train_datagen = ImageDataGenerator() test_datagen = ImageDataGenerator() seed = 7 training_set = train_datagen.flow_from_directory( 'training', target_size=(64, 64), batch_size=32, class_mode='categorical', shuffle=True, seed=seed) #,save_to_dir = 'generatedimages') #categorical,binary test_set = test_datagen.flow_from_directory('test', target_size=(64, 64), batch_size=32, class_mode='categorical', shuffle=True, seed=seed) #categorical,binary with tf.Session() as s: s.run(tf.global_variables_initializer()) classifier.fit_generator(training_set, samples_per_epoch=250, nb_epoch=35, validation_data=test_set, nb_val_samples=90, shuffle=True, verbose=2) return
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
def __init__(self, opts, output_size=1, hidden_size=128): self.model = tf.keras.models.Sequential() loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction=tf.losses.Reduction.NONE) self.model = tf.keras.Sequential() self.model.add(tf.keras.Input(opts['input_shape'])) self.model.add(tf.keras.layers.Reshape([1, opts['input_shape']])) self.model.add(tf.keras.layers.CuDNNLSTM(hidden_size)) self.model.add(tf.keras.layers.Dropout(0.3)) self.model.add(tf.keras.layers.Dense(32, activation='relu')) self.model.add(tf.keras.layers.Dense(output_size, activation='softmax')) self.model.compile(loss=loss, optimizer='adam', metrics=['accuracy', km.categorical_precision(), km.categorical_recall(), km.categorical_f1_score()])
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
#classifier.add(MaxPooling2D(pool_size = (2, 2))) #classifier.add(Dropout(0.2)) # Step 3 - Flattening classifier.add(Flatten()) # Step 4 - Full connection classifier.add(Dense(output_dim=128, activation='relu')) classifier.add(BatchNormalization()) classifier.add(Dropout(0.2)) #classifier.add(Dense(output_dim =1, activation = 'sigmoid'))# binary classifier.add(Dense(output_dim=3, activation='softmax')) # catgorical # SET METRICS precision = km.categorical_precision() recall = km.categorical_recall() f1 = km.categorical_f1_score() # Compiling the CNN #classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) classifier.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy', precision, recall, f1]) # # checkpoint filepath = "weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=True, mode='max') callbacks_list = [checkpoint]