def infer(sess, model, hps, iterator): # Example of using model in inference mode. Load saved model using hps.restore_path # Can provide x, y from files instead of dataset iterator # If model is uncondtional, always pass y = np.zeros([bs], dtype=np.int32) if hps.direct_iterator: iterator = iterator.get_next() xs = [] zs = [] for it in range(hps.full_test_its): if hps.direct_iterator: # replace with x, y, attr if you're getting CelebA attributes, also modify get_data x, y = sess.run(iterator) else: x, y = iterator() z = model.encode(x, y) x = model.decode(y, z) xs.append(x) zs.append(z) x = np.concatenate(xs, axis=0) z = np.concatenate(zs, axis=0) np.save('logs/x.npy', x) np.save('logs/z.npy', z) return zs
def infer(sess, model, hps, iterator): # Example of using model in inference mode. Load saved model using hps.restore_path # Can provide x, y from files instead of dataset iterator # If model is uncondtional, always pass y = np.zeros([bs], dtype=np.int32) if hps.direct_iterator: iterator = iterator.get_next() xs = [] zs = [] for it in range(hps.full_test_its): if hps.direct_iterator: # replace with x, y, attr if you're getting CelebA attributes, also modify get_data x, y = sess.run(iterator) else: x, y = iterator() z = model.encode(x, y) x = model.decode(y, z) xs.append(x) zs.append(z) x = np.concatenate(xs, axis=0) z = np.concatenate(zs, axis=0) np.save('logs/x.npy', x) np.save('logs/z.npy', z) return zs
def run_one_epoch(data_type, dataloader, trainer, epoch, run_type, collector=None): t0 = time.time() assert data_type in ['dev', 'test'] assert run_type in ['teacher_force', 'generation'] model, optimizer, scheduler, tokenizer = trainer LOSS, match, bi_match = {'bi': 0, 'lm': 0, 'mention': 0, 'reference': 0, 'total': 0}, [], [] # result container coref_lines = [] iterator = enumerate(tqdm(dataloader, desc="Epoch {} {}".format(epoch, run_type), disable=args.disable_display)) if args.disable_display: print('Evaluation progress is not showing') for step, batch in iterator: if run_type == 'teacher_force': loss, _, _, _, _, _, _ = model(input_ids=batch['input_ids'], attention_mask=batch['attention_mask'], \ token_type_ids=batch['token_type_ids'], labels=batch['label_ids'], \ mention_labels=batch['mention_label_ids'], batch=batch, coref_links=batch['coref_label']) for k, v in loss.items(): LOSS[k] += v.item() else: decode_output = decode(args, batch, model, tokenizer) score_fn(args, decode_output, batch, match, collector, qr_metric, coref_lines, bi_match) # log if run_type == 'teacher_force': for k, v in LOSS.items(): LOSS[k] /= (step+1) print_loss(epoch, data_type, LOSS, t0) return LOSS else: # record decoding result res = {} if 'qr' in args.task: qr_res = qr_metric.get_metric(reset=True) qr_res['Exact match'] = sum(match) / len(match) * 100 get_binary_res(bi_match, qr_res, args) res['qr'] = qr_res else: res['qr'] = {} if 'coref' in args.task: # prepare conll files key_path = args.dev_conll if data_type == 'dev' else args.test_conll response_path = 'temp/{}.response'.format(args.model_name) # a temp file for calculating coref score with open(response_path, 'w') as f: f.writelines(coref_lines) res['coref'] = coref_evaluate(key_path, response_path, args) else: res['coref'] = {} print_score(args, epoch, data_type, res, t0) return res
def reply(history): clean_history = [clean(str(m).strip()) for m in tokenize(history)] src = " ".join([e + " _eos" for e in clean_history]) tgt = "" fct = best_fact(clean_history[-1]) print(src) print(fct) input_seq, input_lens, target_seq, target_lens = model.prep_batch([(src,tgt,fct)]) output = model.decode(input_seq, input_lens) return output[0]
def greedy_decode(model, src, src_mask, max_len, start_symbol): memory = model.encode(src, src_mask) ys = torch.ones(1, 1).fill_(start_symbol).type_as(src.data) for i in range(max_len - 1): out = model.decode( memory, src_mask, Variable(ys), Variable(subsequent_mask(ys.size(1)).type_as(src.data))) prob = model.generator(out[:, -1]) _, next_word = torch.max(prob, dim=1) next_word = next_word.data[0] ys = torch.cat( [ys, torch.ones(1, 1).type_as(src.data).fill_(next_word)], dim=1) return ys
def sample(opt): # Initialize TensorFlow session. tf.InteractiveSession() assert(opt.model_path or opt.pretrained), 'specify weights path or pretrained model' if opt.model_path: raise NotImplementedError elif opt.pretrained: assert(opt.pretrained == 'celebahq') # make sure to git clone glow repository first sys.path.append('resources/glow/demo') import model eps_std = 0.7 eps_size = model.eps_size rng = np.random.RandomState(opt.seed) attr = np.random.RandomState(opt.seed+1) tags = [] amts = [] for batch_start in tqdm(range(0, opt.num_samples, opt.batch_size)): # Generate latent vectors. bs = min(opt.num_samples, batch_start + opt.batch_size) - batch_start feps = rng.normal(scale=eps_std, size=[bs, eps_size]) if opt.manipulate: tag = attr.randint(len(model._TAGS), size=bs) amt = attr.uniform(-1, 1, size=(bs, 1)) dzs = model.z_manipulate[tag] feps = feps + amt * dzs tags.append(tag) amts.append(amt) images = model.decode(feps) # Save images as PNG. for idx in range(images.shape[0]): filename = os.path.join(opt.output_path, 'seed%03d_sample%06d.%s' % (opt.seed, batch_start + idx, opt.format)) im = PIL.Image.fromarray(images[idx], 'RGB') if opt.resize: im = im.resize((opt.resize, opt.resize), PIL.Image.LANCZOS) im.save(filename) if opt.manipulate: outfile = os.path.join(opt.output_path, 'manipulations.npz') np.savez(outfile, tags=np.concatenate(tags), amts=np.concatenate(amts))
def infer(sess, model, hps, iterators, its): from tqdm import tqdm assert hps.restore_path_A != '' assert hps.restore_path_B != '' xs_A, xs_B = [], [] zs_A, zs_B = [], [] for it in tqdm(range(its)): x_A, y_A = iterators['A']() x_B, y_B = iterators['B']() # A2B z_A = model.encode(x_A, y_A, 'model_A') x_B_recon = model.decode(y_B, z_A, 'model_B') xs_B.append(x_B_recon) zs_A.append(z_A) # B2A z_B = model.encode(x_B, y_B, 'model_B') x_A_recon = model.decode(y_A, z_B, 'model_A') xs_A.append(x_A_recon) zs_B.append(z_B) x_A = np.concatenate(xs_A, axis=0) z_A = np.concatenate(zs_A, axis=0) x_B = np.concatenate(xs_B, axis=0) z_B = np.concatenate(zs_B, axis=0) np.save(os.path.join(hps.logdir, 'z_A'), z_A) np.save(os.path.join(hps.logdir, 'z_B'), z_B) from utils import npy2img npy2img(os.path.join(hps.logdir, 'B2A'), x_A) npy2img(os.path.join(hps.logdir, 'A2B'), x_B) return x_A, z_A, x_B, z_B
def infer(sess, model, hps, iterator): # Example of using model in inference mode. Load saved model using hps.restore_path # Can provide x, y from files instead of dataset iterator # If model is uncondtional, always pass y = np.zeros([bs], dtype=np.int32) print('in infer') if hps.direct_iterator: iterator = iterator.get_next() # if hps.use_samples: # iterator = tf.data.Dataset.from_tensor_slices(np.random.normal(size=(500, 32 * 32 * 3))).batch(hps.n_batch_test) # iterator = iterator.prefetch(10) # iterator = iterator.make_one_shot_iterator() xs = [] zs = [] losses = [] for it in range(hps.full_test_its): # for it in range(10): if hps.direct_iterator: # replace with x, y, attr if you're getting CelebA attributes, also modify get_data x, y = sess.run(iterator) else: x, y = iterator() if hps.use_samples: # z = iterator.get_next() # z = tf.Print(z, [tf.shape(z), tf.reduce_mean(z)]) #, tf.math.reduce_std(z)]) # y = tf.zeros([hps.n_batch_test], dtype=np.int32) z = np.random.normal(size=(hps.n_batch_test, 32 * 32 * 3)) # print(z.mean(), z.std()) else: z = model.encode(x, y) print(z.shape) x = model.decode(y, z) loss = model.calculate_likelihood(x, y) xs.append(x) zs.append(z) losses.append(loss) x = np.concatenate(xs, axis=0) z = np.concatenate(zs, axis=0) l = np.concatenate(losses, axis=0) np.save(os.path.join(hps.logdir, 'x.npy'), x) np.save(os.path.join(hps.logdir, 'z.npy'), z) np.save(os.path.join(hps.logdir, 'l.npy'), l) # from scipy.stats import norm # rv = norm() # unifs = rv.cdf(z) # np.save(os.path.join(hps.logdir, 'unifs.npy'), unifs) return zs
def greedy_decode(model, src, src_mask, src_lengths, max_len=100, sos_index=1, eos_index=None): """Greedily decode a sentence.""" with torch.no_grad(): encoder_hidden, encoder_final = model.encode(src, src_mask, src_lengths) prev_y = torch.ones(1, 1).fill_(sos_index).type_as(src) trg_mask = torch.ones_like(prev_y) output = [] attention_scores = [] hidden = None for i in range(max_len): with torch.no_grad(): out, hidden, pre_output = model.decode(encoder_hidden, encoder_final, src_mask, prev_y, trg_mask, hidden) # we predict from the pre-output layer, which is # a combination of Decoder state, prev emb, and context prob = model.generator(pre_output[:, -1]) _, next_word = torch.max(prob, dim=1) next_word = next_word.data.item() output.append(next_word) prev_y = torch.ones(1, 1).type_as(src).fill_(next_word) attention_scores.append(model.decoder.attention.alphas.cpu().numpy()) output = np.array(output) # cut off everything starting from </s> # (only when eos_index provided) if eos_index is not None: first_eos = np.where(output == eos_index)[0] if len(first_eos) > 0: output = output[:first_eos[0]] return output, np.concatenate(attention_scores, axis=1)
def analyze(z, use_dim=[], seed=25): ''' z = np.array[2, dim], mu of two sentences''' ''' use_dim = list of int describing which dimension should be used ''' # select random path from z1 to z2 np.random.seed(seed) if use_dim == []: rdm_path = np.arange(len(z[0])) else: rdm_path = use_dim np.random.shuffle(rdm_path) # walk the path and print at every step path = np.copy(z[0]) for idx, dim in enumerate(rdm_path): path[dim] = z[1][dim] output = decode(sess, vae, [z[0], path, z[1]]).tolist() _ = [vocab.decode_ids(output[idx]) for idx in range(3)] print(idx, dim, _[1])
def _decode_and_evaluate(name, model, sess, trans_file, ref_file, subword_option, beam_width, tgt_eos, num_translations_per_input=1, decode=True): """Decode a test set and compute a score according to the evaluation task.""" # Decode if decode: utils.print_out(" decoding to output %s." % trans_file) start_time = time.time() num_sentences = 0 with codecs.getwriter("utf-8")(tf.gfile.GFile(trans_file, mode="wb")) as trans_f: trans_f.write("") # Write empty string to ensure file is created. num_translations_per_input = max(min(num_translations_per_input, beam_width), 1) while True: try: outputs, _ = model.decode(sess) if beam_width == 0: outputs = np.expand_dims(outputs, 0) batch_size = outputs.shape[1] num_sentences += batch_size for sent_id in range(batch_size): for beam_id in range(num_translations_per_input): translation = _get_translation( outputs[beam_id], sent_id, tgt_eos=tgt_eos, subword_option=subword_option) trans_f.write((translation + b"\n").decode("utf-8")) except tf.errors.OutOfRangeError: break return
torch.load( os.path.join(save_dir, 'autoEncoder_preTrained300.model'))) print(model) with torch.no_grad(): model.eval() test_data = [] test_data = src for i in range(0, len(src)): input_lines_src, output_lines_src, lens_src, mask_src = get_batch( src, word2idx, i, 1, max_len) print("Total:", len(src), " Current:", i, "Tracker On") if i > 911: print(input_lines_src) decoder_logit, hid_state, trg = model(input_lines_src) prob_2d, word_probs = decode(model, decoder_logit, vocab_size) #word_probs = word_probs.data.cpu().numpy().argmax(axis=-1) output_lines_src = output_lines_src.data.cpu().numpy() print("GPU memory consumption" + str(i) + " " + str(torch.cuda.memory_allocated())) hidden_embed.append(hid_state.data.cpu().numpy()) print("Hidden embeddings list size:", sys.getsizeof(hidden_embed)) #encoder_op.append(decoder_logit[0].data.cpu().numpy()) doc_embedding.append(trg[0].data.cpu().numpy()) print("Doc embedding list size:", sys.getsizeof(doc_embedding)) #for i in encoder_op: # array = i/np.linalg.norm(encoder_op) # docVector.append(array) #print(doc_embedding)
def main(): #load configuration conf, _ = get_config() pp.pprint(conf) if conf.is_gray : n_channel=1 else: n_channel=3 n_grid_row = int(np.sqrt(conf.n_batch)) z = tf.random_uniform((conf.n_batch, conf.n_z), minval=-1.0, maxval=1.0) # execute generator g_net,_ = generate(z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=False, reuse=False) # execute discriminator e_net,_, _ = encode(g_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, is_train=False, reuse=False) d_net,_ = decode(e_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel,is_train=False, reuse=False) g_img=tf.clip_by_value((g_net + 1)*127.5, 0, 255) d_img=tf.clip_by_value((d_net + 1)*127.5, 0, 255) # start session sess = tf.InteractiveSession() init = tf.global_variables_initializer() sess.run(init) # init directories checkpoint_dir = os.path.join(conf.log_dir,conf.curr_time) if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) #saver = tf.train.import_meta_graph(npz_path+'began2_model.ckpt.meta') #saver.restore(sess, tf.train.latest_checkpoint(npz_path)) saver = tf.train.Saver() saver.restore(sess, os.path.join(conf.load_dir, conf.ckpt_nm)) #load real image data_files = glob(os.path.join(conf.data_dir,conf.dataset, "*")) shuffle(data_files) x_fix = data_files[0:conf.n_batch] x_fix=[get_image(f, conf.n_img_pix, is_crop=conf.is_crop, resize_w=conf.n_img_out_pix, is_grayscale = conf.is_gray) for f in x_fix] x_fix = np.array(x_fix).astype(np.float32) if(conf.is_gray == 1): s,h,w = x_fix.shape x_fix = x_fix.reshape(s,h, w,n_channel ) n_loop = 1 def getRealAR(): # run ae x_im =sess.run(d_img,feed_dict={g_net:x_fix}) save_images(x_im, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, 'anal_AE_X.png')) def getRandomG(): f_g = open(checkpoint_dir+ '/g_img.csv', 'a') # generate images from generator and ae for i in range(5): z_test =np.random.uniform(low=-1, high=1, size=(conf.n_batch, 64)).astype(np.float32) g_im =sess.run(g_img,feed_dict={z:z_test}) save_images(g_im, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, str(i)+'_anal_G.png')) # g_im = g_im/127.5 - 1. # ae_g_im =sess.run(d_img,feed_dict={g_net:g_im}) # save_images(ae_g_im, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, str(i)+'_anal_AE_G.png')) for j in range(g_im.shape[0]): f_g.write(str(g_im[j].tolist()).replace("[", "").replace("]", "")+ '\n') f_g.close() def getFixedG(f_in): l_z = list() with open(f_in,'r') as file: for line in file: l_z.append(np.fromstring(line, dtype=float, sep=',')) file.close() n_loop = int(len(l_z)/64) l_z = np.asarray(l_z) for i in range(n_loop): fr = 64*i to = 64*(i+1) z_test =l_z[fr:to] g_im =sess.run(g_img,feed_dict={z:z_test}) save_images(g_im, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, '_anal_fix_G.png')) #g_im = g_im/127.5 - 1. #ae_g_im =sess.run(d_img,feed_dict={g_net:g_im}) #save_images(ae_g_im, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, str(i)+'_anal_AE_G.png')) def getRandomAE(): # generate images from discriminator and ae for i in range(n_loop): z_test =np.random.uniform(low=-1, high=1, size=(conf.n_batch, conf.n_img_out_pix, conf.n_img_out_pix,n_channel)).astype(np.float32) d_im =sess.run(d_img,feed_dict={g_net:z_test}) save_images(d_im, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, str(i)+'_anal_D.png')) def saveFeatures(): # get latent value from real images (10*n_batch) for i in range(n_loop): shuffle(data_files) f_test = data_files[0:conf.n_batch] x_test=[get_image(f, conf.n_img_pix, is_crop=conf.is_crop, resize_w=conf.n_img_out_pix, is_grayscale = conf.is_gray) for f in f_test] x_test = np.array(x_test).astype(np.float32) if(conf.is_gray == 1): s,h,w = x_test.shape x_test = x_test.reshape(s,h, w,n_channel ) latent =sess.run(e_net,feed_dict={g_net:x_test}) f_latent = open(checkpoint_dir+ '/latent.csv', 'a') for k in range(latent.shape[0]): f_latent.write(str(latent[k].tolist()).replace("[", "").replace("]", "")+ '\n') f_latent.close() def getFeatures(): f_path=checkpoint_dir+'/latent.csv'#'C:/samples/img_download/wheels/wheeldesign/output/began2_anal/17-11-28-14-52/latent.csv' data = pd.read_csv(f_path) n_latent = data.shape[1] mean = [None]*n_latent std = [None]*n_latent for i in range(n_latent): #i+=1 latent = np.array(data.iloc[:, i:i+1]) mean[i] = np.mean(latent) std[i] = np.std(latent) plt.show() return mean, std def generateFeature(mean, std): z_size = len(mean) feature = [None]*z_size for i in range(z_size): feature[i] = np.random.normal(loc=mean[i], scale=std[i], size=z_size*n_loop) return feature def generateImage(feature): feature = np.array(feature) idx=0 for i in range(n_loop): f_net = feature[:,idx:idx+64] f_img =sess.run(d_img,feed_dict={e_net:f_net}) save_images(f_img, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, str(i)+'_anal_G_df.png')) idx+=64 def getDiscMeanFeature(mean): mean = np.array(mean) mean = mean-2 m_net = [None]*64 for i in range(64): m_net[i] = mean +1/63 *i d_mnfd =sess.run(d_img,feed_dict={e_net:m_net}) save_images(d_mnfd, [n_grid_row,n_grid_row],os.path.join(checkpoint_dir, 'anal_D_Mean_df.png')) #getFixedG(conf.log_dir+'anal/g_df/z.csv') #getRealAR() getRandomG() #getRandomAE() #saveFeatures() #z_mean, z_std = getFeatures() #z_feature = generateFeature(z_mean, z_std) #shuffle(z_feature) #generateImage(z_feature) #getDiscMeanFeature(z_mean) sess.close()
def main(conf): logger = logging.getLogger("desc") logger.setLevel(logging.INFO) fileHandler = logging.FileHandler(os.path.join(base_dir, 'log.txt')) logger.addHandler(fileHandler) #streamHandler = logging.StreamHandler() #logger.addHandler(streamHandler) if conf.is_gray: n_channel = 1 else: n_channel = 3 # init directories checkpoint_dir = os.path.join(base_dir, conf.curr_time) if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) ##========================= DEFINE MODEL ===========================## #z = tf.random_uniform(conf.n_batch, conf.n_z), minval=-1.0, maxval=1.0) z = readz(os.path.join(base_dir, 'z.csv'), conf.n_batch) x_net = tf.placeholder( tf.float32, [conf.n_batch, conf.n_img_pix, conf.n_img_pix, n_channel], name='real_images') k_t = tf.Variable(0., trainable=False, name='k_t') # execute generator g_net, g_vars, g_conv = generate(z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=True, reuse=False) # execute discriminator e_g_net, enc_vars, e_g_conv = encode(g_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, is_train=True, reuse=False) d_g_net, dec_vars, d_g_conv = decode(e_g_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=True, reuse=False) e_x_net, _, e_x_conv = encode(x_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, is_train=True, reuse=True) d_x_net, _, d_x_conv = decode(e_x_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=True, reuse=True) g_img = tf.clip_by_value((g_net + 1) * 127.5, 0, 255) #x_img=tf.clip_by_value((x_net + 1)*127.5, 0, 255) d_g_img = tf.clip_by_value((d_g_net + 1) * 127.5, 0, 255) d_x_img = tf.clip_by_value((d_x_net + 1) * 127.5, 0, 255) d_vars = enc_vars + dec_vars d_loss_g = tf.reduce_mean(tf.abs(d_g_net - g_net)) d_loss_x = tf.reduce_mean(tf.abs(d_x_net - x_net)) d_loss = d_loss_x - k_t * d_loss_g g_loss = tf.reduce_mean(tf.abs(d_g_net - g_net)) d_loss_prev = d_loss g_loss_prev = g_loss k_t_prev = k_t g_optim = tf.train.AdamOptimizer(conf.g_lr).minimize(g_loss, var_list=g_vars) d_optim = tf.train.AdamOptimizer(conf.d_lr).minimize(d_loss, var_list=d_vars) balance = conf.gamma * d_loss_x - g_loss measure = d_loss_x + tf.abs(balance) with tf.control_dependencies([d_optim, g_optim]): k_update = tf.assign( k_t, tf.clip_by_value(k_t + conf.lambda_k * balance, 0, 1)) # start session sess = tf.InteractiveSession() init = tf.global_variables_initializer() sess.run(init) loadWeight(sess, conf) x_fix = readx(os.path.join(base_dir, 'x.csv'), conf.n_batch) x_fix = x_fix.reshape(conf.n_batch, conf.n_conv_hidden, conf.n_img_out_pix, n_channel) n_loop = 2 for itr in range(n_loop): fetch_dict = { "kupdate": k_update, "m": measure, "b": balance, 'gnet': g_net, 'dgnet': d_g_net, 'dxnet': d_x_net, 'xnet': x_net, 'gconv': g_conv, 'egconv': e_g_conv, 'dgconv': d_g_conv, 'exconv': e_x_conv, 'dxconv': d_x_conv, "dlossx": d_loss_x, "gloss": g_loss, "dloss": d_loss, "kt": k_t, 'gimg': g_img, 'dgimg': d_g_img, 'dximg': d_x_img, } result = sess.run(fetch_dict, feed_dict={x_net: x_fix}) logger.info('measure: ' + str(result['m'])) logger.info('balance: ' + str(result['b'])) logger.info('gloss: ' + str(result['gloss'])) logger.info('dloss: ' + str(result['dloss'])) logger.info('dlossx: ' + str(result['dlossx'])) logger.info('k_t: ' + str(result['kt'])) if itr == 0: gconv = result['gconv'] for i in range(len(gconv)): conv = np.clip((gconv[i] + 1) * 127.5, 0, 255) s, h, w, c = conv.shape for j in range(c): c_img = conv[:, :, :, j:j + 1] save_image( c_img, os.path.join( checkpoint_dir, 'gen_' + str(i) + '_' + str(j) + '_' + str(h) + '_conv.png')) dgconv = result['dgconv'] for i in range(len(dgconv)): conv = np.clip((dgconv[i] + 1) * 127.5, 0, 255) s, h, w, c = conv.shape for j in range(c): c_img = conv[:, :, :, j:j + 1] save_image( c_img, os.path.join( checkpoint_dir, 'dec_g_' + str(i) + '_' + str(j) + '_' + str(h) + '_conv.png')) dxconv = result['dxconv'] for i in range(len(dxconv)): conv = np.clip((dxconv[i] + 1) * 127.5, 0, 255) s, h, w, c = conv.shape for j in range(c): c_img = conv[:, :, :, j:j + 1] save_image( c_img, os.path.join( checkpoint_dir, 'dec_x_' + str(i) + '_' + str(j) + '_' + str(h) + '_conv.png')) exconv = result['exconv'] for i in range(len(exconv)): conv = np.clip((exconv[i] + 1) * 127.5, 0, 255) s, h, w, c = conv.shape for j in range(c): c_img = conv[:, :, :, j:j + 1] save_image( c_img, os.path.join( checkpoint_dir, 'enc_x_' + str(i) + '_' + str(j) + '_' + str(h) + '_conv.png')) egconv = result['egconv'] for i in range(len(egconv)): conv = np.clip((egconv[i] + 1) * 127.5, 0, 255) s, h, w, c = conv.shape for j in range(c): c_img = conv[:, :, :, j:j + 1] save_image( c_img, os.path.join( checkpoint_dir, 'enc_g_' + str(i) + '_' + str(j) + '_' + str(h) + '_conv.png')) gnet = result['gnet'] dgnet = result['dgnet'] dxnet = result['dxnet'] xnet = result['xnet'] for i in range(conf.n_batch): logger.info( 'g_net: ' + str(gnet[i].tolist()).replace("[", "").replace("]", "")) logger.info( 'd_g_net: ' + str(dgnet[i].tolist()).replace("[", "").replace("]", "")) logger.info( 'x_net: ' + str(xnet[i].tolist()).replace("[", "").replace("]", "")) logger.info( 'd_x_net: ' + str(dxnet[i].tolist()).replace("[", "").replace("]", "")) gimg = result['gimg'] dgimg = result['dgimg'] dximg = result['dximg'] save_image(gimg, os.path.join(checkpoint_dir, str(itr) + '_final_g_img.png')) save_image( dgimg, os.path.join(checkpoint_dir, str(itr) + '_final_d_g_img.png')) save_image( dximg, os.path.join(checkpoint_dir, str(itr) + '_final_d_x_img.png')) sess.close()
def main(): #load configuration conf, _ = get_config() pp.pprint(conf) if conf.is_gray : n_channel=1 else: n_channel=3 n_grid_row = int(np.sqrt(conf.n_batch)) ##========================= DEFINE MODEL ===========================## z = tf.random_uniform( (conf.n_batch, conf.n_z), minval=-1.0, maxval=1.0) x_net = tf.placeholder(tf.float32, [conf.n_batch, conf.n_img_pix, conf.n_img_pix, n_channel], name='real_images') k_t = tf.Variable(0., trainable=False, name='k_t') # define generator g_net, g_vars = generate(z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=True, reuse=False) # define discriminator e_g_net, enc_vars,_ = encode(g_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, is_train=True, reuse=False) d_g_net, dec_vars = decode(e_g_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=True, reuse=False) e_x_net, _,_ = encode(x_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, is_train=True, reuse=True) d_x_net, _ = decode(e_x_net, conf.n_z, conf.n_img_out_pix, conf.n_conv_hidden, n_channel, is_train=True, reuse=True) # image de-normalization g_img=tf.clip_by_value((g_net + 1)*127.5, 0, 255) d_g_img=tf.clip_by_value((d_g_net + 1)*127.5, 0, 255) d_x_img=tf.clip_by_value((d_x_net + 1)*127.5, 0, 255) d_vars = enc_vars + dec_vars # define discriminator and generator losses d_loss_g = tf.reduce_mean(tf.abs(d_g_net - g_net)) d_loss_x = tf.reduce_mean(tf.abs(d_x_net - x_net)) d_loss= d_loss_x - k_t * d_loss_g g_loss = tf.reduce_mean(tf.abs(d_g_net - g_net)) # define optimizer d_optim = tf.train.AdamOptimizer(conf.d_lr).minimize(d_loss, var_list=d_vars) g_optim = tf.train.AdamOptimizer(conf.g_lr).minimize(g_loss, var_list=g_vars) balance = conf.gamma * d_loss_x - g_loss measure = d_loss_x + tf.abs(balance) with tf.control_dependencies([d_optim, g_optim]): k_update = tf.assign(k_t, tf.clip_by_value(k_t + conf.lambda_k * balance, 0, 1)) # define summary for tensorboard summary_op = tf.summary.merge([ tf.summary.image("G", g_img), tf.summary.image("AE_G", d_g_img), tf.summary.image("AE_x", d_x_img), tf.summary.scalar("loss/dloss", d_loss), tf.summary.scalar("loss/d_loss_real", d_loss_x), tf.summary.scalar("loss/d_loss_fake", d_loss_g), tf.summary.scalar("loss/gloss", g_loss), tf.summary.scalar("misc/m", measure), tf.summary.scalar("misc/kt", k_t), tf.summary.scalar("misc/balance", balance), ]) # start session sess = tf.InteractiveSession()#config=tf.ConfigProto(log_device_placement=True)) init = tf.global_variables_initializer() sess.run(init) # init directories checkpoint_dir = os.path.join(conf.log_dir,conf.curr_time) if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) # init summary writer for tensorboard summary_writer = tf.summary.FileWriter(checkpoint_dir,sess.graph) saver = tf.train.Saver() if(conf.is_reload): saver.restore(sess, os.path.join(conf.load_dir, conf.ckpt_nm)) # load real image info and shuffle them data_files = glob(os.path.join(conf.data_dir,conf.dataset, "*")) shuffle(data_files) # save real fixed image x_fix = data_files[0:conf.n_batch] x_fix=[get_image(f, conf.n_img_pix, is_crop=conf.is_crop, resize_w=conf.n_img_out_pix, is_grayscale = conf.is_gray) for f in x_fix] x_fix = np.array(x_fix).astype(np.float32) x_fix = x_fix.reshape(x_fix.shape[0],x_fix.shape[1], x_fix.shape[2],n_channel ) save_images(x_fix, [n_grid_row,n_grid_row],'{}/x_fix.png'.format(checkpoint_dir)) cost_file = open(checkpoint_dir+ "/cost.txt", 'w', conf.n_buffer) n_step=0 for epoch in range(conf.n_epoch): ## shuffle data shuffle(data_files) ## load image data n_iters = int(len(data_files)/conf.n_batch) for idx in range(0, n_iters): # make image batch f_batch = data_files[idx*conf.n_batch:(idx+1)*conf.n_batch] data_batch = [get_image(f, conf.n_img_pix, is_crop=conf.is_crop, resize_w=conf.n_img_out_pix, is_grayscale = conf.is_gray) for f in f_batch] img_batch = np.array(data_batch).astype(np.float32) if conf.is_gray : s,h,w = img_batch.shape img_batch = img_batch.reshape(s, h, w, n_channel ) fetch_dict = { "kupdate": k_update, "m": measure, } if n_step % conf.n_save_log_step == 0: fetch_dict.update({ "summary": summary_op, "gloss": g_loss, "dloss": d_loss, "kt": k_t, }) start_time = time.time() # run the session! result = sess.run(fetch_dict, feed_dict={x_net:img_batch}) # get the result m = result['m'] if n_step % conf.n_save_log_step == 0: summary_writer.add_summary(result['summary'], n_step) summary_writer.flush() # write cost to a file gloss = result['gloss'] dloss = result['dloss'] kt = result['kt'] cost_file.write("Epoch: ["+str(epoch)+"/"+str(conf.n_epoch)+"] ["+str(idx)+"/"+str(n_iters)+"] time: "+str(time.time() - start_time)+", d_loss: "+str(dloss)+", g_loss:"+ str(gloss)+" measure: "+str(m)+", k_t: "+ str(kt)+ "\n") # save generated image file if n_step % conf.n_save_img_step == 0: g_sample, g_ae, x_ae = sess.run([g_img, d_g_img,d_x_img] ,feed_dict={x_net: x_fix}) save_image(g_sample,os.path.join(checkpoint_dir, '{}_G.png'.format(n_step))) save_image(g_ae, os.path.join(checkpoint_dir, '{}_AE_G.png'.format(n_step))) save_image(x_ae, os.path.join(checkpoint_dir, '{}_AE_X.png'.format(n_step))) n_step+=1 # save checkpoint saver.save(sess, os.path.join(checkpoint_dir,str(epoch)+"_"+str(n_step)+"_began2_model.ckpt") ) # save final checkpoint saver.save(sess, os.path.join(checkpoint_dir,"final_began2_model.ckpt")) cost_file.close() sess.close()
# Prepare batch batch_indices = indices[batch*args.batch_size:(batch+1)*args.batch_size] batch_rows = [valid[i] for i in batch_indices] if args.bs_predictor: input_seq, input_lens, bs = model.prep_batch(batch_rows) predicted_bs = model.predict(input_seq, input_lens) bs_predictions.append((predicted_bs.data.cpu().numpy(), bs.data.cpu().numpy())) elif args.dm_predictor: bs, da, db = model.prep_batch(batch_rows) predicted_da = model.predict(bs, db) bs_predictions.append((predicted_da.data.cpu().numpy(), da.data.cpu().numpy())) elif args.nlg_predictor: target_seq, target_lens, db, da, bs = model.prep_batch(batch_rows) # Get predicted sentences for batch predicted_sentences = model.decode(50, db, da, bs) # Add predicted to list for i,sent in enumerate(predicted_sentences): all_predicted[batch_rows[i][-2]].append(sent) else: input_seq, input_lens, target_seq, target_lens, db, bs, da = model.prep_batch(batch_rows) # Get predicted sentences for batch predicted_sentences = model.decode(input_seq, input_lens, 50, db, bs, da) # Add predicted to list for i,sent in enumerate(predicted_sentences): all_predicted[batch_rows[i][-2]].append(sent) json.dump(all_predicted, open('temp.json', 'w+'))
args=args, test=True).cuda() # TEST EVALUATION best_epoch = args.epoch model.load("{0}/model_{1}.bin".format(args.save_path, best_epoch)) model.transformer.eval() # Iterate over batches num_batches = math.ceil(len(valid_freq) / args.batch_size) cum_loss = 0 cum_words = 0 predicted_sentences = [] indices = list(range(len(valid_freq))) for batch in tqdm(range(num_batches)): # Prepare batch batch_indices = indices[batch * args.batch_size:(batch + 1) * args.batch_size] batch_rows = [valid_freq[i] for i in batch_indices] # Encode batch. If facts are being used, they'll be prepended to the input input_seq, input_lens, target_seq, target_lens = model.prep_batch( batch_rows) # Decode batch predicted_sentences += model.decode(input_seq, input_lens) # Save predictions open("{0}/valid_freq_out.tgt".format(args.save_path), "w+").writelines([l + "\n" for l in predicted_sentences])
import numpy import random from keras.models import load_model from model import decode, read_folder, read_png from show import plt model = load_model("model.h5") characters = open("model.characters").read() test_folder = "check/" test_file_list, _characters = read_folder(test_folder) test_file = random.choice(test_file_list) x_test, y_test, n_class_test = read_png([test_file], characters) y_pred = model.predict(x_test) title = 'real: %s\npred:%s' % (decode(y_test, characters), decode(y_pred, characters)) print title all_count = 0 right_count = 0 for test_file in test_file_list: x_test, y_test, n_class_test = read_png([test_file], characters) y_pred = model.predict(x_test) y_p = decode(y_pred, characters) y_t = decode(y_test, characters) print "real", y_t, "pred", y_p all_count += 1 if y_p == y_t: right_count += 1 print "all", all_count, "right", right_count, "percent", 1.0 * right_count / all_count """
def auto(z, steps=256): for s in sp.decode(vocab, decode(sess, vae, z, steps)): print(s)
from keras.losses import mse, binary_crossentropy from keras.utils import to_categorical import numpy as np from keras.models import load_model from keras import optimizers from keras.callbacks import ModelCheckpoint from tgru_k2_gpu import TerminalGRU from keras.models import Sequential from keras.layers import Dense, Conv1D, Dropout, MaxPooling1D, Flatten, Dense, BatchNormalization,RepeatVector,GRU,Input,Lambda from data_loader import load_data from model import encode, decode # Tải dữ liệu X_train, X_test, X_val = load_data() encode = encode() decode = decode() def VAE(): inputs = Input(shape=(120,35)) z_mean, z_log_var, z = encode(inputs) x = decode([inputs, z]) VAE = Model(inputs, x, name = "VAE") return VAE, z_mean, z_log_var vae, z_mean, z_log_var = VAE() vae.summary() ''' Test thử 3 hàm loss''' def vae_loss_binary(x, x_reconstruction): xent_loss = K.sum(binary_crossentropy(x, x_reconstruction) , axis = -1) kl_loss = - 0.5 * K.sum(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(xent_loss + kl_loss)
model.cuda() optimizer = optim.Adam(model.parameters(), lr=LR) for epoch in range(1, args.epochs + 1): utils.train(model, train_loader, epoch, optimizer, is_conditional=True) utils.eval(model, val_loader, epoch) if epoch % 10 == 0: sample = Variable(torch.randn(SAMPLES, HIDDEN2)) if USE_CUDA: sample = sample.cuda() c = torch.zeros(SAMPLES).long().random_(0, 10).float() sample = model.decode(sample, Variable(c)).cpu() # pdb.set_trace() save_image(sample.data.view(SAMPLES, 1, img_width, img_height), 'results/sample_meh_' + str(epoch) + '.png') elif args.model == 'VAE': model = model.VAE(img_width * img_height, HIDDEN1, HIDDEN2) if USE_CUDA: model.cuda() optimizer = optim.Adam(model.parameters(), lr=LR) for epoch in range(1, args.epochs + 1): utils.train(model, train_loader, epoch, optimizer) #utils.eval(model, val_loader, epoch)
from util_io import load_txt, save_txt from util_np import np, partition, vpack from util_np import vpack import pandas as pd import util_sp as sp # load data df = pd.read_csv(path_csv) emb = np.load(path_emb) emb_sp = np.load(path_emb_sp) # load sentencepiece model vocab = sp.load_spm(path_vocab) # Load the model model = vAe('infer') # Restore the session sess = tf.InteractiveSession() tf.train.Saver().restore(sess, path_ckpt) ########################### # generate from centroids # ########################### for col in "euc euc_sp cos cos_sp".split(): cluster = df["cls_{}".format(col)].values centroids = np.stack( [np.mean(emb[cluster == c], axis=0) for c in range(cluster.max() + 1)]) y = decode(sess, model, centroids, steps=512) save_txt("../trial/centroids_{}".format(col), sp.decode(vocab, y))
def VAE(): inputs = Input(shape=(120,35)) z_mean, z_log_var, z = encode(inputs) x = decode([inputs, z]) VAE = Model(inputs, x, name = "VAE") return VAE, z_mean, z_log_var