def main():
args = get_args()
# Training Generator/Discriminator
if args.model == 'GAN':
model = GAN()
# elif args.model == 'LSGAN':
# model = LSGAN()
# elif args.model == 'WGAN':
# model = WGAN()
# elif args.model == 'WGAN_GP':
# model = WGAN_GP()
# elif args.model == 'DRAGAN':
# model = DRAGAN()
# elif args.model == 'EBGAN':
# model = EBGAN()
# elif args.model == 'BEGAN':
# model = BEGAN()
# elif args.model == 'SNGAN':
# model = SNGAN()
elif args.model == 'AnoGAN':
model = AnoGAN()
model.train()
# Anomaly Detection
if args.model == 'AnoGAN':
model.anomaly_detect()
def test_gaussian(mean, std, num_data, make_gif=False, use_gpu=True):
num_iters = 30
noise_size = 1
sample_size = 1
batch_size = 512
# Sample some data
data = torch.randn(num_data, sample_size) * std + mean
data = data.resize_(num_data, sample_size)
data_loader = DataLoader(data,
batch_size=batch_size,
shuffle=True,
pin_memory=use_gpu,
num_workers=4,
drop_last=True)
# data_iter = iter(data_loader)
# Construct a GAN
gen = MLPGenerator(noise_size, sample_size)
dis = MLPDiscriminator(sample_size)
gan = GAN(gen, dis, data_loader, use_gpu=use_gpu)
plt.ion()
for ii in range(num_iters):
gan.train(20, batch_size)
# Sample and visualize
# True Distribution
x = data.numpy().reshape(num_data)
# x = np.random.randn(20000) * std + mean
y, bin_edges = np.histogram(x, bins=200, density=True)
bin_centers = 0.5 * (bin_edges[1:] + bin_edges[:-1])
plt.plot(bin_centers, y, '-')
# Generator Approximation
x = gan.sample_gen(20000).data.cpu().numpy()
y, bin_edges = np.histogram(x, bins=200, density=True)
bin_centers = 0.5 * (bin_edges[1:] + bin_edges[:-1])
plt.plot(bin_centers, y, '-')
# Discriminator Probability
axes = plt.gca()
x_lim = axes.get_xlim()
x = torch.linspace(axes.get_xlim()[0],
axes.get_xlim()[1], 200).resize_(200, sample_size)
if use_gpu:
x = x.cuda()
y = dis.forward(Variable(x))
plt.plot(x.cpu().numpy(), y.data.cpu().numpy(), '-')
if make_gif:
plt.savefig('./figs/pic' + str(ii).zfill(3))
plt.pause(0.01)
plt.cla()
if make_gif:
subprocess.call([
'convert', '-loop', '0', '-delay', '50', './figs/pic*.png',
'./figs/output.gif'
])
def fit(self):
for g in ParameterGrid(self.parameters):
self.iter += 1
print(
'\nTraining:',
str(self.iter) + '/' +
str(len(ParameterGrid(self.parameters))), '- Parameters:', g)
# Model
model = GAN(self.name, self.train_dataset, self.test_dataset,
self.shape, **g)
score = model.train()
print(
'\tScore: emd: %f\t fid: %f\t inception: %f\t knn: %f\t mmd: %f\t mode: %f'
% (score.emd, score.fid, score.inception, score.knn, score.mmd,
score.mode))
self.results.append({'score': score, 'params': g})
# Write to results
with open('resources/results.txt', "w+") as f:
f.write(
'\nemd: %f\t fid: %f\t inception: %f\t knn: %f\t mmd: %f\t mode: %f'
% (score.emd, score.fid, score.inception, score.knn,
score.mmd, score.mode))
def main():
# parse arguments
args = parse_args()
if args is None:
exit()
# open session
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
gan = GAN(sess, args)
# build graph
gan.build_model()
if args.phase == 'train' :
gan.train()
print(" [*] Training finished!")
if args.phase == 'test' :
gan.test()
print(" [*] Test finished!")
def main():
for i in range(0, 1000):
a = np.random.randint(10, 41)
b = np.random.randint(a, 70)
c = np.random.randint(10, b)
args = {
'attack_type': "portsweep",
'max_epochs': 7000,
'batch_size': 255,
'sample_size': 500,
'optimizer_learning_rate': 0.001,
'generator_layers': [a, b, c]
}
for iter in range(0, 10):
gan = GAN(**args)
gan.train()
print("GAN finished with layers:")
print(str([a, b, c]))
def main(_):
assert sum([FLAGS.train, FLAGS.extract]) == 1
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(FLAGS.logs_dir):
os.makedirs(FLAGS.logs_dir)
with tf.Session() as sess:
if FLAGS.train:
gan = GAN(sess, FLAGS)
gan.train()
elif FLAGS.extract:
df_X = pd.read_csv('dataset/kddcup.test.data.sub.csv')
df_X.drop('label', axis=1, inplace=True)
df_X = np.array(df_X)
FLAGS.batch_size = df_X.shape[0]
gan = GAN(sess, FLAGS)
features = gan.extract_features(df_X)
pd.DataFrame(features).to_csv('dataset/test.sub.features.csv',
header=None,
index=False)
def main(argv):
# Load configs from file
config = json.load(open(FLAGS.config))
# set_backend()
# Set name
#name = '{}_{}_'.format(config['INPUT_NAME'], config['TARGET_NAME'])
#for l in config['LABELS']:
# name += str(l)
#config['NAME'] += '_' + name
if FLAGS.use_wandb:
import wandb
resume_wandb = True if FLAGS.wandb_resume_id is not None else False
wandb.init(config=config,
resume=resume_wandb,
id=FLAGS.wandb_resume_id,
project='EchoGen',
name=FLAGS.wandb_run_name)
# Initialize GAN
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
model = GAN(config, FLAGS.use_wandb, device, FLAGS.dataset_path)
# load trained models if they exist
if FLAGS.ckpt_load is not None:
model.load(f'{FLAGS.ckpt_load}/generator_last_checkpoint.bin',
model='generator')
model.load(f'{FLAGS.ckpt_load}/discriminator_last_checkpoint.bin',
model='discriminator')
if FLAGS.test:
model.test()
else:
model.train()
def test_gan():
#parameters
file_name = "animals.txt"
g_hidden_size = 10
d_hidden_size = 10
n_epochs = 1000
g_epochs = 20
d_epochs = 10
g_initial_lr = 1
d_initial_lr = 1
g_multiplier = 0.9
d_multiplier = 0.9
g_batch_size = 100
d_batch_size = 100
# data
char_list = dataloader.get_char_list(file_name)
X_actual = dataloader.load_data(file_name)
seq_len = X_actual.shape[1]
# construct GAN
gan = GAN(g_hidden_size, d_hidden_size, char_list)
# train GAN
gan.train(X_actual,
seq_len,
n_epochs,
g_epochs,
d_epochs,
g_initial_lr,
d_initial_lr,
g_multiplier,
d_multiplier,
g_batch_size,
d_batch_size,
print_progress=True,
num_displayed=3)
def main():
''' This is a sample implementation of one generator training with three discriminators '''
# Setting up the gan network system
gan1 = GAN(generator=Generator(), discriminator=Discriminator(), nn=load_model("new_nn.h5"))
gan2 = GAN(generator=gan1.G, discriminator=Discriminator(), nn=load_model("new_nn.h5"))
gan3 = GAN(generator=gan1.G, discriminator=Discriminator(), nn=load_model("new_nn.h5"))
# Set the number of training iterations for the network
training_period = 5
# Train the system
for i in range(training_period):
gan1.train(testid=i)
gan2.train(testid=i)
gan3.train(testid=i)
def main():
dataset_path = "C:/Users/dronp/Desktop/ImageRecognition/cats/"
images_path = "generated/"
models_path = "models/"
image_shape = (64, 64, 3)
latent_dim = 256
batch_size = 16
iterations = 300000
save_period = 1500
save_loss_period = 500
examples_count = 8
init = keras.initializers.RandomNormal(mean=0.0, stddev=0.02)
generator = keras.Sequential([
layers.Reshape((1, 1, latent_dim), input_shape=(latent_dim, )),
layers.Conv2DTranspose(512, (4, 4),
strides=(1, 1),
padding='valid',
kernel_initializer=init),
layers.BatchNormalization(),
layers.ReLU(),
layers.Conv2DTranspose(256, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=init),
layers.BatchNormalization(),
layers.ReLU(),
layers.Conv2DTranspose(128, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=init),
layers.BatchNormalization(),
layers.ReLU(),
layers.Conv2DTranspose(64, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=init),
layers.BatchNormalization(),
layers.ReLU(),
layers.Conv2DTranspose(
3, (4, 4), strides=(2, 2), padding='same', activation='tanh'),
],
name="generator")
discriminator = keras.Sequential([
layers.Conv2D(64, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=init,
input_shape=image_shape),
layers.BatchNormalization(),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(128, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=init),
layers.BatchNormalization(),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(256, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=init),
layers.BatchNormalization(),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(512, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=init),
layers.BatchNormalization(),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(1, (4, 4),
strides=(2, 2),
padding='valid',
kernel_initializer=init),
layers.Flatten()
],
name="discriminator")
g_optimizer = keras.optimizers.Adam(learning_rate=0.0002, beta_1=0.5)
d_optimizer = keras.optimizers.Adam(learning_rate=0.00015, beta_1=0.5)
images = load_data(dataset_path)
if models_path and not os.path.exists(models_path):
os.mkdir(models_path)
if images_path and not os.path.exists(images_path):
os.mkdir(images_path)
loss_fn = losses.RaLSGANLoss()
gan = GAN(latent_dim, discriminator, generator, d_optimizer, g_optimizer,
loss_fn)
gan.summary()
gan.train(images, iterations, batch_size, models_path, images_path,
examples_count, save_period, save_loss_period)
print('Plotting training samples ...')
samples = X[np.random.choice(range(X.shape[0]), size=36)]
# plot_samples(None, samples, scatter=True, symm_axis=symm_axis, s=1.5, alpha=.7, c='k', fname='samples')
plot_samples(None, samples, scale=1.0, scatter=False, symm_axis=symm_axis, lw=1.2, alpha=.7, c='k', fname='samples')
# Split training and test data
X_train, X_test = train_test_plit(X, split=0.8)
# Train
directory = './trained_gan/{}_{}'.format(latent_dim, noise_dim)
if args.model_id is not None:
directory += '/{}'.format(args.model_id)
model = GAN(latent_dim, noise_dim, X_train.shape[1], bezier_degree, bounds)
if args.mode == 'train':
timer = ElapsedTimer()
model.train(X_train, batch_size=batch_size, train_steps=train_steps, save_interval=args.save_interval, directory=directory)
elapsed_time = timer.elapsed_time()
runtime_mesg = 'Wall clock time for training: %s' % elapsed_time
print(runtime_mesg)
runtime_file = open('{}/runtime.txt'.format(directory), 'w')
runtime_file.write('%s\n' % runtime_mesg)
runtime_file.close()
else:
model.restore(directory=directory)
print('Plotting synthesized shapes ...')
points_per_axis = 5
plot_grid(points_per_axis, gen_func=model.synthesize, d=latent_dim, bounds=bounds, scale=1.0, scatter=False, symm_axis=symm_axis,
alpha=.7, lw=1.2, c='k', fname='{}/synthesized'.format(directory))
def synthesize_noise(noise):
return model.synthesize(0.5*np.ones((points_per_axis**2, latent_dim)), noise)
d_iter_count += 1
if d_iter_count == config.max_d_iters:
d_iter_count = 0
mode = 'G'
iter_no = 0
max_iters = 100
mode = 'G'
g_iter_count = 0
d_iter_count = 0
batch_size = config.batch_size
train_writer = SummaryWriter(log_dir='../logs/train')
val_writer = SummaryWriter(log_dir='../logs/val')
with tqdm(total=max_iters) as pbar:
for iter_no in range(max_iters):
train_batch = train_loader.next_batch()
gan.train()
train_step(iter_no, train_batch)
if iter_no % config.validation_interval == 0:
val_batch = val_loader.next_batch()
gan.eval()
validate(val_batch, iter_no)
pbar.update(1)
import numpy as np
from matplotlib import pyplot as plt
from keras.datasets import mnist
from gan import GAN
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape([-1, 28, 28, 1]) / 255
x_test = x_test.reshape([-1, 28, 28, 1]) / 255
x = np.concatenate([x_train, x_test])
gan = GAN()
gan.gan.summary()
gan.train(x, 100, batch_size=100)
gan.save('number_gan/gan.h5')
noise = np.random.normal(size=[10, 8 * 8])
images = gan.generator.predict(noise)
images = images.reshape([-1, 28, 28])
plt.gray()
for i in range(10):
plt.subplot(2, 5, i + 1)
plt.imshow(images[i])
plt.show()
def build_gan_celeba(hyperparams, path):
gan = GAN([128], [128], 100, hyperparams, 'celeba_bw')
gan.train(path)
return gan
from gan import GAN
width, heigth = 128, 128
self_path = os.path.dirname(os.path.abspath(__file__))
temp_path = os.path.join(self_path, "temp")
# print("Video saved to %s" % final_path)
def main():
comand = input("Select what you want( train, start_bot, clean): ")
if comand == "train":
datasets = os.path.join(self_path, "datasets")
dirs = [dI for dI in os.listdir(datasets) if os.path.isdir(os.path.join(datasets,dI))]
comand = input("Select dataset(%s):" % ','.join(dirs))
dataset_data = dataset("file_path", temp_path, width, heigth)
data = dataset_data.prep_imgs(os.path.join(self_path, "datasets/%s" % comand))
#generative_net = GAN(buff_size=, batch_size=4, epochs=5000, imgs_size=(width, heigth))
#generative_net.train(data)
if __name__ == "__main__":
#file_path = input("write path to video:")
dataset_data = dataset("file_path", temp_path, width, heigth)
data = dataset_data.prep_imgs(os.path.join(self_path, "datasets/big_anime"))
generative_net = GAN(buff_size=10035, batch_size=16, epochs=5000, imgs_size=(width, heigth))
generative_net.train(data)
samples = X[np.random.choice(range(X.shape[0]), size=36)]
# plot_samples(None, samples, scatter=True, symm_axis=symm_axis, s=1.5, alpha=.7, c='k', fname='samples')
plot_samples(None, samples, scale=1.0, scatter=False, symm_axis=symm_axis, lw=1.2, alpha=.7, c='k', fname='samples')
# Split training and test data
test_split = 0.8
N = X.shape[0]
split = int(N*test_split)
X_train = X[:split]
X_test = X[split:]
# Train
model = GAN(latent_dim, noise_dim, X_train.shape[1], bezier_degree, bounds)
if args.mode == 'startover':
timer = ElapsedTimer()
model.train(X_train, batch_size=batch_size, train_steps=train_steps, save_interval=args.save_interval)
elapsed_time = timer.elapsed_time()
runtime_mesg = 'Wall clock time for training: %s' % elapsed_time
print(runtime_mesg)
runtime_file = open('gan/runtime.txt', 'w')
runtime_file.write('%s\n' % runtime_mesg)
runtime_file.close()
else:
model.restore()
print('Plotting synthesized shapes ...')
plot_grid(5, gen_func=model.synthesize, d=latent_dim, bounds=bounds, scale=1.0, scatter=False, symm_axis=symm_axis,
alpha=.7, lw=1.2, c='k', fname='gan/synthesized')
n_runs = 10
opts.generator_frequency = 1
opts.generator_dropout = 0.3
opts.label_softness = 0.2
opts.batch_size = 128
opts.epoch_number = 300
#Note: if you are using jupyter notebook you might need to disable workers:
opts.workers_nbr = 0
#List of tranformations applied to each input image
opts.transforms = [
transforms.Resize(int(opts.image_size), Image.BICUBIC),
transforms.ToTensor(), #do not forget to transform image into a tensor
transforms.Normalize((.5, .5, .5), (.5, .5, .5))
#RandomNoise(0.01) #adding noise might prevent the discriminator from over-fitting
]
#Build GAN
model = GAN(opts)
#Display GAN architecture (note: only work if cuda is enabled)
summary(model.generator.cuda(), input_size=(opts.latent_dim, 1, 1))
summary(model.discriminator.cuda(),
input_size=(opts.channels_nbr, opts.image_size, opts.image_size))
#Start training
model.train()
#Save model
model.save(opts.output_path)
# Prepare save directory
create_dir('./trained_gan')
example_dir = './trained_gan/{}_{}'.format(args.data, args.func)
create_dir(example_dir)
save_dir = '{}/{}_{}'.format(example_dir, lambda0, lambda1)
create_dir(save_dir)
# Visualize data
visualize_2d(data, func_obj, save_path='{}/data.svg'.format(example_dir), xlim=(-0.5,0.5), ylim=(-0.5,0.5))
visualize_2d(data, func_obj, save_path='{}/data.png'.format(example_dir), xlim=(-0.5,0.5), ylim=(-0.5,0.5))
# Train
model = GAN(noise_dim, 2, lambda0, lambda1)
if args.mode == 'train':
timer = ElapsedTimer()
model.train(data_obj, func_obj, batch_size=batch_size, train_steps=train_steps,
disc_lr=disc_lr, gen_lr=gen_lr, save_interval=save_interval, save_dir=save_dir)
elapsed_time = timer.elapsed_time()
runtime_mesg = 'Wall clock time for training: %s' % elapsed_time
print(runtime_mesg)
else:
model.restore(save_dir=save_dir)
print('##########################################################################')
print('Plotting generated samples ...')
# Plot generated samples
n = 1000
gen_data = model.synthesize(n)
visualize_2d(data[:n], func_obj, gen_data=gen_data, save_path='{}/synthesized.svg'.format(save_dir),
xlim=(-0.5,0.5), ylim=(-0.5,0.5), axis_off=False)
visualize_2d(data[:n], func_obj, gen_data=gen_data, save_path='{}/synthesized.png'.format(save_dir),
from gan import GAN dataset_id = "Irish" gan = GAN(dataset_id) gan.train(dataset_id, epochs=601, batch_size=32, save_interval=200)
def build_gan(hyperparams):
gan = GAN([128], [128], 100, hyperparams)
gan.train()
return gan
https://arxiv.org/pdf/1704.00028.pdf
'''
if objective == 'max':
# We are coming from the discriminator.
grad_penalty = lamb * (torch.norm(grad, dim=1) - 1).pow(2).mean()
loss = Dx.mean() - DGy.mean() - grad_penalty
loss = -1 * loss
elif objective == 'min':
# We are coming from the generator -- the other terms in the loss don't matter.
loss = -DGy.mean()
return loss
if __name__ == '__main__':
# Get the dataloaders for SVHN
print('Getting dataloaders...')
batch_size = 64
train_loader, valid_loader, test_loader = get_loaders(
batch_size=batch_size)
# Instantiate and train GAN
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
assert (torch.cuda.is_available())
print("device: ", device)
gan = GAN(device=device, batch_size=batch_size)
print('Training GAN...')
gan.train(test_loader, test_loader, loss_fn=wgan_gp)
gan.log_learning_curves()
gan.log_d_crossentropy()
gan.save_model('gan.pt')
import numpy as np from keras.datasets import fashion_mnist from image_helper import ImageHelper from gan import GAN (X, _), (_, _) = fashion_mnist.load_data() X_train = X / 127.5 - 1. X_train = np.expand_dims(X_train, axis=3) image_helper = ImageHelper() generative_advarsial_network = GAN(X_train[0].shape, 100, image_helper) generative_advarsial_network.train(30000, X_train, batch_size=32)
def main():
# parse arguments
args = parse_args()
if args is None:
exit()
if args.benchmark_mode:
torch.backends.cudnn.benchmark = True
# declare instance for GAN
if args.gan_type == 'GAN':
gan = GAN(args)
elif args.gan_type == 'CGAN':
gan = CGAN(args)
elif args.gan_type == 'ACGAN':
gan = ACGAN(args)
elif args.gan_type == 'DSGAN':
gan = DSGAN(args)
elif args.gan_type == 'SNGAN':
gan = SNGAN(args)
else:
raise Exception("[!] There is no option for " + args.gan_type)
if args.mode == 'train':
# launch the graph in a session
gan.train()
print(" [*] Training finished!")
# visualize learned generator
gan.visualize_results(args.epoch)
print(" [*] Testing finished!")
elif args.mode == 'evaluate':
print(" [*] Compute the Lipschitz parameter")
gan.get_lipschitz()
print("")
# print(" [*] Compute the inception score")
# if args.dataset == 'mnist':
# model = SmallCNN()
# model.load_state_dict(torch.load('generative/pretrained/small_cnn/mnist.pt'))
# dataset = dset.MNIST(root='data/mnist/', train=False,
# download=True, transform=transforms.ToTensor())
# img_size = 28
# n_class = 10
# elif args.dataset == 'fashion-mnist':
# model = SmallCNN()
# model.load_state_dict(torch.load('generative/pretrained/small_cnn/fashion-mnist.pt'))
# dataset = dset.FashionMNIST(root='data/fashion-mnist/', train=False,
# download=True, transform=transforms.ToTensor())
# img_size = 28
# n_class = 10
# elif args.dataset == 'cifar10':
# model = inception_v3(pretrained=True, transform_input=False)
# transform = transforms.Compose([transforms.ToTensor(),
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# dataset = dset.CIFAR10(root='data/cifar10/', download=True, transform=transform)
# img_size = 299
# n_class = 1000
# else:
# raise Exception("[!] There is no option for " + args.dataset)
# if args.gpu_mode:
# model = model.cuda()
# model.eval()
# print("Calculating Inception Score for originial dataset...")
# IS_origin = inception_score(IgnoreLabelDataset(dataset), model, cuda=args.gpu_mode,
# batch_size=32, img_size=img_size, n_class=n_class, resize=True, splits=10)
# print(IS_origin[0])
# # test_sample_path = 'data/'+args.dataset+'/'+args.gan_type+'/'+'samples_test.npy'
# # test_label_path ='data/'+args.dataset+'/'+args.gan_type+'/'+'labels_test.npy'
# test_path = 'data/'+args.dataset+'/'+args.gan_type+'/'+'test.npz'
# dataset_acgan = CustomLabelDataset(test_path, args.input_size,
# args.input_size, args.channels, transform=transforms.ToTensor())
# print ("Calculating Inception Score for ACGAN...")
# IS_gan = inception_score(IgnoreLabelDataset(dataset_acgan), model, cuda=args.gpu_mode,
# batch_size=32, img_size=img_size, n_class=n_class, resize=True, splits=10)
# print(IS_gan[0])
# # save the inception score
# IS_log = open(args.log_dir+'/'+args.dataset+'/'+args.gan_type+'/ACGAN_IS.txt', 'w')
# print("%.4f, %.4f" % (IS_origin[0], IS_gan[0]), file=IS_log)
elif args.mode == 'reconstruct':
print(" [*] Reconstruct "+args.dataset+" dataset using "+args.gan_type)
gan.reconstruct()
else:
raise Exception("[!] There is no option for " + args.mode)
# TODO: dropout
def discriminator(x):
with tf.variable_scope("discriminator"):
h1 = fc(x, 200, reuse=tf.AUTO_REUSE, scope="h1")
h2 = fc(h1, 150, reuse=tf.AUTO_REUSE, scope="h2")
h3 = fc(h2, 1, activation_fn = None, \
reuse = tf.AUTO_REUSE, scope = "h3")
o = tf.nn.sigmoid(h3)
return o
mnist = tf.contrib.learn.datasets.load_dataset("mnist")
real_data = mnist.train.images
# copy by reference?
# TODO: read about Adam
g_optimizer = tf.train.AdamOptimizer(0.0001)
d_optimizer = g_optimizer
config = _config()
hook1 = Hook(1, show_result)
m = GAN(generator, discriminator, "wasserstein")
# TODO: cleanup code by placing session creation inside .train()
sess = tf.Session()
#sess = tf_debug.LocalCLIDebugWrapperSession(sess)
m.train(sess, g_optimizer, d_optimizer, real_data, config, hooks=[hook1])
from gan import GAN
import tensorflow as tf
BATCH_SIZE = 256
BUFFER_SIZE = 60000
EPOCHS = 1
if __name__=='__main__':
# Load training data
(train_images, train_labels), (_, _) = tf.keras.datasets.mnist.load_data()
# reshape training images
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype('float32')
# normalize training images to [-1, 1]
train_images = (train_images - 127.5) / 127.5
# Batch and shuffle the data
train_dataset = tf.data.Dataset.from_tensor_slices(train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
# Initialize GAN model (create generator, discriminator and their optimizers)
gan = GAN()
# set batch size before training
gan.set_batch_size(batch_size=BATCH_SIZE)
gan.train(train_dataset, EPOCHS)
