def sampling_model(sess, model, gen_model, data_set, step, seq_len, subset_str=''):
"""Returns the average weighted cost, reconstruction cost and KL cost."""
sketch_size, photo_size = data_set.sketch_size, data_set.image_size
image_index = np.random.randint(0, photo_size)
sketch_index = data_set.get_corr_sketch_id(image_index)
gt_strokes = data_set.sketch_strokes[sketch_index]
image_feat, rnn_enc_seq_len = data_set.get_input_image(image_index)
sample_strokes, m = sample(sess, model, image_feat, seq_len=seq_len, rnn_enc_seq_len=rnn_enc_seq_len)
strokes = utils.to_normal_strokes(sample_strokes)
svg_gen_sketch = os.path.join(FLAGS.img_dir, '%s/%s/gensketch_for_photo%d_step%d.svg' % (data_set.dataset, subset_str, image_index, step))
utils.draw_strokes(strokes, svg_filename=svg_gen_sketch)
svg_gt_sketch = os.path.join(FLAGS.img_dir, '%s/%s/gt_sketch%d_for_photo%d.svg' % (data_set.dataset, subset_str, sketch_index, image_index))
utils.draw_strokes(gt_strokes, svg_filename=svg_gt_sketch)
input_sketch = data_set.pad_single_sketch(image_index)
feed = {gen_model.input_sketch: input_sketch, gen_model.input_photo: image_feat, gen_model.sequence_lengths: [seq_len]}
gen_photo = sess.run(gen_model.gen_photo, feed)
gen_photo_file = os.path.join(FLAGS.img_dir, '%s/%s/gen_photo%d_step%d.png' % (data_set.dataset, subset_str, image_index, step))
cv2.imwrite(gen_photo_file, cv2.cvtColor(gen_photo[0, ::].astype(np.uint8), cv2.COLOR_RGB2BGR))
gt_photo = os.path.join(FLAGS.img_dir, '%s/%s/gt_photo%d.png' % (data_set.dataset, subset_str, image_index))
if len(image_feat[0].shape) == 2:
cv2.imwrite(gt_photo, image_feat[0])
else:
cv2.imwrite(gt_photo, cv2.cvtColor(image_feat[0].astype(np.uint8), cv2.COLOR_RGB2BGR))
def sampling_model_eval(sess, model, gen_model, data_set, seq_len):
"""Returns the average weighted cost, reconstruction cost and KL cost."""
sketch_size, photo_size = data_set.sketch_size, data_set.image_size
folders_to_create = ['gen_test', 'gen_test_png', 'gt_test', 'gt_test_png', 'gt_test_photo', 'gt_test_sketch_image',
'gen_test_s', 'gen_test_s_png', 'gen_test_inter', 'gen_test_inter_png', 'gen_test_inter_sep',
'gen_test_inter_sep_png', 'gen_photo', 'gen_test_inter_with_photo', 'recon_test',
'recon_test_png', 'recon_photo']
for folder_to_create in folders_to_create:
folder_path = os.path.join(FLAGS.img_dir, '%s/%s' % (data_set.dataset, folder_to_create))
if not os.path.exists(folder_path):
os.mkdir(folder_path)
for image_index in range(photo_size):
sys.stdout.write('\x1b[2K\r>> Sampling test set, [%d/%d]' % (image_index + 1, photo_size))
sys.stdout.flush()
image_feat, rnn_enc_seq_len = data_set.get_input_image(image_index)
sample_strokes, m = sample(sess, model, image_feat, seq_len=seq_len, rnn_enc_seq_len=rnn_enc_seq_len)
strokes = utils.to_normal_strokes(sample_strokes)
svg_gen_sketch = os.path.join(FLAGS.img_dir, '%s/gen_test/gen_sketch%d.svg' % (data_set.dataset, image_index))
png_gen_sketch = os.path.join(FLAGS.img_dir, '%s/gen_test_png/gen_sketch%d.png' % (data_set.dataset, image_index))
utils.sv_svg_png_from_strokes(strokes, svg_filename=svg_gen_sketch, png_filename=png_gen_sketch)
print("\nSampling finished")
def decode(session, sample_model, max_seq_len, z_input=None, temperature=0.1):
z = None
if z_input is not None:
z = [z_input]
sample_strokes, m = sketch_rnn_model.sample(session, sample_model,
seq_len=max_seq_len, temperature=temperature, z=z)
strokes = utils.to_normal_strokes(sample_strokes) # sample_strokes in stroke-5 format, strokes in stroke-3 format
return strokes
def evaluate(model, metrics, test_loader, vocab_desc, vocab_api, f_eval,
repeat):
ivocab_api = {v: k for k, v in vocab_api.items()}
ivocab_desc = {v: k for k, v in vocab_desc.items()}
recall_bleus, prec_bleus = [], []
local_t = 0
for descs, apiseqs, desc_lens, api_lens in tqdm(test_loader):
if local_t > 2000:
break
desc_str = indexes2sent(descs[0].numpy(), vocab_desc)
descs, desc_lens = gVar(descs), gVar(desc_lens)
sample_words, sample_lens = model.sample(descs, desc_lens, repeat)
# nparray: [repeat x seq_len]
pred_sents, _ = indexes2sent(sample_words, vocab_api)
pred_tokens = [sent.split(' ') for sent in pred_sents]
ref_str, _ = indexes2sent(apiseqs[0].numpy(), vocab_api,
vocab_api["<s>"])
ref_tokens = ref_str.split(' ')
max_bleu, avg_bleu = metrics.sim_bleu(pred_tokens, ref_tokens)
recall_bleus.append(max_bleu)
prec_bleus.append(avg_bleu)
local_t += 1
f_eval.write("Batch %d \n" % (local_t)) # print the context
f_eval.write("Query: {} \n".format(desc_str))
f_eval.write("Target >> %s\n" %
(ref_str.replace(" ' ", "'"))) # print the true outputs
for r_id, pred_sent in enumerate(pred_sents):
f_eval.write("Sample %d >> %s\n" %
(r_id, pred_sent.replace(" ' ", "'")))
f_eval.write("\n")
recall_bleu = float(np.mean(recall_bleus))
prec_bleu = float(np.mean(prec_bleus))
f1 = 2 * (prec_bleu * recall_bleu) / (prec_bleu + recall_bleu + 10e-12)
report = "Avg recall BLEU %f, avg precision BLEU %f, F1 %f" % (
recall_bleu, prec_bleu, f1)
print(report)
f_eval.write(report + "\n")
print("Done testing")
return recall_bleu, prec_bleu
def test_flip_dist(sess, model, sample_model, hps, feed, s, a, p, n):
tf_images = sess.run(model.tf_images, feed)
import matplotlib.pyplot as plt
if hps.vae_type == 'p2s':
orig_sketch_png = np.array(p[0, ::], np.uint8)
else:
orig_sketch_png = np.array(
np.stack([n[0, ::], n[0, ::], n[0, ::]], axis=-1), np.uint8)
if hps.basenet in ['inceptionv1', 'inceptionv3']:
dist_sketch_png = np.array((tf_images[0, ::] + 1) * 255 / 2, np.uint8)
elif hps.basenet in ['sketchanet']:
dist_sketch_png = np.array(tf_images[0, ::] + 250.42, np.uint8)
else:
raise Exception('basenet type error')
import cv2
cv2.imwrite('./orig_image.png', orig_sketch_png)
cv2.imwrite('./dist_image.png', dist_sketch_png)
import pdb
pdb.set_trace()
flipr_stroke = a[0, :, :4]
flipr_stroke[:, 2] = a[0, :, 3]
flipr_stroke[:, 2] += a[0, :, 4]
flipr_stroke[:, 3] = a[0, :, 4]
sv_svg_png_from_strokes(flipr_stroke,
svg_filename='./flipr_stroke.svg',
png_filename='./flipr_stroke.png')
gen_strokes = sess.run(model.gen_strokes, feed)
sv_svg_png_from_strokes(gen_strokes[0, :s[0], :],
svg_filename='./gen_stroke.svg',
png_filename='./gen_stroke.png')
tar_strokes = sess.run(model.target_strokes, feed)
sv_svg_png_from_strokes(tar_strokes[0, :s[0], :],
svg_filename='./tar_stroke.svg',
png_filename='./tar_stroke.png')
# sampel via the eval model
from model import sample
sample_strokes, m = sample(sess,
sample_model,
p[:1, ::],
seq_len=hps.max_seq_len,
greedy_mode=True)
sample_strokes_normal = to_normal_strokes(sample_strokes)
sv_svg_png_from_strokes(sample_strokes_normal,
svg_filename='./sample_stroke.svg',
png_filename='./sample_stroke.png')
'''
MIT License
Copyright (c) 2017 Mat Leonard
'''
import argparse
from model import CharRNN, load_model, sample
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('checkpoint', type=str, default=None,
help='initialize network from checkpoint')
parser.add_argument('--gpu', action='store_true', default=False,
help='run the network on the GPU')
parser.add_argument('--num_samples', type=int, default=200,
help='number of samples for generating text')
parser.add_argument('--prime', type=str, default='From afar',
help='prime the network with characters for sampling')
parser.add_argument('--top_k', type=int, default=10,
help='sample from top K character probabilities')
args = parser.parse_args()
net = load_model(args.checkpoint)
print(sample(net, args.num_samples, cuda=args.gpu, top_k=args.top_k, prime=args.prime))
sentence = ''
diversity = 0.25
sonnet = ''
# want to generate the poem backwards
for i in range(13, -1, -1):
line = generated
sentence = (sentence + '#\n' + generated[::-1])[-25:]
syls = len(line.split(' '))
while True:
# convert sentence to data format for model
x = np.zeros((1, seq_length, len(chars)))
for t, char in enumerate(sentence):
x[0, t, char_to_int[char]] = 1.
preds = model.predict(x, verbose=0)[0]
next_index = sample(preds, diversity)
next_char = int_to_char[next_index]
# ignore special characters
if (next_char == '\n') or (next_char == '#'):
sentence = sentence[1:] + next_char
continue
# ideally I would have created a syllable counter, but we're just
# using a word count for now
if (next_char == ' '):
syls += 1
if syls >= 10:
break
line = next_char + line
default=10000,
help='sample size for Monte Carlo model')
args = parser.parse_args()
with open(args.passwordfile, 'rt') as f:
training = [w.strip('\r\n') for w in f]
models = {
'{}-gram'.format(i): ngram_chain.NGramModel(training, i)
for i in range(args.min_ngram, args.max_ngram + 1)
}
models['Backoff'] = backoff.BackoffModel(training, 10)
models['PCFG'] = pcfg.PCFG(training)
samples = {
name: list(model.sample(args.samplesize))
for name, model in models.items()
}
estimators = {
name: model.PosEstimator(sample)
for name, sample in samples.items()
}
modelnames = sorted(models)
writer = csv.writer(sys.stdout)
writer.writerow(['password'] + modelnames)
for password in sys.stdin:
password = password.strip('\r\n')
estimations = [
