def __init__(self):
# load images and scale in range (-1, 1)
self.images_loader = utils.load_images('datasets/patterns/')
# dataset = datasets.CIFAR10(root='./cifar10', train=True, download=True, transform=transform)
# dataloader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True, num_workers=20, drop_last=True)
# Define the network
self.generator = utils.load_network('generator', dcgan.Generator())
self.discriminator = utils.load_network('discriminator',
dcgan.Discriminator())
# print total and trainable parameters for networks
utils.print_parameters(self.generator, 'Generator')
utils.print_parameters(self.discriminator, 'Discriminator')
self.adversarial_loss = torch.nn.BCELoss().cuda(
) if cuda else torch.nn.BCELoss()
# set up optimisers
self.optimizer_D = torch.optim.RMSprop(self.discriminator.parameters(),
lr=args.lr_d)
self.optimizer_G = torch.optim.RMSprop(self.generator.parameters(),
lr=args.lr_g)
# set up LR schedulers
self.scheduler_D = StepLR(self.optimizer_D,
step_size=args.lr_step,
gamma=args.lr_gamma)
self.scheduler_G = StepLR(self.optimizer_G,
step_size=args.lr_step,
gamma=args.lr_gamma)
# create latent vectors to visualize the progression of the generator
self.fixed_noise = Variable(
Tensor(
np.random.normal(0, args.s_sd,
(args.batch_size, args.latent_dim))))
def generate(noise):
#generator model
G = dcgan.Generator(fc_shapes=(7, 7, 256),
num_conv=3,
filters=(128, 64, 1),
kernel_sizes=(5, 5, 5),
strides=(1, 2, 2),
activations=(tf.nn.leaky_relu, tf.nn.leaky_relu,
tf.nn.tanh))
checkpoint = tf.train.Checkpoint(G=G)
checkpoint.restore(CHECK_POINTS_PATH)
#generate
fake_images = G(noise, training=False)
fig = plt.figure(figsize=(4, 4))
for i in range(fake_images.shape[0]):
plt.subplot(4, 4, i + 1)
plt.imshow(fake_images[i, :, :, 0] * 127.5 + 127.5, cmap='gray')
plt.axis('off')
plt.savefig('image_at_epoch_{:04d}.png'.format(epoch))
def train():
#trans dataset to distribute dataset
with strategy.scope():
train_dist_dataset = strategy.experimental_distribute_dataset(
train_dataset)
#test_dist_dataset=strategy.experimental_distribute_dataset(test_dataset)
#define loss
with strategy.scope():
BinaryEntropy = tf.keras.losses.BinaryCrossentropy(
from_logits=True, reduction=tf.keras.losses.Reduction.NONE)
#generator loss
def g_loss(fake_logits):
'''
'''
losses = BinaryEntropy(tf.ones_like(fake_logits), fake_logits)
loss = tf.nn.compute_average_loss(per_example_loss=losses,
global_batch_size=BATCH_SIZE)
return loss
#discriminator loss
def d_loss(real_logits, fake_logits):
'''
'''
real_losses = BinaryEntropy(tf.ones_like(real_logits), real_logits)
fake_losses = BinaryEntropy(tf.zeros_like(fake_logits),
fake_logits)
losses = real_losses + fake_losses
loss = tf.nn.compute_average_loss(per_example_loss=losses,
global_batch_size=BATCH_SIZE)
return loss
#define metrics
# with strategy.scope():
# train_accuracy=tf.keras.metrics.SparseCategoricalAccuracy(name="train_loss")
# model and optimizer must be created under `strategy.scope`.
with strategy.scope():
#generator model
G = dcgan.Generator(fc_shapes=(7, 7, 256),
num_conv=3,
filters=(128, 64, 1),
kernel_sizes=(5, 5, 5),
strides=(1, 2, 2),
activations=(tf.nn.leaky_relu, tf.nn.leaky_relu,
tf.nn.tanh))
G_optimizer = tf.keras.optimizers.Adam(1e-4)
#discriminator model
D = dcgan.Discriminator(num_conv=2,
filters=(64, 128),
kernel_sizes=(5, 5),
strides=(2, 2),
activations=(tf.nn.leaky_relu,
tf.nn.leaky_relu))
D_optimizer = tf.keras.optimizers.Adam(1e-4)
#checkpoints
checkpoint = tf.train.Checkpoint(G_optimizer=G_optimizer,
D_optimizer=D_optimizer,
G=G,
D=D)
#basic train step in one device
with strategy.scope():
def train_step(inputs):
x, y = inputs
k = 5
#train generator
for i in range(k):
with tf.GradientTape() as g_tape:
noise = tf.random.normal(shape=(BATCH_SIZE_PER_REPLICA,
NOISE_DIM))
#noise to images
fake_images = G(noise, training=True)
#juege by discriminator
real_logits = D(x, training=True)
fake_logits = D(fake_images, training=True)
#compute gen loss
gen_loss = g_loss(fake_logits)
#compute generatorgradients
g_gradients = g_tape.gradient(gen_loss, G.trainable_variables)
#apply gradients
G_optimizer.apply_gradients(zip(g_gradients,
G.trainable_variables))
with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
#noise to images
fake_images = G(noise, training=True)
#juege by discriminator
real_logits = D(x, training=True)
fake_logits = D(fake_images, training=True)
#compute loss
gen_loss = g_loss(fake_logits)
disc_loss = d_loss(real_logits, fake_logits)
#compute gradients
g_gradients = g_tape.gradient(gen_loss, G.trainable_variables)
d_gradients = d_tape.gradient(disc_loss, D.trainable_variables)
#apply gradients
G_optimizer.apply_gradients(zip(g_gradients,
G.trainable_variables))
D_optimizer.apply_gradients(zip(d_gradients,
D.trainable_variables))
return gen_loss, disc_loss
#distribute train_step use basic train step
with strategy.scope():
def dist_train_step(dataset_inputs):
replica_gen_losses, replica_disc_losses = strategy.experimental_run_v2(
fn=train_step, args=(dataset_inputs, ))
#print("replica_losses:\n",replica_losses)
reduce_gen_loss = strategy.reduce(
reduce_op=tf.distribute.ReduceOp.SUM,
value=replica_gen_losses,
axis=None)
reduce_disc_loss = strategy.reduce(
reduce_op=tf.distribute.ReduceOp.SUM,
value=replica_disc_losses,
axis=None)
return reduce_gen_loss, reduce_disc_loss
for epoch in range(EPOCHS):
print("-----------EPOCH:", epoch)
epoch_gen_loss = 0.0
epoch_disc_loss = 0.0
num_batchs = 0
for records in train_dist_dataset:
reduce_gen_loss, reduce_disc_loss = dist_train_step(records)
epoch_gen_loss += reduce_gen_loss
epoch_disc_loss += reduce_disc_loss
num_batchs += 1
epoch_gen_loss = epoch_gen_loss / num_batchs
epoch_disc_loss = epoch_disc_loss / num_batchs
print("epoch_gen_loss:", epoch_gen_loss.numpy())
print("epoch_disc_loss:", epoch_disc_loss.numpy())
#save model
checkpoint.save(CHECK_POINTS_PATH)
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(opt.workers))
#########################
#### Models building ####
#########################
device = torch.device("cuda:0" if opt.cuda else "cpu")
##device = torch.device("cpu")
ngpu = int(opt.ngpu)
nz = int(opt.nz)
ngf = int(opt.ngf)
ndf = int(opt.ndf)
nc = 3
netG = inputmodel.Generator().to(device)
netG.apply(inputmodel.weights_init)
if opt.netG != '':
netG.load_state_dict(torch.load(opt.netG))
print(netG)
netD = inputmodel.Discriminator().to(device)
netD.apply(inputmodel.weights_init)
if opt.netD != '':
netD.load_state_dict(torch.load(opt.netD))
print(netD)
criterion = nn.BCELoss()
Tensor = torch.FloatTensor
z = Variable(
Tensor(np.random.normal(0, 1, (opt.batchSize, opt.nz))).to(device))
#grid_show(fig, bx, xs.shape)
bx = self.grid_transform(bx, xs.shape)
imsave('logs/{}/{}.png'.format(self.data, t / 100), bx)
#fig.savefig('logs/{}/{}.png'.format(self.data, t/100))
def grid_transform(self, x, size):
a, b = split(x.shape[0])
h, w, c = size[0], size[1], size[2]
x = np.reshape(x, [a, b, h, w, c])
x = np.transpose(x, [0, 2, 1, 3, 4])
x = np.reshape(x, [a * h, b * w, c])
if x.shape[2] == 1:
x = np.squeeze(x, axis=2)
return x
if __name__ == '__main__':
parser = argparse.ArgumentParser('')
parser.add_argument('--data', type=str, default='mnist')
parser.add_argument('--model', type=str, default='dcgan')
parser.add_argument('--gpus', type=str, default='0')
args = parser.parse_args()
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpus
#data = importlib.import_module(args.data)
#model = importlib.import_module(args.data + '.' + args.model)
# xs = data.DataSampler()
# zs = data.NoiseSampler()
d_net = dcgan.Discriminator()
g_net = dcgan.Generator()
wgan = WassersteinGAN(g_net, d_net, args.data, args.model)
wgan.train()
ngf = int(opt.ngf)
ndf = int(opt.ndf)
# custom weights initialization called on netG and netD
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
m.weight.data.normal_(0.0, 0.02)
elif classname.find('BatchNorm') != -1:
m.weight.data.normal_(1.0, 0.02)
m.bias.data.fill_(0)
netD = dcgan.Discriminator(ngpu, ndf=ndf).to(device)
netD.apply(weights_init)
netG = dcgan.Generator(ngpu, nz=nz, ngf=ngf).to(device)
netG.apply(weights_init)
lrD = []
lrG = []
lossD = []
lossG = []
load_state = ""
starting_epoch = 0
if not opt.fresh and opt.loadstate == '':
outf_files = os.listdir(opath)
states = [of for of in outf_files if 'net_state_epoch_' in of]
states.sort()
if len(states) >= 1:
load_state = os.path.join(opath, states[-1])
if os.path.isfile(load_state):