Datasets:

FelixOtt
/

industry_datasets

import numpy as np
import argparse
import os
import time
import torch
import torch.backends.cudnn as cudnn
import torch.nn.init as init
import torch.optim as optim
import torch.utils.data
from glob import glob
torch.autograd.set_detect_anomaly(True)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(device)
parser = argparse.ArgumentParser()
parser.add_argument('--train', help='number of the train set to load', required=True)
parser.add_argument('--timestamps', help='evaluate test data every x iterations', required=True)
parser.add_argument('--beta', help='multiplication fact for rotation loss', required=True)
parser.add_argument('--iterations', help='iterations to train for', required=True)
parser.add_argument('--batchsize', help='batchsize', required=True)
parser.add_argument('--size', help='sequence length', required=True)
parser.add_argument('--rnn_size', help='network hidden size', required=False, default=10)
parser.add_argument('--rot', help='0: keep rel as is, 1: rotate rel with abs', required=False, default=0)
parser.add_argument('--m', help='1: APR + PRP, 2: APR[s] + PRP[s], 3: SfM + PRP, 4: APR + PRP[s], 5: APR[s] + PRP, 6: SfM + PRP[s]', required=False, default=1)
parser.add_argument('--net', help='Network to use', required=False, default="lstm")
parser.add_argument('--stack', help='Number of layers', required=False, default="2")
parser.add_argument('--run_num', help='Id of the run', required=False, default="0")

args = parser.parse_args()
train_num = int(args.train)
TIMESTAMP = int(args.timestamps)
BETA = float(args.beta)
ITERATIONS = int(args.iterations)
batchSize = int(args.batchsize)
time_size = int(args.size)
rnn_size = int(args.rnn_size)
backrot = int(args.rot)
mode = int(args.m)
net_name = args.net
stacks = int(args.stack)
run_num = int(args.run_num)
all_folders = glob("...")  # Collects all previous trainings (the folder names start with the training number)
all_folders = np.array([int(x.split("/")[-1].split("_")[0]) for x in all_folders])
if run_num in all_folders:
	# if the number already exists, then skipp it
	print("Skipped: ", run_num, train_num, TIMESTAMP, BETA, ITERATIONS, batchSize, time_size,
							rnn_size, backrot, mode, net_name, stacks)
	exit()
print("Running: ", run_num, train_num, TIMESTAMP, BETA, ITERATIONS, batchSize, time_size, rnn_size,
						backrot, mode, net_name, stacks)

# Choose and create the network specified in the arguments
if net_name == "lstm":
	from lstm import *
	model = LSTM_stack(14, rnn_size, device, stacks)
	model.train()
	model = model.to(device)
elif net_name == "cfn":
	from cfn import *
	model = CFN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
elif net_name == "gru":
	from gru import *
	model = GRU_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
elif net_name == "mgu":
	from mgu import *
	model = MGU_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
elif net_name == "qrnn":
	from qrnn import *
	model = fakeQRNN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
elif net_name == "ran":
	from ran import *
	model = RAN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
elif net_name == "sru":
	from sru import *
	model = SRU_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
elif net_name == "trnn":
	from trnn import *
	model = TRNN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
import utilities_comb as utilities

# The following deals with paths and folders for the data. It has to be adjusted to your setup.  -------------------- #
# In the end 4 file paths are defined: train_dataset_abs/train_dataset_rel, test_dataset_abs/test_dataset_rel
# Folders with the train/test data for the different methods
# Each is a dictionary with an entry for every train number
abs_datasets_sfm = {1: ..., 2: ...}
abs_datasets = {1: ..., 2: ...}
rel_datasets = {1: ..., 2: ...}
abs_synt_post_datasets = {1: ..., 2: ...}
rel_synt_post_datasets = {1: ..., 2: ...}
# Depending on the mode, the absolute and relative data is combined from different methods
if mode == 1:
	train_base_abs = abs_datasets[train_num]
	train_base_rel = rel_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
elif mode == 2:
	train_base_abs = abs_synt_post_datasets[train_num]
	train_base_rel = rel_synt_post_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
elif mode == 3:
	train_base_abs = abs_datasets_sfm[train_num]
	train_base_rel = rel_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
elif mode == 4:
	train_base_abs = abs_datasets[train_num]
	train_base_rel = rel_synt_post_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
elif mode == 5:
	train_base_abs = abs_synt_post_datasets[train_num]
	train_base_rel = rel_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
elif mode == 6:
	train_base_abs = abs_datasets_sfm[train_num]
	train_base_rel = rel_synt_post_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
# ------------------------------------------------------------------------------------------------------------------- #

# Creates the folders in which the results are saved
currentDate = time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime())
os.mkdir("../results/" + "%05d_" % (run_num) + str(currentDate))
os.mkdir("../results/" + "%05d_" % (run_num) + str(currentDate) + "/weights/")
# writes the current parameters in a file
parameters = open("../results/" + "%05d_" % (run_num) + str(currentDate) + "/parameters.txt", "w")
parameters.write("Modelname:    flownet" + "\n" +
                 "Dataset:      " + str(train_num) + "\n" +
                 "Timestamp:    " + str(TIMESTAMP) + "\n" +
                 "Iterations:   " + str(ITERATIONS) + "\n" +
                 "Batch size:   " + str(batchSize) + "\n" +
                 "Time_size:    " + str(time_size) + "\n" +
                 "Rnn_size:     " + str(rnn_size) + "\n" +
                 "Back_rotate:  " + str(backrot) + "\n" +
                 "Mode:         " + str(mode) + "\n" +
                 "Net name:     " + str(net_name) + "\n" +
                 "Stacks:       " + str(stacks) + "\n")
parameters.close()
outputWeightspath = "../results/" + "%05d_" % (run_num) + str(currentDate) + "/weights/" + str(train_num) + '_BS_' + str(batchSize) + '_'
log = open("../results/" + "%05d_" % (run_num) + str(currentDate) + "/log_" + str(train_num) + '_BS_' + str(batchSize) + '.txt', "w")


def getError(posx, posq, actualx, actualq):
	""" Calculates the position and rotation error """
	q1 = actualq / np.linalg.norm(actualq)
	q2 = posq / np.linalg.norm(posq)
	d = abs(np.sum(np.multiply(q1, q2)))
	theta = 2 * np.arccos(d) * 180 / np.pi
	errx = np.linalg.norm(actualx - posx)
	return errx, theta


def rmse_p(y_true, y_pred):
	return torch.sqrt(torch.sum(torch.square(y_pred-y_true), axis=-1))


def rmse_q(y_true, y_pred):
	return BETA * torch.sqrt(torch.sum(torch.square(y_true-y_pred), axis=-1))


class rmse_wrap(torch.nn.Module):
	""" Wrapper for dealing with the position loss and rotation loss. The rotation loss is multiplied with BETA. """
	def __init__(self):
		super(rmse_wrap, self).__init__()
	def __call__(self, output, target):
		loss1 = rmse_p(output[:, :3], target[:, :3])
		loss2 = rmse_q(output[:, 3:], target[:, 3:])
		return loss1 + loss2


# For keeping track of the total run time
s_time = time.time()
# Loads the training/test data
pred_abs, pred_rel, gt_abs, gt_rel = utilities.get_training_data(train_dataset_abs, train_dataset_rel, backrot)
pred_abs_test, pred_rel_test, gt_abs_test, gt_rel_test = utilities.get_training_data(test_dataset_abs, test_dataset_rel, backrot)
# Generator for creating batches of size batchSize
data_gen = utilities.gen_data_batch(pred_abs, pred_rel, gt_abs, gt_rel, batchSize, time_size)
optimizer = optim.Adam(model.parameters())
criterion = rmse_wrap().to(device)
# train for ITERATIONS
for i in range(ITERATIONS):
	print(i)
	# Load the next batch and put in on the device
	X_batch, Y_batch = next(data_gen)
	X_batch = X_batch.transpose((1, 0, 2))
	X_batch = torch.tensor(X_batch)        
	Y_batch = torch.from_numpy(Y_batch)
	inputs = X_batch.to(device)
	labels = Y_batch.to(device)
	# predict on the current input data
	preds = model(inputs).float()
	# Loss function
	cost = criterion(preds, labels).mean()
	optimizer.zero_grad()
	cost.backward(retain_graph=True)
	optimizer.step()
	model.zero_grad()
	model.detach_hidden()
	print(cost)
	if (i+1) % int(TIMESTAMP) == 0:  # every TIMESTAMP steps: evaluate the network on the test data
		model.eval()
		hidden1_copy = model.cell1.hidden
		model.cell1.hidden = None
		if stacks == 2:
			hidden2_copy = model.cell2.hidden
			model.cell2.hidden = None
		# create a generator for the test data (Batchsize = 1)
		datagen = utilities.limited_gen_data(pred_abs_test, pred_rel_test, gt_abs_test, gt_rel_test, time_size)
		posxs = []
		posqs = []
		for ims, xs, qs in datagen:  # Iterate over the test data and evaluate it
			inputs = np.zeros((1, time_size, 14)).astype("float32")
			inputs[0, :] = ims
			inputs = inputs.transpose((1, 0, 2))
			inputs = torch.tensor(inputs).to(device)
			out = model(inputs).float()
			posx = out[0][:3].detach().cpu().numpy()
			posq = out[0][3:].detach().cpu().numpy()
			actualx = xs
			actualq = qs
			errx, theta = getError(posx, posq, actualx, actualq)
			posxs.append(errx)
			posqs.append(theta)
		# Write the results into a file
		print('Median error ' + str(np.median(posxs)) + ' m and ' + str(np.nanmedian(posqs)) + ' degrees')
		log.write("Median error %f m and %f degrees \n" % (np.median(posxs), np.nanmedian(posqs)))
		log.flush()
		torch.save(model.state_dict(), outputWeightspath + str(i) + '.h5')
		model.cell1.hidden = hidden1_copy
		if stacks == 2:
			model.cell2.hidden = hidden2_copy
		model.train()
print("Total time: ", time.time() - s_time)

	import numpy as np
	import argparse
	import os
	import time
	import torch
	import torch.backends.cudnn as cudnn
	import torch.nn.init as init
	import torch.optim as optim
	import torch.utils.data
	from glob import glob
	torch.autograd.set_detect_anomaly(True)
	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
	print(device)
	parser = argparse.ArgumentParser()
	parser.add_argument('--train', help='number of the train set to load', required=True)
	parser.add_argument('--timestamps', help='evaluate test data every x iterations', required=True)
	parser.add_argument('--beta', help='multiplication fact for rotation loss', required=True)
	parser.add_argument('--iterations', help='iterations to train for', required=True)
	parser.add_argument('--batchsize', help='batchsize', required=True)
	parser.add_argument('--size', help='sequence length', required=True)
	parser.add_argument('--rnn_size', help='network hidden size', required=False, default=10)
	parser.add_argument('--rot', help='0: keep rel as is, 1: rotate rel with abs', required=False, default=0)
	parser.add_argument('--m', help='1: APR + PRP, 2: APR[s] + PRP[s], 3: SfM + PRP, 4: APR + PRP[s], 5: APR[s] + PRP, 6: SfM + PRP[s]', required=False, default=1)
	parser.add_argument('--net', help='Network to use', required=False, default="lstm")
	parser.add_argument('--stack', help='Number of layers', required=False, default="2")
	parser.add_argument('--run_num', help='Id of the run', required=False, default="0")

	args = parser.parse_args()
	train_num = int(args.train)
	TIMESTAMP = int(args.timestamps)
	BETA = float(args.beta)
	ITERATIONS = int(args.iterations)
	batchSize = int(args.batchsize)
	time_size = int(args.size)
	rnn_size = int(args.rnn_size)
	backrot = int(args.rot)
	mode = int(args.m)
	net_name = args.net
	stacks = int(args.stack)
	run_num = int(args.run_num)
	all_folders = glob("...") # Collects all previous trainings (the folder names start with the training number)
	all_folders = np.array([int(x.split("/")[-1].split("_")[0]) for x in all_folders])
	if run_num in all_folders:
	# if the number already exists, then skipp it
	print("Skipped: ", run_num, train_num, TIMESTAMP, BETA, ITERATIONS, batchSize, time_size,
	rnn_size, backrot, mode, net_name, stacks)
	exit()
	print("Running: ", run_num, train_num, TIMESTAMP, BETA, ITERATIONS, batchSize, time_size, rnn_size,
	backrot, mode, net_name, stacks)

	# Choose and create the network specified in the arguments
	if net_name == "lstm":
	from lstm import *
	model = LSTM_stack(14, rnn_size, device, stacks)
	model.train()
	model = model.to(device)
	elif net_name == "cfn":
	from cfn import *
	model = CFN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	elif net_name == "gru":
	from gru import *
	model = GRU_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	elif net_name == "mgu":
	from mgu import *
	model = MGU_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	elif net_name == "qrnn":
	from qrnn import *
	model = fakeQRNN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	elif net_name == "ran":
	from ran import *
	model = RAN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	elif net_name == "sru":
	from sru import *
	model = SRU_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	elif net_name == "trnn":
	from trnn import *
	model = TRNN_stack(14, rnn_size, device, stacks)
	model.train()
	model.to(device)
	import utilities_comb as utilities

	# The following deals with paths and folders for the data. It has to be adjusted to your setup. -------------------- #
	# In the end 4 file paths are defined: train_dataset_abs/train_dataset_rel, test_dataset_abs/test_dataset_rel
	# Folders with the train/test data for the different methods
	# Each is a dictionary with an entry for every train number
	abs_datasets_sfm = {1: ..., 2: ...}
	abs_datasets = {1: ..., 2: ...}
	rel_datasets = {1: ..., 2: ...}
	abs_synt_post_datasets = {1: ..., 2: ...}
	rel_synt_post_datasets = {1: ..., 2: ...}
	# Depending on the mode, the absolute and relative data is combined from different methods
	if mode == 1:
	train_base_abs = abs_datasets[train_num]
	train_base_rel = rel_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
	elif mode == 2:
	train_base_abs = abs_synt_post_datasets[train_num]
	train_base_rel = rel_synt_post_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
	elif mode == 3:
	train_base_abs = abs_datasets_sfm[train_num]
	train_base_rel = rel_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
	elif mode == 4:
	train_base_abs = abs_datasets[train_num]
	train_base_rel = rel_synt_post_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
	elif mode == 5:
	train_base_abs = abs_synt_post_datasets[train_num]
	train_base_rel = rel_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
	elif mode == 6:
	train_base_abs = abs_datasets_sfm[train_num]
	train_base_rel = rel_synt_post_datasets[train_num]
	train_dataset_abs = train_base_abs + "..."
	train_dataset_rel = train_base_rel + "..."
	test_dataset_abs = train_base_abs + "..."
	test_dataset_rel = train_base_rel + "..."
	# ------------------------------------------------------------------------------------------------------------------- #

	# Creates the folders in which the results are saved
	currentDate = time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime())
	os.mkdir("../results/" + "%05d_" % (run_num) + str(currentDate))
	os.mkdir("../results/" + "%05d_" % (run_num) + str(currentDate) + "/weights/")
	# writes the current parameters in a file
	parameters = open("../results/" + "%05d_" % (run_num) + str(currentDate) + "/parameters.txt", "w")
	parameters.write("Modelname: flownet" + "\n" +
	"Dataset: " + str(train_num) + "\n" +
	"Timestamp: " + str(TIMESTAMP) + "\n" +
	"Iterations: " + str(ITERATIONS) + "\n" +
	"Batch size: " + str(batchSize) + "\n" +
	"Time_size: " + str(time_size) + "\n" +
	"Rnn_size: " + str(rnn_size) + "\n" +
	"Back_rotate: " + str(backrot) + "\n" +
	"Mode: " + str(mode) + "\n" +
	"Net name: " + str(net_name) + "\n" +
	"Stacks: " + str(stacks) + "\n")
	parameters.close()
	outputWeightspath = "../results/" + "%05d_" % (run_num) + str(currentDate) + "/weights/" + str(train_num) + '_BS_' + str(batchSize) + '_'
	log = open("../results/" + "%05d_" % (run_num) + str(currentDate) + "/log_" + str(train_num) + '_BS_' + str(batchSize) + '.txt', "w")


	def getError(posx, posq, actualx, actualq):
	""" Calculates the position and rotation error """
	q1 = actualq / np.linalg.norm(actualq)
	q2 = posq / np.linalg.norm(posq)
	d = abs(np.sum(np.multiply(q1, q2)))
	theta = 2 * np.arccos(d) * 180 / np.pi
	errx = np.linalg.norm(actualx - posx)
	return errx, theta


	def rmse_p(y_true, y_pred):
	return torch.sqrt(torch.sum(torch.square(y_pred-y_true), axis=-1))


	def rmse_q(y_true, y_pred):
	return BETA * torch.sqrt(torch.sum(torch.square(y_true-y_pred), axis=-1))


	class rmse_wrap(torch.nn.Module):
	""" Wrapper for dealing with the position loss and rotation loss. The rotation loss is multiplied with BETA. """
	def __init__(self):
	super(rmse_wrap, self).__init__()
	def __call__(self, output, target):
	loss1 = rmse_p(output[:, :3], target[:, :3])
	loss2 = rmse_q(output[:, 3:], target[:, 3:])
	return loss1 + loss2


	# For keeping track of the total run time
	s_time = time.time()
	# Loads the training/test data
	pred_abs, pred_rel, gt_abs, gt_rel = utilities.get_training_data(train_dataset_abs, train_dataset_rel, backrot)
	pred_abs_test, pred_rel_test, gt_abs_test, gt_rel_test = utilities.get_training_data(test_dataset_abs, test_dataset_rel, backrot)
	# Generator for creating batches of size batchSize
	data_gen = utilities.gen_data_batch(pred_abs, pred_rel, gt_abs, gt_rel, batchSize, time_size)
	optimizer = optim.Adam(model.parameters())
	criterion = rmse_wrap().to(device)
	# train for ITERATIONS
	for i in range(ITERATIONS):
	print(i)
	# Load the next batch and put in on the device
	X_batch, Y_batch = next(data_gen)
	X_batch = X_batch.transpose((1, 0, 2))
	X_batch = torch.tensor(X_batch)
	Y_batch = torch.from_numpy(Y_batch)
	inputs = X_batch.to(device)
	labels = Y_batch.to(device)
	# predict on the current input data
	preds = model(inputs).float()
	# Loss function
	cost = criterion(preds, labels).mean()
	optimizer.zero_grad()
	cost.backward(retain_graph=True)
	optimizer.step()
	model.zero_grad()
	model.detach_hidden()
	print(cost)
	if (i+1) % int(TIMESTAMP) == 0: # every TIMESTAMP steps: evaluate the network on the test data
	model.eval()
	hidden1_copy = model.cell1.hidden
	model.cell1.hidden = None
	if stacks == 2:
	hidden2_copy = model.cell2.hidden
	model.cell2.hidden = None
	# create a generator for the test data (Batchsize = 1)
	datagen = utilities.limited_gen_data(pred_abs_test, pred_rel_test, gt_abs_test, gt_rel_test, time_size)
	posxs = []
	posqs = []
	for ims, xs, qs in datagen: # Iterate over the test data and evaluate it
	inputs = np.zeros((1, time_size, 14)).astype("float32")
	inputs[0, :] = ims
	inputs = inputs.transpose((1, 0, 2))
	inputs = torch.tensor(inputs).to(device)
	out = model(inputs).float()
	posx = out[0][:3].detach().cpu().numpy()
	posq = out[0][3:].detach().cpu().numpy()
	actualx = xs
	actualq = qs
	errx, theta = getError(posx, posq, actualx, actualq)
	posxs.append(errx)
	posqs.append(theta)
	# Write the results into a file
	print('Median error ' + str(np.median(posxs)) + ' m and ' + str(np.nanmedian(posqs)) + ' degrees')
	log.write("Median error %f m and %f degrees \n" % (np.median(posxs), np.nanmedian(posqs)))
	log.flush()
	torch.save(model.state_dict(), outputWeightspath + str(i) + '.h5')
	model.cell1.hidden = hidden1_copy
	if stacks == 2:
	model.cell2.hidden = hidden2_copy
	model.train()
	print("Total time: ", time.time() - s_time)