Method forward

code/st_model.py:201–255

(self, data,args)

        self.criteria = nn.CrossEntropyLoss()

    def forward(self, data,args):
        # insert a description node
        virtual_node_description = self.descriptions[data.dataset_name]
        all_node_texts = data.raw_text + [virtual_node_description]

        tokens = self.tokenizer(all_node_texts, max_length=256, return_tensors='pt',
                                truncation=True, padding=True).to(self.args.device)
        if args.text_encoder == 'llama':
            outputs = self.lora_model(**tokens, output_hidden_states=True)
            node_embeds = outputs.hidden_states[-1][:, 0, :]
        else:
            node_embeds = self.lora_model(**tokens)[0][:, 0, :]

        tokens = self.tokenizer(data.label_text, max_length=256, return_tensors='pt',
                                truncation=True, padding=True).to(self.args.device)
        if args.text_encoder == 'llama':
            outputs_label = self.lora_model(**tokens, output_hidden_states=True)
            label_embeds = outputs_label.hidden_states[-1][:, 0, :]
        else:
            label_embeds = self.lora_model(**tokens)[0][:, 0, :]

        if self.args.if_norm:
            node_embeds = (node_embeds - node_embeds.mean(0)) / \
                node_embeds.std(0)
            label_embeds = (label_embeds - label_embeds.mean(0)
                            ) / label_embeds.std(0)

        # change the adj matrix
        num_existing_nodes = data.y.shape[0] + 1
        virtual_node_index = data.y.shape[0]
        if data.dataset_name in ["Citeseer", "Arxiv"]:
            new_edges_to_virtual = [[node_idx, virtual_node_index]
                                    for node_idx in range(num_existing_nodes-1)]
        elif data.dataset_name in ["Cora", "Pubmed", "wikics", "home", "tech","reddit","instagram"]:
            new_edges_to_virtual = []
            for node_idx in range(num_existing_nodes-1):
                new_edges_to_virtual.append([node_idx, virtual_node_index])
                new_edges_to_virtual.append([virtual_node_index, node_idx])
        new_edge_index = torch.cat([data.edge_index.t(), torch.tensor(
            new_edges_to_virtual, dtype=torch.long).to(self.args.device)], dim=0).t()

        adj_normed = self.normalize_adjacency_matrix(
            new_edge_index, num_existing_nodes)
        for _ in range(self.args.R):
            node_embeds = torch.mm(adj_normed, node_embeds)
        new_node_embeds = node_embeds[:-1, :]
        logits = torch.mm(new_node_embeds, label_embeds.transpose(1, 0))
        logits = torch.div(logits, 1)
        # 11*7 -> 10*7
        # 10*1 forever
        labels = data.y.long().to(self.args.device) if data.y.dim(
        ) == 1 else data.y.squeeze(1).long().to(self.args.device)
        CL_loss = self.criteria(logits, labels)

        return CL_loss

    def zero_shot_eval(self, node_embeds, label_embeds, data):
        if self.args.if_norm: