def _start_renderer_clients(self):
from rmp_nav.simulation.gibson2_sim_client import Gibson2SimClient
# There are issues when I let each renderer client create its own context and socket when
# there are large number of environments. In practice one context and socket is sufficient.
self.rc_context = zmq.Context()
for map_name, servers in self.sim_servers.items():
if map_name == 'all':
# This server can handle all maps. We need to set client's to make sure
# requests are correctly routed.
for sim_proc, addr in servers:
socket = self.rc_context.socket(zmq.REQ)
socket.connect(addr)
for identity in self.map_names:
client = Gibson2SimClient(self.rc_context, socket)
client.start(create_server=False,
server_addr=addr,
identity=identity.encode())
if identity not in self.sim_clients:
self.sim_clients[identity] = []
self.sim_clients[identity].append(client)
else:
if map_name not in self.sim_clients:
self.sim_clients[map_name] = []
for sim_proc, addr in servers:
client = Gibson2SimClient(self.rc_context, self.rc_socket)
client.start(create_server=False, server_addr=addr)
self.sim_clients[map_name].append(client)
print('started renderer clients:\n%s' % pprint_dict(self.sim_clients))
def __repr__(self):
return pprint_dict({
'scene_id': self.scene_id,
'create_server': self.create_server,
'server_addr': self.server_addr,
'identity': self.identity
})
def _start_renderer_clients(self):
from rmp_nav.simulation.gibson_sim_client import GibsonSimClient
for map_name, servers in self.sim_servers.items():
if map_name == 'all':
# This server can handle all maps. We need to set client's to make sure
# requests are correctly routed.
for sim_proc, addr in servers:
for identity in self.map_names:
client = GibsonSimClient()
client.start(create_server=False,
server_addr=addr,
identity=identity.encode())
if identity not in self.sim_clients:
self.sim_clients[identity] = []
self.sim_clients[identity].append(client)
else:
if map_name not in self.sim_clients:
self.sim_clients[map_name] = []
for sim_proc, addr in servers:
client = GibsonSimClient()
client.start(create_server=False, server_addr=addr)
self.sim_clients[map_name].append(client)
print('started renderer clients:\n%s' % pprint_dict(self.sim_clients))
def __repr__(self):
return pprint_dict({
'subsample_factor': self.subsample_factor,
'delta_tl': self.delta_tl,
'delta_tw': self.delta_tw,
's_shortcut': self.s_shortcut,
'number of nodes': len(self.graph.nodes),
'number of edges': len(self.graph.edges)
})
def frontend():
sparsify_thres = 0.99
model = model_factory.get(FLAGS.model)(device=FLAGS.device,
**str_to_dict(
FLAGS.model_param))
print('model:\n%s' % pprint_dict(model))
if 'naive' in FLAGS.model:
nav_graph = NavGraphSPTM.from_save_file(model['sparsifier'],
model['motion_policy'],
FLAGS.graph_save_file)
else:
nav_graph = NavGraph.from_save_file(model['sparsifier'],
model['motion_policy'],
sparsify_thres,
FLAGS.graph_save_file)
if FLAGS.graph_subset_ratio < 1.0:
nav_graph.set_subset_ratio(FLAGS.graph_subset_ratio)
env_name = nav_graph.extra['env']
agent = agent_factory.agents_dict[model['agent']]()
dataset = eval_envs.make(env_name, model['sparsifier'])
map_name = dataset.map_names[0]
map = _make_maps([map_name])[0]
dataset._init_once(0)
agent.set_map(map)
vis = make_vis(map, agent) if FLAGS.visualize else None
if FLAGS.task == 'plan_to_dest_single':
start_pos = np.array(
[float(_) for _ in FLAGS.start_pos.split(',')], np.float32)
exec_plan_to_destination(
model,
nav_graph,
start_pos=start_pos,
start_heading=np.deg2rad(FLAGS.start_heading),
goal=eval(FLAGS.goal),
map=map,
dataset=dataset,
agent=agent,
replan_dead_reckon_count=FLAGS.replan_dead_reckon_count,
online_planning=FLAGS.online_planning,
path_vis_dir=None,
path_vis_file=None,
vis=vis,
screenshot_dir=FLAGS.screenshot_dir)
else:
print('Unknown task: %s' % FLAGS.task)
exit(0)
def start_renderer_servers(self):
# Start local servers
self._start_renderer_servers_local()
# Add persistent servers
for map_name, addrs in self.persistent_servers.items():
if map_name not in self.sim_servers and len(addrs) > 0:
self.sim_servers[map_name] = []
for addr in addrs:
self.sim_servers[map_name].append((None, addr))
print('started renderer servers:\n%s' % pprint_dict(self.sim_servers))
def __repr__(self):
return pprint_dict({
'edge_add_thres': self.edge_add_thres,
'reuse_thres': self.reuse_thres,
'reuse_edge_prob_mode': self.reuse_edge_prob_mode,
'reuse_terminal_nodes': self.reuse_terminal_nodes,
'reuse_start_nodes': self.reuse_start_nodes,
'reuse_goal_nodes': self.reuse_goal_nodes,
'delta_tw': self.delta_tw,
'number of nodes': len(self.graph.nodes),
'number of edges': len(self.graph.edges)
})
def _load(self, weights_file, device):
state_dict = torch.load(weights_file, map_location='cpu')
print('loaded %s' % weights_file)
g = state_dict.get('global_args', {})
print('global args:')
print(pprint_dict(g))
self.g = g
self.weights_file = weights_file
if isinstance(g.model_spec, dict):
nets = make_nets(g.model_spec, device)
else:
nets = make_nets(
yaml.load(open(g.model_spec).read(), Loader=yaml.SafeLoader),
device)
for name, net in nets.items():
net.load_state_dict(state_dict['nets'][name])
net.train(False)
self.nets = nets
def __repr__(self):
return pprint_dict({
'search_thres': self.search_thres,
'follow_thres': self.follow_thres
})
import gflags
import sys
import yaml
from topological_nav.reachability import model_factory
from topological_nav.tools import eval_envs
gflags.DEFINE_string('env', '', '')
gflags.DEFINE_string('graph_config', '', '')
gflags.DEFINE_string('save_file', '', '')
gflags.DEFINE_string('device', 'cuda', '')
FLAGS = gflags.FLAGS
FLAGS(sys.argv)
graph_config = yaml.load(open(FLAGS.graph_config).read(), Loader=yaml.SafeLoader)
print('graph_config:\n%s' % pprint_dict(graph_config))
model = model_factory.get(graph_config['model'])(device=FLAGS.device)
graph_type = graph_config.get('type', 'ours')
if graph_type == 'ours':
nav_graph = NavGraph(model['sparsifier'], model['motion_policy'], **graph_config['graph_kwargs'])
elif graph_type == 'SPTM':
nav_graph = NavGraphSPTM(model['sparsifier'], model['motion_policy'], **graph_config['graph_kwargs'])
else:
raise RuntimeError('Unknown graph type: %s' % graph_type)
data_source = graph_config.get('data_source', 'gibson')
if data_source == 'gibson':
def __repr__(self):
return '%s options\n%s' % (self.__class__.__name__, pprint_dict(
self.g))
