初始化项目，由ModelHub XC社区提供模型

Model: RedHatAI/starcoder2-7b-quantized.w8a8
Source: Original Platform

.gitattributes

@@ -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

README.md

@@ -0,0 +1,212 @@
+---
+pipeline_tag: text-generation
+datasets:
+- bigcode/the-stack-v2-train
+license: bigcode-openrail-m
+library_name: transformers
+tags:
+- code
+model-index:
+- name: starcoder2-7b-quantized.w8a8
+  results:
+  - task:
+      type: text-generation
+    dataset:
+      name: HumanEval+
+      type: humanevalplus
+    metrics:
+    - type: pass@1
+      value: 29.3
+  - task:
+      type: text-generation
+    dataset:
+      name: HumanEval
+      type: humaneval
+    metrics:
+    - type: pass@1
+      value: 33.9
+---
+
+# starcoder2-7b-quantized.w8a8
+
+## Model Overview
+- **Model Architecture:** StarCoder2
+  - **Input:** Text
+  - **Output:** Text
+- **Model Optimizations:**
+  - **Activation quantization:** INT8
+  - **Weight quantization:** INT8
+- **Intended Use Cases:** Intended for commercial and research use. Similarly to [starcoder2-7b](https://huggingface.co/bigcode/starcoder2-7b), this model is intended for code generation and is _not_ an instruction model. Commands like "Write a function that computes the square root." do not work well.
+- **Out-of-scope:** Use in any manner that violates applicable laws or regulations (including trade compliance laws).
+- **Release Date:** 8/1/2024
+- **Version:** 1.0
+- **License(s):** bigcode-openrail-m
+- **Model Developers:** Neural Magic
+
+Quantized version of [starcoder2-7b](https://huggingface.co/bigcode/starcoder2-7b).
+It achieves a HumanEval pass@1 of 33.9, whereas the unquantized model achieves 34.9 when evaluated under the same conditions.
+
+### Model Optimizations
+
+This model was obtained by quantizing the weights of [starcoder2-7b](https://huggingface.co/bigcode/starcoder2-7b) to INT8 data type.
+This optimization reduces the number of bits used to represent weights and activations from 16 to 8, reducing GPU memory requirements (by approximately 50%) and increasing matrix-multiply compute throughput (by approximately 2x).
+Weight quantization also reduces disk size requirements by approximately 50%.
+
+Only weights and activations of the linear operators within transformers blocks are quantized.
+Weights are quantized with a symmetric static per-channel scheme, where a fixed linear scaling factor is applied between INT8 and floating point representations for each output channel dimension.
+Activations are quantized with a symmetric dynamic per-token scheme, computing a linear scaling factor at runtime for each token between INT8 and floating point representations.
+The [GPTQ](https://arxiv.org/abs/2210.17323) algorithm is applied for quantization, as implemented in the [llm-compressor](https://github.com/vllm-project/llm-compressor) library.
+GPTQ used a 1% damping factor and 256 sequences of 8,192 random tokens.
+
+
+## Deployment
+
+### Use with vLLM
+
+This model can be deployed efficiently using the [vLLM](https://docs.vllm.ai/en/latest/) backend, as shown in the example below.
+
+```python
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+
+model_id = "neuralmagic/starcoder2-7b-quantized.w8a8"
+number_gpus = 1
+
+sampling_params = SamplingParams(temperature=0.2, top_p=0.95, max_tokens=256)
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+prompts = ["def print_hello_world():"]
+
+llm = LLM(model=model_id, tensor_parallel_size=number_gpus)
+
+outputs = llm.generate(prompts, sampling_params)
+
+generated_text = outputs[0].outputs[0].text
+print(generated_text)
+```
+
+vLLM aslo supports OpenAI-compatible serving. See the [documentation](https://docs.vllm.ai/en/latest/) for more details.
+
+
+## Creation
+
+This model was created by using the [llm-compressor](https://github.com/vllm-project/llm-compressor) library as presented in the code snipet below.
+
+```python
+from transformers import AutoTokenizer
+from datasets import Dataset
+from llmcompressor.transformers import SparseAutoModelForCausalLM, oneshot
+from llmcompressor.modifiers.quantization import GPTQModifier
+import random
+
+model_id = "bigcode/starcoder2-7b"
+
+num_samples = 256
+max_seq_len = 8192
+
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+
+max_token_id = len(tokenizer.get_vocab()) - 1
+input_ids = [[random.randint(0, max_token_id) for _ in range(max_seq_len)] for _ in range(num_samples)]
+attention_mask = num_samples * [max_seq_len * [1]]
+ds = Dataset.from_dict({"input_ids": input_ids, "attention_mask": attention_mask})
+
+recipe = GPTQModifier(
+  targets="Linear",
+  scheme="W8A8",
+  ignore=["lm_head"],
+  dampening_frac=0.01,
+)
+
+model = SparseAutoModelForCausalLM.from_pretrained(
+  model_id,
+  device_map="auto",
+  trust_remote_code=True,
+)
+
+oneshot(
+  model=model,
+  dataset=ds,
+  recipe=recipe,
+  max_seq_length=max_seq_len,
+  num_calibration_samples=num_samples,
+)
+model.save_pretrained("starcoder2-7b-quantized.w8a8")
+```
+
+
+## Evaluation
+
+The model was evaluated on the [HumanEval](https://arxiv.org/abs/2107.03374) and [HumanEval+](https://arxiv.org/abs/2305.01210) benchmarks, using the generation configuration from [Big Code Models Leaderboard](https://huggingface.co/spaces/bigcode/bigcode-models-leaderboard).
+We used Neural Magic's fork of [evalplus](https://github.com/neuralmagic/evalplus) and the [vLLM](https://docs.vllm.ai/en/stable/) engine, using the following commands:
+
+```
+python codegen/generate.py \
+  --model neuralmagic/starcoder2-7b-quantized.w8a8 \
+  --bs 16 \
+  --temperature 0.2 \
+  --n_samples 50 \
+  --dataset humaneval \
+  -- root "."
+
+python3 evalplus/sanitize.py humaneval/neuralmagic--starcoder2-7b-quantized.w8a8_vllm_temp_0.2
+
+evalplus.evaluate --dataset humaneval --samples humaneval/neuralmagic--starcoder2-7b-quantized.w8a8_vllm_temp_0.2-sanitized
+```
+
+### Accuracy
+
+<table>
+  <tr>
+   <td><strong>Benchmark</strong>
+   </td>
+   <td><strong>starcoder2-7b</strong>
+   </td>
+   <td><strong>starcoder2-7b-quantized.w8a8 (this model)</strong>
+   </td>
+   <td><strong>Recovery</strong>
+   </td>
+  </tr>
+  <tr>
+   <td>HumanEval pass@1
+   </td>
+   <td>34.9
+   </td>
+   <td>33.9
+   </td>
+   <td>97.1%
+   </td>
+  </tr>
+  <tr>
+   <td>HumanEval pass@10
+   </td>
+   <td>50.7
+   </td>
+   <td>50.9
+   </td>
+   <td>100.4%
+   </td>
+  </tr>
+  <tr>
+   <td>HumanEval+ pass@1
+   </td>
+   <td>30.0
+   </td>
+   <td>29.3
+   </td>
+   <td>97.7%
+   </td>
+  </tr>
+  <tr>
+   <td>HumanEval+ pass@10
+   </td>
+   <td>43.0
+   </td>
+   <td>43.6
+   </td>
+   <td>101.4%
+   </td>
+  </tr>
+  <tr>
+</table>

config.json

@@ -0,0 +1,76 @@
+{
+  "_name_or_path": "/root/.cache/huggingface/hub/models--bigcode--starcoder2-7b/snapshots/bb9afde76d7945da5745592525db122d4d729eb1",
+  "activation_function": "gelu",
+  "architectures": [
+    "Starcoder2ForCausalLM"
+  ],
+  "attention_dropout": 0.1,
+  "attention_softmax_in_fp32": true,
+  "bos_token_id": 0,
+  "embedding_dropout": 0.1,
+  "eos_token_id": 0,
+  "hidden_act": "gelu_pytorch_tanh",
+  "hidden_size": 4608,
+  "initializer_range": 0.018042,
+  "intermediate_size": 18432,
+  "layer_norm_epsilon": 1e-05,
+  "max_position_embeddings": 16384,
+  "mlp_type": "default",
+  "model_type": "starcoder2",
+  "norm_epsilon": 1e-05,
+  "norm_type": "layer_norm",
+  "num_attention_heads": 36,
+  "num_hidden_layers": 32,
+  "num_key_value_heads": 4,
+  "residual_dropout": 0.1,
+  "rope_theta": 1000000,
+  "scale_attention_softmax_in_fp32": true,
+  "scale_attn_weights": true,
+  "sliding_window": 4096,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.43.3",
+  "use_bias": true,
+  "use_cache": true,
+  "vocab_size": 49152,
+  "quantization_config": {
+    "config_groups": {
+      "group_0": {
+        "input_activations": {
+          "block_structure": null,
+          "dynamic": true,
+          "group_size": null,
+          "num_bits": 8,
+          "observer": "memoryless",
+          "observer_kwargs": {},
+          "strategy": "token",
+          "symmetric": true,
+          "type": "int"
+        },
+        "output_activations": null,
+        "targets": [
+          "Linear"
+        ],
+        "weights": {
+          "block_structure": null,
+          "dynamic": false,
+          "group_size": null,
+          "num_bits": 8,
+          "observer": "minmax",
+          "observer_kwargs": {},
+          "strategy": "channel",
+          "symmetric": true,
+          "type": "int"
+        }
+      }
+    },
+    "format": "int-quantized",
+    "global_compression_ratio": 1.229096047677562,
+    "ignore": [
+      "lm_head"
+    ],
+    "kv_cache_scheme": null,
+    "quant_method": "compressed-tensors",
+    "quantization_status": "compressed",
+    "sparsity_config": {}
+  }
+}

configuration.json

@@ -0,0 +1 @@
+{"framework": "pytorch", "task": "text-generation", "allow_remote": true}

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "transformers_version": "4.43.3"
+}

merges.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac9dfb2c5bd3b10bd46aa7fdaa8c54e8e1bcfe1618d9288320ebc82c518442fc
+size 441705

model-00001-of-00002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10512a78ac59049406bcf5ec8fe6f4736e7224cad2e0cffd68856ff86da123ea
+size 4929775480

model-00002-of-00002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b93cd97cecbbe7a82cafd6dbfd42aec3dc89531629ff65ba3ec795ad6e9b9cd
+size 2927498864

model.safetensors.index.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d078282238d0dca09540584e4fdd5bfafc2d3755beaa511a63b8d4485a0d04b7
+size 58278

recipe.yaml

@@ -0,0 +1,8 @@
+quant_stage:
+  quant_modifiers:
+    GPTQModifier:
+      sequential_update: false
+      dampening_frac: 0.01
+      ignore: [lm_head]
+      scheme: W8A8
+      targets: Linear

special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b8d9e1e1efd775a22a19ee45b85a31b524766c0db89de00ed249a7433794762
+size 1332

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17fa145258b20c18287f1e3bd804e074cc13333f11984a2f5a2f11c5110437aa
+size 2060947

tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:967231a56db74a08ced2afea94492b831e581da94a411436cce9ec40a0541f00
+size 7909

vocab.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:542ee3f8b27b3a825754728b4dc59eff31065fecce843a93f09b98f13dbd7de9
+size 777202