def train_cycle_gan(data_root, semi_supervised=False): opt = get_opts() ensure_dir(models_prefix) ensure_dir(images_prefix) cycle_gan = CycleGAN(device, models_prefix, opt["lr"], opt["b1"], train=True, semi_supervised=semi_supervised) data = DataLoader(data_root=data_root, image_size=(opt['img_height'], opt['img_width']), batch_size=opt['batch_size']) total_images = len(data.names) print("Total Training Images", total_images) total_batches = int(ceil(total_images / opt['batch_size'])) for epoch in range(cycle_gan.epoch_tracker.epoch, opt['n_epochs']): for iteration in range(total_batches): if (epoch == cycle_gan.epoch_tracker.epoch and iteration < cycle_gan.epoch_tracker.iter): continue y, x = next(data.data_generator(iteration)) real_A = Variable(x.type(Tensor)) real_B = Variable(y.type(Tensor)) cycle_gan.set_input(real_A, real_B) cycle_gan.train() message = ( "\r[Epoch {}/{}] [Batch {}/{}] [DA:{}, DB:{}] [GA:{}, GB:{}, cycleA:{}, cycleB:{}, G:{}]" .format(epoch, opt["n_epochs"], iteration, total_batches, cycle_gan.loss_disA.item(), cycle_gan.loss_disB.item(), cycle_gan.loss_genA.item(), cycle_gan.loss_genB.item(), cycle_gan.loss_cycle_A.item(), cycle_gan.loss_cycle_B.item(), cycle_gan.loss_G)) print(message) logger.info(message) if iteration % opt['sample_interval'] == 0: cycle_gan.save_progress(images_prefix, epoch, iteration) cycle_gan.save_progress(images_prefix, epoch, total_batches, save_epoch=True)
def test_cycle_gan(semi_supervised=True): opt = get_opts() ensure_dir(models_prefix) ensure_dir(images_prefix) cycle_gan = CycleGAN(device, models_prefix, opt["lr"], opt["b1"], train=False, semi_supervised=semi_supervised) data = DataLoader(data_root=data_root, image_size=(opt['img_height'], opt['img_width']), batch_size=1, train=False) total_images = len(data.names) print("Total Testing Images", total_images) loss_A = 0.0 loss_B = 0.0 name_loss_A = [] name_loss_B = [] for i in range(total_images): print(i, "/", total_images) x, y = next(data.data_generator(i)) name = data.names[i] real_A = Variable(x.type(Tensor)) real_B = Variable(y.type(Tensor)) cycle_gan.set_input(real_A, real_B) cycle_gan.test() cycle_gan.save_image(images_prefix, name) loss_A += cycle_gan.test_A loss_B += cycle_gan.test_B name_loss_A.append((cycle_gan.test_A, name)) name_loss_B.append((cycle_gan.test_B, name)) info = "Average Loss A:{} B :{}".format(loss_A / (1.0 * total_images), loss_B / (1.0 * total_images)) print(info) logger.info(info) name_loss_A = sorted(name_loss_A) name_loss_B = sorted(name_loss_B) print("top 10 images") print(name_loss_A[:10]) print(name_loss_B[:10])
def train_cycle_gan(data_root, semi_supervised=False): opt = get_opts() ensure_dir(models_prefix) ensure_dir(images_prefix) cycle_gan = CycleGAN(device, models_prefix, opt["lr"], opt["b1"], train=True, semi_supervised=semi_supervised) # data = DataLoader(data_root=data_root, # image_size=(opt['img_height'], opt['img_width']), # batch_size=opt['batch_size']) dataset = TrainDataSet(data_root=data_root, image_size=(opt['img_height'], opt['img_width'])) print("dataset : ", dataset) dataLoader = DataLoader(dataset, batch_size=1) total_images = len(dataset.names) print("Total Training Images", total_images) total_batches = int(ceil(total_images / opt['batch_size'])) for epoch in range(5): for i, data in enumerate(dataLoader): real_A, real_B = data real_A = Variable(real_A.type(Tensor)) real_B = Variable(real_B.type(Tensor)) cycle_gan.set_input(real_A, real_B) cycle_gan.train() message = ( "\r[Epoch {}/{}] [Batch {}/{}] [DA:{}, DB:{}] [GA:{}, GB:{}, cycleA:{}, cycleB:{}, G:{}]" .format(epoch, opt["n_epochs"], iteration, total_batches, cycle_gan.loss_disA.item(), cycle_gan.loss_disB.item(), cycle_gan.loss_genA.item(), cycle_gan.loss_genB.item(), cycle_gan.loss_cycle_A.item(), cycle_gan.loss_cycle_B.item(), cycle_gan.loss_G)) print(message) logger.info(message)
import discord import logging from discord.ext import commands import utils import sys import os import random CONFIG_FILE = 'discordbot.config' options = utils.get_opts(sys.argv[1:]) if not utils.check_dir('logs'): os.mkdir('logs') logger = logging.getLogger('discord') logger.setLevel(logging.INFO) # Change this to get DEBUG info if necessary handler = logging.FileHandler(filename='logs/discordbot.log', encoding='utf-8', mode='w') handler.setFormatter( logging.Formatter('%(asctime)s:%(levelname)s:%(name)s: %(message)s')) logger.addHandler(handler) # Read configuration file/command line options if options.config: config = utils.read_config(file=options.config) else: config = utils.read_config() logger.info(f'Reading Configuration file: {config}') # Instantiate Bot
import os import numpy as np import torch from torch.autograd import Variable from data_loader import DataLoader from networks import GeneratorUNet, GeneratorResNet, Discriminator, ResNetBlock from utils import ensure_dir, get_opts, weights_init_normal, sample_images from logger import logger device = 'cuda:0' if torch.cuda.is_available() else 'cpu' Tensor = torch.cuda.FloatTensor if torch.cuda.is_available( ) else torch.FloatTensor data = DataLoader(data_root='../gta/', image_size=(512, 512), batch_size=16) opt = get_opts() ensure_dir('saved_images/%s' % 'GTA') ensure_dir('saved_models/%s' % 'GTA') criterion_GAN = torch.nn.MSELoss().to(device) criterion_pixelwise = torch.nn.L1Loss().to(device) lambda_pixel = 10 generator = GeneratorUNet().to(device) discriminator = Discriminator().to(device) generator = torch.nn.DataParallel(generator, list(range(torch.cuda.device_count()))) discriminator = torch.nn.DataParallel(discriminator, list(range(torch.cuda.device_count())))
import torch from easydict import EasyDict from data_loader import CubDataset, FlickrDataset, DefaultCaptionTokenizer, BertCaptionTokenizer from data_preprocess import CubDataPreprocessor, get_preprocessor from self_attn.self_attn_gan import SelfAttnGAN, SelfAttnBert from utils import get_opts torch.set_default_tensor_type(torch.cuda.FloatTensor) device = "cuda" if torch.cuda.is_available() else "cpu" MAX_CAPTION_SIZE = 30 opts = EasyDict(get_opts("config/bert_attn_flickr.yaml")) output_dir = os.path.join("checkpoints/", opts.CHECKPOINTS_DIR) data_dir = 'dataset/' epoch_file = "epoch.txt" log_file = "logs.log" print("Dataset: ", opts.DATASET_NAME, opts.DATA_DIR) preprocessor = get_preprocessor(opts.DATASET_NAME, opts.DATA_DIR) if opts.TEXT.ENCODER == "lstm": ixtoword = preprocessor.get_idx_to_word() tokenizer = DefaultCaptionTokenizer(preprocessor.get_word_to_idx(), MAX_CAPTION_SIZE) else: tokenizer = BertCaptionTokenizer(MAX_CAPTION_SIZE)
import torch from easydict import EasyDict from attnGan.attn_gan import AttnGAN from data_loader import CubDataset, DefaultCaptionTokenizer from data_preprocess import CubDataPreprocessor, get_preprocessor from utils import get_opts device = "cuda" if torch.cuda.is_available() else "cpu" output_dir = "checkpoints/attnGAN" data_dir = 'dataset/' epoch_file = "epoch.txt" log_file = "logs.log" opts = EasyDict(get_opts("config/bird.yaml")) MAX_CAPTION_SIZE = 30 preprocessor = get_preprocessor(opts.DATASET_NAME, opts.DATA_DIR) ixtoword = preprocessor.get_idx_to_word() tokenizer = DefaultCaptionTokenizer(preprocessor.get_word_to_idx(), MAX_CAPTION_SIZE) train_set = CubDataset(preprocessor, opts, tokenizer, mode='train') val_set = CubDataset(preprocessor, opts, tokenizer, mode='val') train_loader = torch.utils.data.DataLoader(train_set, batch_size=opts.TRAIN.BATCH_SIZE, shuffle=True, drop_last=True) val_loader = torch.utils.data.DataLoader(val_set, batch_size=opts.TRAIN.BATCH_SIZE, shuffle=True, drop_last=True) attn_gan = AttnGAN(device, output_dir, opts, ixtoword, train_loader, val_loader) attn_gan.train()
from damsm.damsm import Damsm from damsm.damsm_bert import DamsmBert from data_loader import CubDataset, DefaultCaptionTokenizer, BertCaptionTokenizer, FlickrDataset from data_preprocess import get_preprocessor from utils import get_opts, make_dir, save_checkpoint, EpochTracker device = "cuda" if torch.cuda.is_available() else "cpu" output_directory = "checkpoints" epoch_file = "epoch.txt" log_file = "logs.log" UPDATE_INTERVAL = 5 MAX_CAPTION_SIZE = 30 opts = EasyDict(get_opts("config/damsm_bert_bird.yaml")) def create_loader(opts): print("Dataset: ", opts.DATASET_NAME) preprocessor = get_preprocessor(opts.DATASET_NAME, opts.DATA_DIR) if opts.TEXT.ENCODER != 'bert': ixtoword = preprocessor.get_idx_to_word() tokenizer = DefaultCaptionTokenizer(preprocessor.get_word_to_idx(), MAX_CAPTION_SIZE) else: tokenizer = BertCaptionTokenizer(MAX_CAPTION_SIZE) ixtoword = tokenizer.tokenizer.ids_to_tokens if opts.DATASET_NAME == "cub":
model_trainer = Trainer(model, model.criterion, optimizer, config, train_loader, config.n) final_train_loss = model_trainer.train_model() final_test_loss = model_trainer.eval_model(test_loader, directory="test", save_data=True) print("Final loss ->", "\t Train loss: ", final_train_loss, "\t Test loss: ", final_test_loss, "\n", "best_model_index: ", model_trainer.best_model_epoch, ", val loss: ", model_trainer.min_val_loss, " final epoch: ", model_trainer.last_epoch, " Run time: ", model_trainer.train_time, file=open("train.log", "a"), flush=True) if __name__ == '__main__': config = get_opts() main(config)
def main(): global best_result model = DORN() opts = utils.get_opts() epoch_tracker = utils.EpochTracker(epoch_file) train_loader, val_loader = create_loader(opts) name = output_directory + 'checkpoint-' + str( epoch_tracker.epoch) + '.pth.tar' if os.path.exists(name): checkpoint = torch.load(name) start_epoch = checkpoint['epoch'] + 1 best_result = checkpoint['best_result'] optimizer = checkpoint['optimizer'] iteration = checkpoint['iteration'] # solve 'out of memory' model = checkpoint['model'] print("=> loaded checkpoint (epoch {})".format(checkpoint['epoch'])) # clear memory del checkpoint # del model_dict if torch.cuda.is_available(): torch.cuda.empty_cache() else: start_epoch = 0 iteration = 0 # different modules have different learning rate train_params = [{ 'params': model.get_1x_lr_params(), 'lr': opts.lr }, { 'params': model.get_10x_lr_params(), 'lr': opts.lr * 10 }] optimizer = torch.optim.SGD(train_params, lr=opts.lr, momentum=opts.momentum, weight_decay=opts.weight_decay) # You can use DataParallel() whether you use Multi-GPUs or not if torch.cuda.is_available(): model = nn.DataParallel(model).cuda() # when training, use reduceLROnPlateau to reduce learning rate scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=opts.lr_patience) # loss function criterion = criteria.ordLoss(device) if not os.path.exists(output_directory): os.makedirs(output_directory) best_txt = os.path.join(output_directory, 'best.txt') config_txt = os.path.join(output_directory, 'config.txt') # create log log_path = os.path.join( output_directory, 'logs', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname()) if os.path.isdir(log_path): shutil.rmtree(log_path) os.makedirs(log_path) logger = SummaryWriter(log_path) for epoch in range(start_epoch, opts.epochs): # remember change of the learning rate for i, param_group in enumerate(optimizer.param_groups): old_lr = float(param_group['lr']) logger.add_scalar('Lr/lr_' + str(i), old_lr, epoch) train(train_loader, model, criterion, optimizer, epoch, logger, device, opts, iteration) # train for one epoch result, img_merge = validate(val_loader, model, epoch, logger, opts) # evaluate on validation set iteration = 0 # remember best rmse and save checkpoint is_best = result.rmse < best_result.rmse if is_best: best_result = result with open(best_txt, 'w') as txtfile: txtfile.write( "epoch={}, rmse={:.3f}, rml={:.3f}, log10={:.3f}, d1={:.3f}, d2={:.3f}, dd31={:.3f}, " "t_gpu={:.4f}".format(epoch, result.rmse, result.absrel, result.lg10, result.delta1, result.delta2, result.delta3, result.gpu_time)) if img_merge is not None: img_filename = output_directory + '/comparison_best.png' utils.save_image(img_merge, img_filename) # save checkpoint for each epoch utils.save_checkpoint( { 'args': opts, 'epoch': epoch, 'model': model, 'best_result': best_result, 'optimizer': optimizer, 'iteration': iteration }, is_best, epoch, output_directory) epoch_tracker.write(epoch) # when rml doesn't fall, reduce learning rate scheduler.step(result.absrel) logger.close()