Пример #1
0
 def get_edges(self):
     return graph_utils.get_edges(self.G, self.id2idx)
Пример #2
0
    def load_graph_data(self, all_data_cats, seen_train_cats, data_name):

        self.all_cats_embed = self.all_cats_embed.to(self.device)

        if self.args.model in ['fast0tag', 'logistic']:
            self.all_train_names = seen_train_cats
            self.all_test_names = all_data_cats

            self.train_cats_embed = get_word_vectors(self.all_train_names, sep="_").to(self.device)
            self.test_cats_embed = get_word_vectors(self.all_test_names, sep="_").to(self.device)

            self.n_train = len(self.all_train_names)
            self.n_test = len(self.all_test_names)

            self.n_cats_train = len(seen_train_cats)
            self.n_cats_all = len(all_data_cats)
            self.n_cats_seen = len(seen_train_cats)
            self.n_cats_unseen = self.n_cats_all - self.n_cats_seen

            self.imgnet_idx = None

            self.adj_matrix_train = None
            self.adj_matrix_test = None

            self.edges_train = None
            self.edges_test = None

            return

        logger = self.log_master.get_logger("data")
        logger.info("load and building graph...")

        if self.args.model == 'skg':
            self.edges_train, self.mat_ids_train = get_edges(seen_train_cats, data_name, neg=self.args.wup_neg, pos=self.args.wup_pos,
                                                             node_dim=self.args.d_dim)
            self.edges_train = [(u.cuda(), v.cuda()) for u, v in self.edges_train]
            self.mat_ids_train = [e.cuda() for e in self.mat_ids_train]

            self.edges_test, self.mat_ids_test = get_edges(all_data_cats, data_name, neg=self.args.wup_neg, pos=self.args.wup_pos,
                                                           node_dim=self.args.d_dim)
            self.edges_test = [(u.cuda(), v.cuda()) for u, v in self.edges_test]
            self.mat_ids_test = [e.cuda() for e in self.mat_ids_test]

            self.n_cats_all = len(all_data_cats)
            self.n_cats_seen = len(seen_train_cats)
            self.n_cats_unseen = self.n_cats_all - self.n_cats_seen
            self.imgnet_idx = None

            self.train_cats_embed = self.all_cats_embed[self.cats_split['seen']]
            self.test_cats_embed = self.all_cats_embed

            return

        if not self.args.use_imgnet:
            self.args.imgnet_meta = None

        is_skg = self.args.model == "skg-posvae"

        if self.args.model in ['ggnn', 'skg', "skg-posvae"]:
            node_dim = self.args.d_dim
        else:
            node_dim = 5

        train_graph_meta = load_graph(seen_train_cats, self.args.imgnet_meta, self.args.wup_neg, self.args.wup_pos,
                                      binary=False, to_dense=True, data_name=data_name, node_dim=node_dim, skg=is_skg)

        test_graph_meta = load_graph(all_data_cats, self.args.imgnet_meta, self.args.wup_neg, self.args.wup_pos,
                                     binary=False, to_dense=True, data_name=data_name, node_dim=node_dim, skg=is_skg)
        logger.info("done")

        self.all_train_names = train_graph_meta["names"]
        self.all_test_names = test_graph_meta["names"]

        self.imgnet_idx = test_graph_meta["imgnet_idx"].to(self.device)

        if is_skg:
            self.edges_train = [(u.cuda(), v.cuda()) for u, v in train_graph_meta["edges"]]
            self.mat_ids_train = [e.cuda() for e in train_graph_meta["mat"]]
            self.edges_test = [(u.cuda(), v.cuda()) for u, v in test_graph_meta["edges"]]
            self.mat_ids_test = [e.cuda() for e in test_graph_meta["mat"]]
        else:
            self.adj_matrix_train = train_graph_meta["adj_wup_pos"].to(self.device).view(-1, 1)
            self.adj_matrix_test = test_graph_meta["adj_wup_pos"].to(self.device).view(-1, 1)

            self.edges_train = train_graph_meta["edges"][0].to(self.device)
            self.edges_test = test_graph_meta["edges"][0].to(self.device)
            self.edges_w_train = train_graph_meta["adj_wup_pos"].to(self.device)
            self.edges_w_test = test_graph_meta["adj_wup_pos"].to(self.device)
            self.edge_vars_train = train_graph_meta["edges"]
            self.edge_vars_test = test_graph_meta["edges"]


        self.train_cats_embed = get_word_vectors(self.all_train_names, sep="_").to(self.device)
        self.test_cats_embed = get_word_vectors(self.all_test_names, sep="_").to(self.device)

        self.n_train = len(self.all_train_names)
        self.n_test = len(self.all_test_names)

        self.n_cats_train = len(seen_train_cats)
        self.n_cats_all = len(all_data_cats)
        self.n_cats_seen = len(seen_train_cats)
        self.n_cats_unseen = self.n_cats_all - self.n_cats_seen