From 47c26ea215ad28452728032633258559a122ff74 Mon Sep 17 00:00:00 2001 From: hexun Date: Sun, 17 Aug 2025 07:18:05 +0000 Subject: [PATCH 1/2] [fix] shape in torch should be a tuple but not a number. (not sure about the correctness for the other backends) --- gammagl/loader/link_loader.py | 2 +- gammagl/sampler/neighbor_sampler.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/gammagl/loader/link_loader.py b/gammagl/loader/link_loader.py index 252eb55d4..1b6eeaf60 100644 --- a/gammagl/loader/link_loader.py +++ b/gammagl/loader/link_loader.py @@ -75,7 +75,7 @@ def __init__(self, graph, link_sampler, edge_label_index=None, edge_label=None, edge_label_index = graph.edge_index if self.edge_label is None: # edge_label = tlx.zeros(edge_label_index.size(1)) - edge_label = tlx.zeros(edge_label_index.shape[1]) + edge_label = tlx.zeros((edge_label_index.shape[1],)) super(LinkLoader, self).__init__(LinkDataset(edge_label_index, edge_label), collate_fn=self.collate_fn, diff --git a/gammagl/sampler/neighbor_sampler.py b/gammagl/sampler/neighbor_sampler.py index 4ba6b008c..0f9e1f2a6 100644 --- a/gammagl/sampler/neighbor_sampler.py +++ b/gammagl/sampler/neighbor_sampler.py @@ -187,7 +187,7 @@ def sample_from_edges(self, index, **kwargs): # orig_edge_label_index = edge_label_index if issubclass(self.data_cls, Graph): - query_nodes = tlx.reshape(edge_label_index, -1) + query_nodes = tlx.reshape(edge_label_index, (-1,)) query_nodes, reverse = gammagl.ops.unique(query_nodes, return_inverse=True) From 0e4f964c062d78e780842d265c9f94622165abe6 Mon Sep 17 00:00:00 2001 From: hexun Date: Sun, 17 Aug 2025 15:18:55 +0000 Subject: [PATCH 2/2] [Model] GraphTranslator --- .../Producer/Embeddings_GraphSAGE.py | 104 ++ examples/graphtranslator/Producer/producer.py | 194 +++ examples/graphtranslator/README.md | 120 ++ .../Translator/arxiv_text_pair_datasets.py | 157 +++ .../Translator/graphtranslator_eval.py | 171 +++ .../Translator/graphtranslator_trainer.py | 95 ++ .../pretrain_arxiv_generate_stage2.yaml | 74 + .../Translator/pretrain_arxiv_stage1.yaml | 62 + .../Translator/pretrain_arxiv_stage2.yaml | 62 + .../graphtranslator/Translator/runner_base.py | 694 ++++++++++ examples/graphtranslator/Translator/utils.py | 322 +++++ gammagl/models/__init__.py | 1 + gammagl/models/graphtranslator/Qformer.py | 1202 +++++++++++++++++ gammagl/models/graphtranslator/__init__.py | 2 + gammagl/models/graphtranslator/base_model.py | 128 ++ .../chatglm2/MODEL_LICENSE.txt | 65 + .../models/graphtranslator/chatglm2/README.md | 97 ++ .../graphtranslator/chatglm2/__init__.py | 5 + .../graphtranslator/chatglm2/config.json | 41 + .../chatglm2/configuration_chatglm.py | 59 + .../chatglm2/gitattributes.txt | 35 + .../chatglm2/modeling_chatglm.py | 1188 ++++++++++++++++ .../chatglm2/pytorch_model.bin.index.json | 207 +++ .../graphtranslator/chatglm2/quantization.py | 188 +++ .../chatglm2/special_tokens_map.json | 7 + .../chatglm2/tokenization_chatglm.py | 261 ++++ .../graphtranslator/chatglm2/tokenizer.model | Bin 0 -> 1018370 bytes .../chatglm2/tokenizer_config.json | 12 + gammagl/models/graphtranslator/translator.py | 120 ++ .../translator_chatglm_arxiv.py | 331 +++++ .../translator_qformer_arxiv.py | 366 +++++ 31 files changed, 6370 insertions(+) create mode 100644 examples/graphtranslator/Producer/Embeddings_GraphSAGE.py create mode 100644 examples/graphtranslator/Producer/producer.py create mode 100644 examples/graphtranslator/README.md create mode 100755 examples/graphtranslator/Translator/arxiv_text_pair_datasets.py create mode 100755 examples/graphtranslator/Translator/graphtranslator_eval.py create mode 100755 examples/graphtranslator/Translator/graphtranslator_trainer.py create mode 100755 examples/graphtranslator/Translator/pretrain_arxiv_generate_stage2.yaml create mode 100755 examples/graphtranslator/Translator/pretrain_arxiv_stage1.yaml create mode 100644 examples/graphtranslator/Translator/pretrain_arxiv_stage2.yaml create mode 100755 examples/graphtranslator/Translator/runner_base.py create mode 100755 examples/graphtranslator/Translator/utils.py create mode 100755 gammagl/models/graphtranslator/Qformer.py create mode 100755 gammagl/models/graphtranslator/__init__.py create mode 100755 gammagl/models/graphtranslator/base_model.py create mode 100644 gammagl/models/graphtranslator/chatglm2/MODEL_LICENSE.txt create mode 100644 gammagl/models/graphtranslator/chatglm2/README.md create mode 100644 gammagl/models/graphtranslator/chatglm2/__init__.py create mode 100644 gammagl/models/graphtranslator/chatglm2/config.json create mode 100644 gammagl/models/graphtranslator/chatglm2/configuration_chatglm.py create mode 100644 gammagl/models/graphtranslator/chatglm2/gitattributes.txt create mode 100644 gammagl/models/graphtranslator/chatglm2/modeling_chatglm.py create mode 100644 gammagl/models/graphtranslator/chatglm2/pytorch_model.bin.index.json create mode 100644 gammagl/models/graphtranslator/chatglm2/quantization.py create mode 100644 gammagl/models/graphtranslator/chatglm2/special_tokens_map.json create mode 100644 gammagl/models/graphtranslator/chatglm2/tokenization_chatglm.py create mode 100644 gammagl/models/graphtranslator/chatglm2/tokenizer.model create mode 100644 gammagl/models/graphtranslator/chatglm2/tokenizer_config.json create mode 100755 gammagl/models/graphtranslator/translator.py create mode 100644 gammagl/models/graphtranslator/translator_chatglm_arxiv.py create mode 100755 gammagl/models/graphtranslator/translator_qformer_arxiv.py diff --git a/examples/graphtranslator/Producer/Embeddings_GraphSAGE.py b/examples/graphtranslator/Producer/Embeddings_GraphSAGE.py new file mode 100644 index 000000000..2e9c5e6bf --- /dev/null +++ b/examples/graphtranslator/Producer/Embeddings_GraphSAGE.py @@ -0,0 +1,104 @@ +import time +from ogb.nodeproppred import PygNodePropPredDataset +import torch + +from gammagl.data import Graph +from gammagl.loader import LinkNeighborLoader +from gammagl.layers.conv import SAGEConv +import tensorlayerx.nn as nn +import tensorlayerx as tlx +from tensorlayerx.model import WithLoss, TrainOneStep +import os +os.environ['TL_BACKEND'] = "torch" + +bert_node_embeddings = torch.load("../data/bert_node_embeddings.pt") + +dataset = PygNodePropPredDataset(name='ogbn-arxiv', root='./arxiv/') + +edge_index = dataset[0].edge_index +row, col = edge_index[0], edge_index[1] + +src_node = tlx.concat((tlx.convert_to_tensor(row), tlx.convert_to_tensor(col)), axis=0) +dst_node = tlx.concat((tlx.convert_to_tensor(col), tlx.convert_to_tensor(row)), axis=0) +edge_index = tlx.stack((src_node, dst_node), axis=0) + + +split_idx = dataset.get_idx_split() +train_idx, valid_idx, test_idx = split_idx['train'], split_idx['valid'], split_idx['test'] + +graph = Graph(x=bert_node_embeddings, edge_index=edge_index, train_idx=train_idx, valid_idx=valid_idx, test_idx=test_idx, y=dataset[0].y.squeeze()) +train_loader = LinkNeighborLoader( + graph, + batch_size=65536, + shuffle=True, + neg_sampling_ratio=1.0, + num_neighbors=[10, 10], + edge_label_index=graph.edge_index, + edge_label=None +) + + +class Net(nn.Module): + def __init__(self, in_dim, hid_dim, out_dim): + super(Net, self).__init__() + self.conv1 = SAGEConv(in_channels=in_dim, + out_channels=hid_dim) + self.conv2 = SAGEConv(in_channels=hid_dim, + out_channels=out_dim) + self.act = nn.ReLU() + self.dropout = nn.Dropout(p=0.5) + + def forward(self, x, edge_index): + x = self.conv1(x, edge_index) + x = self.act(x) + x = self.dropout(x) + x = self.conv2(x, edge_index) + return x + + +device = 'cuda:0' if torch.cuda.is_available() else 'cpu' +model = Net(768, 1024, 768).to(device) + +class LinkPredictionLoss(WithLoss): + def __init__(self, net, loss_fn): + super(LinkPredictionLoss, self).__init__(backbone=net, loss_fn=loss_fn) + + def forward(self, data, label): + h = self._backbone(data['x'], data['edge_index']) + h_src = tlx.gather(h, data['edge_label_index'][0]) + h_dst = tlx.gather(h, data['edge_label_index'][1]) + pred = tlx.reduce_sum(h_src * h_dst, axis=-1) + loss = self._loss_fn(output=pred, target=label) + return loss + +def train(): + + optimizer = tlx.optimizers.Adam(0.01) + loss_func = LinkPredictionLoss(model, tlx.losses.sigmoid_cross_entropy) + train_one_step = TrainOneStep(loss_func, optimizer, model.trainable_weights) + + total_loss = 0 + total_num = 0 + for batch in train_loader: + data = {'x': batch.x.to(device), + 'edge_index': batch.edge_index.to(device), + 'edge_label_index': batch.edge_label_index.to(device) + } + model.set_train() + loss = train_one_step(data, batch.edge_label.to(device)) + total_loss += float(loss) * batch.edge_label.shape[0] + total_num += batch.edge_label.shape[0] + + return total_loss/ total_num + + +best_acc = 0 +for epoch in range(10): + start = time.time() + loss = train() + print("loss:", loss) + +out = model(graph.x, graph.edge_index) +if os.environ['TL_BACKEND'] == "torch": + torch.save(out, "../../data/graphsage_node_embeddings.pt") + diff --git a/examples/graphtranslator/Producer/producer.py b/examples/graphtranslator/Producer/producer.py new file mode 100644 index 000000000..b5e3e68b3 --- /dev/null +++ b/examples/graphtranslator/Producer/producer.py @@ -0,0 +1,194 @@ +import random +import csv +import argparse +import time +import logging +import os +import sys +import pandas as pd +import numpy as np +import torch +import tensorlayerx.nn as nn +import tensorlayerx as tlx +from transformers import AutoTokenizer, AutoModel + + + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('--llm_checkpoint', type=str, default="../Translator/models/chatglm2-6b", required=False) + parser.add_argument("--batch_size", type=int, default=1, help="Batch size") + parser.add_argument("--distributed", action='store_const', default=False, const=True) + parser.add_argument('--random_seed', type=int, default=42, help="random seed for initialization") + parser.add_argument("--num_workers", default=1, type=int) + + return parser.parse_args() + +def init_seeds(distributed, seed=0): + tlx.set_seed(seed) + random.seed(seed) + np.random.seed(seed) + + + if seed == 0: + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + +def setup_logging(): + logging_formatter = logging.Formatter("%(asctime)s-%(levelname)s-%(message)s") + # Setup common logger + root = logging.getLogger() + root.setLevel(logging.INFO) + + handler = logging.StreamHandler(sys.stderr) + handler.setLevel(logging.INFO) + handler.setFormatter(logging_formatter) + root.addHandler(handler) + +args = parse_args() + +if torch.cuda.is_available(): + torch.backends.cudnn.benchmark = True + device = torch.device('cuda:0') +else: + device = torch.device('cpu') + +def read_arxiv_dataset(): + # paperid to node的映射和node to paperid的映射 + node2paperid = {} + paperid2node = {} + with open('../data/arxiv_nodeidx2paperid.csv', 'r') as file: + reader = csv.reader(file) + next(reader) + for row in reader: + nodeIdx = int(row[0]) + paperId = int(row[1]) + node2paperid[nodeIdx] = paperId + paperid2node[paperId] = nodeIdx + + # 读取paperId到title和abstract映射的内容 + paperId2titleAndabs = pd.read_csv("../data/titleabs.tsv", delimiter='\t', header=None) + paperId2titleAndabs = paperId2titleAndabs.rename(columns={0: "paper_id", 1: "title", 2: "abstract"}) + paperId2titleAndabs['node_id'] = paperId2titleAndabs['paper_id'].map(paperid2node).fillna(-1).astype(int) + paperId2titleAndabs["title_abstract"] = "Title: " + paperId2titleAndabs["title"] + "\n" +"Abstract: " + paperId2titleAndabs["abstract"] + paperId2titleAndabs = paperId2titleAndabs[paperId2titleAndabs['node_id'] != -1] + + paperId2titleAndabs = paperId2titleAndabs.replace('≤', '', regex=True) + paperId2titleAndabs = paperId2titleAndabs.replace('≥', '', regex=True) + paperId2titleAndabs = paperId2titleAndabs.replace('≠', '', regex=True) + paperId2titleAndabs = paperId2titleAndabs.replace('≠', '', regex=True) + paperId2titleAndabs = paperId2titleAndabs.replace('∫', '', regex=True) + paperId2titleAndabs = paperId2titleAndabs.replace('∞', '', regex=True) + paperId2titleAndabs = paperId2titleAndabs.replace('√', '', regex=True) + + sorted_paperId2titleAndabs = paperId2titleAndabs.sort_values(by='node_id') + sample_neighbor_df = pd.read_csv("../data/sample_neighbor_df.csv") + + return sorted_paperId2titleAndabs, sample_neighbor_df + + +class LLM(nn.Module): + def __init__(self, args, **kwargs): + super().__init__() + self._args = args + # tokenizer + self.tokenizer = AutoTokenizer.from_pretrained(self._args.llm_checkpoint, trust_remote_code=True) + # model + self.llm = AutoModel.from_pretrained(self._args.llm_checkpoint, trust_remote_code=True).half().to(device) + + def inference_chatglm_arxiv(self, arxiv_data, sample_neighbor_df): + self.llm.eval() + + node_title_and_abs = arxiv_data.set_index('node_id')['title_abstract'].to_dict() + src_to_dst_dict = sample_neighbor_df.groupby('src_node')['dst_node'].apply(list).to_dict() + node2title = arxiv_data.set_index('node_id')['title'].to_dict() + + print(f"{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))} total paper count: {arxiv_data.shape[0]}") + summary = [] + total = 0 + for data in arxiv_data.iterrows(): + node_id = data[1]['node_id'] + title = data[1]['title'] + src_prompt_pre = "The title and abstract of this paper are as follows: " + src_prompt = '\n please summarize this paper and list five key words of this paper. All answers are in English and No Chinese in your answer' + src_title_abstract = data[1]['title_abstract'] + node_word_input = src_prompt_pre + src_title_abstract + if len(node_word_input[0]) > 3000- len(src_prompt): + node_word_input = node_word_input[:3000-len(src_prompt)] + node_word_input += src_prompt + + dst_prompt_pre = '\n The paper title and abstract are provided as follows: ' + dst_prompt = "\n Please summarize the topic and content of these papers. All answers are in English and No Chinese in your answer" + dst_title_abstract = "" + for neighbor_id in src_to_dst_dict[node_id]: + dst_title_abstract = dst_title_abstract + node_title_and_abs[neighbor_id] + '\n' + + neighbor_word_input = dst_prompt_pre + dst_title_abstract + if len(neighbor_word_input[0]) > 3000-len(dst_prompt): + neighbor_word_input = neighbor_word_input[:3000-len(dst_prompt)] + neighbor_word_input += dst_prompt + + try: + response_node, _ = self.llm.chat(self.tokenizer, + node_word_input , + history=[]) + response_neighbor, _ = self.llm.chat(self.tokenizer, + neighbor_word_input, + history=[]) + summary.append({ + 'node_id': node_id, + 'title': title, + 'response_node': response_node, + 'response_neighbor': response_neighbor + }) + print(f"{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))} paper {node_id+1} title: \"{title}\"") + except RuntimeError as exception: + if "out of memory" in str(exception): + print("CUDA out of memory error detected, skipping this batch") + continue + else: + continue + total += 1 + if total == 6480: + break + + summary_df = pd.DataFrame(summary) + embeddings = torch.load("../data/graphsage_node_embeddings.pt").to('cpu') + new_data = [] + for _, row in summary_df.iterrows(): + node_id = int(row['node_id']) + embedding = np.array(embeddings[node_id].detach()) + str_array = [str(num) for num in embedding] + str_representation = ", ".join(str_array) + title = node2title[row['node_id']] + + new_data.append({ + 'node_id': node_id, + 'embedding':str_representation , + 'paper_summary':row['response_node'], + 'citepapers_summary':row['response_neighbor'], + 'title':title + }) + summary_embeddings = pd.DataFrame(new_data) + summary_embeddings.to_csv('../../data/summary_embeddings_0.csv',index=False) + + +def main(): + setup_logging() + init_seeds(args.distributed, args.random_seed) + + logging.info("Main arguments:") + for k, v in args.__dict__.items(): + logging.info("{}={}".format(k, v)) + + + # load model + model = LLM(args) + logging.info('start inference') + arxiv_data, sample_neighbor_df = read_arxiv_dataset() + model.inference_chatglm_arxiv(arxiv_data, sample_neighbor_df) + + +if __name__ == "__main__": + main() diff --git a/examples/graphtranslator/README.md b/examples/graphtranslator/README.md new file mode 100644 index 000000000..5e72e469f --- /dev/null +++ b/examples/graphtranslator/README.md @@ -0,0 +1,120 @@ +# GraphTranslator: Aligning Graph Model to Large Language Model for Open-ended Tasks +* Paper link: https://arxiv.org/abs/2402.07197 +* Author's code repo: https://github.com/alibaba/GraphTranslator + +# How to Run + +## 0.Datasets & Models Preparation + +Follow the original repo to install all required packages; + +Then, Download datasets and model checkpoints used in this project with huggingface. + +**ArXiv Dataset** + +Download files `bert_node_embeddings.pt`, `graphsage_node_embeddings.pt` and `titleabs.tsv` from [link](https://huggingface.co/datasets/Hualouz/GraphTranslator-arixv) and insert them to `./data`. + +``` +cd ./data +git lfs install +git clone git@hf.co:datasets/Hualouz/GraphTranslator-arxiv +``` + +**Translator Model** + +Download `bert-base-uncased.zip` from [link](https://huggingface.co/Hualouz/Qformer/tree/main) and unzip it to `./Translator/models`. + +``` +cd Translator/models +git lfs install +git clone git@hf.co:Hualouz/Qformer +unzip bert-base-uncased.zip +``` + +**ChatGLM2-6B Model** + +Download the `ChatGLM2-6B` model from [link](https://huggingface.co/THUDM/chatglm2-6b) and insert it to `./Translator/models` + +``` +cd ./Translator/models +git lfs install +git clone git@hf.co:THUDM/chatglm2-6b +``` + +## 1.Pre-training Graph Model Phase +- In the pre-training phase, we employ link prediction as the self-supervised task for pre-training the graph model. Finally, we will get the GraphSAGE node embeddings for each node in the graph. +``` +cd ./Producer +TL_BACKEND=torch python Embeddings_GraphSAGE.py +``` + + +## 2.Producer Phase + +- Generate node summary text with LLM (ChatGLM2-6B). + +``` +cd ./Producer +python producer.py +``` + +## 3.Training Phase + +Train the Translator model with the prepared ArXiv dataset. + +- Stage 1 Training + +Train the Translator for GraphModel-Text alignment. The training configurations are in the file `./Translator/pretrain_arxiv_stage1.yaml`. + +``` +cd ./Translator +TL_BACKEND=torch python graphtranslator_trainer.py --cfg-path ./pretrain_arxiv_stage1.yaml +``` + +After stage 1, you will get a model checkpoint stored in `./Translator/model_output/pretrain_arxiv_stage1/checkpoint_0.pth`. + +- Stage 2 Training + +Train the Translator for GraphModel-LLM alignment. The training configurations are in the file `./Translator/pretrain_arxiv_stage2.yaml`. + +``` +cd ./Translator +TL_BACKEND=torch python graphtranslator_trainer.py --cfg-path ./pretrain_arxiv_stage2.yaml +``` + +After stage 2, you will get a model checkpoint stored in `./Translator/model_output/pretrain_arxiv_stage2/checkpoint_0.pth`. + +After all the training stages , you will get a model checkpoint that can translate GraphModel information into that the LLM can understand. + +## 4.Generate and Evaluate Phase + +- generate prediction with the pre-trained Translator model. The generate configurations are in the file `./Translator/pretrain_arxiv_generate_stage2.yaml`. As to the inference efficiency, it may take a while to generate all the predictions and save them into file. + +``` +cd ./Translator +TL_BACKEND=torch python graphtranslator_eval.py +``` + +The generated prediction results will be saved in `./data/pred.txt`. + +# Dataset Statics +| Dataset | # Nodes | # Edges | # Classes | +| :-------: | :-------: | :------: | :------: | +| ogb-arxiv | 169,343 | 1,166,243 | 40 | + +# Files Description +- `Producer/Embeddings_GraphSAGE.py`: Pre-training Graph Model Phase, which generates node embeddings using GraphSAGE. +- `Producer/producer.py`: Producer Phase, which generates node summary text with LLM (ChatGLM2-6B). +- `Translator/graphtranslator_trainer.py`: Training Phase, which trains the Translator model for GraphModel-Text and GraphModel-LLM alignment. +- `Translator/graphtranslator_eval.py`: Generate and Evaluate Phase, which generates predictions and evaluates the accuracy of the generated predictions. +- `Translator/arxiv_text_pair_datasets.py`: Dataset preparation for ArXiv text pair dataset. +- `Translator/runner_base.py`: Base class for running the training and evaluation processes. + +# Results (dataset: ogb-arxiv) + +| Metrics | Paper | Our(torch) | +| :-------: | :-------: | :------: | +| Legality Rate(%) | 97.8 | 98.25 | +| Top-1 Acc (%) | 28.48 | 27.33 | +| Top-3 Acc (%) | 37.62 | 38.91 | +| Top-5 Acc (%) | 39.87 | 40.94 | \ No newline at end of file diff --git a/examples/graphtranslator/Translator/arxiv_text_pair_datasets.py b/examples/graphtranslator/Translator/arxiv_text_pair_datasets.py new file mode 100755 index 000000000..3d551a527 --- /dev/null +++ b/examples/graphtranslator/Translator/arxiv_text_pair_datasets.py @@ -0,0 +1,157 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import numpy as np +import random +from typing import Iterable +import pandas as pd +from tensorlayerx.dataflow import Dataset, ConcatDataset, IterableDataset + +class BatchIterableDataset(IterableDataset): + def __init__(self, cfg, mode): + super(BatchIterableDataset, self).__init__() + self._cfg = cfg + self._mode = mode + + self.summary_embeddings = pd.read_csv(cfg['datasets_dir']) + self.row_count = self.summary_embeddings.shape[0] + self.start_pos = 0 + self.end_pos = self.summary_embeddings.shape[0] + + self._parser_dict = { + "train": self._train_data_parser, + "eval": self._eval_data_parser, + "infer": self._infer_data_parser + } + + def _train_data_parser(self, data): + raise NotImplementedError + + def _eval_data_parser(self, data): + raise NotImplementedError + + def _infer_data_parser(self, data): + raise NotImplementedError + + def data_iterator(self): + for _, row in self.summary_embeddings.iterrows(): + try: + data = [tuple(row)] + except Exception: + break + yield self._parser_dict[self._mode](data) + + def __iter__(self): + return self.data_iterator() + + +class ConcatDataset(ConcatDataset): + def __init__(self, datasets: Iterable[Dataset]) -> None: + super().__init__(datasets) + + def collater(self, samples): + all_keys = set() + for s in samples: + all_keys.update(s) + + shared_keys = all_keys + for s in samples: + shared_keys = shared_keys & set(s.keys()) + + samples_shared_keys = [] + for s in samples: + samples_shared_keys.append({k: s[k] for k in s.keys() if k in shared_keys}) + + return self.datasets[0].collater(samples_shared_keys) + +class ArxivTextPairDataset(BatchIterableDataset): + def __init__(self, cfg, mode): + super(ArxivTextPairDataset, self).__init__(cfg, mode) + self.max_length = cfg.arxiv_processor.train.max_length + self.vocab_size = cfg.arxiv_processor.train.vocab_size + + def _train_data_parser(self, data): + # 训练阶段使用 + user_id = data[0][0] + embedding = np.array(data[0][1].split(','), dtype=np.float32) + node_input = data[0][2] + if len(node_input)>=1000: + node_input=node_input[:1000] + neighbour_input = data[0][3] + title = data[0][4] + + text_input = 'The summary of this article is as follows:' + node_input+ '\nThere are some papers that cite this paper.' + neighbour_input + + return user_id, embedding, text_input, title + + def __len__(self): + return self.row_count + +class MultiIterLoader: + """ + A simple wrapper for iterating over multiple iterators. + + Args: + loaders (List[Loader]): List of Iterator loaders. + ratios (List[float]): List of ratios to sample from each loader. If None, all loaders are sampled uniformly. + """ + + def __init__(self, loaders, ratios=None): + # assert all loaders has __next__ method + for loader in loaders: + assert hasattr( + loader, "__next__" + ), "Loader {} has no __next__ method.".format(loader) + + if ratios is None: + ratios = [1.0] * len(loaders) + else: + assert len(ratios) == len(loaders) + ratios = [float(ratio) / sum(ratios) for ratio in ratios] + + self.loaders = loaders + self.ratios = ratios + + def __next__(self): + # random sample from each loader by ratio + loader_idx = random.choices(range(len(self.loaders)), self.ratios, k=1)[0] + return next(self.loaders[loader_idx]) + +import torch +import sys + +MAX_INT = sys.maxsize + + +def apply_to_sample(f, sample): + if len(sample) == 0: + return {} + + def _apply(x): + if torch.is_tensor(x): + return f(x) + elif isinstance(x, dict): + return {key: _apply(value) for key, value in x.items()} + elif isinstance(x, list): + return [_apply(x) for x in x] + else: + return x + + return _apply(sample) + + +def move_to_cuda(sample): + def _move_to_cuda(tensor): + return tensor.cuda() + + return apply_to_sample(_move_to_cuda, sample) + + +def prepare_sample(samples, cuda_enabled=True): + if cuda_enabled: + samples = move_to_cuda(samples) + + return samples \ No newline at end of file diff --git a/examples/graphtranslator/Translator/graphtranslator_eval.py b/examples/graphtranslator/Translator/graphtranslator_eval.py new file mode 100755 index 000000000..bb254519f --- /dev/null +++ b/examples/graphtranslator/Translator/graphtranslator_eval.py @@ -0,0 +1,171 @@ +import numpy as np +import argparse +import random +import sys +import os +import re +import pandas as pd +os.environ['TL_BACKEND'] = "torch" + +import logging +import tensorlayerx as tlx +from datetime import datetime + +from utils import Config, setup_logger + +from runner_base import RunnerBase +from arxiv_text_pair_datasets import ArxivTextPairDataset +from gammagl.models import TranslatorCHATGLMArxiv + + + +def parse_args(): + parser = argparse.ArgumentParser(description="Training") + parser.add_argument("--distributed", action='store_const', default=True, const=True) + parser.add_argument('--random_seed', type=int, default=42, help="random seed for initialization") + parser.add_argument("--num_workers", default=1, type=int) + parser.add_argument("--cfg-path", default="./pretrain_arxiv_generate_stage2.yaml", help="path to configuration file.") + parser.add_argument( + "--options", + nargs="+", + help="override some settings in the used config, the key-value pair " + "in xxx=yyy format will be merged into config file (deprecate), " + "change to --cfg-options instead.", + ) + + args = parser.parse_args() + + return args + + +def setup_seeds(config): + seed = config.run_cfg.seed + + random.seed(seed) + np.random.seed(seed) + tlx.set_seed(seed) # Set the seed for tensorlayerx + + if os.environ['TL_BACKEND'] == "torch": + import torch.backends.cudnn as cudnn + import torch + cudnn.benchmark = False + cudnn.deterministic = True + torch.backends.cuda.matmul.allow_tf32 = True + +def build_datasets(cfg): + datasets = dict() + + datasets_config = cfg.datasets_cfg + + assert len(datasets_config) > 0, "At least one dataset has to be specified." + + for name in datasets_config: + dataset_config = datasets_config[name] + logging.info("Building datasets...") + + dataset = dict() + dataset["train"] = ArxivTextPairDataset( + cfg=dataset_config, + mode='train' + ) + + datasets[name] = dataset + + return datasets + +def get_topk_predictions(node_dict, k): + topk_predictions = {} + for node, probabilities in node_dict.items(): + topk_predictions[node] = probabilities[:k] + return topk_predictions + + +def legality_rate(node2pred): + patterns = ["cs.AI", "cs.AR", "cs.CC", "cs.CE", "cs.CG", "cs.CL", "cs.CR", "cs.CV", "cs.CY", "cs.DB", "cs.DC", "cs.DL", "cs.DM", "cs.DS", "cs.ET", "cs.FL", "cs.GL", "cs.GR", "cs.GT", "cs.HC", "cs.IR", "cs.IT", "cs.LG", "cs.LO", "cs.MA", "cs.MM", "cs.MS", "cs.NA", "cs.NE", "cs.NI", "cs.OH", "cs.OS", "cs.PF", "cs.PL", "cs.RO", "cs.SC", "cs.SD", "cs.SE", "cs.SI", "cs.SY", "Artificial Intelligence", "Hardware Architecture", "Computational Complexity", "Computational Engineering, Finance, and Science", "Computational Geometry", "Computation and Language", "Cryptography and Security", "Computer Vision and Pattern Recognition", "Computers and Society", "Databases", "Distributed, Parallel, and Cluster Computing", "Digital Libraries", "Discrete Mathematics", "Data Structures and Algorithms", "Emerging Technologies", "Formal Languages and Automata Theory", "General Literature", "Graphics", "Computer Science and Game Theory", "Human-Computer Interaction", "Information Retrieval", "Information Theory", "Machine Learning", "Logic in Computer Science", "Multiagent Systems", "Multimedia", "Mathematical Software", "Numerical Analysis", "Neural and Evolutionary Computing", "Networking and Internet Architecture", "Other Computer Science", "Operating Systems", "Performance", "Programming Languages", "Robotics", "Symbolic Computation", "Sound", "Software Engineering", "Social and Information Networks", "Systems and Control","Computer Vision","Pattern Recognition"] + label_map = {'Numerical Analysis': 0,'Multimedia': 1,'Logic in Computer Science': 2,'Computers and Society': 3,'Cryptography and Security': 4,'Distributed, Parallel, and Cluster Computing': 5,'Human-Computer Interaction': 6,'Computational Engineering, Finance, and Science': 7,'Networking and Internet Architecture': 8,'Computational Complexity': 9,'Artificial Intelligence': 10,'Multiagent Systems': 11,'General Literature': 12,'Neural and Evolutionary Computing': 13,'Symbolic Computation': 14,'Hardware Architecture': 15,'Computer Vision and Pattern Recognition': 16,'Pattern Recognition': 16,'Computer Vision': 16,'Graphics': 17,'Emerging Technologies': 18,'Systems and Control': 19,'Computational Geometry': 20,'Other Computer Science': 21,'Programming Languages': 22,'Software Engineering': 23,'Machine Learning': 24,'Sound': 25,'Social and Information Networks': 26,'Robotics': 27,'Information Theory': 28,'Performance': 29,'Computation and Language': 30,'Information Retrieval': 31,'Mathematical Software': 32,'Formal Languages and Automata Theory': 33,'Data Structures and Algorithms': 34,'Operating Systems': 35,'Computer Science and Game Theory': 36,'Databases': 37,'Digital Libraries': 38,'Discrete Mathematics': 39,'cs.NA': 0,'cs.MM': 1,'cs.LO': 2,'cs.CY': 3,'cs.CR': 4,'cs.DC': 5,'cs.HC': 6,'cs.CE': 7,'cs.NI': 8,'cs.CC': 9,'cs.AI': 10,'cs.MA': 11,'cs.GL': 12,'cs.NE': 13,'cs.SC': 14,'cs.AR': 15,'cs.CV': 16,'cs.GR': 17,'cs.ET': 18,'cs.SY': 19,'cs.CG': 20,'cs.OH': 21,'cs.PL': 22,'cs.SE': 23,'cs.LG': 24,'cs.SD': 25,'cs.SI': 26,'cs.RO': 27,'cs.IT': 28,'cs.PF': 29,'cs.CL': 30,'cs.IR': 31,'cs.MS': 32,'cs.FL': 33,'cs.DS': 34,'cs.OS': 35,'cs.GT': 36,'cs.DB': 37,'cs.DL': 38,'cs.DM': 39} + print("Total class number:", len(patterns)) + assert len(patterns) == len(label_map), "patterns and label_map should have the same size" + + count = 0 + node2digitallabel = {} + for node, pred_list in node2pred.items(): + matches = [] + for pred in pred_list: + for pattern in patterns: + match_label = re.findall(pattern, pred) + if len(match_label) > 2: + match_label = list(set(match_label)) + label1 = label_map[match_label[0]] + matches.append(label1) + elif len(match_label) == 2: + label1 = label_map[match_label[0]] + label2 = label_map[match_label[1]] + if label1 != label2: + print("error") + else: + matches.append(label1) + elif len(match_label) == 1: + label1 = label_map[match_label[0]] + matches.append(label1) + matches = list(set(matches)) + node2digitallabel[int(node)] = list(set(matches)) + if len(matches)>0: + count += 1 + + print(f"Total sample number: {count}") + print(f"Legality rate: {round(100*count/len(node2pred),2) if len(node2pred) > 0 else 0.0}%") + + return node2digitallabel, count + + +def read_data(label_file, pred_file): + df_node2label = pd.read_csv(label_file) + node2label = dict(zip(df_node2label['node_id'], df_node2label['digital_label'])) + df_pred = pd.read_csv(pred_file, sep='\t', names=['node', 'summary', 'pred']) + node2pred = {} + for _, row in df_pred.iterrows(): + node = int(row.iloc[0]) + node2pred[node] = row.iloc[2].split("\n") + return node2label, node2pred + + +def evaluation(label_file, pred_file): + node2label, node2pred = read_data(label_file, pred_file) + node2digitallabel, count = legality_rate(node2pred) + + for k in [1,3,5]: + acc_count = 0 + node2digitallabel_k = get_topk_predictions(node2digitallabel, k ) + for node, pred_list in node2digitallabel_k.items(): + label = node2label[node] + if len(pred_list) > 0 and label in pred_list: + acc_count += 1 + + print(f"Top@{k} Accuracy: {round(100*acc_count/count,2) if count > 0 else 0.0}%") + +def main(job_id): + cfg = Config(parse_args()) + + setup_seeds(cfg) + setup_logger() + cfg.pretty_print() + + # generate + datasets = build_datasets(cfg) + model = TranslatorCHATGLMArxiv.from_config(cfg.model_cfg) + + runner = RunnerBase( + cfg=cfg, job_id=job_id, model=model, datasets=datasets + ) + runner.translator_generate() + + # evaluate + label_file = "../data/arxiv_test.csv" + pred_file = "../data/pred.txt" + evaluation(label_file, pred_file) + + +if __name__ == "__main__": + job_id = datetime.now().strftime("%Y%m%d%H%M")[:-1] + + main(job_id) diff --git a/examples/graphtranslator/Translator/graphtranslator_trainer.py b/examples/graphtranslator/Translator/graphtranslator_trainer.py new file mode 100755 index 000000000..0c7107dc8 --- /dev/null +++ b/examples/graphtranslator/Translator/graphtranslator_trainer.py @@ -0,0 +1,95 @@ +import argparse +import random +import sys +import os +import numpy as np + +os.environ['TL_BACKEND'] = 'torch' + +import tensorlayerx as tlx +import logging +from datetime import datetime +from utils import Config, setup_logger + +from runner_base import RunnerBase +from arxiv_text_pair_datasets import ArxivTextPairDataset +from gammagl.models import TranslatorCHATGLMArxiv, TranslatorQformerArxiv + + +def parse_args(): + parser = argparse.ArgumentParser(description="Training") + parser.add_argument("--num_workers", default=1, type=int) + parser.add_argument("--cfg-path", default="./pretrain_arxiv_stage1.yaml", help="path to configuration file.") + parser.add_argument( + "--options", + nargs="+", + help="override some settings in the used config, the key-value pair " + "in xxx=yyy format will be merged into config file (deprecate), " + "change to --cfg-options instead.", + ) + + args = parser.parse_args() + + return args + + +def setup_seeds(config): + seed = config.run_cfg.seed + + random.seed(seed) + np.random.seed(seed) + tlx.set_seed(seed) # Set the seed for tensorlayerx + + if os.environ['TL_BACKEND'] == "torch": + import torch.backends.cudnn as cudnn + import torch + cudnn.benchmark = False + cudnn.deterministic = True + torch.backends.cuda.matmul.allow_tf32 = True + + +def build_datasets(cfg): + datasets = dict() + + datasets_config = cfg.datasets_cfg + + assert len(datasets_config) > 0, "At least one dataset has to be specified." + + for name in datasets_config: + dataset_config = datasets_config[name] + logging.info("Building datasets...") + + dataset = dict() + dataset["train"] = ArxivTextPairDataset( + cfg=dataset_config, + mode='train' + ) + + datasets[name] = dataset + + return datasets + + +def main(job_id): + cfg = Config(parse_args()) + + setup_seeds(cfg) + setup_logger() + cfg.pretty_print() + + + datasets = build_datasets(cfg) + if cfg.model_cfg.arch == "translator_arxiv_chatglm": + model = TranslatorCHATGLMArxiv.from_config(cfg.model_cfg) + elif cfg.model_cfg.arch == "translator_arxiv": + model = TranslatorQformerArxiv.from_config(cfg.model_cfg) + + + runner = RunnerBase( + cfg=cfg, job_id=job_id, model=model, datasets=datasets) + runner.train() + + +if __name__ == "__main__": + job_id = datetime.now().strftime("%Y%m%d%H%M")[:-1] + main(job_id) diff --git a/examples/graphtranslator/Translator/pretrain_arxiv_generate_stage2.yaml b/examples/graphtranslator/Translator/pretrain_arxiv_generate_stage2.yaml new file mode 100755 index 000000000..fd91b9253 --- /dev/null +++ b/examples/graphtranslator/Translator/pretrain_arxiv_generate_stage2.yaml @@ -0,0 +1,74 @@ +model: + arch: translator_arxiv_chatglm + model_type: translator_generate_stage2 + load_finetuned: False + pretrained: "./model_output/pretrain_arxiv_stage2/checkpoint_0.pth" + llm_dir: "./models/chatglm2-6b" + bert_dir: "./models/bert-base-uncased" + + + # behavior encoder + behavior_length: 768 + freeze_behavior: True + behavior_precision: "fp16" + + # Text + max_txt_len: 2048 + + # Q-Former + num_query_token: 32 + cross_attention_freq: 2 + +datasets: + arxiv_caption: # name of the dataset builder + type: translator_generate_stage2 + datasets_dir: "../data/arxiv_test.csv" + pred_dir: "../data/pred.txt" + arxiv_processor: + train: + name: "translator_arxiv_train" + max_length: 1024 + vocab_size: 100000 + text_processor: + train: + name: "translator_caption" + + +run: + task: arxiv_generate + # optimizer + lr_sched: "linear_warmup_cosine_lr" + init_lr: 1e-4 + min_lr: 1e-5 + warmup_lr: 1e-6 + + weight_decay: 0.05 + max_epoch: 1 + batch_size_train: 1 + batch_size_eval: 64 + warmup_steps: 5000 + accum_grad_iters: 32 + log_freq: 50 + + + seed: 42 + output_dir: "./model_output/pretrain_arxiv_stage2" + + amp: True + resume_ckpt_path: null + + evaluate: False + train_splits: ["train"] + + device: "cuda:2" + dist_url: "env://" + distributed: Flase + +prompt: + generate_prompt: [ + "\nQuestion: Please summarize the topic and content of the paper and its citations in English.\nAnswer:", + "\nQuestion: Based on the summary of the above paper titled <{}>, please determine into which of the following 40 arXiv CS sub-categories would this paper most likely fall?", + "categories: ", + "Please give 5 likely categories, in order from most likely to least likely, and give your reasoning. Provide response in JSON format with the following keys: category, reason. \n\nAnswer:", + "Round 0:\n\nQuestion:We are trying to explore the paper titled {}. \n Please summarize the topic and content of the paper and its citations in English \n\nAnswer:{} \n\nRound 1:\n{}" +] diff --git a/examples/graphtranslator/Translator/pretrain_arxiv_stage1.yaml b/examples/graphtranslator/Translator/pretrain_arxiv_stage1.yaml new file mode 100755 index 000000000..01f7ff016 --- /dev/null +++ b/examples/graphtranslator/Translator/pretrain_arxiv_stage1.yaml @@ -0,0 +1,62 @@ +model: + arch: translator_arxiv + model_type: pretrain_arxiv + load_finetuned: False + pretrained: "./models/bert-base-uncased/model.pth" + llm_dir: "./models/chatglm2-6b" + bert_dir: "./models/bert-base-uncased" + + # behavior encoder + behavior_length: 768 + freeze_behavior: True + behavior_precision: "fp16" + + # Text + max_txt_len: 512 + + # Q-Former + num_query_token: 32 + cross_attention_freq: 2 + + +datasets: + arxiv_caption: # name of the dataset builder + datasets_dir: "../data/summary_embeddings.csv" + arxiv_processor: + train: + name: "translator_arxiv_train" + max_length: 512 + vocab_size: 100000 + text_processor: + train: + name: "translator_caption" + + +run: + task: arxiv_text_pretrain + # optimizer + lr_sched: "linear_warmup_cosine_lr" + init_lr: 1e-4 + min_lr: 1e-5 + warmup_lr: 1e-6 + + weight_decay: 0.05 + max_epoch: 1 + batch_size_train: 8 + batch_size_eval: 4 + warmup_steps: 5000 + accum_grad_iters: 32 + log_freq: 10 + + seed: 42 + output_dir: "./model_output/pretrain_arxiv_stage1" + + amp: True + resume_ckpt_path: null + + evaluate: False + train_splits: ["train"] + + device: "cuda:2" + dist_url: "env://" + distributed: False \ No newline at end of file diff --git a/examples/graphtranslator/Translator/pretrain_arxiv_stage2.yaml b/examples/graphtranslator/Translator/pretrain_arxiv_stage2.yaml new file mode 100644 index 000000000..171401fec --- /dev/null +++ b/examples/graphtranslator/Translator/pretrain_arxiv_stage2.yaml @@ -0,0 +1,62 @@ +model: + arch: translator_arxiv_chatglm + model_type: pretrain_arxiv + load_finetuned: False + # intialize stage 2 pretraining from stage 1 pretrained model + pretrained: "./model_output/pretrain_arxiv_stage1/checkpoint_0.pth" + llm_dir: "./models/chatglm2-6b" + bert_dir: "./models/bert-base-uncased" + + # behavior encoder + behavior_length: 768 + freeze_behavior: True + behavior_precision: "fp16" + + # Text + max_txt_len: 1024 + + # Q-Former + num_query_token: 32 + +datasets: + arxiv_caption: # name of the dataset builder + type: translator_train_stage2 + datasets_dir: "../data/summary_embeddings.csv" + arxiv_processor: + train: + name: "translator_arxiv_train" + max_length: 1024 + vocab_size: 100000 + text_processor: + train: + name: "translator_caption" + +run: + task: arxiv_text_pretrain + # optimizer + lr_sched: "linear_warmup_cosine_lr" + init_lr: 1e-4 + min_lr: 1e-5 + warmup_lr: 1e-6 + + weight_decay: 0.05 + max_epoch: 1 + batch_size_train: 1 + batch_size_eval: 64 + warmup_steps: 5000 + accum_grad_iters: 32 + log_freq: 50 + + + seed: 42 + output_dir: "./model_output/pretrain_arxiv_stage2" + + amp: True + resume_ckpt_path: null + + evaluate: False + train_splits: ["train"] + + device: "cuda:2" + dist_url: "env://" + distributed: False \ No newline at end of file diff --git a/examples/graphtranslator/Translator/runner_base.py b/examples/graphtranslator/Translator/runner_base.py new file mode 100755 index 000000000..8e70f4b7a --- /dev/null +++ b/examples/graphtranslator/Translator/runner_base.py @@ -0,0 +1,694 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +from datetime import datetime, timedelta +import json +import logging +import os +import time + +import torch +from arxiv_text_pair_datasets import prepare_sample + +from utils import MetricLogger, SmoothedValue +from arxiv_text_pair_datasets import MultiIterLoader +from tensorlayerx.dataflow import DataLoader, ChainDataset + + +class RunnerBase: + """ + A runner class to train and evaluate a model given a task and datasets. + + The runner uses pytorch distributed data parallel by default. Future release + will support other distributed frameworks. + """ + + def __init__(self, cfg, model, datasets, job_id): + self.config = cfg + self.job_id = job_id + + self.datasets = datasets + + self._model = model + + self._wrapped_model = None + self._device = None + self._optimizer = None + self._scaler = None + self._dataloaders = None + self._lr_sched = None + + self.start_epoch = 0 + self.iters_per_epoch = self.datasets[list(self.datasets.keys())[0]]['train'].row_count // self.config.run_cfg.batch_size_train + self.output_dir = cfg.run_cfg.output_dir + + @property + def device(self): + if self._device is None: + self._device = torch.device(self.config.run_cfg.device) + + return self._device + + @property + def use_distributed(self): + return self.config.run_cfg.distributed + + @property + def model(self): + """ + A property to get the DDP-wrapped model on the device. + """ + # move model to device + if self._model.device != self.device: + self._model = self._model.to(self.device) + + return self._model + + @property + def optimizer(self): + if self._optimizer is None: + num_parameters = 0 + p_wd, p_non_wd = [], [] + for n, p in self.model.named_parameters(): + if not p.requires_grad: + continue # frozen weights + if p.ndim < 2 or "bias" in n or "ln" in n or "bn" in n: + p_non_wd.append(p) + else: + p_wd.append(p) + num_parameters += p.data.nelement() + logging.info("number of trainable parameters: %s" % format(num_parameters)) + optim_params = [ + { + "params": p_wd, + "weight_decay": float(self.config.run_cfg.weight_decay), + }, + {"params": p_non_wd, "weight_decay": 0}, + ] + beta2 = self.config.run_cfg.get("beta2", 0.999) + self._optimizer = torch.optim.AdamW( + optim_params, + lr=float(self.config.run_cfg.init_lr), + weight_decay=float(self.config.run_cfg.weight_decay), + betas=(0.9, beta2), + ) + + return self._optimizer + + @property + def scaler(self): + amp = self.config.run_cfg.get("amp", False) + + if amp: + if self._scaler is None: + self._scaler = torch.cuda.amp.GradScaler() + + return self._scaler + + @property + def lr_scheduler(self): + """ + A property to get and create learning rate scheduler by split just in need. + """ + if self._lr_sched is None: + max_epoch = self.max_epoch + min_lr = self.min_lr + init_lr = self.init_lr + + # optional parameters + decay_rate = self.config.run_cfg.get("lr_decay_rate", None) + warmup_start_lr = self.config.run_cfg.get("warmup_lr", -1) + warmup_steps = self.config.run_cfg.get("warmup_steps", 0) + + self._lr_sched = LinearWarmupCosineLRScheduler( + optimizer=self.optimizer, + max_epoch=max_epoch, + min_lr=min_lr, + init_lr=init_lr, + decay_rate=decay_rate, + warmup_start_lr=warmup_start_lr, + warmup_steps=warmup_steps, + ) + + return self._lr_sched + + @property + def dataloaders(self) -> dict: + """ + A property to get and create dataloaders by split just in need. + + If no train_dataset_ratio is provided, concatenate map-style datasets and + chain wds.DataPipe datasets separately. Training set becomes a tuple + (ConcatDataset, ChainDataset), both are optional but at least one of them is + required. The resultant ConcatDataset and ChainDataset will be sampled evenly. + + If train_dataset_ratio is provided, create a MultiIterLoader to sample + each dataset by ratios during training. + + Currently do not support multiple datasets for validation and test. + + Returns: + dict: {split_name: (tuples of) dataloader} + """ + if self._dataloaders is None: + # reoganize datasets by split and concatenate/chain if necessary + dataset_ratios = self.config.run_cfg.get("train_dataset_ratios", None) + + self.datasets = self.datasets[list(self.datasets.keys())[0]] + # create dataloaders + split_names = sorted(self.datasets.keys()) + + datasets = [self.datasets[split] for split in split_names] + is_trains = [split in self.train_splits for split in split_names] + + batch_sizes = [ + self.config.run_cfg.batch_size_train + if split == "train" + else self.config.run_cfg.batch_size_eval + for split in split_names + ] + + collate_fns = [] + for dataset in datasets: + if isinstance(dataset, tuple) or isinstance(dataset, list): + collate_fns.append([getattr(d, "collater", None) for d in dataset]) + else: + collate_fns.append(getattr(dataset, "collater", None)) + + dataloaders = self.create_loaders( + datasets=datasets, + num_workers=self.config.args.num_workers, + batch_sizes=batch_sizes, + is_trains=is_trains, + collate_fns=collate_fns, + dataset_ratios=dataset_ratios, + ) + + self._dataloaders = {k: v for k, v in zip(split_names, dataloaders)} + + return self._dataloaders + + @property + def cuda_enabled(self): + return self.device.type == "cuda" + + @property + def max_epoch(self): + return int(self.config.run_cfg.max_epoch) + + @property + def log_freq(self): + log_freq = self.config.run_cfg.get("log_freq", 50) + return int(log_freq) + + @property + def init_lr(self): + return float(self.config.run_cfg.init_lr) + + @property + def min_lr(self): + return float(self.config.run_cfg.min_lr) + + @property + def accum_grad_iters(self): + return int(self.config.run_cfg.get("accum_grad_iters", 1)) + + @property + def valid_splits(self): + valid_splits = self.config.run_cfg.get("valid_splits", []) + + if len(valid_splits) == 0: + logging.info("No validation splits found.") + + return valid_splits + + @property + def test_splits(self): + test_splits = self.config.run_cfg.get("test_splits", []) + + return test_splits + + @property + def train_splits(self): + train_splits = self.config.run_cfg.get("train_splits", []) + + if len(train_splits) == 0: + logging.info("Empty train splits.") + + return train_splits + + @property + def evaluate_only(self): + """ + Set to True to skip training. + """ + return self.config.run_cfg.evaluate + + @property + def use_dist_eval_sampler(self): + return self.config.run_cfg.get("use_dist_eval_sampler", True) + + @property + def resume_ckpt_path(self): + return self.config.run_cfg.get("resume_ckpt_path", None) + + @property + def train_loader(self): + train_dataloader = self.dataloaders["train"] + return train_dataloader + + def train(self): + start_time = time.time() + best_agg_metric = 0 + best_epoch = 0 + + # resume from checkpoint if specified + if not self.evaluate_only and self.resume_ckpt_path is not None: + self._load_checkpoint(self.resume_ckpt_path) + + for cur_epoch in range(self.start_epoch, self.max_epoch): + # training phase + if not self.evaluate_only: + logging.info("Start training") + train_stats = self.train_epoch(cur_epoch) + + # evaluation phase + if len(self.valid_splits) > 0: + for split_name in self.valid_splits: + logging.info("Evaluating on {}.".format(split_name)) + + val_log = self.eval_epoch( + split_name=split_name, cur_epoch=cur_epoch + ) + if val_log is not None: + assert ( + "agg_metrics" in val_log + ), "No agg_metrics found in validation log." + + agg_metrics = val_log["agg_metrics"] + if agg_metrics > best_agg_metric and split_name == "val": + best_epoch, best_agg_metric = cur_epoch, agg_metrics + + self._save_checkpoint(cur_epoch, is_best=True) + + val_log.update({"best_epoch": best_epoch}) + + else: + # if no validation split is provided, we just save the checkpoint at the end of each epoch. + if not self.evaluate_only: + self._save_checkpoint(cur_epoch, is_best=False) + + if self.evaluate_only: + break + + # testing phase + test_epoch = "best" if len(self.valid_splits) > 0 else cur_epoch + self.evaluate(cur_epoch=test_epoch, skip_reload=self.evaluate_only) + + total_time = time.time() - start_time + total_time_str = str(timedelta(seconds=int(total_time))) + logging.info("Training time {}".format(total_time_str)) + + def evaluate(self, cur_epoch="best", skip_reload=False): + test_logs = dict() + + if len(self.test_splits) > 0: + for split_name in self.test_splits: + test_logs[split_name] = self.eval_epoch( + split_name=split_name, cur_epoch=cur_epoch, skip_reload=skip_reload + ) + + return test_logs + + def train_epoch(self, epoch): + # train + self.model.train() + return self._train_inner_loop( + epoch=epoch, + iters_per_epoch=self.iters_per_epoch, + model=self.model, + data_loader=self.train_loader, + optimizer=self.optimizer, + scaler=self.scaler, + lr_scheduler=self.lr_scheduler, + log_freq=self.log_freq, + cuda_enabled=self.cuda_enabled, + accum_grad_iters=self.accum_grad_iters, + ) + + def _train_inner_loop( + self, + epoch, + iters_per_epoch, + model, + data_loader, + optimizer, + lr_scheduler, + scaler=None, + start_iters=None, + log_freq=50, + cuda_enabled=False, + accum_grad_iters=1, + ): + """ + An inner training loop compatible with both epoch-based and iter-based training. + + When using epoch-based, training stops after one epoch; when using iter-based, + training stops after #iters_per_epoch iterations. + """ + use_amp = scaler is not None + + if not hasattr(data_loader, "__next__"): + # convert to iterator if not already + data_loader = iter(data_loader) + + metric_logger = MetricLogger(delimiter=" ") + metric_logger.add_meter("lr", SmoothedValue(window_size=1, fmt="{value:.8f}")) + metric_logger.add_meter("loss", SmoothedValue(window_size=1, fmt="{value:.8f}")) + + # if iter-based runner, schedule lr based on inner epoch. + logging.info( + "Start training epoch {}, {} iters per inner epoch.".format( + epoch, iters_per_epoch + ) + ) + header = "Time {} Train: data epoch: [{}]".format(datetime.now(), epoch) + if start_iters is None: + # epoch-based runner + inner_epoch = epoch + else: + # In iter-based runner, we schedule the learning rate based on iterations. + inner_epoch = start_iters // iters_per_epoch + header = header + "; inner epoch [{}]".format(inner_epoch) + + current_step = 0 + for network_input in metric_logger.log_every(data_loader, log_freq, iters_per_epoch, header): + lr_scheduler.step(cur_epoch=inner_epoch, cur_step=current_step) + + with torch.cuda.amp.autocast(enabled=use_amp): + loss = model(network_input)["loss"] + + if use_amp: + scaler.scale(loss).backward() + else: + loss.backward() + + # update gradients every accum_grad_iters iterations + if (current_step + 1) % accum_grad_iters == 0: + if use_amp: + scaler.step(optimizer) + scaler.update() + else: + optimizer.step() + optimizer.zero_grad() + + metric_logger.update(loss=loss.item()) + metric_logger.update(lr=optimizer.param_groups[0]["lr"]) + + current_step += 1 + + # gather the stats from all processes + metric_logger.synchronize_between_processes() + logging.info("Averaged stats: " + str(metric_logger.global_avg())) + return { + k: "{:.3f}".format(meter.global_avg) + for k, meter in metric_logger.meters.items() + } + + @torch.no_grad() + def eval_epoch(self, split_name, cur_epoch, skip_reload=False): + """ + Evaluate the model on a given split. + + Args: + split_name (str): name of the split to evaluate on. + cur_epoch (int): current epoch. + skip_reload_best (bool): whether to skip reloading the best checkpoint. + During training, we will reload the best checkpoint for validation. + During testing, we will use provided weights and skip reloading the best checkpoint . + """ + data_loader = self.dataloaders.get(split_name, None) + assert data_loader, "data_loader for split {} is None.".format(split_name) + + model = self.unwrap_dist_model(self.model) + if not skip_reload and cur_epoch == "best": + model = self._reload_best_model(model) + model.eval() + + results = self.evaluation(model, data_loader) + + return results + + def evaluation(self, model, data_loader, cuda_enabled=True): + metric_logger = MetricLogger(delimiter=" ") + header = "Evaluation" + print_freq = 10 + + results = [] + + for samples in metric_logger.log_every(data_loader, print_freq, header): + samples = prepare_sample(samples, cuda_enabled=cuda_enabled) + + eval_output = self.valid_step(model=model, samples=samples) + results.extend(eval_output) + + return results + + def unwrap_dist_model(self, model): + return model + + def create_loaders( + self, + datasets, + num_workers, + batch_sizes, + is_trains, + collate_fns, + dataset_ratios=None, + ): + """ + Create dataloaders for training and validation. + """ + + def _create_loader(dataset, num_workers, bsz, is_train, collate_fn): + # create a single dataloader for each split + if isinstance(dataset, ChainDataset) : + + loader = iter( + DataLoader( + dataset, + batch_size=bsz, + num_workers=num_workers, + shuffle=False + ) + ) + else: + sampler = None + loader = DataLoader( + dataset, + batch_size=bsz, + num_workers=num_workers, + sampler=sampler, + shuffle=False, + collate_fn=collate_fn, + drop_last=True if is_train else False, + ) + + return loader + + loaders = [] + for dataset, bsz, is_train, collate_fn in zip( + datasets, batch_sizes, is_trains, collate_fns + ): + if isinstance(dataset, list) or isinstance(dataset, tuple): + loader = MultiIterLoader( + loaders=[ + _create_loader(d, num_workers, bsz, is_train, collate_fn[i]) + for i, d in enumerate(dataset) + ], + ratios=dataset_ratios, + ) + else: + loader = _create_loader(dataset, num_workers, bsz, is_train, collate_fn) + + loaders.append(loader) + + return loaders + + def _save_checkpoint(self, cur_epoch, is_best=False): + """ + Save the checkpoint at the current epoch. + """ + model_no_ddp = self.unwrap_dist_model(self.model) + param_grad_dic = { + k: v.requires_grad for (k, v) in model_no_ddp.named_parameters() + } + state_dict = model_no_ddp.state_dict() + for k in list(state_dict.keys()): + if k in param_grad_dic.keys() and not param_grad_dic[k]: + # delete parameters that do not require gradient + del state_dict[k] + save_obj = { + "model": state_dict, + "optimizer": self.optimizer.state_dict(), + "config": self.config.to_dict(), + "scaler": self.scaler.state_dict() if self.scaler else None, + "epoch": cur_epoch, + } + if not os.path.exists(self.output_dir): + os.makedirs(self.output_dir) + save_to = os.path.join( + self.output_dir, + "checkpoint_{}.pth".format("best" if is_best else cur_epoch), + ) + logging.info("Saving checkpoint at epoch {} to {}.".format(cur_epoch, save_to)) + torch.save(save_obj, save_to) + + def _reload_best_model(self, model): + """ + Load the best checkpoint for evaluation. + """ + checkpoint_path = os.path.join(self.output_dir, "checkpoint_best.pth") + + logging.info("Loading checkpoint from {}.".format(checkpoint_path)) + checkpoint = torch.load(checkpoint_path, map_location="cpu") + try: + model.load_state_dict(checkpoint["model"]) + except RuntimeError as e: + logging.warning( + """ + Key mismatch when loading checkpoint. This is expected if only part of the model is saved. + Trying to load the model with strict=False. + """ + ) + model.load_state_dict(checkpoint["model"], strict=False) + return model + + def _load_checkpoint(self, url_or_filename): + """ + Resume from a checkpoint. + """ + if os.path.isfile(url_or_filename): + checkpoint = torch.load(url_or_filename, map_location=self.device) + else: + raise RuntimeError("checkpoint url or path is invalid") + + state_dict = checkpoint["model"] + self.unwrap_dist_model(self.model).load_state_dict(state_dict) + + self.optimizer.load_state_dict(checkpoint["optimizer"]) + if self.scaler and "scaler" in checkpoint: + self.scaler.load_state_dict(checkpoint["scaler"]) + + self.start_epoch = checkpoint["epoch"] + 1 + logging.info("Resume checkpoint from {}".format(url_or_filename)) + + def log_stats(self, stats, split_name): + if isinstance(stats, dict): + log_stats = {**{f"{split_name}_{k}": v for k, v in stats.items()}} + with open(os.path.join(self.output_dir, "log.txt"), "a") as f: + f.write(json.dumps(log_stats) + "\n") + elif isinstance(stats, list): + pass + + def log_config(self): + with open(os.path.join(self.output_dir, "log.txt"), "a") as f: + f.write(json.dumps(self.config.to_dict(), indent=4) + "\n") + + def translator_generate(self): + + model = self.unwrap_dist_model(self.model) + model.eval() + + iters_per_epoch = self.iters_per_epoch + data_loader = self.train_loader + scaler = self.scaler + log_freq = 10 + + """ + An inner training loop compatible with both epoch-based and iter-based training. + + When using epoch-based, training stops after one epoch; when using iter-based, + training stops after #iters_per_epoch iterations. + """ + use_amp = scaler is not None + header = "Inference:" + metric_logger = MetricLogger(delimiter=" ") + if not hasattr(data_loader, "__next__"): + data_loader = iter(data_loader) + + pred_txt = open(self.config.datasets_cfg['arxiv_caption']['pred_dir'], 'w') + + for network_input in metric_logger.log_every(data_loader, log_freq, iters_per_epoch, header): + with torch.cuda.amp.autocast(enabled=use_amp): + ChatGLM_response = model.generate(network_input, self.config.prompt_cfg['generate_prompt']) + + for i in range(len(ChatGLM_response)): + id = str(network_input[0][i].detach().cpu().numpy()) + ori_desc = network_input[2][i].replace('\n', '\\n').replace('\t', '\\t') + pred = ChatGLM_response[i].replace('\n', '\\n').replace('\t', '\\t') + pred_txt.write(id+'\t'+ori_desc+'\t'+pred+'\n') + + pred_txt.close() + +import math + +class LinearWarmupCosineLRScheduler: + def __init__( + self, + optimizer, + max_epoch, + min_lr, + init_lr, + warmup_steps=0, + warmup_start_lr=-1, + **kwargs + ): + self.optimizer = optimizer + + self.max_epoch = max_epoch + self.min_lr = min_lr + + self.init_lr = init_lr + self.warmup_steps = warmup_steps + self.warmup_start_lr = warmup_start_lr if warmup_start_lr >= 0 else init_lr + + def step(self, cur_epoch, cur_step): + # assuming the warmup iters less than one epoch + if cur_epoch == 0: + warmup_lr_schedule( + step=cur_step, + optimizer=self.optimizer, + max_step=self.warmup_steps, + init_lr=self.warmup_start_lr, + max_lr=self.init_lr, + ) + else: + cosine_lr_schedule( + epoch=cur_epoch, + optimizer=self.optimizer, + max_epoch=self.max_epoch, + init_lr=self.init_lr, + min_lr=self.min_lr, + ) + + +def cosine_lr_schedule(optimizer, epoch, max_epoch, init_lr, min_lr): + """Decay the learning rate""" + lr = (init_lr - min_lr) * 0.5 * ( + 1.0 + math.cos(math.pi * epoch / max_epoch) + ) + min_lr + for param_group in optimizer.param_groups: + param_group["lr"] = lr + + +def warmup_lr_schedule(optimizer, step, max_step, init_lr, max_lr): + """Warmup the learning rate""" + lr = min(max_lr, init_lr + (max_lr - init_lr) * step / max(max_step, 1)) + for param_group in optimizer.param_groups: + param_group["lr"] = lr + diff --git a/examples/graphtranslator/Translator/utils.py b/examples/graphtranslator/Translator/utils.py new file mode 100755 index 000000000..1dae7227a --- /dev/null +++ b/examples/graphtranslator/Translator/utils.py @@ -0,0 +1,322 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import json + +from omegaconf import OmegaConf + +class Config: + def __init__(self, args): + self.config = {} + + self.args = args + + + user_config = self._build_opt_list(self.args.options) + + config = OmegaConf.load(self.args.cfg_path) + + runner_config = self.build_runner_config(config) + model_config = self.build_model_config(config, **user_config) + dataset_config = self.build_dataset_config(config) + + # Override the default configuration with user options. + self.config = OmegaConf.merge( + runner_config, model_config, dataset_config, user_config + ) + + + def _build_opt_list(self, opts): + opts_dot_list = self._convert_to_dot_list(opts) + return OmegaConf.from_dotlist(opts_dot_list) + + @staticmethod + def build_model_config(config, **kwargs): + model = config.get("model", None) + assert model is not None, "Missing model configuration file." + + model_type = kwargs.get("model.model_type", None) + if not model_type: + model_type = model.get("model_type", None) + # else use the model type selected by user. + + assert model_type is not None, "Missing model_type." + + + model_config = OmegaConf.create() + # hiararchy override, customized config > default config + model_config = OmegaConf.merge( + model_config, + config, + {"model": config["model"]}, + ) + + return model_config + + @staticmethod + def build_runner_config(config): + return {"run": config.run} + + @staticmethod + def build_dataset_config(config): + datasets = config.get("datasets", None) + if datasets is None: + raise KeyError( + "Expecting 'datasets' as the root key for dataset configuration." + ) + + dataset_config = OmegaConf.create() + + for dataset_name in datasets: + + # hiararchy override, customized config > default config + dataset_config = OmegaConf.merge( + dataset_config, + config, + {"datasets": {dataset_name: config["datasets"][dataset_name]}}, + ) + + return dataset_config + + def _convert_to_dot_list(self, opts): + if opts is None: + opts = [] + + if len(opts) == 0: + return opts + + has_equal = opts[0].find("=") != -1 + + if has_equal: + return opts + + return [(opt + "=" + value) for opt, value in zip(opts[0::2], opts[1::2])] + + def get_config(self): + return self.config + + @property + def run_cfg(self): + return self.config.run + + @property + def datasets_cfg(self): + return self.config.datasets + + @property + def model_cfg(self): + return self.config.model + + @property + def prompt_cfg(self): + return self.config.prompt + + def pretty_print(self): + logging.info("\n===== Running Parameters =====") + logging.info(self._convert_node_to_json(self.config.run)) + + logging.info("\n====== Dataset Attributes ======") + datasets = self.config.datasets + + for dataset in datasets: + if dataset in self.config.datasets: + logging.info(f"\n======== {dataset} =======") + dataset_config = self.config.datasets[dataset] + logging.info(self._convert_node_to_json(dataset_config)) + else: + logging.warning(f"No dataset named '{dataset}' in config. Skipping") + + logging.info(f"\n====== Model Attributes ======") + logging.info(self._convert_node_to_json(self.config.model)) + + def _convert_node_to_json(self, node): + container = OmegaConf.to_container(node, resolve=True) + return json.dumps(container, indent=4, sort_keys=True) + + def to_dict(self): + return OmegaConf.to_container(self.config) + +import datetime +import time +from collections import defaultdict, deque + +import torch + +class SmoothedValue(object): + """Track a series of values and provide access to smoothed values over a + window or the global series average. + """ + + def __init__(self, window_size=20, fmt=None): + if fmt is None: + fmt = "{median:.4f} ({global_avg:.4f})" + self.deque = deque(maxlen=window_size) + self.total = 0.0 + self.count = 0 + self.fmt = fmt + + def update(self, value, n=1): + self.deque.append(value) + self.count += n + self.total += value * n + + def synchronize_between_processes(self): + """ + Warning: does not synchronize the deque! + """ + if True: + return + + # t = torch.tensor([self.count, self.total], dtype=torch.float64, device="cuda") + # dist.barrier() + # dist.all_reduce(t) + # t = t.tolist() + # self.count = int(t[0]) + # self.total = t[1] + + @property + def median(self): + d = torch.tensor(list(self.deque)) + return d.median().item() + + @property + def avg(self): + d = torch.tensor(list(self.deque), dtype=torch.float32) + return d.mean().item() + + @property + def global_avg(self): + return self.total / self.count + + @property + def max(self): + return max(self.deque) + + @property + def value(self): + return self.deque[-1] + + def __str__(self): + return self.fmt.format( + median=self.median, + avg=self.avg, + global_avg=self.global_avg, + max=self.max, + value=self.value, + ) + + +class MetricLogger(object): + def __init__(self, delimiter="\t"): + self.meters = defaultdict(SmoothedValue) + self.delimiter = delimiter + + def update(self, **kwargs): + for k, v in kwargs.items(): + if isinstance(v, torch.Tensor): + v = v.item() + assert isinstance(v, (float, int)) + self.meters[k].update(v) + + def __getattr__(self, attr): + if attr in self.meters: + return self.meters[attr] + if attr in self.__dict__: + return self.__dict__[attr] + raise AttributeError( + "'{}' object has no attribute '{}'".format(type(self).__name__, attr) + ) + + def __str__(self): + loss_str = [] + for name, meter in self.meters.items(): + loss_str.append("{}: {}".format(name, str(meter))) + return self.delimiter.join(loss_str) + + def global_avg(self): + loss_str = [] + for name, meter in self.meters.items(): + loss_str.append("{}: {:.8f}".format(name, meter.global_avg)) + return self.delimiter.join(loss_str) + + def synchronize_between_processes(self): + for meter in self.meters.values(): + meter.synchronize_between_processes() + + def add_meter(self, name, meter): + self.meters[name] = meter + + def log_every(self, iterable, print_freq, total_iter, header=None): + i = 0 + if not header: + header = "" + start_time = time.time() + end = time.time() + iter_time = SmoothedValue(fmt="{avg:.4f}") + data_time = SmoothedValue(fmt="{avg:.4f}") + space_fmt = ':' + str(len(str(total_iter))) + 'd' + log_msg = [ + header, + "[{0" + space_fmt + "}/{1}]", + "eta: {eta}", + "{meters}", + "time: {time}", + "data: {data}", + ] + if torch.cuda.is_available(): + log_msg.append("max mem: {memory:.0f}") + log_msg = self.delimiter.join(log_msg) + MB = 1024.0 * 1024.0 + + for obj in iterable: + data_time.update(time.time() - end) + yield obj + iter_time.update(time.time() - end) + if i % print_freq == 0 or i == total_iter - 1: + eta_seconds = iter_time.global_avg * (total_iter - i) + eta_string = str(datetime.timedelta(seconds=int(eta_seconds))) + if torch.cuda.is_available(): + print( + log_msg.format( + i, + total_iter, + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + memory=torch.cuda.max_memory_allocated() / MB, + ) + ) + else: + print( + log_msg.format( + i, + total_iter, + eta=eta_string, + meters=str(self), + time=str(iter_time), + data=str(data_time), + ) + ) + i += 1 + end = time.time() + total_time = time.time() - start_time + total_time_str = str(datetime.timedelta(seconds=int(total_time))) + print( + "{} Total time: {} ({:.4f} s / it)".format( + header, total_time_str, total_time / total_iter + ) + ) + + +def setup_logger(): + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] %(message)s", + handlers=[logging.StreamHandler()], + ) diff --git a/gammagl/models/__init__.py b/gammagl/models/__init__.py index 2f5f1c196..7cf2ec290 100644 --- a/gammagl/models/__init__.py +++ b/gammagl/models/__init__.py @@ -66,6 +66,7 @@ from .gcil import GCILModel, LogReg from .sgformer import SGFormerModel from .adagad import PreModel, ReModel +from .graphtranslator import TranslatorCHATGLMArxiv, TranslatorQformerArxiv __all__ = [ 'HeCo', diff --git a/gammagl/models/graphtranslator/Qformer.py b/gammagl/models/graphtranslator/Qformer.py new file mode 100755 index 000000000..870802118 --- /dev/null +++ b/gammagl/models/graphtranslator/Qformer.py @@ -0,0 +1,1202 @@ +""" + * Copyright (c) 2023, salesforce.com, inc. + * All rights reserved. + * SPDX-License-Identifier: BSD-3-Clause + * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause + * By Junnan Li + * Based on huggingface code base + * https://github.com/huggingface/transformers/blob/v4.15.0/src/transformers/models/bert +""" + +import math +from typing import Tuple +import torch +from torch import Tensor, device, nn +import torch.utils.checkpoint +from torch.nn import CrossEntropyLoss +from transformers.activations import ACT2FN +from transformers.modeling_outputs import ( + BaseModelOutputWithPastAndCrossAttentions, + BaseModelOutputWithPoolingAndCrossAttentions, + CausalLMOutputWithCrossAttentions, + MaskedLMOutput, +) +from transformers.modeling_utils import ( + PreTrainedModel, + apply_chunking_to_forward, + find_pruneable_heads_and_indices, + prune_linear_layer, +) +from transformers.utils import logging +from transformers.models.bert.configuration_bert import BertConfig + +logger = logging.get_logger(__name__) + + +class BertEmbeddings(nn.Module): + """Construct the embeddings from word and position embeddings.""" + + def __init__(self, config): + super().__init__() + self.word_embeddings = nn.Embedding( + config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id + ) + self.position_embeddings = nn.Embedding( + config.max_position_embeddings, config.hidden_size + ) + + # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load + # any TensorFlow checkpoint file + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + # position_ids (1, len position emb) is contiguous in memory and exported when serialized + self.register_buffer( + "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)) + ) + self.position_embedding_type = getattr( + config, "position_embedding_type", "absolute" + ) + + self.config = config + + def forward( + self, + input_ids=None, + position_ids=None, + query_embeds=None, + past_key_values_length=0, + ): + if input_ids is not None: + seq_length = input_ids.size()[1] + else: + seq_length = 0 + + if position_ids is None: + position_ids = self.position_ids[ + :, past_key_values_length : seq_length + past_key_values_length + ].clone() + + if input_ids is not None: + embeddings = self.word_embeddings(input_ids) + if self.position_embedding_type == "absolute": + position_embeddings = self.position_embeddings(position_ids) + embeddings = embeddings + position_embeddings + + if query_embeds is not None: + embeddings = torch.cat((query_embeds, embeddings), dim=1) + else: + embeddings = query_embeds + + embeddings = self.LayerNorm(embeddings) + embeddings = self.dropout(embeddings) + return embeddings + + +class BertSelfAttention(nn.Module): + def __init__(self, config, is_cross_attention): + super().__init__() + self.config = config + if config.hidden_size % config.num_attention_heads != 0 and not hasattr( + config, "embedding_size" + ): + raise ValueError( + "The hidden size (%d) is not a multiple of the number of attention " + "heads (%d)" % (config.hidden_size, config.num_attention_heads) + ) + + self.num_attention_heads = config.num_attention_heads + self.attention_head_size = int(config.hidden_size / config.num_attention_heads) + self.all_head_size = self.num_attention_heads * self.attention_head_size + + self.query = nn.Linear(config.hidden_size, self.all_head_size) + if is_cross_attention: + self.key = nn.Linear(config.encoder_width, self.all_head_size) + self.value = nn.Linear(config.encoder_width, self.all_head_size) + else: + self.key = nn.Linear(config.hidden_size, self.all_head_size) + self.value = nn.Linear(config.hidden_size, self.all_head_size) + + self.dropout = nn.Dropout(config.attention_probs_dropout_prob) + self.position_embedding_type = getattr( + config, "position_embedding_type", "absolute" + ) + if ( + self.position_embedding_type == "relative_key" + or self.position_embedding_type == "relative_key_query" + ): + self.max_position_embeddings = config.max_position_embeddings + self.distance_embedding = nn.Embedding( + 2 * config.max_position_embeddings - 1, self.attention_head_size + ) + self.save_attention = False + + def save_attn_gradients(self, attn_gradients): + self.attn_gradients = attn_gradients + + def get_attn_gradients(self): + return self.attn_gradients + + def save_attention_map(self, attention_map): + self.attention_map = attention_map + + def get_attention_map(self): + return self.attention_map + + def transpose_for_scores(self, x): + new_x_shape = x.size()[:-1] + ( + self.num_attention_heads, + self.attention_head_size, + ) + x = x.view(*new_x_shape) + return x.permute(0, 2, 1, 3) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + ): + + # If this is instantiated as a cross-attention module, the keys + # and values come from an encoder; the attention mask needs to be + # such that the encoder's padding tokens are not attended to. + is_cross_attention = encoder_hidden_states is not None + + if is_cross_attention: + key_layer = self.transpose_for_scores(self.key(encoder_hidden_states)) + value_layer = self.transpose_for_scores(self.value(encoder_hidden_states)) + attention_mask = encoder_attention_mask + elif past_key_value is not None: + key_layer = self.transpose_for_scores(self.key(hidden_states)) + value_layer = self.transpose_for_scores(self.value(hidden_states)) + key_layer = torch.cat([past_key_value[0], key_layer], dim=2) + value_layer = torch.cat([past_key_value[1], value_layer], dim=2) + else: + key_layer = self.transpose_for_scores(self.key(hidden_states)) + value_layer = self.transpose_for_scores(self.value(hidden_states)) + + mixed_query_layer = self.query(hidden_states) + + query_layer = self.transpose_for_scores(mixed_query_layer) + + past_key_value = (key_layer, value_layer) + + # Take the dot product between "query" and "key" to get the raw attention scores. + attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2)) + + if ( + self.position_embedding_type == "relative_key" + or self.position_embedding_type == "relative_key_query" + ): + seq_length = hidden_states.size()[1] + position_ids_l = torch.arange( + seq_length, dtype=torch.long, device=hidden_states.device + ).view(-1, 1) + position_ids_r = torch.arange( + seq_length, dtype=torch.long, device=hidden_states.device + ).view(1, -1) + distance = position_ids_l - position_ids_r + positional_embedding = self.distance_embedding( + distance + self.max_position_embeddings - 1 + ) + positional_embedding = positional_embedding.to( + dtype=query_layer.dtype + ) # fp16 compatibility + + if self.position_embedding_type == "relative_key": + relative_position_scores = torch.einsum( + "bhld,lrd->bhlr", query_layer, positional_embedding + ) + attention_scores = attention_scores + relative_position_scores + elif self.position_embedding_type == "relative_key_query": + relative_position_scores_query = torch.einsum( + "bhld,lrd->bhlr", query_layer, positional_embedding + ) + relative_position_scores_key = torch.einsum( + "bhrd,lrd->bhlr", key_layer, positional_embedding + ) + attention_scores = ( + attention_scores + + relative_position_scores_query + + relative_position_scores_key + ) + + attention_scores = attention_scores / math.sqrt(self.attention_head_size) + if attention_mask is not None: + # Apply the attention mask is (precomputed for all layers in BertModel forward() function) + attention_scores = attention_scores + attention_mask + + # Normalize the attention scores to probabilities. + attention_probs = nn.Softmax(dim=-1)(attention_scores) + + if is_cross_attention and self.save_attention: + self.save_attention_map(attention_probs) + attention_probs.register_hook(self.save_attn_gradients) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs_dropped = self.dropout(attention_probs) + + # Mask heads if we want to + if head_mask is not None: + attention_probs_dropped = attention_probs_dropped * head_mask + + context_layer = torch.matmul(attention_probs_dropped, value_layer) + + context_layer = context_layer.permute(0, 2, 1, 3).contiguous() + new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,) + context_layer = context_layer.view(*new_context_layer_shape) + + outputs = ( + (context_layer, attention_probs) if output_attentions else (context_layer,) + ) + + outputs = outputs + (past_key_value,) + return outputs + + +class BertSelfOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class BertAttention(nn.Module): + def __init__(self, config, is_cross_attention=False): + super().__init__() + self.self = BertSelfAttention(config, is_cross_attention) + self.output = BertSelfOutput(config) + self.pruned_heads = set() + + def prune_heads(self, heads): + if len(heads) == 0: + return + heads, index = find_pruneable_heads_and_indices( + heads, + self.self.num_attention_heads, + self.self.attention_head_size, + self.pruned_heads, + ) + + # Prune linear layers + self.self.query = prune_linear_layer(self.self.query, index) + self.self.key = prune_linear_layer(self.self.key, index) + self.self.value = prune_linear_layer(self.self.value, index) + self.output.dense = prune_linear_layer(self.output.dense, index, dim=1) + + # Update hyper params and store pruned heads + self.self.num_attention_heads = self.self.num_attention_heads - len(heads) + self.self.all_head_size = ( + self.self.attention_head_size * self.self.num_attention_heads + ) + self.pruned_heads = self.pruned_heads.union(heads) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + ): + self_outputs = self.self( + hidden_states, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + past_key_value, + output_attentions, + ) + attention_output = self.output(self_outputs[0], hidden_states) + + outputs = (attention_output,) + self_outputs[ + 1: + ] # add attentions if we output them + return outputs + + +class BertIntermediate(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.intermediate_size) + if isinstance(config.hidden_act, str): + self.intermediate_act_fn = ACT2FN[config.hidden_act] + else: + self.intermediate_act_fn = config.hidden_act + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.intermediate_act_fn(hidden_states) + return hidden_states + + +class BertOutput(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.intermediate_size, config.hidden_size) + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + self.dropout = nn.Dropout(config.hidden_dropout_prob) + + def forward(self, hidden_states, input_tensor): + hidden_states = self.dense(hidden_states) + hidden_states = self.dropout(hidden_states) + hidden_states = self.LayerNorm(hidden_states + input_tensor) + return hidden_states + + +class BertLayer(nn.Module): + def __init__(self, config, layer_num): + super().__init__() + self.config = config + self.chunk_size_feed_forward = config.chunk_size_feed_forward + self.seq_len_dim = 1 + self.attention = BertAttention(config) + self.layer_num = layer_num + if ( + self.config.add_cross_attention + and layer_num % self.config.cross_attention_freq == 0 + ): + self.crossattention = BertAttention( + config, is_cross_attention=self.config.add_cross_attention + ) + self.has_cross_attention = True + else: + self.has_cross_attention = False + self.intermediate = BertIntermediate(config) + self.output = BertOutput(config) + + self.intermediate_query = BertIntermediate(config) + self.output_query = BertOutput(config) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_value=None, + output_attentions=False, + query_length=0, + ): + # decoder uni-directional self-attention cached key/values tuple is at positions 1,2 + self_attn_past_key_value = ( + past_key_value[:2] if past_key_value is not None else None + ) + self_attention_outputs = self.attention( + hidden_states, + attention_mask, + head_mask, + output_attentions=output_attentions, + past_key_value=self_attn_past_key_value, + ) + attention_output = self_attention_outputs[0] + outputs = self_attention_outputs[1:-1] + + present_key_value = self_attention_outputs[-1] + + if query_length > 0: + query_attention_output = attention_output[:, :query_length, :] + + if self.has_cross_attention: + assert ( + encoder_hidden_states is not None + ), "encoder_hidden_states must be given for cross-attention layers" + + cross_attention_outputs = self.crossattention( + query_attention_output, + attention_mask, + head_mask, + encoder_hidden_states, + encoder_attention_mask, + output_attentions=output_attentions, + ) + query_attention_output = cross_attention_outputs[0] + outputs = ( + outputs + cross_attention_outputs[1:-1] + ) # add cross attentions if we output attention weights + + layer_output = apply_chunking_to_forward( + self.feed_forward_chunk_query, + self.chunk_size_feed_forward, + self.seq_len_dim, + query_attention_output, + ) + if attention_output.shape[1] > query_length: + layer_output_text = apply_chunking_to_forward( + self.feed_forward_chunk, + self.chunk_size_feed_forward, + self.seq_len_dim, + attention_output[:, query_length:, :], + ) + layer_output = torch.cat([layer_output, layer_output_text], dim=1) + else: + layer_output = apply_chunking_to_forward( + self.feed_forward_chunk, + self.chunk_size_feed_forward, + self.seq_len_dim, + attention_output, + ) + outputs = (layer_output,) + outputs + + outputs = outputs + (present_key_value,) + + return outputs + + def feed_forward_chunk(self, attention_output): + intermediate_output = self.intermediate(attention_output) + layer_output = self.output(intermediate_output, attention_output) + return layer_output + + def feed_forward_chunk_query(self, attention_output): + intermediate_output = self.intermediate_query(attention_output) + layer_output = self.output_query(intermediate_output, attention_output) + return layer_output + + +class BertEncoder(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.layer = nn.ModuleList( + [BertLayer(config, i) for i in range(config.num_hidden_layers)] + ) + + def forward( + self, + hidden_states, + attention_mask=None, + head_mask=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=False, + output_hidden_states=False, + return_dict=True, + query_length=0, + ): + all_hidden_states = () if output_hidden_states else None + all_self_attentions = () if output_attentions else None + all_cross_attentions = ( + () if output_attentions and self.config.add_cross_attention else None + ) + + next_decoder_cache = () if use_cache else None + + for i in range(self.config.num_hidden_layers): + layer_module = self.layer[i] + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + layer_head_mask = head_mask[i] if head_mask is not None else None + past_key_value = past_key_values[i] if past_key_values is not None else None + + if getattr(self.config, "gradient_checkpointing", False) and self.training: + + if use_cache: + logger.warn( + "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..." + ) + use_cache = False + + def create_custom_forward(module): + def custom_forward(*inputs): + return module( + *inputs, past_key_value, output_attentions, query_length + ) + + return custom_forward + + layer_outputs = torch.utils.checkpoint.checkpoint( + create_custom_forward(layer_module), + hidden_states, + attention_mask, + layer_head_mask, + encoder_hidden_states, + encoder_attention_mask, + ) + else: + layer_outputs = layer_module( + hidden_states, + attention_mask, + layer_head_mask, + encoder_hidden_states, + encoder_attention_mask, + past_key_value, + output_attentions, + query_length, + ) + + hidden_states = layer_outputs[0] + if use_cache: + next_decoder_cache += (layer_outputs[-1],) + if output_attentions: + all_self_attentions = all_self_attentions + (layer_outputs[1],) + all_cross_attentions = all_cross_attentions + (layer_outputs[2],) + + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + if not return_dict: + return tuple( + v + for v in [ + hidden_states, + next_decoder_cache, + all_hidden_states, + all_self_attentions, + all_cross_attentions, + ] + if v is not None + ) + return BaseModelOutputWithPastAndCrossAttentions( + last_hidden_state=hidden_states, + past_key_values=next_decoder_cache, + hidden_states=all_hidden_states, + attentions=all_self_attentions, + cross_attentions=all_cross_attentions, + ) + + +class BertPooler(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + self.activation = nn.Tanh() + + def forward(self, hidden_states): + # We "pool" the model by simply taking the hidden state corresponding + # to the first token. + first_token_tensor = hidden_states[:, 0] + pooled_output = self.dense(first_token_tensor) + pooled_output = self.activation(pooled_output) + return pooled_output + + +class BertPredictionHeadTransform(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + if isinstance(config.hidden_act, str): + self.transform_act_fn = ACT2FN[config.hidden_act] + else: + self.transform_act_fn = config.hidden_act + self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps) + + def forward(self, hidden_states): + hidden_states = self.dense(hidden_states) + hidden_states = self.transform_act_fn(hidden_states) + hidden_states = self.LayerNorm(hidden_states) + return hidden_states + + +class BertLMPredictionHead(nn.Module): + def __init__(self, config): + super().__init__() + self.transform = BertPredictionHeadTransform(config) + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + self.bias = nn.Parameter(torch.zeros(config.vocab_size)) + + # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings` + self.decoder.bias = self.bias + + def forward(self, hidden_states): + hidden_states = self.transform(hidden_states) + hidden_states = self.decoder(hidden_states) + return hidden_states + + +class BertOnlyMLMHead(nn.Module): + def __init__(self, config): + super().__init__() + self.predictions = BertLMPredictionHead(config) + + def forward(self, sequence_output): + prediction_scores = self.predictions(sequence_output) + return prediction_scores + + +class BertPreTrainedModel(PreTrainedModel): + """ + An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained + models. + """ + + config_class = BertConfig + base_model_prefix = "bert" + _keys_to_ignore_on_load_missing = [r"position_ids"] + + def _init_weights(self, module): + """Initialize the weights""" + if isinstance(module, (nn.Linear, nn.Embedding)): + # Slightly different from the TF version which uses truncated_normal for initialization + # cf https://github.com/pytorch/pytorch/pull/5617 + module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + + +class BertModel(BertPreTrainedModel): + """ + The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of + cross-attention is added between the self-attention layers, following the architecture described in `Attention is + all you need `__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, + Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin. + argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an + input to the forward pass. + """ + + def __init__(self, config, add_pooling_layer=False): + super().__init__(config) + self.config = config + + self.embeddings = BertEmbeddings(config) + + self.encoder = BertEncoder(config) + + self.pooler = BertPooler(config) if add_pooling_layer else None + + self.init_weights() + + def get_input_embeddings(self): + return self.embeddings.word_embeddings + + def set_input_embeddings(self, value): + self.embeddings.word_embeddings = value + + def _prune_heads(self, heads_to_prune): + """ + Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base + class PreTrainedModel + """ + for layer, heads in heads_to_prune.items(): + self.encoder.layer[layer].attention.prune_heads(heads) + + def get_extended_attention_mask( + self, + attention_mask: Tensor, + input_shape: Tuple[int], + device: device, + is_decoder: bool, + has_query: bool = False, + ) -> Tensor: + """ + Makes broadcastable attention and causal masks so that future and masked tokens are ignored. + + Arguments: + attention_mask (:obj:`torch.Tensor`): + Mask with ones indicating tokens to attend to, zeros for tokens to ignore. + input_shape (:obj:`Tuple[int]`): + The shape of the input to the model. + device: (:obj:`torch.device`): + The device of the input to the model. + + Returns: + :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`. + """ + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + if attention_mask.dim() == 3: + extended_attention_mask = attention_mask[:, None, :, :] + elif attention_mask.dim() == 2: + # Provided a padding mask of dimensions [batch_size, seq_length] + # - if the model is a decoder, apply a causal mask in addition to the padding mask + # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length] + if is_decoder: + batch_size, seq_length = input_shape + + seq_ids = torch.arange(seq_length, device=device) + causal_mask = ( + seq_ids[None, None, :].repeat(batch_size, seq_length, 1) + <= seq_ids[None, :, None] + ) + + # add a prefix ones mask to the causal mask + # causal and attention masks must have same type with pytorch version < 1.3 + causal_mask = causal_mask.to(attention_mask.dtype) + + if causal_mask.shape[1] < attention_mask.shape[1]: + prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1] + if has_query: # UniLM style attention mask + causal_mask = torch.cat( + [ + torch.zeros( + (batch_size, prefix_seq_len, seq_length), + device=device, + dtype=causal_mask.dtype, + ), + causal_mask, + ], + axis=1, + ) + causal_mask = torch.cat( + [ + torch.ones( + (batch_size, causal_mask.shape[1], prefix_seq_len), + device=device, + dtype=causal_mask.dtype, + ), + causal_mask, + ], + axis=-1, + ) + extended_attention_mask = ( + causal_mask[:, None, :, :] * attention_mask[:, None, None, :] + ) + else: + extended_attention_mask = attention_mask[:, None, None, :] + else: + raise ValueError( + "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format( + input_shape, attention_mask.shape + ) + ) + + # Since attention_mask is 1.0 for positions we want to attend and 0.0 for + # masked positions, this operation will create a tensor which is 0.0 for + # positions we want to attend and -10000.0 for masked positions. + # Since we are adding it to the raw scores before the softmax, this is + # effectively the same as removing these entirely. + extended_attention_mask = extended_attention_mask.to( + dtype=self.dtype + ) # fp16 compatibility + extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0 + return extended_attention_mask + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + past_key_values=None, + use_cache=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + is_decoder=False, + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + """ + output_attentions = ( + output_attentions + if output_attentions is not None + else self.config.output_attentions + ) + output_hidden_states = ( + output_hidden_states + if output_hidden_states is not None + else self.config.output_hidden_states + ) + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + # use_cache = use_cache if use_cache is not None else self.config.use_cache + + if input_ids is None: + assert ( + query_embeds is not None + ), "You have to specify query_embeds when input_ids is None" + + # past_key_values_length + past_key_values_length = ( + past_key_values[0][0].shape[2] - self.config.query_length + if past_key_values is not None + else 0 + ) + + query_length = query_embeds.shape[1] if query_embeds is not None else 0 + + embedding_output = self.embeddings( + input_ids=input_ids, + position_ids=position_ids, + query_embeds=query_embeds, + past_key_values_length=past_key_values_length, + ) + + input_shape = embedding_output.size()[:-1] + batch_size, seq_length = input_shape + device = embedding_output.device + + if attention_mask is None: + attention_mask = torch.ones( + ((batch_size, seq_length + past_key_values_length)), device=device + ) + + # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] + # ourselves in which case we just need to make it broadcastable to all heads. + if is_decoder: + extended_attention_mask = self.get_extended_attention_mask( + attention_mask, + input_ids.shape, + device, + is_decoder, + has_query=(query_embeds is not None), + ) + else: + extended_attention_mask = self.get_extended_attention_mask( + attention_mask, input_shape, device, is_decoder + ) + + # If a 2D or 3D attention mask is provided for the cross-attention + # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] + if encoder_hidden_states is not None: + if type(encoder_hidden_states) == list: + encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[ + 0 + ].size() + else: + ( + encoder_batch_size, + encoder_sequence_length, + _, + ) = encoder_hidden_states.size() + encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length) + + if type(encoder_attention_mask) == list: + encoder_extended_attention_mask = [ + self.invert_attention_mask(mask) for mask in encoder_attention_mask + ] + elif encoder_attention_mask is None: + encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device) + encoder_extended_attention_mask = self.invert_attention_mask( + encoder_attention_mask + ) + else: + encoder_extended_attention_mask = self.invert_attention_mask( + encoder_attention_mask + ) + else: + encoder_extended_attention_mask = None + + # Prepare head mask if needed + # 1.0 in head_mask indicate we keep the head + # attention_probs has shape bsz x n_heads x N x N + # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] + # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] + head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers) + + encoder_outputs = self.encoder( + embedding_output, + attention_mask=extended_attention_mask, + head_mask=head_mask, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_extended_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + query_length=query_length, + ) + sequence_output = encoder_outputs[0] + pooled_output = ( + self.pooler(sequence_output) if self.pooler is not None else None + ) + + if not return_dict: + return (sequence_output, pooled_output) + encoder_outputs[1:] + + return BaseModelOutputWithPoolingAndCrossAttentions( + last_hidden_state=sequence_output, + pooler_output=pooled_output, + past_key_values=encoder_outputs.past_key_values, + hidden_states=encoder_outputs.hidden_states, + attentions=encoder_outputs.attentions, + cross_attentions=encoder_outputs.cross_attentions, + ) + + +class BertLMHeadModel(BertPreTrainedModel): + + _keys_to_ignore_on_load_unexpected = [r"pooler"] + _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"] + + def __init__(self, config): + super().__init__(config) + + self.bert = BertModel(config, add_pooling_layer=False) + self.cls = BertOnlyMLMHead(config) + + self.init_weights() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + labels=None, + past_key_values=None, + use_cache=True, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + return_logits=False, + is_decoder=True, + reduction="mean", + ): + r""" + encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`): + Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if + the model is configured as a decoder. + encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in + the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``: + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in + ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are + ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]`` + past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`): + Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding. + If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids` + (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)` + instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`. + use_cache (:obj:`bool`, `optional`): + If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up + decoding (see :obj:`past_key_values`). + Returns: + Example:: + >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig + >>> import torch + >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased') + >>> config = BertConfig.from_pretrained("bert-base-cased") + >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config) + >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt") + >>> outputs = model(**inputs) + >>> prediction_logits = outputs.logits + """ + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + if labels is not None: + use_cache = False + if past_key_values is not None: + query_embeds = None + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + head_mask=head_mask, + query_embeds=query_embeds, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + past_key_values=past_key_values, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + is_decoder=is_decoder, + ) + + sequence_output = outputs[0] + if query_embeds is not None: + sequence_output = outputs[0][:, query_embeds.shape[1] :, :] + + prediction_scores = self.cls(sequence_output) + + if return_logits: + return prediction_scores[:, :-1, :].contiguous() + + lm_loss = None + if labels is not None: + # we are doing next-token prediction; shift prediction scores and input ids by one + shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous() + labels = labels[:, 1:].contiguous() + loss_fct = CrossEntropyLoss(reduction=reduction, label_smoothing=0.1) + lm_loss = loss_fct( + shifted_prediction_scores.view(-1, self.config.vocab_size), + labels.view(-1), + ) + if reduction == "none": + lm_loss = lm_loss.view(prediction_scores.size(0), -1).sum(1) + + if not return_dict: + output = (prediction_scores,) + outputs[2:] + return ((lm_loss,) + output) if lm_loss is not None else output + + return CausalLMOutputWithCrossAttentions( + loss=lm_loss, + logits=prediction_scores, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + cross_attentions=outputs.cross_attentions, + ) + + def prepare_inputs_for_generation( + self, input_ids, query_embeds, past=None, attention_mask=None, **model_kwargs + ): + # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly + if attention_mask is None: + attention_mask = input_ids.new_ones(input_ids.shape) + query_mask = input_ids.new_ones(query_embeds.shape[:-1]) + attention_mask = torch.cat([query_mask, attention_mask], dim=-1) + + # cut decoder_input_ids if past is used + if past is not None: + input_ids = input_ids[:, -1:] + + return { + "input_ids": input_ids, + "query_embeds": query_embeds, + "attention_mask": attention_mask, + "past_key_values": past, + "encoder_hidden_states": model_kwargs.get("encoder_hidden_states", None), + "encoder_attention_mask": model_kwargs.get("encoder_attention_mask", None), + "is_decoder": True, + } + + def _reorder_cache(self, past, beam_idx): + reordered_past = () + for layer_past in past: + reordered_past += ( + tuple( + past_state.index_select(0, beam_idx) for past_state in layer_past + ), + ) + return reordered_past + + +class BertForMaskedLM(BertPreTrainedModel): + + _keys_to_ignore_on_load_unexpected = [r"pooler"] + _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"] + + def __init__(self, config): + super().__init__(config) + + self.bert = BertModel(config, add_pooling_layer=False) + self.cls = BertOnlyMLMHead(config) + + self.init_weights() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + + def forward( + self, + input_ids=None, + attention_mask=None, + position_ids=None, + head_mask=None, + query_embeds=None, + encoder_hidden_states=None, + encoder_attention_mask=None, + labels=None, + output_attentions=None, + output_hidden_states=None, + return_dict=None, + return_logits=False, + is_decoder=False, + ): + r""" + labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`): + Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ..., + config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored + (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]`` + """ + + return_dict = ( + return_dict if return_dict is not None else self.config.use_return_dict + ) + + outputs = self.bert( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + head_mask=head_mask, + query_embeds=query_embeds, + encoder_hidden_states=encoder_hidden_states, + encoder_attention_mask=encoder_attention_mask, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + is_decoder=is_decoder, + ) + + if query_embeds is not None: + sequence_output = outputs[0][:, query_embeds.shape[1] :, :] + prediction_scores = self.cls(sequence_output) + + if return_logits: + return prediction_scores + + masked_lm_loss = None + if labels is not None: + loss_fct = CrossEntropyLoss() # -100 index = padding token + masked_lm_loss = loss_fct( + prediction_scores.view(-1, self.config.vocab_size), labels.view(-1) + ) + + if not return_dict: + output = (prediction_scores,) + outputs[2:] + return ( + ((masked_lm_loss,) + output) if masked_lm_loss is not None else output + ) + + return MaskedLMOutput( + loss=masked_lm_loss, + logits=prediction_scores, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) diff --git a/gammagl/models/graphtranslator/__init__.py b/gammagl/models/graphtranslator/__init__.py new file mode 100755 index 000000000..e8aff1b42 --- /dev/null +++ b/gammagl/models/graphtranslator/__init__.py @@ -0,0 +1,2 @@ +from .translator_chatglm_arxiv import TranslatorCHATGLMArxiv +from .translator_qformer_arxiv import TranslatorQformerArxiv \ No newline at end of file diff --git a/gammagl/models/graphtranslator/base_model.py b/gammagl/models/graphtranslator/base_model.py new file mode 100755 index 000000000..53e714102 --- /dev/null +++ b/gammagl/models/graphtranslator/base_model.py @@ -0,0 +1,128 @@ +""" + Copyright (c) 2022, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" + +import logging +import os + +import torch +import tensorlayerx.nn as nn + + + +class BaseModel(nn.Module): + """Base class for models.""" + + def __init__(self): + super().__init__() + + @property + def device(self): + return list(self.parameters())[0].device + + def load_checkpoint(self, url_or_filename): + """ + Load from a finetuned checkpoint. + + This should expect no mismatch in the model keys and the checkpoint keys. + """ + + if os.path.isfile(url_or_filename): + checkpoint = torch.load(url_or_filename, map_location="cpu") + else: + raise RuntimeError("checkpoint url or path is invalid") + + if "model" in checkpoint.keys(): + state_dict = checkpoint["model"] + else: + state_dict = checkpoint + + msg = self.load_state_dict(state_dict, strict=False) + + logging.info("Missing keys {}".format(msg.missing_keys)) + logging.info("load checkpoint from %s" % url_or_filename) + + return msg + + def load_checkpoint_from_config(self, cfg, **kwargs): + """ + Load checkpoint as specified in the config file. + + If load_finetuned is True, load the finetuned model; otherwise, load the pretrained model. + When loading the pretrained model, each task-specific architecture may define their + own load_from_pretrained() method. + """ + load_finetuned = cfg.get("load_finetuned", True) + if load_finetuned: + finetune_path = cfg.get("finetuned", None) + assert ( + finetune_path is not None + ), "Found load_finetuned is True, but finetune_path is None." + self.load_checkpoint(url_or_filename=finetune_path) + else: + # load pre-trained weights + pretrain_path = cfg.get("pretrained", None) + assert "Found load_finetuned is False, but pretrain_path is None." + self.load_from_pretrained(url_or_filename=pretrain_path, **kwargs) + + def before_evaluation(self, **kwargs): + pass + + +class GatherLayer(torch.autograd.Function): + """ + Gather tensors from all workers with support for backward propagation: + This implementation does not cut the gradients as torch.distributed.all_gather does. + """ + + @staticmethod + def forward(ctx, x): + output = [ + torch.zeros_like(x) for _ in range(torch.distributed.get_world_size()) + ] + torch.distributed.all_gather(output, x) + return tuple(output) + + @staticmethod + def backward(ctx, *grads): + all_gradients = torch.stack(grads) + torch.distributed.all_reduce(all_gradients) + return all_gradients[torch.distributed.get_rank()] + + +def all_gather_with_grad(tensors): + """ + Performs all_gather operation on the provided tensors. + Graph remains connected for backward grad computation. + """ + # Queue the gathered tensors + # world_size = torch.distributed.get_world_size() + world_size = 1 + # There is no need for reduction in the single-proc case + if world_size == 1: + return tensors + + tensor_all = GatherLayer.apply(tensors) + + return torch.cat(tensor_all, dim=0) + + +@torch.no_grad() +def concat_all_gather(tensor): + """ + Performs all_gather operation on the provided tensors. + *** Warning ***: torch.distributed.all_gather has no gradient. + """ + if True: + return tensor + + tensors_gather = [ + torch.ones_like(tensor) for _ in range(torch.distributed.get_world_size()) + ] + torch.distributed.all_gather(tensors_gather, tensor, async_op=False) + + output = torch.cat(tensors_gather, dim=0) + return output diff --git a/gammagl/models/graphtranslator/chatglm2/MODEL_LICENSE.txt b/gammagl/models/graphtranslator/chatglm2/MODEL_LICENSE.txt new file mode 100644 index 000000000..cabffea1c --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/MODEL_LICENSE.txt @@ -0,0 +1,65 @@ +The ChatGLM2-6B License + +1. 定义 + +“许可方”是指分发其软件的 ChatGLM2-6B 模型团队。 + +“软件”是指根据本许可提供的 ChatGLM2-6B 模型参数。 + +2. 许可授予 + +根据本许可的条款和条件，许可方特此授予您非排他性、全球性、不可转让、不可再许可、可撤销、免版税的版权许可。 + +上述版权声明和本许可声明应包含在本软件的所有副本或重要部分中。 + +3.限制 + +您不得出于任何军事或非法目的使用、复制、修改、合并、发布、分发、复制或创建本软件的全部或部分衍生作品。 + +您不得利用本软件从事任何危害国家安全和国家统一、危害社会公共利益、侵犯人身权益的行为。 + +4.免责声明 + +本软件“按原样”提供，不提供任何明示或暗示的保证，包括但不限于对适销性、特定用途的适用性和非侵权性的保证。 在任何情况下，作者或版权持有人均不对任何索赔、损害或其他责任负责，无论是在合同诉讼、侵权行为还是其他方面，由软件或软件的使用或其他交易引起、由软件引起或与之相关 软件。 + +5. 责任限制 + +除适用法律禁止的范围外，在任何情况下且根据任何法律理论，无论是基于侵权行为、疏忽、合同、责任或其他原因，任何许可方均不对您承担任何直接、间接、特殊、偶然、示范性、 或间接损害，或任何其他商业损失，即使许可人已被告知此类损害的可能性。 + +6.争议解决 + +本许可受中华人民共和国法律管辖并按其解释。 因本许可引起的或与本许可有关的任何争议应提交北京市海淀区人民法院。 + +请注意，许可证可能会更新到更全面的版本。 有关许可和版权的任何问题，请通过 license@zhipuai.cn 与我们联系。 + +1. Definitions + +“Licensor” means the ChatGLM2-6B Model Team that distributes its Software. + +“Software” means the ChatGLM2-6B model parameters made available under this license. + +2. License Grant + +Subject to the terms and conditions of this License, the Licensor hereby grants to you a non-exclusive, worldwide, non-transferable, non-sublicensable, revocable, royalty-free copyright license to use the Software. + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +3. Restriction + +You will not use, copy, modify, merge, publish, distribute, reproduce, or create derivative works of the Software, in whole or in part, for any military, or illegal purposes. + +You will not use the Software for any act that may undermine China's national security and national unity, harm the public interest of society, or infringe upon the rights and interests of human beings. + +4. Disclaimer + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +5. Limitation of Liability + +EXCEPT TO THE EXTENT PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER BASED IN TORT, NEGLIGENCE, CONTRACT, LIABILITY, OR OTHERWISE WILL ANY LICENSOR BE LIABLE TO YOU FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES, OR ANY OTHER COMMERCIAL LOSSES, EVEN IF THE LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +6. Dispute Resolution + +This license shall be governed and construed in accordance with the laws of People’s Republic of China. Any dispute arising from or in connection with this License shall be submitted to Haidian District People's Court in Beijing. + +Note that the license is subject to update to a more comprehensive version. For any questions related to the license and copyright, please contact us at license@zhipuai.cn. diff --git a/gammagl/models/graphtranslator/chatglm2/README.md b/gammagl/models/graphtranslator/chatglm2/README.md new file mode 100644 index 000000000..c6be3a505 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/README.md @@ -0,0 +1,97 @@ +--- +language: +- zh +- en +tags: +- glm +- chatglm +- thudm +--- +# ChatGLM2-6B +

+ 💻 Github Repo • 🐦 Twitter • 📃 [GLM@ACL 22] [GitHub] • 📃 [GLM-130B@ICLR 23] [GitHub]
+

+ +

+ 👋 Join our Slack and WeChat +

+ +## 介绍 +ChatGLM**2**-6B 是开源中英双语对话模型 [ChatGLM-6B](https://github.com/THUDM/ChatGLM-6B) 的第二代版本，在保留了初代模型对话流畅、部署门槛较低等众多优秀特性的基础之上，ChatGLM**2**-6B 引入了如下新特性： + +1. **更强大的性能**：基于 ChatGLM 初代模型的开发经验，我们全面升级了 ChatGLM2-6B 的基座模型。ChatGLM2-6B 使用了 [GLM](https://github.com/THUDM/GLM) 的混合目标函数，经过了 1.4T 中英标识符的预训练与人类偏好对齐训练，[评测结果](#评测结果)显示，相比于初代模型，ChatGLM2-6B 在 MMLU（+23%）、CEval（+33%）、GSM8K（+571%） 、BBH（+60%）等数据集上的性能取得了大幅度的提升，在同尺寸开源模型中具有较强的竞争力。 +2. **更长的上下文**：基于 [FlashAttention](https://github.com/HazyResearch/flash-attention) 技术，我们将基座模型的上下文长度（Context Length）由 ChatGLM-6B 的 2K 扩展到了 32K，并在对话阶段使用 8K 的上下文长度训练，允许更多轮次的对话。但当前版本的 ChatGLM2-6B 对单轮超长文档的理解能力有限，我们会在后续迭代升级中着重进行优化。 +3. **更高效的推理**：基于 [Multi-Query Attention](http://arxiv.org/abs/1911.02150) 技术，ChatGLM2-6B 有更高效的推理速度和更低的显存占用：在官方的模型实现下，推理速度相比初代提升了 42%，INT4 量化下，6G 显存支持的对话长度由 1K 提升到了 8K。 +4. **更开放的协议**：ChatGLM2-6B 权重对学术研究**完全开放**，在填写[问卷](https://open.bigmodel.cn/mla/form)进行登记后**亦允许免费商业使用**。 + +ChatGLM**2**-6B is the second-generation version of the open-source bilingual (Chinese-English) chat model [ChatGLM-6B](https://github.com/THUDM/ChatGLM-6B). It retains the smooth conversation flow and low deployment threshold of the first-generation model, while introducing the following new features: + +1. **Stronger Performance**: Based on the development experience of the first-generation ChatGLM model, we have fully upgraded the base model of ChatGLM2-6B. ChatGLM2-6B uses the hybrid objective function of [GLM](https://github.com/THUDM/GLM), and has undergone pre-training with 1.4T bilingual tokens and human preference alignment training. The [evaluation results](README.md#evaluation-results) show that, compared to the first-generation model, ChatGLM2-6B has achieved substantial improvements in performance on datasets like MMLU (+23%), CEval (+33%), GSM8K (+571%), BBH (+60%), showing strong competitiveness among models of the same size. +2. **Longer Context**: Based on [FlashAttention](https://github.com/HazyResearch/flash-attention) technique, we have extended the context length of the base model from 2K in ChatGLM-6B to 32K, and trained with a context length of 8K during the dialogue alignment, allowing for more rounds of dialogue. However, the current version of ChatGLM2-6B has limited understanding of single-round ultra-long documents, which we will focus on optimizing in future iterations. +3. **More Efficient Inference**: Based on [Multi-Query Attention](http://arxiv.org/abs/1911.02150) technique, ChatGLM2-6B has more efficient inference speed and lower GPU memory usage: under the official implementation, the inference speed has increased by 42% compared to the first generation; under INT4 quantization, the dialogue length supported by 6G GPU memory has increased from 1K to 8K. +4. **More Open License**: ChatGLM2-6B weights are **completely open** for academic research, and **free commercial use** is also allowed after completing the [questionnaire](https://open.bigmodel.cn/mla/form). + +## 软件依赖 + +```shell +pip install protobuf transformers==4.30.2 cpm_kernels torch>=2.0 gradio mdtex2html sentencepiece accelerate +``` + +## 代码调用 + +可以通过如下代码调用 ChatGLM-6B 模型来生成对话： + +```ipython +>>> from transformers import AutoTokenizer, AutoModel +>>> tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm2-6b", trust_remote_code=True) +>>> model = AutoModel.from_pretrained("THUDM/chatglm2-6b", trust_remote_code=True).half().cuda() +>>> model = model.eval() +>>> response, history = model.chat(tokenizer, "你好", history=[]) +>>> print(response) +你好👋!我是人工智能助手 ChatGLM-6B,很高兴见到你,欢迎问我任何问题。 +>>> response, history = model.chat(tokenizer, "晚上睡不着应该怎么办", history=history) +>>> print(response) +晚上睡不着可能会让你感到焦虑或不舒服,但以下是一些可以帮助你入睡的方法: + +1. 制定规律的睡眠时间表:保持规律的睡眠时间表可以帮助你建立健康的睡眠习惯,使你更容易入睡。尽量在每天的相同时间上床,并在同一时间起床。 +2. 创造一个舒适的睡眠环境:确保睡眠环境舒适,安静,黑暗且温度适宜。可以使用舒适的床上用品,并保持房间通风。 +3. 放松身心:在睡前做些放松的活动,例如泡个热水澡,听些轻柔的音乐,阅读一些有趣的书籍等,有助于缓解紧张和焦虑,使你更容易入睡。 +4. 避免饮用含有咖啡因的饮料:咖啡因是一种刺激性物质,会影响你的睡眠质量。尽量避免在睡前饮用含有咖啡因的饮料,例如咖啡,茶和可乐。 +5. 避免在床上做与睡眠无关的事情:在床上做些与睡眠无关的事情,例如看电影,玩游戏或工作等,可能会干扰你的睡眠。 +6. 尝试呼吸技巧:深呼吸是一种放松技巧,可以帮助你缓解紧张和焦虑,使你更容易入睡。试着慢慢吸气,保持几秒钟,然后缓慢呼气。 + +如果这些方法无法帮助你入睡,你可以考虑咨询医生或睡眠专家,寻求进一步的建议。 +``` + +关于更多的使用说明，包括如何运行命令行和网页版本的 DEMO，以及使用模型量化以节省显存，请参考我们的 [Github Repo](https://github.com/THUDM/ChatGLM2-6B)。 + +For more instructions, including how to run CLI and web demos, and model quantization, please refer to our [Github Repo](https://github.com/THUDM/ChatGLM2-6B). + +## Change Log +* v1.0 + +## 协议 + +本仓库的代码依照 [Apache-2.0](LICENSE) 协议开源，ChatGLM2-6B 模型的权重的使用则需要遵循 [Model License](MODEL_LICENSE)。 + +## 引用 + +如果你觉得我们的工作有帮助的话，请考虑引用下列论文，ChatGLM2-6B 的论文会在近期公布，敬请期待～ + +``` +@article{zeng2022glm, + title={Glm-130b: An open bilingual pre-trained model}, + author={Zeng, Aohan and Liu, Xiao and Du, Zhengxiao and Wang, Zihan and Lai, Hanyu and Ding, Ming and Yang, Zhuoyi and Xu, Yifan and Zheng, Wendi and Xia, Xiao and others}, + journal={arXiv preprint arXiv:2210.02414}, + year={2022} +} +``` +``` +@inproceedings{du2022glm, + title={GLM: General Language Model Pretraining with Autoregressive Blank Infilling}, + author={Du, Zhengxiao and Qian, Yujie and Liu, Xiao and Ding, Ming and Qiu, Jiezhong and Yang, Zhilin and Tang, Jie}, + booktitle={Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)}, + pages={320--335}, + year={2022} +} +``` \ No newline at end of file diff --git a/gammagl/models/graphtranslator/chatglm2/__init__.py b/gammagl/models/graphtranslator/chatglm2/__init__.py new file mode 100644 index 000000000..a356d34a2 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/__init__.py @@ -0,0 +1,5 @@ +from .modeling_chatglm import ChatGLMPreTrainedModel, ChatGLMForConditionalGeneration +from .tokenization_chatglm import ChatGLMTokenizer +from .configuration_chatglm import ChatGLMConfig + +__all__ = ["ChatGLMPreTrainedModel", "ChatGLMForConditionalGeneration", "ChatGLMConfig"] \ No newline at end of file diff --git a/gammagl/models/graphtranslator/chatglm2/config.json b/gammagl/models/graphtranslator/chatglm2/config.json new file mode 100644 index 000000000..77bf76c7d --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/config.json @@ -0,0 +1,41 @@ +{ + "_name_or_path": "THUDM/chatglm2-6b", + "model_type": "chatglm", + "architectures": [ + "ChatGLMModel" + ], + "auto_map": { + "AutoConfig": "configuration_chatglm.ChatGLMConfig", + "AutoModel": "modeling_chatglm.ChatGLMForConditionalGeneration", + "AutoModelForCausalLM": "modeling_chatglm.ChatGLMForConditionalGeneration", + "AutoModelForSeq2SeqLM": "modeling_chatglm.ChatGLMForConditionalGeneration" + }, + "add_bias_linear": false, + "add_qkv_bias": true, + "apply_query_key_layer_scaling": true, + "apply_residual_connection_post_layernorm": false, + "attention_dropout": 0.0, + "attention_softmax_in_fp32": true, + "bias_dropout_fusion": true, + "ffn_hidden_size": 13696, + "fp32_residual_connection": false, + "hidden_dropout": 0.0, + "hidden_size": 4096, + "kv_channels": 128, + "layernorm_epsilon": 1e-05, + "multi_query_attention": true, + "multi_query_group_num": 2, + "num_attention_heads": 32, + "num_layers": 28, + "original_rope": true, + "padded_vocab_size": 65024, + "post_layer_norm": true, + "rmsnorm": true, + "seq_length": 32768, + "use_cache": true, + "torch_dtype": "float16", + "transformers_version": "4.27.1", + "tie_word_embeddings": false, + "eos_token_id": 2, + "pad_token_id": 0 +} \ No newline at end of file diff --git a/gammagl/models/graphtranslator/chatglm2/configuration_chatglm.py b/gammagl/models/graphtranslator/chatglm2/configuration_chatglm.py new file mode 100644 index 000000000..3730b4e34 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/configuration_chatglm.py @@ -0,0 +1,59 @@ +from transformers import PretrainedConfig + + +class ChatGLMConfig(PretrainedConfig): + model_type = "chatglm" + def __init__( + self, + num_layers=28, + padded_vocab_size=65024, + hidden_size=4096, + ffn_hidden_size=13696, + kv_channels=128, + num_attention_heads=32, + seq_length=2048, + hidden_dropout=0.0, + attention_dropout=0.0, + layernorm_epsilon=1e-5, + rmsnorm=True, + apply_residual_connection_post_layernorm=False, + post_layer_norm=True, + add_bias_linear=False, + add_qkv_bias=False, + bias_dropout_fusion=True, + multi_query_attention=False, + multi_query_group_num=1, + apply_query_key_layer_scaling=True, + attention_softmax_in_fp32=True, + fp32_residual_connection=False, + quantization_bit=0, + pre_seq_len=None, + prefix_projection=False, + **kwargs + ): + self.num_layers = num_layers + self.vocab_size = padded_vocab_size + self.padded_vocab_size = padded_vocab_size + self.hidden_size = hidden_size + self.ffn_hidden_size = ffn_hidden_size + self.kv_channels = kv_channels + self.num_attention_heads = num_attention_heads + self.seq_length = seq_length + self.hidden_dropout = hidden_dropout + self.attention_dropout = attention_dropout + self.layernorm_epsilon = layernorm_epsilon + self.rmsnorm = rmsnorm + self.apply_residual_connection_post_layernorm = apply_residual_connection_post_layernorm + self.post_layer_norm = post_layer_norm + self.add_bias_linear = add_bias_linear + self.add_qkv_bias = add_qkv_bias + self.bias_dropout_fusion = bias_dropout_fusion + self.multi_query_attention = multi_query_attention + self.multi_query_group_num = multi_query_group_num + self.apply_query_key_layer_scaling = apply_query_key_layer_scaling + self.attention_softmax_in_fp32 = attention_softmax_in_fp32 + self.fp32_residual_connection = fp32_residual_connection + self.quantization_bit = quantization_bit + self.pre_seq_len = pre_seq_len + self.prefix_projection = prefix_projection + super().__init__(**kwargs) \ No newline at end of file diff --git a/gammagl/models/graphtranslator/chatglm2/gitattributes.txt b/gammagl/models/graphtranslator/chatglm2/gitattributes.txt new file mode 100644 index 000000000..a6344aac8 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/gitattributes.txt @@ -0,0 +1,35 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text diff --git a/gammagl/models/graphtranslator/chatglm2/modeling_chatglm.py b/gammagl/models/graphtranslator/chatglm2/modeling_chatglm.py new file mode 100644 index 000000000..688568dad --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/modeling_chatglm.py @@ -0,0 +1,1188 @@ +""" PyTorch ChatGLM model. """ + +import math +import copy +import warnings +import re +import sys + +import torch +import torch.utils.checkpoint +import torch.nn.functional as F +from torch import nn +from torch.nn import CrossEntropyLoss, LayerNorm +from torch.nn.utils import skip_init +from typing import Optional, Tuple, Union, List, Callable, Dict, Any + +from transformers.modeling_outputs import ( + BaseModelOutputWithPast, + CausalLMOutputWithPast, +) +from transformers.modeling_utils import PreTrainedModel +from transformers.utils import logging +from transformers.generation.logits_process import LogitsProcessor +from transformers.generation.utils import LogitsProcessorList, StoppingCriteriaList, GenerationConfig, ModelOutput + +from .configuration_chatglm import ChatGLMConfig + +# flags required to enable jit fusion kernels + +if sys.platform != 'darwin': + torch._C._jit_set_profiling_mode(False) + torch._C._jit_set_profiling_executor(False) + torch._C._jit_override_can_fuse_on_cpu(True) + torch._C._jit_override_can_fuse_on_gpu(True) + +logger = logging.get_logger(__name__) + +_CHECKPOINT_FOR_DOC = "THUDM/ChatGLM2-6B" +_CONFIG_FOR_DOC = "ChatGLM6BConfig" + +CHATGLM_6B_PRETRAINED_MODEL_ARCHIVE_LIST = [ + "THUDM/chatglm2-6b", + # See all ChatGLM models at https://huggingface.co/models?filter=chatglm +] + + +def default_init(cls, *args, **kwargs): + return cls(*args, **kwargs) + + +class InvalidScoreLogitsProcessor(LogitsProcessor): + def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: + if torch.isnan(scores).any() or torch.isinf(scores).any(): + scores.zero_() + scores[..., 5] = 5e4 + return scores + + +class PrefixEncoder(torch.nn.Module): + """ + The torch.nn model to encode the prefix + Input shape: (batch-size, prefix-length) + Output shape: (batch-size, prefix-length, 2*layers*hidden) + """ + + def __init__(self, config: ChatGLMConfig): + super().__init__() + self.prefix_projection = config.prefix_projection + if self.prefix_projection: + # Use a two-layer MLP to encode the prefix + kv_size = config.num_layers * config.kv_channels * config.multi_query_group_num * 2 + self.embedding = torch.nn.Embedding(config.pre_seq_len, kv_size) + self.trans = torch.nn.Sequential( + torch.nn.Linear(kv_size, config.hidden_size), + torch.nn.Tanh(), + torch.nn.Linear(config.hidden_size, kv_size) + ) + else: + self.embedding = torch.nn.Embedding(config.pre_seq_len, + config.num_layers * config.kv_channels * config.multi_query_group_num * 2) + + def forward(self, prefix: torch.Tensor): + if self.prefix_projection: + prefix_tokens = self.embedding(prefix) + past_key_values = self.trans(prefix_tokens) + else: + past_key_values = self.embedding(prefix) + return past_key_values + + +def split_tensor_along_last_dim( + tensor: torch.Tensor, + num_partitions: int, + contiguous_split_chunks: bool = False, +) -> List[torch.Tensor]: + """Split a tensor along its last dimension. + Arguments: + tensor: input tensor. + num_partitions: number of partitions to split the tensor + contiguous_split_chunks: If True, make each chunk contiguous + in memory. + Returns: + A list of Tensors + """ + # Get the size and dimension. + last_dim = tensor.dim() - 1 + last_dim_size = tensor.size()[last_dim] // num_partitions + # Split. + tensor_list = torch.split(tensor, last_dim_size, dim=last_dim) + # Note: torch.split does not create contiguous tensors by default. + if contiguous_split_chunks: + return tuple(chunk.contiguous() for chunk in tensor_list) + + return tensor_list + + +class RotaryEmbedding(nn.Module): + def __init__(self, dim, original_impl=False, device=None, dtype=None): + super().__init__() + inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2, device=device).to(dtype=dtype) / dim)) + self.register_buffer("inv_freq", inv_freq) + self.dim = dim + self.original_impl = original_impl + + def forward_impl( + self, seq_len: int, n_elem: int, dtype: torch.dtype, device: torch.device, base: int = 10000 + ): + """Enhanced Transformer with Rotary Position Embedding. + Derived from: https://github.com/labmlai/annotated_deep_learning_paper_implementations/blob/master/labml_nn/ + transformers/rope/__init__.py. MIT License: + https://github.com/labmlai/annotated_deep_learning_paper_implementations/blob/master/license. + """ + # $\Theta = {\theta_i = 10000^{\frac{2(i-1)}{d}}, i \in [1, 2, ..., \frac{d}{2}]}$ + theta = 1.0 / (base ** (torch.arange(0, n_elem, 2, dtype=dtype, device=device) / n_elem)) + + # Create position indexes `[0, 1, ..., seq_len - 1]` + seq_idx = torch.arange(seq_len, dtype=dtype, device=device) + + # Calculate the product of position index and $\theta_i$ + idx_theta = torch.outer(seq_idx, theta).float() + + cache = torch.stack([torch.cos(idx_theta), torch.sin(idx_theta)], dim=-1) + + # this is to mimic the behaviour of complex32, else we will get different results + if dtype in (torch.float16, torch.bfloat16, torch.int8): + cache = cache.bfloat16() if dtype == torch.bfloat16 else cache.half() + return cache + + def forward(self, max_seq_len, offset=0): + return self.forward_impl( + max_seq_len, self.dim, dtype=self.inv_freq.dtype, device=self.inv_freq.device + ) + + +@torch.jit.script +def apply_rotary_pos_emb(x: torch.Tensor, rope_cache: torch.Tensor) -> torch.Tensor: + # x: [sq, b, np, hn] + sq, b, np, hn = x.size(0), x.size(1), x.size(2), x.size(3) + rot_dim = rope_cache.shape[-2] * 2 + x, x_pass = x[..., :rot_dim], x[..., rot_dim:] + # truncate to support variable sizes + rope_cache = rope_cache[:sq] + xshaped = x.reshape(sq, -1, np, rot_dim // 2, 2) + rope_cache = rope_cache.view(sq, -1, 1, xshaped.size(3), 2) + x_out2 = torch.stack( + [ + xshaped[..., 0] * rope_cache[..., 0] - xshaped[..., 1] * rope_cache[..., 1], + xshaped[..., 1] * rope_cache[..., 0] + xshaped[..., 0] * rope_cache[..., 1], + ], + -1, + ) + x_out2 = x_out2.flatten(3) + return torch.cat((x_out2, x_pass), dim=-1) + + +class RMSNorm(torch.nn.Module): + def __init__(self, normalized_shape, eps=1e-5, device=None, dtype=None, **kwargs): + super().__init__() + self.weight = torch.nn.Parameter(torch.empty(normalized_shape, device=device, dtype=dtype)) + self.eps = eps + + def forward(self, hidden_states: torch.Tensor): + input_dtype = hidden_states.dtype + variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.eps) + + return (self.weight * hidden_states).to(input_dtype) + + +class CoreAttention(torch.nn.Module): + def __init__(self, config: ChatGLMConfig, layer_number): + super(CoreAttention, self).__init__() + + self.apply_query_key_layer_scaling = config.apply_query_key_layer_scaling + self.attention_softmax_in_fp32 = config.attention_softmax_in_fp32 + if self.apply_query_key_layer_scaling: + self.attention_softmax_in_fp32 = True + self.layer_number = max(1, layer_number) + + projection_size = config.kv_channels * config.num_attention_heads + + # Per attention head and per partition values. + self.hidden_size_per_partition = projection_size + self.hidden_size_per_attention_head = projection_size // config.num_attention_heads + self.num_attention_heads_per_partition = config.num_attention_heads + + coeff = None + self.norm_factor = math.sqrt(self.hidden_size_per_attention_head) + if self.apply_query_key_layer_scaling: + coeff = self.layer_number + self.norm_factor *= coeff + self.coeff = coeff + + self.attention_dropout = torch.nn.Dropout(config.attention_dropout) + + def forward(self, query_layer, key_layer, value_layer, attention_mask): + pytorch_major_version = int(torch.__version__.split('.')[0]) + if pytorch_major_version >= 2: + query_layer, key_layer, value_layer = [k.permute(1, 2, 0, 3) for k in [query_layer, key_layer, value_layer]] + if attention_mask is None and query_layer.shape[2] == key_layer.shape[2]: + context_layer = torch.nn.functional.scaled_dot_product_attention(query_layer, key_layer, value_layer, + is_causal=True) + else: + if attention_mask is not None: + attention_mask = ~attention_mask + context_layer = torch.nn.functional.scaled_dot_product_attention(query_layer, key_layer, value_layer, + attention_mask) + context_layer = context_layer.permute(2, 0, 1, 3) + new_context_layer_shape = context_layer.size()[:-2] + (self.hidden_size_per_partition,) + context_layer = context_layer.reshape(*new_context_layer_shape) + else: + # Raw attention scores + + # [b, np, sq, sk] + output_size = (query_layer.size(1), query_layer.size(2), query_layer.size(0), key_layer.size(0)) + + # [sq, b, np, hn] -> [sq, b * np, hn] + query_layer = query_layer.view(output_size[2], output_size[0] * output_size[1], -1) + # [sk, b, np, hn] -> [sk, b * np, hn] + key_layer = key_layer.view(output_size[3], output_size[0] * output_size[1], -1) + + # preallocting input tensor: [b * np, sq, sk] + matmul_input_buffer = torch.empty( + output_size[0] * output_size[1], output_size[2], output_size[3], dtype=query_layer.dtype, + device=query_layer.device + ) + + # Raw attention scores. [b * np, sq, sk] + matmul_result = torch.baddbmm( + matmul_input_buffer, + query_layer.transpose(0, 1), # [b * np, sq, hn] + key_layer.transpose(0, 1).transpose(1, 2), # [b * np, hn, sk] + beta=0.0, + alpha=(1.0 / self.norm_factor), + ) + + # change view to [b, np, sq, sk] + attention_scores = matmul_result.view(*output_size) + + # =========================== + # Attention probs and dropout + # =========================== + + # attention scores and attention mask [b, np, sq, sk] + if self.attention_softmax_in_fp32: + attention_scores = attention_scores.float() + if self.coeff is not None: + attention_scores = attention_scores * self.coeff + if attention_mask is None and attention_scores.shape[2] == attention_scores.shape[3]: + attention_mask = torch.ones(output_size[0], 1, output_size[2], output_size[3], + device=attention_scores.device, dtype=torch.bool) + attention_mask.tril_() + attention_mask = ~attention_mask + if attention_mask is not None: + attention_scores = attention_scores.masked_fill(attention_mask, float("-inf")) + attention_probs = F.softmax(attention_scores, dim=-1) + attention_probs = attention_probs.type_as(value_layer) + + # This is actually dropping out entire tokens to attend to, which might + # seem a bit unusual, but is taken from the original Transformer paper. + attention_probs = self.attention_dropout(attention_probs) + # ========================= + # Context layer. [sq, b, hp] + # ========================= + + # value_layer -> context layer. + # [sk, b, np, hn] --> [b, np, sq, hn] + + # context layer shape: [b, np, sq, hn] + output_size = (value_layer.size(1), value_layer.size(2), query_layer.size(0), value_layer.size(3)) + # change view [sk, b * np, hn] + value_layer = value_layer.view(value_layer.size(0), output_size[0] * output_size[1], -1) + # change view [b * np, sq, sk] + attention_probs = attention_probs.view(output_size[0] * output_size[1], output_size[2], -1) + # matmul: [b * np, sq, hn] + context_layer = torch.bmm(attention_probs, value_layer.transpose(0, 1)) + # change view [b, np, sq, hn] + context_layer = context_layer.view(*output_size) + # [b, np, sq, hn] --> [sq, b, np, hn] + context_layer = context_layer.permute(2, 0, 1, 3).contiguous() + # [sq, b, np, hn] --> [sq, b, hp] + new_context_layer_shape = context_layer.size()[:-2] + (self.hidden_size_per_partition,) + context_layer = context_layer.view(*new_context_layer_shape) + + return context_layer + + +class SelfAttention(torch.nn.Module): + """Parallel self-attention layer abstract class. + Self-attention layer takes input with size [s, b, h] + and returns output of the same size. + """ + + def __init__(self, config: ChatGLMConfig, layer_number, device=None): + super(SelfAttention, self).__init__() + self.layer_number = max(1, layer_number) + + self.projection_size = config.kv_channels * config.num_attention_heads + + # Per attention head and per partition values. + self.hidden_size_per_attention_head = self.projection_size // config.num_attention_heads + self.num_attention_heads_per_partition = config.num_attention_heads + + self.multi_query_attention = config.multi_query_attention + self.qkv_hidden_size = 3 * self.projection_size + if self.multi_query_attention: + self.num_multi_query_groups_per_partition = config.multi_query_group_num + self.qkv_hidden_size = ( + self.projection_size + 2 * self.hidden_size_per_attention_head * config.multi_query_group_num + ) + self.query_key_value = nn.Linear(config.hidden_size, self.qkv_hidden_size, + bias=config.add_bias_linear or config.add_qkv_bias, + device=device, **_config_to_kwargs(config) + ) + + self.core_attention = CoreAttention(config, self.layer_number) + + # Output. + self.dense = nn.Linear(self.projection_size, config.hidden_size, bias=config.add_bias_linear, + device=device, **_config_to_kwargs(config) + ) + + def _allocate_memory(self, inference_max_sequence_len, batch_size, device=None, dtype=None): + if self.multi_query_attention: + num_attention_heads = self.num_multi_query_groups_per_partition + else: + num_attention_heads = self.num_attention_heads_per_partition + return torch.empty( + inference_max_sequence_len, + batch_size, + num_attention_heads, + self.hidden_size_per_attention_head, + dtype=dtype, + device=device, + ) + + def forward( + self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True + ): + # hidden_states: [sq, b, h] + + # ================================================= + # Pre-allocate memory for key-values for inference. + # ================================================= + # ===================== + # Query, Key, and Value + # ===================== + + # Attention heads [sq, b, h] --> [sq, b, (np * 3 * hn)] + mixed_x_layer = self.query_key_value(hidden_states) + + if self.multi_query_attention: + (query_layer, key_layer, value_layer) = mixed_x_layer.split( + [ + self.num_attention_heads_per_partition * self.hidden_size_per_attention_head, + self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head, + self.num_multi_query_groups_per_partition * self.hidden_size_per_attention_head, + ], + dim=-1, + ) + query_layer = query_layer.view( + query_layer.size()[:-1] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head) + ) + key_layer = key_layer.view( + key_layer.size()[:-1] + (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head) + ) + value_layer = value_layer.view( + value_layer.size()[:-1] + + (self.num_multi_query_groups_per_partition, self.hidden_size_per_attention_head) + ) + else: + new_tensor_shape = mixed_x_layer.size()[:-1] + \ + (self.num_attention_heads_per_partition, + 3 * self.hidden_size_per_attention_head) + mixed_x_layer = mixed_x_layer.view(*new_tensor_shape) + + # [sq, b, np, 3 * hn] --> 3 [sq, b, np, hn] + (query_layer, key_layer, value_layer) = split_tensor_along_last_dim(mixed_x_layer, 3) + + # apply relative positional encoding (rotary embedding) + if rotary_pos_emb is not None: + query_layer = apply_rotary_pos_emb(query_layer, rotary_pos_emb) + key_layer = apply_rotary_pos_emb(key_layer, rotary_pos_emb) + + # adjust key and value for inference + if kv_cache is not None: + cache_k, cache_v = kv_cache + key_layer = torch.cat((cache_k, key_layer), dim=0) + value_layer = torch.cat((cache_v, value_layer), dim=0) + if use_cache: + kv_cache = (key_layer, value_layer) + else: + kv_cache = None + + if self.multi_query_attention: + key_layer = key_layer.unsqueeze(-2) + key_layer = key_layer.expand( + -1, -1, -1, self.num_attention_heads_per_partition // self.num_multi_query_groups_per_partition, -1 + ) + key_layer = key_layer.contiguous().view( + key_layer.size()[:2] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head) + ) + value_layer = value_layer.unsqueeze(-2) + value_layer = value_layer.expand( + -1, -1, -1, self.num_attention_heads_per_partition // self.num_multi_query_groups_per_partition, -1 + ) + value_layer = value_layer.contiguous().view( + value_layer.size()[:2] + (self.num_attention_heads_per_partition, self.hidden_size_per_attention_head) + ) + + # ================================== + # core attention computation + # ================================== + + context_layer = self.core_attention(query_layer, key_layer, value_layer, attention_mask) + + # ================= + # Output. [sq, b, h] + # ================= + + output = self.dense(context_layer) + + return output, kv_cache + + +def _config_to_kwargs(args): + common_kwargs = { + "dtype": args.torch_dtype, + } + return common_kwargs + + +class MLP(torch.nn.Module): + """MLP. + MLP will take the input with h hidden state, project it to 4*h + hidden dimension, perform nonlinear transformation, and project the + state back into h hidden dimension. + """ + + def __init__(self, config: ChatGLMConfig, device=None): + super(MLP, self).__init__() + + self.add_bias = config.add_bias_linear + + # Project to 4h. If using swiglu double the output width, see https://arxiv.org/pdf/2002.05202.pdf + self.dense_h_to_4h = nn.Linear( + config.hidden_size, + config.ffn_hidden_size * 2, + bias=self.add_bias, + device=device, + **_config_to_kwargs(config) + ) + + def swiglu(x): + x = torch.chunk(x, 2, dim=-1) + return F.silu(x[0]) * x[1] + + self.activation_func = swiglu + + # Project back to h. + self.dense_4h_to_h = nn.Linear( + config.ffn_hidden_size, + config.hidden_size, + bias=self.add_bias, + device=device, + **_config_to_kwargs(config) + ) + + def forward(self, hidden_states): + # [s, b, 4hp] + intermediate_parallel = self.dense_h_to_4h(hidden_states) + intermediate_parallel = self.activation_func(intermediate_parallel) + # [s, b, h] + output = self.dense_4h_to_h(intermediate_parallel) + return output + + +class GLMBlock(torch.nn.Module): + """A single transformer layer. + Transformer layer takes input with size [s, b, h] and returns an + output of the same size. + """ + + def __init__(self, config: ChatGLMConfig, layer_number, device=None): + super(GLMBlock, self).__init__() + self.layer_number = layer_number + + self.apply_residual_connection_post_layernorm = config.apply_residual_connection_post_layernorm + + self.fp32_residual_connection = config.fp32_residual_connection + + LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm + # Layernorm on the input data. + self.input_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device, + dtype=config.torch_dtype) + + # Self attention. + self.self_attention = SelfAttention(config, layer_number, device=device) + self.hidden_dropout = config.hidden_dropout + + # Layernorm on the attention output + self.post_attention_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device, + dtype=config.torch_dtype) + + # MLP + self.mlp = MLP(config, device=device) + + def forward( + self, hidden_states, attention_mask, rotary_pos_emb, kv_cache=None, use_cache=True, + ): + # hidden_states: [s, b, h] + + # Layer norm at the beginning of the transformer layer. + layernorm_output = self.input_layernorm(hidden_states) + # Self attention. + attention_output, kv_cache = self.self_attention( + layernorm_output, + attention_mask, + rotary_pos_emb, + kv_cache=kv_cache, + use_cache=use_cache + ) + + # Residual connection. + if self.apply_residual_connection_post_layernorm: + residual = layernorm_output + else: + residual = hidden_states + + layernorm_input = torch.nn.functional.dropout(attention_output, p=self.hidden_dropout, training=self.training) + layernorm_input = residual + layernorm_input + + # Layer norm post the self attention. + layernorm_output = self.post_attention_layernorm(layernorm_input) + + # MLP. + mlp_output = self.mlp(layernorm_output) + + # Second residual connection. + if self.apply_residual_connection_post_layernorm: + residual = layernorm_output + else: + residual = layernorm_input + + output = torch.nn.functional.dropout(mlp_output, p=self.hidden_dropout, training=self.training) + output = residual + output + + return output, kv_cache + + +class GLMTransformer(torch.nn.Module): + """Transformer class.""" + + def __init__(self, config: ChatGLMConfig, device=None): + super(GLMTransformer, self).__init__() + + self.fp32_residual_connection = config.fp32_residual_connection + self.post_layer_norm = config.post_layer_norm + + # Number of layers. + self.num_layers = config.num_layers + + # Transformer layers. + def build_layer(layer_number): + return GLMBlock(config, layer_number, device=device) + + self.layers = torch.nn.ModuleList([build_layer(i + 1) for i in range(self.num_layers)]) + + if self.post_layer_norm: + LayerNormFunc = RMSNorm if config.rmsnorm else LayerNorm + # Final layer norm before output. + self.final_layernorm = LayerNormFunc(config.hidden_size, eps=config.layernorm_epsilon, device=device, + dtype=config.torch_dtype) + + self.gradient_checkpointing = False + + def _get_layer(self, layer_number): + return self.layers[layer_number] + + def forward( + self, hidden_states, attention_mask, rotary_pos_emb, kv_caches=None, + use_cache: Optional[bool] = True, + output_hidden_states: Optional[bool] = False, + ): + if not kv_caches: + kv_caches = [None for _ in range(self.num_layers)] + presents = () if use_cache else None + if self.gradient_checkpointing and self.training: + if use_cache: + logger.warning_once( + "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..." + ) + use_cache = False + + all_self_attentions = None + all_hidden_states = () if output_hidden_states else None + for index in range(self.num_layers): + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + layer = self._get_layer(index) + if self.gradient_checkpointing and self.training: + layer_ret = torch.utils.checkpoint.checkpoint( + layer, + hidden_states, + attention_mask, + rotary_pos_emb, + kv_caches[index], + use_cache + ) + else: + layer_ret = layer( + hidden_states, + attention_mask, + rotary_pos_emb, + kv_cache=kv_caches[index], + use_cache=use_cache + ) + hidden_states, kv_cache = layer_ret + if use_cache: + presents = presents + (kv_cache,) + + if output_hidden_states: + all_hidden_states = all_hidden_states + (hidden_states,) + + # Final layer norm. + if self.post_layer_norm: + hidden_states = self.final_layernorm(hidden_states) + + return hidden_states, presents, all_hidden_states, all_self_attentions + + +class ChatGLMPreTrainedModel(PreTrainedModel): + """ + An abstract class to handle weights initialization and + a simple interface for downloading and loading pretrained models. + """ + + is_parallelizable = False + supports_gradient_checkpointing = True + config_class = ChatGLMConfig + base_model_prefix = "transformer" + _no_split_modules = ["GLMBlock"] + + def _init_weights(self, module: nn.Module): + """Initialize the weights.""" + return + + def get_masks(self, input_ids, past_key_values, padding_mask=None): + batch_size, seq_length = input_ids.shape + full_attention_mask = torch.ones(batch_size, seq_length, seq_length, device=input_ids.device) + full_attention_mask.tril_() + past_length = 0 + if past_key_values: + past_length = past_key_values[0][0].shape[0] + if past_length: + full_attention_mask = torch.cat((torch.ones(batch_size, seq_length, past_length, + device=input_ids.device), full_attention_mask), dim=-1) + if padding_mask is not None: + full_attention_mask = full_attention_mask * padding_mask.unsqueeze(1) + if not past_length and padding_mask is not None: + full_attention_mask -= padding_mask.unsqueeze(-1) - 1 + full_attention_mask = (full_attention_mask < 0.5).bool() + full_attention_mask.unsqueeze_(1) + return full_attention_mask + + def get_position_ids(self, input_ids, device): + batch_size, seq_length = input_ids.shape + position_ids = torch.arange(seq_length, dtype=torch.long, device=device).unsqueeze(0).repeat(batch_size, 1) + return position_ids + + def _set_gradient_checkpointing(self, module, value=False): + if isinstance(module, GLMTransformer): + module.gradient_checkpointing = value + + +class Embedding(torch.nn.Module): + """Language model embeddings.""" + + def __init__(self, config: ChatGLMConfig, device=None): + super(Embedding, self).__init__() + + self.hidden_size = config.hidden_size + # Word embeddings (parallel). + self.word_embeddings = nn.Embedding( + config.padded_vocab_size, + self.hidden_size, + dtype=config.torch_dtype, + device=device + ) + self.fp32_residual_connection = config.fp32_residual_connection + + def forward(self, input_ids): + # Embeddings. + words_embeddings = self.word_embeddings(input_ids) + embeddings = words_embeddings + # Data format change to avoid explicit tranposes : [b s h] --> [s b h]. + embeddings = embeddings.transpose(0, 1).contiguous() + # If the input flag for fp32 residual connection is set, convert for float. + if self.fp32_residual_connection: + embeddings = embeddings.float() + return embeddings + + +class ChatGLMModel(ChatGLMPreTrainedModel): + def __init__(self, config: ChatGLMConfig, device=None, empty_init=True): + super().__init__(config) + if empty_init: + init_method = skip_init + else: + init_method = default_init + init_kwargs = {} + if device is not None: + init_kwargs["device"] = device + self.embedding = init_method(Embedding, config, **init_kwargs) + self.num_layers = config.num_layers + self.multi_query_group_num = config.multi_query_group_num + self.kv_channels = config.kv_channels + + # Rotary positional embeddings + self.seq_length = config.seq_length + rotary_dim = ( + config.hidden_size // config.num_attention_heads if config.kv_channels is None else config.kv_channels + ) + + self.rotary_pos_emb = RotaryEmbedding(rotary_dim // 2, original_impl=config.original_rope, device=device, + dtype=config.torch_dtype) + self.encoder = init_method(GLMTransformer, config, **init_kwargs) + self.output_layer = init_method(nn.Linear, config.hidden_size, config.padded_vocab_size, bias=False, + dtype=config.torch_dtype, **init_kwargs) + self.pre_seq_len = config.pre_seq_len + self.prefix_projection = config.prefix_projection + if self.pre_seq_len is not None: + for param in self.parameters(): + param.requires_grad = False + self.prefix_tokens = torch.arange(self.pre_seq_len).long() + self.prefix_encoder = PrefixEncoder(config) + self.dropout = torch.nn.Dropout(0.1) + + def get_input_embeddings(self): + return self.embedding.word_embeddings + + def get_prompt(self, batch_size, device, dtype=torch.half): + prefix_tokens = self.prefix_tokens.unsqueeze(0).expand(batch_size, -1).to(device) + past_key_values = self.prefix_encoder(prefix_tokens).type(dtype) + past_key_values = past_key_values.view( + batch_size, + self.pre_seq_len, + self.num_layers * 2, + self.multi_query_group_num, + self.kv_channels + ) + # seq_len, b, nh, hidden_size + past_key_values = self.dropout(past_key_values) + past_key_values = past_key_values.permute([2, 1, 0, 3, 4]).split(2) + return past_key_values + + def forward( + self, + input_ids, + position_ids: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.BoolTensor] = None, + full_attention_mask: Optional[torch.BoolTensor] = None, + past_key_values: Optional[Tuple[Tuple[torch.Tensor, torch.Tensor], ...]] = None, + inputs_embeds: Optional[torch.Tensor] = None, + use_cache: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ): + output_hidden_states = ( + output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + ) + use_cache = use_cache if use_cache is not None else self.config.use_cache + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + batch_size, seq_length = input_ids.shape + + if inputs_embeds is None or inputs_embeds.shape[0] > seq_length: + inputs_embeds = self.embedding(input_ids) + + if self.pre_seq_len is not None: + if past_key_values is None: + past_key_values = self.get_prompt(batch_size=batch_size, device=input_ids.device, + dtype=inputs_embeds.dtype) + if attention_mask is not None: + attention_mask = torch.cat([attention_mask.new_ones((batch_size, self.pre_seq_len)), + attention_mask], dim=-1) + + if full_attention_mask is None: + if (attention_mask is not None and not attention_mask.all()) or (past_key_values and seq_length != 1): + full_attention_mask = self.get_masks(input_ids, past_key_values, padding_mask=attention_mask) + + # Rotary positional embeddings + rotary_pos_emb = self.rotary_pos_emb(self.seq_length) + if position_ids is not None: + rotary_pos_emb = rotary_pos_emb[position_ids] + else: + rotary_pos_emb = rotary_pos_emb[None, :seq_length] + rotary_pos_emb = rotary_pos_emb.transpose(0, 1).contiguous() + + # Run encoder. + hidden_states, presents, all_hidden_states, all_self_attentions = self.encoder( + inputs_embeds, full_attention_mask, rotary_pos_emb=rotary_pos_emb, + kv_caches=past_key_values, use_cache=use_cache, output_hidden_states=output_hidden_states + ) + + if not return_dict: + return tuple(v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] if v is not None) + + return BaseModelOutputWithPast( + last_hidden_state=hidden_states, + past_key_values=presents, + hidden_states=all_hidden_states, + attentions=all_self_attentions, + ) + + def quantize(self, weight_bit_width: int): + from .quantization import quantize + quantize(self.encoder, weight_bit_width) + return self + + +class ChatGLMForConditionalGeneration(ChatGLMPreTrainedModel): + def __init__(self, config: ChatGLMConfig, empty_init=True, device=None): + super().__init__(config) + + self.max_sequence_length = config.max_length + self.transformer = ChatGLMModel(config, empty_init=empty_init, device=device) + self.config = config + self.quantized = False + + if self.config.quantization_bit: + self.quantize(self.config.quantization_bit, empty_init=True) + + def _update_model_kwargs_for_generation( + self, + outputs: ModelOutput, + model_kwargs: Dict[str, Any], + is_encoder_decoder: bool = False, + standardize_cache_format: bool = False, + ) -> Dict[str, Any]: + # update past_key_values + model_kwargs["past_key_values"] = self._extract_past_from_model_output( + outputs, standardize_cache_format=standardize_cache_format + ) + + # update attention mask + if "attention_mask" in model_kwargs: + attention_mask = model_kwargs["attention_mask"] + model_kwargs["attention_mask"] = torch.cat( + [attention_mask, attention_mask.new_ones((attention_mask.shape[0], 1))], dim=-1 + ) + + # update position ids + if "position_ids" in model_kwargs: + position_ids = model_kwargs["position_ids"] + new_position_id = position_ids[..., -1:].clone() + new_position_id += 1 + model_kwargs["position_ids"] = torch.cat( + [position_ids, new_position_id], dim=-1 + ) + + model_kwargs["is_first_forward"] = False + return model_kwargs + + def prepare_inputs_for_generation( + self, + input_ids: torch.LongTensor, + inputs_embeds: Optional[torch.Tensor] = None, + past_key_values: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.Tensor] = None, + is_first_forward: bool = True, + **kwargs + ) -> dict: + # only last token for input_ids if past is not None + if position_ids is None: + position_ids = self.get_position_ids(input_ids, device=input_ids.device) + if not is_first_forward: + position_ids = position_ids[..., -1:] + input_ids = input_ids[:, -1:] + return { + "input_ids": input_ids, + "inputs_embeds": inputs_embeds, + "past_key_values": past_key_values, + "position_ids": position_ids, + "attention_mask": attention_mask, + "return_last_logit": True + } + + def forward( + self, + input_ids: Optional[torch.Tensor] = None, + position_ids: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + past_key_values: Optional[Tuple[torch.FloatTensor]] = None, + inputs_embeds: Optional[torch.Tensor] = None, + labels: Optional[torch.Tensor] = None, + use_cache: Optional[bool] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + return_last_logit: Optional[bool] = False, + ): + use_cache = use_cache if use_cache is not None else self.config.use_cache + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + transformer_outputs = self.transformer( + input_ids=input_ids, + position_ids=position_ids, + attention_mask=attention_mask, + past_key_values=past_key_values, + inputs_embeds=inputs_embeds, + use_cache=use_cache, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + hidden_states = transformer_outputs[0] + if return_last_logit: + hidden_states = hidden_states[-1:] + lm_logits = self.transformer.output_layer(hidden_states) + lm_logits = lm_logits.transpose(0, 1).contiguous() + + loss = None + if labels is not None: + lm_logits = lm_logits.to(torch.float32) + + # Shift so that tokens < n predict n + shift_logits = lm_logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + # Flatten the tokens + loss_fct = CrossEntropyLoss(ignore_index=-100) + loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)) + + lm_logits = lm_logits.to(hidden_states.dtype) + loss = loss.to(hidden_states.dtype) + + if not return_dict: + output = (lm_logits,) + transformer_outputs[1:] + return ((loss,) + output) if loss is not None else output + + return CausalLMOutputWithPast( + loss=loss, + logits=lm_logits, + past_key_values=transformer_outputs.past_key_values, + hidden_states=transformer_outputs.hidden_states, + attentions=transformer_outputs.attentions, + ) + + @staticmethod + def _reorder_cache( + past: Tuple[Tuple[torch.Tensor, torch.Tensor], ...], beam_idx: torch.LongTensor + ) -> Tuple[Tuple[torch.Tensor, torch.Tensor], ...]: + """ + This function is used to re-order the `past_key_values` cache if [`~PreTrainedModel.beam_search`] or + [`~PreTrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct + beam_idx at every generation step. + Output shares the same memory storage as `past`. + """ + return tuple( + ( + layer_past[0].index_select(1, beam_idx.to(layer_past[0].device)), + layer_past[1].index_select(1, beam_idx.to(layer_past[1].device)), + ) + for layer_past in past + ) + + def process_response(self, response): + response = response.strip() + response = response.replace("[[训练时间]]", "2023年") + return response + + def build_inputs(self, tokenizer, query: str, history: List[Tuple[str, str]] = None): + prompt = tokenizer.build_prompt(query, history=history) + inputs = tokenizer([prompt], return_tensors="pt") + inputs = inputs.to(self.device) + return inputs + + def build_stream_inputs(self, tokenizer, query: str, history: List[Tuple[str, str]] = None): + if history: + prompt = "\n\n[Round {}]\n\n问：{}\n\n答：".format(len(history) + 1, query) + input_ids = tokenizer.encode(prompt, add_special_tokens=False) + input_ids = input_ids[1:] + inputs = tokenizer.batch_encode_plus([(input_ids, None)], return_tensors="pt", add_special_tokens=False) + else: + prompt = "[Round {}]\n\n问：{}\n\n答：".format(len(history) + 1, query) + inputs = tokenizer([prompt], return_tensors="pt") + inputs = inputs.to(self.device) + return inputs + + @torch.inference_mode() + def chat(self, tokenizer, query: str, history: List[Tuple[str, str]] = None, max_length: int = 8192, num_beams=1, + do_sample=True, top_p=0.8, temperature=0.8, logits_processor=None, **kwargs): + if history is None: + history = [] + if logits_processor is None: + logits_processor = LogitsProcessorList() + logits_processor.append(InvalidScoreLogitsProcessor()) + gen_kwargs = {"max_length": max_length, "num_beams": num_beams, "do_sample": do_sample, "top_p": top_p, + "temperature": temperature, "logits_processor": logits_processor, **kwargs} + inputs = self.build_inputs(tokenizer, query, history=history) + outputs = self.generate(**inputs, **gen_kwargs) + outputs = outputs.tolist()[0][len(inputs["input_ids"][0]):] + response = tokenizer.decode(outputs) + response = self.process_response(response) + history = history + [(query, response)] + return response, history + + @torch.inference_mode() + def stream_chat(self, tokenizer, query: str, history: List[Tuple[str, str]] = None, past_key_values=None, + max_length: int = 8192, do_sample=True, top_p=0.8, temperature=0.8, logits_processor=None, + return_past_key_values=False, **kwargs): + if history is None: + history = [] + if logits_processor is None: + logits_processor = LogitsProcessorList() + logits_processor.append(InvalidScoreLogitsProcessor()) + gen_kwargs = {"max_length": max_length, "do_sample": do_sample, "top_p": top_p, + "temperature": temperature, "logits_processor": logits_processor, **kwargs} + if past_key_values is None and not return_past_key_values: + inputs = self.build_inputs(tokenizer, query, history=history) + else: + inputs = self.build_stream_inputs(tokenizer, query, history=history) + if past_key_values is not None: + past_length = past_key_values[0][0].shape[0] + if self.transformer.pre_seq_len is not None: + past_length -= self.transformer.pre_seq_len + inputs.position_ids += past_length + attention_mask = inputs.attention_mask + attention_mask = torch.cat((attention_mask.new_ones(1, past_length), attention_mask), dim=1) + inputs['attention_mask'] = attention_mask + for outputs in self.stream_generate(**inputs, past_key_values=past_key_values, + return_past_key_values=return_past_key_values, **gen_kwargs): + if return_past_key_values: + outputs, past_key_values = outputs + outputs = outputs.tolist()[0][len(inputs["input_ids"][0]):] + response = tokenizer.decode(outputs) + if response and response[-1] != "�": + response = self.process_response(response) + new_history = history + [(query, response)] + if return_past_key_values: + yield response, new_history, past_key_values + else: + yield response, new_history + + @torch.inference_mode() + def stream_generate( + self, + input_ids, + generation_config: Optional[GenerationConfig] = None, + logits_processor: Optional[LogitsProcessorList] = None, + stopping_criteria: Optional[StoppingCriteriaList] = None, + prefix_allowed_tokens_fn: Optional[Callable[[int, torch.Tensor], List[int]]] = None, + return_past_key_values=False, + **kwargs, + ): + batch_size, input_ids_seq_length = input_ids.shape[0], input_ids.shape[-1] + + if generation_config is None: + generation_config = self.generation_config + generation_config = copy.deepcopy(generation_config) + model_kwargs = generation_config.update(**kwargs) + bos_token_id, eos_token_id = generation_config.bos_token_id, generation_config.eos_token_id + + if isinstance(eos_token_id, int): + eos_token_id = [eos_token_id] + + has_default_max_length = kwargs.get("max_length") is None and generation_config.max_length is not None + if has_default_max_length and generation_config.max_new_tokens is None: + warnings.warn( + f"Using `max_length`'s default ({generation_config.max_length}) to control the generation length. " + "This behaviour is deprecated and will be removed from the config in v5 of Transformers -- we" + " recommend using `max_new_tokens` to control the maximum length of the generation.", + UserWarning, + ) + elif generation_config.max_new_tokens is not None: + generation_config.max_length = generation_config.max_new_tokens + input_ids_seq_length + if not has_default_max_length: + logger.warn( + f"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(=" + f"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. " + "Please refer to the documentation for more information. " + "(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)", + UserWarning, + ) + + if input_ids_seq_length >= generation_config.max_length: + input_ids_string = "decoder_input_ids" if self.config.is_encoder_decoder else "input_ids" + logger.warning( + f"Input length of {input_ids_string} is {input_ids_seq_length}, but `max_length` is set to" + f" {generation_config.max_length}. This can lead to unexpected behavior. You should consider" + " increasing `max_new_tokens`." + ) + + # 2. Set generation parameters if not already defined + logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList() + stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList() + + logits_processor = self._get_logits_processor( + generation_config=generation_config, + input_ids_seq_length=input_ids_seq_length, + encoder_input_ids=input_ids, + prefix_allowed_tokens_fn=prefix_allowed_tokens_fn, + logits_processor=logits_processor, + ) + + stopping_criteria = self._get_stopping_criteria( + generation_config=generation_config, stopping_criteria=stopping_criteria + ) + logits_warper = self._get_logits_warper(generation_config) + + unfinished_sequences = input_ids.new(input_ids.shape[0]).fill_(1) + scores = None + while True: + model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs) + # forward pass to get next token + outputs = self( + **model_inputs, + return_dict=True, + output_attentions=False, + output_hidden_states=False, + ) + + next_token_logits = outputs.logits[:, -1, :] + + # pre-process distribution + next_token_scores = logits_processor(input_ids, next_token_logits) + next_token_scores = logits_warper(input_ids, next_token_scores) + + # sample + probs = nn.functional.softmax(next_token_scores, dim=-1) + if generation_config.do_sample: + next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1) + else: + next_tokens = torch.argmax(probs, dim=-1) + + # update generated ids, model inputs, and length for next step + input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1) + model_kwargs = self._update_model_kwargs_for_generation( + outputs, model_kwargs, is_encoder_decoder=self.config.is_encoder_decoder + ) + unfinished_sequences = unfinished_sequences.mul((sum(next_tokens != i for i in eos_token_id)).long()) + if return_past_key_values: + yield input_ids, outputs.past_key_values + else: + yield input_ids + # stop when each sentence is finished, or if we exceed the maximum length + if unfinished_sequences.max() == 0 or stopping_criteria(input_ids, scores): + break + + def quantize(self, bits: int, empty_init=False, device=None, **kwargs): + if bits == 0: + return + + from .quantization import quantize + + if self.quantized: + logger.info("Already quantized.") + return self + + self.quantized = True + + self.config.quantization_bit = bits + + self.transformer.encoder = quantize(self.transformer.encoder, bits, empty_init=empty_init, device=device, + **kwargs) + return self \ No newline at end of file diff --git a/gammagl/models/graphtranslator/chatglm2/pytorch_model.bin.index.json b/gammagl/models/graphtranslator/chatglm2/pytorch_model.bin.index.json new file mode 100644 index 000000000..fb856bdb5 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/pytorch_model.bin.index.json @@ -0,0 +1,207 @@ +{ + "metadata": { + "total_size": 12487168064 + }, + "weight_map": { + "transformer.embedding.word_embeddings.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.final_layernorm.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.0.input_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.0.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.0.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.0.post_attention_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.0.self_attention.dense.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.0.self_attention.query_key_value.bias": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.0.self_attention.query_key_value.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.input_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.post_attention_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.self_attention.dense.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.self_attention.query_key_value.bias": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.1.self_attention.query_key_value.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.10.input_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.10.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.10.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.10.post_attention_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.10.self_attention.dense.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.10.self_attention.query_key_value.bias": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.10.self_attention.query_key_value.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.input_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.post_attention_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.self_attention.dense.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.self_attention.query_key_value.bias": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.11.self_attention.query_key_value.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.12.input_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.12.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.12.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.12.post_attention_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.12.self_attention.dense.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.12.self_attention.query_key_value.bias": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.12.self_attention.query_key_value.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.13.input_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.13.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.13.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.13.post_attention_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.13.self_attention.dense.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.13.self_attention.query_key_value.bias": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.13.self_attention.query_key_value.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.input_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.post_attention_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.self_attention.dense.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.self_attention.query_key_value.bias": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.14.self_attention.query_key_value.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.input_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.post_attention_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.self_attention.dense.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.self_attention.query_key_value.bias": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.15.self_attention.query_key_value.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.input_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.mlp.dense_4h_to_h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.mlp.dense_h_to_4h.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.post_attention_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.self_attention.dense.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.self_attention.query_key_value.bias": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.16.self_attention.query_key_value.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.17.input_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.17.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.17.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.17.post_attention_layernorm.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.17.self_attention.dense.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.17.self_attention.query_key_value.bias": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.17.self_attention.query_key_value.weight": "pytorch_model-00004-of-00007.bin", + "transformer.encoder.layers.18.input_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.18.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.18.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.18.post_attention_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.18.self_attention.dense.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.18.self_attention.query_key_value.bias": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.18.self_attention.query_key_value.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.input_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.post_attention_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.self_attention.dense.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.self_attention.query_key_value.bias": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.19.self_attention.query_key_value.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.2.input_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.2.mlp.dense_4h_to_h.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.2.mlp.dense_h_to_4h.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.2.post_attention_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.2.self_attention.dense.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.2.self_attention.query_key_value.bias": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.2.self_attention.query_key_value.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.20.input_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.20.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.20.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.20.post_attention_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.20.self_attention.dense.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.20.self_attention.query_key_value.bias": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.20.self_attention.query_key_value.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.input_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.mlp.dense_4h_to_h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.mlp.dense_h_to_4h.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.post_attention_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.self_attention.dense.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.self_attention.query_key_value.bias": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.21.self_attention.query_key_value.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.22.input_layernorm.weight": "pytorch_model-00005-of-00007.bin", + "transformer.encoder.layers.22.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.22.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.22.post_attention_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.22.self_attention.dense.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.22.self_attention.query_key_value.bias": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.22.self_attention.query_key_value.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.input_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.post_attention_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.self_attention.dense.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.self_attention.query_key_value.bias": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.23.self_attention.query_key_value.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.input_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.post_attention_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.self_attention.dense.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.self_attention.query_key_value.bias": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.24.self_attention.query_key_value.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.input_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.mlp.dense_4h_to_h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.post_attention_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.self_attention.dense.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.self_attention.query_key_value.bias": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.25.self_attention.query_key_value.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.26.input_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.26.mlp.dense_4h_to_h.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.26.mlp.dense_h_to_4h.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.26.post_attention_layernorm.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.26.self_attention.dense.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.26.self_attention.query_key_value.bias": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.26.self_attention.query_key_value.weight": "pytorch_model-00006-of-00007.bin", + "transformer.encoder.layers.27.input_layernorm.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.27.mlp.dense_4h_to_h.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.27.mlp.dense_h_to_4h.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.27.post_attention_layernorm.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.27.self_attention.dense.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.27.self_attention.query_key_value.bias": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.27.self_attention.query_key_value.weight": "pytorch_model-00007-of-00007.bin", + "transformer.encoder.layers.3.input_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.3.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.3.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.3.post_attention_layernorm.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.3.self_attention.dense.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.3.self_attention.query_key_value.bias": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.3.self_attention.query_key_value.weight": "pytorch_model-00001-of-00007.bin", + "transformer.encoder.layers.4.input_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.4.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.4.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.4.post_attention_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.4.self_attention.dense.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.4.self_attention.query_key_value.bias": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.4.self_attention.query_key_value.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.input_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.post_attention_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.self_attention.dense.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.self_attention.query_key_value.bias": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.5.self_attention.query_key_value.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.input_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.post_attention_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.self_attention.dense.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.self_attention.query_key_value.bias": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.6.self_attention.query_key_value.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.input_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.mlp.dense_4h_to_h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.mlp.dense_h_to_4h.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.post_attention_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.self_attention.dense.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.self_attention.query_key_value.bias": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.7.self_attention.query_key_value.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.8.input_layernorm.weight": "pytorch_model-00002-of-00007.bin", + "transformer.encoder.layers.8.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.8.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.8.post_attention_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.8.self_attention.dense.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.8.self_attention.query_key_value.bias": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.8.self_attention.query_key_value.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.input_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.mlp.dense_4h_to_h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.mlp.dense_h_to_4h.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.post_attention_layernorm.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.self_attention.dense.weight": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.self_attention.query_key_value.bias": "pytorch_model-00003-of-00007.bin", + "transformer.encoder.layers.9.self_attention.query_key_value.weight": "pytorch_model-00003-of-00007.bin", + "transformer.output_layer.weight": "pytorch_model-00007-of-00007.bin", + "transformer.rotary_pos_emb.inv_freq": "pytorch_model-00001-of-00007.bin" + } +} diff --git a/gammagl/models/graphtranslator/chatglm2/quantization.py b/gammagl/models/graphtranslator/chatglm2/quantization.py new file mode 100644 index 000000000..cb95bfe82 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/quantization.py @@ -0,0 +1,188 @@ +from torch.nn import Linear +from torch.nn.parameter import Parameter + +import bz2 +import torch +import base64 +import ctypes +from transformers.utils import logging + +from typing import List +from functools import partial + +logger = logging.get_logger(__name__) + +try: + from cpm_kernels.kernels.base import LazyKernelCModule, KernelFunction, round_up + + class Kernel: + def __init__(self, code: bytes, function_names: List[str]): + self.code = code + self._function_names = function_names + self._cmodule = LazyKernelCModule(self.code) + + for name in self._function_names: + setattr(self, name, KernelFunction(self._cmodule, name)) + + quantization_code = "$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" + + kernels = Kernel( + bz2.decompress(base64.b64decode(quantization_code)), + [ + "int4WeightCompression", + "int4WeightExtractionFloat", + "int4WeightExtractionHalf", + "int8WeightExtractionFloat", + "int8WeightExtractionHalf", + ], + ) +except Exception as exception: + kernels = None + logger.warning("Failed to load cpm_kernels:" + str(exception)) + + +class W8A16Linear(torch.autograd.Function): + @staticmethod + def forward(ctx, inp: torch.Tensor, quant_w: torch.Tensor, scale_w: torch.Tensor, weight_bit_width): + ctx.inp_shape = inp.size() + ctx.weight_bit_width = weight_bit_width + out_features = quant_w.size(0) + inp = inp.contiguous().view(-1, inp.size(-1)) + weight = extract_weight_to_half(quant_w, scale_w, weight_bit_width) + ctx.weight_shape = weight.size() + output = inp.mm(weight.t()) + ctx.save_for_backward(inp, quant_w, scale_w) + return output.view(*(ctx.inp_shape[:-1] + (out_features,))) + + @staticmethod + def backward(ctx, grad_output: torch.Tensor): + inp, quant_w, scale_w = ctx.saved_tensors + weight = extract_weight_to_half(quant_w, scale_w, ctx.weight_bit_width) + grad_output = grad_output.contiguous().view(-1, weight.size(0)) + grad_input = grad_output.mm(weight) + grad_weight = grad_output.t().mm(inp) + return grad_input.view(ctx.inp_shape), grad_weight.view(ctx.weight_shape), None, None + + +def compress_int4_weight(weight: torch.Tensor): # (n, m) + with torch.cuda.device(weight.device): + n, m = weight.size(0), weight.size(1) + assert m % 2 == 0 + m = m // 2 + out = torch.empty(n, m, dtype=torch.int8, device="cuda") + stream = torch.cuda.current_stream() + + gridDim = (n, 1, 1) + blockDim = (min(round_up(m, 32), 1024), 1, 1) + + kernels.int4WeightCompression( + gridDim, + blockDim, + 0, + stream, + [ctypes.c_void_p(weight.data_ptr()), ctypes.c_void_p(out.data_ptr()), ctypes.c_int32(n), ctypes.c_int32(m)], + ) + return out + + +def extract_weight_to_half(weight: torch.Tensor, scale_list: torch.Tensor, source_bit_width: int): + assert scale_list.dtype in [torch.half, torch.bfloat16] + assert weight.dtype in [torch.int8] + if source_bit_width == 8: + return weight.to(scale_list.dtype) * scale_list[:, None] + elif source_bit_width == 4: + func = ( + kernels.int4WeightExtractionHalf if scale_list.dtype == torch.half else kernels.int4WeightExtractionBFloat16 + ) + else: + assert False, "Unsupported bit-width" + + with torch.cuda.device(weight.device): + n, m = weight.size(0), weight.size(1) + out = torch.empty(n, m * (8 // source_bit_width), dtype=scale_list.dtype, device="cuda") + stream = torch.cuda.current_stream() + + gridDim = (n, 1, 1) + blockDim = (min(round_up(m, 32), 1024), 1, 1) + + func( + gridDim, + blockDim, + 0, + stream, + [ + ctypes.c_void_p(weight.data_ptr()), + ctypes.c_void_p(scale_list.data_ptr()), + ctypes.c_void_p(out.data_ptr()), + ctypes.c_int32(n), + ctypes.c_int32(m), + ], + ) + return out + + +class QuantizedLinear(torch.nn.Module): + def __init__(self, weight_bit_width: int, weight, bias=None, device="cpu", dtype=None, empty_init=False, *args, + **kwargs): + super().__init__() + self.weight_bit_width = weight_bit_width + + shape = weight.shape + + if weight is None or empty_init: + self.weight = torch.empty(shape[0], shape[1] * weight_bit_width // 8, dtype=torch.int8, device=device) + self.weight_scale = torch.empty(shape[0], dtype=dtype, device=device) + else: + self.weight_scale = weight.abs().max(dim=-1).values / ((2 ** (weight_bit_width - 1)) - 1) + self.weight = torch.round(weight / self.weight_scale[:, None]).to(torch.int8) + if weight_bit_width == 4: + self.weight = compress_int4_weight(self.weight) + + self.weight = Parameter(self.weight.to(device), requires_grad=False) + self.weight_scale = Parameter(self.weight_scale.to(device), requires_grad=False) + self.bias = Parameter(bias.to(device), requires_grad=False) if bias is not None else None + + def forward(self, input): + output = W8A16Linear.apply(input, self.weight, self.weight_scale, self.weight_bit_width) + if self.bias is not None: + output = output + self.bias + return output + + +def quantize(model, weight_bit_width, empty_init=False, device=None): + """Replace fp16 linear with quantized linear""" + for layer in model.layers: + layer.self_attention.query_key_value = QuantizedLinear( + weight_bit_width=weight_bit_width, + weight=layer.self_attention.query_key_value.weight.to(torch.cuda.current_device()), + bias=layer.self_attention.query_key_value.bias, + dtype=layer.self_attention.query_key_value.weight.dtype, + device=layer.self_attention.query_key_value.weight.device if device is None else device, + empty_init=empty_init + ) + layer.self_attention.dense = QuantizedLinear( + weight_bit_width=weight_bit_width, + weight=layer.self_attention.dense.weight.to(torch.cuda.current_device()), + bias=layer.self_attention.dense.bias, + dtype=layer.self_attention.dense.weight.dtype, + device=layer.self_attention.dense.weight.device if device is None else device, + empty_init=empty_init + ) + layer.mlp.dense_h_to_4h = QuantizedLinear( + weight_bit_width=weight_bit_width, + weight=layer.mlp.dense_h_to_4h.weight.to(torch.cuda.current_device()), + bias=layer.mlp.dense_h_to_4h.bias, + dtype=layer.mlp.dense_h_to_4h.weight.dtype, + device=layer.mlp.dense_h_to_4h.weight.device if device is None else device, + empty_init=empty_init + ) + layer.mlp.dense_4h_to_h = QuantizedLinear( + weight_bit_width=weight_bit_width, + weight=layer.mlp.dense_4h_to_h.weight.to(torch.cuda.current_device()), + bias=layer.mlp.dense_4h_to_h.bias, + dtype=layer.mlp.dense_4h_to_h.weight.dtype, + device=layer.mlp.dense_4h_to_h.weight.device if device is None else device, + empty_init=empty_init + ) + + return model diff --git a/gammagl/models/graphtranslator/chatglm2/special_tokens_map.json b/gammagl/models/graphtranslator/chatglm2/special_tokens_map.json new file mode 100644 index 000000000..1f897c919 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/special_tokens_map.json @@ -0,0 +1,7 @@ +{ + "bos_token": "", + "eos_token": "", + "mask_token": "[MASK]", + "pad_token": "", + "unk_token": "" +} diff --git a/gammagl/models/graphtranslator/chatglm2/tokenization_chatglm.py b/gammagl/models/graphtranslator/chatglm2/tokenization_chatglm.py new file mode 100644 index 000000000..3e41b637e --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/tokenization_chatglm.py @@ -0,0 +1,261 @@ +import os +import torch +from typing import List, Optional, Union, Dict +from sentencepiece import SentencePieceProcessor +from transformers import PreTrainedTokenizer +from transformers.utils import logging, PaddingStrategy +from transformers.tokenization_utils_base import EncodedInput, BatchEncoding + + +class SPTokenizer: + def __init__(self, model_path: str): + # reload tokenizer + assert os.path.isfile(model_path), model_path + self.sp_model = SentencePieceProcessor(model_file=model_path) + + # BOS / EOS token IDs + self.n_words: int = self.sp_model.vocab_size() + self.bos_id: int = self.sp_model.bos_id() + self.eos_id: int = self.sp_model.eos_id() + self.pad_id: int = self.sp_model.unk_id() + assert self.sp_model.vocab_size() == self.sp_model.get_piece_size() + + special_tokens = ["[MASK]", "[gMASK]", "[sMASK]", "sop", "eop"] + self.special_tokens = {} + self.index_special_tokens = {} + for token in special_tokens: + self.special_tokens[token] = self.n_words + self.index_special_tokens[self.n_words] = token + self.n_words += 1 + + def tokenize(self, s: str): + return self.sp_model.EncodeAsPieces(s) + + def encode(self, s: str, bos: bool = False, eos: bool = False) -> List[int]: + assert type(s) is str + t = self.sp_model.encode(s) + if bos: + t = [self.bos_id] + t + if eos: + t = t + [self.eos_id] + return t + + def decode(self, t: List[int]) -> str: + return self.sp_model.decode(t) + + def decode_tokens(self, tokens: List[str]) -> str: + text = self.sp_model.DecodePieces(tokens) + return text + + def convert_token_to_id(self, token): + """ Converts a token (str) in an id using the vocab. """ + if token in self.special_tokens: + return self.special_tokens[token] + return self.sp_model.PieceToId(token) + + def convert_id_to_token(self, index): + """Converts an index (integer) in a token (str) using the vocab.""" + if index in self.index_special_tokens or index in [self.eos_id, self.bos_id, self.pad_id] or index < 0: + return "" + return self.sp_model.IdToPiece(index) + + +class ChatGLMTokenizer(PreTrainedTokenizer): + vocab_files_names = {"vocab_file": "tokenizer.model"} + + model_input_names = ["input_ids", "attention_mask", "position_ids"] + + def __init__(self, vocab_file, padding_side="left", clean_up_tokenization_spaces=False, **kwargs): + super().__init__(padding_side=padding_side, clean_up_tokenization_spaces=clean_up_tokenization_spaces, **kwargs) + self.name = "GLMTokenizer" + + self.vocab_file = vocab_file + self.tokenizer = SPTokenizer(vocab_file) + self.special_tokens = { + "": self.tokenizer.bos_id, + "": self.tokenizer.eos_id, + "": self.tokenizer.pad_id + } + + def get_command(self, token): + if token in self.special_tokens: + return self.special_tokens[token] + assert token in self.tokenizer.special_tokens, f"{token} is not a special token for {self.name}" + return self.tokenizer.special_tokens[token] + + @property + def unk_token(self) -> str: + return "" + + @property + def pad_token(self) -> str: + return "" + + @property + def pad_token_id(self): + return self.get_command("") + + @property + def eos_token(self) -> str: + return "" + + @property + def eos_token_id(self): + return self.get_command("") + + @property + def bos_token_id(self): + return self.get_command("") + + @property + def vocab_size(self): + return self.tokenizer.n_words + + def get_vocab(self): + """ Returns vocab as a dict """ + vocab = {self._convert_id_to_token(i): i for i in range(self.vocab_size)} + vocab.update(self.added_tokens_encoder) + return vocab + + def _tokenize(self, text, **kwargs): + return self.tokenizer.tokenize(text) + + def _convert_token_to_id(self, token): + """ Converts a token (str) in an id using the vocab. """ + return self.tokenizer.convert_token_to_id(token) + + def _convert_id_to_token(self, index): + """Converts an index (integer) in a token (str) using the vocab.""" + return self.tokenizer.convert_id_to_token(index) + + def convert_tokens_to_string(self, tokens: List[str]) -> str: + return self.tokenizer.decode_tokens(tokens) + + def save_vocabulary(self, save_directory, filename_prefix=None): + """ + Save the vocabulary and special tokens file to a directory. + + Args: + save_directory (`str`): + The directory in which to save the vocabulary. + filename_prefix (`str`, *optional*): + An optional prefix to add to the named of the saved files. + + Returns: + `Tuple(str)`: Paths to the files saved. + """ + if os.path.isdir(save_directory): + vocab_file = os.path.join( + save_directory, self.vocab_files_names["vocab_file"] + ) + else: + vocab_file = save_directory + + with open(self.vocab_file, 'rb') as fin: + proto_str = fin.read() + + with open(vocab_file, "wb") as writer: + writer.write(proto_str) + + return (vocab_file,) + + def get_prefix_tokens(self): + prefix_tokens = [self.get_command("[gMASK]"), self.get_command("sop")] + return prefix_tokens + + def build_prompt(self, query, history=None): + if history is None: + history = [] + prompt = "" + for i, (old_query, response) in enumerate(history): + prompt += "[Round {}]\n\n问：{}\n\n答：{}\n\n".format(i + 1, old_query, response) + prompt += "[Round {}]\n\n问：{}\n\n答：".format(len(history) + 1, query) + return prompt + + def build_inputs_with_special_tokens( + self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None + ) -> List[int]: + """ + Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and + adding special tokens. A BERT sequence has the following format: + + - single sequence: `[CLS] X [SEP]` + - pair of sequences: `[CLS] A [SEP] B [SEP]` + + Args: + token_ids_0 (`List[int]`): + List of IDs to which the special tokens will be added. + token_ids_1 (`List[int]`, *optional*): + Optional second list of IDs for sequence pairs. + + Returns: + `List[int]`: List of [input IDs](../glossary#input-ids) with the appropriate special tokens. + """ + prefix_tokens = self.get_prefix_tokens() + token_ids_0 = prefix_tokens + token_ids_0 + if token_ids_1 is not None: + token_ids_0 = token_ids_0 + token_ids_1 + [self.get_command("")] + return token_ids_0 + + def _pad( + self, + encoded_inputs: Union[Dict[str, EncodedInput], BatchEncoding], + max_length: Optional[int] = None, + padding_strategy: PaddingStrategy = PaddingStrategy.DO_NOT_PAD, + pad_to_multiple_of: Optional[int] = None, + return_attention_mask: Optional[bool] = None, + ) -> dict: + """ + Pad encoded inputs (on left/right and up to predefined length or max length in the batch) + + Args: + encoded_inputs: + Dictionary of tokenized inputs (`List[int]`) or batch of tokenized inputs (`List[List[int]]`). + max_length: maximum length of the returned list and optionally padding length (see below). + Will truncate by taking into account the special tokens. + padding_strategy: PaddingStrategy to use for padding. + + - PaddingStrategy.LONGEST Pad to the longest sequence in the batch + - PaddingStrategy.MAX_LENGTH: Pad to the max length (default) + - PaddingStrategy.DO_NOT_PAD: Do not pad + The tokenizer padding sides are defined in self.padding_side: + + - 'left': pads on the left of the sequences + - 'right': pads on the right of the sequences + pad_to_multiple_of: (optional) Integer if set will pad the sequence to a multiple of the provided value. + This is especially useful to enable the use of Tensor Core on NVIDIA hardware with compute capability + `>= 7.5` (Volta). + return_attention_mask: + (optional) Set to False to avoid returning attention mask (default: set to model specifics) + """ + # Load from model defaults + assert self.padding_side == "left" + + required_input = encoded_inputs[self.model_input_names[0]] + seq_length = len(required_input) + + if padding_strategy == PaddingStrategy.LONGEST: + max_length = len(required_input) + + if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0): + max_length = ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of + + needs_to_be_padded = padding_strategy != PaddingStrategy.DO_NOT_PAD and len(required_input) != max_length + + # Initialize attention mask if not present. + if "attention_mask" not in encoded_inputs: + encoded_inputs["attention_mask"] = [1] * seq_length + + if "position_ids" not in encoded_inputs: + encoded_inputs["position_ids"] = list(range(seq_length)) + + if needs_to_be_padded: + difference = max_length - len(required_input) + + if "attention_mask" in encoded_inputs: + encoded_inputs["attention_mask"] = [0] * difference + encoded_inputs["attention_mask"] + if "position_ids" in encoded_inputs: + encoded_inputs["position_ids"] = [0] * difference + encoded_inputs["position_ids"] + encoded_inputs[self.model_input_names[0]] = [self.pad_token_id] * difference + required_input + + return encoded_inputs diff --git a/gammagl/models/graphtranslator/chatglm2/tokenizer.model b/gammagl/models/graphtranslator/chatglm2/tokenizer.model new file mode 100644 index 0000000000000000000000000000000000000000..c8336ad04bdd4e2d2aa62261f77698b13f5686ac GIT binary patch literal 1018370 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�{-P`%O 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%0DyG#o%PuZs##}0FpyY5|^SgKi1B) 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 z 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⪼~q@}GjdpwB>^W5&KUQgv!>LRY6Muh8y#T|RJ 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 z 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 literal 0 HcmV?d00001 diff --git a/gammagl/models/graphtranslator/chatglm2/tokenizer_config.json b/gammagl/models/graphtranslator/chatglm2/tokenizer_config.json new file mode 100644 index 000000000..79b212c00 --- /dev/null +++ b/gammagl/models/graphtranslator/chatglm2/tokenizer_config.json @@ -0,0 +1,12 @@ +{ + "name_or_path": "THUDM/chatglm2-6b", + "remove_space": false, + "do_lower_case": false, + "tokenizer_class": "ChatGLMTokenizer", + "auto_map": { + "AutoTokenizer": [ + "tokenization_chatglm.ChatGLMTokenizer", + null + ] + } +} diff --git a/gammagl/models/graphtranslator/translator.py b/gammagl/models/graphtranslator/translator.py new file mode 100755 index 000000000..15d5cd9cb --- /dev/null +++ b/gammagl/models/graphtranslator/translator.py @@ -0,0 +1,120 @@ +""" + Copyright (c) 2023, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import contextlib + + +import tensorlayerx.nn as nn +import tensorlayerx as tlx + +import torch + +from .base_model import BaseModel +from transformers import BertTokenizer + + +class TranslatorBase(BaseModel): + @classmethod + def init_tokenizer(cls): + tokenizer = BertTokenizer.from_pretrained("../bert-base-uncased") + tokenizer.add_special_tokens({"bos_token": "[DEC]"}) + return tokenizer + + def maybe_autocast(self, dtype=tlx.float16): + # if on cpu, don't use autocast + # if on gpu, use autocast with dtype if provided, otherwise use torch.float16 + enable_autocast = self.device != torch.device("cpu") + + if enable_autocast: + return torch.cuda.amp.autocast(dtype=dtype) + else: + return contextlib.nullcontext() + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x): + orig_type = x.dtype + ret = super().forward(x.type(tlx.float32)) + return ret.type(orig_type) + + + +from dataclasses import dataclass +from typing import Optional +from transformers.modeling_outputs import ( + ModelOutput, + BaseModelOutputWithPoolingAndCrossAttentions, + CausalLMOutputWithCrossAttentions, +) + + +@dataclass +class TranslatorSimilarity(ModelOutput): + sim_i2t: torch.FloatTensor = None + sim_t2i: torch.FloatTensor = None + + sim_i2t_m: Optional[torch.FloatTensor] = None + sim_t2i_m: Optional[torch.FloatTensor] = None + + sim_i2t_targets: Optional[torch.FloatTensor] = None + sim_t2i_targets: Optional[torch.FloatTensor] = None + + +@dataclass +class TranslatorIntermediateOutput(ModelOutput): + + + # uni-modal features + image_embeds: torch.FloatTensor = None + text_embeds: Optional[torch.FloatTensor] = None + + image_embeds_m: Optional[torch.FloatTensor] = None + text_embeds_m: Optional[torch.FloatTensor] = None + + # intermediate outputs of multimodal encoder + encoder_output: Optional[BaseModelOutputWithPoolingAndCrossAttentions] = None + encoder_output_neg: Optional[BaseModelOutputWithPoolingAndCrossAttentions] = None + + itm_logits: Optional[torch.FloatTensor] = None + itm_labels: Optional[torch.LongTensor] = None + + # intermediate outputs of multimodal decoder + decoder_output: Optional[CausalLMOutputWithCrossAttentions] = None + decoder_labels: Optional[torch.LongTensor] = None + + +@dataclass +class TranslatorOutput(ModelOutput): + + sims: Optional[TranslatorSimilarity] = None + + intermediate_output: TranslatorIntermediateOutput = None + + loss: Optional[torch.FloatTensor] = None + + loss_itc: Optional[torch.FloatTensor] = None + + loss_itm: Optional[torch.FloatTensor] = None + + loss_lm: Optional[torch.FloatTensor] = None + + +@dataclass +class TranslatorOutputWithLogits(TranslatorOutput): + logits: torch.FloatTensor = None + logits_m: torch.FloatTensor = None + + +@dataclass +class TranslatorOutputFeatures(ModelOutput): + image_embeds: Optional[torch.FloatTensor] = None + image_embeds_proj: Optional[torch.FloatTensor] = None + + text_embeds: Optional[torch.FloatTensor] = None + text_embeds_proj: Optional[torch.FloatTensor] = None + + multimodal_embeds: Optional[torch.FloatTensor] = None diff --git a/gammagl/models/graphtranslator/translator_chatglm_arxiv.py b/gammagl/models/graphtranslator/translator_chatglm_arxiv.py new file mode 100644 index 000000000..3021a1637 --- /dev/null +++ b/gammagl/models/graphtranslator/translator_chatglm_arxiv.py @@ -0,0 +1,331 @@ +""" + Copyright (c) 2023, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import logging +from typing import List, Optional + +import tensorlayerx as tlx +import tensorlayerx.nn as nn +import torch +from torch.nn.utils.rnn import pad_sequence +from transformers import BertTokenizer +from .translator import TranslatorBase +from .Qformer import BertConfig, BertLMHeadModel +from .chatglm2 import ChatGLMForConditionalGeneration, ChatGLMTokenizer + +IMAGE_TOKEN_ID = 101 + + +class TranslatorCHATGLMArxiv(TranslatorBase): + + def __init__( + self, + config, + num_features=768, + num_query_token=32, + chatglm2_model="", + max_txt_len=2048, + ): + super().__init__() + self.config = config + + chatglm2_model = config['llm_dir'] + self.llm_dir = config['llm_dir'] + self.bert_dir = config['bert_dir'] + + self.tokenizer = self.init_tokenizer() + + self.Qformer, self.query_tokens = self.init_Qformer( + num_query_token, num_features + ) + + self.Qformer.resize_token_embeddings(len(self.tokenizer)) + self.Qformer.cls = None + + self.chatglm2_tokenizer = ChatGLMTokenizer.from_pretrained(chatglm2_model, use_fast=False, trust_remote_code=True) + + + self.chatglm2_model = ChatGLMForConditionalGeneration.from_pretrained(chatglm2_model) + + for _, param in self.chatglm2_model.named_parameters(): + param.requires_grad = False + + # self.chatglm2_proj = nn.Linear( + # in_features=self.Qformer.config.hidden_size, out_features=self.chatglm2_model.config.hidden_size + # ) + self.chatglm2_proj = torch.nn.Linear( + in_features=self.Qformer.config.hidden_size, out_features=self.chatglm2_model.config.hidden_size + ) + + self.max_txt_len = max_txt_len + + def init_tokenizer(self): + tokenizer = BertTokenizer.from_pretrained(self.bert_dir) + tokenizer.add_special_tokens({"bos_token": "[DEC]"}) + return tokenizer + + def init_Qformer(self, num_query_token, vision_width, cross_attention_freq=2): + encoder_config = BertConfig.from_pretrained(self.bert_dir) + encoder_config.encoder_width = vision_width + # insert cross-attention layer every other block + encoder_config.add_cross_attention = True + encoder_config.cross_attention_freq = cross_attention_freq + encoder_config.query_length = num_query_token + + Qformer = BertLMHeadModel(encoder_config) + + checkpoint = torch.load(self.bert_dir+"/model.pth", map_location=lambda storage, loc: storage) + Qformer.load_state_dict(checkpoint['model_state_dict'], strict=True) + + query_tokens = nn.Parameter( + tlx.zeros((1, num_query_token, encoder_config.hidden_size)) + ) + query_tokens.data.normal_(mean=0.0, std=encoder_config.initializer_range) + + return Qformer, query_tokens + + def prepare_lm_input(self, vtokens, text_input: List[str], answer: Optional[List[str]]): + bsz, nvtoken, _ = vtokens.size() + tokenizer = self.chatglm2_tokenizer + device = self.device + + sequences = [] + labels = [] + if answer is None: + def get_ids(): + for text in text_input: + a_ids = [IMAGE_TOKEN_ID] * nvtoken + tokenizer.encode("", add_special_tokens=True) + b_ids = tokenizer.encode(text, add_special_tokens=True) + yield a_ids, b_ids + else: + def get_ids(): + for text, ans in zip(text_input, answer): + a_ids = [IMAGE_TOKEN_ID] * nvtoken + tokenizer.encode(text, add_special_tokens=True) + b_ids = tokenizer.encode(ans, add_special_tokens=True) + yield a_ids, b_ids + for a_ids, b_ids in get_ids(): + max_caption_length = self.max_txt_len - (len(a_ids) - nvtoken) + if len(b_ids) > max_caption_length: + b_ids = b_ids[: max_caption_length] + input_ids = a_ids + b_ids + context_length = len(a_ids) + nvtoken_id = input_ids.index(IMAGE_TOKEN_ID) + input_ids = tlx.convert_to_tensor(input_ids, dtype=tlx.int64) + sequences.append(input_ids) + label = input_ids.detach().clone() + # -100 is the ignore index is CELoss + label[:context_length] = -100 + labels.append(label) + + # pad sequences + input_ids = pad_sequence(sequences, batch_first=True, padding_value=tokenizer.pad_token_id).to(device) + labels = pad_sequence(labels, batch_first=True, padding_value=-100).to(device) + inputs_embeds = self.chatglm2_model.transformer.embedding.word_embeddings(input_ids) + inputs_embeds[:, nvtoken_id: nvtoken_id + nvtoken] = vtokens + inputs_embeds = inputs_embeds.transpose(0, 1).contiguous() + return input_ids, labels, inputs_embeds + + def forward(self, samples): + multimodal_embeds = samples[1].unsqueeze(dim=1).to(self.device) + text = samples[2] + pre_instruction = ['The description of the paper and its cited papers is as follows:' for _ in range(len(text))] + instruction = ['\nQuestion: Please summarize the topic and content of the paper and its citations in English. Answer:' for _ in range(len(text))] + device = self.Qformer.bert.device + + multimodal_atts = tlx.ones(multimodal_embeds.size()[:-1], dtype=tlx.int64).to(device) + + query_tokens = self.query_tokens.expand(multimodal_embeds.shape[0], -1, -1).to(device) + text_Qformer = self.tokenizer( + instruction, + padding='max_length', + truncation=True, + max_length=self.max_txt_len, + return_tensors="pt", + ).to(device) + + query_atts = tlx.ones(query_tokens.size()[:-1], dtype=tlx.int64).to(device) + + + query_output = self.Qformer.bert( + query_embeds=query_tokens, + encoder_hidden_states=multimodal_embeds, + encoder_attention_mask=multimodal_atts, + return_dict=True, + ) + vtokens = self.chatglm2_proj(query_output.last_hidden_state[:, :query_tokens.size(1), :]) + + input_ids, labels, inputs_embeds = self.prepare_lm_input( + vtokens=vtokens, text_input=instruction, answer=text + ) + + outputs = self.chatglm2_model( + input_ids=input_ids, + inputs_embeds=inputs_embeds, + return_dict=True, + labels=labels, + ) + + loss = outputs.loss + + return {"loss": loss, "vtokens": vtokens, "logits": outputs.logits} + + @torch.no_grad() + def generate( + self, + samples, + prompts=[], + use_nucleus_sampling=False, + num_beams=1, + max_length=2048, + min_length=1, + top_p=0.8, + repetition_penalty=1.5, + length_penalty=1.0, + num_captions=1, + temperature=0.65, + ): + """ + Args: + samples (dict): A dictionary containing the following keys: + - image (torch.Tensor): A tensor of shape (batch_size, 3, H, W) + use_nucleus_sampling (bool): Whether to use nucleus sampling. If False, use top-k sampling. + num_beams (int): Number of beams for beam search. 1 means no beam search. + max_length (int): The maximum length of the sequence to be generated. + min_length (int): The minimum length of the sequence to be generated. + top_p (float): The cumulative probability for nucleus sampling. + repetition_penalty (float): The parameter for repetition penalty. 1.0 means no penalty. + num_captions (int): Number of captions to be generated for each image. + Returns: + captions (list): A list of strings of length batch_size * num_captions. + """ + + device = self.Qformer.bert.device + multimodal_embeds = samples[1].unsqueeze(dim=1).to(device) + bs = len(samples[0]) + title = samples[3] + instruction = [prompts[0]] * bs + + question_prompt_pre = prompts[1].format(title) + + categories = prompts[2] + + question_prompt = prompts[3] + qustion = question_prompt_pre + categories + question_prompt + + with self.maybe_autocast(): + multimodal_atts = tlx.ones(multimodal_embeds.size()[:-1], dtype=tlx.int64).to(device) + query_tokens = self.query_tokens.expand(multimodal_embeds.shape[0], -1, -1) + text_Qformer = self.tokenizer( + instruction, + padding='max_length', + truncation=True, + max_length=self.max_txt_len, + return_tensors="pt", + ).to(device) + + query_output = self.Qformer.bert( + query_embeds=query_tokens, + encoder_hidden_states=multimodal_embeds, + encoder_attention_mask=multimodal_atts, + return_dict=True, + ) + + + vtokens = self.chatglm2_proj(query_output.last_hidden_state[:, :query_tokens.size(1), :]) + + #first summarize and then answer the question + + #input_ids, labels, inputs_embeds = self.prepare_lm_input( + # vtokens=vtokens, text_input=instruction, answer=None + #) + + #no summarize, straight Q&A + + input_ids, labels, inputs_embeds = self.prepare_lm_input( + vtokens=vtokens, text_input=[qustion], answer=None + ) + + from transformers.generation.utils import LogitsProcessorList + logits_processor = LogitsProcessorList() + from .chatglm2.modeling_chatglm import InvalidScoreLogitsProcessor + logits_processor.append(InvalidScoreLogitsProcessor()) + + #gen_kwargs = { + # "max_length": max_length, + # "min_length": min_length, + # "num_beams": 1, + # "do_sample": True, + # "top_p": top_p, + # "temperature": temperature, + # "repetition_penalty": repetition_penalty, + # "length_penalty": length_penalty, + # "logits_processor": logits_processor + #} + gen_kwargs = {"max_length": 1024} + + outputs = self.chatglm2_model.generate(input_ids, inputs_embeds=inputs_embeds, **gen_kwargs) + + + response_output = [] + for i in range(multimodal_embeds.shape[0]): + outputs_i = outputs.tolist()[i][len(input_ids[i]):] + response0 = self.chatglm2_tokenizer.decode(outputs_i) + response0 = self.chatglm2_model.process_response(response0) + + + #first summarize and then answer the question + #if len(response0) > max_length - len(qustion) - 1: + # response0 = response0[:max_length - len(qustion) - 1] + #summary_prompt = prompts[4].format(title, response0, qustion) + #gen_kwargs = { + # "max_length": max_length, + # "min_length": 100 + #} + #response2, history = self.chatglm2_model.chat(tokenizer=self.chatglm2_tokenizer, + # query=summary_prompt, + # **gen_kwargs) + #no summarize, straight Q&A + response_output.append(response0) + + return response_output + + @classmethod + def from_config(cls, cfg): + # multimodal + num_features = cfg.get("num_features", 768) + # Text + max_txt_len = cfg.get("max_txt_len", 32) + + # Q-Former + num_query_token = cfg.get("num_query_token") + + model = cls( + config=cfg, + num_features=num_features, + num_query_token=num_query_token, + max_txt_len=max_txt_len, + ) + model.load_checkpoint_from_config(cfg) + + return model + + def load_from_pretrained(self, url_or_filename): + if url_or_filename: + checkpoint = torch.load(url_or_filename, map_location=lambda storage, loc: storage) + if "model_state_dict" in checkpoint.keys(): + state_dict = checkpoint["model_state_dict"] + elif "model" in checkpoint.keys(): + state_dict = checkpoint["model"] + else: + state_dict = checkpoint + + msg = self.load_state_dict(state_dict, strict=False) + + logging.info("load checkpoint from %s" % url_or_filename) + + return msg + + return diff --git a/gammagl/models/graphtranslator/translator_qformer_arxiv.py b/gammagl/models/graphtranslator/translator_qformer_arxiv.py new file mode 100755 index 000000000..54ba53629 --- /dev/null +++ b/gammagl/models/graphtranslator/translator_qformer_arxiv.py @@ -0,0 +1,366 @@ +""" + Copyright (c) 2023, salesforce.com, inc. + All rights reserved. + SPDX-License-Identifier: BSD-3-Clause + For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause +""" +import logging + +import tensorlayerx as tlx +import tensorlayerx.nn as nn +import torch + +from .base_model import all_gather_with_grad, concat_all_gather +from .translator import TranslatorBase,TranslatorOutput + +from transformers import BertTokenizer +from .Qformer import BertConfig, BertLMHeadModel + +class GELU(nn.Module): + def __init__(self, approximate=False): + super(GELU, self).__init__() + self.approximate = approximate + + def forward(self, x): + if self.approximate: + return tlx.gelu(x, approximate=self.approximate) + else: + return tlx.gelu(x) + + + +class TranslatorQformerArxiv(TranslatorBase): + def __init__( + self, + config, + num_features=768, + num_query_token=32, + cross_attention_freq=2, + embed_dim=256, + max_txt_len=32, + ): + super().__init__() + + self.bert_dir = config['bert_dir'] + + self.tokenizer = self.init_tokenizer() + + self.Qformer, self.query_tokens = self.init_Qformer( + num_query_token, num_features, cross_attention_freq + ) + self.Qformer.resize_token_embeddings(len(self.tokenizer)) + state_dict = self.Qformer.state_dict() + for name, param in self.Qformer.named_parameters(): + if "_query" in name: + key_orig = name.replace("_query", "") + param.data.copy_(state_dict[key_orig]) + + self.behavior_proj = nn.Linear(in_features=self.Qformer.config.hidden_size, out_features=embed_dim) + self.text_proj = nn.Linear(in_features=self.Qformer.config.hidden_size, out_features=embed_dim) + + self.itm_head = nn.Linear(in_features=self.Qformer.config.hidden_size, out_features=2) + + self.temp = nn.Parameter(0.07 * tlx.ones([])) + + self.max_txt_len = max_txt_len + self.proj = nn.Sequential( + nn.Linear(in_features=embed_dim, out_features=embed_dim), + GELU(), + nn.Linear(in_features=embed_dim, out_features=embed_dim) + ) + + def init_tokenizer(self): + tokenizer = BertTokenizer.from_pretrained(self.bert_dir) + tokenizer.add_special_tokens({"bos_token": "[DEC]"}) + return tokenizer + + def init_Qformer(self, num_query_token, vision_width, cross_attention_freq=2): + encoder_config = BertConfig.from_pretrained(self.bert_dir) + encoder_config.encoder_width = vision_width + # insert cross-attention layer every other block + encoder_config.add_cross_attention = True + encoder_config.cross_attention_freq = cross_attention_freq + encoder_config.query_length = num_query_token + Qformer = BertLMHeadModel(encoder_config) + checkpoint = torch.load(self.bert_dir+"/model.pth", map_location=lambda storage, loc: storage) + + Qformer.load_state_dict(checkpoint['model_state_dict'], strict=True) + query_tokens = nn.Parameter( + tlx.zeros((1, num_query_token, encoder_config.hidden_size)) + ) + query_tokens.data.normal_(mean=0.0, std=encoder_config.initializer_range) + return Qformer, query_tokens + + def forward(self, samples): + behavior_embeds = tlx.expand_dims(samples[1], axis=1) + text = samples[2] + behavior_embeds = behavior_embeds.to(self.device) + behavior_atts = tlx.ones(behavior_embeds.size()[:-1], dtype=tlx.int64).to(behavior_embeds.device) + + query_tokens = self.query_tokens.expand(behavior_embeds.shape[0], -1, -1) + + query_output = self.Qformer.bert( + query_embeds=query_tokens, + encoder_hidden_states=behavior_embeds, + encoder_attention_mask=behavior_atts, + use_cache=True, + return_dict=True, + ) + + behavior_feats = tlx.l2_normalize( + self.behavior_proj(query_output.last_hidden_state), axis=-1 + ) + + text_tokens = self.tokenizer( + text, + padding="max_length", + truncation=True, + max_length=self.max_txt_len, + return_tensors="pt", + ).to(behavior_embeds.device) + + text_output = self.Qformer.bert( + text_tokens.input_ids, + attention_mask=text_tokens.attention_mask, + return_dict=True, + ) + text_feat = tlx.l2_normalize( + self.text_proj(text_output.last_hidden_state[:, 0, :]), axis=-1 + ) + + ###============== Image-text Contrastive ===================### + behavior_feats_all = concat_all_gather( + behavior_feats + ) # [batch_size*num_gpu, num_query_tokens, embed_dim] # torch.Size([8, 32, 256]) + text_feat_all = concat_all_gather(text_feat) # [batch_size*num_gpu, embed_dim] + + sim_q2t = tlx.matmul( + behavior_feats.unsqueeze(1), text_feat_all.unsqueeze(-1) + ).squeeze() + # [batch_size, batch_size*num_gpu, num_query_tokens] + + # image-text similarity: aggregate across all query tokens + sim_i2t, _ = sim_q2t.max(-1) + sim_i2t = sim_i2t / self.temp + + # text-query similarity: [batch_size, batch_size*num_gpu, num_query_tokens] + sim_t2q = tlx.matmul( + text_feat.unsqueeze(1).unsqueeze(1), behavior_feats_all.permute(0, 2, 1) + ).squeeze() + + # text-image similarity: aggregate across all query tokens + sim_t2i, _ = sim_t2q.max(-1) + sim_t2i = sim_t2i / self.temp # [batch_size, batch_size*num_gpu] + + rank = 0 + bs = behavior_embeds.size(0) + targets = tlx.linspace(rank * bs, rank * bs + bs - 1, bs).to(behavior_embeds.device).to(dtype=tlx.int64) + + loss_itc = ( + tlx.losses.softmax_cross_entropy_with_logits(sim_i2t, targets) + + tlx.losses.softmax_cross_entropy_with_logits(sim_t2i, targets) + ) / 2 + + ###============== Image-text Matching ===================### + text_input_ids_world = concat_all_gather(text_tokens.input_ids) + text_attention_mask_world = concat_all_gather(text_tokens.attention_mask) + behavior_embeds_world = all_gather_with_grad(behavior_embeds) + with torch.no_grad(): + weights_t2i = tlx.softmax(sim_t2i, axis=1) + 1e-4 + weights_t2i[:, rank * bs : rank * bs + bs].fill_diagonal_(0) + weights_i2t = tlx.softmax(sim_i2t, axis=1) + 1e-4 + weights_i2t[:, rank * bs : rank * bs + bs].fill_diagonal_(0) + + # select a negative image for each text + behavior_embeds_neg = [] + for b in range(bs): + neg_idx = torch.multinomial(weights_t2i[b], 1).item() + behavior_embeds_neg.append(behavior_embeds_world[neg_idx]) + behavior_embeds_neg = tlx.stack(behavior_embeds_neg, axis=0) + + # select a negative text for each image + text_ids_neg = [] + text_atts_neg = [] + for b in range(bs): + neg_idx = torch.multinomial(weights_i2t[b], 1).item() + text_ids_neg.append(text_input_ids_world[neg_idx]) + text_atts_neg.append(text_attention_mask_world[neg_idx]) + + text_ids_neg = tlx.stack(text_ids_neg, axis=0) + text_atts_neg = tlx.stack(text_atts_neg, axis=0) + + text_ids_all = tlx.concat( + [text_tokens.input_ids, text_tokens.input_ids, text_ids_neg], axis=0 + ) # pos, pos, neg + text_atts_all = tlx.concat( + [text_tokens.attention_mask, text_tokens.attention_mask, text_atts_neg], + axis=0, + ) + + query_tokens_itm = self.query_tokens.expand(text_ids_all.shape[0], -1, -1) + query_atts_itm = tlx.ones(query_tokens_itm.size()[:-1], dtype=tlx.int64).to( + behavior_embeds.device + ) + attention_mask_all = tlx.concat([query_atts_itm, text_atts_all], axis=1) + + behavior_embeds_all = tlx.concat( + [behavior_embeds, behavior_embeds_neg, behavior_embeds], axis=0 + ) # pos, neg, pos + behavior_atts_all = tlx.ones(behavior_embeds_all.size()[:-1], dtype=tlx.int64).to( + behavior_embeds.device + ) + + output_itm = self.Qformer.bert( + text_ids_all, + query_embeds=query_tokens_itm, + attention_mask=attention_mask_all, + encoder_hidden_states=behavior_embeds_all, + encoder_attention_mask=behavior_atts_all, + return_dict=True, + ) + + vl_embeddings = output_itm.last_hidden_state[:, : query_tokens_itm.size(1), :] + vl_output = self.itm_head(vl_embeddings) + logits = vl_output.mean(dim=1) + + itm_labels = tlx.concat( + [tlx.ones((bs,), dtype=tlx.int64), tlx.zeros((2 * bs,), dtype=tlx.int64)], + axis=0, + ).to(behavior_embeds.device) + loss_itm = tlx.losses.softmax_cross_entropy_with_logits(output=logits, target=itm_labels) + + + ##================= Image Captioning ========================## + decoder_input_ids = text_tokens.input_ids.clone() + decoder_input_ids[:, 0] = self.tokenizer.bos_token_id + labels = decoder_input_ids.masked_fill( + decoder_input_ids == self.tokenizer.pad_token_id, -100 + ) + + query_atts = tlx.ones(query_tokens.size()[:-1], dtype=tlx.int64).to( + behavior_embeds.device + ) + attention_mask = tlx.concat([query_atts, text_tokens.attention_mask], axis=1) + lm_output = self.Qformer( + decoder_input_ids, + attention_mask=attention_mask, + past_key_values=query_output.past_key_values, + return_dict=True, + labels=labels, + ) + + loss_lm = lm_output.loss + return TranslatorOutput( + loss=loss_itc + loss_itm + loss_lm, + loss_itc=loss_itc, + loss_itm=loss_itm, + loss_lm=loss_lm, + ) + + @torch.no_grad() + def generate( + self, + samples, + use_nucleus_sampling=False, + num_beams=3, + max_length=512, + min_length=10, + top_p=0.9, + repetition_penalty=1.0, + ): + """ + Args: + samples (dict): A dictionary containing the following keys: + - image (torch.Tensor): A tensor of shape (batch_size, 3, H, W) + use_nucleus_sampling (bool): Whether to use nucleus sampling. If False, use top-k sampling. + num_beams (int): Number of beams for beam search. 1 means no beam search. + max_length (int): The maximum length of the sequence to be generated. + min_length (int): The minimum length of the sequence to be generated. + top_p (float): The cumulative probability for nucleus sampling. + repetition_penalty (float): The parameter for repetition penalty. 1.0 means no penalty. + num_captions (int): Number of captions to be generated for each image. + Returns: + captions (list): A list of strings of length batch_size * num_captions. + """ + + behavior_embeds = tlx.expand_dims(samples[1], aixs=1).to('cuda:1') + + if not use_nucleus_sampling: + behavior_embeds = behavior_embeds.repeat_interleave(num_beams, dim=0) + else: + num_beams = 1 + behavior_atts = tlx.ones(behavior_embeds.size()[:-1], dtype=tlx.int64).to( + behavior_embeds.device + ) + + model_kwargs = { + "encoder_hidden_states": behavior_embeds, + "encoder_attention_mask": behavior_atts, + } + + input_ids = ( + tlx.convert_to_tensor( + [[self.tokenizer.bos_token_id]] * samples[1].size(0), # 创建形状为 [batch_size, 1] 的tensor + dtype=tlx.int64, + device=behavior_embeds.device + ) + ) + query_tokens = self.query_tokens.expand(behavior_embeds.shape[0], -1, -1).to(behavior_embeds.device) + + outputs = self.Qformer.generate( + input_ids=input_ids, + query_embeds=query_tokens, + max_length=max_length, + min_length=min_length, + num_beams=num_beams, + do_sample=use_nucleus_sampling, + top_p=top_p, + eos_token_id=self.tokenizer.sep_token_id, + pad_token_id=self.tokenizer.pad_token_id, + **model_kwargs + ) + captions = self.tokenizer.batch_decode(outputs, skip_special_tokens=True) + return captions + + + @classmethod + def from_config(cls, cfg): + # Behavior + behavior_length = cfg.get("behavior_length", 384) + + # Text + max_txt_len = cfg.get("max_txt_len", 32) + + # Q-Former + num_query_token = cfg.get("num_query_token") + cross_attention_freq = cfg.get("cross_attention_freq", 2) + + model = cls( + config=cfg, + num_features=behavior_length, + num_query_token=num_query_token, + cross_attention_freq=cross_attention_freq, + max_txt_len=max_txt_len, + ) + + model.load_checkpoint_from_config(cfg) + + return model + + def load_from_pretrained(self, url_or_filename): + if url_or_filename: + checkpoint = torch.load(url_or_filename, map_location=lambda storage, loc: storage) + if "model_state_dict" in checkpoint.keys(): + state_dict = checkpoint["model_state_dict"] + elif "model" in checkpoint.keys(): + state_dict = checkpoint["model"] + else: + state_dict = checkpoint + + msg = self.load_state_dict(state_dict, strict=False) + + logging.info("load checkpoint from %s" % url_or_filename) + + return msg + + return