def run_cart_abc(path, t_s):
# newsgroups_train = fetch_20newsgroups(subset='train')
# newsgroups_test = fetch_20newsgroups(subset='test')
# X_train = newsgroups_train.data
# X_test = newsgroups_test.data
# y_train = newsgroups_train.target
# y_test = newsgroups_test.target
# clf = Pipeline([('vect', CountVectorizer()),
# ('tfidf', TfidfTransformer()),
# ('clf', DecisionTreeClassifier()),
# ])
# clf.fit(X_train, y_train)
# score = get_score(clf, X_test, y_test)
# modification_rate = 0.3
# cycle = 10
# columns = [c for c in range(len(X_train))]
# abc = ArtificialBeeColony(clf, columns, X_train, X_test, y_train, y_test, modification_rate)
# accuracy, selected_features, bee, _ = abc.execute(cycle, score)
# print(reports(y_test, bee.get_y_pred()))
test_size = 0.3
x_axis = []
y_axis = []
df = load(path)
features, labels = get_features_labels(df)
for i in range(1):
# print(df)
x_axis.append(test_size)
X_train, X_test, y_train, y_test = get_train_test_data(
features, labels, test_size)
# y_test_binarized = class_binarize(y_test, [1, 2])
clf = DecisionTreeClassifier()
clf = train_cart(clf, X_train, y_train)
# n_classes = y_test_binarized.shape[1]
y_pred = test_cart(clf, X_test)
# y_pred_binarized = class_binarize(y_pred, [1, 2])
score = get_score(clf, X_test, y_test)
modification_rate = 0.85
max_limit = 3
cycle = 2
food_num = int(len(X_train) / 30)
abc = ArtificialBeeColony(clf, X_train.columns, X_train, X_test,
y_train, y_test, modification_rate, food_num)
accuracy, selected_features, bee, _ = abc.execute(
cycle, score, max_limit)
# print(score)
# print(clf.classes_)
# print(accuracy)
y_axis.append(accuracy)
# print(f'Test Size: {test_size}')
print(reports(y_test, bee.get_y_pred()))
def run(args: Namespace):
global LOGGER
global RUN
img_shape = (1, args.img_size, args.img_size)
# noinspection PyMethodMayBeStatic
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
def block(in_feat, out_feat, normalize=True):
layers = [nn.Linear(in_feat, out_feat)]
if normalize:
layers.append(nn.BatchNorm1d(out_feat, 0.8))
layers.append(nn.LeakyReLU(0.2, inplace=True))
return layers
self.model = nn.Sequential(
*block(args.latent_dim, 128, normalize=False),
*block(128, 256), *block(256, 512), *block(512, 1024),
nn.Linear(1024, int(np.prod(img_shape))), nn.Tanh())
def forward(self, z_batch):
img = st_heaviside.straight_through(self.model(z_batch))
return img.view(img.size(0), *img_shape)
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.model = nn.Sequential(nn.Linear(int(np.prod(img_shape)), 512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 1), nn.Sigmoid())
def forward(self, img):
img_flat = img.view(img.shape[0], -1)
validity = self.model(img_flat)
return validity
adversarial_loss = torch.nn.BCELoss()
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
# Initialize optimizers for generator and discriminator
optimizer_g = torch.optim.Adam(generator.parameters(), lr=args.g_lr)
optimizer_d = torch.optim.Adam(discriminator.parameters(), lr=args.d_lr)
# Map to CUDA if necessary
if CUDA:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# Initialize weights
generator.apply(weights_init_xavier)
discriminator.apply(weights_init_xavier)
# Create checkpoint handler and load state if required
current_epoch = 0
checkpoint_g = Checkpoint(CWD, generator, optimizer_g)
checkpoint_d = Checkpoint(CWD, discriminator, optimizer_d)
if args.resume:
RUN, current_epoch = checkpoint_g.load()
_, _ = checkpoint_d.load()
LOGGER = Logger(CWD, RUN, args)
print('Loaded models from disk. Starting at epoch {}.'.format(
current_epoch + 1))
else:
LOGGER = Logger(CWD, RUN, args)
# Configure data loader
opts = {'binary': True, 'crop': 20}
mnist_loader = data_loader.load(args, opts)
for epoch in range(current_epoch, args.n_epochs):
for i, imgs in enumerate(mnist_loader):
# Adversarial ground truths with noise
valid = 0.8 + torch.rand(imgs.shape[0], 1).type(TENSOR) * 0.3
valid = Variable(valid, requires_grad=False)
fake = torch.rand(imgs.shape[0], 1).type(TENSOR) * 0.3
fake = Variable(fake, requires_grad=False)
# Configure input
real_imgs = Variable(imgs)
# -----------------
# Train Generator
# -----------------
optimizer_g.zero_grad()
# Sample noise as generator input
z = Variable(
torch.randn(imgs.shape[0], args.latent_dim).type(TENSOR))
# Generate a batch of images
fake_images = generator(z)
# Loss measures generator's ability to fool the discriminator
g_loss = adversarial_loss(discriminator(fake_images), valid)
g_loss.backward()
optimizer_g.step()
# ---------------------
# Train Discriminator
# ---------------------
optimizer_d.zero_grad()
# Measure discriminator's ability to classify real from generated samples
real_scores = discriminator(real_imgs)
real_loss = adversarial_loss(real_scores, valid)
fake_scores = discriminator(fake_images.detach())
fake_loss = adversarial_loss(fake_scores, fake)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_d.step()
batches_done = epoch * len(mnist_loader) + i + 1
if batches_done % args.sample_interval == 0:
LOGGER.log_generated_sample(fake_images, batches_done)
LOGGER.log_batch_statistics(epoch, args.n_epochs, i + 1,
len(mnist_loader), d_loss, g_loss,
real_scores, fake_scores)
LOGGER.log_tensorboard_basic_data(g_loss, d_loss, real_scores,
fake_scores, batches_done)
if args.log_details:
if batches_done == args.sample_interval:
LOGGER.save_image_grid(real_imgs, fake_images,
batches_done)
else:
LOGGER.save_image_grid(None, fake_images, batches_done)
# -- Save model checkpoints after each epoch -- #
checkpoint_g.save(RUN, epoch)
checkpoint_d.save(RUN, epoch)
LOGGER.close_writers()
def run(args: argparse.Namespace):
global LOGGER
global RUN
img_shape = (1, args.img_size, args.img_size)
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
def block(in_feat, out_feat, normalize=True):
layers = [nn.Linear(in_feat, out_feat)]
if normalize:
layers.append(nn.BatchNorm1d(out_feat, 0.8))
layers.append(nn.LeakyReLU(0.2, inplace=True))
return layers
self.model = nn.Sequential(
*block(args.latent_dim, 128, normalize=False),
*block(128, 256),
*block(256, 512),
*block(512, 1024),
nn.Linear(1024, int(np.prod(img_shape))),
)
self.out = nn.LogSigmoid()
def forward(self, z_batch):
linear = self.model(z_batch)
white_prob = self.out(linear).view(args.batch_size,
args.img_size**2, 1)
black_prob = self.out(-linear).view(args.batch_size,
args.img_size**2, 1)
probs = torch.cat([black_prob, white_prob], dim=-1)
img = st_gumbel_softmax.straight_through(probs, args.temp, True)
return img.view(img.shape[0], *img_shape)
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.model = nn.Sequential(nn.Linear(int(np.prod(img_shape)), 512),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(512, 256),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(256, 1))
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()
# Optimizers
optimizer_g = torch.optim.RMSprop(generator.parameters(), lr=args.g_lr)
optimizer_d = torch.optim.RMSprop(discriminator.parameters(), lr=args.d_lr)
if CUDA:
generator.cuda()
discriminator.cuda()
# Initialize weights
generator.apply(weights_init_xavier)
discriminator.apply(weights_init_xavier)
# Create checkpoint handler and load state if required
current_epoch = 0
checkpoint_g = Checkpoint(CWD, generator, optimizer_g)
checkpoint_d = Checkpoint(CWD, discriminator, optimizer_d)
if args.resume:
RUN, current_epoch = checkpoint_g.load()
_, _ = checkpoint_d.load()
LOGGER = Logger(CWD, RUN, args)
print('Loaded models from disk. Starting at epoch {}.'.format(
current_epoch + 1))
else:
LOGGER = Logger(CWD, RUN, args)
# Configure data loader
opts = {
'binary': True,
}
batched_data = data_loader.load(args, opts)
# ----------
# Training
# ----------
for epoch in range(current_epoch, args.n_epochs):
for i, imgs in enumerate(batched_data):
# Configure input
real_imgs = Variable(imgs.type(TENSOR))
# ---------------------
# Train Discriminator
# ---------------------
optimizer_d.zero_grad()
# Sample noise as generator input
z = Variable(
torch.randn(imgs.shape[0], args.latent_dim).type(TENSOR))
# Generate a batch of images
fake_images = generator(z).detach()
# Adversarial loss
loss_d = -torch.mean(discriminator(real_imgs)) + torch.mean(
discriminator(fake_images))
loss_d.backward()
optimizer_d.step()
# Clip weights of discriminator
for p in discriminator.parameters():
p.data.clamp_(-args.clip_value, args.clip_value)
batches_done = epoch * len(batched_data) + i + 1
# Train the generator every n_critic iterations
if batches_done % args.n_critic == 0:
# -----------------
# Train Generator
# -----------------
optimizer_g.zero_grad()
# Generate a batch of images
fake_images = generator(z)
# Adversarial loss
loss_g = -torch.mean(discriminator(fake_images))
loss_g.backward()
optimizer_g.step()
if batches_done % args.sample_interval == 0:
LOGGER.log_generated_sample(fake_images, batches_done)
LOGGER.log_batch_statistics(epoch, args.n_epochs, i + 1,
len(batched_data), loss_d,
loss_g)
LOGGER.log_tensorboard_basic_data(loss_g,
loss_d,
step=batches_done)
if args.log_details:
if batches_done == args.sample_interval:
LOGGER.save_image_grid(real_imgs, fake_images,
batches_done)
else:
LOGGER.save_image_grid(None, fake_images,
batches_done)
# -- Save model checkpoints after each epoch -- #
checkpoint_g.save(RUN, epoch)
checkpoint_d.save(RUN, epoch)
def run(opt):
global LOGGER
global RUN
# noinspection PyMethodMayBeStatic
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.init_size = opt.maze_size**2 // 4
self.l1 = nn.Sequential(
nn.Linear(opt.latent_dim, 128 * self.init_size))
self.model = nn.Sequential(
nn.BatchNorm1d(128), nn.Upsample(scale_factor=2),
nn.Conv1d(128, 128, 3, stride=1, padding=1),
nn.BatchNorm1d(128, 0.8), nn.LeakyReLU(0.2, inplace=True),
nn.Upsample(scale_factor=2),
nn.Conv1d(128, 64, 3, stride=1, padding=1),
nn.BatchNorm1d(64, 0.8), nn.LeakyReLU(0.2, inplace=True),
nn.Conv1d(64, 1, 3, stride=1, padding=1), nn.Tanh())
def forward(self, z):
out = self.l1(z)
out = out.view(out.shape[0], 128, self.init_size)
fake_mazes = self.model(out)
fake_mazes = straight_through(fake_mazes)
return fake_mazes
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
def discriminator_block(in_filters, out_filters, bn=True):
block = [
nn.Conv1d(in_filters, out_filters, 3, 2, 1),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.25)
]
if bn:
block.append(nn.BatchNorm1d(out_filters, 0.8))
return block
self.model = nn.Sequential(
*discriminator_block(1, 16, bn=False),
*discriminator_block(16, 32),
*discriminator_block(32, 64),
*discriminator_block(64, 128),
)
# The height and width of downsampled image
ds_size = math.ceil((opt.maze_size**2) / 4**2)
self.adv_layer = nn.Sequential(nn.Linear(128 * ds_size**1, 1),
nn.Sigmoid())
def forward(self, maze):
out = self.model(maze)
out = out.view(out.shape[0], -1)
validity = self.adv_layer(out)
return validity
adversarial_loss = torch.nn.BCELoss()
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
# Initialize optimizers for generator and discriminator
optimizer_g = torch.optim.Adam(generator.parameters(), lr=opt.g_lr)
optimizer_d = torch.optim.Adam(discriminator.parameters(), lr=opt.d_lr)
# Map to CUDA if necessary
if CUDA:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# Initialize weights
generator.apply(weights_init_xavier)
discriminator.apply(weights_init_xavier)
# Create checkpoint handler and load state if required
current_epoch = 0
checkpoint_g = Checkpoint(CWD, generator, optimizer_g)
checkpoint_d = Checkpoint(CWD, discriminator, optimizer_d)
if opt.resume:
RUN, current_epoch = checkpoint_g.load()
_, _ = checkpoint_d.load()
LOGGER = Logger(CWD, RUN, opt)
print('Loaded models from disk. Starting at epoch {}.'.format(
current_epoch + 1))
else:
LOGGER = Logger(CWD, RUN, opt)
# Configure data loader
opts = {
'binary': True,
}
maze_loader = data_loader.load(opt, opts)
for epoch in range(current_epoch, opt.n_epochs):
for i, mazes in enumerate(maze_loader):
mazes = mazes.reshape(opt.batch_size, -1).type(TENSOR).float()
# Adversarial ground truths
# valid = Variable(torch.ones(mazes.shape[0], 1).type(TENSOR), requires_grad=False)
# fake = Variable(torch.zeros(mazes.shape[0], 1).type(TENSOR), requires_grad=False)
# Adversarial ground truths with noise
valid = 0.8 + torch.rand(mazes.shape[0], 1).type(TENSOR) * 0.3
valid = Variable(valid, requires_grad=False)
fake = torch.rand(mazes.shape[0], 1).type(TENSOR) * 0.3
fake = Variable(fake, requires_grad=False)
# Configure input
real_mazes = Variable(mazes)
# -----------------
# Train Generator
# -----------------
optimizer_g.zero_grad()
# Sample noise as generator input
z = Variable(
torch.randn(mazes.shape[0], opt.latent_dim).type(TENSOR))
# Generate a batch of images
fake_mazes = generator(z)
# Loss measures generator's ability to fool the discriminator
g_loss = adversarial_loss(discriminator(fake_mazes), valid)
g_loss.backward()
optimizer_g.step()
# ---------------------
# Train Discriminator
# ---------------------
optimizer_d.zero_grad()
# Measure discriminator's ability to classify real from generated samples
real_mazes = real_mazes.unsqueeze_(1)
real_scores = discriminator(real_mazes)
real_loss = adversarial_loss(real_scores, valid)
fake_scores = discriminator(fake_mazes.detach())
fake_loss = adversarial_loss(fake_scores, fake)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_d.step()
batches_done = epoch * len(maze_loader) + i + 1
if batches_done % opt.sample_interval == 0:
fake_mazes = fake_mazes.reshape(fake_mazes.size(0),
opt.maze_size, opt.maze_size)
fake_mazes[fake_mazes < 0.5] = 0
fake_mazes[fake_mazes > 0.5] = 1
#correct = 0
#for maze in fake_mazes:
# correct += int(check_maze(maze.detach()))
#print(correct)
real_mazes = real_mazes.reshape(real_mazes.size(0),
opt.maze_size, opt.maze_size)
LOGGER.log_generated_sample(fake_mazes, batches_done)
LOGGER.log_batch_statistics(epoch, opt.n_epochs, i + 1,
len(maze_loader), d_loss, g_loss,
real_scores, fake_scores)
LOGGER.log_tensorboard_basic_data(g_loss, d_loss, real_scores,
fake_scores, batches_done)
if opt.log_details:
LOGGER.save_image_grid(real_mazes, fake_mazes,
batches_done)
# LOGGER.log_tensorboard_parameter_data(discriminator, generator, batches_done)
# -- Save model checkpoints after each epoch -- #
checkpoint_g.save(RUN, epoch)
checkpoint_d.save(RUN, epoch)
LOGGER.close_writers()
def run(args: Namespace):
global LOGGER
global RUN
# noinspection PyMethodMayBeStatic
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.init_size = args.img_size // 4
self.filters = 32
self.l1 = nn.Linear(args.latent_dim, self.filters * self.init_size ** 2)
self.conv_blocks = nn.Sequential(
nn.BatchNorm2d(self.filters),
nn.Upsample(scale_factor=2),
nn.Conv2d(self.filters, self.filters, 3, stride=1, padding=1),
nn.BatchNorm2d(self.filters, 0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Upsample(scale_factor=2),
nn.Conv2d(self.filters, self.filters // 2, 3, stride=1, padding=1),
nn.BatchNorm2d(self.filters // 2, 0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(self.filters // 2, 1, 3, stride=1, padding=1),
nn.Tanh()
)
def forward(self, z_batch):
out = self.l1(z_batch)
out = out.view(out.shape[0], self.filters, self.init_size, self.init_size)
img = self.conv_blocks(out)
return img
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.filters = 8
def discriminator_block(in_filters, out_filters, step, bn=True):
block = [nn.Conv2d(in_filters, out_filters, 3, step, 1),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout2d(0.25)]
if bn:
block.append(nn.BatchNorm2d(out_filters, 0.8))
return block
self.model = nn.Sequential(
*discriminator_block(1, self.filters, 1, bn=False),
*discriminator_block(self.filters, self.filters * 2, 2),
*discriminator_block(self.filters * 2, self.filters * 4, 1),
*discriminator_block(self.filters * 4, self.filters * 8, 2),
)
# The height and width of downsampled image
ds_size = args.img_size // 2 ** 2
self.adv_layer = nn.Sequential(
nn.Linear(self.filters * 8 * ds_size ** 2, 1),
nn.Sigmoid()
)
def forward(self, img):
out = self.model(img)
out = out.view(out.shape[0], -1)
validity = self.adv_layer(out)
return validity
adversarial_loss = torch.nn.BCELoss()
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
# Initialize optimizers for generator and discriminator
optimizer_g = torch.optim.Adam(generator.parameters(), lr=args.g_lr)
optimizer_d = torch.optim.Adam(discriminator.parameters(), lr=args.d_lr)
# Map to CUDA if necessary
if CUDA:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# Initialize weights
generator.apply(weights_init_xavier)
discriminator.apply(weights_init_xavier)
# Create checkpoint handler and load state if required
current_epoch = 0
checkpoint_g = Checkpoint(CWD, generator, optimizer_g)
checkpoint_d = Checkpoint(CWD, discriminator, optimizer_d)
if args.resume:
RUN, current_epoch = checkpoint_g.load()
_, _ = checkpoint_d.load()
LOGGER = Logger(CWD, RUN, args)
print('Loaded models from disk. Starting at epoch {}.'.format(current_epoch + 1))
else:
LOGGER = Logger(CWD, RUN, args)
# Configure data loader
opts = {
'binary': False,
'crop': 20
}
mnist_loader = data_loader.load(args, opts)
for epoch in range(current_epoch, args.n_epochs):
for i, imgs in enumerate(mnist_loader):
# Adversarial ground truths with noise
valid = 0.8 + torch.rand(imgs.shape[0], 1).type(TENSOR) * 0.3
valid = Variable(valid, requires_grad=False)
fake = torch.rand(imgs.shape[0], 1).type(TENSOR) * 0.3
fake = Variable(fake, requires_grad=False)
# Configure input
real_imgs = Variable(imgs)
# -----------------
# Train Generator
# -----------------
optimizer_g.zero_grad()
# Sample noise as generator input
z = Variable(torch.randn(imgs.shape[0], args.latent_dim).type(TENSOR))
# Generate a batch of images
fake_images = generator(z)
# Loss measures generator's ability to fool the discriminator
g_loss = adversarial_loss(discriminator(fake_images), valid)
g_loss.backward()
optimizer_g.step()
# ---------------------
# Train Discriminator
# ---------------------
optimizer_d.zero_grad()
# Measure discriminator's ability to classify real from generated samples
real_scores = discriminator(real_imgs)
real_loss = adversarial_loss(real_scores, valid)
fake_scores = discriminator(fake_images.detach())
fake_loss = adversarial_loss(fake_scores, fake)
d_loss = (real_loss + fake_loss) / 2
d_loss.backward()
optimizer_d.step()
batches_done = epoch * len(mnist_loader) + i + 1
if batches_done % args.sample_interval == 0:
LOGGER.log_generated_sample(fake_images, batches_done)
LOGGER.log_batch_statistics(epoch, args.n_epochs, i + 1, len(mnist_loader), d_loss, g_loss, real_scores,
fake_scores)
LOGGER.log_tensorboard_basic_data(g_loss, d_loss, real_scores, fake_scores, batches_done)
if args.log_details:
if batches_done == args.sample_interval:
LOGGER.save_image_grid(real_imgs, fake_images, batches_done)
else:
LOGGER.save_image_grid(None, fake_images, batches_done)
# -- Save model checkpoints after each epoch -- #
checkpoint_g.save(RUN, epoch)
checkpoint_d.save(RUN, epoch)
LOGGER.close_writers()
def run_compare(path):
df = load(path)
run_comp_test(df)
def run_cart_kfold(path, n_splits):
df = load(path)
features, labels = get_features_labels(df)
cv = StratifiedKFold(n_splits=n_splits)
avg_scores = np.array([])
clf = DecisionTreeClassifier()
x_axis = []
y_axis = []
y_axis_1 = []
train_num = 900
food_num_coef = 0
cycle = 1.5
while cycle < 15:
cycle = int(cycle * 1.5)
modification_rate = 0.85
# food_num_coef += 0.01
max_limit = 3
food_num = 50
for i, (train, test) in enumerate(cv.split(features, labels)):
probas_ = clf.fit(features.iloc[train],
labels.iloc[train]).predict_proba(
features.iloc[test])
score = clf.score(features.iloc[test], labels.iloc[test])
abc = ArtificialBeeColony(clf, features.columns,
features.iloc[train],
features.iloc[test], labels.iloc[train],
labels.iloc[test], modification_rate,
food_num)
accuracy, selected_features, bee, _ = abc.execute(
cycle, score, max_limit)
print(f'Score Fold-{i+1}: {accuracy}')
avg_scores = np.append(avg_scores, accuracy)
avg = np.average(avg_scores)
std = np.std(avg_scores)
y_axis.append(avg)
y_axis_1.append(std)
x_axis.append(cycle)
print(f'Score Average-: {avg}')
plt.plot(x_axis, y_axis)
plt.ylabel('accuracy')
plt.xlabel('cycle')
plt.show()
plt.plot(x_axis, y_axis_1)
plt.ylabel('standard deviation')
plt.xlabel('cycle')
plt.show()
def run(args: Namespace):
global LOGGER
global RUN
# noinspection PyMethodMayBeStatic
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.init_size = args.maze_size**2 // 4
self.l1 = nn.Sequential(
nn.Linear(args.latent_dim, 128 * self.init_size))
self.model = nn.Sequential(
nn.BatchNorm1d(128),
nn.Upsample(scale_factor=2),
nn.Conv1d(128, 128, 3, stride=1, padding=1),
nn.BatchNorm1d(128, 0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Upsample(scale_factor=2),
nn.Conv1d(128, 64, 3, stride=1, padding=1),
nn.BatchNorm1d(64, 0.8),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv1d(64, 1, 3, stride=1, padding=1),
)
self.out = nn.LogSigmoid()
def forward(self, z):
map1 = self.l1(z)
map1 = map1.view(map1.size(0), 128, self.init_size)
conv = self.model(map1).view(args.batch_size, args.img_size**2, 1)
white_prob = self.out(conv).view(args.batch_size, args.img_size**2,
1)
black_prob = self.out(-conv).view(args.batch_size,
args.img_size**2, 1)
probs = torch.cat([black_prob, white_prob], dim=-1)
img = st_gumbel_softmax.straight_through(probs, args.temp, True)
return img.view(args.batch_size, 1, args.img_size**2)
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
def discriminator_block(in_filters, out_filters, bn=True):
block = [
nn.Conv1d(in_filters, out_filters, 3, 2, 1),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.25)
]
if bn:
block.append(nn.BatchNorm1d(out_filters, 0.8))
return block
self.model = nn.Sequential(
*discriminator_block(1, 16, bn=False),
*discriminator_block(16, 32, bn=False),
*discriminator_block(32, 64, bn=False),
*discriminator_block(64, 128, bn=False),
)
# The height and width of down sampled image
ds_size = math.ceil((args.img_size**2) / 4**2)
self.adv_layer = nn.Linear(128 * ds_size, 1)
def forward(self, maze):
out = self.model(maze)
out = out.view(out.shape[0], -1)
validity = self.adv_layer(out)
return validity
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
# Initialize optimizers for generator and discriminator
optimizer_g = torch.optim.RMSprop(generator.parameters(), lr=args.g_lr)
optimizer_d = torch.optim.RMSprop(discriminator.parameters(), lr=args.d_lr)
# Map to CUDA if necessary
if CUDA:
generator.cuda()
discriminator.cuda()
# Initialize weights
generator.apply(weights_init_xavier)
discriminator.apply(weights_init_xavier)
# Create checkpoint handler and load state if required
current_epoch = 0
checkpoint_g = Checkpoint(CWD, generator, optimizer_g)
checkpoint_d = Checkpoint(CWD, discriminator, optimizer_d)
if args.resume:
RUN, current_epoch = checkpoint_g.load()
_, _ = checkpoint_d.load()
LOGGER = Logger(CWD, RUN, args)
print('Loaded models from disk. Starting at epoch {}.'.format(
current_epoch + 1))
else:
LOGGER = Logger(CWD, RUN, args)
# Configure data loader
opts = {
'binary': True,
}
batched_data = data_loader.load(args, opts)
for epoch in range(current_epoch, args.n_epochs):
for i, mazes in enumerate(batched_data):
batches_done = epoch * len(batched_data) + i + 1
mazes = mazes.reshape(args.batch_size, 1, -1).type(TENSOR)
# Configure input
real_images = Variable(mazes)
# ---------------------
# Train Discriminator
# ---------------------
optimizer_d.zero_grad()
z = Variable(
torch.randn(real_images.size(0), args.latent_dim).type(TENSOR))
fake_images = generator(z).detach()
# Adversarial loss
loss_d = -torch.mean(discriminator(real_images)) + torch.mean(
discriminator(fake_images))
loss_d.backward()
optimizer_d.step()
# Clip weights of discriminator
for p in discriminator.parameters():
p.data.clamp_(-args.clip_value, args.clip_value)
# Train the generator every n_critic iterations
if batches_done % args.n_critic == 0:
# -----------------
# Train Generator
# -----------------
optimizer_g.zero_grad()
# Generate a batch of images
fake_images = generator(z)
# Adversarial loss
loss_g = -torch.mean(discriminator(fake_images))
loss_g.backward()
optimizer_g.step()
if batches_done % args.sample_interval == 0:
fake_mazes = fake_images.reshape(fake_images.size(0),
args.img_size,
args.img_size)
fake_mazes[fake_mazes < 0.5] = 0
fake_mazes[fake_mazes > 0.5] = 1
real_mazes = real_images.reshape(real_images.size(0),
args.img_size,
args.img_size)
LOGGER.log_generated_sample(fake_mazes, batches_done)
LOGGER.log_batch_statistics(epoch, args.n_epochs, i + 1,
len(batched_data), loss_d,
loss_g)
LOGGER.log_tensorboard_basic_data(loss_g,
loss_d,
step=batches_done)
if args.log_details:
if batches_done == args.sample_interval:
LOGGER.save_image_grid(real_mazes, fake_mazes,
batches_done)
else:
LOGGER.save_image_grid(None, fake_images,
batches_done)
# -- Save model checkpoints after each epoch -- #
checkpoint_g.save(RUN, epoch)
checkpoint_d.save(RUN, epoch)
LOGGER.close_writers()
