# decay
if iter_n % args['decay_after'] == 0:
model.decay_learning_rate()
print 'New learning rate:', model.lr
if SAVE_TO_DISK:
with open(args['log_path'], 'a+') as f:
spamwriter = csv.writer(f)
spamwriter.writerow([
new_loss, l2_train, l2_test, l2_valid, mean_std_pred,
std_std_pred, log_valid, mean_std_class, std_std_class
])
if __name__ == '__main__':
args, data_iter, test_iter, valid_data = parser.get_parse('train')
# import model class
module = __import__('models.' + args['method_name'])
method_class = getattr(getattr(module, args['method_name']),
args['method_name'])
model = method_class(args)
if args['debug']:
__print_model(model)
if args['load_path'] != None:
print 'Load model ...', args['load_path']
model.load(args['load_path'])
SAVE_TO_DISK = not args['debug']
train(model, data_iter, test_iter, valid_data, args)
for i in range(self.periods):
for x, y in iter1:
x_train, x_test, y_train, y_test = cross_validation.train_test_split(
x, y, test_size=self.cv_splits)
self.model.fit([x_train, y_train],
[x_train, y_train, x_train, y_train],
shuffle=True,
epochs=self.epochs,
batch_size=self.batch_size,
validation_data=([x_test, y_test], [
x_test, y_test, x_test, y_test
]),
callbacks=[self.history])
y_test_decoded = self.translator.predict(x_test[:1])
image.plot_batch_1D(y_test[:1], y_test_decoded)
# self.model.save_weights(self.load_path, overwrite=True)
iter1, iter2 = tee(iter2)
# data_iterator = iter2
# model_vars = [NAME, self.latent_dim, self.timesteps, self.batch_size]
# embedding_plotter.see_embedding(self.encoder, data_iterator, model_vars)
# self.history.record(self.log_path, model_vars)
if __name__ == '__main__':
data_iterator, config = parser.get_parse(NAME)
ae = LSTM_UNIT(config)
ae.run(data_iterator)
data_iterator = iter2
# metric_baselines.compare(self)
# metrics.gen_long_sequence(valid_data, self)
# embedding_plotter.see_hierarchical_embedding(self.encoder, self.decoder, data_iterator, valid_data, model_vars, self.label_dim)
# iter1, iter2 = tee(data_iterator)
# metrics.validate(valid_data, self)
#nn = NN.Forward_NN({'input_dim':self.latent_dim, 'output_dim':self.latent_dim, 'mode':'sample'})
#nn.run(None)
# metrics.plot_metrics(self, data_iterator, valid_data)
# association_evaluation.plot_best_distance_function(self, valid_data, data_iterator)
# association_evaluation.eval_generation(self, valid_data, data_iterator)
# association_evaluation.eval_center(self, valid_data, 'sitting')
# association_evaluation.transfer_motion(self, valid_data, 'sitting', 'walking', data_iterator)
# association_evaluation.plot_transfer_motion(self, '../new_out/transfer_motion-sitting-to-greeting-scores.npy')
# association_evaluation.plot_transfer_motion(self, '../new_out/transfer_motion-sitting-to-walking-scores.npy')
# association_evaluation.eval_generation_from_label(self, data_iterator)
# association_evaluation.plot_add(self, data_iterator)
# metrics.plot_metrics_labels(self, data_iterator, valid_data)
# metric_baselines.compare_label_embedding(self, nn, data_iterator)
# association_evaluation.eval_distance(self, valid_data)
# evaluate.eval_pattern_reconstruction(self.encoder, self.decoder, iter2)
if __name__ == '__main__':
data_iterator, valid_data, config = parser.get_parse(NAME, labels=True)
ae = R_H_LSTM(config)
ae.run(data_iterator, valid_data)
if self.trained:
self.model.load_weights(self.load_path)
# blah
else:
iter1, iter2 = tee(data_iterator)
for i in range(self.periods):
for x, y in iter1:
norm_y = y / np.pi / 2
x_train, x_test, y_train, y_test = cross_validation.train_test_split(
x, norm_y, test_size=self.cv_splits)
self.model.fit(x_train,
y_train,
shuffle=True,
epochs=self.epochs,
batch_size=self.batch_size,
validation_data=(x_test, y_test))
y_test_decoded = self.model.predict(x_test[:1])
image.plot_batch_1D(y_test[:1], y_test_decoded)
# self.model.save_weights(self.load_path, overwrite=True)
iter1, iter2 = tee(iter2)
if __name__ == '__main__':
data_iterator, config = parser.get_parse('LSTM_AE')
ae = Stacked_LSTM(config)
ae.run(data_iterator)
#score_name = score_name + '%s:%2f_' %(method, error[basename][method]['euler'][-1])
#poses[k+2] = self.recover(model_pred[:1])
# error[method]['z'] = np.mean([np.linalg.norm(new_enc[i] - enc[i,-1]) for i in range(_N)])
# print error[method]['z']
# for i in range(_N):
# pose_err = metrics.pose_seq_error(gtp_x[i], model_pred[i,:,:self.euler_start], cumulative=True)
# error[method]['pose'] = error[method]['pose'] + np.array(pose_err)
# error[method]['pose'] = error[method]['pose']/_N
# print error[method]['pose']
# error[method]['pose'] = error[method]['pose'].tolist()
#poses = np.concatenate(poses, axis=0)
#image.plot_fk_from_euler(poses, title='%s_gt_agt_%s'%(basename, score_name), image_dir='../new_out/')
with open(
'../new_out/zero_velocity_validation-testset-mseMartinez.json',
'wb') as result_file:
json.dump(error, result_file)
#with open('../new_out/%s_t%d_l%d_opt-%s_validation-testset-mseMartinez.json'%(NAME, self.timesteps, self.latent_dim, self.loss_opt_str), 'wb') as result_file:
# json.dump(error, result_file)
if __name__ == '__main__':
data_iterator, valid_data, config = parser.get_parse(NAME)
ae = H_euler_RNN_R(config)
ae.run(data_iterator, valid_data)
opt = RMSprop(lr=self.lr) self.autoencoder.compile(optimizer=opt, loss=self.loss) # def run(self, data_iterator): # self.load() # if not self.trained: # # from keras.utils import plot_model # # plot_model(self.autoencoder, to_file='model.png') # for x in data_iterator: # x_data = self.alter_label(x) # x_train, x_test, y_train, y_test = cross_validation.train_test_split(x_data, x_data, test_size=self.cv_splits) # y_train = self.alter_y(y_train) # y_test = self.alter_y(y_test) # print x_train.shape, x_test.shape, y_train.shape, y_test.shape # #from utils import image # #xyz = translate__.batch_expmap2xyz(y_train[:5,:5], self) # #image.plot_poses(xyz) # history = self.autoencoder.fit(x_train, y_train, # shuffle=True, # epochs=self.epochs, # batch_size=self.batch_size, # validation_data=(x_test, y_test)) # self.post_train_step(history.history['loss'][0], x_test) if __name__ == '__main__': train_set_gen, test_set, config = parser.get_parse(MODEL_NAME, HAS_LABELS) ae = R_RNN(config, HAS_LABELS) ae.run(train_set_gen, test_set, HAS_LABELS)
import time
import os
import h5py
import numpy as np
from tqdm import tqdm
from utils.parser import get_parse
from utils.testdataset import configdataset
from utils.general import get_data_root, htime
from utils.evaluate import compute_map_and_print
args = get_parse()
datasets = args.datasets.split(',')
h5 = h5py.File(args.features, 'r')
keys = list(h5.keys())
def get_features(images):
vecs = []
for img in tqdm(images):
basename = os.path.basename(img).split('.')[0]
vecs.append(np.array(h5[basename]))
vecs = np.asarray(vecs)
return vecs
for dataset in datasets:
start = time.time()
cfg = configdataset(dataset, os.path.join(get_data_root(), 'test'))
images = [cfg['im_fname'](cfg, i) for i in range(cfg['n'])]
