648 lines
No EOL
31 KiB
Python
648 lines
No EOL
31 KiB
Python
# adapted from Trajectron++ online_server.py
|
||
import json
|
||
import logging
|
||
import os
|
||
import pathlib
|
||
import pickle
|
||
import random
|
||
import time
|
||
import warnings
|
||
from argparse import ArgumentParser, Namespace
|
||
from multiprocessing import Event
|
||
|
||
import dill
|
||
import numpy as np
|
||
import torch
|
||
import zmq
|
||
from trajectron.environment import Environment, Scene
|
||
from trajectron.model.model_registrar import ModelRegistrar
|
||
from trajectron.model.online.online_trajectron import OnlineTrajectron
|
||
from trajectron.utils import prediction_output_to_trajectories
|
||
|
||
from trap.frame_emitter import DataclassJSONEncoder, Frame
|
||
from trap.node import Node
|
||
from trap.tracker import Smoother
|
||
|
||
logger = logging.getLogger("trap.prediction")
|
||
|
||
|
||
# if not torch.cuda.is_available() or self.config.device == 'cpu':
|
||
# self.config.device = torch.device('cpu')
|
||
# else:
|
||
# if torch.cuda.device_count() == 1:
|
||
# # If you have CUDA_VISIBLE_DEVICES set, which you should,
|
||
# # then this will prevent leftover flag arguments from
|
||
# # messing with the device allocation.
|
||
# self.config.device = 'cuda:0'
|
||
|
||
# self.config.device = torch.device(self.config.device)
|
||
|
||
|
||
|
||
def create_online_env(env, hyperparams, scene_idx, init_timestep):
|
||
test_scene = env.scenes[scene_idx]
|
||
|
||
online_scene = Scene(timesteps=init_timestep + 1,
|
||
map=test_scene.map,
|
||
dt=test_scene.dt)
|
||
online_scene.nodes = test_scene.get_nodes_clipped_at_time(
|
||
timesteps=np.arange(init_timestep - hyperparams['maximum_history_length'],
|
||
init_timestep + 1),
|
||
state=hyperparams['state'])
|
||
online_scene.robot = test_scene.robot
|
||
online_scene.calculate_scene_graph(attention_radius=env.attention_radius,
|
||
edge_addition_filter=hyperparams['edge_addition_filter'],
|
||
edge_removal_filter=hyperparams['edge_removal_filter'])
|
||
|
||
return Environment(node_type_list=env.node_type_list,
|
||
standardization=env.standardization,
|
||
scenes=[online_scene],
|
||
attention_radius=env.attention_radius,
|
||
robot_type=env.robot_type)
|
||
|
||
|
||
def get_maps_for_input(input_dict, scene, hyperparams, device):
|
||
scene_maps = list()
|
||
scene_pts = list()
|
||
heading_angles = list()
|
||
patch_sizes = list()
|
||
nodes_with_maps = list()
|
||
for node in input_dict:
|
||
if node.type in hyperparams['map_encoder']:
|
||
x = input_dict[node]
|
||
me_hyp = hyperparams['map_encoder'][node.type]
|
||
if 'heading_state_index' in me_hyp:
|
||
heading_state_index = me_hyp['heading_state_index']
|
||
# We have to rotate the map in the opposit direction of the agent to match them
|
||
if type(heading_state_index) is list: # infer from velocity or heading vector
|
||
# heading_angle = -np.arctan2(x[-1, heading_state_index[1]],
|
||
# x[-1, heading_state_index[0]]) * 180 / np.pi
|
||
heading_angle = -np.arctan2(x[heading_state_index[1]],
|
||
x[heading_state_index[0]]) * 180 / np.pi
|
||
else:
|
||
heading_angle = -x[-1, heading_state_index] * 180 / np.pi
|
||
else:
|
||
heading_angle = None
|
||
|
||
scene_map = scene.map[node.type]
|
||
# map_point = x[-1, :2]
|
||
# map_point = x[:2]
|
||
map_point = x[:2].clip(0) # prevent crash for out of map point.
|
||
|
||
patch_size = hyperparams['map_encoder'][node.type]['patch_size']
|
||
|
||
scene_maps.append(scene_map)
|
||
scene_pts.append(map_point)
|
||
heading_angles.append(heading_angle)
|
||
patch_sizes.append(patch_size)
|
||
nodes_with_maps.append(node)
|
||
|
||
if heading_angles[0] is None:
|
||
heading_angles = None
|
||
else:
|
||
heading_angles = torch.Tensor(heading_angles)
|
||
|
||
# print(scene_maps, patch_sizes, heading_angles)
|
||
# print(scene_pts)
|
||
try:
|
||
maps = scene_maps[0].get_cropped_maps_from_scene_map_batch(scene_maps,
|
||
scene_pts=torch.Tensor(scene_pts),
|
||
patch_size=patch_sizes[0],
|
||
rotation=heading_angles,
|
||
device='cpu')
|
||
except Exception as e:
|
||
print(scene_maps)
|
||
logger.warning(f"Crash on getting maps for points: {scene_pts=} {heading_angles=} {patch_size=}")
|
||
raise e
|
||
|
||
maps_dict = {node: maps[[i]].to(device) for i, node in enumerate(nodes_with_maps)}
|
||
return maps_dict
|
||
|
||
|
||
# If homography is in cm, predictions can be terrible. Correct that here
|
||
# TODO)) This should actually not be here, but we should use alternative homography
|
||
# and then scale up in rendering
|
||
def history_cm_to_m(history):
|
||
return [(h[0]/100, h[1]/100) for h in history]
|
||
|
||
# TODO)) variable. Now placeholders for hof2 dataset
|
||
cx = 11.874955125
|
||
cy = 7.186118765
|
||
|
||
def prediction_m_to_cm(source):
|
||
# histories_dict[t][node]
|
||
for t in source:
|
||
for node in source[t]:
|
||
# source[t][node][:,0] += cx
|
||
# source[t][node][:,1] += cy
|
||
source[t][node] *= 100
|
||
# print(t,node, source[t][node])
|
||
return source
|
||
|
||
def offset_trajectron_dict(source, x, y):
|
||
# histories_dict[t][node]
|
||
for t in source:
|
||
for node in source[t]:
|
||
source[t][node][:,0] += x
|
||
source[t][node][:,1] += y
|
||
return source
|
||
|
||
class PredictionServer(Node):
|
||
def setup(self):
|
||
if self.config.eval_device == 'cpu':
|
||
logger.warning("Running on CPU. Specifying --eval_device cuda:0 should dramatically speed up prediction")
|
||
|
||
if self.config.smooth_predictions:
|
||
self.smoother = Smoother(window_len=12, convolution=True) # convolution seems fine for predictions
|
||
|
||
self.trajectory_socket = self.sub(self.config.zmq_trajectory_addr)
|
||
self.prediction_socket = self.pub(self.config.zmq_prediction_addr)
|
||
self.external_predictions = not self.config.zmq_prediction_addr.startswith("ipc://")
|
||
|
||
|
||
def send_frame(self, frame: Frame):
|
||
if self.external_predictions:
|
||
# data = json.dumps(frame, cls=DataclassJSONEncoder)
|
||
self.prediction_socket.send_json(obj=frame, cls=DataclassJSONEncoder)
|
||
else:
|
||
self.prediction_socket.send_pyobj(frame)
|
||
|
||
def run(self):
|
||
if self.config.seed is not None:
|
||
random.seed(self.config.seed)
|
||
np.random.seed(self.config.seed)
|
||
torch.manual_seed(self.config.seed)
|
||
if torch.cuda.is_available():
|
||
torch.cuda.manual_seed_all(self.config.seed)
|
||
|
||
# Choose one of the model directory names under the experiment/*/models folders.
|
||
# Possibilities are 'vel_ee', 'int_ee', 'int_ee_me', or 'robot'
|
||
# model_dir = os.path.join(self.config.log_dir, 'int_ee')
|
||
# model_dir = 'models/models_04_Oct_2023_21_04_48_eth_vel_ar3'
|
||
|
||
# Load hyperparameters from json
|
||
config_file = os.path.join(self.config.model_dir, self.config.conf)
|
||
if not os.path.exists(config_file):
|
||
raise ValueError('Config json not found!')
|
||
with open(config_file, 'r') as conf_json:
|
||
logger.info(f"Load config from {config_file}")
|
||
hyperparams = json.load(conf_json)
|
||
|
||
# Add hyperparams from arguments
|
||
hyperparams['dynamic_edges'] = self.config.dynamic_edges
|
||
hyperparams['edge_state_combine_method'] = self.config.edge_state_combine_method
|
||
hyperparams['edge_influence_combine_method'] = self.config.edge_influence_combine_method
|
||
hyperparams['edge_addition_filter'] = self.config.edge_addition_filter
|
||
hyperparams['edge_removal_filter'] = self.config.edge_removal_filter
|
||
hyperparams['batch_size'] = self.config.batch_size
|
||
hyperparams['k_eval'] = self.config.k_eval
|
||
hyperparams['offline_scene_graph'] = self.config.offline_scene_graph
|
||
hyperparams['incl_robot_node'] = self.config.incl_robot_node
|
||
hyperparams['edge_encoding'] = not self.config.no_edge_encoding
|
||
hyperparams['use_map_encoding'] = self.config.map_encoding
|
||
# hyperparams['maximum_history_length'] = 12 # test
|
||
|
||
logger.info(f"Use hyperparams: {hyperparams=}")
|
||
|
||
with open(self.config.eval_data_dict, 'rb') as f:
|
||
eval_env = dill.load(f, encoding='latin1')
|
||
|
||
logger.info('Loaded data from %s' % (self.config.eval_data_dict,))
|
||
|
||
# Creating a dummy environment with a single scene that contains information about the world.
|
||
# When using this code, feel free to use whichever scene index or initial timestep you wish.
|
||
scene_idx = 0
|
||
|
||
# You need to have at least acceleration, so you want 2 timesteps of prior data, e.g. [0, 1],
|
||
# so that you can immediately start incremental inference from the 3rd timestep onwards.
|
||
init_timestep = 2
|
||
|
||
eval_scene = eval_env.scenes[scene_idx]
|
||
logger.info(f"Basing online env on {eval_scene=} -- loaded from {self.config.eval_data_dict}")
|
||
online_env = create_online_env(eval_env, hyperparams, scene_idx, init_timestep)
|
||
|
||
# auto-find highest iteration
|
||
model_registrar = ModelRegistrar(self.config.model_dir, self.config.eval_device)
|
||
model_iterations = pathlib.Path(self.config.model_dir).glob('model_registrar-*.pt')
|
||
highest_iter = max([int(p.stem.split('-')[-1]) for p in model_iterations])
|
||
logger.info(f"Loading model {highest_iter}")
|
||
|
||
model_registrar.load_models(iter_num=highest_iter)
|
||
|
||
trajectron = OnlineTrajectron(model_registrar,
|
||
hyperparams,
|
||
self.config.eval_device)
|
||
|
||
# If you want to see what different robot futures do to the predictions, uncomment this line as well as
|
||
# related "... += adjustment" lines below.
|
||
# adjustment = np.stack([np.arange(13)/float(i*2.0) for i in range(6, 12)], axis=1)
|
||
|
||
# Here's how you'd incrementally run the model, e.g. with streaming data.
|
||
trajectron.set_environment(online_env, init_timestep)
|
||
|
||
timestep = init_timestep + 1
|
||
|
||
while self.run_loop():
|
||
|
||
|
||
# TODO: see process_data.py on how to create a node, the provide nodes + incoming data columns
|
||
# data_columns = pd.MultiIndex.from_product([['position', 'velocity', 'acceleration'], ['x', 'y']])
|
||
# x = node_values[:, 0]
|
||
# y = node_values[:, 1]
|
||
# vx = derivative_of(x, scene.dt)
|
||
# vy = derivative_of(y, scene.dt)
|
||
# ax = derivative_of(vx, scene.dt)
|
||
# ay = derivative_of(vy, scene.dt)
|
||
|
||
# data_dict = {('position', 'x'): x,
|
||
# ('position', 'y'): y,
|
||
# ('velocity', 'x'): vx,
|
||
# ('velocity', 'y'): vy,
|
||
# ('acceleration', 'x'): ax,
|
||
# ('acceleration', 'y'): ay}
|
||
|
||
# node_data = pd.DataFrame(data_dict, columns=data_columns)
|
||
# node = Node(node_type=env.NodeType.PEDESTRIAN, node_id=node_id, data=node_data)
|
||
if self.config.predict_training_data:
|
||
input_dict = eval_scene.get_clipped_input_dict(timestep, hyperparams['state'])
|
||
else:
|
||
zmq_ev = self.trajectory_socket.poll(timeout=2000)
|
||
if not zmq_ev:
|
||
# on no data loop so that is_running is checked
|
||
continue
|
||
|
||
t_init = time.time()
|
||
|
||
data = self.trajectory_socket.recv()
|
||
# print('recv tracker frame')
|
||
frame: Frame = pickle.loads(data)
|
||
|
||
# add settings to log
|
||
frame.log['predictor'] = {}
|
||
for option in ['prediction_horizon','num_samples','full_dist','gmm_mode','z_mode', 'model_dir']:
|
||
frame.log['predictor'][option] = self.config.__dict__[option]
|
||
|
||
|
||
# print('indexrecv', [frame.tracks[t].frame_index for t in frame.tracks])
|
||
# trajectory_data = {t.track_id: t.get_projected_history_as_dict(frame.H) for t in frame.tracks.values()}
|
||
# trajectory_data = json.loads(data)
|
||
# logger.debug(f"Receive {frame.index}")
|
||
|
||
# class FakeNode:
|
||
# def __init__(self, node_type: NodeType):
|
||
# self.type = node_type
|
||
|
||
input_dict = {}
|
||
for identifier, track in frame.tracks.items():
|
||
# if len(trajectory['history']) < 7:
|
||
# # TODO: these trajectories should still be in the output, but without predictions
|
||
# continue
|
||
|
||
# TODO: modify this into a mapping function between JS data an the expected Node format
|
||
# node = FakeNode(online_env.NodeType.PEDESTRIAN)
|
||
|
||
if self.config.step_size > 1:
|
||
if (len(track.history) % self.config.step_size) != 0:
|
||
# only add when having a new step
|
||
continue
|
||
track = track.get_sampled(self.config.step_size)
|
||
|
||
if len(track.history) < 2:
|
||
continue
|
||
|
||
node = track.to_trajectron_node(frame.camera, online_env)
|
||
# print(node.data.data[-1])
|
||
input_dict[node] = np.array(object=node.data.data[-1])
|
||
# print("history", node.data.data[-10:])
|
||
# print("get", node.get(np.array([frame.index-10,frame.index]), {'position': ['x', 'y']}))
|
||
|
||
# history = [[h['x'], h['y']] for h in track.get_projected_history_as_dict(frame.H, self.config.camera)]
|
||
# if self.config.cm_to_m:
|
||
# history = history_cm_to_m(history)
|
||
|
||
# history = np.array(history)
|
||
# x = history[:, 0] #- cx # we can create bigger steps by doing history[::5,0]
|
||
# y = history[:, 1] #- cy # history[::5,1]
|
||
# if self.config.center_data:
|
||
# x -= cx
|
||
# y -= cy
|
||
# # TODO: calculate dt based on input
|
||
# vx = derivative_of(x, .1) #eval_scene.dt
|
||
# vy = derivative_of(y, .1)
|
||
# ax = derivative_of(vx, .1)
|
||
# ay = derivative_of(vy, .1)
|
||
|
||
# data_dict = {('position', 'x'): x[:], # [-10:-1]
|
||
# ('position', 'y'): y[:], # [-10:-1]
|
||
# ('velocity', 'x'): vx[:], # [-10:-1]
|
||
# ('velocity', 'y'): vy[:], # [-10:-1]
|
||
# ('acceleration', 'x'): ax[:], # [-10:-1]
|
||
# ('acceleration', 'y'): ay[:]} # [-10:-1]
|
||
# data_columns = pd.MultiIndex.from_product([['position', 'velocity', 'acceleration'], ['x', 'y']])
|
||
|
||
# node_data = pd.DataFrame(data_dict, columns=data_columns)
|
||
# node = Node(
|
||
# node_type=online_env.NodeType.PEDESTRIAN,
|
||
# node_id=identifier,
|
||
# data=node_data,
|
||
# first_timestep=timestep
|
||
# )
|
||
|
||
# input_dict[node] = np.array(object=[x[-1],y[-1],vx[-1],vy[-1],ax[-1],ay[-1]])
|
||
|
||
# print(input_dict)
|
||
|
||
if not len(input_dict):
|
||
# skip if our input is empty
|
||
# TODO: we want to send out empty result...
|
||
# And want to update the network
|
||
|
||
# data = json.dumps({})
|
||
# TODO)) signal doing nothing
|
||
# TODO)) And update the network
|
||
self.send_frame(frame)
|
||
|
||
continue
|
||
|
||
maps = None
|
||
if hyperparams['use_map_encoding']:
|
||
maps = get_maps_for_input(input_dict, eval_scene, hyperparams, device=self.config.eval_device)
|
||
|
||
# print(maps)
|
||
|
||
# robot_present_and_future = None
|
||
# if eval_scene.robot is not None and hyperparams['incl_robot_node']:
|
||
# robot_present_and_future = eval_scene.robot.get(np.array([timestep,
|
||
# timestep + hyperparams['prediction_horizon']]),
|
||
# hyperparams['state'][eval_scene.robot.type],
|
||
# padding=0.0)
|
||
# robot_present_and_future = np.stack([robot_present_and_future, robot_present_and_future], axis=0)
|
||
# # robot_present_and_future += adjustment
|
||
|
||
start = time.time()
|
||
with warnings.catch_warnings():
|
||
warnings.simplefilter('ignore') # prevent deluge of UserWarning from torch's rrn.py
|
||
|
||
# in the OnlineMultimodalGenerativeCVAE (see trajectron.model.online_mgcvae.py) each node's distribution
|
||
# is put stored in self.latent.p_dist by OnlineMultimodalGenerativeCVAE.p_z_x(). Type: torch.distributions.OneHotCategorical
|
||
# Later sampling in discrete_latent.py: DiscreteLatent.sample_p()
|
||
# print(input_dict)
|
||
dists, preds = trajectron.incremental_forward(input_dict,
|
||
maps,
|
||
prediction_horizon=self.config.prediction_horizon, # TODO: make variable
|
||
num_samples=self.config.num_samples, # TODO: make variable
|
||
full_dist=self.config.full_dist, # "The mol’des full sampled output, where z and y are sampled sequentially"
|
||
gmm_mode=self.config.gmm_mode, # "If True: The mode of the Gaussian Mixture Model (GMM) is sampled (see trajectron.model.mgcvae.py)"
|
||
z_mode=self.config.z_mode # "Predictions from the model’s most-likely high-level latent behavior mode" (see trajecton.models.components.discrete_latent:sample_p(most_likely_z=z_mode))
|
||
)
|
||
|
||
# unsure what this bit from online_prediction.py does:
|
||
# detailed_preds_dict = dict()
|
||
# for node in eval_scene.nodes:
|
||
# if node in preds:
|
||
# detailed_preds_dict[node] = preds[node]
|
||
|
||
#adapted from trajectron.visualization
|
||
# prediction_dict provides the actual predictions
|
||
# histories_dict provides the trajectory used for prediction
|
||
# futures_dict is the Ground Truth, which is unvailable in an online setting
|
||
|
||
prediction_dict, histories_dict, futures_dict = prediction_output_to_trajectories({frame.index: preds},
|
||
eval_scene.dt,
|
||
hyperparams['maximum_history_length'],
|
||
hyperparams['prediction_horizon']
|
||
)
|
||
|
||
|
||
end = time.time()
|
||
logger.debug("took %.2f s (= %.2f Hz) w/ %d nodes and %d edges -- init: %.2f s" % (end - start,
|
||
1. / (end - start), len(trajectron.nodes),
|
||
trajectron.scene_graph.get_num_edges(), start-t_init))
|
||
|
||
# if self.config.center_data:
|
||
# prediction_dict, histories_dict, futures_dict = offset_trajectron_dict(prediction_dict, cx, cy), offset_trajectron_dict(histories_dict, cx, cy), offset_trajectron_dict(futures_dict, cx, cy)
|
||
# print('pred timesteps', list(prediction_dict.keys()))
|
||
# print('histories', [n.data.data.shape[0] for n in prediction_dict[frame.index].keys()])
|
||
if self.config.cm_to_m:
|
||
# convert back to fit homography
|
||
prediction_dict, histories_dict, futures_dict = prediction_m_to_cm(prediction_dict), prediction_m_to_cm(histories_dict), prediction_m_to_cm(futures_dict)
|
||
|
||
|
||
assert(len(prediction_dict.keys()) <= 1)
|
||
if len(prediction_dict.keys()) == 0:
|
||
return
|
||
ts_key = list(prediction_dict.keys())[0]
|
||
|
||
prediction_dict = prediction_dict[ts_key]
|
||
histories_dict = histories_dict[ts_key]
|
||
futures_dict = futures_dict[ts_key]
|
||
|
||
response = {}
|
||
logger.debug(f"{histories_dict=}")
|
||
for node in histories_dict:
|
||
history = histories_dict[node]
|
||
# future = futures_dict[node] # ground truth dict
|
||
predictions = prediction_dict[node]
|
||
# print('preds', len(predictions[0][0]))
|
||
|
||
if not len(history) or np.isnan(history[-1]).any():
|
||
logger.warning('skip for no history')
|
||
continue
|
||
|
||
# response[node.id] = {
|
||
# 'id': node.id,
|
||
# 'det_conf': trajectory_data[node.id]['det_conf'],
|
||
# 'bbox': trajectory_data[node.id]['bbox'],
|
||
# 'history': history.tolist(),
|
||
# 'predictions': predictions[0].tolist() # use batch 0
|
||
# }
|
||
|
||
|
||
frame.tracks[node.id].predictor_history = history.tolist() #node.data[:,{'position': ['x', 'y']}].tolist()
|
||
frame.tracks[node.id].predictions = predictions[0].tolist() # use batch 0
|
||
|
||
# data = json.dumps(response)
|
||
if self.config.predict_training_data:
|
||
logger.info(f"Frame prediction: {len(trajectron.nodes)} nodes & {trajectron.scene_graph.get_num_edges()} edges. Trajectron: {end - start}s")
|
||
else:
|
||
logger.debug(f"Total frame delay = {time.time()-frame.time}s ({len(trajectron.nodes)} nodes & {trajectron.scene_graph.get_num_edges()} edges. Trajectron: {end - start}s)")
|
||
|
||
if self.config.smooth_predictions:
|
||
frame = self.smoother.smooth_frame_predictions(frame)
|
||
|
||
frame.maps = list([m.cpu().numpy() for m in maps.values()]) if maps else None
|
||
|
||
# print('index', [frame.tracks[t].frame_index for t in frame.tracks])
|
||
|
||
self.send_frame(frame)
|
||
|
||
logger.info('Stopping')
|
||
|
||
@classmethod
|
||
def arg_parser(cls) -> ArgumentParser:
|
||
inference_parser = ArgumentParser()
|
||
inference_parser.add_argument('--zmq-trajectory-addr',
|
||
help='Manually specity communication addr for the trajectory messages',
|
||
type=str,
|
||
default="ipc:///tmp/feeds_traj")
|
||
inference_parser.add_argument('--zmq-prediction-addr',
|
||
help='Manually specity communication addr for the prediction messages',
|
||
type=str,
|
||
default="ipc:///tmp/feeds_preds")
|
||
|
||
|
||
inference_parser.add_argument("--step-size",
|
||
# TODO)) Make dataset/model metadata
|
||
help="sample step size (should be the same as for data processing and augmentation)",
|
||
type=int,
|
||
default=1,
|
||
)
|
||
inference_parser.add_argument("--model_dir",
|
||
help="directory with the model to use for inference",
|
||
type=str, # TODO: make into Path
|
||
default='../Trajectron-plus-plus/experiments/trap/models/models_18_Oct_2023_19_56_22_virat_vel_ar3/')
|
||
# default='../Trajectron-plus-plus/experiments/pedestrians/models/models_04_Oct_2023_21_04_48_eth_vel_ar3')
|
||
|
||
inference_parser.add_argument("--conf",
|
||
help="path to json config file for hyperparameters, relative to model_dir",
|
||
type=str,
|
||
default='config.json')
|
||
|
||
# Model Parameters (hyperparameters)
|
||
inference_parser.add_argument("--offline_scene_graph",
|
||
help="whether to precompute the scene graphs offline, options are 'no' and 'yes'",
|
||
type=str,
|
||
default='yes')
|
||
|
||
inference_parser.add_argument("--dynamic_edges",
|
||
help="whether to use dynamic edges or not, options are 'no' and 'yes'",
|
||
type=str,
|
||
default='yes')
|
||
|
||
inference_parser.add_argument("--edge_state_combine_method",
|
||
help="the method to use for combining edges of the same type",
|
||
type=str,
|
||
default='sum')
|
||
|
||
inference_parser.add_argument("--edge_influence_combine_method",
|
||
help="the method to use for combining edge influences",
|
||
type=str,
|
||
default='attention')
|
||
|
||
inference_parser.add_argument('--edge_addition_filter',
|
||
nargs='+',
|
||
help="what scaling to use for edges as they're created",
|
||
type=float,
|
||
default=[0.25, 0.5, 0.75, 1.0]) # We don't automatically pad left with 0.0, if you want a sharp
|
||
# and short edge addition, then you need to have a 0.0 at the
|
||
# beginning, e.g. [0.0, 1.0].
|
||
|
||
inference_parser.add_argument('--edge_removal_filter',
|
||
nargs='+',
|
||
help="what scaling to use for edges as they're removed",
|
||
type=float,
|
||
default=[1.0, 0.0]) # We don't automatically pad right with 0.0, if you want a sharp drop off like
|
||
# the default, then you need to have a 0.0 at the end.
|
||
|
||
|
||
inference_parser.add_argument('--incl_robot_node',
|
||
help="whether to include a robot node in the graph or simply model all agents",
|
||
action='store_true')
|
||
|
||
inference_parser.add_argument('--map_encoding',
|
||
help="Whether to use map encoding or not",
|
||
action='store_true')
|
||
|
||
inference_parser.add_argument('--no_edge_encoding',
|
||
help="Whether to use neighbors edge encoding",
|
||
action='store_true')
|
||
|
||
|
||
inference_parser.add_argument('--batch_size',
|
||
help='training batch size',
|
||
type=int,
|
||
default=256)
|
||
|
||
inference_parser.add_argument('--k_eval',
|
||
help='how many samples to take during evaluation',
|
||
type=int,
|
||
default=25)
|
||
|
||
# Data Parameters
|
||
inference_parser.add_argument("--eval_data_dict",
|
||
help="what file to load for evaluation data (WHEN NOT USING LIVE DATA)",
|
||
type=str,
|
||
default='../Trajectron-plus-plus/experiments/processed/eth_test.pkl')
|
||
|
||
inference_parser.add_argument("--output_dir",
|
||
help="what dir to save output (i.e., saved models, logs, etc) (WHEN NOT USING LIVE OUTPUT)",
|
||
type=pathlib.Path,
|
||
default='./OUT/test_inference')
|
||
|
||
|
||
# inference_parser.add_argument('--device',
|
||
# help='what device to perform training on',
|
||
# type=str,
|
||
# default='cuda:0')
|
||
|
||
inference_parser.add_argument("--eval_device",
|
||
help="what device to use during inference",
|
||
type=str,
|
||
default="cpu")
|
||
|
||
|
||
inference_parser.add_argument('--seed',
|
||
help='manual seed to use, default is 123',
|
||
type=int,
|
||
default=123)
|
||
|
||
inference_parser.add_argument('--predict_training_data',
|
||
help='Ignore tracker and predict data from the training dataset',
|
||
action='store_true')
|
||
|
||
inference_parser.add_argument("--smooth-predictions",
|
||
help="Smooth the predicted tracks",
|
||
action='store_true')
|
||
|
||
inference_parser.add_argument('--prediction-horizon',
|
||
help='Trajectron.incremental_forward parameter',
|
||
type=int,
|
||
default=30)
|
||
inference_parser.add_argument('--num-samples',
|
||
help='Trajectron.incremental_forward parameter',
|
||
type=int,
|
||
default=5)
|
||
inference_parser.add_argument("--full-dist",
|
||
help="Trajectron.incremental_forward parameter",
|
||
action='store_true')
|
||
inference_parser.add_argument("--gmm-mode",
|
||
help="Trajectron.incremental_forward parameter",
|
||
type=bool,
|
||
default=True)
|
||
inference_parser.add_argument("--z-mode",
|
||
help="Trajectron.incremental_forward parameter",
|
||
action='store_true')
|
||
inference_parser.add_argument('--cm-to-m',
|
||
help="Correct for homography that is in cm (i.e. {x,y}/100). Should also be used when processing data",
|
||
action='store_true')
|
||
inference_parser.add_argument('--center-data',
|
||
help="Center data around cx and cy. Should also be used when processing data",
|
||
action='store_true')
|
||
|
||
|
||
return inference_parser
|
||
|
||
|
||
|
||
def run_prediction_server(config: Namespace, is_running: Event, timer_counter):
|
||
|
||
# attempt to trace the warnings coming from pytorch
|
||
# def warn_with_traceback(message, category, filename, lineno, file=None, line=None):
|
||
|
||
# log = file if hasattr(file,'write') else sys.stderr
|
||
# traceback.print_stack(file=log)
|
||
# log.write(warnings.formatwarning(message, category, filename, lineno, line))
|
||
|
||
# warnings.showwarning = warn_with_traceback
|
||
s = PredictionServer(config, is_running)
|
||
s.run(timer_counter) |