def task5(self, args, path='.'):
"""
Use as:
-task 5 --layers # --hashes # --k # --imageId #
"""
if args.layers == None or args.hashes == None or \
args.k == None or args.imageId == None:
raise ValueError(
'Layers, Hashes, Vectors, K, and IMG must all be defined for task 5.'
)
layers = int(args.layers)
hashes = int(args.hashes)
t = int(args.k)
imageId = args.imageId
if args.vectors:
vectors = str(args.vectors)
# YOUR CODE HERE
lsh = LSH()
nearest = lsh.main(layers,
hashes,
imageId,
vectors=(),
t=t,
database=self.__database__)
show_images(nearest, self.__database__)
save_images(nearest, self.__database__, join(path, 'out'))
def test(ctx, enc, dec, gdc, test_data):
global test_idx
ae_metric = mx.metric.MSE()
gd_metric = mx.metric.Accuracy()
samples = []
for images, labels in test_data:
gauss_yes = nd.ones((labels.shape[0], 1), ctx=ctx)
features = encode(enc, images, labels)
images_out = decode(dec, features, labels)
ae_metric.update([images], [images_out])
gauss_fit = gdc(features)
gd_metric.update([gauss_yes], [gauss_fit])
idx = np.random.randint(images.shape[0])
samples.append(
mx.nd.concat(images[idx], images_out[idx], dim=2)[0].asnumpy())
name, mse = ae_metric.get()
print(' AutoEncoder: {}={:.4f}'.format(name, mse))
name, mse = gd_metric.get()
print(' GaussDiscriminator: feature space satisfaction {}={:.4f}'.format(
name, mse))
try:
imgdir = '/tmp/mnist'
save_images(samples[::2], imgdir, test_idx * 1000)
test_idx += 1
print(" test images written to", imgdir)
except Exception as e:
print(" writing images failed:", e)
def train(self):
# load train datasets
(X_train, Y_train), (_, _) = cifar10.load_data()
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1],
X_train.shape[2], 3)
d_opt = Adam(lr=1e-5, beta_1=0.1)
self.discriminator.model.compile(loss='binary_crossentropy',
optimizer=d_opt)
self.discriminator.model.trainable = False
dcgan = Sequential([self.generator.model, self.discriminator.model])
g_opt = Adam(lr=2e-4, beta_1=0.5)
self.generator.model.compile(loss='binary_crossentropy',
optimizer='Adam')
dcgan.compile(loss='binary_crossentropy', optimizer=g_opt)
num_batches = int(X_train.shape[0] / self.BATCH_SIZE)
for epoc in xrange(self.NUM_EPOCH):
for batch_index in xrange(num_batches):
noise = np.array([
np.random.uniform(-1, 1, 100)
for _ in range(self.BATCH_SIZE)
])
image_batch = X_train[batch_index *
self.BATCH_SIZE:(batch_index + 1) *
self.BATCH_SIZE]
generated_images = self.generator.model.predict(noise,
verbose=0)
if batch_index % 100 == 0:
if not os.path.exists(self.GENERATED_IMAGE_PATH):
os.mkdir(self.GENERATED_IMAGE_PATH)
util.save_images(
generated_images, self.GENERATED_IMAGE_PATH +
"{:04d}_{:04d}.png".format(epoc, batch_index))
X = np.concatenate((image_batch, generated_images))
y = [1] * self.BATCH_SIZE + [0] * self.BATCH_SIZE
self.discriminator.model.trainable = True
d_loss = self.discriminator.model.train_on_batch(X, y)
self.discriminator.model.trainable = False
noise = np.array([
np.random.uniform(-1, 1, 100)
for _ in range(self.BATCH_SIZE)
])
g_loss = dcgan.train_on_batch(noise, [1] * self.BATCH_SIZE)
print("epoch: {}, batch: {}, d_loss:{}, g_loss:{}".format(
epoc, batch_index, d_loss, g_loss))
self.generator.model.save_weights('generator.h5')
self.discriminator.model.save_weights('discriminator.h5')
def sample_save(self, step):
test_files = glob(os.path.join(self.data_dir, 'test', '*'))
# [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save
testA_list = random.sample(test_files, 10)
testB_list = random.sample(test_files, 10)
attrA_list = [
self.attr_list[os.path.basename(val)] for val in testA_list
]
attrB_list = [
self.attr_list[os.path.basename(val)] for val in testB_list
]
# get batch images and labels
attrA, attrB = preprocess_attr(self.attr_names, attrA_list, attrB_list,
self.attr_keys)
imgA, imgB = preprocess_image(testA_list,
testB_list,
self.image_size,
phase='test')
dataA, dataB = preprocess_input(imgA, imgB, attrA, attrB,
self.image_size, self.n_label)
# generate fakeB
feed = {self.real_A: dataA}
fake_B = self.sess.run(self.fake_B, feed_dict=feed)
# save samples
sample_file = os.path.join(self.sample_dir, '%06d.jpg' % (step))
save_images(imgA, imgB, fake_B, self.image_size, sample_file, num=10)
def task3(self, args, path='.'):
"""
-task 3 --k #
"""
if args.k == None:
raise ValueError('K must be defined for task 3.')
k = int(args.k)
# YOUR CODE HERE.
G = self.__graph__.get_adjacency()
images = self.__graph__.get_images()
n = G.shape[0]
s = 0.86
maxerr = 0.01
# transform G into markov matrix A
A = csc_matrix(G, dtype=np.float)
rsums = np.array(A.sum(1))[:, 0]
ri, ci = A.nonzero()
A.data /= rsums[ri]
# bool array of sink states
sink = rsums == 0
# Compute pagerank r until we converge
ro, r = np.zeros(n), np.ones(n)
# account for sink states
Di = sink / float(n)
# account for teleportation to state i
Ei = np.ones(n) / float(n)
# while np.sum(np.abs(r - ro)) > maxerr:
for _ in range(150):
if np.sum(np.abs(r - ro)) <= maxerr:
break
ro = r.copy()
# calculate each pagerank at a time
for i in range(0, n):
# in-links of state i
Ai = np.array(A[:, i].todense())[:, 0]
r[i] = ro.dot(Ai * s + Di * s + Ei * (1 - s))
weights = r / float(sum(r))
orderedWeights = np.argsort(weights)
ReorderedWeights = np.flipud(orderedWeights)
# m = max(weights)
# ind = np.argmax(weights)
listOfImages = list()
for xx in range(k):
listOfImages.append(images[ReorderedWeights[xx]])
# weightDict = {}
# for xx in range(len(weights)):
# weightDict[xx] = weights[xx]
print(listOfImages)
show_images(listOfImages, self.__database__)
save_images(listOfImages, self.__database__, join(path, 'out'))
def run_scan(rotations, prefix, right=False):
s = Scanner()
print("Scanner initialized")
print("Current laser is: " + "right" if right else "left")
print("Rotations: " + str(rotations))
result = s.continuous(rotations, right=right)
print("Images taken")
raw_dir = 'raw_r' if right else 'raw_l'
util.save_images(result,
prefix,
dir_name=os.path.join("img", prefix, raw_dir))
print("Images saved")
def process_continuous(self, images, num_rotations, prefix=None, right=False):
processed = []
for i, img in enumerate(images):
angle = 360.0 * i * num_rotations / len(images)
processed.append(self.process_picture(img, angle, right))
print("Processing image {0} of {1}".format(i + 1, len(images)))
if prefix:
raw_dir = 'processed_r' if right else 'processed_l'
util.save_images(processed,
prefix,
dir_name=os.path.join("img", prefix, raw_dir))
def process_pictures(self, pictures, prefix=None):
# process pics
if filter(lambda x: x is None, pictures):
raise Exception('some pictures are null')
processed = []
for i, picture in enumerate(pictures):
#picture = resize_image(picture) #if we turn resize back on
# don't forget to adjust back_wall_x
processed.append(self.process_picture(picture, i * 360.0 / len(pictures)))
print "processed %d; angle %f" % (i, i * 360.0 / len(pictures))
if prefix:
util.save_images(processed,
prefix,
dir_name=os.path.join("img", prefix, "processed"))
def test(self):
# check if attribute available
# binary_attrsでtagを指定しているので長さは同じに
if not len(self.binary_attrs) == self.n_label:
print(
"binary_attr length is wrong! The length should be {}".format(
self.n_label))
return
# variable initialize
self.sess.run(tf.global_variables_initializer())
# load or not checkpoint
if self.phase == 'test' and self.checkpoint_load():
print(" [*] before training, Load SUCCESS ")
else:
print(" [!] before training, no need to Load ")
# [5,6] with the seequnce of (realA, realB, fakeB), totally 10 set save
# data_dirから適当なサンプルを十持ってきている
# 音声データだから連続的に適当な範囲を持ってくる
test_files = glob(os.path.join(self.data_dir, 'test', '*'))
testA_list = random.sample(test_files, 10)
# get batch images and labels
# self.attr_keys = ['Black_Hair','Blond_Hair','Brown_Hair', 'Male', 'Young','Mustache','Pale_Skin']
attrA = [float(i) for i in list(self.binary_attrs)] * len(testA_list)
imgA, _ = preprocess_image(testA_list,
testA_list,
self.image_size,
phase='test')
dataA, _ = preprocess_input(imgA, imgA, attrA, attrA, self.image_size,
self.n_label)
# generate fakeB
# 生成結果はfake_Bの中
feed = {self.real_A: dataA}
fake_B = self.sess.run(self.fake_B, feed_dict=feed)
# save samples
test_file = os.path.join(self.test_dir, 'test.jpg')
save_images(imgA, imgA, fake_B, self.image_size, test_file, num=10)
def test(ctx, enc, dec, test_data):
global test_idx
metric = mx.metric.MSE()
samples = []
for images, labels in test_data:
features = encode(enc, images, labels)
images_out = decode(dec, features, labels)
metric.update([images], [images_out])
idx = np.random.randint(images.shape[0])
samples.append(mx.nd.concat(images[idx], images_out[idx], dim=2)[0].asnumpy())
try:
imgdir = '/tmp/mnist'
save_images(samples[::2], imgdir, test_idx*1000)
test_idx += 1
print("test images written to", imgdir)
except Exception as e:
print("writing images failed:", e)
return metric.get()
def train(self, config):
X = np.load(config.training_data)
Prev = np.load(config.prev_data)
ycond = np.zeros(shape=[self.batch_size, 13])
X, Prev = shuffle(X, Prev, random_state=0)
d_optim = tf.train.AdamOptimizer(config.learning_rate, beta1=config.beta1) \
.minimize(self.d_loss, var_list=self.d_vars)
g_optim = tf.train.AdamOptimizer(config.learning_rate, beta1=config.beta1) \
.minimize(self.g_loss, var_list=self.g_vars)
self.sess.run(tf.global_variables_initializer())
self.g_sum = tf.summary.merge([
self.noise_sum, self.Df_sum, self.G_sum, self.d_loss_fake_sum,
self.g_loss_sum
])
self.d_sum = tf.summary.merge([
self.noise_sum, self.D_sum, self.d_loss_real_sum, self.d_loss_sum
])
self.writer = tf.summary.FileWriter("./logs", self.sess.graph)
counter = 0
start_time = time.time()
for epoch in range(config.epochs):
batch_idxs = len(X) // self.batch_size
for idx in range(batch_idxs):
batch_images = X[idx * self.batch_size:(idx + 1) *
self.batch_size]
prev_batch_images = Prev[idx * self.batch_size:(idx + 1) *
self.batch_size]
batch_labels = ycond.tolist()
batch_noise = sample_Z([self.batch_size, 100])
_, summary_str = self.sess.run(
[d_optim, self.d_sum],
feed_dict={
self.data: batch_images,
self.noise: batch_noise,
self.cond1d: batch_labels,
self.cond2d: prev_batch_images
})
self.writer.add_summary(summary_str, counter)
# Update G network
_, summary_str = self.sess.run(
[g_optim, self.g_sum],
feed_dict={
self.data: batch_images,
self.noise: batch_noise,
self.cond1d: batch_labels,
self.cond2d: prev_batch_images
})
self.writer.add_summary(summary_str, counter)
# Run g_optim twice to make sure that d_loss does not go to zero (different from paper)
# We've tried to run more d_optim and g_optim, while getting a better result by running g_optim twice in this MidiNet version.
_, summary_str = self.sess.run(
[g_optim, self.g_sum],
feed_dict={
self.data: batch_images,
self.noise: batch_noise,
self.cond1d: batch_labels,
self.cond2d: prev_batch_images
})
self.writer.add_summary(summary_str, counter)
errD_fake = self.sess.run(self.d_loss_fake,
feed_dict={
self.noise: batch_noise,
self.cond1d: batch_labels,
self.cond2d: prev_batch_images
})
errD_real = self.sess.run(self.d_loss_real,
feed_dict={
self.data: batch_images,
self.cond1d: batch_labels
})
errG = self.sess.run(self.g_loss,
feed_dict={
self.data: batch_images,
self.noise: batch_noise,
self.cond1d: batch_labels,
self.cond2d: prev_batch_images
})
print("Epoch: [%2d] [%4d/%4d] time: %4.4f, d_loss: %.8f, g_loss: %.8f" \
% (epoch, idx, batch_idxs,
time.time() - start_time, errD_fake+errD_real, errG))
samples, d_loss, g_loss = self.sess.run(
[self.sample, self.d_loss, self.g_loss],
feed_dict={
self.noise: batch_noise,
self.data: batch_images,
self.cond1d: batch_labels,
self.cond2d: prev_batch_images
})
#samples = (samples+1.)/2.
save_images(
samples[:5, :], [1, 5],
'{}/train_{:02d}_{:04d}.png'.format(config.sample_dir, epoch,
idx))
print("[Sample] d_loss: %.8f, g_loss: %.8f" % (d_loss, g_loss))
sound_sample = samples[0, :, :, 0]
save_midi(
sound_sample,
'{}/train_{:02d}_{:04d}.mid'.format(config.sample_dir, epoch,
idx))
print("Epoch: [%2d] time: %4.4f, d_loss: %.8f" \
% (epoch + 1,
time.time() - start_time, (errD_fake+errD_real)))
def task4(self, args, path='.'):
"""
-task 4 --k # --imgs id1 id2 id3
"""
if args.k == None or args.imgs == None:
raise ValueError('K and Imgs must be defined for task 4.')
k = int(args.k)
imgs = list(args.imgs)
# 6 2976167 83 38391649 299 135049429
# YOUR CODE HERE.
G = self.__graph__.get_adjacency()
images = self.__graph__.get_images()
indexes = list()
for x in imgs:
indexes.append(images.index(x))
n = G.shape[0]
s = 0.6
maxerr = 0.1
# transform G into markov matrix A
A = csc_matrix(G, dtype=np.float)
rsums = np.array(A.sum(1))[:, 0]
ri, ci = A.nonzero()
A.data /= rsums[ri]
# bool array of sink states
sink = rsums == 0
Ei = np.zeros(n)
for ii in indexes:
Ei[ii] = 1 / len(imgs)
# Compute pagerank r until we converge
ro, r = np.zeros(n), np.ones(n)
# while np.sum(np.abs(r - ro)) > maxerr:
for _ in range(100):
if np.sum(np.abs(r - ro)) <= maxerr:
break
ro = r.copy()
# calculate each pagerank at a time
for i in range(0, n):
# in-links of state i
Ai = np.array(A[:, i].todense())[:, 0]
# account for sink states
Di = sink / float(n)
# account for teleportation to state i
r[i] = ro.dot(Ai * s + Di * s + Ei * (1 - s))
weights = r / float(sum(r))
orderedWeights = np.argsort(weights)
ReorderedWeights = np.flipud(orderedWeights)
# m = max(weights)
# ind = np.argmax(weights)
listOfImages = list()
for xx in range(k):
listOfImages.append(images[ReorderedWeights[xx]])
print(listOfImages)
show_images(listOfImages, self.__database__)
save_images(listOfImages, self.__database__, join(path, 'out'))
import os
from arguments import Arguments
from data import CreateDataLoader
from models import create_model
from util import save_images
if __name__ == '__main__':
args = Arguments().parse()
data_loader = CreateDataLoader(args)
dataset = data_loader.load_data()
model = create_model(args)
for i, data in enumerate(dataset):
if i >= args.how_many:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
img_size = model.get_image_sizes()
print('%04d: processing image... %s' % (i, img_path))
save_images(args.results_dir, visuals, img_path, size=img_size)
count = 0
every_n = 10
with tf.gfile.Open(args.output_file, 'w') as out_file:
for filenames, images in util.load_images(args.input_dir, batch_shape, normalize=False, max_number=max_number):
count += 1
if count % every_n == 0:
start_time_loop = timeit.default_timer()
# perform image denoising
if not use_denoiser:
pass
elif use_denoiser == 'rand_uniform':
images = images + 16 * np.random.uniform(-1, 1, images.shape)
elif use_denoiser == 'rand_gaussian':
images = images + 16 * np.random.normal(0, 0.7, images.shape)
elif use_denoiser == 'quantization':
images = np.round(images / quantization_bin) * quantization_bin
else:
raise ValueError("unsupported denoising method ", use_denoiser)
images = util.normalize_image(images)
if save_denoised:
util.save_images(images, filenames, denoised_path)
labels = sess.run(predicted_labels, feed_dict={img: images})
for filename, label in zip(filenames, labels):
out_file.write('{0},{1}\n'.format(filename, label))
if count % every_n == 0:
elapsed = timeit.default_timer() - start_time_loop
print('processing speed ' + str(batch_shape[0]/elapsed) + ' samples per second')
elapsed = timeit.default_timer() - start_time
print('total elapsed time ' + str(elapsed) + ' second')
def generate(self):
noise = np.array([np.random.uniform(-1, 1, 100)
for _ in range(10)])
generated_images = self.model.predict(noise, verbose=0)
util.save_images(generated_images, "generated_image.png")
def main():
parser = make_standard_parser(
'Train a GAN model on simple square images or Clevr two-object color images',
arch_choices=arch_choices,
skip_train=True,
skip_val=True)
parser.add_argument('--z_dim',
type=int,
default=10,
help='Dimension of noise vector')
parser.add_argument('--lr2',
type=float,
default=None,
help='learning rate for generator')
parser.add_argument('--feature_match',
'-fm',
action='store_true',
help='use feature matching loss for generator.')
parser.add_argument(
'--feature_match_loss_weight',
'-fmalpha',
type=float,
default=1.0,
help='weight on the feature matching loss for generator.')
parser.add_argument(
'--pairedz',
action='store_true',
help='If True, pair the same z with a training batch each epoch')
parser.add_argument(
'--eval-train-every',
type=int,
default=0,
help='evaluate whole training set every N epochs. 0 to disable.')
args = parser.parse_args()
args.skipval = True
minibatch_size = args.minibatch
train_style, val_style = ('',
'') if args.nocolor else (colorama.Fore.BLUE,
colorama.Fore.MAGENTA)
evaltrain_style = '' if args.nocolor or args.eval_train_every <= 0 else colorama.Fore.CYAN
black_divider = True if args.arch.startswith('clevr') else False
# Get a TF session and set numpy and TF seeds
sess = setup_session_and_seeds(args.seed, assert_gpu=not args.cpu)
# 0. LOAD DATA
if args.arch.startswith('simple'):
fd = h5py.File('data/rectangle_4_uniform.h5', 'r')
train_x = np.array(fd['train_imagegray'],
dtype=float) / 255.0 # shape (2368, 64, 64, 1)
val_x = np.array(fd['val_imagegray'],
dtype=float) / 255.0 # shape (768, 64, 64, 1)
train_x = np.concatenate((train_x, val_x),
axis=0) # shape (3136, 64, 64, 1)
elif args.arch.startswith('clevr'):
(train_x, val_x) = load_sort_of_clevr()
# shape (50000, 64, 64, 3)
train_x = np.concatenate((train_x, val_x), axis=0)
else:
raise Exception('Unknown network architecture: %s' % args.arch)
print 'Train data loaded: {} images, size {}'.format(
train_x.shape[0], train_x.shape[1:])
#print 'Val data loaded: {} images, size {}'.format(val_x.shape[0], val_x.shape[1:])
#print 'Label dimension: {}'.format(val_y.shape[1:])
# 1. CREATE MODEL
assert len(train_x.shape) == 4, "image data must be of 4 dimensions"
image_h, image_w, image_c = train_x.shape[1], train_x.shape[
2], train_x.shape[3]
model = build_model(args, image_h, image_w, image_c)
print 'All model weights:'
summarize_weights(model.trainable_weights)
print 'Model summary:'
# model.summary() # TOREPLACE
print 'Another model summary:'
model.summarize_named(prefix=' ')
print_trainable_warnings(model)
# 2. COMPUTE GRADS AND CREATE OPTIMIZER
lr_gen = args.lr2 if args.lr2 else args.lr
if args.opt == 'sgd':
d_opt = tf.train.MomentumOptimizer(args.lr, args.mom)
g_opt = tf.train.MomentumOptimizer(lr_gen, args.mom)
elif args.opt == 'rmsprop':
d_opt = tf.train.RMSPropOptimizer(args.lr, momentum=args.mom)
g_opt = tf.train.RMSPropOptimizer(lr_gen, momentum=args.mom)
elif args.opt == 'adam':
d_opt = tf.train.AdamOptimizer(args.lr, args.beta1, args.beta2)
g_opt = tf.train.AdamOptimizer(lr_gen, args.beta1, args.beta2)
# Optimize w.r.t all trainable params in the model
all_vars = model.trainable_variables
d_vars = [var for var in all_vars if 'discriminator' in var.name]
g_vars = [var for var in all_vars if 'generator' in var.name]
d_grads_and_vars = d_opt.compute_gradients(
model.d_loss, d_vars, gate_gradients=tf.train.Optimizer.GATE_GRAPH)
d_train_step = d_opt.apply_gradients(d_grads_and_vars)
g_grads_and_vars = g_opt.compute_gradients(
model.g_loss, g_vars, gate_gradients=tf.train.Optimizer.GATE_GRAPH)
g_train_step = g_opt.apply_gradients(g_grads_and_vars)
hist_summaries_traintest(model.d_real_logits, model.d_fake_logits)
add_grads_and_vars_hist_summaries(d_grads_and_vars)
add_grads_and_vars_hist_summaries(g_grads_and_vars)
image_summaries_traintest(model.fake_images)
# 3. OPTIONALLY SAVE OR LOAD VARIABLES (e.g. model params, model running
# BN means, optimization momentum, ...) and then finalize initialization
saver = tf.train.Saver(
max_to_keep=None) if (args.output or args.load) else None
if args.load:
ckptfile, miscfile = args.load.split(':')
# Restore values directly to graph
saver.restore(sess, ckptfile)
with gzip.open(miscfile) as ff:
saved = pickle.load(ff)
buddy = saved['buddy']
else:
buddy = StatsBuddy(pretty_replaces=[('evaltrain_', ''), (
'eval', '')]) if args.eval_train_every > 0 else StatsBuddy()
buddy.tic() # call if new run OR resumed run
tf.global_variables_initializer().run()
# 4. SETUP TENSORBOARD LOGGING
param_histogram_summaries = get_collection_intersection_summary(
'param_collection', 'orig_histogram')
train_histogram_summaries = get_collection_intersection_summary(
'train_collection', 'orig_histogram')
train_scalar_summaries = get_collection_intersection_summary(
'train_collection', 'orig_scalar')
test_histogram_summaries = get_collection_intersection_summary(
'test_collection', 'orig_histogram')
test_scalar_summaries = get_collection_intersection_summary(
'test_collection', 'orig_scalar')
train_image_summaries = get_collection_intersection_summary(
'train_collection', 'orig_image')
test_image_summaries = get_collection_intersection_summary(
'test_collection', 'orig_image')
writer = None
if args.output:
mkdir_p(args.output)
writer = tf.summary.FileWriter(args.output, sess.graph)
# 5. TRAIN
train_iters = (train_x.shape[0]) // minibatch_size
if not args.skipval:
val_iters = (val_x.shape[0]) // minibatch_size
if args.ipy:
print 'Embed: before train / val loop (Ctrl-D to continue)'
embed()
# 2. use same noise, eval on 100 samples and save G(z),
np.random.seed()
eval_batch_size = 100
eval_z = np.random.uniform(-1, 1, size=(eval_batch_size, args.z_dim))
while buddy.epoch < args.epochs + 1:
# How often to log data
def do_log_params(ep, it, ii):
return True
def do_log_val(ep, it, ii):
return True
def do_log_train(ep, it, ii):
return (it < train_iters and it & it - 1 == 0
or it >= train_iters and it % train_iters == 0
) # Log on powers of two then every epoch
# 0. Log params
if args.output and do_log_params(
buddy.epoch, buddy.train_iter,
0) and param_histogram_summaries is not None:
params_summary_str, = sess.run([param_histogram_summaries])
writer.add_summary(params_summary_str, buddy.train_iter)
# 1. Evaluate generator by showing random generated results
# Evaluate descriminator by showing seeing correct rate on generated and real (hold-out) results
#assert(args.skipval), "only support training now"
if not args.skipval:
tic2()
# use different noise, eval on larger number of samples and get
# correct rate
np.random.seed()
val_z = np.random.uniform(-1, 1, size=(val_x.shape[0], args.z_dim))
with WithTimer('sess.run val iter', quiet=not args.verbose):
feed_dict = {
model.input_images: val_x,
model.input_noise: val_z,
learning_phase(): 0
}
if 'input_labels' in model.named_keys():
feed_dict.update({model.input_labels: val_y})
val_corr_fake_bn0, val_corr_real_bn0 = sess.run(
[model.correct_fake, model.correct_real],
feed_dict=feed_dict)
feed_dict[learning_phase()] = 1
val_corr_fake_bn1, val_corr_real_bn1 = sess.run(
[model.correct_fake, model.correct_real],
feed_dict=feed_dict)
if args.output and do_log_val(buddy.epoch, buddy.train_iter, 0):
fetch_dict = {}
if test_image_summaries is not None:
fetch_dict.update(
{'test_image_summaries': test_image_summaries})
if test_scalar_summaries is not None:
fetch_dict.update(
{'test_scalar_summaries': test_scalar_summaries})
if test_histogram_summaries is not None:
fetch_dict.update(
{'test_histogram_summaries': test_histogram_summaries})
if fetch_dict:
summary_strs = sess_run_dict(sess,
fetch_dict,
feed_dict=feed_dict)
buddy.note_list([
'correct_real_bn0', 'correct_fake_bn0', 'correct_real_bn1',
'correct_fake_bn1'
], [
val_corr_real_bn0, val_corr_fake_bn0, val_corr_real_bn1,
val_corr_fake_bn1
],
prefix='val_')
print(
'%3d (ep %d) val: %s (%.3gs/ep)' %
(buddy.train_iter, buddy.epoch,
buddy.epoch_mean_pretty_re('^val_', style=val_style), toc2()))
if args.output and do_log_val(buddy.epoch, buddy.train_iter, 0):
log_scalars(
writer,
buddy.train_iter, {
'mean_%s' % name: value
for name, value in buddy.epoch_mean_list_re('^val_')
},
prefix='buddy')
if test_image_summaries is not None:
image_summary_str = summary_strs['test_image_summaries']
writer.add_summary(image_summary_str, buddy.train_iter)
if test_scalar_summaries is not None:
scalar_summary_str = summary_strs['test_scalar_summaries']
writer.add_summary(scalar_summary_str, buddy.train_iter)
if test_histogram_summaries is not None:
hist_summary_str = summary_strs['test_histogram_summaries']
writer.add_summary(hist_summary_str, buddy.train_iter)
# In addition, evalutate 1000 more images
np.random.seed()
eval_more = np.random.uniform(-1, 1, size=(1000, args.z_dim))
feed_dict2 = {
# (100,-) generated outside of loop to keep the same every round
model.input_noise:
eval_z,
learning_phase():
0
}
eval_samples_bn0 = sess.run(model.fake_images, feed_dict=feed_dict2)
feed_dict2[learning_phase()] = 1
eval_samples_bn1 = sess.run(model.fake_images, feed_dict=feed_dict2)
# feed in 10 times because coordconv cannot handle too big of a batch
for cc in range(10):
eval_z2 = eval_more[cc * 100:(cc + 1) * 100, :]
_eval_more_samples = sess.run(
model.fake_images,
feed_dict={
model.input_noise: eval_z2, # (1000,-)
learning_phase(): 0
})
eval_more_samples = _eval_more_samples if cc == 0 else np.concatenate(
(eval_more_samples, _eval_more_samples), axis=0)
if args.output:
mkdir_p('{}/fake_images'.format(args.output))
# eval_samples_bn*: e.g. (100, 64, 64, 3)
save_images(eval_samples_bn0, [10, 10],
'{}/fake_images/g_out_bn0_epoch_{}_iter_{}.png'.format(
args.output, buddy.epoch, buddy.train_iter),
black_divider=black_divider)
save_images(eval_samples_bn1, [10, 10],
'{}/fake_images/g_out_bn1_epoch_{}.png'.format(
args.output, buddy.epoch),
black_divider=black_divider)
save_average_image(
eval_more_samples,
'{}/fake_images/g_out_averaged_epoch_{}_iter_{}.png'.format(
args.output, buddy.epoch, buddy.train_iter))
# 2. Possiby Snapshot, possibly quit
if args.output and args.snapshot_to and args.snapshot_every:
snap_intermed = args.snapshot_every > 0 and buddy.train_iter % args.snapshot_every == 0
snap_end = buddy.epoch == args.epochs
if snap_intermed or snap_end:
# Snapshot
save_path = saver.save(
sess, '%s/%s_%04d.ckpt' %
(args.output, args.snapshot_to, buddy.epoch))
print 'snappshotted model to', save_path
with gzip.open(
'%s/%s_misc_%04d.pkl.gz' %
(args.output, args.snapshot_to, buddy.epoch), 'w') as ff:
saved = {'buddy': buddy}
pickle.dump(saved, ff)
# snapshot sampled images too
ff = h5py.File(
'%s/sampled_images_%04d.h5' % (args.output, buddy.epoch),
'w')
ff.create_dataset('eval_samples_bn0', data=eval_samples_bn0)
ff.create_dataset('eval_samples_bn1', data=eval_samples_bn1)
ff.create_dataset('eval_z', data=eval_z)
ff.create_dataset('eval_z_more', data=eval_more)
ff.create_dataset('eval_more_samples', data=eval_more_samples)
ff.close()
# 2. Possiby evaluate the training set
if args.eval_train_every > 0:
if buddy.epoch % args.eval_train_every == 0:
tic2()
for ii in xrange(train_iters):
start_idx = ii * minibatch_size
if args.pairedz:
np.random.seed(args.seed + ii)
else:
np.random.seed()
batch_z = np.random.uniform(-1,
1,
size=(minibatch_size,
args.z_dim))
batch_x = train_x[start_idx:start_idx + minibatch_size]
batch_y = train_y[start_idx:start_idx + minibatch_size]
feed_dict = {
model.input_images: batch_x,
# model.input_labels: batch_y,
model.input_noise: batch_z,
learning_phase(): 0,
}
if 'input_labels' in model.named_keys():
feed_dict.update({model.input_labels: val_y})
fetch_dict = model.trackable_dict()
result_eval_train = sess_run_dict(sess,
fetch_dict,
feed_dict=feed_dict)
buddy.note_weighted_list(
batch_x.shape[0],
model.trackable_names(), [
result_eval_train[k]
for k in model.trackable_names()
],
prefix='evaltrain_bn0_')
feed_dict = {
model.input_images: batch_x,
# model.input_labels: batch_y,
model.input_noise: batch_z,
learning_phase(): 1,
}
if 'input_labels' in model.named_keys():
feed_dict.update({model.input_labels: val_y})
result_eval_train = sess_run_dict(sess,
fetch_dict,
feed_dict=feed_dict)
buddy.note_weighted_list(
batch_x.shape[0],
model.trackable_names(), [
result_eval_train[k]
for k in model.trackable_names()
],
prefix='evaltrain_bn1_')
if args.output:
log_scalars(writer,
buddy.train_iter, {
'batch_%s' % name: value
for name, value in buddy.last_list_re(
'^evaltrain_bn0_')
},
prefix='buddy')
log_scalars(writer,
buddy.train_iter, {
'batch_%s' % name: value
for name, value in buddy.last_list_re(
'^evaltrain_bn1_')
},
prefix='buddy')
if args.output:
log_scalars(writer,
buddy.epoch, {
'mean_%s' % name: value
for name, value in
buddy.epoch_mean_list_re('^evaltrain_bn0_')
},
prefix='buddy')
log_scalars(writer,
buddy.epoch, {
'mean_%s' % name: value
for name, value in
buddy.epoch_mean_list_re('^evaltrain_bn1_')
},
prefix='buddy')
print('%3d (ep %d) evaltrain: %s (%.3gs/ep)' %
(buddy.train_iter, buddy.epoch,
buddy.epoch_mean_pretty_re(
'^evaltrain_bn0_', style=evaltrain_style), toc2()))
print('%3d (ep %d) evaltrain: %s (%.3gs/ep)' %
(buddy.train_iter, buddy.epoch,
buddy.epoch_mean_pretty_re(
'^evaltrain_bn1_', style=evaltrain_style), toc2()))
if buddy.epoch == args.epochs:
if args.ipy:
print 'Embed: at end of training (Ctrl-D to exit)'
embed()
break # Extra pass at end: just report val stats and skip training
# 3. Train on training set
if args.shuffletrain:
train_order = np.random.permutation(train_x.shape[0])
train_order2 = np.random.permutation(train_x.shape[0])
tic3()
for ii in xrange(train_iters):
tic2()
start_idx = ii * minibatch_size
if args.pairedz:
np.random.seed(args.seed + ii)
else:
np.random.seed()
batch_z = np.random.uniform(-1,
1,
size=(minibatch_size, args.z_dim))
if args.shuffletrain:
#batch_x = train_x[train_order[start_idx:start_idx + minibatch_size]]
batch_x = train_x[sorted(train_order[start_idx:start_idx +
minibatch_size].tolist())]
if args.feature_match:
assert args.shuffletrain, "feature matching loss requires shuffle train"
batch_x2 = train_x[sorted(
train_order2[start_idx:start_idx +
minibatch_size].tolist())]
if 'input_labels' in model.named_keys():
batch_y = train_y[sorted(
train_order[start_idx:start_idx +
minibatch_size].tolist())]
else:
batch_x = train_x[start_idx:start_idx + minibatch_size]
if 'input_labels' in model.named_keys():
batch_y = train_y[start_idx:start_idx + minibatch_size]
feed_dict = {
model.input_images: batch_x,
# model.input_labels: batch_y,
model.input_noise: batch_z,
learning_phase(): 1,
}
if 'input_labels' in model.named_keys():
feed_dict.update({model.input_labels: batch_y})
if 'input_images2' in model.named_keys():
feed_dict.update({model.input_images2: batch_x2})
fetch_dict = model.trackable_and_update_dict()
if args.output and do_log_train(buddy.epoch, buddy.train_iter, ii):
if train_histogram_summaries is not None:
fetch_dict.update({
'train_histogram_summaries':
train_histogram_summaries
})
if train_scalar_summaries is not None:
fetch_dict.update(
{'train_scalar_summaries': train_scalar_summaries})
if train_image_summaries is not None:
fetch_dict.update(
{'train_image_summaries': train_image_summaries})
with WithTimer('sess.run train iter', quiet=not args.verbose):
result_train = sess_run_dict(sess,
fetch_dict,
feed_dict=feed_dict)
# if result_train['d_loss'] < result_train['g_loss']:
# #print 'Only train G'
# sess.run(g_train_step, feed_dict=feed_dict)
# else:
# #print 'Train both D and G'
# sess.run(d_train_step, feed_dict=feed_dict)
# sess.run(g_train_step, feed_dict=feed_dict)
# sess.run(g_train_step, feed_dict=feed_dict)
sess.run(d_train_step, feed_dict=feed_dict)
sess.run(g_train_step, feed_dict=feed_dict)
sess.run(g_train_step, feed_dict=feed_dict)
if do_log_train(buddy.epoch, buddy.train_iter, ii):
buddy.note_weighted_list(
batch_x.shape[0],
model.trackable_names(),
[result_train[k] for k in model.trackable_names()],
prefix='train_')
print('[%5d] [%2d/%2d] train: %s (%.3gs/i)' %
(buddy.train_iter, buddy.epoch, args.epochs,
buddy.epoch_mean_pretty_re('^train_',
style=train_style), toc2()))
if args.output and do_log_train(buddy.epoch, buddy.train_iter, ii):
if train_histogram_summaries is not None:
hist_summary_str = result_train[
'train_histogram_summaries']
writer.add_summary(hist_summary_str, buddy.train_iter)
if train_scalar_summaries is not None:
scalar_summary_str = result_train['train_scalar_summaries']
writer.add_summary(scalar_summary_str, buddy.train_iter)
if train_image_summaries is not None:
image_summary_str = result_train['train_image_summaries']
writer.add_summary(image_summary_str, buddy.train_iter)
log_scalars(
writer,
buddy.train_iter, {
'batch_%s' % name: value
for name, value in buddy.last_list_re('^train_')
},
prefix='buddy')
if ii > 0 and ii % 100 == 0:
print ' %d: Average iteration time over last 100 train iters: %.3gs' % (
ii, toc3() / 100)
tic3()
buddy.inc_train_iter() # after finished training a mini-batch
buddy.inc_epoch() # after finished training whole pass through set
if args.output and do_log_train(buddy.epoch, buddy.train_iter, 0):
log_scalars(
writer,
buddy.train_iter, {
'mean_%s' % name: value
for name, value in buddy.epoch_mean_list_re('^train_')
},
prefix='buddy')
print '\nFinal'
print '%02d:%d val: %s' % (buddy.epoch, buddy.train_iter,
buddy.epoch_mean_pretty_re('^val_',
style=val_style))
print '%02d:%d train: %s' % (buddy.epoch, buddy.train_iter,
buddy.epoch_mean_pretty_re('^train_',
style=train_style))
print '\nfinal_stats epochs %g' % buddy.epoch
print 'final_stats iters %g' % buddy.train_iter
print 'final_stats time %g' % buddy.toc()
for name, value in buddy.epoch_mean_list_all():
print 'final_stats %s %g' % (name, value)
if args.output:
writer.close() # Flush and close
def train(self):
# Create fade-in (transition) parameters.
step_pl = tf.placeholder(tf.float32, shape=None)
alpha_transition_assign = self.alpha_transition.assign(
step_pl / self.max_iterations)
# Create Optimizers
opti_D = tf.train.AdamOptimizer(learning_rate=self.learning_rate,
beta1=0.0,
beta2=0.99).minimize(
self.D_loss, var_list=self.d_vars)
opti_G = tf.train.AdamOptimizer(learning_rate=self.learning_rate,
beta1=0.0,
beta2=0.99).minimize(
self.G_loss, var_list=self.g_vars)
# Create Volume Transparency Stuff..
self.low_volumes = downscale(self.volumes, 2)
self.low_volumes = upscale(self.low_volumes, 2)
self.real_volumes = self.alpha_transition * self.volumes + (
1 - self.alpha_transition) * self.low_volumes
downscale_factor = 64 / (2**(self.progressive_depth + 1))
self.raw_volumes = tf.placeholder(
tf.float32, [self.batch_size, 64, 64, 64, self.channel])
self.input_volumes = downscale(self.raw_volumes, downscale_factor)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
# Personally have no idea what is being logged in this thing --andrew
sess.run(init)
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(self.log_dir, sess.graph)
# No idea what the saving systems is like. TODO investigate --andrew.
# I don't think you need to save and reload models if you create a crazy
# system where you're only optimizing certain outputs/cost functions at
# any one time.
if self.progressive_depth != 1 and self.progressive_depth != 10:
if self.transition:
self.r_saver.restore(sess, self.input_model_path)
self.rgb_saver.restore(sess, self.input_model_path)
else:
self.saver.restore(sess, self.input_model_path)
step = 0
batch_num = 0
while step <= self.max_iterations:
n_critic = 1
# Update Discriminator
for i in range(n_critic):
sample_latent = np.random.normal(
size=[self.batch_size, self.latent_size])
# Not very Tensorflow aesthetic, here.
realbatch_array = self.training_data.get_next_batch(
batch_num=batch_num,
zoom_level=self.zoom_level,
batch_size=self.batch_size)
realbatch_array = sess.run(
self.input_volumes,
feed_dict={self.raw_volumes: realbatch_array})
if self.transition and self.progressive_depth != 0:
realbatch_array = sess.run(
self.real_volumes,
feed_dict={self.volumes: realbatch_array})
sess.run(opti_D,
feed_dict={
self.volumes: realbatch_array,
self.latent: sample_latent
})
batch_num += 1
# Update Generator
sess.run(opti_G, feed_dict={self.latent: sample_latent})
summary_str = sess.run(summary_op,
feed_dict={
self.volumes: realbatch_array,
self.latent: sample_latent
})
summary_writer.add_summary(summary_str, step)
# the alpha of fake_in process
sess.run(alpha_transition_assign, feed_dict={step_pl: step})
if step % 40 == 0:
D_loss, G_loss, D_origin_loss, alpha_tra = sess.run(
[
self.D_loss, self.G_loss, self.D_origin_loss,
self.alpha_transition
],
feed_dict={
self.volumes: realbatch_array,
self.latent: sample_latent
})
print(
"PG %d, step %d: D loss=%.7f G loss=%.7f, D_or loss=%.7f, opt_alpha_tra=%.7f"
% (self.progressive_depth, step, D_loss, G_loss,
D_origin_loss, alpha_tra))
if step % 400 == 0:
save_images(
realbatch_array[0:self.batch_size],
[2, self.batch_size / 2],
'{}/{:02d}_real.nii.gz'.format(self.samples_dir, step))
if self.transition and self.progressive_depth != 0:
low_realbatch_array = sess.run(
self.low_volumes,
feed_dict={self.volumes: realbatch_array})
save_images(
low_realbatch_array[0:self.batch_size],
[2, self.batch_size / 2],
'{}/{:02d}_real_lower.nii.gz'.format(
self.samples_dir, step))
fake_image = sess.run(self.fake_images,
feed_dict={
self.volumes: realbatch_array,
self.latent: sample_latent
})
save_images(
fake_image[0:self.batch_size],
[2, self.batch_size / 2],
'{}/{:02d}_train.nii.gz'.format(
self.samples_dir, step))
if np.mod(step, 4000) == 0 and step != 0:
self.saver.save(sess, self.output_model_path)
step += 1
save_path = self.saver.save(sess, self.output_model_path)
print "Model saved in file: %s" % save_path
tf.reset_default_graph()
def train(self, config):
batch_size = config.batch_size
learn_rate = config.learning_rate
#################################### 定义优化器
# D的优化器
with tf.name_scope('D_train'):
d_optimizer = tf.train.MomentumOptimizer(
self.d_learn_rate, 0.5).minimize(
self.d_loss,
# global_step=global_step,
var_list=[
t for t in tf.global_variables()
if t.name.startswith('Discrim')
])
# G的优化器
with tf.name_scope('G_train'):
g_optimizer = tf.train.MomentumOptimizer(
self.g_learn_rate, 0.5).minimize(
self.g_loss,
# global_step=tf.Variable(0),
var_list=[
t for t in tf.global_variables()
if t.name.startswith('Generator')
])
import os
if not os.path.exists("./checkpoint"): # 创建checkpoint存放文件夹
os.mkdir("./checkpoint")
if not os.path.exists("./samples"): # 创建样本产生的文件夹
os.mkdir("./samples")
writer = tf.summary.FileWriter(".//test", self.sess.graph)
writer.add_graph(self.sess.graph)
sum_var = tf.summary.merge_all()
saver = tf.train.Saver()
tf.global_variables_initializer().run()
print("begin to get trainning data of MNIST")
from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets(config.datadir,
validation_size=0) # 载入训练数据，不需要验证数据
data = data.train # 仅保留训练数据
batch_num = data.num_examples // batch_size
images = []
for i in range(batch_num):
images.append(data.next_batch(batch_size)[0])
print("data has prepared")
sess = self.sess
index = 0
print('begin to train GAN....')
for step in range(config.epoch):
# 使用G生成一批样本:
d_loss_sum = 0.0
g_loss_sum = 0.0
for batch in range(1):
batch_data = images[index]
index = (index + 1) % batch_num
# 训练D
noise = random_data(batch_size, self.input_dim)
d_loss_value, _, sum_v = sess.run(
[self.d_loss, d_optimizer, sum_var],
feed_dict={
self.input_real: batch_data,
self.input_fake: noise,
self.d_learn_rate: learn_rate,
self.drop_possible: 0.5,
})
d_loss_sum = d_loss_sum + d_loss_value
writer.add_summary(sum_v, (step) * batch_num + batch)
# 训练G
g_loss_value, _ = sess.run(
[self.g_loss, g_optimizer],
feed_dict={
self.input_fake: noise,
self.g_learn_rate: learn_rate,
self.drop_possible: 1.0,
})
g_loss_sum = g_loss_sum + g_loss_value
noise = random_data(batch_size, self.input_dim)
generate = sess.run(self.fake_data,
feed_dict={
self.input_fake: noise,
})
# print("before generate0",generate[0])
# print("before generate1",generate[1])
# generate = denormal_image(generate)
if step == 5000:
print("generate0", generate[0])
print("generate1", generate[1])
image1 = np.resize(generate[0], (28, 28))
image2 = np.resize(generate[1], (28, 28))
imsave("./samples/5000_1.jpg", image1)
imsave("./samples/5000_2.jpg", image2)
if step % 100 == 0:
print("[%4d] GAN-d-loss: %.12f GAN-g-loss: %.12f" %
(step, d_loss_sum / batch_num, g_loss_sum / batch_num))
# generate = denormal_image(generate[0:64])
generate = generate[0:64]
# print("generate0",generate[0])
# print("generate1",generate[1])
save_images(generate, (8, 8), (28, 28, 1),
"./samples/train_%d.jpg" % step)
if step % 5000 == 0:
saver.save(self.sess, os.path.join("./checkpoint", 'gan.ckpt'))
print("check point saving...")
noise = random_data(batch_size, self.input_dim)
generate = sess.run(self.fake_data,
feed_dict={
self.input_fake: noise,
})
generate = denormal_image(generate[0:64])
save_images(generate, (8, 8), (28, 28, 1), "./samples/final.jpg")
print("train finished" + "." * 10)
opt.num_threads = 0
opt.batch_size = 1
opt.serial_batches = True
opt.no_flip = True
opt.display_id = -1
dataset = create_dataset(opt)
model = create_model(opt)
model.setup(opt)
web_dir = os.path.join(opt.results_dir, opt.name,
'%s_%s' % (opt.phase, opt.epoch))
webpage = util.HTML(
web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' %
(opt.name, opt.phase, opt.epoch))
if opt.eval:
model.eval()
for i, data in enumerate(dataset):
if i >= opt.num_test:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
if i % 5 == 0:
print('processing (%04d)-th image... %s' % (i, img_path))
save_images(webpage,
visuals,
img_path,
aspect_ratio=opt.aspect_ratio,
width=opt.display_winsize)
webpage.save()
