def create_and_train_model(self, trainX, trainY, testX, testY, main_directory): start = datetime.datetime.now() # Update indiv_id pour avoir un vrai ID unique self.indiv_id = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") # Choix d'un emplacement pour les logs log_dir=main_directory+"\\logs_"+self.indiv_id+"\\tensorboard_data\\" tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1) print("log dir = ",log_dir) #ON VA GERER L1 ET L2, A L AVENIR IL FAUDRAIT MIEUX LES GERER DANS UNE FONCTION ? if self.l1 > 0: self.my_regularizer = regularizers.l1(self.l1 / self.nb_layers) elif self.l2 > 0: self.my_regularizer = regularizers.l2(self.l2 / self.nb_layers) else: self.my_reguralizer = 'he_uniform' # Definir notre modèle basique, 2 couches de conv et 1 pool avant tout model = Sequential() model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding, input_shape=(32, 32, 3))) model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding)) model.add(MaxPooling2D((2, 2))) # Faire toutes les convs nécessaires if self.nb_layers > 2: for i in range(2, self.nb_layers): if self.nb_layers - i != 1: print("i = ", i) # 2 conv + pool model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding)) model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding)) model.add(MaxPooling2D((2, 2))) else: # 1 conv + pool si nombre impair de couches (nb_layers) model.add(Conv2D(self.filters_per_layers, self.kernel, activation=self.activation, kernel_initializer=self.my_reguralizer, padding=self.padding)) model.add(MaxPooling2D((2, 2))) # Fin des convs -> neural network classique (je n'utilise pas self.activation car ce n'est pas relié a ce neural net) model.add(Flatten()) model.add(Dense(128, activation='relu', kernel_initializer=self.my_reguralizer)) model.add(Dense(10, activation='softmax')) # Compiler le modele opt = SGD(lr=0.001, momentum=0.9) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) #save model png plot_model(model, "model.png") # Entrainer le modele history = model.fit(trainX, trainY, epochs=self.epochs, batch_size=64, validation_data=(testX, testY), verbose=0, callbacks=[tensorboard_callback]) end = datetime.datetime.now() self.time_fit = end - start # J'arrive pas trop à le round, ça pourrait servir ! print("Time for fit = ", self.time_fit) # Deplacement modele au bon endroit shutil.move("C:\\Users\\arnau\\Desktop\\quatrième_année\\Deep_Learning\\Projet_cifar-10\\model.png", main_directory+"\\logs_"+self.indiv_id+"\\model.png") return history
outName = videoName[:-4] + '_' + str(qsize) + '.avi' modelname = 'phone_usage_DNN' modelpath = os.path.join('model', modelname + ".hdf5") pickpath = os.path.join('model', modelname + ".pickle") videopath = os.path.join('example_clips', videoName) outpath = os.path.join('output', outName) imgMean = np.array([123.68, 116.779, 103.939], dtype="float32") Q = deque(maxlen=qsize) # ........................................................................... print("Loading model and pickle files ...") lb = pickle.loads(open(pickpath, "rb").read()) optmz = SGD(lr=1e-4, momentum=0.9, decay=1e-4 / 25) #base = ResNet50(weights="imagenet", # include_top=False, # input_tensor=Input(shape=(224, 224, 3))) base = ResNet50(weights=None, include_top=False, input_tensor=Input(shape=(224, 224, 3))) def createModel(): h = base.output h = AveragePooling2D(pool_size=(7, 7))(h) h = Flatten(name="flatten")(h) h = Dense(512, activation="relu")(h)
activation='relu', strides=(2, 2), padding='same'), tf.keras.layers.BatchNormalization(axis=3), tf.keras.layers.Conv2D(48, (3, 3), activation='relu', strides=(2, 2), padding='same'), tf.keras.layers.BatchNormalization(axis=3), tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.001, decay=1e-6, momentum=0.9), metrics=['acc']) train_datagen = ImageDataGenerator(rescale=1 / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) validation_datagen = ImageDataGenerator(rescale=1 / 255) train_generator = train_datagen.flow_from_directory( r"D://Learning//tensorflow_2.0//data//train", # 训练集的根目录 target_size=(48, 48), # 所有图像的分辨率将被调整为48x48 batch_size=32, # 每次输入32个图像 # 类别模式设为二分类 class_mode='binary') # 对验证集做同样的操作
print('data.len=', len(data), 'labels.len=', len(labels)) # perform one-hot encoding on the labels and account for skew in the labeled data labels = to_categorical(labels, num_classes=config.CLASS_NUM) classTotals = labels.sum(axis=0) classWeight = classTotals.max() / classTotals # construct the training and testing split trainX, testX, trainY, testY = train_test_split(data, labels, test_size=config.TEST_SPLIT, random_state=42) print('trainX.len=', len(trainX), 'trainY.len=', len(trainY), 'testX.len=', len(testX), 'testY.len=', len(testY)) # initialize the training data augmentation object aug = ImageDataGenerator(rotation_range=30, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") print("[INFO] compiling model...") opt = SGD(lr=config.INIT_LR, momentum=0.9, decay=config.INIT_LR / config.NUM_EPOCHS) if os.path.exists(config.MODEL_PATH): print("[INFO] loading from ", config.MODEL_PATH) model = load_model(config.MODEL_PATH) else: model = DetectionNet.build(width=config.RESIZE_WH, height=config.RESIZE_WH, depth=3, classes=config.CLASS_NUM) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"]) # check to see if we are attempting to find an optimal learning rate # before training for the full number of epochs if args["lr_find"] > 0: # initialize the learning rate finder and then train with learning rates ranging from 1e-10 to 1e+1 print("[INFO] finding learning rate...") lrf = LearningRateFinder(model) lrf.find(aug.flow(trainX, trainY, batch_size=config.BATCH_SIZE), 1e-10, 1e+1, stepsPerEpoch=np.ceil((trainX.shape[0] / float(config.BATCH_SIZE))),
# start to become initialized with actual "learned" values # versus pure random print("[INFO] training head...") model.fit_generator(aug.flow(trainX, trainY, batch_size=32), validation_data=(testX, testY), epochs=20, steps_per_epoch=len(trainX) // 32, verbose=200) # evaluate the network after initialization print("[INFO] evaluating after initialization...") predictions = model.predict(testX, batch_size=32) print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=classNames)) print("[INFO] re-compiling model...") opt = SGD(lr=0.0001) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) # train the model again, this time fine-tuning *both* the final set # of CONV layers along with our set of FC layers print("[INFO] fine-tuning model...") H = model.fit_generator(aug.flow(trainX, trainY, batch_size=32), validation_data=(testX, testY), epochs=15, steps_per_epoch=len(trainX) // 32, verbose=1) for key in H.history.keys(): print(key) # evaluate the network on the fine-tuned model print("[INFO] evaluating after fine-tuning...")
from tensorflow.keras.optimizers import SGD # ----- network constants ----- # CIFAR_INPUT_SHAPE = (32, 32, 3) IMAGENET_INPUT_SHAPE = (224, 224, 3) BATCH_SIZE = 256 IMAGENET_EPOCH_SIZE = 1280000 IMAGENET_VALIDATION_SIZE = 50000 CIFAR_NUM_OF_CLASSES = 10 IMAGENET_NUM_OF_CLASSES = 1000 NUM_OF_CONV_LAYERS = 7 NUM_OF_CHANNELS = 128 KERNEL_SIZE = 5 NUM_OF_FC_LAYERS = 2 FC_SIZE = 256 CONV_ACTIVATION = 'relu' FC_ACTIVATION = 'relu' LAST_ACTIVATION = 'softmax' LEARNING_RATE = 0.001 OPTIMIZER = SGD(lr=LEARNING_RATE, momentum=0.9, nesterov=False) LOSS = 'categorical_crossentropy'
# x = AveragePooling2D(pool_size=(1,4))(x) x = Dense(1024, activation='relu')(x) x = Dense(1251, activation='softmax')(x) x = Reshape(target_shape=(1251,))(x) model = Model(inputs=input, outputs=x) """ model = saved_model.load_keras_model(save_dir + checkpoints[-1]) model = multi_gpu_model(model, gpus=G) # we need to recompile the model for these modifications to take effect # we use SGD with a low learning rate print("[INFO] Compiling Model ... ") from tensorflow.keras.optimizers import SGD rms = RMSprop() model.compile(optimizer=SGD(INIT_LR,0.99), loss=contrastive_loss, metrics=[accuracy]) # model.compile(optimizer=RMSprop(lr=INIT_LR), loss='categorical_crossentropy',metrics=['accuracy']) print("[INFO] Loading Data... ") filename = "data4/data1.txt" filename2 = "data4/labels1.txt" counter = 1 le = preprocessing.LabelEncoder() start = time.time() filename2 = filename2[:-4 - len(str(counter - 1))] + str(counter) + filename2[-4:] data = np.memmap('pairs_data.array', dtype=np.float64, mode='r+', shape=(294343, 2, 100, 40, 3)) labels = np.memmap('pairs_labels.array', dtype= np.float64, mode= 'r+', shape= (294343, ))
def buildGraph(self): optimizer = SGD(lr=self.config['lr'], decay=self.config['decay'], momentum=0.9) self.model.compile(loss=self.config['loss'], #'binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
precision = true_positives / (predicted_positives + K.epsilon()) return precision pipe = make_pipeline( RandomUnderSampler(sampling_strategy=0.2, random_state=42), SVMSMOTE(sampling_strategy=0.7, n_jobs=12, random_state=42)) start = datetime.datetime.now() print(f"{start} : over sampling......") print(f"1 : {np.sum(y_train)}, 0 :{len(y_train)- np.sum(y_train)}") x_tmp, y_tmp = pipe.fit_resample(x_train, y_train) print(f"sampling : {datetime.datetime.now() - start}") print(f"1 : {np.sum(y_tmp)}, 0 :{len(y_tmp)- np.sum(y_tmp)}") sgd = SGD(lr=0.0002, momentum=0.9, decay=10e-6, nesterov=True) adam = Adam(lr=1e-4, decay=1e-6) rmsprop = RMSprop(lr=1e-5, epsilon=1.0) amsgrad = Adam(lr=1e-5, decay=1e-6, amsgrad=True) adagrad = Adagrad(lr=1e-5, decay=1e-6) nadam = Nadam(lr=0.002, beta_1=0.9, beta_2=0.999, epsilon=None, schedule_decay=0.004) adadelta = Adadelta(lr=1., rho=0.95, epsilon=None, decay=0.0) model = dnn_model(x_train.shape[1], FEATURE_SIZE) # model = chunje_1(x_train.shape[1]) model.compile(optimizer=adadelta, loss='binary_crossentropy',
equal = tf.cast(predicted == truth, tf.int32) return tf.math.reduce_sum(equal).numpy() / equal.shape[0] def accuracy_metrics(truth, logits): acc = accuracy(truth, logits) return {'accuracy': acc} if __name__ == '__main__': cifar10 = tf.keras.datasets.cifar10 (x_train, y_train), (x_valid, y_valid) = cifar10.load_data() x_train, x_valid = x_train / 255.0, x_valid / 255.0 train_set = (x_train, y_train) valid_set = (x_valid, y_valid) net = Net() trainer = EnasTrainer( net, loss=SparseCategoricalCrossentropy(from_logits=True, reduction=Reduction.NONE), metrics=accuracy_metrics, reward_function=accuracy, optimizer=SGD(learning_rate=0.001, momentum=0.9), batch_size=64, num_epochs=2, dataset_train=train_set, dataset_valid=valid_set ) trainer.train()
#logging.info("1111111111111111111111111") strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy( tf.distribute.experimental.CollectiveCommunication.AUTO, ) #logging.info("222222222222222222222222222") with strategy.scope(): model = Sequential() model.add(Dense(8, input_dim=2)) model.add(Activation('tanh')) model.add(Dense(1)) model.add(Activation('sigmoid')) sgd = SGD(lr=0.1) model.compile(loss='binary_crossentropy', optimizer=sgd) #logging.info("333333333333333333333333333") def fit(events): logging.info("4444444444444444444444") input_tensors = np.array([[ int(e["i1"]), int(e["i2"]), ] for e in events]) output_tensors = np.array([[ int(e["o"]), ] for e in events])
def fit_model(x_train, y_train, epochs = 100, batch_size = 1024): # convolutional layers for time-series ts = Sequential([ Input(shape = (130,1)), # 1st set of convolution layer (96 -> MaxPool -> Dropout) Conv1D(filters = 96, kernel_size = 6, strides = 4, padding = "valid", kernel_initializer = GlorotNormal()), Activation(tf.keras.activations.relu), MaxPooling1D(pool_size = 2, strides = 2, padding = "valid"), # 2nd set of convolutional layer (256 -> MaxPool) Conv1D(filters = 256, kernel_size = 5, strides = 1, padding = "same", kernel_initializer = GlorotNormal()), Activation(tf.keras.activations.relu), MaxPooling1D(pool_size = 2, strides = 2, padding = "valid"), # 3rd set of convolutional layer (384 -> 384 -> 256 -> MaxPool) Conv1D(filters = 384, kernel_size = 3, strides = 1, padding = "same", kernel_initializer = GlorotNormal()), Activation(tf.keras.activations.relu), Conv1D(filters = 384, kernel_size = 3, strides = 1, padding = "same", kernel_initializer = GlorotNormal()), Activation(tf.keras.activations.relu), Conv1D(filters = 256, kernel_size = 3, strides = 1, padding = "same", kernel_initializer = GlorotNormal()), Activation(tf.keras.activations.relu), MaxPooling1D(pool_size = 3, strides = 2, padding = "valid"), # Flatten layer Flatten() ]) # regular layer for weight w = Sequential([ Input(shape = (1,)), Dense(units = 4, kernel_initializer = GlorotNormal()) ]) # concatenate ts and w model_concat = Concatenate(axis = -1)([ts.output, w.output]) # 1st set of layers (256 -> Dropout -> 256 -> Dropout ) model_concat = Dense(units = 256, kernel_initializer = GlorotNormal())(model_concat) model_concat = BatchNormalization()(model_concat) model_concat = Activation(tf.keras.activations.relu)(model_concat) model_concat = Dropout(0.2)(model_concat) model_concat = Dense(units = 256, kernel_initializer = GlorotNormal())(model_concat) model_concat = BatchNormalization()(model_concat) model_concat = Activation(tf.keras.activations.relu)(model_concat) model_concat = Dropout(0.2)(model_concat) # output layer model_concat = Dense(units = 1, activation = "sigmoid")(model_concat) # define full model model = Model(inputs = [ts.input, w.input], outputs = model_concat) # fit model opt = SGD(learning_rate = 0.05, momentum = 0.9, decay = 0.0005) model.compile( loss = "binary_crossentropy", optimizer = opt, metrics = [tf.keras.metrics.AUC(name="AUC"), "accuracy"] ) history = model.fit( x = x_train, y = y_train, epochs = epochs, batch_size = batch_size, validation_split = 0.2, callbacks = [EarlyStopping('accuracy', patience=10, restore_best_weights = True)], verbose = 2 ) return model, history
def model_CrossingDetection_OrderPrediction_SIAMESE_NTL( the_input_shape, units_dense_layer_1, units_dense_layer_2, dropout_rate_1, dropout_rate_2, learning_rate, momentum): # Se definen las 4 entradas del modelo input_1 = Input(shape=the_input_shape) input_2 = Input(shape=the_input_shape) input_3 = Input(shape=the_input_shape) input_4 = Input(shape=the_input_shape) #CaffeNet base_model = Sequential() base_model.add( Conv2D(filters=96, kernel_size=(11, 11), strides=(4, 4), padding='valid', data_format='channels_last', activation='relu', input_shape=the_input_shape, name='Conv2D_1_CaffeNet')) base_model.add( MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', data_format='channels_last', name='MaxPooling2D_1_CaffeNet')) base_model.add(BatchNormalization()) base_model.add( Conv2D(filters=256, kernel_size=(5, 5), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_2_CaffeNet')) base_model.add( MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', data_format='channels_last', name='MaxPooling2D_2_CaffeNet')) base_model.add(BatchNormalization()) base_model.add( Conv2D(filters=384, kernel_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_3_CaffeNet')) base_model.add( Conv2D(filters=384, kernel_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_4_CaffeNet')) base_model.add( Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', data_format='channels_last', activation='relu', name='Conv2D_5_CaffeNet')) base_model.add( MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid', data_format='channels_last', name='MaxPooling2D_3_CaffeNet')) # Las 4 entradas son pasadas a través del modelo base (calculo de las distintas convoluciones) output_1 = base_model(input_1) output_2 = base_model(input_2) output_3 = base_model(input_3) output_4 = base_model(input_4) flatten_1 = Flatten(name='Flatten_1_FINAL') # Se obtienen los vectores de características de las 4 entradas features_1 = flatten_1(output_1) features_2 = flatten_1(output_2) features_3 = flatten_1(output_3) features_4 = flatten_1(output_4) # Capa densa utilizada para resumir las caracteristicas extraidas de las capas convolucionales para cada frame dense_1 = Dense(units=units_dense_layer_1, activation='relu', name='FC_1_FINAL') features_1 = dense_1(features_1) features_2 = dense_1(features_2) features_3 = dense_1(features_3) features_4 = dense_1(features_4) dropout_1 = Dropout(rate=dropout_rate_1, name='Dropout_1_FINAL') features_1 = dropout_1(features_1) features_2 = dropout_1(features_2) features_3 = dropout_1(features_3) features_4 = dropout_1(features_4) Features_12 = concatenate([features_1, features_2]) Features_13 = concatenate([features_1, features_3]) Features_14 = concatenate([features_1, features_4]) Features_23 = concatenate([features_2, features_3]) Features_24 = concatenate([features_2, features_4]) Features_34 = concatenate([features_3, features_4]) # Capa densa que aprende la relación entre las características de los distintos fotogramas dense_2 = Dense(units=units_dense_layer_2, activation='relu', name='FC_2_FINAL') RelationShip_1_2 = dense_2(Features_12) RelationShip_1_3 = dense_2(Features_13) RelationShip_1_4 = dense_2(Features_14) RelationShip_2_3 = dense_2(Features_23) RelationShip_2_4 = dense_2(Features_24) RelationShip_3_4 = dense_2(Features_34) dropout_2 = Dropout(rate=dropout_rate_2, name='Dropout_2_FINAL') RelationShip_1_2 = dropout_2(RelationShip_1_2) RelationShip_1_3 = dropout_2(RelationShip_1_3) RelationShip_1_4 = dropout_2(RelationShip_1_4) RelationShip_2_3 = dropout_2(RelationShip_2_3) RelationShip_2_4 = dropout_2(RelationShip_2_4) RelationShip_3_4 = dropout_2(RelationShip_3_4) # Concatenación de todas las relaciones Features_Final = concatenate([ RelationShip_1_2, RelationShip_1_3, RelationShip_1_4, RelationShip_2_3, RelationShip_2_4, RelationShip_3_4 ]) prediction = Dense(units=2, activation='softmax', name='FC_Final_FINAL')(Features_Final) siamese_model = Model(inputs=[input_1, input_2, input_3, input_4], outputs=prediction) siamese_model.summary() optimizer = SGD(learning_rate=learning_rate, momentum=momentum) siamese_model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=[ 'accuracy', tf.keras.metrics.AUC(), tf.keras.metrics.Precision(), tf.keras.metrics.Recall() ]) return siamese_model
##--------------------------- SETTING AREA ------------------------------## loading = instant_data() df, mode = loading.hourly_instant(), 'hour' # df,mode = loading.daily_instant(),'day' if mode == 'hour': n_past, n_future = 24 * 7, 72 elif mode == 'day': n_past, n_future = 60, 30 st = 'CPY012' target, start_p, stop_p, host_path = station_sel(st, mode) #------------ DL PARAMETER ---------------------# callback_early_stopping = EarlyStopping(monitor='val_loss', patience=5, verbose=2) reduce_lr = tf.keras.callbacks.LearningRateScheduler(lambda x: 1e-5 * 0.90**x) callbacks = [callback_early_stopping, reduce_lr] my_optimizer = SGD(lr=0.01, decay=0, momentum=0.9, nesterov=True) #--------------------------- 2 Yr Edit -----------------------------------# host_path = './CPY012/2Yr_flood/' start_p = '2016-01-01' split_date = '2017-05-10' stop_p = '2018-01-01' n_pca = 7 #-----------------------Baseline / Hybrid -----------------------------------# save_path = host_path + 'Wavelet_exp2' import os if not os.path.exists(save_path): os.makedirs(save_path) #----------------------------------------------------------# #Split XY
def main(): """ A function for running text classification of GoT texts from the terminal """ # loading data data = pd.read_csv(os.path.join("..", "data", "raw","Game_of_Thrones_Script.csv")) # gathering all lines from a given character by a seson an episode to context and model's accuracy data = data.groupby(["Season", "Episode", "Name"]) data = data["Sentence"].agg(lambda x: " ".join(x)).to_frame() data = data.reset_index().rename(columns ={"Sentence": "Text"}) #resetting index # train and test split using sklearn X_train, X_test, y_train, y_test = train_test_split(data.Text, data["Season"], test_size=0.1, random_state=random_state) print("Data loaded and split") ### a baseline model of a logistic regresssion ### print("fitting baseline LogReg model") pipe = Pipeline(steps=[ ('tfidf', TfidfVectorizer()), ('clf', LogisticRegression(solver = "liblinear",random_state = random_state)) ]) # report model metrict classifier = pipe.fit(X_train, y_train) y_pred = classifier.predict(X_test) classifier_metrics_lr = metrics.classification_report(y_test, y_pred) print(classifier_metrics_lr) # save the classification report filepath = os.path.join("..","models","LG_metrics.txt") text_file = open(filepath, "w") text_file.write(classifier_metrics_lr) text_file.close() ### Building network ### # integers to one-hot vectors lb = LabelBinarizer() y_train_bin = lb.fit_transform(y_train) y_test_bin = lb.fit_transform(y_test) # the nn will have a vocabulary size of 15000 maxlen = 15000 vectorizer = TfidfVectorizer(ngram_range=(1,2), max_features = maxlen) X_train_feats = vectorizer.fit_transform(X_train).toarray() X_test_feats = vectorizer.transform(X_test).toarray() # l2 regularization l2 = L2(0.00001) # a new neural network model = Sequential() model.add(Dense(64, activation='relu', kernel_regularizer=l2,input_shape=(maxlen,))) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Dense(8, activation='softmax')) # compiler model.compile(loss='categorical_crossentropy', optimizer= SGD(learning_rate= .01), metrics=['accuracy']) epochs = 10 print(model.summary()) achitecture_path = os.path.join("..","models","nn_model_architecture.png") #plot model plot_model(model, to_file = achitecture_path, show_shapes=True, show_layer_names=True) print(f"Image of model architecture saved in {achitecture_path}") print("fitting nn-model") # a fit history of the network history = model.fit(X_train_feats, y_train_bin, epochs=epochs, verbose=True, validation_data=(X_test_feats, y_test_bin)) # plot history plot_history(history, epochs = epochs) predictions=model.predict(X_test_feats, verbose=True) # get the class with highest probability for each sample y_pred = np.argmax(predictions, axis=1) le = LabelEncoder() y_test_int = le.fit_transform(y_test) #encode labels for the classification report # get the classification report metrics_nn = metrics.classification_report(y_test_int, y_pred, target_names = y_test.sort_values().unique()) print(metrics_nn) # save metrics filepath = os.path.join("..","models","NN_metrics.txt") text_file = open(filepath, "w") text_file.write(metrics_nn) text_file.close() print("We will now use grid search and crossvalidation to find a better model using an SGD-classifier") # Grid Search for SGD Classifier (stochastic gradient classifier) ## making a pipeline where we use two embedding methods to find out the best one pipe = Pipeline(steps=[ ('tfidf', TfidfVectorizer()), ('clf', SGDClassifier(random_state = random_state)) ]) ## specifying parameters = { 'tfidf__ngram_range': [(1, 1), (1, 2),(1,3)], 'tfidf__max_df': [1.0, 0.95,0.9,0.85], 'tfidf__min_df': [0.0, 0.05], 'clf__alpha': [1e-3, 1e-2, 1e-1], # learning rate 'clf__penalty': ['l2'], } search = GridSearchCV(pipe, parameters, n_jobs = -1, verbose = 1, refit = True) gs_clf = search.fit(X_train, y_train) print(f"The best{gs_clf.best_score_}") print(f"The best model hyper parameters: {gs_clf.best_params_}") y_pred = gs_clf.predict(X_test) classifier_metrics_sgd = metrics.classification_report(y_test, y_pred) print(classifier_metrics_sgd) # get the classification report filepath = os.path.join("..","models", "SGD_metrics.txt") text_file = open(filepath, "w") text_file.write(classifier_metrics_sgd) text_file.close()
elif K.image_data_format() == "channels_last": X_train = X_train.reshape((X_train.shape[0], 32, 32, 1)) X_test = X_test.reshape((X_test.shape[0], 32, 32, 1)) X_train = X_train.astype("float32") / 255.0 X_test = X_test.astype("float32") / 255.0 lb = LabelBinarizer() y_train = lb.fit_transform(y_train) y_train = to_categorical(y_train) y_test = lb.transform(y_test) y_test = to_categorical(y_test) opt = SGD(lr=0.01) model = LeNet.build(width=32, height=32, depth=1, classes=2) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) H = model.fit(X_train, y_train, validation_data=(X_test, y_test), batch_size=32, epochs=20, verbose=1) predictions = model.predict(X_test, batch_size=32) print( classification_report(y_test.argmax(axis=1),
def train_semantic_segmentation(normalize, img_list, label_list, x_scale, y_scale, z_scale, crop_data, path_to_model, z_patch, y_patch, x_patch, epochs, batch_size, channels, validation_split, stride_size, balance, flip_x, flip_y, flip_z, rotate, image, early_stopping, val_tf, validation_freq, cropping_weights, cropping_config): # training data img, label, position, allLabels, configuration_data, header, extension, number_of_images, counts = load_training_data(normalize, img_list, label_list, channels, x_scale, y_scale, z_scale, crop_data) # force validation_split for large number of training images if number_of_images > 20: if validation_split == 0: validation_split = 0.8 early_stopping = True # img shape zsh, ysh, xsh = img.shape # validation data if validation_split: number_of_images = zsh // z_scale split = round(number_of_images * validation_split) img_val = np.copy(img[split*z_scale:]) label_val = np.copy(label[split*z_scale:]) img = np.copy(img[:split*z_scale]) label = np.copy(label[:split*z_scale]) zsh, ysh, xsh = img.shape if channels == 2: position_val = np.copy(position[split*z_scale:]) position = np.copy(position[:split*z_scale]) # img_val shape zsh_val, ysh_val, xsh_val = img_val.shape # list of validation IDs list_IDs_val = [] # get validation IDs of patches for k in range(0, zsh_val-z_patch+1, stride_size): for l in range(0, ysh_val-y_patch+1, stride_size): for m in range(0, xsh_val-x_patch+1, stride_size): list_IDs_val.append(k*ysh_val*xsh_val+l*xsh_val+m) # make length of list divisible by batch size rest = batch_size - (len(list_IDs_val) % batch_size) list_IDs_val = list_IDs_val + list_IDs_val[:rest] # list of IDs list_IDs = [] # get IDs of patches for k in range(0, zsh-z_patch+1, stride_size): for l in range(0, ysh-y_patch+1, stride_size): for m in range(0, xsh-x_patch+1, stride_size): list_IDs.append(k*ysh*xsh+l*xsh+m) # number of labels nb_labels = len(allLabels) # input shape input_shape = (z_patch, y_patch, x_patch, channels) # parameters params = {'batch_size': batch_size, 'dim': (z_patch, y_patch, x_patch), 'dim_img': (zsh, ysh, xsh), 'n_classes': nb_labels, 'n_channels': channels, 'class_weights': False, 'augment': (flip_x, flip_y, flip_z, rotate)} # data generator validation_generator = None training_generator = DataGenerator(img, label, position, list_IDs, counts, True, **params) if validation_split: if val_tf: params['dim_img'] = (zsh_val, ysh_val, xsh_val) params['augment'] = (False, False, False, 0) validation_generator = DataGenerator(img_val, label_val, position_val, list_IDs_val, counts, False, **params) else: metrics = Metrics(img_val, label_val, list_IDs_val, (z_patch, y_patch, x_patch), (zsh_val, ysh_val, xsh_val), batch_size, path_to_model, early_stopping, validation_freq, nb_labels) # optimizer sgd = SGD(learning_rate=0.01, decay=1e-6, momentum=0.9, nesterov=True) # create a MirroredStrategy if os.name == 'nt': cdo = tf.distribute.HierarchicalCopyAllReduce() else: cdo = tf.distribute.NcclAllReduce() strategy = tf.distribute.MirroredStrategy(cross_device_ops=cdo) print('Number of devices: {}'.format(strategy.num_replicas_in_sync)) # compile model with strategy.scope(): model = make_unet(input_shape, nb_labels) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) # save meta data meta_data = MetaData(path_to_model, configuration_data, allLabels, extension, header, crop_data, cropping_weights, cropping_config) # model checkpoint if validation_split: if val_tf: model_checkpoint_callback = ModelCheckpoint( filepath=str(path_to_model), save_weights_only=False, monitor='val_accuracy', mode='max', save_best_only=True) callbacks = [model_checkpoint_callback, CustomCallback(image.id,epochs), meta_data] if early_stopping: callbacks.insert(0, EarlyStopping(monitor='val_accuracy', mode='max', patience=10)) else: callbacks = [metrics, CustomCallback(image.id,epochs), meta_data] else: callbacks = [ModelCheckpoint(filepath=str(path_to_model)), CustomCallback(image.id,epochs), meta_data] # train model model.fit(training_generator, epochs=epochs, validation_data=validation_generator, callbacks=callbacks)
cv2.destroyAllWindows() if __name__ == '__main__': parser = argparse.ArgumentParser( description='Facial expression recognition for demo') parser.add_argument('--one-image', dest='method', default='realtime', help='predict from one image in local storage') args = parser.parse_args() print("Loading Residual Masking Network model...") model = ResMaskingNet(input_shape=(48, 48, 3), classes=7) model.compile(optimizer=SGD(lr=1e-2, decay=1e-6, momentum=0.9, nesterov=True), loss='categorical_crossentropy', metrics=['accuracy']) model.load_weights("residual_masking_71_best.h5") print("========Completed load model========") face_decade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') if args.method == 'realtime' or args.method == '': print("Recognizing real-time...") predict_real_time(model, face_decade) else: print("Recognizing one image...") predict_one_pic(args.method, model, face_decade)
def one_hot_cnn(dense_out, max_len=300, frame='small'): """ Temporal CNN Model As defined in "Text Understanding from Scratch" by Zhang, LeCun 2015 https://arxiv.org/pdf/1502.01710v4.pdf This model is a series of 1D CNNs, with a maxpooling and fully connected layers. The frame sizes may either be large or small. Args: dense_out (int): size out the output dense layer, this is the number of classes max_len (int): length of the input text frame (str): frame size, either large or small Returns: model (model): temporal CNN model """ if frame == 'large': cnn_size = 1024 fully_connected = [2048, 2048, dense_out] else: cnn_size = 256 fully_connected = [1024, 1024, dense_out] model = Sequential() model.add(Conv1D(cnn_size, 7, padding='same', input_shape=(68, max_len))) model.add(MaxPooling1D(pool_size=3)) print(model.output_shape) # Input = 22 x 256 model.add(Conv1D(cnn_size, 7, padding='same')) model.add(MaxPooling1D(pool_size=3)) print(model.output_shape) # Input = 7 x 256 model.add(Conv1D(cnn_size, 3, padding='same')) # Input = 7 x 256 model.add(Conv1D(cnn_size, 3, padding='same')) model.add(Conv1D(cnn_size, 3, padding='same')) # Input = 7 x 256 model.add(Conv1D(cnn_size, 3, padding='same')) model.add(MaxPooling1D(pool_size=3)) model.add(Flatten()) # Fully Connected Layers # Input is 512 Output is 1024/2048 model.add(Dense(fully_connected[0])) model.add(Dropout(0.75)) model.add(Activation('relu')) # Input is 1024/2048 Output is 1024/2048 model.add(Dense(fully_connected[1])) model.add(Dropout(0.75)) model.add(Activation('relu')) # Input is 1024/2048 Output is dense_out size (number of classes) model.add(Dense(fully_connected[2])) model.add(Activation('softmax')) # Stochastic gradient parameters as set by paper sgd = SGD(lr=0.01, decay=1e-5, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) return model
def __init__(self, nrows, ncols): self.nrows = nrows self.ncols = ncols wr = 0.00001 # l1 regularizer value dp = 0.125 # dropout rate model = models.Sequential() # speed, accel, distance, angle #real_in = Input(shape=(2,), name='real_input') #video fram frame_in = Input(shape=(3, nrows, ncols), name='img_input') print("adding first convolutional layer") #5x5 convolutional layer with a stride of 2 model.add( Conv2D(24, (5, 5), input_shape=(nrows, ncols, 3), strides=(2, 2), activation='elu', padding='same', kernel_initializer='lecun_uniform')) model.add(Dropout(dp)) print("adding second convolutional layer") #5x5 convolutional layer with a stride of 2 model.add( Conv2D(32, (5, 5), strides=(2, 2), activation='elu', padding='same', kernel_initializer='lecun_uniform')) model.add(Dropout(dp)) print("adding third convolutional layer") #5x5 convolutional layer with a stride of 2 model.add( Conv2D(40, (5, 5), strides=(2, 2), activation='elu', padding='same', kernel_initializer='lecun_uniform')) model.add(Dropout(dp)) print("adding fourth convolutional layer") #3x3 convolutional layer with no stride model.add( Conv2D(48, (3, 3), strides=(2, 2), activation='elu', padding='same', kernel_initializer='lecun_uniform')) model.add(Dropout(dp)) print("adding fifth convolutional layer") #3x3 convolutional layer with no stride model.add( Conv2D(48, (3, 3), strides=(2, 2), activation='elu', padding='same', kernel_initializer='lecun_uniform')) model.add(Dropout(dp)) model.add(Flatten()) print("adding fully connected layer") #fully connected layer model.add( Dense(100, activation='elu', kernel_initializer='lecun_uniform')) model.add(Dropout(dp)) #M = merge([flat,real_in], mode='concat', concat_axis=1) print("adding output layer") #fully connected layer to output node model.add( Dense(1, activation='linear', kernel_initializer='lecun_uniform')) model.compile(loss=['mse'], optimizer=SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True), metrics=['mse']) print(model.summary())
def _test_async_correctness( self, grads_and_vars_batches, embed_values, expected_non_embed_values, expected_embed_values=None, ): """Checks the correctness of async OptimizerWrapper. This function creates many threads and these threads call `OptimizerWrapper.apply_gradients` simultaneously. Args: grads_and_vars_batches: A python list of `grads_and_vars`. Every thread takes a `grads_and_vars` and calls `apply_gradients`. embed_values: A python dictionary of `(layer_name, embedding table)`. expected_non_embed_values: A python list of expected non-embdding values after applying gradients. expected_embed_values: A python dictionary of expected embedding values after applying gradients. None means no need to check embedding values. """ thread_num = len(grads_and_vars_batches) input_dims = {} embed_var_n = len(embed_values) params = Parameters() for layer, values in embed_values.items(): embed_dim = values.shape[1] input_dims[layer] = values.shape[0] embed_table = EmbeddingTable(layer, embed_dim) embed_table.set(range(input_dims[layer]), values) params.embedding_params[layer] = embed_table opt = SGD(0.1) opt_wrapper = OptimizerWrapper( opt, True, lookup_embedding_func=params.get_embedding_param, update_embedding_func=params.set_embedding_param, ) # call optimizer_wrapper.apply_gradients asynchronously def _apply_gradients(opt_wrapper, grads_and_vars): # sleep 1s to wait that all threads are in this method call time.sleep(1) opt_wrapper.apply_gradients(grads_and_vars) executor = ThreadPoolExecutor(max_workers=thread_num) tasks = [ executor.submit(_apply_gradients, opt_wrapper, grads_and_vars) for grads_and_vars in grads_and_vars_batches ] _ = [task.result() for task in tasks] # check updated results of non-embedding variables non_embed_vars = [ var for grad, var in grads_and_vars_batches[0][:-embed_var_n] ] for var, expected_value in zip(non_embed_vars, expected_non_embed_values): self.assertTrue(np.isclose(var.numpy(), expected_value).all()) # `expected_embed_values=None` means that no need to check # embedding table if not expected_embed_values: return # check updated results of embedding table for layer, expected_values in expected_embed_values.items(): value = params.get_embedding_param(layer, range(input_dims[layer])) self.assertTrue( any([ np.isclose(value, expected).all() for expected in expected_values ]))
# example of a 3-block vgg style architecture model = Sequential() model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same', input_shape=(32, 32, 3))) model.add(Conv2D(32, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same')) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same')) model.add(Conv2D(64, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same')) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same')) model.add(Conv2D(128, (3, 3), activation='relu', kernel_initializer='he_uniform', padding='same')) model.add(MaxPooling2D((2, 2))) model.add(Flatten()) model.add(Dense(128, activation='relu', kernel_initializer='he_uniform')) model.add(Dense(10, activation='softmax')) # compile model opt = SGD(lr=0.001, momentum=0.9) model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(train_images, train_labels, epochs=50, batch_size=64, validation_data=(test_images, test_labels), verbose=0) model.save("cifar.h5") plt.plot(history.history['accuracy'], label='accuracy') plt.plot(history.history['val_accuracy'], label = 'val_accuracy') plt.xlabel('Epoch') plt.ylabel('Accuracy') plt.ylim([0.5, 1]) plt.legend(loc='lower right')
import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Flatten, Dense from tensorflow.keras.optimizers import SGD, Adam import numpy as np print(tf.__version__) x_data = np.array([[1, 2, 0], [5, 4, 3], [1, 2, -1], [3, 1, 0], [2, 4, 2], [4, 1, 2], [-1, 3, 2], [4, 3, 3], [0, 2, 6], [2, 2, 1], [1, -2, -2], [0, 1, 3], [1, 2, 3], [0, 2, 4], [2, 3, 3]]) t_data = np.array([-4, 4, -6, 3, -4, 9, -7, 5, 6, 0, 4, 3, 5, 5, 1]) print('x_data_dhape=', x_data.shape, ',t_data_shape=', t_data.shape) model = Sequential() model.add(Dense(1, input_shape=(3, ), activation='linear')) model.compile(optimizer=SGD(learning_rate=1e-2), loss='mse') model.summary() model.fit(x_data, t_data, epochs=1000) test_data = [[5, 5, 0], [2, 3, 1], [-1, 0, -1], [10, 5, 2], [4, -1, -2]] ret_val = [2 * data[0] - 3 * data[1] + 2 * data[2] for data in test_data] predict_val = model.predict(np.array(test_data)) print(predict_val) print('--------------------') print(ret_val)
ap.add_argument("-o", "--output", required=True, help="path to output") args = vars(ap.parse_args()) print("[INFO] loading CIFAR-10 data...") ((trainX, trainY), (testX, testY)) = cifar10.load_data() trainX = trainX.astype("float") / 255.0 testX = testX.astype("float") / 255.0 lb = LabelBinarizer() trainY = lb.fit_transform(trainY) testY = lb.transform(testY) labelNames = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"] print("[INFO] compiling model...") opt = SGD(lr=0.01, decay=0.01/40, momentum=0.9, nesterov=True) model = MiniVGGNet.build(width=32, height=32, depth=3, classes=10) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) print("[INFO] training network...") H = model.fit(trainX, trainY, validation_data=(testX, testY), batch_size=24, epochs=40, verbose=1) print("[INFO] evaluating network...") predictions = model.predict(testX, batch_size=64) print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=labelNames)) plt.style.use("ggplot") plt.figure() plt.plot(np.arange(0, 40), H.history["loss"], label="train_loss") plt.plot(np.arange(0, 40), H.history["val_loss"], label="val_loss") plt.plot(np.arange(0, 40), H.history["accuracy"], label="train_acc")
def train_wrn(data_generator, file_name, num_epochs=200, debug=True, gpus=None, initial_epoch=0, initial_model=None, data_format=None, rand_spike=0, dropout=0.0, train_temp=1): # For WRN-16-8 put N = 2, k = 8 # For WRN-28-10 put N = 4, k = 10 # For WRN-40-4 put N = 6, k = 4 def _create_model(): return wrn.create_wide_residual_network(data.train_data.shape[1:], nb_classes=10, N=4, k=10, dropout=dropout, weight_decay=0.0005, output_logits=True, input_data_format=data_format, data_format=data_format, rand_spike=rand_spike) devices = get_available_gpus() devices_len = len(devices) if gpus is None: gpus = [] elif isinstance(gpus, list): pass elif isinstance(gpus, int): gpus = list(range(gpus)) else: raise ValueError('number of gpus is either list or int') if devices_len >= 2 and len(gpus) >= 2: with tf.device('/cpu:0'): _model = _create_model() _model_multi = multi_gpu_model(_model, gpus) else: _model = _create_model() _model_multi = _model # learning rate schedule lr_schedule = [60, 120, 160, 180] # epoch_step def schedule(epoch_idx): if (epoch_idx + 1) < lr_schedule[0]: return 0.1 elif (epoch_idx + 1) < lr_schedule[1]: return 0.02 # lr_decay_ratio = 0.2 elif (epoch_idx + 1) < lr_schedule[2]: return 0.004 elif (epoch_idx + 1) < lr_schedule[3]: return 0.0008 return 0.0008 def fn(correct, predicted): return tf.nn.softmax_cross_entropy_with_logits(labels=correct, logits=predicted/train_temp) sgd = SGD(lr=0.1, decay=0, momentum=0.9, nesterov=True) if initial_epoch > 0: _model_multi.load_weights(initial_model) _model_multi.compile(loss=fn, optimizer=sgd, metrics=['accuracy']) _model.summary() log_path = file_name + "_log" checkpoint_path = os.path.join(log_path, "checkpoint") if not os.path.exists(checkpoint_path): os.makedirs(checkpoint_path) _model_multi.fit_generator(data_generator, steps_per_epoch=len(data_generator), validation_data=(data.validation_data, data.validation_labels), epochs=num_epochs, initial_epoch=initial_epoch, callbacks=[ LearningRateScheduler(schedule=schedule), SGDLearningRateTracker(), ModelCheckpoint(os.path.join( checkpoint_path, 'weights.{epoch:02d}-{val_acc:.2f}-{val_loss:.2f}.hdf5'), monitor='val_acc', verbose=1, save_best_only=True, save_weights_only=True, mode='auto') ], shuffle=True) if debug: plot_model(_model, os.path.join(log_path, "WRN-{0}-{1}.png".format(28, 10)), show_shapes=True, show_layer_names=True) with open(os.path.join(log_path, 'WRN-{0}-{1}.json'.format(28, 10)), 'w') as f: f.write(_model.to_json()) f.close() if file_name is not None: _model.save(file_name) # save idx utils.save_model_idx(file_name, data) return _model
def create_model(ac_weights, train_vec, parms): # ============================================================================= # Input layer # ============================================================================= ac_input = Input(shape=(train_vec['pref']['ac_index'].shape[1], ), name='ac_input') features = Input(shape=(train_vec['pref']['features'].shape[1], train_vec['pref']['features'].shape[2]), name='features') # ============================================================================= # Embedding layer for categorical attributes # ============================================================================= ac_embedding = Embedding( ac_weights.shape[0], ac_weights.shape[1], weights=[ac_weights], input_length=train_vec['pref']['ac_index'].shape[1], trainable=False, name='ac_embedding')(ac_input) # ============================================================================= # Layer 1 # ============================================================================= merged = Concatenate(name='concatenated', axis=2)([ac_embedding, features]) l1_c1 = LSTM(parms['l_size'], kernel_initializer='glorot_uniform', return_sequences=True, dropout=0.2, implementation=parms['imp'])(merged) # ============================================================================= # Batch Normalization Layer # ============================================================================= batch1 = BatchNormalization()(l1_c1) # ============================================================================= # The layer specialized in prediction # ============================================================================= l2_c1 = LSTM(parms['l_size'], activation=parms['lstm_act'], kernel_initializer='glorot_uniform', return_sequences=False, dropout=0.2, implementation=parms['imp'])(batch1) # ============================================================================= # Output Layer # ============================================================================= times_output = Dense(train_vec['next'].shape[1], activation=parms['dense_act'], kernel_initializer='glorot_uniform', name='time_output')(l2_c1) model = Model(inputs=[ac_input, features], outputs=[times_output]) if parms['optim'] == 'Nadam': opt = Nadam(learning_rate=0.002, beta_1=0.9, beta_2=0.999) elif parms['optim'] == 'Adam': opt = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False) elif parms['optim'] == 'SGD': opt = SGD(learning_rate=0.01, momentum=0.0, nesterov=False) elif parms['optim'] == 'Adagrad': opt = Adagrad(learning_rate=0.01) model.compile(loss={'time_output': 'mae'}, optimizer=opt) model.summary() return model
# we should freeze: # for i, layer in enumerate(base_model.layers): # print(i, layer.name) # we chose to train the top 1 inception blocks, i.e. we will freeze # the first 250 layers and unfreeze the rest: for layer in model.layers[:250]: layer.trainable = False for layer in model.layers[250:]: layer.trainable = True # we need to recompile the model for these modifications to take effect # we use SGD with a low learning rate # if required remove one metric from tensorflow.keras.optimizers import SGD model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy', 'categorical_accuracy']) # we train our model again (this time fine-tuning the top 1 inception blocks) # alongside the top Dense layers model.fit(X_train, y_train, epochs=50, batch_size=64, verbose=0) # Use the following code for training in a mini-batch basis. # When limited resources are available. # 287 -> number of COVID 19 photos # 1595 -> number of Normal photos # 4371 -> number of Pneumonia photos # Used a mini-batch of maximum 200 photos in one go from each class for i in range(23): # 23 would be sufficient to cover all the images in the largest category here (pneumonia) overall = [] c = listdir(fp + 'corona')
import numpy as np from tensorflow import keras from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout, Activation from tensorflow.keras.optimizers import SGD x_train = np.random.random((1000, 20)) y_train = keras.utils.to_categorical(np.random.randint(10, size=(1000, 1)), num_classes=10) x_test = np.random.random((100, 20)) y_test = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10) model = Sequential() model.add(Dense(64, activation='relu', input_dim=20)) model.add(Dropout(0.5)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax')) sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) model.fit(x_train, y_train, epochs=20, batch_size=128) score = model.evaluate(x_test, y_test, batch_size=128)
#convert labels from integers to Vectors trainY = LabelBinarizer().fit_transform(trainY) testY = LabelBinarizer().fit_transform(testY) #constructing image generator for Data augumentation aug = ImageDataGenerator(rotation_range=30, width_shift_range=0.1, height_shift_range=0.1, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') #initializing the optimizer and model print('[INFO] compiling model ...') opt = SGD(lr=0.05) model = MiniVGGNet.build(width=64, height=64, depth=3, classes=len(classNames)) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) #train network print('[INFO] training network ...') H = model.fit_generator(aug.flow(trainX, trainY, batch_size=32), validation_data=(testX, testY), steps_per_epoch=len(trainX) // 32, epochs=100, verbose=1) #evaluate the model print('[INFO] evaluating the network ...')
MaxPooling2D(pool_size=(2, 2)), BatchNormalization(), Conv2D(128, kernel_size=(3, 3), activation='relu'), MaxPooling2D(pool_size=(2, 2)), BatchNormalization(), Conv2D(128, kernel_size=(3, 3), activation='relu'), MaxPooling2D(pool_size=(2, 2)), BatchNormalization(), Conv2D(64, kernel_size=(3, 3), activation='relu'), MaxPooling2D(pool_size=(2, 2)), Flatten(), Dropout(0.2), Dense(256, activation='relu'), Dropout(0.2), Dense(64, activation='relu'), Dense(1, activation='sigmoid') ]) model.compile(optimizer=SGD(), loss='binary_crossentropy', metrics=['accuracy']) model.summary() history = model.fit(train_generator, steps_per_epoch=total_train // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=validation_generator.samples // batch_size) print("Evaluate on test data") results = model.evaluate(test_generator, batch_size=1) print("test loss, test acc:", results) model.save('model')