def data_generator(model, train_data, val_data): train_gen = DataGenerator(root_dir, model, train_data, batch_size, target_dim, n_classes) val_gen = DataGenerator(root_dir, model, val_data, batch_size, target_dim, n_classes) return train_gen, val_gen
def train(sr_model, opt, loss, tr_hr, tr_lr, vl_hr, vl_lr, epochs, batch_size, path_save): patch_gen(tr_hr, "train", path_save) patch_gen(vl_hr, "validation", path_save) val_txt = open(path_save + "validation.txt", "r+") tr_txt = open(path_save + "train.txt", "r+") tr_patch_list = tr_txt.readlines() val_patch_list = (val_txt.readlines()) if loss == "ssim_loss": loss = ssim_loss elif loss == "psnr_loss": loss = psnr_loss tr_generator = DataGenerator(tr_patch_list, batch_size, tr_hr, tr_lr) vl_generator = DataGenerator(val_patch_list, batch_size, vl_hr, vl_lr) sr_model.compile(optimizer=opt, loss=loss) sr_model.fit(tr_generator, epochs=epochs, validation_data=vl_generator)
def __init__(self): pygame.init() self.display = pygame.display.set_mode((600, 660), pygame.SRCALPHA, 32) # Game level (Probably should modify this) self.frames = 0 self.speed = 15 # Game essentials self.grid = Grid() self.gGrid = Grid() self.piece = Piece.generate_piece(randint(1, 7)) # Data generation for the neural network self.data_gen = DataGenerator() # Arg flags self.is_human = True self.debug_mode = False self.model = None self.flag_setup()
def do_eval(model_path): # Load saved Model model = load_model(model_path, custom_objects={ 'soft_dice_loss': soft_dice_loss, 'mean_iou': mean_iou }) # Load Test Img-GT Paths img2gt_paths = get_data_paths(train=False) # Initialize DataGenerator generator = DataGenerator(img2gt_paths, batch_size=1) loss, acc, m_iou = model.evaluate_generator(generator, steps=len(img2gt_paths)) print('Pixel level accuracy: {}'.format(acc)) print('Mean IoU: {}'.format(m_iou))
def predict(model, data): print("Prediction: #samples {}".format(len(data))) generator = DataGenerator(root_dir, model, data, batch_size, target_dim, n_classes) _, infests = zip(*generator.image_infest_list) labels = [infest_to_class_ind(n_classes, infest) for infest in infests] predictions = model.predict_generator(generator, verbose=True) label_predictions = predictions.argmax(axis=1) n_match = sum(y_pred == y_true for y_pred, y_true in zip(label_predictions, labels)) if n_classes > 2: fpr, tpr, _ = roc_curve(labels, predictions[:, 1]) auc_keras = auc(fpr, tpr) plot_ROC(fpr, tpr, auc_keras) print("Test acc {}".format(n_match / len(labels))) print(classification_report(labels, label_predictions))
def do_train(batch_size, save_name): # Load the Train Img-GT Paths img2gt_paths = get_data_paths(train=True) # Initialize Data Generator generator = DataGenerator(img2gt_paths, batch_size=batch_size) # Create Model and Transfer Caffe weights model = create_model() model.compile(optimizer=keras.optimizers.Adam(lr=0.0001), loss=soft_dice_loss, metrics=['accuracy', mean_iou]) model.fit_generator(generator=generator, steps_per_epoch=int( np.floor(len(img2gt_paths) / batch_size)), epochs=8, use_multiprocessing=True, workers=8) model.save(save_name)
"/saved-model-{epoch:02d}-{val_classifier_accuracy:.2f}.hdf5" checkpoint = callbacks.ModelCheckpoint(filepath, monitor='val_classifier_accuracy', verbose=1, save_best_only=False, mode='max') BATCH = 32 file_names_train, gt_train, n_train = data_preprocessing.load_metadata('train') file_names_test, gt_test, n_test = data_preprocessing.load_metadata('test') gt_train, gt_test, shape_mean, shape_std = normalize_data(gt_train, gt_test) training_generator = DataGenerator(list(range(len(file_names_train))), file_names_train, train_image_path, gt_train, dim=(50, 50), batch_size=BATCH, shuffle=True) validation_generator = DataGenerator(list(range(len(file_names_test))), file_names_test, test_image_path, gt_test, dim=(50, 50), batch_size=BATCH, shuffle=False) model = FullyConnected() epochs = 1000 opt = Adam()
# print(len(train_d.keys())) # train_d = dict(filter(lambda elem: select_fights(elem[0]), train_d.items())) print(len(train_d.keys())) print(Counter(list(train_d.values()))) print(Counter(list(val_d.values()))) # print(Counter(list(test_d.values()))) train_keys = list(train_d.keys()) * n_mul_train val_keys = list(val_d.keys()) * n_mul_val # test_keys = list(test_d.keys()) # Generators print("Params for DataGen:", params) training_generator = DataGenerator(train_keys, train_d, **params, type_gen='train') validation_generator = DataGenerator(val_keys, val_d, **params, type_gen='test') # params['shuffle'] = False # params['batch_size'] = 2 # testing_generator = DataGenerator(test_keys, test_d, **params, type_gen='test') X, Y = training_generator[0] # returns variables and labels pair print(X[0].shape, X[1].shape, Y.shape) X0 = X[0] X1 = X[1] fig = plt.figure(figsize=(8, 8))
################################################################################ dataset_type = 'data' dirname = 'MichelEnergyImageData' if 'Data' in args.input else 'MichelEnergyImage' n_channels = 1 conv_depth = 2 patch_w, patch_h = 160, 160 batch_size = 16 steps = 0 ################################################################################ print('Building data generator') test_gen = DataGenerator(dataset_type=dataset_type, dirname=dirname, batch_size=batch_size, shuffle=False, root_data=args.input, patch_w=patch_w, patch_h=patch_h, patch_depth=n_channels) ################################################################################ sess = tf.InteractiveSession() with sess.as_default(): print('Loading model') if 'inception' in args.weights: model = inception_unet(inputshape=(patch_w, patch_h, n_channels), conv_depth=int(args.weights.split('_')[2][-1]), number_base_nodes=int( args.weights.split('_')[1][-2:])) else:
def evaluate(config, weights_path): ###### Parameters setting dim = (config['model']['input_width'], config['model']['input_height'] ) # for MobileNetV2 n_sequence = config['model']['sequence'] # for LSTM n_channels = config['model']['channels'] # color channel(RGB) n_output = config['model']['class_num'] # number of output class batch_size = config['train']['batch_size'] n_mul_train = 1 # To increase sample of train set n_mul_test = 4 # To increase sample of test set path_dataset = config['train']['data_dir'] ###### params = { 'dim': dim, 'batch_size': batch_size, 'n_sequence': n_sequence, 'n_channels': n_channels, 'path_dataset': path_dataset, 'option': 'RGBdiff', 'shuffle': False } test_txt = config['valid']['file_list'] test_d = readfile_to_dict(test_txt) key_list = list(test_d.keys()) * n_mul_test # IDs # validation_generator = DataGeneratorBKB(partition['validation'] , labels, **params, type_gen='test') # for evalutate_generator predict_generator = DataGenerator(key_list, test_d, **params, type_gen='predict') # evaluate eval_graph = tf.Graph() eval_sess = tf.Session(graph=eval_graph, config=tf_config) keras.backend.set_session(eval_sess) with eval_graph.as_default(): keras.backend.set_learning_phase(0) model = create_model(n_output) model.load_weights(weights_path) # Example for evaluate generator # If you want to use, just uncomment it # loss, acc = model.evaluate_generator(validation_generator, verbose=0) # print(loss,acc) # #### Confusion Matrix y_pred_prob = model.predict_generator(predict_generator, workers=0) test_y = np.array(list(test_d.values()) * n_mul_test) print("-----------") print(y_pred_prob.shape) print(len(test_y)) y_pred = np.argmax(y_pred_prob, axis=1) normalize = True all_y = len(test_y) sum = all_y for i in range(len(y_pred)): if test_y[i] != y_pred[i]: sum -= 1 print(key_list[i], ' actual:', test_y[i], 'predict:', y_pred[i]) cm = confusion_matrix(test_y, y_pred) if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print('Confusion matrix, without normalization') accuracy = sum / all_y print("accuracy:", accuracy) classes = [*range(1, n_output + 1)] # [1,2,3,...,18] df_cm = pd.DataFrame(cm, columns=classes, index=classes) df_cm.index.name = 'Actual' df_cm.columns.name = 'Predicted' fig, ax = plt.subplots(figsize=(5, 5)) sn.set(font_scale=0.6) #for label size sn.heatmap(df_cm, cmap="Blues", annot=True, fmt=".2f", annot_kws={"size": 8}) # font size # ax.set_ylim(5, 0) # plt.show() plt.savefig('eval_model.png')
class GameManager: '''Game manager class. Manages the main game loop and will manage other things as events.''' def __init__(self): pygame.init() self.display = pygame.display.set_mode((600, 660), pygame.SRCALPHA, 32) # Game level (Probably should modify this) self.frames = 0 self.speed = 15 # Game essentials self.grid = Grid() self.gGrid = Grid() self.piece = Piece.generate_piece(randint(1, 7)) # Data generation for the neural network self.data_gen = DataGenerator() # Arg flags self.is_human = True self.debug_mode = False self.model = None self.flag_setup() def flag_setup(self): '''Setup function for whatever is needed''' arguments = sys.argv[1:] if '-ai' in arguments: print('AI is working') self.is_human = False ai_file = arguments[arguments.index('-ai') + 1] self.model = load(ai_file) if '-debug' in arguments: self.debug_mode = True if '-o' in arguments: pass def handle_events(self): '''Handle all events in the event queue''' for event in pygame.event.get(): if event.type == pygame.QUIT: print('Bye bye') exit() if self.is_human: self.handle_human_input(event) if not self.is_human: row = [] for i in range(self.gGrid.height): for j in range(self.gGrid.width): row.append(int(self.gGrid[i][j] > 0)) row.append(self.piece.piece_type) reshaped_row = np.asarray(row).reshape(1, -1) move = self.model.predict(reshaped_row)[0] if move == 1: self.rotate() elif move == 2: self.dropdown() elif move == 3: self.move_right() elif move == 4: self.move_left() def handle_human_input(self, event): '''Handle human input if control is given''' if event.type == pygame.KEYDOWN: # Rotation if event.key == pygame.K_r: self.rotate() self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 1) # Drop down elif event.key == pygame.K_s: self.dropdown() self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 2) elif event.key == pygame.K_d: self.move_right() self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 3) elif event.key == pygame.K_a: self.move_left() self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 4) def rotate(self): self.piece.rotate(self.grid) def dropdown(self): self.piece.pos_y += self.piece.dropdown(self.grid) def move_right(self): if self.piece.can_place( piece=self.piece.shape, grid=self.grid, dx=1, ) == PieceState.CAN_PLACE: self.piece.pos_x += 1 def move_left(self): if self.piece.can_place( piece=self.piece.shape, grid=self.grid, dx=-1, ) == PieceState.CAN_PLACE: self.piece.pos_x += -1 def update(self): '''Update part from the loop. All logic should be managed from here.''' if self.frames % self.speed == 0: if self.piece.can_place( #piece=self.piece, piece=self.piece.shape, grid=self.grid, dy=1, ) == PieceState.CAN_PLACE: self.piece.pos_y += 1 if self.is_human: self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 0) else: # Place piece self.grid.set_piece(self.piece) self.grid.check_completition() self.piece = Piece.generate_piece(randint(1, 7)) self.gGrid.grid = deepcopy(self.grid.grid) self.gGrid.set_piece(self.piece) def render(self): '''Render method of the game loop. Here everything will be rendered.''' self.display.fill((100, 100, 100)) self.gGrid.render(self.display, x=10, y=20) pygame.display.update() def print(self): ''' Print part from the loop. The grid will be printed from here. If there is enough time, print will be eventually be made into a render function for functional graphics. ''' system('clear') self.gGrid.print() print('Piece type: ', self.piece.piece_type) def loop(self): '''Game loop''' clock = pygame.time.Clock() # self.setup() while True: clock.tick(30) self.frames += 1 self.handle_events() self.update() self.render() if self.debug_mode: self.print()
# Parameters params = { 'dim': (30, 30), 'batch_size': 200, 'n_channels': 3, 'shuffle': True } # Datasets partition = create_partition(10000) # Generators data_generators = { 'training_generator': DataGenerator(partition['train'], **params), 'validation_generator': DataGenerator(partition['validation'], **params), 'test_generator': DataGenerator(partition['test'], **params), 'predition_generator': PredictionDataGenerator(partition['test'], dim=(30, 30)) } model = create_model() history, result, predictions = evaluate_model( model, data_generators, 'checkpoints/model3/cp-{epoch:04d}.ckpt', period=1, epochs=40,
name += '_basenodes' + str(number_base_nodes) name += '_layers' + str(number_layers) name += '_convdepth' + str(conv_depth) name += '_patchsize' + str(patch_w) name += '_final' ################################################################################ if use_generator: print ('Using generator') number_keys = 100 if test_sample else 0 train_gen = DataGenerator(root_data = args.input, dataset_type = 'train', dirname = 'MichelEnergyImage', batch_size = batch_size, patch_w = patch_w, patch_h = patch_h, patch_depth = n_channels, number_keys = number_keys) val_gen = DataGenerator(root_data = args.input, dataset_type = 'val', dirname = 'MichelEnergyImage', batch_size = batch_size, patch_w = patch_w, patch_h = patch_h, patch_depth = n_channels, number_keys = number_keys) else: print ('Using large batches')
#perm = np.random.permutation(full_data_size) perm = range(full_data_size) partition = { 'train': [str(perm[i]) for i in xrange(train_size)], 'validation': [str(perm[i]) for i in xrange(train_size, train_size + val_size)], 'test': [ str(perm[i]) for i in xrange(train_size + val_size, train_size + val_size + test_size) ] #'validation':[ str(perm[i]) for i in xrange(val_size) ], #'test':[ str(perm[i]) for i in xrange(test_size) ] } print noEpochs, train_size, val_size, test_size training_generator = DataGenerator(partition['train'], **params) validation_generator = DataGenerator(partition['validation'], **params) test_generator = DataGenerator(partition['test'], **params) print('Traning:') model.fit_generator(generator=training_generator, validation_data=validation_generator, epochs=noEpochs, use_multiprocessing=True, workers=12, verbose=1) print('Testing') pred_labels = np.array( model.predict_generator(generator=test_generator, use_multiprocessing=True,
""" Fetch files for train(ing)/test(ing). """ def fetch_files(purpose): subdirectory = MAIN_DIRECTORY + purpose all_folders = [ folder for folder in Path(subdirectory).iterdir() if folder.is_dir() ] all_files = [] for folder in all_folders: all_files.extend([ str(x) for x in Path(folder).iterdir() if str(x).endswith('.npy') ]) return all_files if __name__ == "__main__": # obtain relevant files training_files = fetch_files('train') validation_files = fetch_files('test') # get data generators training_gen = DataGenerator(training_files, **params) validation_gen = DataGenerator(validation_files, **params, shuffle=False) model = nn_model() model.fit_generator(generator=training_gen, validation_data=validation_gen, use_multiprocessing=True, workers=NUM_WORKERS, epochs=NUM_EPOCHS) model.save('../predict_emo.h5')
inter.add(Dense(50, activation='softmax')) # x = MaxPooling2D(pool_size=(2,2))(x) # x = Flatten()(x) # x = Dense(1000)(x) # x = Dense(500)(x) # preds = Dense(50, activation='softmax')(x) # # final_model = Model(inputs=noise.input, outputs=preds) sgd = SGD(lr=0.001, decay=0.00004) top3_acc = functools.partial(metrics.top_k_categorical_accuracy, k=3) top3_acc.__name__ = 'top3_acc' inter.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy', top3_acc]) inter.summary() feat_dict = get_vector_from_cats() training_generator = DataGenerator(train_imgs, train_labels, feat_dict) validation_generator = DataGenerator(val_imgs, val_labels, feat_dict) testing_generator = DataGenerator(test_imgs, test_labels, feat_dict) cp_callback = ModelCheckpoint('/home/ad0915/Desktop/CV_final/VGG19_weights/aug_bce_rms.h5', monitor='val_acc', verbose=1, save_best_only=True, period=4) #inter.fit_generator(generator=training_generator, validation_data=validation_generator, validation_steps=int(np.floor(850/8)), epochs=400, use_multiprocessing=True, workers=8, callbacks=[cp_callback]) model = load_model('./VGG19_weights/base_msle_sgd0.03_all_noise.h5', custom_objects={'top3_acc':top3_acc}) model.summary() loss, acc, top3_acc = model.evaluate_generator(testing_generator, verbose=1) print(' Testing Accuracy = {:5.2f}%'.format(100*acc))
'dim': dim, 'batch_size': batch_size, 'n_sequence': n_sequence, 'n_channels': n_channels, 'path_dataset': path_dataset, 'option': 'RGBdiff', 'shuffle': False } test_txt = "dataset_list/testlist.txt" test_d = readfile_to_dict(test_txt) key_list = list(test_d.keys()) * n_mul_test # IDs # validation_generator = DataGeneratorBKB(partition['validation'] , labels, **params, type_gen='test') # for evalutate_generator predict_generator = DataGenerator(key_list, test_d, **params, type_gen='predict') model = create_model_pretrain(dim, n_sequence, n_channels, n_output) model.load_weights(weights_path) # Example for evaluate generator # If you want to use, just uncomment it # loss, acc = model.evaluate_generator(validation_generator, verbose=0) # print(loss,acc) # #### Confusion Matrix y_pred_prob = model.predict_generator(predict_generator, workers=0) test_y = np.array(list(test_d.values()) * n_mul_test) print("-----------") print(y_pred_prob.shape)
import numpy as np import cv2 from data_gen import DataGenerator batch_size = 32 num_classes = 10 im_size = 64 num_epochs = 100 train_path = '/data/ImageNet/data64/train' val_path = '/data/ImageNet/data64/val' saveDir = '/data/ImageNet/autoencoder/dae_keras/64' if not os.path.isdir(saveDir): os.makedirs(saveDir) training_generator = DataGenerator(train_path) validation_generator = DataGenerator(val_path) input_img = Input(shape=(im_size, im_size, 3)) x = Conv2D(32, (3, 3), padding='same')(input_img) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(32, (3, 3), padding='same')(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(32, (3, 3), padding='same')(x) x = BatchNormalization()(x)
def train(annotation_path, taxonomy_path, emb_dir, output_dir, exp_id, label_mode="fine", batch_size=64, num_epochs=1000, patience=20, learning_rate=1e-4, dropout_size=0.5, ef_mode=4, l2_reg=1e-5, standardize=True, timestamp=None, random_state=0): """ Train and evaluate a MIL MLP model. Parameters ---------- annotation_path emb_dir output_dir label_mode batch_size num_epochs patience learning_rate dropout_size l2_reg standardize timestamp random_state Returns ------- """ np.random.seed(random_state) random.seed(random_state) # Load annotations and taxonomy print("* Loading dataset.") annotation_data = pd.read_csv(annotation_path).sort_values('audio_filename') with open(taxonomy_path, 'r') as f: taxonomy = yaml.load(f, Loader=yaml.Loader) annotation_data_trunc = annotation_data[['audio_filename', 'latitude', 'longitude', 'year', 'week', 'day', 'hour']].drop_duplicates() file_list = annotation_data_trunc['audio_filename'].to_list() latitude_list = annotation_data_trunc['latitude'].to_list() longitude_list = annotation_data_trunc['longitude'].to_list() year_list = annotation_data_trunc['year'].to_list() #### added week_list = annotation_data_trunc['week'].to_list() day_list = annotation_data_trunc['day'].to_list() hour_list = annotation_data_trunc['hour'].to_list() full_fine_target_labels = ["{}-{}_{}".format(coarse_id, fine_id, fine_label) for coarse_id, fine_dict in taxonomy['fine'].items() for fine_id, fine_label in fine_dict.items()] fine_target_labels = [x for x in full_fine_target_labels if x.split('_')[0].split('-')[1] != 'X'] coarse_target_labels = ["_".join([str(k), v]) for k,v in taxonomy['coarse'].items()] print("* Preparing training data.") # For fine, we include incomplete labels in targets for computing the loss fine_target_list = get_file_targets(annotation_data, full_fine_target_labels) coarse_target_list = get_file_targets(annotation_data, coarse_target_labels) train_file_idxs, valid_file_idxs = get_subset_split(annotation_data) if label_mode == "fine": target_list = fine_target_list labels = fine_target_labels elif label_mode == "coarse": target_list = coarse_target_list labels = coarse_target_labels else: raise ValueError("Invalid label mode: {}".format(label_mode)) num_classes = len(labels) print(np.shape(target_list[0]), np.shape(labels)) embeddings = load_embeddings(file_list[:1], emb_dir) print(np.shape(embeddings[0])) dim = np.shape(embeddings[0]) #(11,597) num_frames = len(embeddings[0]) print(num_frames) params = {'dim': dim, 'batch_size': batch_size, 'shuffle': True} scaler = None training_generator = DataGenerator(file_list, target_list, train_file_idxs, latitude_list, longitude_list, year_list, week_list, day_list, hour_list, len(target_list[0]), emb_dir, **params) validation_generator = DataGenerator(file_list, target_list, valid_file_idxs, latitude_list, longitude_list, year_list, week_list, day_list, hour_list, len(target_list[0]), emb_dir, **params) model = construct_mlp(dim, num_classes, num_frames, ef_mode=ef_mode, dropout_size=dropout_size, l2_reg=l2_reg) if not timestamp: timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S") results_dir = os.path.join(output_dir, exp_id, timestamp) if scaler is not None: scaler_path = os.path.join(results_dir, 'stdizer.pkl') with open(scaler_path, 'wb') as f: pk.dump(scaler, f) if label_mode == "fine": full_coarse_to_fine_terminal_idxs = np.cumsum( [len(fine_dict) for fine_dict in taxonomy['fine'].values()]) incomplete_fine_subidxs = [len(fine_dict) - 1 if 'X' in fine_dict else None for fine_dict in taxonomy['fine'].values()] coarse_to_fine_end_idxs = np.cumsum([len(fine_dict) - 1 if 'X' in fine_dict else len(fine_dict) for fine_dict in taxonomy['fine'].values()]) # Create loss function that only adds loss for fine labels for which # the we don't have any incomplete labels def masked_loss(y_true, y_pred): loss = None for coarse_idx in range(len(full_coarse_to_fine_terminal_idxs)): true_terminal_idx = full_coarse_to_fine_terminal_idxs[coarse_idx] true_incomplete_subidx = incomplete_fine_subidxs[coarse_idx] pred_end_idx = coarse_to_fine_end_idxs[coarse_idx] if coarse_idx != 0: true_start_idx = full_coarse_to_fine_terminal_idxs[coarse_idx-1] pred_start_idx = coarse_to_fine_end_idxs[coarse_idx-1] else: true_start_idx = 0 pred_start_idx = 0 if true_incomplete_subidx is None: true_end_idx = true_terminal_idx sub_true = y_true[:, true_start_idx:true_end_idx] sub_pred = y_pred[:, pred_start_idx:pred_end_idx] else: # Don't include incomplete label true_end_idx = true_terminal_idx - 1 true_incomplete_idx = true_incomplete_subidx + true_start_idx assert true_end_idx - true_start_idx == pred_end_idx - pred_start_idx assert true_incomplete_idx == true_end_idx # 1 if not incomplete, 0 if incomplete mask = K.expand_dims(1 - y_true[:, true_incomplete_idx]) # Mask the target and predictions. If the mask is 0, # all entries will be 0 and the BCE will be 0. # This has the effect of masking the BCE for each fine # label within a coarse label if an incomplete label exists sub_true = y_true[:, true_start_idx:true_end_idx] * mask sub_pred = y_pred[:, pred_start_idx:pred_end_idx] * mask if loss is not None: loss += K.sum(K.binary_crossentropy(sub_true, sub_pred)) else: loss = K.sum(K.binary_crossentropy(sub_true, sub_pred)) return loss loss_func = masked_loss else: loss_func = None training = True prediction = True if training == True: #history = train_model(model, X_train, y_train, X_valid, y_valid, # results_dir, loss=loss_func, # batch_size=batch_size, num_epochs=num_epochs, # patience=patience, learning_rate=learning_rate) history = train_model(model, training_generator, validation_generator, results_dir, loss=loss_func, batch_size=batch_size, num_epochs=num_epochs, patience=patience, learning_rate=learning_rate) # Reload checkpointed file if prediction == True: model = construct_mlp(dim, num_classes, num_frames, ef_mode=ef_mode, dropout_size=dropout_size, l2_reg=l2_reg) #model = multi_gpu_model(model, gpus=2) #model.summary() params = {'dim': dim, 'batch_size': 1, 'shuffle': False} scaler = None training_generator = DataGenerator(file_list, target_list, train_file_idxs, latitude_list, longitude_list, year_list, week_list, day_list, hour_list, len(target_list[0]), emb_dir, **params) validation_generator = DataGenerator(file_list, target_list, valid_file_idxs, latitude_list, longitude_list, year_list, week_list, day_list, hour_list, len(target_list[0]), emb_dir, **params) out_dir = os.listdir(results_dir) out_dir.sort() count = 0 for i in out_dir: if i[-2:] == "h5": from keras.models import load_model from keras.models import model_from_json model_weight_file = os.path.join(results_dir, i) model.load_weights(model_weight_file) print("* Saving model predictions.") results = {} results['train'] = model.predict_generator(training_generator, use_multiprocessing=True, workers=8).tolist() results['validate'] = model.predict_generator(validation_generator, use_multiprocessing=True, workers=8).tolist() results_path = os.path.join(results_dir, "results.json") with open(results_path, "w") as f: json.dump(results, f, indent=2) generate_output_file(results['validate'], valid_file_idxs, results_dir, file_list, label_mode, taxonomy, count) print(np.shape(results['validate']), np.shape(valid_file_idxs)) count = count + 1
MaxPooling3D) from keras.layers.advanced_activations import LeakyReLU from keras.losses import categorical_crossentropy from keras.models import Sequential from keras.optimizers import Adam from keras.utils import np_utils from keras.utils.vis_utils import plot_model from sklearn.model_selection import train_test_split from data_gen import DataGenerator from config import Config import data_gen from pre_recall import * root_data_path = 'data_files' data_gen_obj = DataGenerator(root_data_path, temporal_stride=4, temporal_length=16, resize=224) train_data = data_gen_obj.load_samples(data_cat='train') test_data = data_gen_obj.load_samples(data_cat='test') print('num of train_samples: {}'.format(len(train_data))) print('num of test_samples: {}'.format(len(test_data))) train_generator = data_gen_obj.data_generator(train_data, batch_size=4, shuffle=True) test_generator = data_gen_obj.data_generator(test_data, batch_size=4, shuffle=True)
################################################################################ if not (args.input and args.weights): print('Please provide data, model, and weights') exit() n_channels = 3 conv_depth = 3 patch_w, patch_h = 160, 160 batch_size = 1 print('Building data generator') test_gen = DataGenerator(dataset_type='data', dirname='MichelEnergyImageData', batch_size=batch_size, shuffle=False, root_data=args.input, patch_w=patch_w, patch_h=patch_h, patch_depth=n_channels) sess = tf.InteractiveSession() with sess.as_default(): print('Loading model') model = unet(inputshape=(patch_w, patch_h, n_channels), conv_depth=conv_depth) model.load_weights(args.weights) print('Reformating data') test_x = np.zeros((test_gen.__len__(), patch_w, patch_h, n_channels)) test_y = np.zeros((test_gen.__len__(), patch_w, patch_h, 1))
params = { 'dim': dim, 'batch_size': 1, # 'n_classes': 6, 'n_sequence': n_sequence, 'n_channels': n_channels, 'path_dataset': path_dataset, 'shuffle': False } ## dataset test_d = readfile_to_dict("dataset_list/trainlistUCF.txt") labels = test_d.copy() partition = {'validation': list(test_d.keys())} # IDs validation_generator = DataGenerator(partition['validation'], labels, **params, type_gen='test') predict_generator = DataGenerator(partition['validation'], labels, **params, type_gen='predict') weights_path = 'pretrain/mobileNet-47-0.97.hdf5' # 15 frame model = create_model_pretrain(dim, n_sequence, n_channels, n_output, 'MobileNet') model.load_weights(weights_path) ## evaluate # loss, acc = model.evaluate_generator(validation_generator, verbose=0) # print(loss,acc)
def train(config): ###### Parameters setting dim = (config['model']['input_width'], config['model']['input_height'] ) # for MobileNetV2 n_sequence = config['model']['sequence'] # for LSTM n_channels = config['model']['channels'] # color channel(RGB) n_output = config['model']['class_num'] # number of output class batch_size = config['train']['batch_size'] n_mul_train = 1 # To increase sample of train set n_mul_test = 4 # To increase sample of test set path_dataset = config['train']['data_dir'] ###### # Keyword argument params = { 'dim': dim, 'batch_size': batch_size, # you can increase for faster training 'n_sequence': n_sequence, 'n_channels': n_channels, 'path_dataset': path_dataset, 'option': 'RGBdiff', 'shuffle': True } train_txt = config['train']['file_list'] test_txt = config['valid']['file_list'] # Read file # train_d and test_d is dictionary that contain name of video as key and label as value # For example, {'a01\a01_s08_e01': 0, 'a01\a01_s08_e02': 0, .... } # It's used for getting label(Y) train_d = readfile_to_dict(train_txt) test_d = readfile_to_dict(test_txt) # Prepare key, name of video(X) train_keys = list(train_d.keys()) * n_mul_train test_keys = list(test_d.keys()) * n_mul_test # Generators training_generator = DataGenerator(train_keys, train_d, **params, type_gen='train') validation_generator = DataGenerator(test_keys, test_d, **params, type_gen='test') # define logs for tensorboard tensorboard = TensorBoard(log_dir='logs', histogram_freq=0) # train train_graph = tf.Graph() train_sess = tf.Session(graph=train_graph, config=tf_config) keras.backend.set_session(train_sess) with train_graph.as_default(): # Design model model = create_model(n_output) # model.compile(optimizer=tf.train.AdamOptimizer(), loss='sparse_categorical_crossentropy', metrics=['acc']) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc']) model.summary() start_epoch = 0 # Load weight of unfinish training model(optional) pretrained_weights = config['train'][ 'pretrained_weights'] # name of model if pretrained_weights != '': start_epoch = config['train']['start_epoch'] model.load_weights(pretrained_weights) # Set callback wgtdir = 'save_weight' if not os.path.exists(wgtdir): os.makedirs(wgtdir) validate_freq = 5 filepath = os.path.join( wgtdir, "weight-{epoch:02d}-{acc:.2f}-{val_acc:.2f}.hdf5") checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1, save_best_only=False, period=validate_freq) callbacks_list = [checkpoint, tensorboard] # Train model on dataset model.fit_generator(generator=training_generator, validation_data=validation_generator, epochs=config['train']['nb_epochs'], callbacks=callbacks_list, initial_epoch=start_epoch, validation_freq=validate_freq)
if not (args.input and args.weights): print('Please provide data, model, and weights') exit() n_channels = 3 conv_depth = 3 patch_w, patch_h = 160, 160 batch_size = 64 steps = 1 print('Building data generator') test_gen = DataGenerator(dataset_type='data', dirname='MichelEnergyImage', batch_size=batch_size, shuffle=False, root_data=args.input, patch_w=patch_w, patch_h=patch_h, patch_depth=n_channels) sess = tf.InteractiveSession() with sess.as_default(): print('Loading model') model = unet(inputshape=(patch_w, patch_h, n_channels), conv_depth=conv_depth) model.load_weights(args.weights) print('Loading charge info') if steps == 0: test_charge = np.zeros(
'n_channels': 3, 'shuffle': True, 'datapath': f'/vagrant/imgs/training_data2/{PADDING}' } partition = get_pickled_partition('all', PADDING) print(len(partition['test'])) prediction_data = [] for i in range(0, len(partition['test']), 200): prediction_data.append(partition['test'][i:i + 200]) print(len(prediction_data)) # 1/0 data_generators = { 'test_generator': DataGenerator(partition['test'], **params), 'predition_generator': PredictionDataGenerator(partition['test'], dim=(48, 48)) } # for image_path in partition['test']: # p = os.path.join(params['datapath'], image_path) # img = cv2.imread(p) # if img.shape != (95, 95, 3): # print(img.shape) # 1/0 checkpoint_path = 'checkpoints/model6-3/cp-0038.ckpt' model = create_model() model.load_weights(checkpoint_path) predictions = []