Esempio n. 1
0
    def load_data(self, data):
        self.gt = {}
        self.instr_ids = []
        scans = []
        for item in data:
            self.gt[str(item['path_id'])] = item
            if isinstance(item['path_id'], int):
                self.instr_ids.extend([
                    '%d_%d' % (item['path_id'], i)
                    for i in range(len(item['instructions']))
                ])
            else:
                self.instr_ids.extend([
                    '%s_%d' % (item['path_id'], i)
                    for i in range(len(item['instructions']))
                ])
            scans.append(item['scan'])
        self.instr_ids = set(self.instr_ids)
        scans = set(scans)

        new_scans = set.difference(scans, self.scans)
        if new_scans:
            for scan in new_scans:
                self.graphs[scan] = load_nav_graphs(scan)
                self.distances[scan] = dict(
                    nx.all_pairs_dijkstra_path_length(self.graphs[scan]))
        self.scans.update(new_scans)
Esempio n. 2
0
    def __init__(self, splits, path_type='planner_path'):
        self.error_margin = 3.0
        self.splits = splits
        self.gt = {}
        self.instr_ids = []
        self.scans = []
        for item in load_datasets(splits):
            self.gt[item['inst_idx']] = item
            self.instr_ids.append(item['inst_idx'])
            self.scans.append(item['scan'])

            # Add 'trusted_path' to gt metadata if necessary.
            if path_type == 'trusted_path':
                planner_goal = item['planner_path'][-1]
                if planner_goal in item['player_path'][1:]:
                    self.gt[item['inst_idx']]['trusted_path'] = item[
                        'player_path'][:]
                else:
                    self.gt[item['inst_idx']]['trusted_path'] = item[
                        'planner_path'][:]

        self.scans = set(self.scans)
        self.instr_ids = set(self.instr_ids)
        self.graphs = load_nav_graphs(self.scans)
        self.distances = {}
        self.path_type = path_type
        for scan, G in self.graphs.iteritems():  # compute all shortest paths
            self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 3
0
 def _compute_shortest_paths(self, scan, path=None):
     ''' Load connectivity graph for each scan, useful for reasoning about shortest paths '''
     graph = utils.load_nav_graphs(scan, path=path)
     paths = dict(
         nx.all_pairs_dijkstra_path(graph))  # paths from graph of scan
     distances = dict(nx.all_pairs_dijkstra_path_length(
         graph))  # distances for respective paths
     return graph, paths, distances
Esempio n. 4
0
 def _load_nav_graphs(self):
     ''' Load connectivity graph for each scan, useful for reasoning about shortest paths '''
     print 'Loading navigation graphs for %d scans' % len(self.scans)
     self.graphs = load_nav_graphs(self.scans)
     self.paths = {}
     for scan,G in self.graphs.iteritems(): # compute all shortest paths
         self.paths[scan] = dict(nx.all_pairs_dijkstra_path(G))
     self.distances = {}
     for scan,G in self.graphs.iteritems(): # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 5
0
 def _load_nav_graphs(self):
     """ Load connectivity graph for each scan, useful for reasoning about shortest paths """
     print('Loading navigation graphs for %d scans' % len(self.scans))
     self.graphs = load_nav_graphs(self.scans)
     self.paths = {}
     for scan, G in self.graphs.items():  # compute all shortest paths
         self.paths[scan] = dict(nx.all_pairs_dijkstra_path(G))
     self.distances = {}
     for scan, G in self.graphs.items():  # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 6
0
 def __init__(self, splits):
     self.error_margin = 3.0
     self.splits = splits
     self.gt = {}
     self.instr_ids = []
     self.scans = []
     for item in load_datasets(splits):
         self.gt[item['path_id']] = item
         self.scans.append(item['scan'])
         self.instr_ids += ['%d_%d' % (item['path_id'],i) for i in range(3)]
     self.scans = set(self.scans)
     self.instr_ids = set(self.instr_ids)
     self.graphs = load_nav_graphs(self.scans)
     self.distances = {}
     for scan,G in self.graphs.items(): # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 7
0
 def __init__(self, splits):
     self.error_margin = 3.0
     self.splits = splits
     self.gt = {}
     self.instr_ids = []
     self.scans = []
     for item in load_datasets(splits):
         self.gt[item['path_id']] = item
         self.scans.append(item['scan'])
         self.instr_ids += ['%d_%d' % (item['path_id'],i) for i in range(3)]
     self.scans = set(self.scans)
     self.instr_ids = set(self.instr_ids)
     self.graphs = load_nav_graphs(self.scans)
     self.distances = {}
     for scan,G in self.graphs.iteritems(): # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 8
0
 def _load_nav_graphs(self):
     """
     load graph from self.scan,
     Store the graph {scan_id: graph} in self.graphs
     Store the shortest path {scan_id: {view_id_x: {view_id_y: [path]} } } in self.paths
     Store the distances in self.distances. (Structure see above)
     Load connectivity graph for each scan, useful for reasoning about shortest paths
     :return: None
     """
     print('Loading navigation graphs for %d scans' % len(self.scans))
     self.graphs = load_nav_graphs(self.scans)
     self.paths = {}
     for scan, G in self.graphs.items(): # compute all shortest paths
         self.paths[scan] = dict(nx.all_pairs_dijkstra_path(G))
     self.distances = {}
     for scan, G in self.graphs.items(): # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 9
0
 def __init__(self, splits, path_type='planner_path'):
     self.error_margin = 3.0
     self.splits = splits
     self.gt = {}
     self.instr_ids = []
     self.scans = []
     for item in load_datasets(splits):
         self.gt[item['inst_idx']] = item
         self.instr_ids.append(item['inst_idx'])
         self.scans.append(item['scan'])
     self.scans = set(self.scans)
     self.instr_ids = set(self.instr_ids)
     self.graphs = load_nav_graphs(self.scans)
     self.distances = {}
     self.path_type = path_type
     for scan, G in self.graphs.iteritems():  # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 10
0
 def __init__(self, splits, encoder_type):  # , subgoal):
     self.error_margin = 3.0
     self.splits = splits
     self.gt = {}
     self.instr_ids = []
     self.scans = []
     for item in load_datasets(splits,
                               "lstm"):  # no matter what encoder type ?
         self.gt[item["path_id"]] = item
         self.scans.append(item["scan"])
         self.instr_ids += [
             "%d_%d" % (item["path_id"], i) for i in range(3)
         ]
     self.scans = set(self.scans)
     self.instr_ids = set(self.instr_ids)
     self.graphs = load_nav_graphs(self.scans)
     self.distances = {}
     for scan, G in self.graphs.items():  # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 11
0
 def __init__(self, splits, scans, tok):
     self.error_margin = 3.0
     self.splits = splits
     self.tok = tok
     self.gt = {}
     self.instr_ids = []
     self.scans = []
     for split in splits:
         for item in load_datasets([split]):
             if scans is not None and item['scan'] not in scans:
                 continue
             self.gt[str(item['path_id'])] = item
             self.scans.append(item['scan'])
             self.instr_ids += ['%s_%d' % (item['path_id'], i) for i in range(len(item['instructions']))]
     self.scans = set(self.scans)
     self.instr_ids = set(self.instr_ids)
     self.graphs = load_nav_graphs(self.scans)
     self.distances = {}
     for scan,G in self.graphs.items(): # compute all shortest paths
         self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 12
0
    def __init__(self, args, splits=['train']):

        self.args = args

        # Check for vocabs, build if necessary
        if not os.path.exists(self.args.train_vocab):
            tu.write_vocab(
                tu.build_vocab(self.args.data_dir, splits=["train"]),
                self.args.train_vocab,
            )
        if not os.path.exists(self.args.trainval_vocab):
            tu.write_vocab(
                tu.build_vocab(self.args.data_dir, splits=["train", "val_seen", "val_unseen"]),
                self.args.trainval_vocab,
            )

        # Load vocab and set tokenizer etc
        if self.args.train_split == 'trainval':
            self.vocab = tu.read_vocab(self.args.trainval_vocab)
        else:
            self.vocab = tu.read_vocab(self.args.train_vocab)
        self.args.vocab_size = len(self.vocab)
        self.tokenizer = tu.Tokenizer(self.vocab, self.args.max_input_length)

        # Load training and val data
        # data: [{"scan", "instr_id", "path", "heading", "instruction",  "encoding", "xyzhe"}]
        self.data = []
        self.scans = []
        for item in tu.load_datasets(self.args.data_dir, splits):
            # Split multiple instructions into separate entries
            for j,instr in enumerate(item['instructions']):
                self.scans.append(item['scan'])
                train_obj = {
                    'heading': item['heading'],
                    'scan': item['scan'],
                    'instruction': instr,
                    'instr_id': '%d_%d' % (item['path_id'], j),
                    'encoding': self.text_to_encoding(instr),
                    'path': item['path']
                }
                self.data.append(train_obj)
        self.scans = set(self.scans)
        self.splits = splits
        random.shuffle(self.data)
        self.reset_epoch()
        print('Loaded %d data tuples from %s' % (len(self.data), self.splits))

        # Load connectivity graph for each scan, useful for reasoning about shortest paths
        print('Loading navigation graphs for %d scans' % len(self.scans))
        self.graphs = load_nav_graphs(self.scans)
        self.paths = {}
        for scan,G in self.graphs.items(): # compute all shortest paths
            self.paths[scan] = dict(nx.all_pairs_dijkstra_path(G))
        self.distances = {}
        for scan,G in self.graphs.items(): # compute all shortest paths
            self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))

        # Pre-calculate the position and heading along each path
        for item in self.data:
            G = self.graphs[item['scan']]
            item['xyzhe'] = xyzhe_from_viewpoints(G, item['path'], item['heading'])
Esempio n. 13
0
    def __init__(
        self,
        splits,
        sim=None,
        args=None,
    ):

        prefix = args.prefix
        error_margin = args.error_margin
        add_asterix = args.add_asterix

        self.error_margin = error_margin
        self.splits = splits
        self.gt = {}
        self.instr_ids = []
        self.scans = []
        self.instructions = {}
        counts = defaultdict(int)

        if prefix in ['r2r', 'R2R'] or 'RxR' in prefix:
            instr_key = 'path_id'
        elif prefix == 'REVERIE':
            instr_key = 'id'
        else:
            raise NotImplementedError(
                'dataset prefix {} not implemented'.format(prefix))

        for item in load_datasets(splits, prefix=prefix):
            path_id = item[instr_key]
            count = counts[path_id]
            counts[path_id] += 1
            if add_asterix:
                new_path_id = '{}*{}'.format(path_id, count)
                item['path_id'] = new_path_id

            self.gt['{}'.format(item[instr_key])] = item
            self.scans.append(item['scan'])
            if prefix == 'R2R':
                self.instr_ids += [
                    '{}_{}'.format(item[instr_key], i) for i in range(3)
                ]
            elif 'RxR' in prefix:
                self.instr_ids += [
                    '{}_{}'.format(item[instr_key], i) for i in range(1)
                ]
            elif 'REVERIE' == prefix:
                self.instr_ids += [
                    '{}_{}'.format(item[instr_key], i)
                    for i in range(len(item['instructions']))
                ]
#        pdb.set_trace()
            else:
                raise NotImplementedError()
            for j, instruction in enumerate(item['instructions']):
                self.instructions['{}_{}'.format(item[instr_key],
                                                 j)] = instruction
        self.scans = set(self.scans)
        self.instr_ids = set(self.instr_ids)
        self.graphs = load_nav_graphs(self.scans)
        self.distances = {}
        for scan, G in self.graphs.items():  # compute all shortest paths
            self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
Esempio n. 14
0
                    cnt[x] += 1
    return cnt['lost'] / total * 100, cnt['uncertain_wrong'] / total * 100, \
           cnt['already_asked'] / total * 100


data_path = '../../../data'

graphs = {}
distances = {}

with open(os.path.join(data_path, 'hanna/scan_split.json')) as f:
    scan_split = json.load(f)

for split in ['train', 'val', 'test']:
    for scan in scan_split[split]:
        graphs[scan] = load_nav_graphs(scan)
        distances[scan] = dict(nx.all_pairs_dijkstra_path_length(graphs[scan]))

filename = sys.argv[1]

with open(filename) as f:
    data = json.load(f)

print('Success rate: %.2f' % success_rate(data))
print('SPL: %.2f' % spl_score(data))
print('Navigation error: %.2f' % navigation_error(data))
print('Requests: %.1f' % num_requests(data))
print('Nav mistake repeat: %.2f' % nav_mistake_repeat(data))
print('Ask repeat: %.2f' % ask_repeat(data))
for reason in ['lost', 'uncertain_wrong', 'already_asked']:
    print_values = (reason, ) + reason_metrics(data, reason)