def main():
parser = argparse.ArgumentParser()
# Observed length of the trajectory parameter
parser.add_argument('--obs_length',
type=int,
default=8,
help='Observed length of the trajectory')
# Predicted length of the trajectory parameter
parser.add_argument('--pred_length',
type=int,
default=12,
help='Predicted length of the trajectory')
# Train Dataset
# Use like:
# python transpose_inrange.py --train_dataset index_1 index_2 ...
parser.add_argument(
'-l',
'--train_dataset',
nargs='+',
help=
'<Required> training dataset(s) the model is trained on: --train_dataset index_1 index_2 ...',
default=[0, 1, 2, 4],
type=int)
# Test dataset
parser.add_argument('--test_dataset',
type=int,
default=3,
help='Dataset to be tested on')
# Model to be loaded
parser.add_argument('--epoch',
type=int,
default=26,
help='Epoch of model to be loaded')
# Use GPU or not
parser.add_argument('--use_cuda',
action="store_true",
default=False,
help="Use GPU or CPU")
# Parse the parameters
sample_args = parser.parse_args()
# Save directory
load_directory = 'save/'
load_directory += 'trainedOn_' + str(sample_args.train_dataset)
# Define the path for the config file for saved args
## Arguments of parser while traning
with open(os.path.join(load_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
# Initialize net
net = SRNN(saved_args, True)
if saved_args.use_cuda:
net = net.cuda()
checkpoint_path = os.path.join(
load_directory, 'srnn_model_' + str(sample_args.epoch) + '.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
# model_iteration = checkpoint['iteration']
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at {}'.format(model_epoch))
# Dataset to get data from
dataset = [sample_args.test_dataset]
dataloader = DataLoader(1,
sample_args.pred_length + sample_args.obs_length,
dataset,
True,
infer=True)
dataloader.reset_batch_pointer()
# Construct the ST-graph object
stgraph = ST_GRAPH(1, sample_args.pred_length + sample_args.obs_length)
results = []
# Variable to maintain total error
total_error = 0
final_error = 0
for batch in range(dataloader.num_batches):
start = time.time()
# Get the next batch
x, _, frameIDs, d = dataloader.next_batch(randomUpdate=False)
# Construct ST graph
stgraph.readGraph(x)
nodes, edges, nodesPresent, edgesPresent = stgraph.getSequence()
# Convert to cuda variables
nodes = Variable(torch.from_numpy(nodes).float(), volatile=True)
edges = Variable(torch.from_numpy(edges).float(), volatile=True)
if saved_args.use_cuda:
nodes = nodes.cuda()
edges = edges.cuda()
# Separate out the observed part of the trajectory
obs_nodes, obs_edges, obs_nodesPresent, obs_edgesPresent = nodes[:
sample_args
.
obs_length], edges[:
sample_args
.
obs_length], nodesPresent[:
sample_args
.
obs_length], edgesPresent[:
sample_args
.
obs_length]
# Sample function
ret_nodes, ret_attn, ret_new_attn = sample(obs_nodes, obs_edges,
obs_nodesPresent,
obs_edgesPresent,
sample_args, net, nodes,
edges, nodesPresent)
# Compute mean and final displacement error
total_error += get_mean_error(ret_nodes[sample_args.obs_length:].data,
nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:],
saved_args.use_cuda)
final_error += get_final_error(
ret_nodes[sample_args.obs_length:].data,
nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:])
end = time.time()
print('Processed trajectory number : ', batch, 'out of',
dataloader.num_batches, 'trajectories in time', end - start)
# Store results
if saved_args.use_cuda:
results.append(
(nodes.data.cpu().numpy(), ret_nodes.data.cpu().numpy(),
nodesPresent, sample_args.obs_length, ret_attn, ret_new_attn,
frameIDs))
else:
results.append(
(nodes.data.numpy(), ret_nodes.data.numpy(), nodesPresent,
sample_args.obs_length, ret_attn, ret_new_attn, frameIDs))
# Reset the ST graph
stgraph.reset()
print('Total mean error of the model is ',
total_error / dataloader.num_batches)
print('Total final error of the model is ',
final_error / dataloader.num_batches)
print('Saving results')
save_directory = load_directory + '/testedOn_' + str(
sample_args.test_dataset)
if not os.path.exists(save_directory):
os.makedirs(save_directory)
with open(os.path.join(save_directory, 'results.pkl'), 'wb') as f:
pickle.dump(results, f)
def main():
parser = argparse.ArgumentParser()
# Observed length of the trajectory parameter
parser.add_argument('--obs_length',
type=int,
default=8,
help='Observed length of the trajectory')
# Predicted length of the trajectory parameter
parser.add_argument('--pred_length',
type=int,
default=12,
help='Predicted length of the trajectory')
# Test dataset
parser.add_argument('--test_dataset',
type=int,
default=4,
help='Dataset to be tested on')
parser.add_argument('--sample_dataset',
type=int,
default=4,
help='Dataset to be sampled on')
# Model to be loaded
parser.add_argument('--epoch',
type=int,
default=133,
help='Epoch of model to be loaded')
#[109,149,124,80,128]
# Parse the parameters
sample_args = parser.parse_args()
# Save directory
save_directory = '/home/hesl/PycharmProjects/srnn-pytorch/save/FixedPixel_150epochs_batchsize24_Pruned/'
save_directory += str(sample_args.test_dataset) + '/'
save_directory += 'save_attention'
ouput_directory = '/home/hesl/PycharmProjects/srnn-pytorch/save/'
#ouput_directory+= str(sample_args.test_dataset) + '/'
ouput_directory = save_directory
# Define the path for the config file for saved args
with open(os.path.join(save_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
# Initialize net
net = SRNN(saved_args, True)
net.cuda()
#net.forward()
checkpoint_path = os.path.join(
save_directory, 'srnn_model_' + str(sample_args.epoch) + '.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
# model_iteration = checkpoint['iteration']
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at {}'.format(model_epoch))
# homography
H = np.loadtxt(H_path[sample_args.sample_dataset])
# Dataset to get data from
dataset = [sample_args.test_dataset]
dataset = [sample_args.sample_dataset]
dataloader = DataLoader(1,
sample_args.pred_length + sample_args.obs_length,
dataset,
True,
infer=True)
dataloader.reset_batch_pointer()
# Construct the ST-graph object
stgraph = ST_GRAPH(1, sample_args.pred_length + sample_args.obs_length)
NumberofSampling = 10
for i in range(NumberofSampling):
results = []
# Variable to maintain total error
total_error = 0
final_error = 0
for batch in range(dataloader.num_batches):
start = time.time()
# Get the next batch
x, _, frameIDs, d = dataloader.next_batch(randomUpdate=False)
# Construct ST graph
stgraph.readGraph(x)
nodes, edges, nodesPresent, edgesPresent = stgraph.getSequence()
# Convert to cuda variables
nodes = Variable(torch.from_numpy(nodes).float(),
volatile=True).cuda()
edges = Variable(torch.from_numpy(edges).float(),
volatile=True).cuda()
# Separate out the observed part of the trajectory
obs_nodes, obs_edges, obs_nodesPresent, obs_edgesPresent = nodes[:
sample_args
.
obs_length], edges[:
sample_args
.
obs_length], nodesPresent[:
sample_args
.
obs_length], edgesPresent[:
sample_args
.
obs_length]
# Sample function
ret_nodes, ret_attn = sample(obs_nodes, obs_edges,
obs_nodesPresent, obs_edgesPresent,
sample_args, net, nodes, edges,
nodesPresent)
# Compute mean and final displacement error
total_error += get_mean_error(
ret_nodes[sample_args.obs_length:].data,
nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:], H,
sample_args.sample_dataset)
final_error += get_final_error(
ret_nodes[sample_args.obs_length:].data,
nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:], H,
sample_args.sample_dataset)
end = time.time()
print('Processed trajectory number : ', batch, 'out of',
dataloader.num_batches, 'trajectories in time', end - start)
# Store results
results.append(
(nodes.data.cpu().numpy(), ret_nodes.data.cpu().numpy(),
nodesPresent, sample_args.obs_length, ret_attn, frameIDs,
total_error / dataloader.num_batches,
final_error / dataloader.num_batches))
# Reset the ST graph
stgraph.reset()
print('Total mean error of the model is ',
total_error / dataloader.num_batches)
print('Total final error of the model is ',
final_error / dataloader.num_batches)
current_mean_error = total_error / dataloader.num_batches
current_final_error = final_error / dataloader.num_batches
if i == 0:
min_current_mean_error = current_mean_error
min_current_final_error = current_final_error
min_index = i
print('Saving initial results on {}'.format(i))
with open(os.path.join(ouput_directory, 'results.pkl'), 'wb') as f:
pickle.dump(results, f)
else:
if current_mean_error < min_current_mean_error:
min_current_mean_error = current_mean_error
min_current_final_error = current_final_error
min_index = i
print('Found Smaller Error on {}, Saving results'.format(i))
print(
'Smaller current_mean_error"{} and current_final_error:{} and '
.format(current_mean_error, current_final_error))
with open(os.path.join(ouput_directory, 'results.pkl'),
'wb') as f:
pickle.dump(results, f)
print(
'Minimum Total Mean Error is {} and Minimum Final Mean Error is {} on {}th Sampling'
.format(min_current_mean_error, min_current_final_error, min_index))
def main():
parser = argparse.ArgumentParser()
# Observed length of the trajectory parameter
parser.add_argument('--obs_length', type=int, default=8,
help='Observed length of the trajectory')
# Predicted length of the trajectory parameter
parser.add_argument('--pred_length', type=int, default=12,
help='Predicted length of the trajectory')
# Test dataset
parser.add_argument('--test_dataset', type=int, default=3,
help='Dataset to be tested on')
# Model to be loaded
parser.add_argument('--epoch', type=int, default=107,
help='Epoch of model to be loaded')
# Parse the parameters
sample_args = parser.parse_args()
# Save directory
save_directory = '/home/hesl/PycharmProjects/social-lstm-pytorch/save/FixedPixel_Normalized_150epoch/'+ str(sample_args.test_dataset) + '/'
save_directory='/home/hesl/PycharmProjects/social-lstm-pytorch/save/FixedPixel_Normalized_150epoch/1/'
ouput_directory='/home/hesl/PycharmProjects/social-lstm-pytorch/save/'
# Define the path for the config file for saved args
with open(os.path.join(save_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
# Initialize net
net = SocialLSTM(saved_args, True)
net.cuda()
# Get the checkpoint path
checkpoint_path = os.path.join(save_directory, 'social_lstm_model_'+str(sample_args.epoch)+'.tar')
# checkpoint_path = os.path.join(save_directory, 'srnn_model.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
# model_iteration = checkpoint['iteration']
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at epoch', model_epoch)
#homography
H = np.loadtxt(H_path[sample_args.test_dataset])
# Test dataset
dataset = [sample_args.test_dataset]
# Create the DataLoader object
dataloader = DataLoader(1, sample_args.pred_length + sample_args.obs_length, dataset, True, infer=True)
dataloader.reset_batch_pointer()
# Construct the ST-graph object
stgraph = ST_GRAPH(1, sample_args.pred_length + sample_args.obs_length)
results = []
# Variable to maintain total error
total_error = 0
final_error = 0
# For each batch
for batch in range(dataloader.num_batches):
start = time.time()
# Get data
x, _, d = dataloader.next_batch(randomUpdate=False)
# Get the sequence
x_seq, d_seq = x[0], d[0]
# Dimensions of the dataset
if d_seq == 0 and dataset[0] == 0:
dimensions = [640, 480]
else:
dimensions = [720, 576]
dimensions=[1224,370]
# Get the grid masks for the sequence
grid_seq = getSequenceGridMask(x_seq, dimensions, saved_args.neighborhood_size, saved_args.grid_size)
# Construct ST graph
stgraph.readGraph(x)
# Get nodes and nodesPresent
nodes, _, nodesPresent, _ = stgraph.getSequence(0)
nodes = Variable(torch.from_numpy(nodes).float(), volatile=True).cuda()
# Extract the observed part of the trajectories
obs_nodes, obs_nodesPresent, obs_grid = nodes[:sample_args.obs_length], nodesPresent[:sample_args.obs_length], grid_seq[:sample_args.obs_length]
# The sample function
ret_nodes = sample(obs_nodes, obs_nodesPresent, obs_grid, sample_args, net, nodes, nodesPresent, grid_seq, saved_args, dimensions)
#print(nodes[sample_args.obs_length:].data)
# Record the mean and final displacement error
total_error += get_mean_error(ret_nodes[sample_args.obs_length:].data, nodes[sample_args.obs_length:].data, nodesPresent[sample_args.obs_length-1], nodesPresent[sample_args.obs_length:],H,sample_args.test_dataset)
final_error += get_final_error(ret_nodes[sample_args.obs_length:].data, nodes[sample_args.obs_length:].data, nodesPresent[sample_args.obs_length-1], nodesPresent[sample_args.obs_length:],H,sample_args.test_dataset)
end = time.time()
print('Processed trajectory number : ', batch, 'out of', dataloader.num_batches, 'trajectories in time', end - start)
results.append((nodes.data.cpu().numpy(), ret_nodes.data.cpu().numpy(), nodesPresent, sample_args.obs_length))
# Reset the ST graph
stgraph.reset()
print('Total mean error of the model is ', total_error / dataloader.num_batches)
print('Total final error of the model is ', final_error / dataloader.num_batches)
print('Saving results')
with open(os.path.join(ouput_directory, 'results.pkl'), 'wb') as f:
pickle.dump(results, f)
def main():
parser = argparse.ArgumentParser()
# Observed length of the trajectory parameter
parser.add_argument('--obs_length',
type=int,
default=8,
help='Observed length of the trajectory')
# Predicted length of the trajectory parameter
parser.add_argument('--pred_length',
type=int,
default=12,
help='Predicted length of the trajectory')
# Model to be loaded
parser.add_argument('--epoch',
type=int,
default=14,
help='Epoch of model to be loaded')
# cuda support
parser.add_argument('--use_cuda',
action="store_true",
default=False,
help='Use GPU or not')
# drive support
parser.add_argument('--drive',
action="store_true",
default=False,
help='Use Google drive or not')
# number of iteration -> we are trying many times to get lowest test error derived from observed part and prediction of observed
# part.Currently it is useless because we are using direct copy of observed part and no use of prediction.Test error will be 0.
parser.add_argument(
'--iteration',
type=int,
default=1,
help=
'Number of iteration to create test file (smallest test errror will be selected)'
)
# gru model
parser.add_argument('--gru',
action="store_true",
default=False,
help='True : GRU cell, False: LSTM cell')
# method selection
parser.add_argument(
'--method',
type=int,
default=1,
help=
'Method of lstm will be used (1 = social lstm, 2 = obstacle lstm, 3 = vanilla lstm)'
)
# Parse the parameters
sample_args = parser.parse_args()
#for drive run
prefix = ''
f_prefix = '.'
if sample_args.drive is True:
prefix = 'drive/semester_project/social_lstm_final/'
f_prefix = 'drive/semester_project/social_lstm_final'
#run sh file for folder creation
if not os.path.isdir("log/"):
print("Directory creation script is running...")
subprocess.call([f_prefix + '/make_directories.sh'])
method_name = get_method_name(sample_args.method)
model_name = "LSTM"
save_tar_name = method_name + "_lstm_model_"
if sample_args.gru:
model_name = "GRU"
save_tar_name = method_name + "_gru_model_"
print("Selected method name: ", method_name, " model name: ", model_name)
# Save directory
save_directory = os.path.join(f_prefix, 'model/', method_name, model_name)
#plot directory for plotting in the future
plot_directory = os.path.join(f_prefix, 'plot/', method_name, model_name)
result_directory = os.path.join(f_prefix, 'result/', method_name)
plot_test_file_directory = 'test'
# Define the path for the config file for saved args
with open(os.path.join(save_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
seq_lenght = sample_args.pred_length + sample_args.obs_length
# Create the DataLoader object
dataloader = DataLoader(f_prefix,
1,
seq_lenght,
forcePreProcess=True,
infer=True)
create_directories(os.path.join(result_directory, model_name),
dataloader.get_all_directory_namelist())
create_directories(plot_directory, [plot_test_file_directory])
dataloader.reset_batch_pointer()
dataset_pointer_ins = dataloader.dataset_pointer
smallest_err = 100000
smallest_err_iter_num = -1
origin = (0, 0)
reference_point = (0, 1)
submission_store = [] # store submission data points (txt)
result_store = [] # store points for plotting
for iteration in range(sample_args.iteration):
# Initialize net
net = get_model(sample_args.method, saved_args, True)
if sample_args.use_cuda:
net = net.cuda()
# Get the checkpoint path
checkpoint_path = os.path.join(
save_directory, save_tar_name + str(sample_args.epoch) + '.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at epoch', model_epoch)
# For each batch
iteration_submission = []
iteration_result = []
results = []
submission = []
# Variable to maintain total error
total_error = 0
final_error = 0
for batch in range(dataloader.num_batches):
start = time.time()
# Get data
x, y, d, numPedsList, PedsList, target_ids = dataloader.next_batch(
)
# Get the sequence
x_seq, d_seq, numPedsList_seq, PedsList_seq, target_id = x[0], d[
0], numPedsList[0], PedsList[0], target_ids[0]
dataloader.clean_test_data(x_seq, target_id,
sample_args.obs_length,
sample_args.pred_length)
dataloader.clean_ped_list(x_seq, PedsList_seq, target_id,
sample_args.obs_length,
sample_args.pred_length)
#get processing file name and then get dimensions of file
folder_name = dataloader.get_directory_name_with_pointer(d_seq)
dataset_data = dataloader.get_dataset_dimension(folder_name)
#dense vector creation
x_seq, lookup_seq = dataloader.convert_proper_array(
x_seq, numPedsList_seq, PedsList_seq)
#will be used for error calculation
orig_x_seq = x_seq.clone()
# target_id_values = orig_x_seq[0][lookup_seq[target_id], 0:2]
#grid mask calculation
if sample_args.method == 2: #obstacle lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
saved_args.neighborhood_size,
saved_args.grid_size,
saved_args.use_cuda, True)
elif sample_args.method == 1: #social lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
saved_args.neighborhood_size,
saved_args.grid_size,
saved_args.use_cuda)
#vectorize datapoints
x_seq, first_values_dict = vectorize_seq(x_seq, PedsList_seq,
lookup_seq)
# <------------- Experimental block ---------------->
# x_seq = translate(x_seq, PedsList_seq, lookup_seq ,target_id_values)
# angle = angle_between(reference_point, (x_seq[1][lookup_seq[target_id], 0].data.numpy(), x_seq[1][lookup_seq[target_id], 1].data.numpy()))
# x_seq = rotate_traj_with_target_ped(x_seq, angle, PedsList_seq, lookup_seq)
# grid_seq = getSequenceGridMask(x_seq[:sample_args.obs_length], dataset_data, PedsList_seq, saved_args.neighborhood_size, saved_args.grid_size, sample_args.use_cuda)
# x_seq, first_values_dict = vectorize_seq(x_seq, PedsList_seq, lookup_seq)
if sample_args.use_cuda:
x_seq = x_seq.cuda()
# The sample function
if sample_args.method == 3: #vanilla lstm
# Extract the observed part of the trajectories
obs_traj, obs_PedsList_seq = x_seq[:sample_args.
obs_length], PedsList_seq[:
sample_args
.
obs_length]
ret_x_seq = sample(obs_traj, obs_PedsList_seq, sample_args,
net, x_seq, PedsList_seq, saved_args,
dataset_data, dataloader, lookup_seq,
numPedsList_seq, sample_args.gru)
else:
# Extract the observed part of the trajectories
obs_traj, obs_PedsList_seq, obs_grid = x_seq[:sample_args.
obs_length], PedsList_seq[:
sample_args
.
obs_length], grid_seq[:
sample_args
.
obs_length]
ret_x_seq = sample(obs_traj, obs_PedsList_seq, sample_args,
net, x_seq, PedsList_seq, saved_args,
dataset_data, dataloader, lookup_seq,
numPedsList_seq, sample_args.gru, obs_grid)
#revert the points back to original space
ret_x_seq = revert_seq(ret_x_seq, PedsList_seq, lookup_seq,
first_values_dict)
# <--------------------- Experimental inverse block ---------------------->
# ret_x_seq = revert_seq(ret_x_seq, PedsList_seq, lookup_seq, target_id_values, first_values_dict)
# ret_x_seq = rotate_traj_with_target_ped(ret_x_seq, -angle, PedsList_seq, lookup_seq)
# ret_x_seq = translate(ret_x_seq, PedsList_seq, lookup_seq ,-target_id_values)
# Record the mean and final displacement error
print(PedsList_seq[-sample_args.pred_length:])
total_error += get_mean_error(
ret_x_seq[-sample_args.pred_length:].data,
orig_x_seq[-sample_args.pred_length:].data,
PedsList_seq[-sample_args.pred_length:],
PedsList_seq[-sample_args.pred_length:], sample_args.use_cuda,
lookup_seq)
final_error += get_final_error(
ret_x_seq[-sample_args.pred_length:].data,
orig_x_seq[-sample_args.pred_length:].data,
PedsList_seq[-sample_args.pred_length:],
PedsList_seq[-sample_args.pred_length:], lookup_seq)
end = time.time()
print('Current file : ', dataloader.get_file_name(0),
' Processed trajectory number : ', batch + 1, 'out of',
dataloader.num_batches, 'trajectories in time', end - start)
# if dataset_pointer_ins is not dataloader.dataset_pointer:
# if dataloader.dataset_pointer is not 0:
# iteration_submission.append(submission)
# iteration_result.append(results)
# dataset_pointer_ins = dataloader.dataset_pointer
# submission = []
# results = []
# submission.append(submission_preprocess(dataloader, ret_x_seq.data[sample_args.obs_length:, lookup_seq[target_id], :].numpy(), sample_args.pred_length, sample_args.obs_length, target_id))
# results.append((x_seq.data.cpu().numpy(), ret_x_seq.data.cpu().numpy(), PedsList_seq, lookup_seq , dataloader.get_frame_sequence(seq_lenght), target_id, sample_args.obs_length))
# iteration_submission.append(submission)
# iteration_result.append(results)
# submission_store.append(iteration_submission)
# result_store.append(iteration_result)
if total_error < smallest_err:
print("**********************************************************")
print('Best iteration has been changed. Previous best iteration: ',
smallest_err_iter_num + 1, 'Error: ',
smallest_err / dataloader.num_batches)
print('New best iteration : ', iteration + 1, 'Error: ',
total_error / dataloader.num_batches)
smallest_err_iter_num = iteration
smallest_err = total_error
print('Iteration:', iteration + 1,
' Total training (observed part) mean error of the model is ',
total_error / dataloader.num_batches)
print('Iteration:', iteration + 1,
'Total training (observed part) final error of the model is ',
final_error / dataloader.num_batches)
#print(submission)
print('Smallest error iteration:', smallest_err_iter_num + 1)
def main():
# os.chdir('/home/serene/Documents/KITTIData/GT/')
# os.chdir('/home/siri0005/copy_srnn_pytorch/srnn-pytorch-master/')#/srnn-pytorch-master
os.chdir('/home/serene/Documents/copy_srnn_pytorch/srnn-pytorch-master')
H_path = ['./pedestrians/ewap_dataset/seq_eth/H.txt',
'./pedestrians/ewap_dataset/seq_hotel/H.txt',
'./pedestrians/ucy_crowd/data_zara01/H.txt',
'./pedestrians/ucy_crowd/data_zara02/H.txt',
'./pedestrians/ucy_crowd/data_students03/H.txt']
# ,1,2,3,
base_dir = '../fine_obstacle/prelu/p_02/'
for i in [4]:#,1,2,3,4
avg = []
ade = []
with open(base_dir+'log/{0}/log_attention/val.txt'.format(i)) as val_f:
if i == 1:
e = 99
else:
best_val = val_f.readline()
[e, val] = best_val.split(',')
parser = argparse.ArgumentParser()
# Observed length of the trajectory parameter
parser.add_argument('--obs_length', type=int, default=8,
help='Observed length of the trajectory')
# Predicted length of the trajectory parameter
parser.add_argument('--pred_length', type=int, default=12,
help='Predicted length of the trajectory')
# Test dataset
parser.add_argument('--test_dataset', type=int, default=i,
help='Dataset to be tested on')
# Model to be loaded
parser.add_argument('--epoch', type=int, default=e,
help='Epoch of model to be loaded')
# Parse the parameters
sample_args = parser.parse_args()
# Save directory
save_directory = base_dir+'save/{0}/save_attention'.format(i)
plot_directory = base_dir + '/selected_plots/' #'plot_1/'
# Define the path for the config file for saved args
with open(os.path.join(save_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
# Initialize net
net = SRNN(saved_args, sample_args.test_dataset, True)
net.cuda()
## TODO: visualize trained weights
# plt.imshow(net.humanNodeRNN.edge_embed.weight)
# plt.colorbar()
# plt.show()
checkpoint_path = os.path.join(save_directory, 'srnn_model_'+str(sample_args.epoch)+'.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
# model_iteration = checkpoint['iteration']
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at {}'.format(model_epoch))
H_mat = np.loadtxt(H_path[i])
avg = []
ade = []
# Dataset to get data from
dataset = [sample_args.test_dataset]
sample_ade_error_arr = []
sample_fde_error_arr = []
num_nodes = 0
inner_num_nodes_1= 0
inner_num_nodes_2= 0
ade_sum = 0
fde_sum = 0
dataloader = DataLoader(1, sample_args.pred_length + sample_args.obs_length, dataset, True, infer=True)
dataloader.reset_batch_pointer()
# Construct the ST-graph object
stgraph = ST_GRAPH(1, sample_args.pred_length + sample_args.obs_length)
results = []
# Variable to maintain total error
total_error = 0
final_error = 0
# TRY this code version
for batch in range(dataloader.num_batches):
sample_fde_error = []
sample_ade_error = []
running_time_sample = []
c = 0
x, _, frameIDs, d = dataloader.next_batch(randomUpdate=False)
# Construct ST graph
stgraph.readGraph(x, ds_ptr=d, threshold=1.0)
nodes, edges, nodesPresent, edgesPresent, obsNodes, obsEdges, obsNodesPresent, obsEdgesPresent = stgraph.getSequence()
nodes = Variable(torch.from_numpy(nodes).float(), volatile=True).cuda()
edges = Variable(torch.from_numpy(edges).float(), volatile=True).cuda()
obsNodes = Variable(torch.from_numpy(obsNodes).float()).cuda()
obsEdges = Variable(torch.from_numpy(obsEdges).float()).cuda()
# Separate out the observed part of the trajectory
obs_nodes, obs_edges, obs_nodesPresent, obs_edgesPresent = nodes[:sample_args.obs_length], edges[:sample_args.obs_length], nodesPresent[:sample_args.obs_length], edgesPresent[:sample_args.obs_length]
# Separate out the observed obstacles in a given sequence
obsnodes_v, obsEdges_v, obsNodesPresent_v, obsEdgesPresent_v = obsNodes[:sample_args.obs_length], obsEdges[:sample_args.obs_length], obsNodesPresent[:sample_args.obs_length], obsEdgesPresent[:sample_args.obs_length]
# if c == 0:
# num_nodes += np.shape(nodes)[1]
for c in range(10):
num_nodes += np.shape(nodes)[1]
start = time.time()
# Sample function
ret_nodes, ret_attn = sample(obs_nodes, obs_edges, obs_nodesPresent, obs_edgesPresent, obsnodes_v,
obsEdges_v, obsNodesPresent_v,obsEdgesPresent_v, sample_args, net, nodes, edges, nodesPresent)
end = time.time()
running_time_sample.append((end-start))
# print('One-time Sampling took = ', (end - start), ' seconds.')
# Compute mean and final displacement error
total_error , _ = get_mean_error(ret_nodes[sample_args.obs_length:].data, nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:], H_mat, i)
# print("ADE errors:", total_error)
inner_num_nodes_1 += _
sample_ade_error.append(total_error)
final_error , _ = get_final_error(ret_nodes[sample_args.obs_length:].data, nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:], H_mat, i)
# print("final errors:", final_error)
sample_fde_error.append(final_error)
results.append((nodes.data.cpu().numpy(), ret_nodes.data.cpu().numpy(), nodesPresent, sample_args.obs_length, ret_attn, frameIDs))
stgraph.reset()
sample_ade_error_arr.append(np.sum(sample_ade_error))
sample_fde_error_arr.append(np.sum(sample_fde_error))
sample_ade_error = np.sum(sample_ade_error, 0)
if len(sample_ade_error):
# sample_ade_error /= 10
sample_ade_error = torch.min(sample_ade_error)
ade_sum += sample_ade_error
ade.append(ade_sum)
# for non-rectangular tensors
for (e, idx) in zip(sample_fde_error , range(len(sample_fde_error))):
if int(len(e)) > 0 :
l = int(len(e))
sample_fde_error[idx] = np.sum(e) #/l
else:
del sample_fde_error[idx]
print(sample_fde_error)
if (np.ndim(sample_fde_error) == 1 and len(sample_fde_error)) or \
(np.ndim(sample_fde_error) > 1 and np.all([True for x in sample_fde_error if len(x) > 0] == True)):
sample_fde_error = np.min(sample_fde_error)
fde_sum += sample_fde_error
avg.append(fde_sum)
with open(os.path.join(save_directory, 'results.pkl'), 'wb') as f:
pickle.dump(results, f)
print('SUMMARY **************************//')
print('One-time Sampling took = ', np.average(running_time_sample), ' seconds.')
print(np.sum(ade) , ' ' , np.sum(avg))
print('average ADE', np.sum(ade) / (sample_args.pred_length * num_nodes))#
print('average FDE', np.sum(avg) / (num_nodes*10))#
with open(os.path.join(save_directory, 'sampling_results.txt'), 'wb') as o:
np.savetxt(os.path.join(save_directory, 'sampling_results.txt'), (np.sum(ade) / (sample_args.pred_length * num_nodes),
np.sum(avg) / inner_num_nodes_1))
def main():
parser = argparse.ArgumentParser()
# Model to be loaded
parser.add_argument('--epoch',
type=int,
default=15,
help='Epoch of model to be loaded')
parser.add_argument('--seq_length',
type=int,
default=20,
help='RNN sequence length')
parser.add_argument('--use_cuda',
action="store_true",
default=False,
help='Use GPU or not')
parser.add_argument('--drive',
action="store_true",
default=False,
help='Use Google drive or not')
# Size of neighborhood to be considered parameter
parser.add_argument(
'--neighborhood_size',
type=int,
default=32,
help='Neighborhood size to be considered for social grid')
# Size of the social grid parameter
parser.add_argument('--grid_size',
type=int,
default=4,
help='Grid size of the social grid')
# number of validation will be used
parser.add_argument(
'--num_validation',
type=int,
default=5,
help='Total number of validation dataset will be visualized')
# gru support
parser.add_argument('--gru',
action="store_true",
default=False,
help='True : GRU cell, False: LSTM cell')
# method selection
parser.add_argument(
'--method',
type=int,
default=1,
help=
'Method of lstm will be used (1 = social lstm, 2 = obstacle lstm, 3 = vanilla lstm)'
)
# Parse the parameters
sample_args = parser.parse_args()
# for drive run
prefix = ''
f_prefix = '.'
if sample_args.drive is True:
prefix = 'drive/semester_project/social_lstm_final/'
f_prefix = 'drive/semester_project/social_lstm_final'
method_name = get_method_name(sample_args.method)
model_name = "LSTM"
save_tar_name = method_name + "_lstm_model_"
if sample_args.gru:
model_name = "GRU"
save_tar_name = method_name + "_gru_model_"
# Save directory
save_directory = os.path.join(f_prefix, 'model/', method_name, model_name)
# plot directory for plotting in the future
plot_directory = os.path.join(f_prefix, 'plot/', method_name, model_name)
plot_validation_file_directory = 'validation'
# Define the path for the config file for saved args
with open(os.path.join(save_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
origin = (0, 0)
reference_point = (0, 1)
net = get_model(sample_args.method, saved_args, True)
if sample_args.use_cuda:
net = net.cuda()
# Get the checkpoint path
checkpoint_path = os.path.join(
save_directory, save_tar_name + str(sample_args.epoch) + '.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at epoch', model_epoch)
# Create the DataLoader object
dataloader = DataLoader(f_prefix,
1,
sample_args.seq_length,
num_of_validation=sample_args.num_validation,
forcePreProcess=True,
infer=True)
create_directories(plot_directory, [plot_validation_file_directory])
dataloader.reset_batch_pointer()
print(
'****************Validation dataset batch processing******************'
)
dataloader.reset_batch_pointer(valid=False)
dataset_pointer_ins = dataloader.dataset_pointer
loss_epoch = 0
err_epoch = 0
f_err_epoch = 0
num_of_batch = 0
smallest_err = 100000
# results of one epoch for all validation datasets
epoch_result = []
# results of one validation dataset
results = []
# For each batch
for batch in range(dataloader.num_batches):
start = time.time()
# Get batch data
x, y, d, numPedsList, PedsList, target_ids = dataloader.next_batch()
if dataset_pointer_ins is not dataloader.dataset_pointer:
if dataloader.dataset_pointer is not 0:
print('Finished prosessed file : ',
dataloader.get_file_name(-1), ' Avarage error : ',
err_epoch / num_of_batch)
num_of_batch = 0
epoch_result.append(results)
dataset_pointer_ins = dataloader.dataset_pointer
results = []
# Loss for this batch
loss_batch = 0
err_batch = 0
f_err_batch = 0
# For each sequence
for sequence in range(dataloader.batch_size):
# Get data corresponding to the current sequence
x_seq, _, d_seq, numPedsList_seq, PedsList_seq = x[sequence], y[
sequence], d[sequence], numPedsList[sequence], PedsList[
sequence]
target_id = target_ids[sequence]
folder_name = dataloader.get_directory_name_with_pointer(d_seq)
dataset_data = dataloader.get_dataset_dimension(folder_name)
# dense vector creation
x_seq, lookup_seq = dataloader.convert_proper_array(
x_seq, numPedsList_seq, PedsList_seq)
# will be used for error calculation
orig_x_seq = x_seq.clone()
target_id_values = x_seq[0][lookup_seq[target_id], 0:2]
# grid mask calculation
if sample_args.method == 2: # obstacle lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
saved_args.neighborhood_size,
saved_args.grid_size,
saved_args.use_cuda, True)
elif sample_args.method == 1: # social lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
saved_args.neighborhood_size,
saved_args.grid_size,
saved_args.use_cuda)
# vectorize datapoints
x_seq, first_values_dict = vectorize_seq(x_seq, PedsList_seq,
lookup_seq)
# <---------------- Experimental block (may need update in methods)----------------------->
# x_seq = translate(x_seq, PedsList_seq, lookup_seq ,target_id_values)
# angle = angle_between(reference_point, (x_seq[1][lookup_seq[target_id], 0].data.numpy(), x_seq[1][lookup_seq[target_id], 1].data.numpy()))
# x_seq = rotate_traj_with_target_ped(x_seq, angle, PedsList_seq, lookup_seq)
# # Compute grid masks
# grid_seq = getSequenceGridMask(x_seq, dataset_data, PedsList_seq, sample_args.neighborhood_size, sample_args.grid_size, sample_args.use_cuda)
# x_seq, first_values_dict = vectorize_seq(x_seq, PedsList_seq, lookup_seq)
if sample_args.use_cuda:
x_seq = x_seq.cuda()
if sample_args.method == 3: # vanilla lstm
ret_x_seq, loss = sample_validation_data_vanilla(
x_seq, PedsList_seq, sample_args, net, lookup_seq,
numPedsList_seq, dataloader)
else:
ret_x_seq, loss = sample_validation_data(
x_seq, PedsList_seq, grid_seq, sample_args, net,
lookup_seq, numPedsList_seq, dataloader)
# <---------------------Experimental inverse block -------------->
# ret_x_seq = revert_seq(ret_x_seq, PedsList_seq, lookup_seq, target_id_values, first_values_dict)
# ret_x_seq = rotate_traj_with_target_ped(ret_x_seq, -angle, PedsList_seq, lookup_seq)
# ret_x_seq = translate(ret_x_seq, PedsList_seq, lookup_seq ,-target_id_values)
# revert the points back to original space
ret_x_seq = revert_seq(ret_x_seq, PedsList_seq, lookup_seq,
first_values_dict)
err = get_mean_error(ret_x_seq.data, orig_x_seq.data, PedsList_seq,
PedsList_seq, sample_args.use_cuda,
lookup_seq)
f_err = get_final_error(ret_x_seq.data, orig_x_seq.data,
PedsList_seq, PedsList_seq, lookup_seq)
loss_batch += loss
err_batch += err
f_err_batch += f_err
results.append(
(orig_x_seq.data.cpu().numpy(), ret_x_seq.data.cpu().numpy(),
PedsList_seq, lookup_seq,
dataloader.get_frame_sequence(sample_args.seq_length),
target_id))
end = time.time()
print('Current file : ', dataloader.get_file_name(0), ' Batch : ',
batch + 1, ' Sequence: ', sequence + 1, ' Sequence mean error: ',
err, ' Sequence final error: ', f_err, ' time: ', end - start)
loss_batch = loss_batch / dataloader.batch_size
err_batch = err_batch / dataloader.batch_size
f_err_batch = f_err_batch / dataloader.batch_size
num_of_batch += 1
loss_epoch += loss_batch.item()
err_epoch += err_batch
f_err_epoch += f_err_batch
epoch_result.append(results)
if dataloader.num_batches != 0:
loss_epoch = loss_epoch / dataloader.num_batches
err_epoch = err_epoch / dataloader.num_batches
f_err_epoch = f_err_epoch / dataloader.num_batches
print(
'valid_loss = {:.3f}, valid_mean_err = {:.3f}, valid_final_err = {:.3f}'
.format(loss_epoch, err_epoch, f_err_epoch))
dataloader.write_to_plot_file(
epoch_result,
os.path.join(plot_directory, plot_validation_file_directory))
def main():
# os.chdir('/home/serene/Documents/KITTIData/GT/')
# os.chdir('/home/siri0005/srnn-pytorch-master/')#/srnn-pytorch-master
os.chdir('/home/serene/Documents/copy_srnn_pytorch/srnn-pytorch-master')
H_path = ['././pedestrians/ewap_dataset/seq_eth/H.txt',
'././pedestrians/ewap_dataset/seq_hotel/H.txt',
'././pedestrians/ucy_crowd/data_zara01/H.txt',
'././pedestrians/ucy_crowd/data_zara02/H.txt',
'././pedestrians/ucy_crowd/data_students03/H.txt']
avg = []
ade = []
# ,1,2,3,
# base_dir = '/home/serene/Downloads/srnn-pytorch-master/' #'../MultiNodeAttn_HH/' #'../fine_obstacle/prelu/p_02/'
base_dir = '../MultiNodeAttn_HH/' #'/home/serene/Downloads/ablation/'
for i in [1]:
with open(base_dir+'log/{0}/log_attention/val.txt'.format(i)) as val_f:
best_val = val_f.readline()
# e = 45
[e, val] = best_val.split(',')
parser = argparse.ArgumentParser()
# Observed length of the trajectory parameter
parser.add_argument('--obs_length', type=int, default=8,
help='Observed length of the trajectory')
# Predicted length of the trajectory parameter
parser.add_argument('--pred_length', type=int, default=12,
help='Predicted length of the trajectory')
# Test dataset
parser.add_argument('--test_dataset', type=int, default=i,
help='Dataset to be tested on')
# Model to be loaded
parser.add_argument('--epoch', type=int, default=e,
help='Epoch of model to be loaded')
parser.add_argument('--use_cuda', action="store_true", default=True,
help="Use GPU or CPU")
# Parse the parameters
sample_args = parser.parse_args()
# Save directory
save_directory = base_dir+'save/{0}/save_attention'.format(i)
plot_directory = base_dir + '/selected_plots/' #'plot_1/'
# save_directory = './srnn-pytorch-master/fine_obstacle/save/{0}/save_attention'.format(i)
#'/home/serene/Documents/copy_srnn_pytorch/srnn-pytorch-master/save/pixel_data/100e/'
#'/home/serene/Documents/InVehicleCamera/save_kitti/'
# save_directory += str(sample_args.test_dataset)+'/'
# save_directory += 'save_attention'
# Define the path for the config file for saved args
with open(os.path.join(save_directory, 'config.pkl'), 'rb') as f:
saved_args = pickle.load(f)
# Initialize net
net = SRNN(saved_args, True)
net.cuda()
## TODO: visualize trained weights
# plt.imshow(net.humanNodeRNN.edge_embed.weight)
# plt.colorbar()
# plt.show()
checkpoint_path = os.path.join(save_directory, 'srnn_model_'+str(sample_args.epoch)+'.tar')
if os.path.isfile(checkpoint_path):
print('Loading checkpoint')
checkpoint = torch.load(checkpoint_path)
# model_iteration = checkpoint['iteration']
model_epoch = checkpoint['epoch']
net.load_state_dict(checkpoint['state_dict'])
print('Loaded checkpoint at {}'.format(model_epoch))
H_mat = np.loadtxt(H_path[i])
avg = []
ade = []
# Dataset to get data from
dataset = [sample_args.test_dataset]
for c in range(30):
dataloader = DataLoader(1, sample_args.pred_length + sample_args.obs_length, dataset, True, infer=True)
dataloader.reset_batch_pointer()
# Construct the ST-graph object
stgraph = ST_GRAPH(1, sample_args.pred_length + sample_args.obs_length)
results = []
# Variable to maintain total error
total_error = 0
final_error = 0
minimum = 1000
min_final = 1000
for batch in range(dataloader.num_batches):
start = time.time()
# Get the next batch
x, _, frameIDs, d = dataloader.next_batch(randomUpdate=False)
# Construct ST graph
stgraph.readGraph(x, ds_ptr=d,threshold=1.0)
nodes, edges, nodesPresent, edgesPresent = stgraph.getSequence()
#obsNodes, obsEdges, obsNodesPresent, obsEdgesPresent
# Convert to cuda variables
nodes = Variable(torch.from_numpy(nodes).float(), volatile=True).cuda()
edges = Variable(torch.from_numpy(edges).float(), volatile=True).cuda()
# obsNodes = Variable(torch.from_numpy(obsNodes).float()).cuda()
# obsEdges = Variable(torch.from_numpy(obsEdges).float()).cuda()
# NOTE: obs_ : observed
# Separate out the observed part of the trajectory
obs_nodes, obs_edges, obs_nodesPresent, obs_edgesPresent = nodes[:sample_args.obs_length], edges[:sample_args.obs_length], nodesPresent[:sample_args.obs_length], edgesPresent[:sample_args.obs_length]
# Separate out the observed obstacles in a given sequence
# obsnodes_v, obsEdges_v , obsNodesPresent_v , obsEdgesPresent_v = obsNodes[:sample_args.obs_length], obsEdges[:sample_args.obs_length], obsNodesPresent[:sample_args.obs_length], obsEdgesPresent[:sample_args.obs_length]
# Sample function
ret_nodes, ret_attn = sample(obs_nodes, obs_edges, obs_nodesPresent, obs_edgesPresent,sample_args, net, nodes, edges, nodesPresent)
# , obsnodes_v , obsEdges_v, obsNodesPresent_v,
# obsEdgesPresent_v , )
# Compute mean and final displacement error
total_error += get_mean_error(ret_nodes[sample_args.obs_length:].data, nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:], H_mat, i)
final_error += get_final_error(ret_nodes[sample_args.obs_length:].data, nodes[sample_args.obs_length:].data,
nodesPresent[sample_args.obs_length - 1],
nodesPresent[sample_args.obs_length:], H_mat, i)
# if total_error < minimum:
# minimum = total_error
# if final_error < min_final:
# min_final = final_error
end = time.time()
# Store results
results.append((nodes.data.cpu().numpy(), ret_nodes.data.cpu().numpy(), nodesPresent, sample_args.obs_length, ret_attn, frameIDs))
# zfill = 3
# for i in range(len(results)):
# skip = str(int(results[i][5][0][8])).zfill(zfill)
# # img_file = '/home/serene/Documents/video/hotel/frame-{0}.jpg'.format(skip)
# # for j in range(20):
# # if i == 40:
#
# img_file = '/home/serene/Documents/copy_srnn_pytorch/data/ucy/zara/zara.png'
# name = plot_directory + 'sequence_zara' + str(i) # /pedestrian_1
# # for k in range(20):
# vis.plot_trajectories(results[i][0], results[i][1], results[i][2], results[i][3], name,
# plot_directory, img_file, 1)
# if int(skip) >= 999 and zfill < 4:
# zfill = zfill + 1
# elif int(skip) >= 9999 and zfill < 5:
# zfill = zfill + 1
# Reset the ST graph
stgraph.reset()
print('Total mean error of the model is ', total_error / dataloader.num_batches)
print('Total final error of the model is ', final_error / dataloader.num_batches)
ade.append(total_error / dataloader.num_batches)
avg.append(final_error / dataloader.num_batches)
print('Saving results')
with open(os.path.join(save_directory, 'results.pkl'), 'wb') as f:
pickle.dump(results, f)
print('average FDE', np.average(avg))
print('average ADE', np.average(ade))
with open(os.path.join(save_directory, 'sampling_results.txt'), 'wb') as o:
np.savetxt(os.path.join(save_directory, 'sampling_results.txt'), (ade, avg) , fmt='%.03e')
def main():
parser = argparse.ArgumentParser()
# Model to be loaded
# RNN size parameter (dimension of the output/hidden state)
parser.add_argument('--input_size', type=int, default=2)
parser.add_argument('--output_size', type=int, default=5)
parser.add_argument('--seq_length',
type=int,
default=20,
help='RNN sequence length')
# Size of each batch parameter
parser.add_argument('--batch_size',
type=int,
default=10,
help='minibatch size')
parser.add_argument('--num_samples',
type=int,
default=500,
help='NUmber of random configuration will be tested')
parser.add_argument('--num_epochs',
type=int,
default=3,
help='number of epochs')
# Maximum number of pedestrians to be considered
parser.add_argument('--maxNumPeds',
type=int,
default=27,
help='Maximum Number of Pedestrians')
# cuda support
parser.add_argument('--use_cuda',
action="store_true",
default=False,
help='Use GPU or not')
# drive support
parser.add_argument('--drive',
action="store_true",
default=False,
help='Use Google drive or not')
# number of validation dataset will be used
parser.add_argument(
'--num_validation',
type=int,
default=1,
help='Total number of validation dataset will be visualized')
# gru model
parser.add_argument('--gru',
action="store_true",
default=False,
help='True : GRU cell, False: LSTM cell')
# method selection for hyperparameter
parser.add_argument(
'--method',
type=int,
default=1,
help=
'Method of lstm will be used (1 = social lstm, 2 = obstacle lstm, 3 = vanilla lstm)'
)
# number of parameter set will be logged
parser.add_argument('--best_n',
type=int,
default=100,
help='Number of best n configuration will be logged')
# Parse the parameters
#sample_args = parser.parse_args()
args = parameters(parser)
args.best_n = np.clip(args.best_n, 0, args.num_samples)
#for drive run
prefix = ''
f_prefix = '.'
if args.drive is True:
prefix = 'drive/semester_project/social_lstm_final/'
f_prefix = 'drive/semester_project/social_lstm_final'
method_name = get_method_name(args.method)
model_name = "LSTM"
save_tar_name = method_name + "_lstm_model_"
if args.gru:
model_name = "GRU"
save_tar_name = method_name + "_gru_model_"
#plot directory for plotting in the future
param_log = os.path.join(f_prefix)
param_log_file = "hyperparameter"
origin = (0, 0)
reference_point = (0, 1)
score = []
param_set = []
# Create the DataLoader object
create_directories(param_log, [param_log_file])
log_file = open(os.path.join(param_log, param_log_file, 'log.txt'), 'w+')
dataloader_t = DataLoader(f_prefix,
args.batch_size,
args.seq_length,
num_of_validation=args.num_validation,
forcePreProcess=True,
infer=True)
dataloader_v = DataLoader(f_prefix,
1,
args.seq_length,
num_of_validation=args.num_validation,
forcePreProcess=True,
infer=True)
for hyperparams in itertools.islice(sample_hyperparameters(),
args.num_samples):
args = parameters(parser)
# randomly sample a parameter set
args.rnn_size = hyperparams.pop("rnn_size")
args.learning_schedule = hyperparams.pop("learning_schedule")
args.grad_clip = hyperparams.pop("grad_clip")
args.learning_rate = hyperparams.pop("learning_rate")
args.lambda_param = hyperparams.pop("lambda_param")
args.dropout = hyperparams.pop("dropout")
args.embedding_size = hyperparams.pop("embedding_size")
args.neighborhood_size = hyperparams.pop("neighborhood_size")
args.grid_size = hyperparams.pop("grid_size")
log_file.write("##########Parameters########" + '\n')
print("##########Parameters########")
write_to_file(log_file, args)
print_to_screen(args)
net = get_model(args.method, args)
if args.use_cuda:
net = net.cuda()
if (args.learning_schedule == "RMSprop"):
optimizer = torch.optim.RMSprop(net.parameters(),
lr=args.learning_rate)
elif (args.learning_schedule == "adagrad"):
optimizer = torch.optim.Adagrad(net.parameters(),
weight_decay=args.lambda_param)
else:
optimizer = torch.optim.Adam(net.parameters(),
weight_decay=args.lambda_param)
learning_rate = args.learning_rate
total_process_start = time.time()
# Training
for epoch in range(args.num_epochs):
print('****************Training epoch beginning******************')
dataloader_t.reset_batch_pointer()
loss_epoch = 0
# For each batch
for batch in range(dataloader_t.num_batches):
start = time.time()
# Get batch data
x, y, d, numPedsList, PedsList, target_ids = dataloader_t.next_batch(
)
loss_batch = 0
# For each sequence
for sequence in range(dataloader_t.batch_size):
# Get the data corresponding to the current sequence
x_seq, _, d_seq, numPedsList_seq, PedsList_seq = x[
sequence], y[sequence], d[sequence], numPedsList[
sequence], PedsList[sequence]
target_id = target_ids[sequence]
#get processing file name and then get dimensions of file
folder_name = dataloader_t.get_directory_name_with_pointer(
d_seq)
dataset_data = dataloader_t.get_dataset_dimension(
folder_name)
#dense vector creation
x_seq, lookup_seq = dataloader_t.convert_proper_array(
x_seq, numPedsList_seq, PedsList_seq)
target_id_values = x_seq[0][lookup_seq[target_id], 0:2]
#grid mask calculation
if args.method == 2: #obstacle lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
args.neighborhood_size,
args.grid_size,
args.use_cuda, True)
elif args.method == 1: #social lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
args.neighborhood_size,
args.grid_size,
args.use_cuda)
# vectorize trajectories in sequence
x_seq, _ = vectorize_seq(x_seq, PedsList_seq, lookup_seq)
if args.use_cuda:
x_seq = x_seq.cuda()
#number of peds in this sequence per frame
numNodes = len(lookup_seq)
hidden_states = Variable(
torch.zeros(numNodes, args.rnn_size))
if args.use_cuda:
hidden_states = hidden_states.cuda()
cell_states = Variable(torch.zeros(numNodes,
args.rnn_size))
if args.use_cuda:
cell_states = cell_states.cuda()
# Zero out gradients
net.zero_grad()
optimizer.zero_grad()
# Forward prop
if args.method == 3: #vanilla lstm
outputs, _, _ = net(x_seq, hidden_states, cell_states,
PedsList_seq, numPedsList_seq,
dataloader_t, lookup_seq)
else:
outputs, _, _ = net(x_seq, grid_seq, hidden_states,
cell_states, PedsList_seq,
numPedsList_seq, dataloader_t,
lookup_seq)
# Compute loss
loss = Gaussian2DLikelihood(outputs, x_seq, PedsList_seq,
lookup_seq)
loss_batch += loss.item()
# Compute gradients
loss.backward()
# Clip gradients
torch.nn.utils.clip_grad_norm_(net.parameters(),
args.grad_clip)
# Update parameters
optimizer.step()
end = time.time()
loss_batch = loss_batch / dataloader_t.batch_size
loss_epoch += loss_batch
print(
'{}/{} (epoch {}), train_loss = {:.3f}, time/batch = {:.3f}'
.format(epoch * dataloader_t.num_batches + batch,
args.num_epochs * dataloader_t.num_batches, epoch,
loss_batch, end - start))
loss_epoch /= dataloader_t.num_batches
# Log loss values
log_file.write("Training epoch: " + str(epoch) + " loss: " +
str(loss_epoch) + '\n')
net = get_model(args.method, args, True)
if args.use_cuda:
net = net.cuda()
if (args.learning_schedule == "RMSprop"):
optimizer = torch.optim.RMSprop(net.parameters(),
lr=args.learning_rate)
elif (args.learning_schedule == "adagrad"):
optimizer = torch.optim.Adagrad(net.parameters(),
weight_decay=args.lambda_param)
else:
optimizer = torch.optim.Adam(net.parameters(),
weight_decay=args.lambda_param)
print(
'****************Validation dataset batch processing******************'
)
dataloader_v.reset_batch_pointer()
dataset_pointer_ins = dataloader_v.dataset_pointer
loss_epoch = 0
err_epoch = 0
f_err_epoch = 0
num_of_batch = 0
smallest_err = 100000
# For each batch
for batch in range(dataloader_v.num_batches):
start = time.time()
# Get batch data
x, y, d, numPedsList, PedsList, target_ids = dataloader_v.next_batch(
)
if dataset_pointer_ins is not dataloader_v.dataset_pointer:
if dataloader_v.dataset_pointer is not 0:
print('Finished prosessed file : ',
dataloader_v.get_file_name(-1), ' Avarage error : ',
err_epoch / num_of_batch)
num_of_batch = 0
dataset_pointer_ins = dataloader_v.dataset_pointer
# Loss for this batch
loss_batch = 0
err_batch = 0
f_err_batch = 0
# For each sequence
for sequence in range(dataloader_v.batch_size):
# Get data corresponding to the current sequence
x_seq, _, d_seq, numPedsList_seq, PedsList_seq = x[
sequence], y[sequence], d[sequence], numPedsList[
sequence], PedsList[sequence]
target_id = target_ids[sequence]
folder_name = dataloader_v.get_directory_name_with_pointer(
d_seq)
dataset_data = dataloader_v.get_dataset_dimension(folder_name)
#dense vector creation
x_seq, lookup_seq = dataloader_v.convert_proper_array(
x_seq, numPedsList_seq, PedsList_seq)
#will be used for error calculation
orig_x_seq = x_seq.clone()
target_id_values = x_seq[0][lookup_seq[target_id], 0:2]
#grid mask calculation
if args.method == 2: #obstacle lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
args.neighborhood_size,
args.grid_size,
args.use_cuda, True)
elif args.method == 1: #social lstm
grid_seq = getSequenceGridMask(x_seq, dataset_data,
PedsList_seq,
args.neighborhood_size,
args.grid_size,
args.use_cuda)
# vectorize trajectories in sequence
x_seq, first_values_dict = vectorize_seq(
x_seq, PedsList_seq, lookup_seq)
# <--------------Experimental block --------------->
# Construct variables
# x_seq, lookup_seq = dataloader_v.convert_proper_array(x_seq, numPedsList_seq, PedsList_seq)
# x_seq, target_id_values, first_values_dict = vectorize_seq_with_ped(x_seq, PedsList_seq, lookup_seq ,target_id)
# angle = angle_between(reference_point, (x_seq[1][lookup_seq[target_id], 0].data.numpy(), x_seq[1][lookup_seq[target_id], 1].data.numpy()))
# x_seq = rotate_traj_with_target_ped(x_seq, angle, PedsList_seq, lookup_seq)
if args.use_cuda:
x_seq = x_seq.cuda()
if args.method == 3: #vanilla lstm
ret_x_seq, loss = sample_validation_data_vanilla(
x_seq, PedsList_seq, args, net, lookup_seq,
numPedsList_seq, dataloader_v)
else:
ret_x_seq, loss = sample_validation_data(
x_seq, PedsList_seq, grid_seq, args, net, lookup_seq,
numPedsList_seq, dataloader_v)
#revert the points back to original space
ret_x_seq = revert_seq(ret_x_seq, PedsList_seq, lookup_seq,
first_values_dict)
err = get_mean_error(ret_x_seq.data, orig_x_seq.data,
PedsList_seq, PedsList_seq, args.use_cuda,
lookup_seq)
f_err = get_final_error(ret_x_seq.data, orig_x_seq.data,
PedsList_seq, PedsList_seq, lookup_seq)
# ret_x_seq = rotate_traj_with_target_ped(ret_x_seq, -angle, PedsList_seq, lookup_seq)
# ret_x_seq = revert_seq(ret_x_seq, PedsList_seq, lookup_seq, target_id_values, first_values_dict)
loss_batch += loss.item()
err_batch += err
f_err_batch += f_err
end = time.time()
print('Current file : ', dataloader_v.get_file_name(0),
' Batch : ', batch + 1, ' Sequence: ', sequence + 1,
' Sequence mean error: ', err, ' Sequence final error: ',
f_err, ' time: ', end - start)
loss_batch = loss_batch / dataloader_v.batch_size
err_batch = err_batch / dataloader_v.batch_size
f_err_batch = f_err_batch / dataloader_v.batch_size
num_of_batch += 1
loss_epoch += loss_batch
err_epoch += err_batch
f_err_epoch += f_err_batch
total_process_end = time.time()
if dataloader_v.num_batches != 0:
loss_epoch = loss_epoch / dataloader_v.num_batches
err_epoch = err_epoch / dataloader_v.num_batches
f_err_epoch = f_err_epoch / dataloader_v.num_batches
# calculate avarage error and time
avg_err = (err_epoch + f_err_epoch) / 2
elapsed_time = (total_process_end - total_process_start)
args.time = elapsed_time
args.avg_err = avg_err
score.append(avg_err)
param_set.append(args)
print(
'valid_loss = {:.3f}, valid_mean_err = {:.3f}, valid_final_err = {:.3f}, score = {:.3f}, time = {:.3f}'
.format(loss_epoch, err_epoch, f_err_epoch, avg_err,
elapsed_time))
log_file.write(
'valid_loss = {:.3f}, valid_mean_err = {:.3f}, valid_final_err = {:.3f}, score = {:.3f}, time = {:.3f}'
.format(loss_epoch, err_epoch, f_err_epoch, avg_err,
elapsed_time) + '\n')
print("--------------------------Best ", args.best_n,
" configuration------------------------")
log_file.write("-----------------------------Best " + str(args.best_n) +
" configuration---------------------" + '\n')
biggest_indexes = np.array(score).argsort()[-args.best_n:]
print("biggest_index: ", biggest_indexes)
for arr_index, index in enumerate(biggest_indexes):
print("&&&&&&&&&&&&&&&&&&&& ", arr_index, " &&&&&&&&&&&&&&&&&&&&&&")
log_file.write("&&&&&&&&&&&&&&&&&&&& " + str(arr_index) +
" &&&&&&&&&&&&&&&&&&&&&&" + '\n')
curr_arg = param_set[index]
write_to_file(log_file, curr_arg)
print_to_screen(curr_arg)
print("score: ", score)
print('error = {:.3f}, time = {:.3f}'.format(curr_arg.avg_err,
curr_arg.time))
log_file.write('error = {:.3f}, time = {:.3f}'.format(
curr_arg.avg_err, curr_arg.time) + '\n')
