def run(): device = 0 if torch.cuda.is_available() else -1 config = BaseConfig() logging.info('%s_cross_entropy/ckpt.pth.tar' % config.result_dir) if os.path.exists('%s_cross_entropy/ckpt.pth.tar' % config.result_dir): return True logging.info("Triplet Trainer Not Return") create_dirs() tr_data_loader, val_data_loader, te_data_loader = loaders.data_loaders( shuffle=True) model = getattr(models, config.network)(num_classes=len(tr_data_loader.dataset.y)) model criterion = CrossEntropyLoss() if device == 0: model.cuda() criterion.cuda() trainer = ModuleTrainer(model) epochs = config.epochs callbacks = [ EarlyStopping(monitor='val_acc', patience=20), ModelCheckpoint('%s_cross_entropy' % config.result_dir, save_best_only=True, verbose=1), CSVLogger("%s_cross_entropy/logger.csv" % config.result_dir) ] metrics = [CategoricalAccuracy()] trainer.compile(loss=criterion, optimizer='adam', metrics=metrics) trainer.set_callbacks(callbacks) trainer.fit_loader(tr_data_loader, val_loader=val_data_loader, num_epoch=epochs, verbose=2, cuda_device=device) tr_loss = trainer.evaluate_loader(tr_data_loader, cuda_device=device) logging.info(tr_loss) val_loss = trainer.evaluate_loader(val_data_loader, cuda_device=device) logging.info(val_loss) te_loss = trainer.evaluate_loader(te_data_loader, cuda_device=device) logging.info(te_loss) with open('%s_cross_entropy' % config.log_path, "a") as f: f.write('Train %s\nVal:%s\nTest:%s\n' % (str(tr_loss), str(val_loss), te_loss))
def run(): from config import get_config config = get_config() import losses import models from utils.make_dirs import create_dirs from datasets import loaders from torchsample.callbacks import EarlyStopping, ModelCheckpoint, CSVLogger from torchsample.metrics import CategoricalAccuracy from torchsample.modules import ModuleTrainer create_dirs() model = getattr(models, config.network).get_network()( channel=config.network_channel, embedding_size=config.embedding) criterion = getattr(losses, config.loss)() if config.cuda: model.cuda() criterion.cuda() trainer = ModuleTrainer(model) callbacks = [ EarlyStopping(monitor='val_loss', patience=50), ModelCheckpoint(config.result_dir, save_best_only=True, verbose=1), CSVLogger("%s/logger.csv" % config.result_dir) ] metrics = [] if config.loader_name == 'data_loaders': metrics.append(CategoricalAccuracy(top_k=1)) trainer.compile(loss=criterion, optimizer='adam', metrics=metrics) trainer.set_callbacks(callbacks) def get_n_params(model): pp = 0 for p in list(model.parameters()): nn = 1 for s in list(p.size()): nn = nn * s pp += nn return pp with open("models.log", mode="a") as f: f.write("%s\n" % str(config.__dict__)) f.write("%s\n" % str(model)) f.write("%s\n" % str(get_n_params(model))) f.write("\n")
def run(): from config import get_config config = get_config() print('%s/ckpt.pth.tar' % config.result_dir) if os.path.exists('%s/ckpt.pth.tar' % config.result_dir): return True print("Contrastive Trainer Not Return") import models from utils.make_dirs import create_dirs from datasets import loaders from torchsample.callbacks import EarlyStopping, ModelCheckpoint, CSVLogger from torchsample.metrics import CategoricalAccuracy from torchsample.modules import ModuleTrainer create_dirs() cuda_device = -1 tr_data_loader, val_data_loader, te_data_loader = loaders.online_pair_loaders() model = getattr(models, config.network).get_network()(channel=config.network_channel, embedding_size=config.embedding) from losses.online_cosine import OnlineCosineLoss from datasets.data_utils import AllPositivePairSelector, HardNegativePairSelector margin = 0.5 if args.selector == 'AllPositivePairSelector': criterion = OnlineCosineLoss(margin, AllPositivePairSelector()) elif args.selector == 'HardNegativePairSelector': criterion = OnlineCosineLoss(margin, HardNegativePairSelector()) if config.cuda: model.cuda() criterion.cuda() trainer = ModuleTrainer(model) epochs = config.epochs callbacks = [EarlyStopping(monitor='val_loss', patience=50), ModelCheckpoint(config.result_dir, save_best_only=True, verbose=1), CSVLogger("%s/logger.csv" % config.result_dir)] metrics = [] if config.loader_name == 'data_loaders' and 'Angle' not in config.loss: metrics.append(CategoricalAccuracy(top_k=1)) trainer.compile(loss=criterion, optimizer='adam', metrics=metrics) trainer.set_callbacks(callbacks) if config.cuda: cuda_device = 0 start_time = time.time() trainer.fit_loader(tr_data_loader, val_loader=val_data_loader, num_epoch=epochs, verbose=2, cuda_device=cuda_device) end_time = time.time() with open("%s/app.log" % config.result_dir, mode="a") as f: f.write("%s\n" % str(model)) f.write("%s %s\n" % (config.loss, str(end_time - start_time))) tr_loss = trainer.evaluate_loader(tr_data_loader, cuda_device=cuda_device) print(tr_loss) val_loss = trainer.evaluate_loader(val_data_loader, cuda_device=cuda_device) te_loss = trainer.evaluate_loader(te_data_loader, cuda_device=cuda_device) print(te_loss) with open(config.log_path, "a") as f: f.write('Train %s\nVal:%s\nTest:%s\n' % (str(tr_loss), str(val_loss), te_loss)) tr_data_loader, val_data_loader, te_data_loader = loaders.data_loaders(train=False, val=True) tr_y_pred = trainer.predict_loader(tr_data_loader, cuda_device=cuda_device) save_embeddings(tr_y_pred, '%s/train_embeddings.csv' % config.result_dir) save_labels(tr_data_loader, '%s/train_labels.csv' % config.result_dir) val_y_pred = trainer.predict_loader(val_data_loader, cuda_device=cuda_device) save_embeddings(val_y_pred, '%s/val_embeddings.csv' % config.result_dir) save_labels(val_data_loader, '%s/val_labels.csv' % config.result_dir) te_y_pred = trainer.predict_loader(te_data_loader, cuda_device=cuda_device) save_embeddings(te_y_pred, '%s/test_embeddings.csv' % config.result_dir) save_labels(te_data_loader, '%s/test_labels.csv' % config.result_dir)
def train_net(train, val, model, name): transformations_train = transforms.apply_chain([ transforms.random_fliplr(), transforms.random_flipud(), transforms.augment(), torchvision.transforms.ToTensor() ]) transformations_val = transforms.apply_chain([ torchvision.transforms.ToTensor(), ]) dset_train = KaggleAmazonJPGDataset(train, paths.train_jpg, transformations_train, divide=False) train_loader = DataLoader(dset_train, batch_size=64, shuffle=True, num_workers=10, pin_memory=True) dset_val = KaggleAmazonJPGDataset(val, paths.train_jpg, transformations_val, divide=False) val_loader = DataLoader(dset_val, batch_size=64, num_workers=10, pin_memory=True) ignored_params = list(map(id, chain( model.classifier.parameters(), model.layer1.parameters(), model.layer2.parameters(), model.layer3.parameters(), model.layer4.parameters() ))) base_params = filter(lambda p: id(p) not in ignored_params, model.parameters()) optimizer = optim.Adam([ {'params': base_params}, {'params': model.layer1.parameters()}, {'params': model.layer2.parameters()}, {'params': model.layer3.parameters()}, {'params': model.layer4.parameters()}, {'params': model.classifier.parameters()} ], lr=0, weight_decay=0.0005) trainer = ModuleTrainer(model) def schedule(current_epoch, current_lrs, **logs): lrs = [1e-3, 1e-4, 1e-5] epochs = [0, 2, 10] for lr, epoch in zip(lrs, epochs): if current_epoch >= epoch: current_lrs[5] = lr if current_epoch >= 1: current_lrs[4] = lr * 0.4 current_lrs[3] = lr * 0.2 current_lrs[2] = lr * 0.1 current_lrs[1] = lr * 0.05 current_lrs[0] = lr * 0.01 return current_lrs trainer.set_callbacks([ callbacks.ModelCheckpoint( paths.models, name, save_best_only=False, saving_strategy=lambda epoch: True ), CSVLogger('./logs/' + name), LearningRateScheduler(schedule) ]) trainer.compile(loss=nn.BCELoss(), optimizer=optimizer) trainer.fit_loader(train_loader, val_loader, nb_epoch=35, verbose=1, cuda_device=0)