def train(latent_dim, height, width, channels):
(X_train, Y_train), (_, _) = tf.keras.datasets.mnist.load_data()
# X_train = X_train[0: 2000]
X_train = X_train.reshape((X_train.shape[0],) + (height, width, channels)).astype('float32')
X_train = normalize(X_train)
epochs = 20
# epochs = 2
batch_size = 128
iterations = X_train.shape[0]//batch_size
dcgan = DCGAN(latent_dim, height, width, channels)
for epoch in range(epochs):
for iteration in range(iterations):
real_images = X_train[iteration*batch_size:(iteration+1)*batch_size]
d_loss, g_loss = dcgan.train(real_images, batch_size)
if (iteration + 1) % 10 == 0:
print('{} / {}'.format(iteration + 1, iterations))
print('discriminator loss: {}'.format(d_loss))
print('generator loss: {}'.format(g_loss))
print()
with open('loss.txt', 'a') as f:
f.write(str(d_loss) + ',' + str(g_loss) + '\r')
dcgan.save_weights('gan' + '_epoch' + str(epoch + 1) + '.h5')
print('epoch' + str(epoch) + ' end')
print()
def main(_):
pp.pprint(FLAGS.__flags)
# training/inference
with tf.Session() as sess:
dcgan = DCGAN(sess, FLAGS)
# path checks
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(
os.path.join(FLAGS.log_dir, dcgan.get_model_dir())):
os.makedirs(os.path.join(FLAGS.log_dir, dcgan.get_model_dir()))
# load checkpoint if found
if dcgan.checkpoint_exists():
print("Loading checkpoints...")
if dcgan.load():
print "success!"
else:
raise IOError("Could not read checkpoints from {0}!".format(
FLAGS.checkpoint_dir))
else:
print "No checkpoints found. Training from scratch."
dcgan.load()
# train DCGAN
if FLAGS.train:
train(dcgan)
else:
dcgan.load()
def main(_):
pp.pprint(FLAGS.__flags)
with tf.Session() as sess:
dcgan = DCGAN(sess, FLAGS)
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(
os.path.join(FLAGS.sample_dir, dcgan.get_model_dir())):
os.makedirs(os.path.join(FLAGS.sample_dir, dcgan.get_model_dir()))
if not os.path.exists(
os.path.join(FLAGS.log_dir, dcgan.get_model_dir())):
os.makedirs(os.path.join(FLAGS.log_dir, dcgan.get_model_dir()))
if dcgan.checkpoint_exists():
print "Loading checkpoints"
if dcgan.load():
print "Success"
else:
raise IOError("Could not read checkpoints from {}".format(
FLAGS.checkpoint_dir))
else:
if not FLAGS.train:
raise IOError("No checkpoints found")
print "No checkpoints found. Training from scratch"
dcgan.load()
if FLAGS.train:
train(dcgan)
print "Generating samples..."
inference.sample_images(dcgan)
inference.visualize_z(dcgan)
def compile(self):
"""Compile model (loss function, optimizers, etc.)"""
# Create new GAN
self.gan = DCGAN(self.gan_type, self.latent_dim, self.batch_size,
self.use_cuda)
# Set optimizers for generator and discriminator
if self.optim == 'adam':
self.G_optimizer = optim.Adam(self.gan.G.parameters(),
lr=self.learning_rate,
betas=self.momentum)
self.D_optimizer = optim.Adam(self.gan.D.parameters(),
lr=self.learning_rate,
betas=self.momentum)
elif self.optim == 'rmsprop':
self.G_optimizer = optim.RMSprop(self.gan.G.parameters(),
lr=self.learning_rate)
self.D_optimizer = optim.RMSprop(self.gan.D.parameters(),
lr=self.learning_rate)
else:
raise NotImplementedError
# CUDA support
if torch.cuda.is_available() and self.use_cuda:
self.gan = self.gan.cuda()
# Create fixed latent variables for inference while training
self.latent_vars = []
for i in range(100):
self.latent_vars.append(self.gan.create_latent_var(1))
def main(**kwargs):
from types import SimpleNamespace
_ = SimpleNamespace(**kwargs)
loader = ImageLoader(_.folder)
data = loader.setup(datalen=_.datalen)
dcgan = DCGAN(loader.shape_x, loader.shape_y, loader.channels, data)
dcgan.train(epochs=_.epochs, batch_size=_.batch_size, save_interval=50)
def predict(latent_dim, height, width, channels):
random_latent_vectors = np.random.normal(size=(100, latent_dim))
dcgan = DCGAN(latent_dim, height, width, channels)
dcgan.load_weights('gan_epoch20.h5')
# dcgan.load_weights('gan_epoch1.h5')
generated_images = dcgan.predict(random_latent_vectors)
for i, generated_image in enumerate(generated_images):
img = image.array_to_img(denormalize(generated_image), scale=False)
img.save(os.path.join('generated', str(i) + '.png'))
def train():
"""
学習データを構築する。
"""
# 画像をデータセットから読み込む
imgs = load_images()
with tf.Session() as sess:
# (3)DCGANネットワークの生成
batch_size = 64
dcgan = DCGAN(
generator_layers=[1024, 512, 256, 128],
discriminator_layer=[64, 128, 256, 512],
batch_size=batch_size,
image_inputs=tf.placeholder(tf.float32,
[batch_size, SIZE, SIZE, 3]),
)
sess.run(tf.global_variables_initializer())
# (4)ファイル保存の準備
g_saver = tf.train.Saver(dcgan.generator.variables)
d_saver = tf.train.Saver(dcgan.discriminator.variables)
maxstep = 10000
N = len(imgs)
# (5)サンプル出力の準備
sample_z = tf.random_uniform([dcgan.batch_size, dcgan.z_dim],
minval=-1.0,
maxval=1.0)
images = dcgan.sample_images(8, 8, inputs=sample_z)
os.makedirs('../data/generated_images/', exist_ok=True)
# (6)学習
for step in range(maxstep):
permutation = np.random.permutation(N)
imgs_batch = imgs[permutation[0:batch_size]]
g_loss, d_loss = dcgan.fit_step(sess=sess, image_inputs=imgs_batch)
# 100 stepごとに学習結果を出力する。
if step % 100 == 0:
filename = os.path.join('../data/', "generated_images",
'%05d.jpg' % step)
with open(filename, 'wb') as f:
f.write(sess.run(images))
print("Generator loss: {} , Discriminator loss: {}".format(
g_loss, d_loss))
# (7)学習済みモデルのファイル保存
os.makedirs('../data/models/', exist_ok=True)
g_saver.save(sess=sess, save_path="../data/models/g_saver.ckpg")
d_saver.save(sess=sess, save_path="../data/models/d_saver.ckpg")
def main():
flags = tf.app.flags
flags.DEFINE_integer("epoch", 25, "Epoch to train [25]")
flags.DEFINE_float("learning_rate", 0.0002,
"Learning rate of for adam [0.0002]")
flags.DEFINE_float("beta1", 0.5, "Momentum term of adam [0.5]")
FLAGS = flags.FLAGS
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
dcgan = DCGAN(sess)
dcgan.train(FLAGS)
def init():
dcgan = DCGAN()
if path.exists("%s/generator.h5" % modelSaveLocation):
print("Model is trained. Loading from %s" % modelSaveLocation)
dcgan.loadWeights(modelSaveLocation)
dcgan.generate("./images/generated/example.png")
else:
data = loadData()
print("Model is not trained. Loaded %d images for training" %
len(data))
dcgan.train(data=data, epochs=2000, batch_size=32, save_interval=50)
print("Model is trained. Saving to %s" % modelSaveLocation)
dcgan.saveWeights(modelSaveLocation)
def main():
dcgan = DCGAN(s_size=s_size, batch_size=batch_size)
train_im, total_imgs = load_image()
total_batch = int(total_imgs / batch_size)
losses = dcgan.loss(train_im)
train_op = dcgan.train(losses, learning_rate=learning_rate)
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.33)
config = tf.ConfigProto(gpu_options=gpu_options,
device_count={"CPU": 8},
inter_op_parallelism_threads=1,
intra_op_parallelism_threads=1)
with tf.Session() as sess:
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
init = tf.global_variables_initializer()
sess.run(init)
g_saver = tf.train.Saver(dcgan.g.variables)
d_saver = tf.train.Saver(dcgan.d.variables)
if os.path.isdir(save_dir):
g_saver.restore(sess,
tf.train.latest_checkpoint(save_dir + '/g_model'))
d_saver.restore(sess,
tf.train.latest_checkpoint(save_dir + '/d_model'))
else:
os.mkdir(save_dir)
sample_z = np.float32(
np.random.uniform(-1, 1, [dcgan.batch_size, dcgan.z_dim]))
images = dcgan.sample_images(5, 5, inputs=sample_z)
print("Start training")
for step in range(1, epochs + 1):
start_time = time.time()
for batch in range(total_batch):
_, g_loss, d_loss = sess.run(
[train_op, losses[dcgan.g], losses[dcgan.d]])
print("epochs {} loss = G: {:.8f}, D: {:.8f} run time:{:.4f} sec"\
.format(step, g_loss, d_loss, time.time()-start_time))
g_saver.save(sess, save_dir + '/g_model/g.ckpt', global_step=step)
d_saver.save(sess, save_dir + '/d_model/d.ckpt', global_step=step)
with open('./test/%05d.jpg' % step, 'wb') as f:
f.write(sess.run(images))
coord.request_stop()
coord.join(threads)
def geneator_handler():
print('start request!')
zvector = None
batchSize = 1
# Upload a serialized Zvector
if request.method == 'POST':
print('POST!')
# DO things
# check if the post request has the file part
if 'file' not in request.files:
return BadRequest("File not present in request")
file = request.files['file']
if file.filename == '':
return BadRequest("File name is not present in request")
if not allowed_file(file.filename):
return BadRequest("Invalid file type")
filename = secure_filename(file.filename)
# input_filepath = os.path.join('./', filename)
file.save(filename)
# Load a Z vector and Retrieve the N of samples to generate
zvector = torch.load(filename)
batchSize = zvector.size()[0]
checkpoint = request.form.get("ckp") or "netG_epoch_99.pth"
# Check for cuda availability
if torch.cuda.is_available():
# GPU and cuda
Generator = DCGAN(netG=os.path.join(MODEL_PATH, checkpoint), zvector=zvector, batchSize=batchSize, ngpu=1, cuda=True, outf="./")
else:
# CPU
Generator = DCGAN(netG=os.path.join(MODEL_PATH, checkpoint), zvector=zvector, batchSize=batchSize, ngpu=0, outf="./")
Generator.build_model()
Generator.generate()
return send_file(OUTPUT_PATH, mimetype='image/png')
def __init__(self):
self.img_rows = 28
self.img_cols = 28
self.channel = 8
self.x_train = input_data.read_data_sets("mnist",
one_hot=True).train.images
self.x_train = self.x_train.reshape(-1, self.img_rows, self.img_cols,
1).astype(np.float32)
self.DCGAN = DCGAN()
self.discriminator = self.DCGAN.discriminator_model()
self.adversarial = self.DCGAN.adversarial_model()
self.generator = self.DCGAN.generator()
def main(argv=None):
dcgan = DCGAN(
batch_size=96, f_size=6, z_dim=40,
gdepth1=512, gdepth2=256, gdepth3=128, gdepth4=64,
ddepth1=54, ddepth2=90, ddepth3=150, ddepth4=250)
dcgan.d(dcgan.g(dcgan.z))
g_saver = tf.train.Saver(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='g'))
d_saver = tf.train.Saver(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='d'))
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
g_checkpoint_path = os.path.join(os.path.dirname(__file__), '..', FLAGS.train_dir, 'g.ckpt')
d_checkpoint_path = os.path.join(os.path.dirname(__file__), '..', FLAGS.train_dir, 'd.ckpt')
if os.path.exists(g_checkpoint_path):
g_saver.restore(sess, g_checkpoint_path)
if os.path.exists(d_checkpoint_path):
d_saver.restore(sess, d_checkpoint_path)
ops = []
targets = [
{'name': 'g/conv1/Relu:0', 'row': 8, 'col': 32},
{'name': 'g/conv2/Relu:0', 'row': 8, 'col': 16},
{'name': 'g/conv3/Relu:0', 'row': 8, 'col': 8 },
{'name': 'Tanh:0', 'row': 1, 'col': 3 },
{'name': 'd/conv0/Maximum:0', 'row': 6, 'col': 9 },
{'name': 'd/conv1/Maximum:0', 'row': 6, 'col': 15},
{'name': 'd/conv2/Maximum:0', 'row': 6, 'col': 25},
]
for target in targets:
t = sess.graph.get_tensor_by_name(target['name'])
batch_outputs = tf.split(0, dcgan.batch_size, t)
for i in range(3):
maps = tf.split(3, t.get_shape()[3], batch_outputs[i])
rows = []
cols = target['col']
for row in range(target['row']):
rows.append(tf.concat(2, maps[cols * row: cols * row + cols]))
montaged = tf.concat(1, rows)
out = tf.image.convert_image_dtype(tf.squeeze(montaged, [0]), tf.uint8, saturate=True)
ops.append(tf.image.encode_png(out, name=t.op.name.replace('/', '-') + '-%02d' % i))
results = sess.run(ops)
for i in range(len(ops)):
filename = ops[i].op.name + '.png'
print('write %s' % filename)
with open(os.path.join(os.path.dirname(__file__), '..', FLAGS.images_dir, filename), 'wb') as f:
f.write(results[i])
def main(argv=None):
dcgan = DCGAN(
batch_size=96, f_size=6, z_dim=40,
gdepth1=512, gdepth2=256, gdepth3=128, gdepth4=64,
ddepth1=54, ddepth2=90, ddepth3=150, ddepth4=250)
dcgan.d(dcgan.g(dcgan.z))
g_saver = tf.train.Saver(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='g'))
d_saver = tf.train.Saver(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='d'))
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
g_checkpoint_path = os.path.join(os.path.dirname(__file__), '..', FLAGS.train_dir, 'g.ckpt')
d_checkpoint_path = os.path.join(os.path.dirname(__file__), '..', FLAGS.train_dir, 'd.ckpt')
if os.path.exists(g_checkpoint_path):
g_saver.restore(sess, g_checkpoint_path)
if os.path.exists(d_checkpoint_path):
d_saver.restore(sess, d_checkpoint_path)
ops = []
targets = [
{'name': 'g/conv1/Relu:0', 'row': 8, 'col': 32},
{'name': 'g/conv2/Relu:0', 'row': 8, 'col': 16},
{'name': 'g/conv3/Relu:0', 'row': 8, 'col': 8 },
{'name': 'Tanh:0', 'row': 1, 'col': 3 },
{'name': 'd/conv0/Maximum:0', 'row': 6, 'col': 9 },
{'name': 'd/conv1/Maximum:0', 'row': 6, 'col': 15},
{'name': 'd/conv2/Maximum:0', 'row': 6, 'col': 25},
]
for target in targets:
t = sess.graph.get_tensor_by_name(target['name'])
batch_outputs = tf.split(0, dcgan.batch_size, t)
for i in range(3):
maps = tf.split(3, t.get_shape()[3], batch_outputs[i])
rows = []
cols = target['col']
for row in range(target['row']):
rows.append(tf.concat(2, maps[cols * row: cols * row + cols]))
montaged = tf.concat(1, rows)
out = tf.image.convert_image_dtype(tf.squeeze(montaged, [0]), tf.uint8, saturate=True)
ops.append(tf.image.encode_png(out, name=t.op.name.replace('/', '-') + '-%02d' % i))
results = sess.run(ops)
for i in range(len(ops)):
filename = ops[i].op.name + '.png'
print('write %s' % filename)
with open(os.path.join(os.path.dirname(__file__), '..', FLAGS.images_dir, filename), 'wb') as f:
f.write(results[i])
def main(N_EPOCH=10, BATCH_SIZE=32, G_SIZE=100):
(X_train, y_train), (_, _) = tf.contrib.keras.datasets.mnist.load_data()
X = select(scaled(X_train), y_train, 8)
gan = DCGAN(G_SIZE, (28, 28), 1, shape_trace=[(7, 7, 128), (14, 14, 64)])
sess = tf.Session()
sess.run(tf.global_variables_initializer())
plt.figure()
for i, epoch in enumerate(range(N_EPOCH)):
X = shuffle(X)
for step, images in enumerate(gen_batch(X, BATCH_SIZE)):
noise = np.random.randn(len(images), G_SIZE)
sess.run(gan.D_train, {gan.G_in: noise, gan.X_in: images, gan.train_flag: True})
for _ in range(2):
sess.run(gan.G_train, {gan.G_in: noise, gan.train_flag: True})
G_loss, D_loss, D_prob, G_prob, mse = sess.run([gan.G_loss, gan.D_loss, gan.X_prob, gan.G_prob, gan.mse],
{gan.G_in: noise, gan.X_in: images, gan.train_flag: False})
print("Epoch %d/%d | Step %d/%d" % (epoch+1, N_EPOCH, step, len(X)//BATCH_SIZE))
print("G loss: %.4f | D loss: %.4f | D prob: %.4f | G prob: %.4f | mse: %.4f" %
(G_loss, D_loss, D_prob.mean(), G_prob.mean(), mse))
if i in range(N_EPOCH-4, N_EPOCH):
img = sess.run(gan.G_out, {gan.G_in: noise, gan.train_flag: False})[0]
plt.subplot(2, 2, i+1-(N_EPOCH-4))
plt.imshow(np.squeeze(img))
plt.tight_layout()
plt.show()
def dcgan_image_transition(z, checkpoint_file, model_params):
tree_net = DCGAN(**model_params)
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, checkpoint_file)
x_transition = sess.run(tree_net.sampler, feed_dict={tree_net.z: z})
return x_transition
def __init__(self, flags):
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth = True
self.sess = tf.Session(config=run_config)
self.flags = flags
self.dataset = Dataset(self.sess, flags, self.flags.dataset)
self.model = DCGAN(self.sess, self.flags, self.dataset.image_size)
self._make_folders()
self.iter_time = 0
self.saver = tf.train.Saver()
self.sess.run(tf.global_variables_initializer())
tf_utils.show_all_variables()
def load_model(model_params, contF=True):
from dcgan import DCGAN
import os
model = DCGAN(model_params, ltype=os.environ['LTYPE'])
if contF:
# print '...Continuing from Last time'''
from utils import unpickle
_model = unpickle(os.environ['LOAD_PATH'])
np_gen_params= [param.get_value() for param in _model.gen_network.params]
np_dis_params= [param.get_value() for param in _model.dis_network.params]
model.load(np_dis_params, np_gen_params, verbose=False)
return model
def main():
# Load MNIST data
print("[INFO] Loading MNIST handwritten digits...\n")
(X, _), (_, _) = mnist.load_data()
images = X.reshape(X.shape[0], 28, 28, 1)
# Initialize DCGAN object
gan_model = DCGAN(data=images,
learning_rate=2e-04,
batch_size=128,
latent_dim=100)
# Train GAN Model
gan_model.train(epochs=100,
batches_per_epoch=300,
checkpoint_frequency=1,
save_path='.././save_data/')
def __init__(self, j=10, batch_size=128, target="HH", data=None):
self.training_generator = None
self.test_generator = None
self.batch_size = batch_size
self.target = target
self.data = data
self.spec_cols = 1024
self.spec_length = j
self.DCGAN = DCGAN(img_rows=self.spec_length,
img_cols=self.spec_cols,
channel=1)
self.discriminator = self.DCGAN.discriminator_model()
self.adversarial = self.DCGAN.adversarial_model()
self.generator = self.DCGAN.generator()
self.data_size = 0
self.load_data()
def main(_):
# create checkpoint saver
# the checkpoint saver, can create checkpoint files, which later can be use to restore a model state, but it also
# audits the model progress to a log file
checkpoint_saver = CheckpointSaver(FLAGS.data_dir)
checkpoint_saver.save_experiment_config(FLAGS.__dict__['__flags'])
# load training data
data_set, data_set_shape = hdf5_dataset.read_data_set(
FLAGS.dataset,
image_size=FLAGS.image_size,
shape=(FLAGS.image_size, FLAGS.image_size, FLAGS.channels),
binarized=FLAGS.binarized,
validation=0)
train_data = data_set.train
# create a data visualizer
visualizer = ImageVisualizer(checkpoint_saver.get_experiment_dir(),
image_size=FLAGS.image_size)
visualizer.training_data_sample(train_data)
# create the actual DCGAN model
dcgan_model = DCGAN(FLAGS.image_size,
FLAGS.channels,
z_size=FLAGS.z_size,
learning_rate=FLAGS.learning_rate)
print("start", type(dcgan_model).__name__, "model training")
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
dcgan_model.initialize_summaries(sess,
checkpoint_saver.get_experiment_dir())
for epoch in range(FLAGS.max_epoch):
for images in train_data.next_batch(FLAGS.batch_size):
d_loss, g_loss = dcgan_model.update_params(sess, images)
msg = "epoch: %3d" % epoch + " Discriminator loss %.4f" % d_loss + " Generator loss %.4f" % g_loss
checkpoint_saver.audit_loss(msg)
dcgan_model.update_summaries(sess, images, epoch)
if epoch % FLAGS.generation_step == 0:
visualizer.save_generated_samples(
dcgan_model.generate_samples(sess, num_samples=200), epoch)
if epoch % FLAGS.checkpoint_step == 0:
checkpoint_saver.save_checkpoint(dcgan_model.saver, sess,
epoch)
def main(_):
pp.pprint(FLAGS.__flags)
# training/inference
with tf.Session() as sess:
dcgan = DCGAN(sess, FLAGS)
# path checks
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(
os.path.join(FLAGS.log_dir, dcgan.get_model_dir())):
os.makedirs(os.path.join(FLAGS.log_dir, dcgan.get_model_dir()))
if not os.path.exists(
os.path.join(FLAGS.sample_dir, dcgan.get_model_dir())):
os.makedirs(os.path.join(FLAGS.sample_dir, dcgan.get_model_dir()))
# load checkpoint if found
if dcgan.checkpoint_exists():
print("Loading checkpoints...")
if dcgan.load():
print "success!"
else:
raise IOError("Could not read checkpoints from {0}!".format(
FLAGS.checkpoint_dir))
else:
if not FLAGS.train:
raise IOError("No checkpoints found but need for sampling!")
print "No checkpoints found. Training from scratch."
dcgan.load()
# train DCGAN
if FLAGS.train:
train(dcgan)
# inference/visualization code goes here
print "Generating samples..."
inference.sample_images(dcgan)
print "Generating visualizations of z..."
inference.visualize_z(dcgan)
def main(_):
pp = pprint.PrettyPrinter()
pp.pprint(flags.FLAGS.__flags)
if FLAGS.input_width is None:
FLAGS.input_width = FLAGS.input_height
if FLAGS.output_width is None:
FLAGS.output_width = FLAGS.output_height
if not os.path.exists(FLAGS.checkpoint_dir):
os.makedirs(FLAGS.checkpoint_dir)
if not os.path.exists(FLAGS.sample_dir):
os.makedirs(FLAGS.sample_dir)
#gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)
#run_config = tf.compat.v1.ConfigProto
#run_config.gpu_options.allow_growth = True
#run_config.gpu_options.visible_device_list = ''
with tf.compat.v1.Session() as sess:
dcgan = DCGAN(
sess,
input_width=FLAGS.input_width,
input_height=FLAGS.input_height,
output_width=FLAGS.output_width,
output_height=FLAGS.output_height,
batch_size=FLAGS.batch_size,
sample_num=FLAGS.sample_num,
dataset_name=FLAGS.dataset,
input_fname_pattern=FLAGS.input_fname_pattern,
crop=FLAGS.crop,
checkpoint_dir=FLAGS.checkpoint_dir,
data_dir=FLAGS.data_dir)
model_vars = tf.trainable_variables()
slim.model_analyzer.analyze_vars(model_vars, print_info=True)
if FLAGS.train:
dcgan.train(FLAGS)
else:
if not dcgan.load(FLAGS.checkpoint_dir)[0]:
raise Exception("[!] Train a model first, then run test mode")
if FLAGS.predict:
dcgan.predict(FLAGS.predict_dataset)
else:
dcgan.test()
def __init__(self, sess, flags):
self.sess = sess
self.flags = flags
self.image_size = (flags.img_size, flags.img_size, 3)
self.z_vectors, self.learning_rate, self.velocity = None, None, None
self.masks, self.wmasks = None, None
self.dcgan = DCGAN(sess, Flags(flags), self.image_size)
self._build_net()
self._tensorboard()
print('Initialized Model Inpaint SUCCESS!')
def run_test():
model_object = DCGAN(dataset, label, data_object.input_size, class_name, generator_arch, discriminator_arch, encoder_arch, learning_rate, batch_size)
if label is None:
model_object.train(x, epochs)
else:
index = list(np.where(y[:, label] == 1)[0])
x_positive = x[index]
model_object.train(x_positive, epochs)
def test(filepath):
"""
判定を行う。
"""
with tf.Session() as sess:
# (1)モデルの復元
batch_size = 64
dcgan = DCGAN(
generator_layers=[1024, 512, 256, 128],
discriminator_layer=[64, 128, 256, 512],
batch_size=batch_size,
image_inputs=tf.placeholder(tf.float32, [batch_size, SIZE, SIZE, 3]),
)
sess.run(tf.global_variables_initializer())
g_saver = tf.train.Saver(dcgan.generator.variables)
d_saver = tf.train.Saver(dcgan.discriminator.variables)
g_saver.restore(sess=sess, save_path="../data/models/g_saver.ckpg")
d_saver.restore(sess=sess, save_path="../data/models/d_saver.ckpg")
# (2)画像の生成
sample_z = tf.random_uniform([dcgan.batch_size, dcgan.z_dim], minval=-1.0, maxval=1.0)
images = dcgan.sample_images(8, 8, inputs=sample_z)
with open(filepath, 'wb') as f:
f.write(sess.run(images))
def create_model(model=config.model,category=config.category):
if model == 'DCGAN_1':
my_model = DCGAN(name='DCGAN_1',category=category)
elif model == 'DCGAN_1X':
my_model = DCGAN(name='DCGAN_1X',category=category)
elif model == 'DCGAN_1XX':
my_model = DCGAN(name='DCGAN_1XX',category=category)
elif model == 'DCGAN_2':
my_model = DCGAN(name='DCGAN_2',category=category)
elif model == 'DCGAN_3':
my_model = DCGAN(name='DCGAN_3',category=category)
elif model == 'VAE_1':
my_model = VAE(name='VAE_1',category=category)
elif model.upper() == 'VAE_2':
my_model = VAE(name='VAE_2',category=category)
elif model == 'VAE_3':
my_model = VAE(name='VAE_3',category=category)
elif model == 'VAE_4':
my_model = VAE(name='VAE_4',category=category)
else:
my_model = VAE(name='VAE_2',category=category)
print('The selected model {} is not in the list [DCGAN_1, DCGAN_1X, DCGAN_1XX, DCGAN_2, DCGAN_3, VAE_1, VAE_2, VAE_3, VAE_4]'.format(
model))
return my_model
def main():
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch_size', '-bs',
type=int, default=64)
parser.add_argument('--nb_epoch', '-e',
type=int, default=100)
parser.add_argument('--save_steps', '-ss',
type=int, default=10)
parser.add_argument('--lr_d',
type=float, default=2e-4)
parser.add_argument('--lr_g',
type=float, default=2e-4)
parser.add_argument('--ngf', '-ngf',
type=int, default=64)
parser.add_argument('--ndf', '-ndf',
type=int, default=64)
parser.add_argument('--latent_dim', '-ld',
type=int, default=128)
parser.add_argument('--logdir',
type=str, default='logs')
parser.add_argument('--no-cuda',
dest='use_cuda',
action='store_false', default=True,
help='disables CUDA training')
args = parser.parse_args()
device = torch.device("cuda" if args.use_cuda else "cpu")
kwargs = {'num_workers': 1, 'pin_memory': True} if args.use_cuda else {}
train_loader = torch.utils.data.DataLoader(
datasets.MNIST('./data', train=True, download=True,
transform=transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Lambda(lambda x: (x-0.5)*2),
])),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
generator = Generator(args.latent_dim, args.ngf)
discriminator = Discriminator(args.ndf)
gan = DCGAN(generator, discriminator, device)
gan.init_params()
if args.use_cuda:
generator.cuda()
discriminator.cuda()
gan.fit(train_loader,
nb_epoch=args.nb_epoch,
lr_d=args.lr_d,
lr_g=args.lr_g,
save_steps=args.save_steps,
logdir=args.logdir)
def main(argv=None):
log_dir, model_dir = generate_log_model_dirs(FLAGS.root_logdir,
FLAGS.root_model_dir)
create_path(log_dir)
create_path(model_dir)
tf.reset_default_graph()
with tf.Session() as sess:
dcgan_nn = DCGAN(sess, log_dir, model_dir)
dcgan_nn.build_graph(FLAGS)
dcgan_nn.train(FLAGS)
def gan_repository(sess, flags, dataset):
if flags.gan_model == 'vanilla_gan':
print('Initializing Vanilla GAN...')
return GAN(sess, flags, dataset.image_size)
elif flags.gan_model == 'dcgan':
print('Initializing DCGAN...')
return DCGAN(sess, flags, dataset.image_size)
elif flags.gan_model == 'pix2pix':
print('Initializing pix2pix...')
return Pix2Pix(sess, flags, dataset.image_size)
elif flags.gan_model == 'pix2pix-patch':
print('Initializing pix2pix-patch...')
return Pix2PixPatch(sess, flags, dataset.image_size)
elif flags.gan_model == 'wgan':
print('Initializing WGAN...')
return WGAN(sess, flags, dataset)
elif flags.gan_model == 'cyclegan':
print('Initializing cyclegan...')
return CycleGAN(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan':
print('Initializing mrigan...')
return MRIGAN(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan02':
print('Initializing mrigan02...')
return MRIGAN02(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan03':
print('Initializing mrigan03...')
return MRIGAN03(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan01_lsgan':
print('Initializing mrigan01_lsgan...')
return MRIGAN01_LSGAN(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan02_lsgan':
print('Initializing mrigan02_lsgan...')
return MRIGAN02_LSGAN(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan03_lsgan':
print('Initializing mrigan03_lsgan...')
return MRIGAN03_LSGAN(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan_01':
print('Initializing mrigan_01...')
return MRIGAN_01(sess, flags, dataset.image_size, dataset())
elif flags.gan_model == 'mrigan_02':
print('Initializing mrigan_02...')
return MRIGAN_02(sess, flags, dataset.image_size, dataset())
else:
raise NotImplementedError
def run_gan_main(input_f,
name='normal',
generated_num=10000,
output_dir='log',
epochs=10,
show_flg=True,
gan_type='naive_gan',
time_str='',
**kwargs):
# step 1 achieve train set
train = TrafficDataset(input_f, transform=None, normalization_flg=False)
print('\'%s\' train size : (%d, %d) used for training \'%s\' naive_gan.' %
(name, len(train.X), len(train.X[0]), name))
# step 2.1 initialize gan
if gan_type == 'dcgan':
gan_m = DCGAN(num_epochs=epochs,
num_features=len(train.X[0]),
batch_size=64,
show_flg=show_flg,
output_dir=output_dir,
GAN_name=name,
time_str=time_str)
else: # default gan_type
gan_m = NaiveGAN(num_epochs=epochs,
num_features=len(train.X[0]),
batch_size=64,
show_flg=show_flg,
output_dir=output_dir,
GAN_name=name,
time_str=time_str)
# step 2.2 train gan model
print('\nTraining begins ...')
gan_m.train(train)
print('Train finished.')
# step 3.1 dump model
model_file = dump_model(gan_m,
os.path.join(output_dir, 'gan_%s_model.p' % name))
# step 3.2 load model
gan_m = load_model(model_file)
# step 4 generated more data
print('generated_num is', generated_num)
gen_data = gan_m.generate_data(generated_num)
output_f = save_data(np.asarray(gen_data).tolist(),
output_f=os.path.join(
output_dir, 'gan_%s_model' % name +
'_generated_%s_samples.csv' % str(generated_num)))
return output_f, gan_m.gan_loss_file, gan_m.gan_decision_file
def main(argv=None):
dcgan = DCGAN(
batch_size=128, f_size=6, z_dim=20,
gdepth1=216, gdepth2=144, gdepth3=96, gdepth4=64,
ddepth1=64, ddepth2=96, ddepth3=144, ddepth4=216)
input_images, num_samples = inputs(dcgan.batch_size, dcgan.f_size)
train_op = dcgan.build(input_images, feature_matching=True)
g_saver = tf.train.Saver(dcgan.g.variables)
d_saver = tf.train.Saver(dcgan.d.variables)
g_checkpoint_path = os.path.join(FLAGS.train_dir, 'g.ckpt')
d_checkpoint_path = os.path.join(FLAGS.train_dir, 'd.ckpt')
with tf.Session() as sess:
# restore or initialize generator
sess.run(tf.initialize_all_variables())
if os.path.exists(g_checkpoint_path):
print('restore variables:')
for v in dcgan.g.variables:
print(' ' + v.name)
g_saver.restore(sess, g_checkpoint_path)
if FLAGS.is_train:
# restore or initialize discriminator
if os.path.exists(d_checkpoint_path):
print('restore variables:')
for v in dcgan.d.variables:
print(' ' + v.name)
d_saver.restore(sess, d_checkpoint_path)
# setup for monitoring
sample_z = sess.run(tf.random_uniform([dcgan.batch_size, dcgan.z_dim], minval=-1.0, maxval=1.0))
images = dcgan.sample_images(4, 4, inputs=sample_z)
# start training
tf.train.start_queue_runners(sess=sess)
# shuffle inputs
for _ in range(num_samples // dcgan.batch_size + 1):
sess.run(input_images)
print('.', end='', flush=True)
print()
for step in range(FLAGS.max_steps):
start_time = time.time()
_, g_loss, d_loss = sess.run([train_op, dcgan.losses['g'], dcgan.losses['d']])
duration = time.time() - start_time
format_str = '%s: step %d, loss = (G: %.8f, D: %.8f) (%.3f sec/batch)'
print(format_str % (datetime.now(), step, g_loss, d_loss, duration))
# save generated images
if step % 100 == 0:
filename = os.path.join(FLAGS.images_dir, '%04d.jpg' % step)
with open(filename, 'wb') as f:
f.write(sess.run(images))
# save variables
if step % 100 == 0:
g_saver.save(sess, g_checkpoint_path, global_step=step)
d_saver.save(sess, d_checkpoint_path, global_step=step)
else:
generated = sess.run(dcgan.sample_images(8, 8))
filename = os.path.join(FLAGS.images_dir, 'out.jpg')
with open(filename, 'wb') as f:
print('write to %s' % filename)
f.write(generated)
