generator = Generator()
discriminator = Discriminator()
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
auxiliary_loss.cuda()
# Initialize weights
generator.apply(weights_init_normal)
discriminator.apply(weights_init_normal)
# Configure data loader
from datasets import G10
dataset = G10(img_size=opt.img_size, use_labels=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batch_size,
shuffle=True)
from utils import sample_real
sample_real(dataloader=dataloader,
batch_size=opt.batch_size,
save_path=DIR_PATH,
labled=True)
# Losses
g_losses_per_epoch = []
d_losses_per_epoch = []
# Optimizers
generator = Generator()
discriminator = Discriminator()
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
auxiliary_loss.cuda()
# Initialize weights
generator.apply(weights_init_normal)
discriminator.apply(weights_init_normal)
# Configure data loader
dataloader = torch.utils.data.DataLoader(
G10(img_size=opt.img_size),
batch_size=opt.batch_size,
shuffle=True,
)
# dataloader = torch.utils.data.DataLoader(
# datasets.MNIST(
# "./src/datasets",
# train=True,
# download=True,
# transform=transforms.Compose(
# [transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]
# ),
# ),
# batch_size=opt.batch_size,
# shuffle=True,
num_epochs = 20
# Learning rate for optimizers
lr = 0.0002
# Beta1 hyperparam for Adam optimizers
beta1 = 0.5
# Number of GPUs available. Use 0 for CPU mode.
ngpu = 0
# Decide which device we want to run on
device = torch.device("cuda:0" if (
torch.cuda.is_available() and ngpu > 0) else "cpu")
dataset = G10(img_size=image_size, just_spirals=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=True)
# Plot some training images
sample_real(dataloader=dataloader, batch_size=batch_size, run_name=RUN_NAME)
def weights_init(m):
classname = m.__class__.__name__
if classname.find("Conv") != -1:
nn.init.normal_(m.weight.data, 0.0, 0.02)
elif classname.find("BatchNorm") != -1:
nn.init.normal_(m.weight.data, 1.0, 0.02)
nn.init.constant_(m.bias.data, 0)
# Configure data loader
# os.makedirs("../../data/mnist", exist_ok=True)
# dataloader = torch.utils.data.DataLoader(
# datasets.MNIST(
# "../../data/mnist",
# train=True,
# download=True,
# transform=transforms.Compose(
# [transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]
# ),
# ),
# batch_size=opt.batch_size,
# shuffle=True,
# )
dataset = G10(img_size=opt.img_size, no_classes=False)
dataloader = torch.utils.data.DataLoader(
dataset, batch_size=opt.batch_size, shuffle=True
)
sample_real(dataloader=dataloader, batch_size=opt.batch_size, run_name=DIR, labled=True)
# Optimizers
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
FloatTensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
LongTensor = torch.cuda.LongTensor if cuda else torch.LongTensor
def sample_image(n_row, batches_done):
def forward(self, img):
img_flat = img.view(img.shape[0], -1)
validity = self.model(img_flat)
return validity
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
if cuda:
generator.cuda()
discriminator.cuda()
# Configure data loader
dataset = G10(img_size=opt.img_size, just_spirals=False)
dataloader = torch.utils.data.DataLoader(
dataset, batch_size=opt.batch_size, shuffle=True
)
# dataloader = torch.utils.data.DataLoader(
# datasets.MNIST(
# "../../data/mnist",
# train=True,
# download=True,
# transform=transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]),
# ),
# batch_size=opt.batch_size,
# shuffle=True,
# )
generator = Generator_Stage1()
discriminator = Discriminator_Stage1()
adversarial_loss = nn.BCELoss()
if CUDA:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# Initialize weights
generator.apply(weights_init_normal)
discriminator.apply(weights_init_normal)
# Configure data loader
dataset = G10(img_size=IMG_SIZE, just_spirals=True)
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=BATCH_SIZE,
shuffle=True)
sample_real(dataloader=dataloader, batch_size=BATCH_SIZE, run_name=DIR)
# Optimizers
optimizer_G = torch.optim.Adam(generator.parameters(), lr=LR, betas=BETAS)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=LR, betas=BETAS)
Tensor = torch.cuda.FloatTensor if CUDA else torch.FloatTensor
# ----------
# Training