def active_learning(config): from data_process import makeDataSet from trainer.trainer import Trainer logger = config.get_logger('train') train_set, valid_set, query_set = makeDataSet(config) model = makeModel(config) logger.info(model) criterion = makeLoss(config) metrics = makeMetrics(config) optimizer = makeOptimizer(config, model) # lr_scheduler = makeLrSchedule(config, optimizer, train_set) trainer = Trainer( model, criterion, metrics, optimizer, config=config, train_dataset=train_set, valid_dataset=valid_set, query_dataset=query_set, test_dataset=None, # lr_scheduler=lr_scheduler ) trainer.train()
def main(): # Define a curriculum for the training curriculum = Curriculum() curriculum.add(Program({"n_units": 1000, "n_outs": 10, "batch_size": 64, "epoch": 1}, [Target.lte("loss", 0.19), Target.gte("accuracy", 0.941)])) curriculum.add(Program({"n_units": 1000, "n_outs": 10, "batch_size": 100, "epoch": 1}, [Target.lte("loss", 0.19), Target.gte("accuracy", 0.941)])) curriculum.add(Program({"n_units": 1000, "n_outs": 10, "batch_size": 128, "epoch": 1}, [Target.lte("loss", 0.19), Target.gte("accuracy", 0.941)])) # Define figures to visualize the training # VisualizerDefinition: x_axis = activites.key, y_axis = results.key visualizer = Visualizer([ VisualizerDefinition("batch_size", "loss", "Compare loss for hyperparameter: batch_size, iteration #1"), VisualizerDefinition("batch_size", "accuracy", "Compare accuracy for hyperparameter: accuracy, iteration #1") ]) # Defines the trainer trainer = Trainer(curriculum, visualizer) # Defines the trainer callback # Called at each training iteration and should call the network with the parameters defined in the activity def trainer_callback(activities): sum_loss, sum_accuracy = network(activities["n_units"], activities["n_outs"], activities["batch_size"], activities["epoch"]) # Values that will be used in trainer and will be compared to the Targets return {"loss": sum_loss, "accuracy": sum_accuracy} trainer.train("./example/output", trainer_callback)
def main(config, resume): train_logger = Logger() model = get_instance(module_arch, 'arch', config) img_sz = config["train_loader"]["args"]["resize"] if config["arch"]["type"] != "HighResolutionNet": model.summary(input_shape=(3, img_sz, img_sz)) else: dump_input = torch.rand((1, 3, img_sz, img_sz)) print(get_model_summary(model, dump_input, verbose=True)) train_loader = get_instance(module_data, 'train_loader', config).loader valid_loader = get_instance(module_data, 'valid_loader', config).loader loss = getattr(module_loss, config['loss']) metrics = [getattr(module_metric, met) for met in config['metrics']] trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = get_instance(torch.optim, 'optimizer', config, trainable_params) lr_scheduler = get_instance(torch.optim.lr_scheduler, 'lr_scheduler', config, optimizer) trainer = Trainer(model, loss, metrics, optimizer, resume=resume, config=config, data_loader=train_loader, valid_data_loader=valid_loader, lr_scheduler=lr_scheduler, train_logger=train_logger) trainer.train()
def train(cfg): train_ds = COCODataset(cfg.train_imgs_path, cfg.train_anno_path, resize_size=cfg.resize_size) train_dl = DataLoader(train_ds, batch_size=cfg.batch_size, shuffle=False, num_workers=cfg.num_workers, collate_fn=train_ds.collate_fn) if cfg.eval: eval_ds = COCODataset(cfg.eval_imgs_path, cfg.eval_anno_path, resize_size=cfg.resize_size) eval_dl = DataLoader(eval_ds, batch_size=max(cfg.batch_size // 2, 1), num_workers=cfg.num_workers, collate_fn=eval_ds.collate_fn) else: eval_dl = None model = CenterNet(cfg) if cfg.gpu: model = model.cuda() loss_func = Loss(cfg) trainer = Trainer(cfg, model, loss_func, train_dl, eval_dl) trainer.train()
def main(config): #%% preprocessing = Preprocessing_sasrec('/content/drive/MyDrive/brunch/data') item_num = max(preprocessing.content2num.values()) train_dataset = BrunchDataset(preprocessing.train_df, item_num) train_len = int(0.9*len(train_dataset)) valid_len = len(train_dataset) - train_len train_dataset, val_dataset = random_split(train_dataset, [train_len, valid_len]) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True ) val_loader = torch.utils.data.DataLoader( val_dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True ) model = SASRec(item_num, config) model.to(config.SYSTEM.DEVICE) criterion = torch.nn.BCEWithLogitsLoss() # torch.nn.BCELoss() optimizer = torch.optim.Adam(model.parameters(), lr=config.TRAIN.BASE_LR, betas=(0.9, 0.98)) trainer = Trainer(model, criterion, optimizer, train_loader, val_loader, config) trainer.train(config.TRAIN.EPOCH)
def main(config): print('loading dataset') nlp_dataset = NPLMDataset(csv_file=config.data_path, root_dir='.', config=config) dataloader = DataLoader( nlp_dataset, batch_size=config.batch_size, shuffle=False, num_workers=0, collate_fn=collate_fn, ) model = EmbeddingModule( len(nlp_dataset.word_to_idx), config.embedding_dim, config.h_dim, config, ).to(config.device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=1e-3) trainer = Trainer(dataset, model, criterion, optimizer, config) trainer.train() model = trainer.model with open('./checkpoints/nplm_model.pkl', 'wb') as f: pickle.dump(model, f)
def main(config, resume): logger = Logger() act = config['data_loader']['activate'] if act == 0: # ICDAR 2019 LSVT data_loader = ICDAR2019DataLoaderFactory(config) train = data_loader.train() val = data_loader.val() elif act == 1: pass os.environ['CUDA_VISIBLE_DEVICES'] = ','.join( [str(i) for i in config['gpus']]) model = eval(config['arch'])(config) # model.summary() loss = eval(config['loss'])(config) metrics = [eval(metric) for metric in config['metrics']] trainer = Trainer(model, loss, metrics, resume=resume, config=config, data_loader=train, valid_data_loader=val, train_logger=logger, toolbox=Toolbox()) trainer.train()
def main(config): logger = config.get_logger('train') num_words = config["dataset"]["args"]["num_words"] num_phoneme_thr = config["dataset"]["args"]["num_phoneme_thr"] split = config["dataset"]["args"]["split"] cmu_dict_path = config["dataset"]["args"]["cmu_dict_path"] data_struct_path = config["dataset"]["args"]["data_struct_path"] p_field_path = config["dataset"]["args"]["field_vocab_paths"]["phonemes"] g_field_path = config["dataset"]["args"]["field_vocab_paths"]["graphemes"] vis_feat_dir = config["dataset"]["args"]["vis_feat_dir"] batch_size = config["data_loader"]["args"]["batch_size"] shuffle = config["data_loader"]["args"]["shuffle"] drop_last = config["data_loader"]["args"]["drop_last"] pin_memory = config["data_loader"]["args"]["pin_memory"] num_workers = config["data_loader"]["args"]["num_workers"] train_dataset = DatasetV(num_words, num_phoneme_thr, cmu_dict_path, vis_feat_dir, "train", data_struct_path, p_field_path, g_field_path, True) train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers, pin_memory=pin_memory, shuffle=True, drop_last=True, collate_fn=collate_fn) val_dataset = DatasetV(num_words, num_phoneme_thr, cmu_dict_path, vis_feat_dir, "val", data_struct_path, p_field_path, g_field_path, False) val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, num_workers=num_workers, pin_memory=pin_memory, shuffle=False, drop_last=True, collate_fn=collate_fn) model = config.init('arch', module_arch) logger.info(model) trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = config.init('optimizer', torch.optim, trainable_params) lr_scheduler = config.init('lr_scheduler', torch.optim.lr_scheduler, optimizer) trainer = Trainer( model, optimizer, config=config, lr_scheduler=lr_scheduler, num_words=num_words, logger=logger, train_dataset=train_dataset, train_dataloader=train_dataloader, val_dataset=val_dataset, val_dataloader=val_dataloader, ) trainer.train()
def main(): config = get_args() if config.load_model is not None: model, features, target_feature = load_model(config) data_loader = DataLoader(config, split=False, pretrained=True) data_loader.setup(features, target_feature) evaluator = Evaluator(config) evaluator.evaluate_pretrianed(model, data_loader, target_feature) exit(0) if config.load_checkpoint: auc, acc, pred, classes, completed = load_checkpoint(config) data_loader = DataLoader(config, split=not config.active_features) evaluator = Evaluator(config) trainer = Trainer(config, data_loader, evaluator) if config.load_checkpoint: evaluator.set_checkpoint(auc, acc, pred, classes) trainer.set_completed(completed) trainer.train() if not config.active_features: print(f"AUC ({config.evaluation_mode}): {evaluator.get_auc()}") print(f"Accuracy ({config.evaluation_mode}): {evaluator.get_accuracy()}") evaluator.save(data_loader.getFeatures()) display_runtime(config)
def main(config, resume): torch.manual_seed(config["seed"]) np.random.seed(config["seed"]) train_dataset = initialize_config(config["train_dataset"]) train_data_loader = DataLoader( dataset=train_dataset, shuffle=config["train_dataloader"]["shuffle"], batch_size=config["train_dataloader"]["batch_size"], num_workers=config["train_dataloader"]["num_workers"]) validation_dataset = initialize_config(config["validation_dataset"]) valid_data_loader = DataLoader( dataset=validation_dataset, num_workers=config["validation_dataloader"]["num_workers"], batch_size=config["validation_dataloader"]["batch_size"]) model = initialize_config(config["model"]) optimizer = torch.optim.Adam(params=model.parameters(), lr=config["optimizer"]["lr"], betas=(config["optimizer"]["beta1"], 0.999)) loss_function = initialize_config(config["loss_function"]) trainer = Trainer(config=config, resume=resume, model=model, loss_function=loss_function, optimizer=optimizer, train_dataloader=train_data_loader, validation_dataloader=valid_data_loader) trainer.train()
def main(): args = parse_args() trainer = Trainer(args) trainer.save_config() trainer.train() trainer.save_model()
def main(config: ConfigParser): # 获取一个logging.getLogger,默认日志级别为debug logger = config.get_logger('train') # 数据模块 # 获取config中读取到的config.json里的loader的名字,并实例化,用json里的参数去填充 data_loader = config.init_obj('data_loader', module_data) valid_data_loader = data_loader.split_validation() # 模型模块 model = config.init_obj('arch', module_arch) logger.info(model) # 损失与评估模块 criterion = getattr(module_loss, config['loss']) # 这里面存的是function,也可能存的是类,通过__name__方法获得名字 metrics = [getattr(module_metric, met) for met in config['metrics']] # 优化器模块 # filter,过滤掉false值 trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = config.init_obj('optimizer', torch.optim, trainable_params) # 学习率衰减策略 lr_scheduler = config.init_obj('lr_scheduler', torch.optim.lr_scheduler, optimizer) # 训练模型 trainer = Trainer(model, criterion, metrics, optimizer, config=config, data_loader=data_loader, valid_data_loader=valid_data_loader, lr_scheduler=lr_scheduler) trainer.train()
def main(config): device = torch.device('cuda') logger = config.get_logger('trainer') dataset = config.initialize('dataset', dataset_module) train_loader = config.initialize('data_loader', data_loader_module, dataset) test_loader = train_loader.get_test_loader() model = Model().to(device) logger.info(model) metrics = [getattr(metric_module, mtr) for mtr in config['metrics']] loss = getattr(F, config['loss']) trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = config.initialize('optimizer', torch.optim, trainable_params) scheduler = config.initialize('scheduler', torch.optim.lr_scheduler, optimizer) trainer = Trainer(model, loss, metrics, config, optimizer, train_loader, test_loader=test_loader, scheduler=scheduler) trainer.train()
def main(config, resume): train_logger = Logger() # setup data_loader instances data_loader = get_instance(module_data, 'data_loader', config) valid_data_loader = data_loader.split_validation() # build model architecture model = get_instance(module_arch, 'arch', config) print(model) # get function handles of loss and metrics loss = [getattr(module_loss, l) for l in config['loss']] metrics = [getattr(module_metric, met) for met in config['metrics']] # build optimizer, learning rate scheduler. delete every lines containing lr_scheduler for disabling scheduler trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = get_instance(torch.optim, 'optimizer', config, trainable_params) Lambda = [l for l in config['Lambda']] lr_scheduler = get_instance(torch.optim.lr_scheduler, 'lr_scheduler', config, optimizer) trainer = Trainer(model, loss, Lambda, metrics, optimizer, resume=resume, config=config, data_loader=data_loader, valid_data_loader=valid_data_loader, lr_scheduler=lr_scheduler, train_logger=train_logger) trainer.train()
def main(config, resume): train_logger = Logger() # Build model architecture model = get_instance(module_arch, 'arch', config) img_sz = config["train_loader"]["args"]["resize"] model.summary(input_shape=(3, img_sz, img_sz)) # Setup data_loader instances train_loader = get_instance(module_data, 'train_loader', config).loader valid_loader = get_instance(module_data, 'valid_loader', config).loader # Get function handles of loss and metrics loss = getattr(module_loss, config['loss']) metrics = [getattr(module_metric, met) for met in config['metrics']] # Build optimizer, learning rate scheduler. trainable_params = filter(lambda p: p.requires_grad, model.parameters()) optimizer = get_instance(torch.optim, 'optimizer', config, trainable_params) lr_scheduler = get_instance(torch.optim.lr_scheduler, 'lr_scheduler', config, optimizer) # Create trainer and start training trainer = Trainer(model, loss, metrics, optimizer, resume=resume, config=config, data_loader=train_loader, valid_data_loader=valid_loader, lr_scheduler=lr_scheduler, train_logger=train_logger) trainer.train()
def main(): # Base Logger setup MyLogger.logger.setLevel(logging.INFO) logger = MyLogger.logger.getChild(__name__) args = argument_parser() # params from argparse csvpath = args.train_data BATCH_SIZE = args.batch_size EPOCHS = args.epochs OUTPKL = args.outpkl MDL_OUTDIR = args.mdl_outdir if not os.path.exists(MDL_OUTDIR): os.mkdir(MDL_OUTDIR) LOSS_HISTORY = {} MODELS = [] # (width, depth) DEEP_MODEL = [(18, 1), (9, 4), (8, 5)] # (width) SHALLOW_MODEL = [128] training_dataset = TrainingDataset(csvpath) train_loader = DataLoader(training_dataset, shuffle=True, batch_size=BATCH_SIZE) # append different models for w in SHALLOW_MODEL: MODELS.append(ShallowNet(w)) for w, d in DEEP_MODEL: MODELS.append(DeepNet(depth=d, width=w)) # train EPOCHS epochs for each model in MODELS for model in MODELS: model_name = model.get_name() logger.info("Start training {}".format(model_name)) trainer = Trainer(model, train_loader) # add model loss history into dictionary LOSS_HISTORY[model_name] = [] s = time.time() for epoch in range(EPOCHS): trainer.train(epoch + 1) LOSS_HISTORY[model_name].append(trainer.loss) e = time.time() torch.save(model, "{}/{}.h5".format(MDL_OUTDIR, model_name)) logger.info( "Finished training {} Time elapsed: {: .3f} seconds. \n".format( model_name, e - s)) logger.info("Finished training all models. Dumping loss history") with open(OUTPKL, 'wb') as f: pickle.dump(LOSS_HISTORY, f) logger.info("Finished dumping. Existing program...")
def main(): # TODO: Implement argparse params = {'n_estimators': 10000, 'num_leaves': 30, 'learning_rate': 0.01} training_params = {'early_stop_round': 100, 'verbose': 100} trainer = Trainer('lightgbm', params, training_params) trainer.train()
def main(config, resume): torch.manual_seed(config["seed"]) np.random.seed(config["seed"]) def pad_to_longest(batch): mixture_list = [] clean_list = [] names = [] n_frames_list = [] for mixture, clean, n_frames, name in batch: mixture_list.append(torch.tensor(mixture).reshape(-1, 1)) clean_list.append(torch.tensor(clean).reshape(-1, 1)) n_frames_list.append(n_frames) names.append(name) # seq_list = [(L_1, 1), (L_2, 1), ...] # item.size() must be (L, *) # return (longest_len, len(seq_list), *) mixture_list = pad_sequence(mixture_list).squeeze(2).permute(1, 0) clean_list = pad_sequence(clean_list).squeeze(2).permute(1, 0) return mixture_list, clean_list, n_frames_list, names train_dataset = initialize_config(config["train_dataset"]) train_data_loader = DataLoader( shuffle=config["train_dataloader"]["shuffle"], dataset=train_dataset, batch_size=config["train_dataloader"]["batch_size"], num_workers=config["train_dataloader"]["num_workers"], collate_fn=pad_to_longest, drop_last=True) validation_dataset = initialize_config(config["validation_dataset"]) valid_data_loader = DataLoader( dataset=validation_dataset, num_workers=config["validation_dataloader"]["num_workers"], batch_size=config["validation_dataloader"]["batch_size"], collate_fn=pad_to_longest, shuffle=config["validation_dataloader"]["shuffle"]) model = initialize_config(config["model"]) optimizer = torch.optim.Adam(params=model.parameters(), lr=config["optimizer"]["lr"], betas=(config["optimizer"]["beta1"], 0.999)) loss_function = initialize_config(config["loss_function"]) trainer = Trainer(config=config, resume=resume, model=model, optimizer=optimizer, loss_function=loss_function, train_dataloader=train_data_loader, validation_dataloader=valid_data_loader) trainer.train()
def main(config, resume): """ 训练脚本的入口函数 Notes: 1. 加载数据集 2. 初始化模型 3. 设置优化器 4. 选择损失函数 5. 训练脚本 run Args: config (dict): 配置项 resume (bool): 是否加载最近一次存储的模型断点 """ torch.manual_seed(config["seed"]) np.random.seed(config["seed"]) train_dataset = TrainDataset( mixture_dataset=config["train_dataset"]["mixture"], mask_dataset=config["train_dataset"]["clean"], limit=config["train_dataset"]["limit"], offset=config["train_dataset"]["offset"], ) train_data_loader = DataLoader( dataset=train_dataset, batch_size=config["train_dataset"]["batch_size"], num_workers=config["train_dataset"]["num_workers"], shuffle=config["train_dataset"]["shuffle"]) valid_dataset = TestDataset( mixture_dataset=config["valid_dataset"]["mixture"], clean_dataset=config["valid_dataset"]["clean"], limit=config["valid_dataset"]["limit"], offset=config["valid_dataset"]["offset"], ) valid_data_loader = DataLoader(dataset=valid_dataset) model = initialize_config(config["model"]) optimizer = torch.optim.Adam(params=model.parameters(), lr=config["optimizer"]["lr"]) loss_function = initialize_config(config["loss_function"]) trainer = Trainer( config=config, resume=resume, model=model, loss_function=loss_function, optim=optimizer, train_dl=train_data_loader, validation_dl=valid_data_loader, ) trainer.train()
def main(config): logger = config.get_logger("train") data_loader = CityscapesDataLoader( config["data_loader"]["args"]["data_dir"], config["data_loader"]["args"]["train_extra"], config["data_loader"]["args"]["batch_size"], config["data_loader"]["args"]["num_workers"], ) num_classes = config["arch"]["args"]["num_classes"] model = DeepLabv3Plus(num_classes=num_classes) logger.info( summary( model, (3, 1024, 2048), col_names=("kernel_size", "output_size", "num_params"), depth=5, verbose=0, ) ) device, device_ids = prepare_device(config["n_gpu"]) model = model.to(device) if len(device_ids) > 1: model = nn.DataParallel(model, device_ids=device_ids) ignore_index = config["loss"]["args"]["ignore_index"] criterion = nn.CrossEntropyLoss(ignore_index=ignore_index) metrics = SegmentationMetrics(num_classes, ignore_index) optimizer = torch.optim.SGD( model.parameters(), lr=config["optimizer"]["args"]["lr"], momentum=config["optimizer"]["args"]["momentum"], weight_decay=config["optimizer"]["args"]["weight_decay"], ) lr_scheduler = PolynomialLRDecay( optimizer, max_decay_steps=config["lr_scheduler"]["args"]["max_decay_steps"], end_learning_rate=config["lr_scheduler"]["args"]["end_learning_rate"], power=config["lr_scheduler"]["args"]["power"], ) trainer = Trainer( config=config, model=model, criterion=criterion, metrics=metrics, optimizer=optimizer, device=device, train_loader=data_loader.train_loader, val_loader=data_loader.val_loader, lr_scheduler=lr_scheduler, ) trainer.train()
def main(args): config = ConfigParser(args) cfg = config.config logger = get_logger(config.log_dir, "train") train_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) validation_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) train_dataset = CTImageLoader(link_label_file=cfg["train_data"], image_size=cfg["input_size"], root_folder=cfg["root_folder"], transforms=train_transform) validation_dataset = CTImageLoader(link_label_file=cfg["validation_data"], image_size=cfg["input_size"], root_folder=cfg["root_folder"], transforms=validation_transform) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=cfg["train_batch_size"], shuffle=True, num_workers=cfg["workers"], drop_last=True) vali_loader = torch.utils.data.DataLoader( validation_dataset, batch_size=cfg["vali_batch_size"], shuffle=False, num_workers=cfg["workers"], drop_last=False) model = resnet50(number_class=3, pretrained=True) criterion = getattr(loss, 'cross_entropy') optimizer = optim.SGD(model.parameters(), lr=cfg["lr"], momentum=0.9, weight_decay=cfg["weight_decay"]) metrics_name = ["accuracy"] trainer = Trainer(model=model, criterion=criterion, optimizer=optimizer, train_loader=train_loader, nb_epochs=config['epoch'], valid_loader=vali_loader, logger=logger, log_dir=config.save_dir, metrics_name=metrics_name, resume=config['resume'], save_dir=config.save_dir) trainer.train()
def train_model_once(subject_id, i_valid_fold, config, model_state_dict=None): # Data loading data = get_dataset(subject_id, i_valid_fold, config["experiment"]["dataset"], config) # import pickle # from base.base_data_loader import BaseDataLoader # from braindecode.datautil.splitters import split_into_train_valid_test # pickle_path = os.path.abspath( # os.path.join(os.path.dirname(__file__), '..', # 'data/bcic_iv_2a_all_9_subjects.pickle')) # with open(pickle_path, 'rb') as f: # data = pickle.load(f) # data = data[0] # train, valid, test = split_into_train_valid_test(data, 4, 0) # data = BaseDataLoader(train, valid, test, 4) # Build model architecture model = get_model(data, model_state_dict, config) # Set iterator and metric function handle iterator = get_iterator(model, data, config) predict_label_func = get_prediction_func(config) # Get function handle of loss loss_function = get_loss(config) # Build optimizer, learning rate scheduler stop_criterion = get_stop_criterion(config) optimizer = get_optmizer(model, config) print(model) # Init trainer and train trainer = Trainer( data.train_set, data.validation_set, data.test_set, model, optimizer, iterator, loss_function, stop_criterion, model_constraint=MaxNormDefaultConstraint(), cuda=torch.cuda.is_available(), func_compute_pred_labels=predict_label_func, siamese=(config["experiment"]["type"] == "ccsa_da"), ) trainer.train() # Save results log_training_results(trainer) file_state_dict = save_result_and_model(trainer, model, config) return file_state_dict
def main(config, resume): """ 训练脚本的入口函数 Args: config (dict): 配置项 resume (bool): 是否加载最近一次存储的模型断点 """ torch.manual_seed(config["seed"]) np.random.seed(config["seed"]) train_dataset = initialize_config(config["train_dataset"]) validation_dataset = initialize_config(config["validation_dataset"]) train_data_loader = DataLoader( dataset=train_dataset, batch_size=config["train_dataloader"]["batch_size"], num_workers=config["train_dataloader"]["num_workers"], shuffle=config["train_dataloader"]["shuffle"]) collate_all_data = lambda data_list: data_list valid_data_loader = DataLoader( dataset=validation_dataset, batch_size=config["validation_dataloader"]["batch_size"], num_workers=config["validation_dataloader"]["num_workers"], collate_fn=collate_all_data) generator = initialize_config(config["generator_model"]) discriminator = initialize_config(config["discriminator_model"]) generator_optimizer = torch.optim.Adam(params=generator.parameters(), lr=config["optimizer"]["G_lr"]) discriminator_optimizer = torch.optim.Adam( params=discriminator.parameters(), lr=config["optimizer"]["D_lr"], betas=(config["optimizer"]["beta1"], 0.999)) loss_function = initialize_config(config["loss_function"]) trainer = Trainer( config=config, resume=resume, G=generator, D=discriminator, optim_G=generator_optimizer, optim_D=discriminator_optimizer, loss_function=loss_function, train_dl=train_data_loader, validation_dl=valid_data_loader, ) trainer.train()
def main(config, resume): torch.manual_seed(config["seed"]) # For both GPU and CPU np.random.seed(config["seed"]) random.seed(config["seed"]) train_dataset = initialize_config(config["train_dataset"]) train_data_loader = DataLoader( dataset=train_dataset, batch_size=config["train_dataloader"]["batch_size"], num_workers=config["train_dataloader"]["num_workers"], shuffle=config["train_dataloader"]["shuffle"], pin_memory=config["train_dataloader"]["pin_memory"], collate_fn=train_dataset.pad_batch ) validation_dataset = initialize_config(config["validation_dataset"]) valid_data_loader = DataLoader( dataset=validation_dataset, num_workers=1, batch_size=1 ) generator = initialize_config(config["generator_model"]) discriminator = initialize_config(config["discriminator_model"]) generator_optimizer = torch.optim.Adam( params=generator.parameters(), lr=config["optimizer"]["G_lr"], betas=(config["optimizer"]["beta1"], config["optimizer"]["beta2"]) ) discriminator_optimizer = torch.optim.Adam( params=discriminator.parameters(), lr=config["optimizer"]["D_lr"], betas=(config["optimizer"]["beta1"], config["optimizer"]["beta2"]) ) loss_function = initialize_config(config["loss_function"]) trainer = Trainer( config=config, resume=resume, generator=generator, discriminator=discriminator, generator_optimizer=generator_optimizer, discriminator_optimizer=discriminator_optimizer, loss_function=loss_function, train_dl=train_data_loader, validation_dl=valid_data_loader, ) trainer.train()
def main(config, resume): train_logger = Logger() # load data train_dataloader = ICDARDataLoader(config).train() # initial model os.environ['CUDA_VISIBLE_DEVICES'] = ','.join([str(i) for i in config['gpus']]) model = Model(config) model.summary() loss = Loss() trainer = Trainer(model, loss, resume, config, train_dataloader, train_logger) trainer.train()
def main(): # Processing config file config = get_config_from_json('.\\utils\\config.json') # Processing data train_dataset, val_dataset, test_dataset, num_train_features, num_train_samples, num_val_samples, num_test_samples = getData( mypath, config) # Creating an empty model dense_model = DenseModel(num_train_features, config) load_flag = config.experiment.load # load model from h5 file if load_flag == True: try: print('Loading saved model') dense_model.load(".\\h5 models\\" + model_version) results = dense_model.model.evaluate( test_dataset, steps=int(num_test_samples / (config.model.batch_size))) print('test loss, test acc:', results) except Exception as ex: print(ex) print("Invalid model file name provided") # build and train and save a new model elif load_flag == False: try: dense_model.build_model() print('Create the trainer') trainer = Trainer(dense_model.model, train_dataset, val_dataset, config, steps_per_epoch=int(num_train_samples / config.model.batch_size), val_steps=int(num_val_samples / config.model.batch_size)) print('Start training the model.') trainer.train() dense_model.save(".\\h5_models\\" + model_version) except Exception as ex: print(ex) print("Unable to create new model") else: print("Invalid load flag in config file") logging.info('---------Successful execution---------')
def train(cfg): train_ds = VOCDataset(cfg.root, mode=cfg.split, resize_size=cfg.resize_size) train_dl = DataLoader(train_ds, batch_size=1, shuffle=True, num_workers=cfg.num_workers, collate_fn=train_ds.collate_fn, pin_memory=True) model = CenterNet(cfg) if cfg.gpu: model = model.cuda() loss_func = Loss(cfg) epoch = 100 cfg.max_iter = len(train_dl) * epoch cfg.steps = (int(cfg.max_iter * 0.6), int(cfg.max_iter * 0.8)) trainer = Trainer(cfg, model, loss_func, train_dl, None) trainer.train()
def main(config, resume): train_logger = Logger() # setup data_loader instances data_loader_class = getattr(module_data, config['data_loader']['type']) data_loader = data_loader_class(**config['data_loader']['args']) valid_data_loader = data_loader.split_validation() # build model architecture generator_class = getattr(module_arch, config['generator']['type']) generator = generator_class(**config['generator']['args']) discriminator_class = getattr(module_arch, config['discriminator']['type']) discriminator = discriminator_class(**config['discriminator']['args']) print(generator) print(discriminator) # get function handles of loss and metrics loss = {k: getattr(module_loss, v) for k, v in config['loss'].items()} metrics = [getattr(module_metric, met) for met in config['metrics']] # build optimizer for generator and discriminator generator_trainable_params = filter(lambda p: p.requires_grad, generator.parameters()) discriminator_trainable_params = filter(lambda p: p.requires_grad, discriminator.parameters()) optimizer_class = getattr(torch.optim, config['optimizer']['type']) optimizer = dict() optimizer['generator'] = optimizer_class(generator_trainable_params, **config['optimizer']['args']) optimizer['discriminator'] = optimizer_class( discriminator_trainable_params, **config['optimizer']['args']) # build learning rate scheduler for generator and discriminator lr_scheduler = dict() lr_scheduler['generator'] = get_lr_scheduler(config['lr_scheduler'], optimizer['generator']) lr_scheduler['discriminator'] = get_lr_scheduler( config['lr_scheduler'], optimizer['discriminator']) # start to train the network trainer = Trainer(config, generator, discriminator, loss, metrics, optimizer, lr_scheduler, resume, data_loader, valid_data_loader, train_logger) trainer.train()
def main(config, resume): torch.manual_seed(config["seed"]) # both CPU and CUDA np.random.seed(config["seed"]) train_dataloader = DataLoader( dataset=initialize_config(config["train_dataset"]), batch_size=config["train_dataloader"]["batch_size"], num_workers=config["train_dataloader"]["num_workers"], shuffle=config["train_dataloader"]["shuffle"], pin_memory=config["train_dataloader"][ "pin_memory"] # Very small data set False ) validation_dataloader = DataLoader( dataset=initialize_config(config["validation_dataset"]), batch_size=1, num_workers=1, ) generator = initialize_config(config["generator_model"]) discriminator = initialize_config(config["discriminator_model"]) generator_optimizer = torch.optim.Adam( params=generator.parameters(), lr=config["optimizer"]["G_lr"], betas=(config["optimizer"]["beta1"], config["optimizer"]["beta2"])) discriminator_optimizer = torch.optim.Adam( params=discriminator.parameters(), lr=config["optimizer"]["D_lr"], betas=(config["optimizer"]["beta1"], config["optimizer"]["beta2"])) additional_loss_function = initialize_config( config["additional_loss_function"]) trainer = Trainer( config=config, resume=resume, generator=generator, discriminator=discriminator, generator_optimizer=generator_optimizer, discriminator_optimizer=discriminator_optimizer, additional_loss_function=additional_loss_function, train_dl=train_dataloader, validation_dl=validation_dataloader, ) trainer.train()
def main(data, load=0): X_train = data[0].X_train_std Y_train = data[0].Y_train X_test = data[0].X_test_std Y_test = data[0].Y_test for i in range(1, len(data)): X_train = np.concatenate((X_train, data[i].X_train_std), axis=0) Y_train = np.concatenate((Y_train, data[i].Y_train), axis=0) X_test = np.concatenate((X_test, data[i].X_test_std), axis=0) Y_test = np.concatenate((Y_test, data[i].Y_test), axis=0) num_features = X_train.shape[1] logging.info('Size of X_Train: %s', X_train.shape) logging.info('Size of X_Train: %s', Y_train.shape) logging.info('Data loaded succesfully') dense_model = DenseModel(num_features) # load model from h5 file if load == 1: dense_model.load(".\saved_models\\Mercury 1.h5") results = dense_model.model.evaluate(X_test, Y_test, batch_size=32) print('test loss, test acc:', results) # build and train and save model else: print('Create the model.') dense_model.build_model() print('Create the trainer') trainer = Trainer(dense_model.model, X_train, Y_train, epochs=100, batch_size=32) print('Start training the model.') trainer.train() dense_model.save(".\saved_models\\Mercury 1.h5")
# -*- coding: utf-8 -*- import os from trainer.trainer import Trainer trainer = Trainer() trainer.train(10, 1, False) trainer.test()