def eval_center(model, action_data, action_name, n=200, n_comp=1000, cut=-1): LABEL_GEN_CENTERS = '../new_out/L_RNN-t30-l400/generate_from_labels/eval_generation_from_label-gen_poses-L_GRU.npy' if cut == -1: cut = model.hierarchies[-1] encoded = metrics.__get_latent_reps(model.encoder, action_data, model.MODEL_CODE, n=cut) center_a = np.array([np.mean(encoded, axis=0)]) center_a = metrics.__get_decoded_reps(model.decoder, center_a, model.MODEL_CODE)[0] center_raw = np.mean(action_data, axis=0) pseudo_center_idxs = np.random.choice(action_data.shape[0], n, replace=False) comp_idxs = np.random.choice(action_data.shape[0], min(n_comp, action_data.shape[0]), replace=False) scores = np.array([[1000.0]*(n+3)]*n_comp) print scores.shape if model.MODEL_CODE == metrics.L_LSTM: center_a = center_a[:,:-model.label_dim] center_raw = center_raw[:,:-model.label_dim] action_data = action_data[:,:,:-model.label_dim] center_from_label = np.load(LABEL_GEN_CENTERS)[model.labels[action_name]] for l, i in enumerate(tqdm(comp_idxs)): for k, j in enumerate(pseudo_center_idxs): scores[l][k] = metrics.__pose_seq_error(action_data[i], action_data[j]) scores[l][-3] = metrics.__pose_seq_error(action_data[i], center_from_label) scores[l][-2] = metrics.__pose_seq_error(action_data[i], center_a) scores[l][-1] = metrics.__pose_seq_error(action_data[i], center_raw) __save_score(scores, model, 'eval_center') print 'animating...' import fk_animate fk_animate.animate_motion(center_raw, 'center raw', '../new_out/center_raw_animate-%s-t%d-l%d'%(model.NAME, model.timesteps, model.latent_dim)) fk_animate.animate_motion(center_a, 'center latent', '../new_out/center_latent_animate-%s-t%d-l%d'%(model.NAME, model.timesteps, model.latent_dim))
def animate_results(from_path, predict_path, predict_name, baseline='1', baseline_name='Residual sup. (MA)', ground_truth='2'): for basename in iter_actions(from_path): pds = np.load(predict_path + basename + '.npy') for i in range(_N): print basename, i gt = np.load(from_path + LOAD_PATH + basename + '_0-%d.npy' % i) gtp = np.load(from_path + LOAD_PATH + basename + '_%s-%d.npy' % (ground_truth, i)) bpd = np.load(from_path + LOAD_PATH + basename + '_%s-%d.npy' % (baseline, i)) pd_score = metrics.__pose_seq_error(pds[i], gtp[:pds.shape[1]]) bl_score = metrics.__pose_seq_error(bpd[:pds.shape[1]], gtp[:pds.shape[1]]) score = bl_score / pd_score fk_animate.animate_compare( gt, gtp[:pds.shape[1]], pds[i], predict_name, bpd[:pds.shape[1]], baseline_name, predict_path + '%6.2f-p%6.2f-b%6.2f-images-%s-%d-%s' % (score, pd_score, bl_score, basename, i, predict_name.replace('.', '').replace('/', '-').replace( ' ', '-')))
def plot_results_npy(from_path, npy_files_dirs, method_names): for basename in iter_actions(from_path): for i in range(len(method_names)): pd = np.load(npy_files_dirs[i] + basename + '.npy') score = [None] * _N score_ = [None] * _N t = pd.shape[1] for j in range(_N): gt = np.load(from_path + LOAD_PATH + basename + '_2-%d.npy' % j)[:t] score[j] = metrics.__pose_seq_error(pd[j], gt, cumulative=True) if i == 0: pd_b = np.load(from_path + LOAD_PATH + basename + '_1-%d.npy' % j)[:t] score_[j] = metrics.__pose_seq_error(pd_b, gt, cumulative=True) if i == 0: plt.plot(range(1, t + 1), np.mean(score_, axis=0), linestyle=':', linewidth=3, label='Base') #Residual sup. (MA)') if i > len(method_names) / 2 - 1: plt.plot(range(1, t + 1), np.mean(score, axis=0), label=method_names[i], linestyle='--') else: plt.plot(range(1, t + 1), np.mean(score, axis=0), label=method_names[i]) plt.legend() plt.xlabel('time-steps') plt.ylabel('error') plt.title(basename) plt.savefig('../../new_out/L-RNN-%s.png' % (basename)) plt.close()
def compare_embedding(model, data_iterator): import image embedding = metrics.get_embedding(model, data_iterator, subspace=model.hierarchies[-2:]) mean_diff, diff = metrics.get_embedding_diffs(embedding[1], embedding[0]) std_diff = np.std(diff, axis=0) cut = model.hierarchies[-2] + 1 pred_n = model.timesteps - cut for basename in iter_actions(): print basename n = 8 pose_ref = np.zeros((n, model.timesteps, model.input_dim)) pose_pred_bl = np.zeros((n, model.timesteps - cut, model.input_dim)) pose_gt = np.zeros((n, model.timesteps - cut, model.input_dim)) for i in tqdm(range(n)): gt = np.load(LOAD_PATH + basename + '_0-%d.npy' % i) pd = np.load(LOAD_PATH + basename + '_1-%d.npy' % i) gtp = np.load(LOAD_PATH + basename + '_2-%d.npy' % i) pose_ref[i, :cut] = gt[-cut:] pose_pred_bl[i] = pd[:pred_n] pose_gt[i] = gtp[:pred_n] new_enc = model.encoder.predict(pose_ref)[:, cut - 1] + mean_diff pose_pred = model.decoder.predict(new_enc)[:, :pred_n] error_bl = [ metrics.__pose_seq_error(pose_gt[i], pose_pred_bl[i]) for i in range(n) ] error = [ metrics.__pose_seq_error(pose_gt[i], pose_pred[i]) for i in range(n) ] print np.mean(error), np.mean(error_bl) image.plot_poses(pose_pred, title='rnn') image.plot_poses(pose_pred_bl, title='baseline') image.plot_poses(pose_gt, title='gt') np.save('../new_out/HRNN-%s.npy' % basename, pose_pred)
def eval_nearest_neighbor(validation_data, training_data, n_valid=250, n_random=1000, n_input=15): error_score = [1000] * n_valid error_x = [None] * n_valid idxs = np.random.choice(len(validation_data), n_valid, replace=False) for xs, _ in training_data: idx_comp = np.random.choice(xs.shape[0], min(n_random, xs.shape[0]), replace=False) for i, idx in enumerate(tqdm(idxs)): for x in xs[idx_comp]: score = metrics.__pose_seq_error( x[:n_input], validation_data[idx, :n_input]) if score < error_score[i]: error_score[i] = score error_x[i] = np.copy(x[n_input:]) error = [None] * n_valid error_ = [None] * n_valid for i, idx in enumerate(idxs): error[i] = metrics.__pose_seq_error(error_x[i], validation_data[idx, n_input:], cumulative=True) # fk_animate.animate_compare(gt[basename][i], gtp[basename][i], # error_x[basename][i], 'Nearest Neighbor (1/%d)'%(DATA_ITER_SIZE/RANDOM_N), # pd[basename][i], 'Residual sup. (MA)', from_path+LOAD_PATH+'images/') _err = np.mean(error, axis=0) plt.plot(range(1, _err.shape[0] + 1), _err) plt.xlabel('time-steps') plt.ylabel('error') plt.title('Nearest Neighbor (1/10)') plt.savefig('../new_out/nn-random-sampled-v%d-r%d.png' % (n_valid, n_random)) plt.close()
def transfer_motion(model, action_data, from_motion_name, to_motion_name, data_iterator, n=10, n_comp=1000, cut=-1): LABEL_GEN_Z = '../new_out/L_RNN-t30-l400/generate_from_labels/eval_generation_from_label-gen_z-L_GRU.npy' LABEL_GEN_CENTERS = '../new_out/L_RNN-t30-l400/generate_from_labels/eval_generation_from_label-gen_poses-L_GRU.npy' if cut == -1: cut = model.hierarchies[-1] action_data = action_data[np.random.choice(action_data.shape[0], n, replace=False)] z_actions = metrics.__get_latent_reps(model.encoder, action_data, model.MODEL_CODE, n=cut) z_labels = np.load(LABEL_GEN_Z)[[model.labels[from_motion_name], model.labels[to_motion_name]]] z_infered = z_actions - z_labels[0] + z_labels[1] action_from_z = metrics.__get_decoded_reps(model.decoder, z_infered, model.MODEL_CODE) # action_normalized = metrics.__get_decoded_reps(model.decoder, z_infered/np.linalg.norm(z_infered), model.MODEL_CODE) center_from_label = np.zeros((2, model.timesteps, model.input_dim)) center_from_label[:,:,:-model.label_dim] = np.load(LABEL_GEN_CENTERS)[[model.labels[from_motion_name], model.labels[to_motion_name]]] center_from_label[0,:,-model.label_dim+model.labels[from_motion_name]] = 1 center_from_label[1,:,-model.label_dim+model.labels[to_motion_name]] = 1 z_labels = metrics.__get_latent_reps(model.encoder, center_from_label, model.MODEL_CODE, n=cut) z_infered = z_actions - z_labels[0] + z_labels[1] action_from_pose = metrics.__get_decoded_reps(model.decoder, z_infered, model.MODEL_CODE) print 'animating...' import fk_animate save_path = '../new_out/transfer_motion-%s-to-%s-'%(from_motion_name, to_motion_name) for i in range(z_actions.shape[0]): fk_animate.animate_motion([action_data[i], action_from_z[i], action_from_pose[i]], [from_motion_name, to_motion_name, to_motion_name+'(+name)'], save_path+str(i)) # fk_animate.animate_motion([action_data[i], action_from_z[i], action_normalized[i]], [from_motion_name, to_motion_name, to_motion_name+'(norm)'], save_path+str(i)+'-') scores = [[1000.0]*len(model.labels)]*n count = 0 for xs,_ in data_iterator: x_idx = np.random.choice(xs.shape[0], min(n_comp, xs.shape[0]), replace=False) for x in tqdm(xs[x_idx]): for i, z in enumerate(action_from_z): s = metrics.__pose_seq_error(z[:,:-model.label_dim], x[:,:-model.label_dim]) label_idx = np.argmax(x[-model.label_dim:]) - model.input_dim + model.label_dim if scores[i][label_idx] > s: scores[i][label_idx] = s del xs print count count += 1 print scores np.save(save_path+'scores.npy', scores)
def eval_generation(model, action_data, data_iterator, n=20, n_comp=1000, cut=-1): if cut == -1: cut = model.hierarchies[-1] ind_rand = np.random.choice(action_data.shape[0], n, replace=False) n = n/2 encoded = metrics.__get_latent_reps(model.encoder, action_data[ind_rand], model.MODEL_CODE, n=cut) encoded = np.array([(encoded[i] + encoded[i+n])/2 for i in range(n)]) action_data = metrics.__get_decoded_reps(model.decoder, encoded, model.MODEL_CODE) scores = [[1000.0]*len(model.labels)]*n count = 0 for xs,_ in data_iterator: x_idx = np.random.choice(xs.shape[0], min(n_comp, xs.shape[0]), replace=False) for x in tqdm(xs[x_idx]): for i, z in enumerate(action_data): s = metrics.__pose_seq_error(z[:,:-model.label_dim], x[:,:-model.label_dim]) label_idx = np.argmax(x[-model.label_dim:]) - model.input_dim + model.label_dim if scores[i][label_idx] > s: scores[i][label_idx] = s del xs print count count += 1 __save_score(scores, model, 'eval_generation')
def plot_best_distance_function(model, data, data_iterator, nn, n=50): idx = np.random.choice(data.shape[0], n, replace=False) enc = metrics.__get_latent_reps(model.encoder, data[idx], model.MODEL_CODE, n=model.hierarchies) nn_pred_z = nn.model.predict(enc[:,-2]) N = 3 colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"] avg_error_raw = np.zeros(N) avg_error_lat = np.zeros(N) errors = np.zeros(n+2) dists = np.zeros(n+2) zs = np.zeros((N,model.latent_dim)) poses_plot = np.zeros((N+3, model.timesteps, model.input_dim-model.label_dim)) emb = metrics.get_label_embedding(model, data_iterator, subspaces=model.hierarchies) cut = model.hierarchies[-2]+1 # new_e = np.zeros((N,n,model.latent_dim)) for j in tqdm(range(n)): z_ref = enc[j,-2] z_true = enc[j,-1] p_enc_dec = metrics.__get_decoded_reps(model.decoder, np.array([z_ref, z_true, nn_pred_z[j]]), model.MODEL_CODE) poses_plot[:3] = p_enc_dec[:,:,:-model.label_dim] for i in range(N): dist_name = metrics.__dist_name__(i) ls = emb[:,-1] weights, w_i = metrics.__get_weights(ls, z_ref, mode=i) zs[i] = ls[w_i[0]] preds = metrics.__get_decoded_reps(model.decoder, ls[w_i[:n]], model.MODEL_CODE) poses_plot[3+i] = preds[0,:,:-model.label_dim] for k in range(n): errors[k] = metrics.__pose_seq_error(preds[k,:,:-model.label_dim],data[idx[j],:,:-model.label_dim]) dists[k] = metrics.__distance__(ls[w_i[k]], z_true, mode=i) errors[-2] = metrics.__pose_seq_error(p_enc_dec[0,:cut,:-model.label_dim],data[idx[j],:cut,:-model.label_dim]) dists[-2] = metrics.__distance__(z_ref, z_true, mode=i) errors[-1] = metrics.__pose_seq_error(p_enc_dec[-1,:,:-model.label_dim],data[idx[j],:,:-model.label_dim]) dists[-1] = metrics.__distance__(nn_pred_z[j], z_true, mode=i) plt.scatter(dists, errors, label=dist_name, s=30, c=colors[i]) if i == N-1: plt.scatter(dists[:1], errors[:1], c='black', alpha='0.3', s=100, label='closest') plt.scatter(dists[-1:], errors[-1:], c=colors[-1], alpha='0.3', s=100, label='FN') plt.scatter(dists[-2:-1], errors[-2:-1], c='red', alpha='0.3', s=100, label='dec-part') else: plt.scatter(dists[:1], errors[:1], c='black', alpha='0.3', s=100) plt.scatter(dists[-1:], errors[-1:], c=colors[-1], alpha='0.3', s=100) plt.scatter(dists[-2:-1], errors[-2:-1], c='red', alpha='0.3', s=100) avg_error_raw[i] += errors[0] error = metrics.__pose_seq_error(p_enc_dec[1,:,:-model.label_dim],data[idx[j],:,:-model.label_dim]) plt.scatter([0], [error], label='dec-comp', c=colors[3]) plt.legend() plt.xlabel('distance to comp. seq. rep.') plt.ylabel('error in raw space') plt.title('distance vs error in raw space (sample %d)'%(j)) plt.savefig('../new_out/__plot_best_distance_function_%d-1.png'%(j)) plt.close() for i in range(N): dist_name = metrics.__dist_name__(i) error = [metrics.__latent_error(z, z_true) for z in [zs[i], nn_pred_z[j], z_true]] dist = [metrics.__distance__(z, z_ref, mode=i) for z in [zs[i], nn_pred_z[j], z_true]] plt.scatter(dist, error, label=dist_name, s=30, c=colors[i]) if i == N-1: plt.scatter(dist[-1:], error[-1:], c='black', alpha='0.3', s=100, label='true') plt.scatter(dist[-2:-1], error[-2:-1], c=colors[-1], alpha='0.3', s=100, label='FN') else: plt.scatter(dist[-1:], error[-1:], c='black', alpha='0.3', s=100) plt.scatter(dist[-2:-1], error[-2:-1], c=colors[-1], alpha='0.3', s=100) avg_error_lat[i] += error[0] plt.legend() plt.xlabel('distance to part. seq. rep.') plt.ylabel('error in latent space') plt.title('distance vs error in latent space(sample %d)'%(j)) plt.savefig('../new_out/__plot_best_distance_function_%d-2.png'%(j)) plt.close() image.plot_poses([data[idx[j],:,:-model.label_dim]], poses_plot, title='part-comp-l2-l1-cos (sample %d)'%j, image_dir='../new_out/') tot = N*n print 'Avg error in raw space' print avg_error_raw / tot print 'Avg error in latent space' print avg_error_lat / tot
def compare_raw_closest(from_path, data_iterator): import csv def load__(i, cut=0): if cut > 0: return { basename: [ np.load(from_path + LOAD_PATH + basename + '_%d-%d.npy' % (i, j))[:cut] for j in range(_N) ] for basename in iter_actions(from_path) } else: return { basename: [ np.load(from_path + LOAD_PATH + basename + '_%d-%d.npy' % (i, j)) for j in range(_N) ] for basename in iter_actions(from_path) } with open('../../results/nn_15_results.csv', 'wb') as csvfile: spamwriter = csv.writer(csvfile) # iter1, iter2 = tee(data_iterator) error_score = { basename: [10000] * _N for basename in iter_actions(from_path) } error_x = { basename: [None] * _N for basename in iter_actions(from_path) } gt = load__(0) gtp = load__(2, _N_PRED) pd = load__(1, _N_PRED) iterations = 0 for xs, _ in data_iterator: idx = np.random.choice(xs.shape[0], min(RANDOM_N, xs.shape[0]), replace=False) for x in tqdm(xs[idx]): for basename in iter_actions(from_path): for i in range(_N): score = metrics.__pose_seq_error( x[:_N_INPUT], gt[basename][i][-_N_INPUT:]) if score < error_score[basename][i]: error_score[basename][i] = score error_x[basename][i] = np.copy(x[_N_INPUT:]) del xs iterations += 1 print iterations # break for basename in iter_actions(from_path): error = [None] * _N error_ = [None] * _N for i in range(_N): error[i] = metrics.__pose_seq_error(error_x[basename][i], gtp[basename][i], cumulative=True) error_[i] = metrics.__pose_seq_error(pd[basename][i], gtp[basename][i], cumulative=True) np.save(from_path + LOAD_PATH + basename + '_nn_15-%d.npy' % i, error_x[basename][i]) # fk_animate.animate_compare(gt[basename][i], gtp[basename][i], # error_x[basename][i], 'Nearest Neighbor (1/%d)'%(DATA_ITER_SIZE/RANDOM_N), # pd[basename][i], 'Residual sup. (MA)', from_path+LOAD_PATH+'images/') print basename _err = np.mean(error, axis=0) print 'nearest neighbor' print _err spamwriter.writerow([ basename, 'Nearest nei. (1/%d)' % (DATA_ITER_SIZE / RANDOM_N) ] + _err.tolist()) _err = np.mean(error_, axis=0) print 'baseline error' print np.mean(error_, axis=0) spamwriter.writerow([basename, 'Residual sup. (MA)'] + _err.tolist())
def compare(model, data_iterator): import image h = model.timesteps embedding = metrics.get_embedding(model, data_iterator, model.timesteps - 1) # methods = ['Closest', 'Mean-45', 'Mean-75', 'Mean-100', 'Random-5000', 'Random-10000', 'Multi'] methods = [ 'Add', 'Add-Closest', 'Add-Mean-30', 'Add-Mean-45', 'Add-Mean-75' ] # methods = ['Closest', 'Mean-30', 'Mean-45', 'Random-5000', 'Random-10000'] for k, cut in enumerate(model.hierarchies[-2:-1]): # k = (h-cut)/3 errors = {} errors_ = {} for basename in iter_actions(): errors[basename] = [] errors_[basename] = [] print basename for i in tqdm(range(8)): gt = np.load(LOAD_PATH + basename + '_0-%d.npy' % i) pd = np.load(LOAD_PATH + basename + '_1-%d.npy' % i) gtp = np.load(LOAD_PATH + basename + '_2-%d.npy' % i) if model.MODEL_CODE == metrics.HL_LSTM: l = np.zeros((gt.shape[0], model.label_dim)) l[:, model.labels[basename]] = 1 gt = np.concatenate((gt, l), axis=1) # pose = metrics.__get_next_half(embedding, gt[-10:], encoder, decoder, h, model_name) # poses = metrics.__get_consecutive(embedding, gt[-h:], model, cut+1, k) # poses = metrics.__get_consecutive_multi(embedding, gt[-h:], model, cut+1, k) poses = metrics.__get_consecutive_add(embedding, gt[-h:], model, cut + 1) ground_truth = metrics.__autoencode(model.autoencoder, np.array([gtp[:h]]), model.MODEL_CODE) ground_truth = np.reshape( ground_truth, (-1, model.timesteps, model.input_dim))[-1] # pose_ref = poses[0] # poses = poses[1:] n = poses.shape[1] # metrics.__get_embedding_path(gt, encoder, decoder, h, model_name) if len(errors[basename]) == 0: errors[basename] = np.zeros((8, poses.shape[0], n)) errors_[basename] = np.zeros((8, 4, n)) for j in range(n): for k, p in enumerate(poses): errors[basename][i, k, j] = metrics.__pose_seq_error( gtp[:j + 1], p[:j + 1]) errors_[basename][i, 3, j] = metrics.__pose_seq_error( gtp[:j + 1], pd[:j + 1]) errors_[basename][i, 0, :] = metrics.__zeros_velocity_error( gt[-n:], gtp[:n])[:] errors_[basename][i, 1, :] = metrics.__average_2_error( gt[-n:], gtp[:n])[:] errors_[basename][i, 2, :] = metrics.__average_4_error( gt[-n:], gtp[:n])[:] # image.plot_poses([gt[-h:], gtp[:h]], [pose[:h], pd[:h]]) best_error = np.min(errors[basename][i, :, -1]) b_error = errors_[basename][i, -1, -1] image_dir = '../results/t30-l200/low_error/refined-add/' if best_error > errors_[basename][i, -1, -1]: image_dir = '../results/t30-l200/high_error/refined-add/' image.plot_poses( [gt[-n:], gtp[:n], ground_truth[:n]], np.concatenate([poses, [pd[:n]]], axis=0), title='%6.3f-%6.3f (%s - C, M, R-5000-10000, B) %d-%d' % (b_error, best_error / b_error, basename, cut, k), image_dir=image_dir) # print basename, mean_err[[1,3,7,9,-1]] # if basename in ['walking', 'eating', 'smoking', 'discussion']: x = np.arange(n) + 1 for k, method in enumerate(methods): mean_err = np.mean(errors[basename][:, k, :], axis=0) plt.plot(x, mean_err, label=method) for k, method in enumerate( ['0 velocity', 'avg-2', 'avg-4', 'baseline']): mean_err_ = np.mean(errors_[basename][:, k, :], axis=0) plt.plot(x, mean_err_, '--', label=method) plt.legend() plt.title('%s-%d' % (basename, cut)) # plt.show() plt.savefig('../results/t30-l200/graphs/refined-add/%s-%d-%d.png' % (basename, cut, k)) plt.close() errors = np.reshape(np.array(errors.values()), (-1, poses.shape[0], n)) errors_ = np.reshape(np.array(errors_.values()), (-1, 4, n)) for k, method in enumerate(methods): mean_err = np.mean(errors[:, k, :], axis=0) plt.plot(x, mean_err, label=method) for k, method in enumerate( ['0 velocity', 'avg-2', 'avg-4', 'baseline']): mean_err_ = np.mean(errors_[:, k, :], axis=0) plt.plot(x, mean_err_, '--', label=method) plt.legend() plt.title('Total-%d' % (cut)) # plt.show() plt.savefig('../results/t30-l200/graphs/refined-add/total-%d-%d.png' % (cut, k)) plt.close()
def compare_label_embedding(model, nn, data_iterator, with_label=True): import image embedding = metrics.get_label_embedding( model, data_iterator, subspaces=model.hierarchies[-2:]) #, without_label_only=True) print len(embedding) mean_diff, diff = metrics.get_embedding_diffs(embedding[:, 1], embedding[:, 0]) cut = model.hierarchies[-2] + 1 pred_n = model.timesteps - cut for basename in iter_actions(): print basename pose_ref = np.zeros((_N, model.timesteps, model.input_dim)) pose_pred_bl = np.zeros( (_N, pred_n, model.input_dim - model.label_dim)) pose_gt = np.zeros((_N, pred_n, model.input_dim - model.label_dim)) for i in tqdm(range(_N)): gt = np.load(LOAD_PATH + basename + '_0-%d.npy' % i) pd = np.load(LOAD_PATH + basename + '_1-%d.npy' % i) gtp = np.load(LOAD_PATH + basename + '_2-%d.npy' % i) pose_ref[i, :cut, :-model.label_dim] = gt[-cut:] pose_pred_bl[i] = pd[:pred_n] pose_gt[i] = gtp[:pred_n] # pose_ref[i,cut:,:-model.label_dim] = gtp[:pred_n] if with_label: print model.labels[basename] pose_ref[:, :, -model.label_dim + model.labels[basename]] = 1 enc = model.encoder.predict(pose_ref)[:, cut - 1] new_enc_partial = np.zeros(enc.shape) for i in tqdm(range(_N)): new_e_idx = metrics.__closest_partial_index( embedding[:, 0], enc[i]) #new_enc_partial[i] = metrics.__closest(embedding[:,1], enc[i]) new_enc_partial[i] = embedding[new_e_idx, 1] print enc.shape, pose_ref.shape, new_enc_partial.shape pose_pred_from_part = model.decoder.predict( new_enc_partial)[:, -pred_n:, :-model.label_dim] #new_enc = nn.model.predict(enc) #new_enc = enc + mean_diff # # pose_pred = model.decoder.predict(new_enc) #pose_pred = model.decoder.predict(new_enc)[:,-pred_n:,:-model.label_dim] error_bl = [ metrics.__pose_seq_error(pose_gt[i], pose_pred_bl[i]) for i in range(_N) ] error_part = [ metrics.__pose_seq_error(pose_gt[i], pose_pred_from_part[i]) for i in range(_N) ] #error = [metrics.__pose_seq_error(pose_gt[i], pose_pred[i]) for i in range(_N)] #print error #print error_part #print error_bl # image.plot_poses(pose_pred, title='rnn', image_dir='../new_out/') # image.plot_poses(pose_pred_bl, title='baseline', image_dir='../new_out/') # image.plot_poses(pose_gt, title='gt', image_dir='../new_out/') #np.save('../new_out/R-RNN-t25-l512/npy/RRNN-add-nl-%s.npy'%basename, pose_pred) np.save('../new_out/t25-l512-r/LRNN-r-%s.npy' % basename, pose_pred_from_part)