def main(args): model = models.get_model(args.model, args.dataset) dataset = model.dataset train, test = datasets.load_data(dataset) train, validation = datasets.split_data(train, fractions=[0.8, 0.2]) trainer.train(model, train, validation, args.epochs, args.batch_size, args.learning_rate, dataset_update=args.dataset_update, increments=args.splits, use_ewc=args.ewc, ewc_lambda=args.ewc_lambda, ewc_samples=args.ewc_samples, use_fim=args.fim, fim_threshold=args.fim_threshold, fim_samples=args.fim_samples, use_incdet=args.incdet, incdet_threshold=args.incdet_threshold)
def generator(dataset_name, batch_size, classes): data_loader = DataManager(dataset_name) ground_truth_data = data_loader.get_data() images_path = data_loader.dataset_path train_keys, val_keys = split_data(ground_truth_data, 0) image_generator = ImageGenerator(ground_truth_data, batch_size, [224, 224, 3], train_keys, val_keys, classes, None, path_prefix=images_path, grayscale=False) train_generator = image_generator.flow(mode='train') train_num = len(train_keys) / batch_size return train_generator, train_num
def generate_data(size, test_part): radius = 5 noise = 0 positive_num = int(size / 2) negative_num = size - positive_num positive_data = _generate_region(positive_num, radius, noise, 0, radius * 0.5) negative_data = _generate_region(negative_num, radius, noise, radius, radius * 0.7) x = np.hstack((positive_data[0], negative_data[0])).reshape(1, size) y = np.hstack((positive_data[1], negative_data[1])).reshape(1, size) labels = np.hstack((positive_data[2], negative_data[2])).reshape(1, size) all_data = np.vstack((x, y, labels)) all_data_t = all_data.T np.random.shuffle(all_data_t) shuffled_t = all_data_t.T points = np.vstack((shuffled_t[0], shuffled_t[1])) train, test = ds.split_data(points, shuffled_t[2].reshape(1, size), test_part) return train, test
#callbacks log_base_path = base_path + dataset_name + '_emotion_training.log' csv_logger = CSVLogger(log_base_path, append=False) early_stop = EarlyStopping('val_loss', patience=patience) reduce_lr = ReduceLROnPlateau('val_loss', factor=0.1, patience=int(patience / 4), verbose=1) trained_models_path = base_path + dataset_name + '_mini_XCEPTION' model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5' model_checkpoint = ModelCheckpoint(model_names, 'val_loss', verbose=1, save_best_only=True) callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr] # loading dataset data_loader = DataManager(dataset_name, image_size=input_shape[:2]) faces, emotions = data_loader.get_data() faces = preprocess_input(faces) num_samples, num_classes = emotions.shape train_data, val_data = split_data(faces, emotions, validation_split) train_faces, train_emotions = train_data model.fit_generator(data_generator.flow(train_faces, train_emotions, batch_size), steps_per_epoch=len(train_faces) / batch_size, epochs=num_epochs, verbose=1, callbacks=callbacks, validation_data=val_data)
log_file_path = base_path + 'cew_training.log' csv_logger = CSVLogger(log_file_path, append=False) #early_stop = EarlyStopping('val_loss', patience=patience) reduce_lr = ReduceLROnPlateau('val_loss', factor=0.1, patience=int(patience / 4), verbose=1) trained_models_path = base_path + 'cew_blink_detect' model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5' model_checkpoint = ModelCheckpoint(model_names, 'val_loss', verbose=1, save_best_only=True) callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr] # loading dataset data_loader = DataLoader('cew') faces, eyestates = data_loader.get_data() print("out shapes: ", faces.shape, eyestates.shape) faces = preprocess_input(faces) num_samples, num_classes = eyestates.shape train_data, val_data = split_data(faces, eyestates, validation_split) train_faces, train_eyestates = train_data model.fit_generator(data_generator.flow(train_faces, train_eyestates, batch_size), steps_per_epoch=len(train_faces) / batch_size, epochs=num_epochs, verbose=1, callbacks=callbacks, validation_data=val_data)
def main(): #Folder for images DATA_PATH = '/home/sunny/work/fridgeObjects' IMAGE_SIZE = 300 BATCH_SIZE = 16 LR = 0.0001 EPOCHS = 10 RANDOM_STATE = 19 #define argument parser parser = argparse.ArgumentParser(description='Image classfication.') parser.add_argument('-fp', '--filepath', help='Base directory for the dataset') parser.add_argument('-i', '--image_size', help='Image size', type=int) parser.add_argument('-b', '--batch_size', help='Batch size', type=int) parser.add_argument('-lr', '--lr', help='Learning rate', type=float) parser.add_argument('-e', '--epochs', help='Number of epochs', type=int) parser.add_argument('-rs', '--random_state', help='Random state for datasplit') args = vars(parser.parse_args()) if args['filepath']: DATA_PATH = args['filepath'] if args['image_size']: IMAGE_SIZE = args['image_size'] if args['batch_size']: BATCH_SIZE = args['batch_size'] if args['lr']: LR = args['lr'] if args['epochs']: EPOCHS = args['epochs'] if args['random_state']: RANDOM_STATE = args['random_state'] #load annotations image_ids, labels, class_names = load_annotations_from_folder(DATA_PATH) assert len(image_ids) == len(labels) print(f'Total images: {len(image_ids)}') print(f'Classes: {class_names}') #split data into train and validation set train_img_ids, val_img_ids, train_labels, val_labels = split_data( image_ids, labels, test_size=0.2, shuffle=True, stratify=labels, random_state=RANDOM_STATE) assert len(train_img_ids) == len(train_labels) assert len(val_img_ids) == len(val_labels) print(f'Train samples: {len(train_img_ids)}') print(f'Validation samples: {len(val_img_ids)}') #calculate and display number of samples per class in train and test set print() print('Class distribution:') print('Train set:') train_classes, train_counts = np.unique(train_labels, return_counts=True) assert len(train_classes) == len(class_names) viz_utils.print_table(class_names, train_counts, header=['class', 'count']) print() print('validation set:') val_classes, val_counts = np.unique(val_labels, return_counts=True) assert len(val_classes) == len(class_names) viz_utils.print_table(class_names, val_counts, header=['class', 'count']) #define transforms for train and val dataset #imagenet stats mean = np.array([0.485, 0.456, 0.406]) std = np.array([0.229, 0.224, 0.225]) train_transforms = T.Compose([ T.Resize((IMAGE_SIZE, IMAGE_SIZE)), T.ToTensor(), T.Normalize(mean, std) ]) val_transforms = T.Compose([ T.Resize((IMAGE_SIZE, IMAGE_SIZE)), T.ToTensor(), T.Normalize(mean, std) ]) #create train and validation dataset train_dataset = ImageClassificationDataset(DATA_PATH, train_img_ids, train_labels, train_transforms) val_dataset = ImageClassificationDataset(DATA_PATH, val_img_ids, val_labels, val_transforms) #checks assert len(train_dataset) == len(train_img_ids) assert len(val_dataset) == len(val_img_ids) ti, tl = train_dataset[0] assert ti.shape == torch.Size((3, IMAGE_SIZE, IMAGE_SIZE)) assert type(tl) == int #create dataloaders train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False) batch_inputs, batch_labels = next(iter(train_loader)) assert batch_inputs.shape == torch.Size( (BATCH_SIZE, 3, IMAGE_SIZE, IMAGE_SIZE)) assert batch_labels.shape == torch.Size((BATCH_SIZE, )) out = torchvision.utils.make_grid(batch_inputs) viz_utils.imshow(out, mean, std, title=[class_names[x] for x in batch_labels]) batch_inputs, batch_labels = next(iter(val_loader)) out = torchvision.utils.make_grid(batch_inputs) viz_utils.imshow(out, mean, std, title=[class_names[x] for x in batch_labels]) #create model model = torchvision.models.resnet18(pretrained=True) in_features = model.fc.in_features model.fc = torch.nn.Linear(in_features, len(class_names)) #select gpu device if available device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') #move model to right device model.to(device) #create loss criterion criterion = torch.nn.CrossEntropyLoss() #create optimizer optimizer = torch.optim.Adam(model.parameters(), lr=LR) #create recorder to record metrics during training recorder = TrainMetricRecorder( ['accuracy', 'precision', 'recall', 'f1_score']) print("Training:") fit(model, train_loader, val_loader, optimizer, criterion, EPOCHS, device, recorder) history = recorder.history header = ['train_loss', 'val_loss', 'train_accuracy', 'val_accuracy'] viz_utils.print_table(history[header[0]], history[header[1]], history[header[2]], history[header[3]], header=header)
def train(model, train_data, valid_data, epochs, batch_size, learning_rate, dataset_update="full", increments=1, use_ewc=False, ewc_lambda=1, ewc_samples=100, use_fim=False, fim_threshold=1e-3, fim_samples=100, use_incdet=False, incdet_threshold=None): """ Train a model using a complete dataset. :param model: Model to be trained. :param train_data: Training dataset. :param valid_data: Validation dataset. :param epochs: Number of epochs to train for. :param batch_size: Number of inputs to process simultaneously. :param learning_rate: Initial learning rate for Adam optimiser. :param increments: Number of times to update the dataset (default 1). :param dataset_update: Style of dataset update (full, increment, switch). :param use_ewc: Should EWC be used? :param ewc_lambda: Relative weighting of EWC loss vs normal loss. :param ewc_samples: Samples of dataset to take when initialising EWC. :param use_fim: Should Fisher information masking be used? :param fim_threshold: How important a parameter must be to stop training. :param fim_samples: Samples of dataset to take when initialising FIM. :param use_incdet: Should IncDet (incremental detection) be used? :param incdet_threshold: Threshold for IncDet gradient clipping. """ compile_model(model, learning_rate) all_classes = np.unique(valid_data[1]) class_sets = np.array_split(all_classes, increments) if dataset_update == "permute": train_sets, perms = datasets.permute_pixels(train_data, increments) valid_sets, _ = datasets.permute_pixels(valid_data, increments, perms) else: train_sets = datasets.split_data(train_data, classes=class_sets) valid_sets = datasets.split_data(valid_data, classes=class_sets) epochs_per_step = epochs // increments regularisers = [] gradient_mask = None if not use_incdet: incdet_threshold = None for step in range(increments): # Get a training dataset for this step. inputs, labels = dataset_selector[dataset_update](train_sets, step) current_epoch = step * epochs_per_step for epoch in range(current_epoch, current_epoch + epochs_per_step): train_epoch(model, (inputs, labels), batch_size, gradient_mask=gradient_mask, incdet_threshold=incdet_threshold) report(model, epoch, valid_sets, batch_size) # If we're using EWC, generate a loss function which adds a penalty if # the model strays from the current state. This aims to preserve # performance on the current dataset, which may not be seen again. if use_ewc: loss_fn = ewc.ewc_loss(ewc_lambda, model, (inputs, labels), ewc_samples) regularisers.append(loss_fn) compile_model(model, learning_rate, extra_losses=regularisers) # If using FIM, determine which weights must be frozen to preserve # performance on the current dataset. elif use_fim: new_mask = ewc.fim_mask(model, (inputs, labels), fim_samples, fim_threshold) gradient_mask = ewc.combine_masks(gradient_mask, new_mask)
def generate_data(size, test_part): points = ds.get_random_uniform(2, size, -5, 5) points = _add_padding(points, 0.3) labels = _get_xor_labels(points) train, test = ds.split_data(points, labels, test_part) return train, test
model_path = os.path.join(pargs.models_home, model_path) if not os.path.exists(model_path): os.makedirs(model_path) if hasattr(params, 'model_dir'): params.set_hparam('model_dir', model_path) else: params.add_hparam('model_dir', model_path) logging.info('\nPARAMETERS:\n--------------\n{}\n--------------\n'.format( params.to_json())) # split data into train/valid/test train_interactions, valid_interactions, test_interactions = split_data( interactions=dataset['interactions'], split_ratio=(3, 1, 1), random_seed=RANDOM_SEED) eval_users = np.array( np.random.choice(np.arange(len(dataset['user_ids'])), size=params.n_users_in_validation, replace=False)) if params.mode == 'train': train_model(params, train_interactions, valid_interactions, eval_users) else: logging.info('Get item popularities') item_popularities = get_item_popularity(train_interactions) mmr = get_median_rank_recommended_items(train_interactions, eval_users, item_popularities,
from keras.applications.imagenet_utils import preprocess_input sys.path.append('../utils') from data_augmentation_reid import ImageGenerator from datasets import DataManager from datasets import split_data if __name__ == '__main__': dataset_name = 'market' batch_size = 32 input_shape = (224, 224, 3) classes = 751 data_loader = DataManager(dataset_name) images_path = data_loader.dataset_path ground_truth_data = data_loader.get_data() train_keys, val_keys = split_data(ground_truth_data, 0.2) #print ground_truth_data f = open('../result/market_ground_truth.txt', 'w') f.write(str(ground_truth_data)) f.close() #np.savetxt('../result/market_ground_truth.txt',ground_truth_data) #print len(ground_truth_data) #print len(train_keys) #print train_keys[0] #print ground_truth_data[train_keys[0]] #print images_path #print ground_truth_data[train_keys[1]] #print ground_truth_data[train_keys[0]][0] #print ground_truth_data[train_keys[1]][0] #print ground_truth_data