From fa838418c0b2bd2e5af2384a82a147e196858d0a Mon Sep 17 00:00:00 2001 From: ModelHub XC Date: Mon, 4 May 2026 09:05:48 +0800 Subject: [PATCH] =?UTF-8?q?=E5=88=9D=E5=A7=8B=E5=8C=96=E9=A1=B9=E7=9B=AE?= =?UTF-8?q?=EF=BC=8C=E7=94=B1ModelHub=20XC=E7=A4=BE=E5=8C=BA=E6=8F=90?= =?UTF-8?q?=E4=BE=9B=E6=A8=A1=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Model: sokada/codegen25-7b-multi-gguf-with-dummy-tokenizer Source: Original Platform --- .gitattributes | 36 ++++ README.md | 136 +++++++++++++++ config.json | 22 +++ generation_config.json | 6 + ggml-model-Q4_K.gguf | 3 + ggml-model-f16.gguf | 3 + ggml-model-f32.gguf | 3 + pytorch_model.bin.index.json | 330 +++++++++++++++++++++++++++++++++++ tokenization_codegen25.py | 247 ++++++++++++++++++++++++++ tokenizer_config.json | 12 ++ 10 files changed, 798 insertions(+) create mode 100644 .gitattributes create mode 100644 README.md create mode 100644 config.json create mode 100644 generation_config.json create mode 100644 ggml-model-Q4_K.gguf create mode 100644 ggml-model-f16.gguf create mode 100644 ggml-model-f32.gguf create mode 100644 pytorch_model.bin.index.json create mode 100644 tokenization_codegen25.py create mode 100644 tokenizer_config.json diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..f15b49c --- /dev/null +++ b/.gitattributes @@ -0,0 +1,36 @@ +*.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 +*.gguf filter=lfs diff=lfs merge=lfs -text diff --git a/README.md b/README.md new file mode 100644 index 0000000..8f4a1f9 --- /dev/null +++ b/README.md @@ -0,0 +1,136 @@ +--- +license: apache-2.0 +datasets: +- bigcode/starcoderdata +language: +- code +pipeline_tag: text-generation +--- + +# This repo is a fork for flatline_lsp + +See [flatline_lsp](https://github.com/okdshin/flatline_lsp). + +This repository is a fork of [Salesforce/codegen25-7b-multi](https://huggingface.co/Salesforce/codegen25-7b-multi). +This repository contains gguf files but its tokenizer is dummy. + +--- + +# CodeGen2.5-7B-multi + +Title: [**CodeGen2.5: Small, but mighty**](https://blog.salesforceairesearch.com/codegen25) + +Authors: [Erik Nijkamp](https://eriknijkamp.com)\*, [Hiroaki Hayashi](https://hiroakih.me)\*, Yingbo Zhou, Caiming Xiong + +(\* equal contribution) + +## Model description + +[CodeGen2.5](https://github.com/salesforce/CodeGen) is a family of autoregressive language models for **program synthesis**. + +Building upon [CodeGen2](https://arxiv.org/abs/2305.02309), the model is trained on [StarCoderData](https://huggingface.co/datasets/bigcode/starcoderdata) for 1.4T tokens, achieving competitive results compared to StarCoderBase-15.5B with less than half the size. + +Like CodeGen2, this model is capable of infilling, and supports multiple programming languages. + +We then further train on Python, then on instruction data. We release all the models as follows: + +* **CodeGen2.5-7B-multi** (this repo): Trained on StarCoderData. Licensed under Apache-2.0. +* **CodeGen2.5-7B-mono**: Further trained on additional Python tokens. Licensed under Apache-2.0. +* **CodeGen2.5-7B-instruct**: Further trained from CodeGen2.5-7B-mono on instruction data. *Research purposes only*. + +## How to use + +This model can be easily loaded using the `AutoModelForCausalLM` functionality. + +### Pre-requisite + +Please install OpenAI `tiktoken` for the tokenizer. + +```bash +pip install tiktoken==0.4.0 +``` + +### Causal sampling (code autocompletion) + +For regular causal sampling, simply generate completions given the context: +```python +from transformers import AutoTokenizer, AutoModelForCausalLM +tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen25-7b-multi", trust_remote_code=True) +model = AutoModelForCausalLM.from_pretrained("Salesforce/codegen25-7b-multi") + +text = "def hello_world():" +input_ids = tokenizer(text, return_tensors="pt").input_ids +generated_ids = model.generate(input_ids, max_length=128) +print(tokenizer.decode(generated_ids[0], skip_special_tokens=True)) +``` + +### Infill sampling + +For **infill** sampling, we follow the CodeGen2 format: + +* ``: N-th span to be masked. In practice, use `` to where you want to sample infill. +* ``: Separator token between the suffix and the infilled sample. See below. +* ``: "End-Of-Mask" token that model will output at the end of infilling. You may use this token to truncate the output. + +For example, if we want to generate infill for the following cursor position of a function: +```python +def hello_world(): + | + return name +``` +we construct an input to the model by + +1. Inserting `` token in place of cursor position +2. Append `` token to indicate the boundary +3. Insert another `` to indicate which mask we want to infill. + +The final snippet looks as follows: + +```python +from transformers import AutoTokenizer, AutoModelForCausalLM +tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen25-7b-multi", trust_remote_code=True) +model = AutoModelForCausalLM.from_pretrained("Salesforce/codegen25-7b-multi") + + +def format(prefix, suffix): + return prefix + "" + suffix + "<|endoftext|>" + "" + "" + + +prefix = "def hello_world():\n " +suffix = " return name" +text = format(prefix, suffix) +input_ids = tokenizer(text, return_tensors="pt").input_ids +generated_ids = model.generate(input_ids, max_length=128) +print(tokenizer.decode(generated_ids[0], skip_special_tokens=False)[len(text):]) +``` + +You might want to truncate the model output with ``. + +## Evaluation results + +We evaluate our models on HumanEval and HumanEval-Infill. +Please refer to the [blog](https://blog.salesforceairesearch.com/codegen25) for more details. + +## Intended use and limitations + +As an autoregressive language model, CodeGen2.5 is capable of extracting features from given natural language and programming language texts, and calculating the likelihood of them. +However, the model is intended for and best at **program synthesis**, that is, generating executable code given English prompts, where the prompts should be in the form of a comment string. The model can complete partially-generated code as well. + +## Attribution & Other Requirements +The pretraining dataset of the model was filtered for permissive licenses only. +Nevertheless, the model can generate source code verbatim from the dataset. +The code's license might require attribution and/or other specific requirements that must be respected. +The data provider BigCode provides a [search index](https://huggingface.co/spaces/bigcode/starcoder-search) that lets you search through the pretraining data to identify where generated code came from and apply the proper attribution to your code. + +## BibTeX entry and citation info + +Please cite CodeGen2 paper: + +```bibtex +@article{Nijkamp2023codegen2, + title={CodeGen2: Lessons for Training LLMs on Programming and Natural Languages}, + author={Nijkamp, Erik and Hayashi, Hiroaki and Xiong, Caiming and Savarese, Silvio and Zhou, Yingbo}, + journal={arXiv preprint}, + year={2023} +} +``` diff --git a/config.json b/config.json new file mode 100644 index 0000000..d5ef65e --- /dev/null +++ b/config.json @@ -0,0 +1,22 @@ +{ + "architectures": [ + "LlamaForCausalLM" + ], + "bos_token_id": 50256, + "eos_token_id": 50256, + "hidden_act": "silu", + "hidden_size": 4096, + "initializer_range": 0.02, + "intermediate_size": 11008, + "max_position_embeddings": 2048, + "model_type": "llama", + "num_attention_heads": 32, + "num_hidden_layers": 32, + "pad_token_id": 0, + "rms_norm_eps": 1e-06, + "tie_word_embeddings": false, + "torch_dtype": "float32", + "transformers_version": "4.29.2", + "use_cache": true, + "vocab_size": 51200 +} diff --git a/generation_config.json b/generation_config.json new file mode 100644 index 0000000..773393f --- /dev/null +++ b/generation_config.json @@ -0,0 +1,6 @@ +{ + "_from_model_config": true, + "bos_token_id": 50256, + "eos_token_id": 50256, + "transformers_version": "4.29.2" +} diff --git a/ggml-model-Q4_K.gguf b/ggml-model-Q4_K.gguf new file mode 100644 index 0000000..3572198 --- /dev/null +++ b/ggml-model-Q4_K.gguf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a33eb6211c79e25d2c179614e04be6b734070a8d097e9ab22def3a19c1472c7d +size 4190013312 diff --git a/ggml-model-f16.gguf b/ggml-model-f16.gguf new file mode 100644 index 0000000..5bcfb95 --- /dev/null +++ b/ggml-model-f16.gguf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea6e9c8d6418ba85178e0c0f3547087196dcc008333844c8e61cd80bf33c5b57 +size 13792937824 diff --git a/ggml-model-f32.gguf b/ggml-model-f32.gguf new file mode 100644 index 0000000..5a8e967 --- /dev/null +++ b/ggml-model-f32.gguf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8bae4d623525c0cc749c4398a153c8717557ccd676a5a9ee0511c1ae42577ec +size 27583809376 diff --git a/pytorch_model.bin.index.json b/pytorch_model.bin.index.json new file mode 100644 index 0000000..a186fd7 --- /dev/null +++ b/pytorch_model.bin.index.json @@ -0,0 +1,330 @@ +{ + "metadata": { + "total_size": 27582816256 + }, + "weight_map": { + "lm_head.weight": "pytorch_model-00003-of-00003.bin", + "model.embed_tokens.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.0.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.0.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.1.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.1.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.10.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.10.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.11.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.11.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.11.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.11.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.11.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.11.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.11.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.11.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.11.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.11.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.12.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.12.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.12.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.13.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.13.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.14.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.14.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.15.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.15.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.16.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.16.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.17.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.17.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.18.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.18.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.19.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.19.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.2.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.2.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.2.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.20.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.20.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.20.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.21.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.21.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.input_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.mlp.down_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.mlp.up_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.post_attention_layernorm.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.22.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.22.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.23.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.23.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.23.mlp.gate_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.23.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.23.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.23.self_attn.k_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.23.self_attn.o_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.23.self_attn.q_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.23.self_attn.rotary_emb.inv_freq": "pytorch_model-00002-of-00003.bin", + "model.layers.23.self_attn.v_proj.weight": "pytorch_model-00002-of-00003.bin", + "model.layers.24.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.24.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.24.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.25.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.25.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.26.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.26.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.27.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.27.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.28.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.28.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.29.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.29.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.3.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.3.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.3.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.30.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.30.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.30.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.input_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.mlp.down_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.mlp.gate_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.mlp.up_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.post_attention_layernorm.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.self_attn.k_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.self_attn.o_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.self_attn.q_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.31.self_attn.rotary_emb.inv_freq": "pytorch_model-00003-of-00003.bin", + "model.layers.31.self_attn.v_proj.weight": "pytorch_model-00003-of-00003.bin", + "model.layers.4.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.4.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.4.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.5.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.5.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.6.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.6.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.7.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.7.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.8.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.8.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.input_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.mlp.down_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.mlp.gate_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.mlp.up_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.post_attention_layernorm.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.self_attn.k_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.self_attn.o_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.self_attn.q_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.layers.9.self_attn.rotary_emb.inv_freq": "pytorch_model-00001-of-00003.bin", + "model.layers.9.self_attn.v_proj.weight": "pytorch_model-00001-of-00003.bin", + "model.norm.weight": "pytorch_model-00003-of-00003.bin" + } +} diff --git a/tokenization_codegen25.py b/tokenization_codegen25.py new file mode 100644 index 0000000..06a194e --- /dev/null +++ b/tokenization_codegen25.py @@ -0,0 +1,247 @@ +# Copyright (c) 2023, salesforce.com, inc. +# All rights reserved. +# SPDX-License-Identifier: Apache-2.0 +# For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/Apache-2.0 +"""Tokenization classes for CodeGen2.5.""" + +from typing import List, Optional, Union + +from transformers.tokenization_utils import AddedToken, PreTrainedTokenizer +from transformers.utils import logging + +try: + import tiktoken +except ModuleNotFoundError as e: + raise ModuleNotFoundError("CodeGen2.5 requires the installation of tiktoken. Please install it via `pip install tiktoken`.") from e + + +logger = logging.get_logger(__name__) + +MAX_MODEL_INPUT_SIZES = { + "Salesforce/codegen25-7b-multi": 2048, + "Salesforce/codegen25-7b-mono": 2048, + "Salesforce/codegen25-7b-instruct": 2048, +} + + +def tiktoken_tokenizer(base="gpt2", pad_token=None, add_special=True): + if not add_special: + return tiktoken.get_encoding(base) + + def include_whitespace(n_min=2, n_max=20): + whitespaces = [" " * n for n in reversed(range(n_min, n_max))] + return whitespaces + + def include_tabs(n_min=2, n_max=20): + tabs = ["\t" * n for n in reversed(range(n_min, n_max))] + return tabs + + def include_fim_tokens(): + fim_tokens = [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + ] + return fim_tokens + + def include_codegen2_tokens(): + tokens = [] + tokens += [f"" for i in range(4)] + tokens.append("") # 50317 + tokens.append("") # 50318 + tokens += [f"" for i in reversed(range(1, 51199-50318+1))] + return tokens + + add_whitespaces = include_whitespace(n_min=2, n_max=32) + add_tabs = include_tabs(n_min=2, n_max=10) + fim_tokens = include_fim_tokens() + codegen2_tokens = include_codegen2_tokens() + + tokenizer = tiktoken.get_encoding(base) + + idx = tokenizer.n_vocab + + bpe_ranks = tokenizer._mergeable_ranks + + for wsp in add_whitespaces: + bpe_ranks[bytes(wsp, 'ascii')] = idx + idx += 1 + for t in add_tabs: + bpe_ranks[bytes(t, 'ascii')] = idx + idx += 1 + + special_tokens = dict() + + for sp in fim_tokens: + special_tokens[sp] = idx + idx += 1 + for sp in codegen2_tokens: + special_tokens[sp] = idx + idx += 1 + + if pad_token and pad_token not in tokenizer._special_tokens and pad_token not in special_tokens: + special_tokens[pad_token] = idx + idx += 1 + # In production, load the arguments directly instead of accessing private attributes + # See openai_public.py for examples of arguments for specific encodings + enc = tiktoken.Encoding( + # If you're changing the set of special tokens, make sure to use a different name + # It should be clear from the name what behaviour to expect. + name=base.replace("base", "im"), + pat_str=tokenizer._pat_str, + mergeable_ranks=bpe_ranks, + special_tokens={ + **tokenizer._special_tokens, + **special_tokens + } + ) + return enc + + +class CodeGen25Tokenizer(PreTrainedTokenizer): + """ + Construct a CodeGen2.5 tokenizer. Based on byte-level Byte-Pair-Encoding. + Args: + vocab_file (`str`): + Path to the vocabulary file. + """ + max_model_input_sizes = MAX_MODEL_INPUT_SIZES + model_input_names = ["input_ids", "attention_mask"] + + def __init__( + self, + pad_token=None, + eos_token="<|endoftext|>", + add_eos_token=False, + add_special_tokens=True, + **kwargs, + ): + pad_token_added = AddedToken(pad_token, lstrip=False, rstrip=False) if isinstance(pad_token, str) else pad_token + eos_token_added = AddedToken(eos_token, lstrip=False, rstrip=False) if isinstance(eos_token, str) else eos_token + super().__init__( + pad_token=pad_token_added, + eos_token=eos_token_added, + add_eos_token=add_eos_token, + add_special_tokens=add_special_tokens, + **kwargs, + ) + self.add_eos_token = add_eos_token + self.encoder = tiktoken_tokenizer(base="gpt2", pad_token=pad_token, add_special=add_special_tokens) + + @property + def vocab_size(self): + """Returns vocab size""" + return self.encoder.n_vocab + + def get_vocab(self): + """Returns vocab as a dict""" + vocab = {self._convert_id_to_token(i): i for i in range(self.vocab_size)} + return vocab + + def _tokenize(self, text, **kwargs): + """Returns a tokenized string.""" + return self.encoder.encode(text, allowed_special="all") + + def _convert_token_to_id(self, token): + """Converts a token (str) in an id using the vocab.""" + if isinstance(token, str): + return self.encoder.encode_single_token(token) + else: + return token + + def _convert_id_to_token(self, index): + """Converts an index (integer) in a token (str) using the vocab.""" + return self.encoder.decode_single_token_bytes(index).decode("utf-8") + + def _decode(self, token_ids: Union[int, List[int]], skip_special_tokens: bool = False, **kwargs): + if isinstance(token_ids, int): + token_ids = [token_ids] + if skip_special_tokens: + token_ids = [t for t in token_ids if t not in self.all_special_ids] + return self.encoder.decode(token_ids) + + def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None) -> List[int]: + """Build model inputs from a sequence by appending eos_token_id.""" + eos_token_id = [self.eos_token_id] if self.add_eos_token else [] + + output = token_ids_0 + eos_token_id + + if token_ids_1 is not None: + output = output + token_ids_1 + eos_token_id + + return output + + def get_special_tokens_mask( + self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, + already_has_special_tokens: bool = False + ) -> List[int]: + """ + Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding + special tokens using the tokenizer `prepare_for_model` method. + Args: + token_ids_0 (`List[int]`): + List of IDs. + token_ids_1 (`List[int]`, *optional*): + Optional second list of IDs for sequence pairs. + already_has_special_tokens (`bool`, *optional*, defaults to `False`): + Whether the token list is already formatted with special tokens for the model. + Returns: + `List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token. + """ + if already_has_special_tokens: + return super().get_special_tokens_mask( + token_ids_0=token_ids_0, token_ids_1=token_ids_1, already_has_special_tokens=True + ) + + eos_token_id = [1] if self.add_eos_token else [] + + if token_ids_1 is None: + return ([0] * len(token_ids_0)) + eos_token_id + return ([0] * len(token_ids_0)) + eos_token_id + ([0] * len(token_ids_1)) + eos_token_id + + def create_token_type_ids_from_sequences( + self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None + ) -> List[int]: + """ + Creates a mask from the two sequences passed to be used in a sequence-pair classification task. An ALBERT + sequence pair mask has the following format: + ``` + 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 + | first sequence | second sequence | + ``` + if token_ids_1 is None, only returns the first portion of the mask (0s). + Args: + token_ids_0 (`List[int]`): + List of ids. + token_ids_1 (`List[int]`, *optional*): + Optional second list of IDs for sequence pairs. + Returns: + `List[int]`: List of [token type IDs](../glossary#token-type-ids) according to the given sequence(s). + """ + eos_token_id = [self.eos_token_id] if self.add_eos_token else [] + + output = [0] * len(token_ids_0 + eos_token_id) + + if token_ids_1 is not None: + output += [1] * len(token_ids_1 + eos_token_id) + + return output + + # has no vocab file + def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None): + return () diff --git a/tokenizer_config.json b/tokenizer_config.json new file mode 100644 index 0000000..b0f36d7 --- /dev/null +++ b/tokenizer_config.json @@ -0,0 +1,12 @@ +{ + "add_eos_token": false, + "add_special_tokens": true, + "clean_up_tokenization_spaces": true, + "eos_token": "<|endoftext|>", + "model_max_length": 1000000000000000019884624838656, + "pad_token": null, + "tokenizer_class": "CodeGen25Tokenizer", + "auto_map": { + "AutoTokenizer": ["tokenization_codegen25.CodeGen25Tokenizer", null] + } +}