def load_dataset_test(data_dir, dataset, batch_size): list_classes_test = [] fas = False path = os.path.join(data_dir, 'Datasets', dataset) if dataset == 'mnist': dataset_test = datasets.MNIST(path, train=False, download=True, transform=transforms.Compose( [transforms.ToTensor()])) elif dataset == 'fashion': if fas: dataset_test = DataLoader(datasets.FashionMNIST( path, train=False, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=batch_size) else: dataset_test = fashion(path, train=False, download=True, transform=transforms.ToTensor()) elif dataset == 'cifar10': transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) dataset_test = datasets.CIFAR10(root=path, train=False, download=True, transform=transform) elif dataset == 'celebA': dataset_test = utils.load_celebA(path + 'celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=batch_size) elif dataset == 'timagenet': dataset_test, labels = get_test_image_folders(path) list_classes_test = np.asarray( [labels[i] for i in range(len(dataset_test))]) dataset_test = Subset(dataset_test, np.where(list_classes_test < 10)[0]) list_classes_test = np.where(list_classes_test < 10)[0] list_classes_test = np.asarray( [dataset_test[i][1] for i in range(len(dataset_test))]) return dataset_test, list_classes_test
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type # EBGAN parameters self.pt_loss_weight = 0.1 self.margin = max(1, self.batch_size / 64.) # margin for loss function # usually margin of 1 is enough, but for large batch size it must be larger than 1 # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.G.cuda() self.D.cuda() self.MSE_loss = nn.MSELoss().cuda() else: self.MSE_loss = nn.MSELoss() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST('data/mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader( datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA('data/celebA', transform=transforms.Compose( [transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor()]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)), volatile=True)
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type # EBGAN parameters self.pt_loss_weight = 0.1 self.margin = max(1, self.batch_size / 64.) # margin for loss function # usually margin of 1 is enough, but for large batch size it must be larger than 1 # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.G.cuda() self.D.cuda() self.MSE_loss = nn.MSELoss().cuda() else: self.MSE_loss = nn.MSELoss() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST('data/mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader( datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA('data/celebA', transform=transforms.Compose( [transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor()]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)), volatile=True)
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type # BEGAN parameters self.gamma = 0.75 self.lambda_ = 0.001 self.k = 0. # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.G.cuda() self.D.cuda() # self.L1_loss = torch.nn.L1loss().cuda() # BEGAN does not work well when using L1loss(). # else: # self.L1_loss = torch.nn.L1loss() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST('data/mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader( datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA('data/celebA', transform=transforms.Compose( [transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor()]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)), volatile=True)
def __init__(self, args): # parameters self.epoch = 2 self.sample_num = 64 self.batch_size = 20000 self.save_dir = './save' self.result_dir = './result' self.dataset ='mnist' self.log_dir = './logs' self.gpu_mode = False self.model_name = 'wgan-gp' self.lrG=1e-4 self.lrD=1e-4 self.lambda_ = 0.25 self.n_critic = 2 # the number of iterations of the critic per generator iteration # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=self.lrG, betas=(0.5,0.9)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=self.lrD, betas=(0.5,0.9)) if self.gpu_mode: self.G.cuda() self.D.cuda() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST('data/mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader( datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA('data/celebA', transform=transforms.Compose( [transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor()]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand((self.batch_size, self.z_dim)), volatile=True)
def __init__(self, args, test_only=False): # parameters self.epoch = args.epoch self.sample_num = 16 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type self.test_only = test_only self.gan_type = args.gan_type # networks init self.G = generator(self.dataset) if not test_only: self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) if not test_only: self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.G.cuda() if not test_only: self.D.cuda() self.BCE_loss = nn.BCELoss().cuda() else: self.BCE_loss = nn.BCELoss() print('---------- Networks architecture -------------') utils.print_network(self.G) if not test_only: utils.print_network(self.D) print('-----------------------------------------------') if not test_only: # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST( 'data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader(datasets.FashionMNIST( 'data/fashion-mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA( 'data/celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)), volatile=True)
def __init__(self): # parameters self.epoch = 35 self.sample_num = 16 self.batch_size = 64 self.save_dir = 'simple gan' self.result_dir = 'results' self.dataset = 'mnist' self.log_dir = 'logs' self.gpu_mode = True self.model_name = 'SimpleGAN' # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=0.0002, betas=(0.5, 0.999)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=0.0002, betas=(0.5, 0.999)) if self.gpu_mode: self.G.cuda() self.D.cuda() self.BCE_loss = nn.BCELoss().cuda() else: self.BCE_loss = nn.BCELoss() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST( 'data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader(datasets.FashionMNIST( 'data/fashion-mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA( 'data/celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)), volatile=True)
def __init__(self, args): # parameters self.root = args.root self.epoch = args.epoch self.sample_num = 16 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.z_dim = args.z_dim self.model_name = args.model_name + '_7' self.load_model = args.load_model self.args = args # load dataset if self.dataset == 'mnist': dset = datasets.MNIST('data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])) valid_dset = datasets.MNIST('data/mnist', train=False, download=True, transform=transforms.Compose([transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=64, shuffle=True) elif self.dataset == 'emnist': dset = datasets.EMNIST('data/emnist', split='balanced', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])) valid_dset = datasets.EMNIST('data/emnist', split='balanced', train=False, download=True, transform=transforms.Compose([transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'cifar10': dset = datasets.CIFAR10(root='data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])) valid_dset = datasets.CIFAR10(root='data/mnist', train=False, download=True, transform=transforms.Compose([transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'svhn': dset = datasets.SVHN(root='data/svhn', split='train', download=True, transform=transforms.Compose([transforms.ToTensor()])) valid_dset = datasets.SVHN(root='data/svhn', split='test', download=True, transform=transforms.Compose([transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': dset = datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])) valid_dset = datasets.FashionMNIST('data/fashion-mnist', train=False, download=True, transform=transforms.Compose( [transforms.ToTensor()])) self.data_loader = DataLoader( dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader( valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': # TODO: add test data dset = utils.load_celebA('data/celebA', transform=transforms.Compose( [transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) # image dimensions if self.dataset == 'svhn': self.height, self.width = dset.data.shape[2:4] self.pix_level = dset.data.shape[1] else: self.height, self.width = dset.train_data.shape[1:3] if len(dset.train_data.shape) == 3: self.pix_level = 1 # elif self.dataset == 'cifar10': # self.height = 2* self.height # self.width = 2 * self.width # self.pix_level = dset.train_data.shape[3] elif len(dset.train_data.shape) == 4: self.pix_level = dset.train_data.shape[3] print("Data shape is height:{}, width:{}, and pixel level:{}\n".format(self.height, self.width, self.pix_level)) # networks init self.G = Generator(self.dataset, self.z_dim, self.height, self.width, self.pix_level) self.E = Encoder(self.dataset, self.z_dim, self.height, self.width, self.pix_level) self.D = Discriminator(self.dataset, self.height, self.width, self.pix_level) self.FC = Feature(self.dataset, self.height, self.width, self.pix_level) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1* 1.2, args.beta2)) self.D_optimizer = optim.Adam(chain(self.D.parameters(), self.FC.parameters()), lr=args.lrD, betas=(args.beta1* 1.2, args.beta2)) self.E_optimizer = optim.Adam(self.E.parameters(), lr=args.lrE, betas=(args.beta1* 1.2, args.beta2)) if torch.cuda.is_available(): self.G.cuda() self.D.cuda() self.E.cuda() self.FC.cuda() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) utils.print_network(self.E) utils.print_network(self.FC) print('-----------------------------------------------')
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 100 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type self.lambda_ = 0.25 self.n_critic = 5 # the number of iterations of the critic per generator iteration self.lambda_cl = 0.2 self.c = 0.01 # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) # self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) # self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) self.G_optimizer = optim.RMSprop(self.G.parameters(), lr=args.lrG) self.D_optimizer = optim.RMSprop(self.D.parameters(), lr=args.lrD) if self.gpu_mode: self.G.cuda() self.D.cuda() self.BCE_loss = nn.BCELoss().cuda() self.CE_loss = nn.CrossEntropyLoss().cuda() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST( 'data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 self.y_dim = 10 elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader(datasets.FashionMNIST( 'data/fashion-mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA( 'data/celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=self.batch_size, shuffle=True) from load_attr import load_attr attr = load_attr() self.attr = torch.FloatTensor(attr) self.z_dim = 62 self.y_dim = 1 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand( (self.sample_num, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)), volatile=True) if self.dataset == 'mnist': temp = torch.zeros((10, 1)) for i in range(self.y_dim): temp[i, 0] = i temp_y = torch.zeros((self.sample_num, 1)) for i in range(10): temp_y[i * self.y_dim:(i + 1) * self.y_dim] = temp self.sample_y_ = torch.zeros((self.sample_num, self.y_dim)) self.sample_y_.scatter_(1, temp_y.type(torch.LongTensor), 1) elif self.dataset == 'celebA': self.sample_y_ = torch.zeros((self.sample_num, self.y_dim)) self.sample_y_[:50, 0] = 1 # self.sample_y_[25:75, 1] = 1 if self.gpu_mode: self.sample_y_ = Variable(self.sample_y_.cuda(), volatile=True) else: self.sample_z_, self.sample_y_ = Variable(self.sample_z_, volatile=True), Variable( self.sample_y_, volatile=True)
type=str, default=None, help= f'path to a saved model for resuming training and/or performing testing (default: None)' ) parser.add_argument( '--save_examples', action='store_true', default=False, help= 'whether to save example images to files during training (default: False)' ) args = parser.parse_args() if args.train or args.test: train_loader, test_loader = utils.load_celebA( data_path=args.data_path, batch_size=args.batch_size) else: print('Neither --train nor --test specified. Quitting.') exit(0) if args.train: vae.train( train_loader, model_path=args.model_path, num_epochs=args.epochs, seed=args.seed, report_freq=args.report_freq, save_examples=args.save_examples, ) if args.test:
def __init__(self, args): # parameters self.root = args.root self.epoch = args.epoch self.sample_num = 16 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.log_dir = args.log_dir self.z_dim = args.z_dim self.model_name = args.model_name self.load_model = args.load_model self.dataset = args.dataset # load dataset if self.dataset == 'mnist': dset = datasets.MNIST('data/mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])) valid_dset = datasets.MNIST('data/mnist', train=False, download=True, transform=transforms.Compose( [transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'cifar10': dset = datasets.CIFAR10(root='data/cifar10', train=True, download=True, transform=transforms.Compose([ transforms.Scale(64), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ])) valid_dset = datasets.CIFAR10(root='data/cifar10', train=False, download=True, transform=transforms.Compose([ transforms.Scale(64), transforms.ToTensor(), transforms.Normalize( mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'svhn': # load SVHN dataset (73257, 3, 32, 32) dset = datasets.SVHN(root='data/svhn', split='train', download=True, transform=transforms.Compose([ transforms.Scale(64), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ])) valid_dset = datasets.SVHN(root='data/svhn', split='test', download=True, transform=transforms.Compose([ transforms.Scale(64), transforms.ToTensor(), transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)) ])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': dset = datasets.FashionMNIST('data/fashion-mnist', train=True, download=True, transform=transforms.Compose( [transforms.ToTensor()])) valid_dset = datasets.FashionMNIST('data/fashion-mnist', train=False, download=True, transform=transforms.Compose( [transforms.ToTensor()])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) self.valid_loader = DataLoader(valid_dset, batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': # TODO: add test data dset = utils.load_celebA('data/celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ])) self.data_loader = DataLoader(dset, batch_size=self.batch_size, shuffle=True) # image dimensions if self.dataset == 'svhn': self.height, self.width = dset.data.shape[2:4] self.pix_level = dset.data.shape[1] else: self.height, self.width = dset.train_data.shape[1:3] if len(dset.train_data.shape) == 3: self.pix_level = 1 elif self.dataset == 'cifar10': self.height = 64 self.width = 64 self.pix_level = dset.train_data.shape[3] elif len(dset.train_data.shape) == 4: self.pix_level = dset.train_data.shape[3] # networks init self.G = Generator(self.z_dim, self.pix_level) self.E = Encoder(self.z_dim, self.pix_level) self.D = Discriminator(self.pix_level) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) self.E_optimizer = optim.Adam(self.E.parameters(), lr=args.lrE, betas=(args.beta1, args.beta2)) if torch.cuda.is_available(): self.G.cuda() self.D.cuda() self.E.cuda() self.BCE_loss = nn.BCELoss().cuda() else: self.BCE_loss = nn.BCELoss() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) utils.print_network(self.E) print('-----------------------------------------------') # load in saved model if self.load_model: self.load()
download=True), batch_size=batch_size, shuffle=True) elif dset == 'fashion-mnist': train_loader = DataLoader(dataset=datasets.FashionMNIST( root='./data/', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=batch_size, shuffle=True) elif dset == 'celebA': train_loader = utils.load_celebA('./data/', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=batch_size, shuffle=True) elif dset == 'cifar10': train_loader = DataLoader(dataset=datasets.CIFAR10( root='./data/', train=True, transform=transforms.ToTensor(), download=True), batch_size=batch_size, shuffle=True) """Generator""" class Generator(nn.Module):
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type # BEGAN parameters self.gamma = 0.75 self.lambda_ = 0.001 self.k = 0. # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.G.cuda() self.D.cuda() # self.L1_loss = torch.nn.L1loss().cuda() # BEGAN does not work well when using L1loss(). # else: # self.L1_loss = torch.nn.L1loss() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST( 'data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader(datasets.FashionMNIST( 'data/fashion-mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA( 'data/celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)), volatile=True)
def __init__(self, args): # parameters self.epoch = args.epoch self.sample_num = 64 self.batch_size = args.batch_size self.save_dir = args.save_dir self.result_dir = args.result_dir self.dataset = args.dataset self.log_dir = args.log_dir self.gpu_mode = args.gpu_mode self.model_name = args.gan_type self.dk = args.dk self.c = 0.01 # clipping value self.n_critic = 5 # the number of iterations of the critic per generator iteration if args.dk != 1: self.model_name = "WGAN_DK_" + str(args.dk) print(self.model_name) # networks init self.G = generator(self.dataset) self.D = discriminator(self.dataset) self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2)) self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2)) if self.gpu_mode: self.G.cuda() self.D.cuda() print('---------- Networks architecture -------------') utils.print_network(self.G) utils.print_network(self.D) print('-----------------------------------------------') # load dataset if self.dataset == 'mnist': self.data_loader = DataLoader(datasets.MNIST( 'data/mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'fashion-mnist': self.data_loader = DataLoader(datasets.FashionMNIST( 'data/fashion-mnist', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])), batch_size=self.batch_size, shuffle=True) elif self.dataset == 'celebA': self.data_loader = utils.load_celebA( 'data/celebA', transform=transforms.Compose([ transforms.CenterCrop(160), transforms.Scale(64), transforms.ToTensor() ]), batch_size=self.batch_size, shuffle=True) self.z_dim = 62 # fixed noise if self.gpu_mode: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)).cuda(), volatile=True) else: self.sample_z_ = Variable(torch.rand( (self.batch_size, self.z_dim)), volatile=True)