diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..352207e9d567da48dbf850b4581f78a88e8f72b4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,35 +1,48 @@ *.7z filter=lfs diff=lfs merge=lfs -text *.arrow filter=lfs diff=lfs merge=lfs -text *.bin 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 +*.zstandard filter=lfs diff=lfs merge=lfs -text +*.tfevents* filter=lfs diff=lfs merge=lfs -text +*.db* filter=lfs diff=lfs merge=lfs -text +*.ark* filter=lfs diff=lfs merge=lfs -text +**/*ckpt*data* filter=lfs diff=lfs merge=lfs -text +**/*ckpt*.meta filter=lfs diff=lfs merge=lfs -text +**/*ckpt*.index filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.gguf* filter=lfs diff=lfs merge=lfs -text +*.ggml filter=lfs diff=lfs merge=lfs -text +*.llamafile* filter=lfs diff=lfs merge=lfs -text +*.pt2 filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +"/model.safetensors.index.json" filter=lfs diff=lfs merge=lfs -text \ No newline at end of file diff --git a/.ipynb_checkpoints/cubic_quantization_report-checkpoint.json b/.ipynb_checkpoints/cubic_quantization_report-checkpoint.json new file mode 100644 index 0000000000000000000000000000000000000000..e7b32bc47c08fbcd0e814cefc8c0007624c82db6 --- /dev/null +++ b/.ipynb_checkpoints/cubic_quantization_report-checkpoint.json @@ -0,0 +1,105 @@ +{ + "manifest": { + "source": "/root/private_data/model/moonshotai/Kimi-K3", + "output": "/root/private_data/model/tclf90/Kimi-K3-Cubic-2.5Bit", + "temporary_output": "/root/private_data/model/tclf90/Kimi-K3-Cubic-2.5Bit.incomplete", + "moe_schedule": "1-3:3@256,4-32:3@512,33-91:2@512,92:4@512", + "linear_schedule": "", + "devices": [ + "cuda:0" + ], + "shard_size_gib": 3.0, + "a8_carrier_aware": true, + "a8_correction_default": "enabled", + "fitting_objective": "groupwise-least-squares", + "reported_loss": "NRMSE = sqrt(joint SSE / source weight SSE)", + "row_chunk_size": -1, + "source_shards": 96, + "expert_payload_bits": 2.369565217391304, + "expert_effective_bits": 2.498641304347826, + "converted_tensor_effective_bits": 2.498641304347826, + "worker_scheduling": "dynamic_source_shard_queue", + "output_partitioning": "deterministic_source_shard_index", + "script": "/root/private_data/quantize_k3.py", + "script_sha256": "49a8ddded77fe5b0dbb9273341e357881a96f6d0dcb08d620d3597286849dfb2", + "source_config_sha256": "9710e121a58d03ac92c8d6da287a19541994319afbbe6d6202af001ffd379213", + "source_index_sha256": "a1c5210650ce71d2d3ae9ec5a101ac4afd3cf4b10091be589853437eb967febd", + "output_shards": 341, + "output_total_bytes": 964943224704, + "combined_report": "cubic_quantization_report.json" + }, + "loss_statistics": { + "objective": "mean(continuous MSE, rounded-A8-carrier MSE)", + "normalization": "loss is sqrt(joint SSE / source weight SSE), i.e. NRMSE; the fitting objective itself remains least squares.", + "loss_metadata_precision": "FP32 scale and FP16 a/b", + "by_bit": { + "2": { + "bits": 2, + "loss": 0.4512510036043458, + "clipped_percent": 12.230740958337455, + "a8_correction_loss": 0.4512510036043458 + }, + "3": { + "bits": 3, + "loss": 0.1808832329572129, + "clipped_percent": 2.966870049061148, + "a8_correction_loss": 0.18091672432952213 + }, + "4": { + "bits": 4, + "loss": 0.0430471542191854, + "clipped_percent": 0.5635438119473101, + "a8_correction_loss": 0.04324462046872603 + } + }, + "by_bit_and_group_size": { + "2@512": { + "bits": 2, + "loss": 0.4512510036043458, + "clipped_percent": 12.230740958337455, + "a8_correction_loss": 0.4512510036043458, + "group_size": 512 + }, + "3@256": { + "bits": 3, + "loss": 0.17960834694437933, + "clipped_percent": 2.697093164208975, + "a8_correction_loss": 0.17957951946425452, + "group_size": 256 + }, + "3@512": { + "bits": 3, + "loss": 0.18100745846499253, + "clipped_percent": 2.9947780026665454, + "a8_correction_loss": 0.18104699761257, + "group_size": 512 + }, + "4@512": { + "bits": 4, + "loss": 0.0430471542191854, + "clipped_percent": 0.5635438119473101, + "a8_correction_loss": 0.04324462046872603, + "group_size": 512 + } + } + }, + "audit": { + "checkpoint": "/root/private_data/model/tclf90/Kimi-K3-Cubic-2.5Bit.incomplete", + "shards": 341, + "tensors": 991812, + "total_size": 964943224704, + "max_shard_bytes": 3221225472, + "widths_present": [ + 2, + 3, + 4 + ], + "converted_tensor_effective_bits": 2.498641304347826, + "dtype_counts": { + "BF16": 2122, + "F32": 247802, + "F16": 494592, + "U8": 247296 + } + } +} diff --git a/.mdl b/.mdl new file mode 100644 index 0000000000000000000000000000000000000000..201fe8071b295a6a6825d8e3f6af14e702d46114 Binary files /dev/null and b/.mdl differ diff --git a/.msc b/.msc new file mode 100644 index 0000000000000000000000000000000000000000..ef82019041880fc6e0b85555707f2a3c27c07cf9 Binary files /dev/null and b/.msc differ diff --git a/.mv b/.mv new file mode 100644 index 0000000000000000000000000000000000000000..060f608c8a1d92d5d6a83201a75488de6602a64a --- /dev/null +++ b/.mv @@ -0,0 +1 @@ +Revision:master,CreatedAt:1785171841 \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..97c0111bba229b0981b1d74e34bacef723ca8f7b --- /dev/null +++ b/LICENSE @@ -0,0 +1,52 @@ +Kimi K3 License + +Copyright (c) 2026 Moonshot AI + +Permission is hereby granted, free of charge, to any person (the "Licensee") +obtaining a copy of this software — including the model weights, parameters, +configuration files, inference and training code, and associated documentation +(collectively, the "Software") — to deal in the Software without restriction. +This includes, without limitation, the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of the Software; to run, +deploy, fine-tune, or otherwise modify the Software and create derivative works +from it; and to permit persons to whom the Software is furnished to do so, in +each case subject to the following conditions: + +1. The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. Licensee's use of the +Software must comply with applicable laws and regulations. + +2. "Model as a Service" means giving a third party access to language model +inference or fine-tuning (e.g., via API) in a manner that allows such third +party to exercise meaningful control over the inputs, parameters, or training +data. This does not include (a) end-user products with model capabilities solely +embedded within specific features or harnesses, or (b) mere relaying of requests +to models hosted by others. + +If the Licensee or any of its affiliates operates a Model as a Service business, +and the aggregate revenue of the Licensee and its affiliates exceeds 20 million +US dollars (or the equivalent in other currencies) in total over any consecutive +12 months, the Licensee must enter into a separate agreement with Moonshot AI +before using the Software or its derivative works for any commercial purpose. + +3. If the Software (or any derivative works thereof) is used for any of the +Licensee's commercial products or services that have more than 100 million +monthly active users, or more than 20 million US dollars (or equivalent in other +currencies) in monthly revenue, "Kimi K3" must be prominently displayed on the +user interface of such product or service. + +4. The requirements set forth in Sections 2 and 3 do not apply to: (a) internal +use of the Software, defined as any use that does not make the Software, its +outputs, or its underlying capabilities available to third parties; or (b) any +use of the Software accessed through Moonshot AI's official products or +certified inference partners. + +5. THE SOFTWARE AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” +BASIS, 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 MOONSHOT AI OR ITS AFFILIATES 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. + +For any questions regarding this license, please contact . \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..99d922dfec349089dcedf8ebddea647fd89580f6 --- /dev/null +++ b/README.md @@ -0,0 +1,876 @@ +--- +license: other +license_name: kimi-k3 +library_name: transformers +pipeline_tag: image-text-to-text +tags: +- vLLM +- cubic-quantization +- W2A8 +- W3A8 +- W4A8 +- W2A16 +- W3A16 +- W4A16 +- multimodal +base_model: +- moonshotai/Kimi-K3 +base_model_relation: quantized +--- + +# Kimi-K3-Cubic-2.5Bit + +Base model: [moonshotai/Kimi-K3](https://huggingface.co/moonshotai/Kimi-K3) + +**2.8T parameters · 2.5-bit experts · one 8 × H200 node · ~700K context** + +Kimi-K3-Cubic-2.5Bit is the first public showcase of **Cubic quantization**, +exploring practical ultra-low-bit, high-concurrency LLM inference. + +Cubic uses parameterized, non-uniform levels that adapt to each weight group, +designed to challenge conventional integer and floating-point formats at +ultra-low precision while relaxing the usual need for small group sizes; most +quantized layers in this model use group size 512. + +- **57 output tok/s** — single-request short-context decode +- **800–900+ output tok/s** — 64-way concurrency, without dSpark or other + speculative decoding +- **W1–W8 runtime kernels** — native SM80/86/89/90/90a/100/120 coverage + +The export is fully data-free: no calibration dataset or activation samples +were used. The complete converter is included as +[`quantize_k3.py`](./quantize_k3.py). The same packed checkpoint runs in either +weight-only A16 or dynamic-A8 mode through the +[QuantTrio vLLM Cubic runtime](https://github.com/QuantTrio/vllm-cubic). +This checkpoint itself uses mixed W2, W3, and W4 expert weights with an audited +effective width of **2.4986 bits**. + +### 【Quantization Policy】 + +| Scope | Format | +|-------|--------| +| Dense layer 0 | Source dtype (BF16) | +| MoE layers 1–3 routed experts | Cubic W3, group size 256 | +| MoE layers 4–32 routed experts | Cubic W3, group size 512 | +| MoE layers 33–91 routed experts | Cubic W2, group size 512 | +| MoE layer 92 routed experts | Cubic W4, group size 512 | +| Attention/KDA/MLA weights | Source dtype (BF16) | +| Shared experts and ordinary MLP weights | Source dtype (BF16) | +| Vision tower, multimodal projector, embeddings, norms, and LM head | Source dtype | + +`Loss` is the scale-free NRMSE of groupwise weight reconstruction, not a +downstream task-accuracy score. + +| Format | Loss | Clipped values | +|--------|-----:|---------------:| +| W2, group size 512 | 0.451251 | 12.2307% | +| W3, group size 256 | 0.179608 | 2.6971% | +| W3, group size 512 | 0.181007 | 2.9948% | +| W4, group size 512 | 0.043047 | 0.5635% | + +### 【Dependencies / Installation】 + +- Runtime: [vLLM Cubic v0.26.1+cubic.20260805](https://github.com/QuantTrio/vllm-cubic/releases/tag/v0.26.1%2Bcubic.20260805) +- Python: 3.10–3.14 +- Platform: Linux x86-64, PyTorch 2.13.0, CUDA 13.0 +- Verified: Python 3.12, 8 × H200, TP8 + EP + +Install: + +```bash +uv venv --python 3.12 .venv +source .venv/bin/activate +uv pip install \ + 'https://github.com/QuantTrio/vllm-cubic/releases/download/v0.26.1%2Bcubic.20260805/vllm-0.26.1%2Bcubic.20260805-cp38-abi3-linux_x86_64.whl' +``` + +### 【Quantization Script】 + +- Script: [`quantize_k3.py`](./quantize_k3.py) ([source](https://github.com/QuantTrio/vllm-cubic/blob/main/examples/quantization/quantize_k3.py)) +- Input: original `moonshotai/Kimi-K3` MXFP4 checkpoint +- Method: data-free; dynamic-A8 carrier correction on by default (`--disable-a8-correction` to disable) +- Time: approximately **35–40 minutes on 8 × H200** with fast local storage +- Dependencies: included with vLLM Cubic; standalone: `pip install torch safetensors regex` +- Output: destination path must not already exist + +```bash +python -u quantize_k3.py \ + --source __YOUR_PATH__/moonshotai/Kimi-K3 \ + --output __YOUR_PATH__/Kimi-K3-Cubic-2.5Bit \ + --devices cuda:0,cuda:1,cuda:2,cuda:3,cuda:4,cuda:5,cuda:6,cuda:7 +``` + +### 【vLLM Startup Command】 + +The following command enables dynamic A8 Cubic execution. Change +`VLLM_CUBIC_DYNAMIC_A8` to `0` to run the same checkpoint in weight-only A16 +mode. + +```bash +export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 +export VLLM_CUBIC_DYNAMIC_A8=1 + +vllm serve \ + __YOUR_PATH__/Kimi-K3-Cubic-2.5Bit \ + --served-model-name Kimi-K3-Cubic-2.5Bit \ + --trust-remote-code \ + --quantization cubic \ + --kv-cache-dtype fp8_q16 \ + --gpu-memory-utilization 0.985 \ + --tensor-parallel-size 8 \ + --enable-expert-parallel \ + --mm-encoder-tp-mode data \ + --max-model-len auto \ + --max-num-seqs 128 \ + --max-num-batched-tokens 2048 \ + --enable-prefix-caching \ + --enable-auto-tool-choice \ + --tool-call-parser kimi_k3 \ + --reasoning-parser kimi_k3 \ + --host 0.0.0.0 \ + --port 8000 \ + --disable-uvicorn-access-log +``` + +Observed performance for this command on 8 × NVIDIA H200 141GB +(2026-08-05) is: + +| Item | Observed value | +|------|---------------:| +| Dynamic Cubic mode | A8 | +| Parallel topology | TP8 + EP | +| KV-cache dtype | `fp8_q16` | +| Effective maximum model length | 728,640 tokens | +| Single-request short-context decode | approximately 57 output tok/s | +| 64-request aggregate decode | approximately 800–900+ output tok/s | +| Speculative decoding | None; dSpark was not used | + +The throughput values are stable decode-window measurements from short-prompt, +long-output text requests, rather than end-to-end request throughput. Prompt +length, generated context length, sampling, concurrent prefill, GPU clocks, and +other workloads can change the result. Because `--max-model-len auto` derives +the limit from free memory measured during startup, the effective token count +can also vary slightly between launches. + +`fp8_q16` is an optional query-preserving FP8 KV-cache mode from the Cubic +runtime. It keeps attention queries in the model dtype and automatically +selects a compatible attention backend. To use a conventional BF16 KV cache, +replace it with `--kv-cache-dtype auto`; this reduces the available context +length but provides the highest-precision KV storage. + +The first launch may spend several minutes compiling Triton kernels, +calibrating Cubic kernel choices for the tensors and GPU type in use, and +capturing CUDA graphs. Calibration results are persisted in the Triton cache +and reused by later launches on compatible devices. + +### 【Validation Status】 + +- 8 × H200 TP8 + EP model loading and text generation verified. +- Weight-only A16 and dynamic-A8 execution verified with the same checkpoint. +- `fp8_q16` and BF16 KV-cache serving paths verified. +- No formal downstream benchmark is claimed for this quantized checkpoint; + evaluate quality and performance for your own workloads before deployment. + +### 【Model Files】 + +| Item | Value | +|------|-------| +| Model data | 899 GiB | +| Safetensors shards | 341 | +| Last updated | 2026-08-05 | + +### 【Model Download】 + +```python +from huggingface_hub import snapshot_download + +snapshot_download( + "QuantTrio/Kimi-K3-Cubic-2.5Bit", + local_dir="your_local_path/Kimi-K3-Cubic-2.5Bit", +) +``` + +### 【License】 + +This quantized checkpoint is derived from Kimi K3 and remains subject to the +[Kimi K3 License](https://huggingface.co/moonshotai/Kimi-K3/blob/main/LICENSE). +The QuantTrio vLLM Cubic runtime is distributed separately under its own +repository license. + +### 【Base Model Overview】 + +The following material is reproduced from the upstream Kimi K3 model card and +describes the base model. Upstream MXFP4 deployment instructions do not apply +to this Cubic checkpoint; use the Cubic installation and launch command above. + +
+ + Kimi K3 + +
+
+
+ Chat + Homepage +
+ +
+ Hugging Face + Twitter Follow + Discord + ModelScope +
+
+ License +
+ + +

+📰  Tech Blog |     📄  Full Report +

+ + + +## 1. Model Introduction + +Kimi K3 is an open-weight, native multimodal agentic model and our most capable model to date. It is a 2.8T-parameter model built on Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), with native vision capabilities and a 1-million-token context window. It is the world's first open 3T-class model, designed for frontier intelligence across long-horizon coding, knowledge work, and reasoning. + +### Key Features +- **New Architecture**: Kimi K3 is built on Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), and scales up MoE sparsity with a Stable LatentMoE framework that activates 16 out of 896 experts — yielding an approximate 2.5× improvement in overall scaling efficiency over Kimi K2. +- **Long-Horizon Coding**: Operating with minimal human oversight, Kimi K3 sustains long engineering sessions, navigates massive repositories, and orchestrates terminal tools — from GPU kernel optimization and compiler development to vision-in-the-loop game dev, CAD, and even chip design. +- **Agentic Knowledge Work**: Kimi K3 advances end-to-end knowledge work, producing deep research with interactive visualizations, widgets and dashboards, and motion design and video editing, powered by its native multimodal architecture. +- **Native Multimodality & Long Context**: Kimi K3 understands text, images, and video within the same model, and supports a 1-million-token context window. +- **Open Frontier Weights**: We release the full Kimi K3 model weights under the Kimi K3 License, making frontier intelligence openly available for research, deployment, and further innovation. +## 2. Model Summary + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ArchitectureMixture-of-Experts (MoE)
Total Parameters2.8T
Activated Parameters104B
Number of Layers93
Number of Dense Layers1
Attention-Layer Composition69 KDA + 24 Gated MLA
Attention Hidden Dimension7168
Number of Attention Heads96
Latent MoE Dimension3584
MoE Hidden Dimension (per Expert)3072
Number of Experts896
Selected Experts per Token16
Number of Shared Experts2
Vocabulary Size160K
Context Length1048576
Attention MechanismKDA & Gated MLA
Activation FunctionSiTU-GLU
Vision EncoderMoonViT-V2
Parameters of Vision Encoder401M
QuantizationMXFP4 weights / MXFP8 activations
(quantization-aware training)
ModalityText, Image
+
+ + +## 3. Evaluation Results + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BenchmarkKimi K3
(max)		Claude Fable 5
(max, w/ fallback)		GPT-5.6 Sol
(max)		Claude Opus 4.8
(max)		GPT-5.5
(xhigh)		GLM-5.2
(max)
Reasoning & Knowledge
GPQA Diamond93.592.694.191.093.591.2
CritPt23.428.632.320.927.120.9
AA-LCR74.770.073.767.774.371.3
HLE-Full43.5 / 56.053.3 / 63.044.5 / 58.049.8 / 57.941.4 / 52.2—
Coding
DeepSWE67.570.073.059.067.046.2
ProgramBench77.876.877.671.970.863.7
Terminal-Bench 2.188.388.088.884.683.482.7
FrontierSWE81.286.671.366.764.967.3
SWE-Marathon42.035.039.040.014.013.0
PostTrainBench36.641.434.634.128.434.3
MLS-Bench-Lite48.349.946.242.835.540.4
SciCode58.760.256.153.556.150.5
Kimi Code Bench 2.072.976.964.871.769.064.2
Agentic
BrowseComp91.288.090.484.384.4—
DeepSearchQA (F1)95.094.2—93.1——
ResearchRubrics76.2—73.873.564.071.1
GDPval-AA v2 (Elo)168617471736159314911510
Toolathlon-Verified76.577.974.976.273.559.9
MCPMark-Verified94.587.492.976.492.9—
MCP-Atlas84.284.783.683.682.882.6
AutomationBench30.829.129.727.222.712.9
JobBench54.357.445.448.438.343.4
AA-Briefcase (Elo)154815831495135411581260
Agents' Last Exam28.325.7†29.627.026.620.4
APEX-Agents41.043.339.939.438.535.6
OfficeQA Pro63.369.963.263.960.941.4
SpreadsheetBench 234.834.732.431.629.128.1
OSWorld-Verified84.885.083.083.479.0—
OSWorld 2.058.366.162.655.749.5—
SaaS-Bench60.1—61.456.143.8—
τ³-Banking33.426.833.027.631.326.8
Harvey Lab-AA94.693.687.291.186.391.0
CorpFin v271.671.864.466.768.466.1
Finance Agent v254.456.353.853.951.849.7
Legal Research Bench44.249.548.143.840.431.3
Vision
WorldVQA ForceAnswer51.056.741.839.138.5—
OmniDocBench91.189.885.887.989.4—
PerceptionBench58.557.259.747.255.8—
Video-MME (w. sub)90.0—89.586.089.3—
MMVU82.1—81.279.281.7—
BabyVision w/ python85.790.588.981.283.6—
MMMU-Pro81.6 / 83.481.2 / 86.583.0 / 84.678.9 / 82.781.2 / 83.2—
CharXiv (RQ)84.8 / 91.388.9 / 93.584.6 / 89.180.5 / 89.984.1 / 89.0—
MathVision94.3 / 97.894.8 / 98.695.8 / 97.886.7 / 97.192.2 / 96.8—
ZeroBench (pass@5)23.0 / 41.023.0 / 46.017.0 / 35.017.0 / 34.022.0 / 41.0—
+
+ +
+Footnotes + +All Kimi K3 results are obtained with reasoning effort set to 'max' and temperature = 1.0. For single-step tasks, such as GPQA Diamond, HLE-Full, and vision benchmarks without tools, we set top-p = 0.95; for agentic tasks, we set top-p = 1.0. For HLE-Full, MMMU-Pro, CharXiv (RQ), MathVision, and ZeroBench, each cell reports the scores without and with tool augmentation (general tools for HLE-Full, Python for the vision benchmarks), in that order. + +1. **Reasoning & knowledge benchmarks** + - **CritPt and AA-LCR.** Scores are cited from [Artificial Analysis](https://artificialanalysis.ai/) as of July 23, 2026. +2. **Coding benchmarks** + - **DeepSWE.** Kimi K3 is evaluated with the Kimi Code harness. The GLM-5.2 score is taken from the [GLM-5.2 release blog](https://z.ai/blog/glm-5.2); all remaining scores are from the official [DeepSWE leaderboard](https://deepswe.datacurve.ai/), under which Kimi K3 attains 67.3 with the mini-SWE-agent harness. We report the DeepSWE v1.1 tasks. + - **Terminal-Bench 2.1.** Kimi K3 is evaluated with the Kimi Code harness. For all other models, we report the best score across harnesses: GLM-5.2 with Claude Code ([GLM-5.2 release blog](https://z.ai/blog/glm-5.2)); Claude Opus 4.8 and Claude Fable 5 with Terminus 2 ([Artificial Analysis](https://artificialanalysis.ai/evaluations/terminalbench-v2-1)); GPT-5.5 and GPT-5.6 Sol with Codex ([OpenAI](https://openai.com/index/previewing-gpt-5-6-sol/)). + - **ProgramBench.** Kimi K3 is evaluated with the Kimi Code harness. The GLM-5.2 score is from the [GLM-5.2 release blog](https://z.ai/blog/glm-5.2); all other scores are from [Vals AI](https://www.vals.ai/benchmarks/programbench). + - **SWE-Marathon.** Kimi K3, Claude Opus 4.8, and Claude Fable 5 are evaluated with the Claude Code harness; GPT-5.6 Sol is evaluated with the Codex harness. The GLM-5.2 score is from the [GLM-5.2 release blog](https://z.ai/blog/glm-5.2). Our evaluation is based on an H20-calibrated branch of the [official tasks](https://www.swe-marathon.org/) as of July 9, 2026, prior to the final v1.1 release: the Docker images, performance gates, and reference oracles for the GPU tasks have been recalibrated for H20, while the correctness and anti-cheat validators remain unchanged. Additionally, Claude Fable 5 hit fallbacks on 35% of the tasks in our evaluation, which may have negatively impacted its measured performance. + - **FrontierSWE.** Kimi K3 is evaluated with the Kimi Code harness and GPT-5.6 Sol with the Codex harness; all other results are from [FrontierSWE](https://www.frontierswe.com/). Dominance scores are recomputed from the raw scores using the official evaluation script and are current as of July 16, 2026. + - **PostTrainBench.** Scores for GLM-5.2, GPT-5.5, and Claude Opus 4.8 are adopted from the official [PostTrainBench](https://posttrainbench.com/) results. Kimi K3, Claude Fable 5, and GPT-5.6 Sol are evaluated with the official Harbor implementation at maximum reasoning effort, averaged over three runs on H20 GPUs (instead of H100 in the official setting) — Kimi K3 and Claude Fable 5 with the Claude Code harness, and GPT-5.6 Sol with the Codex harness. + - **MLS-Bench-Lite.** Kimi K3 is evaluated with the Kimi Code harness; GLM-5.2 and the Claude models with the Claude Code harness; GPT-5.5 and GPT-5.6 Sol with the Codex harness. + - **SciCode.** Scores are cited from [Artificial Analysis](https://artificialanalysis.ai/) as of July 23, 2026. + - **Kimi Code Bench 2.0 (in-house).** Kimi K3 is evaluated with the Kimi Code harness (it attains 73.7 with the Claude Code harness); GLM-5.2, Claude Opus 4.8, and Claude Fable 5 with the Claude Code harness; GPT-5.5 and GPT-5.6 Sol with the Codex harness. All models are evaluated at maximum reasoning effort, except GPT-5.5, which uses the "xhigh" setting. As the benchmark includes cybersecurity and safety-related tasks, we also disclose the fraction of refused or fallback tasks: Claude Fable 5 hit 13 fallbacks and 1 refusal out of 80 tasks; 10 refusals out of 80 tasks entered GPT-5.6 Sol's cyber guard; GPT-5.5 had 3 refusals out of 80 tasks. +3. **Agentic benchmarks** + - **OfficeQA Pro.** Each test case provides the agent with the entire PDF corpus, with all PDFs rendered as images and no machine-readable text available. + - **OfficeQA Pro and SpreadsheetBench 2.** Kimi K3, GLM-5.2, Claude Opus 4.8, and Claude Fable 5 are evaluated with the Claude Code harness; GPT-5.5 and GPT-5.6 Sol are evaluated with the Codex harness. + - **MCP-Atlas.** All models are evaluated on the 500-task public subset with a 100-turn limit, using Gemini 3.1 Pro as the judge. + - **AutomationBench.** All models are evaluated on the 600-task public subset, following the official GitHub setup in all other respects. + - **BrowseComp.** We adopt a context-compaction strategy triggered at 300K tokens. When evaluated with the full 1M-token context window and no context management, Kimi K3 achieves a score of 90.4. The results of Claude Fable 5, Claude Opus 4.8, GPT-5.6 Sol, and GPT-5.5 are cited from [Anthropic](https://www.anthropic.com/news/claude-fable-5-mythos-5) and [OpenAI](https://openai.com/index/gpt-5-6/). + - **GDPval-AA v2, AA-Briefcase, τ³-Banking, Harvey Lab-AA, and APEX-Agents.** Scores are cited from [Artificial Analysis](https://artificialanalysis.ai/) and the [APEX-Agents leaderboard](https://www.mercor.com/apex/apex-agents-leaderboard/) as of July 23, 2026. For Harvey Lab-AA, we report the criterion pass rate. + - **CorpFin v2, Finance Agent v2, and Legal Research Bench.** Scores are cited from [Vals AI](https://www.vals.ai/). + - **Agents' Last Exam.** Scores are cited from the [official leaderboard](https://agents-last-exam.org/leaderboard) as of July 23, 2026; we report the leaderboard's primary pass-rate metric. On the leaderboard, each model is paired with a specific harness: Kimi K3 with Kimi Code; GPT-5.6 Sol and GPT-5.5 with Codex; Claude Fable 5, Claude Opus 4.8, and GLM-5.2 with Claude Code. † The Claude Fable 5 entry runs at xhigh effort with 40% of tasks annotated as downgraded. +4. **Multimodal benchmarks** + - Except for ZeroBench, which follows the official setting and is run five times, all multimodal scores are averaged over three runs. MMMU-Pro is evaluated following the official protocol, preserving the original input order and prepending images to the text input. + - **PerceptionBench** is an in-house benchmark that focuses on atomic visual perception capabilities. + +
+ +## 4. Native MXFP4 Quantization + +Kimi K3 applies quantization-aware training from the SFT stage onward, using MXFP4 weights with MXFP8 activations for broad hardware compatibility. + +## 5. Deployment + +> [!Note] +> You can access Kimi K3's API on https://platform.kimi.ai by selecting `kimi-k3`, and we provide OpenAI/Anthropic-compatible API for you. Currently, Kimi K3 is recommended to run on the following inference engines: + +- [vLLM](https://github.com/vllm-project/vllm) — see [recipes](https://recipes.vllm.ai/moonshotai/Kimi-K3) +- [SGLang](https://github.com/sgl-project/sglang) — see [cookbook](https://docs.sglang.io/cookbook/autoregressive/Moonshotai/Kimi-K3) +- [TokenSpeed](https://github.com/lightseekorg/tokenspeed) — see [recipes](https://lightseek.org/tokenspeed/recipes/models#kimi-k3) + +--- +## 6. Model Usage + +Kimi K3 always has thinking enabled, and will return `reasoning_content`. Thinking effort is configured with the top-level `reasoning_effort` request field, which supports `"low"`, `"high"`, and `"max"` (default `"max"`). + +Kimi K3 was trained in the preserved thinking history mode. For multi-turn conversations and tool calls, Kimi K3 requires the complete assistant message returned by the API to be passed back to `messages` as-is — including `reasoning_content` and `tool_calls`, not just `content`: + +```python +import openai + +def chat_with_preserved_thinking(client: openai.OpenAI, model_name: str): + messages = [ + { + "role": "user", + "content": "Tell me three random numbers." + }, + { + "role": "assistant", + "reasoning_content": "I'll start by listing five numbers: 473, 921, 235, 215, 222, and I'll tell you the first three.", + "content": "473, 921, 235" + }, + { + "role": "user", + "content": "What are the other two numbers you have in mind?" + } + ] + + response = client.chat.completions.create( + model=model_name, + messages=messages, + stream=False, + max_tokens=4096, + reasoning_effort="max", + ) + # the assistant should mention 215 and 222 that appear in the prior reasoning content + print(f"response: {response.choices[0].message.reasoning}") + return response.choices[0].message.content +``` + +For full guides and examples (vision input, structured output, partial mode, tool choice, dynamic tool loading, context caching), see the [Kimi K3 Quickstart](https://platform.kimi.ai/docs/guide/kimi-k3-quickstart) and [Thinking Effort](https://platform.kimi.ai/docs/guide/use-thinking-effort). + +### Coding Agent Framework + +Kimi K3 works best with [Kimi Code CLI](https://www.kimi.com/code) as its agent framework. We warmly invite you to give it a try — run Kimi Code in your terminal and select Kimi K3 using the `/model` command. We hope you enjoy building with Kimi K3, and we would love to hear your feedback! + + +--- + +## 7. License + +Both the code repository and the model weights are released under the [Kimi K3 License](https://huggingface.co/moonshotai/Kimi-K3/blob/main/LICENSE). + +--- + +## 8. Contact Us + +If you have any questions, please reach out at [support@moonshot.ai](mailto:support@moonshot.ai). diff --git a/assets/.gitkeep b/assets/.gitkeep new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/assets/kimi-logo.png b/assets/kimi-logo.png new file mode 100644 index 0000000000000000000000000000000000000000..870b8be6e07cc2c46f7173e800fbaff8af0af5d1 Binary files /dev/null and b/assets/kimi-logo.png differ diff --git a/config.json b/config.json new file mode 100644 index 0000000000000000000000000000000000000000..2d973b916f371d521f7c9ef5cfea664d06336c3c --- /dev/null +++ b/config.json @@ -0,0 +1,474 @@ +{ + "name_or_path": "tclf90/Kimi-K3-Cubic-2.5Bit", + "architectures": [ + "KimiK3ForConditionalGeneration" + ], + "auto_map": { + "AutoConfig": "configuration_kimi_k3.KimiK3Config", + "AutoModel": "modeling_kimi_k3.KimiK3ForConditionalGeneration", + "AutoModelForCausalLM": "modeling_kimi_k3.KimiK3ForConditionalGeneration" + }, + "bos_token_id": 163584, + "dtype": "bfloat16", + "eos_token_id": 163586, + "ignore_index": -100, + "image_placeholder": "<|kimi_image_placeholder|>", + "media_placeholder_token_id": 163605, + "model_type": "kimi_k3", + "pad_token_id": 163839, + "text_config": { + "_name_or_path": "", + "activation_situ_beta": 4.0, + "activation_situ_linear_beta": 25.0, + "add_cross_attention": false, + "architectures": [ + "KimiLinearForCausalLM" + ], + "attn_res_block_size": 12, + "auto_map": { + "AutoConfig": "configuration_kimi_k3.KimiLinearConfig", + "AutoModel": "modeling_kimi_linear.KimiLinearModel", + "AutoModelForCausalLM": "modeling_kimi_linear.KimiLinearForCausalLM" + }, + "bad_words_ids": null, + "begin_suppress_tokens": null, + "bos_token_id": 163584, + "chunk_size_feed_forward": 0, + "cross_attention_hidden_size": null, + "decoder_start_token_id": null, + "diversity_penalty": 0.0, + "do_sample": false, + "dtype": "bfloat16", + "early_stopping": false, + "encoder_no_repeat_ngram_size": 0, + "eos_token_id": 163586, + "exponential_decay_length_penalty": null, + "finetuning_task": null, + "first_k_dense_replace": 1, + "forced_bos_token_id": null, + "forced_eos_token_id": null, + "hidden_act": "situ", + "hidden_size": 7168, + "id2label": { + "0": "LABEL_0", + "1": "LABEL_1" + }, + "initializer_range": 0.02, + "intermediate_size": 33792, + "is_decoder": false, + "is_encoder_decoder": false, + "kv_lora_rank": 512, + "label2id": { + "LABEL_0": 0, + "LABEL_1": 1 + }, + "latent_moe_use_norm": true, + "length_penalty": 1.0, + "linear_attn_config": { + "full_attn_layers": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64, + 68, + 72, + 76, + 80, + 84, + 88, + 92, + 93 + ], + "gate_lower_bound": -5.0, + "head_dim": 128, + "kda_layers": [ + 1, + 2, + 3, + 5, + 6, + 7, + 9, + 10, + 11, + 13, + 14, + 15, + 17, + 18, + 19, + 21, + 22, + 23, + 25, + 26, + 27, + 29, + 30, + 31, + 33, + 34, + 35, + 37, + 38, + 39, + 41, + 42, + 43, + 45, + 46, + 47, + 49, + 50, + 51, + 53, + 54, + 55, + 57, + 58, + 59, + 61, + 62, + 63, + 65, + 66, + 67, + 69, + 70, + 71, + 73, + 74, + 75, + 77, + 78, + 79, + 81, + 82, + 83, + 85, + 86, + 87, + 89, + 90, + 91 + ], + "num_heads": 96, + "short_conv_kernel_size": 4, + "use_full_rank_gate": true + }, + "max_length": 20, + "max_position_embeddings": 1048576, + "min_length": 0, + "mla_use_nope": true, + "mla_use_output_gate": true, + "model_type": "kimi_linear", + "moe_intermediate_size": 3072, + "moe_layer_freq": 1, + "moe_renormalize": true, + "moe_router_activation_func": "sigmoid", + "no_repeat_ngram_size": 0, + "num_attention_heads": 96, + "num_beam_groups": 1, + "num_beams": 1, + "num_expert_group": 1, + "num_experts": 896, + "num_experts_per_token": 16, + "num_hidden_layers": 93, + "num_key_value_heads": 96, + "num_nextn_predict_layers": 0, + "num_return_sequences": 1, + "num_shared_experts": 2, + "output_attentions": false, + "output_hidden_states": false, + "output_scores": false, + "pad_token_id": 163839, + "prefix": null, + "problem_type": null, + "pruned_heads": {}, + "q_lora_rank": 1536, + "qk_nope_head_dim": 128, + "qk_rope_head_dim": 64, + "quantization_config": { + "quant_method": "cubic", + "format": "cubic-pack-quantized", + "quantization_status": "compressed", + "config_groups": { + "moe_layers_1_3": { + "targets": [ + "re:.*\\.layers\\.(?:1|2|3)\\.block_sparse_moe\\.experts" + ], + "input_activations": null, + "output_activations": null, + "weights": { + "num_bits": 3, + "group_size": 256, + "strategy": "group", + "symmetric": true, + "dynamic": false, + "scale_dtype": "torch.float32", + "param_dtype": "torch.float16", + "reserved_code": "zero", + "packing": "little-endian-bitstream" + } + }, + "moe_layers_4_32": { + "targets": [ + "re:.*\\.layers\\.(?:4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)\\.block_sparse_moe\\.experts" + ], + "input_activations": null, + "output_activations": null, + "weights": { + "num_bits": 3, + "group_size": 512, + "strategy": "group", + "symmetric": true, + "dynamic": false, + "scale_dtype": "torch.float32", + "param_dtype": "torch.float16", + "reserved_code": "zero", + "packing": "little-endian-bitstream" + } + }, + "moe_layers_33_91": { + "targets": [ + "re:.*\\.layers\\.(?:33|34|35|36|37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|52|53|54|55|56|57|58|59|60|61|62|63|64|65|66|67|68|69|70|71|72|73|74|75|76|77|78|79|80|81|82|83|84|85|86|87|88|89|90|91)\\.block_sparse_moe\\.experts" + ], + "input_activations": null, + "output_activations": null, + "weights": { + "num_bits": 2, + "group_size": 512, + "strategy": "group", + "symmetric": true, + "dynamic": false, + "scale_dtype": "torch.float32", + "param_dtype": "torch.float16", + "reserved_code": "zero", + "packing": "little-endian-bitstream" + } + }, + "moe_layers_92_92": { + "targets": [ + "re:.*\\.layers\\.(?:92)\\.block_sparse_moe\\.experts" + ], + "input_activations": null, + "output_activations": null, + "weights": { + "num_bits": 4, + "group_size": 512, + "strategy": "group", + "symmetric": true, + "dynamic": false, + "scale_dtype": "torch.float32", + "param_dtype": "torch.float16", + "reserved_code": "zero", + "packing": "little-endian-bitstream" + } + } + }, + "ignore": [ + "re:.*self_attn.*", + "re:.*shared_experts.*", + "re:.*mlp\\.(gate|up|gate_up|down)_proj.*", + "re:.*lm_head.*", + "re:.*vision_tower.*", + "re:.*mm_projector.*" + ], + "runtime_weight_storage": "native_packed_bitstream", + "layer_bit_schedule": [ + { + "start_layer": 1, + "end_layer": 3, + "num_bits": 3, + "group_size": 256 + }, + { + "start_layer": 4, + "end_layer": 32, + "num_bits": 3, + "group_size": 512 + }, + { + "start_layer": 33, + "end_layer": 91, + "num_bits": 2, + "group_size": 512 + }, + { + "start_layer": 92, + "end_layer": 92, + "num_bits": 4, + "group_size": 512 + } + ], + "layer_group_size_overrides": { + "1": 256, + "2": 256, + "3": 256, + "4": 512, + "5": 512, + "6": 512, + "7": 512, + "8": 512, + "9": 512, + "10": 512, + "11": 512, + "12": 512, + "13": 512, + "14": 512, + "15": 512, + "16": 512, + "17": 512, + "18": 512, + "19": 512, + "20": 512, + "21": 512, + "22": 512, + "23": 512, + "24": 512, + "25": 512, + "26": 512, + "27": 512, + "28": 512, + "29": 512, + "30": 512, + "31": 512, + "32": 512, + "33": 512, + "34": 512, + "35": 512, + "36": 512, + "37": 512, + "38": 512, + "39": 512, + "40": 512, + "41": 512, + "42": 512, + "43": 512, + "44": 512, + "45": 512, + "46": 512, + "47": 512, + "48": 512, + "49": 512, + "50": 512, + "51": 512, + "52": 512, + "53": 512, + "54": 512, + "55": 512, + "56": 512, + "57": 512, + "58": 512, + "59": 512, + "60": 512, + "61": 512, + "62": 512, + "63": 512, + "64": 512, + "65": 512, + "66": 512, + "67": 512, + "68": 512, + "69": 512, + "70": 512, + "71": 512, + "72": 512, + "73": 512, + "74": 512, + "75": 512, + "76": 512, + "77": 512, + "78": 512, + "79": 512, + "80": 512, + "81": 512, + "82": 512, + "83": 512, + "84": 512, + "85": 512, + "86": 512, + "87": 512, + "88": 512, + "89": 512, + "90": 512, + "91": 512, + "92": 512 + }, + "tensor_bit_overrides": [], + "expert_payload_bits": 2.369565217391304, + "expert_effective_bits": 2.498641304347826, + "converted_tensor_effective_bits": 2.498641304347826 + }, + "remove_invalid_values": false, + "repetition_penalty": 1.0, + "return_dict": true, + "return_dict_in_generate": false, + "rms_norm_eps": 1e-05, + "routed_expert_hidden_size": 3584, + "routed_scaling_factor": 1.0, + "sep_token_id": null, + "suppress_tokens": null, + "task_specific_params": null, + "temperature": 1.0, + "tf_legacy_loss": false, + "tie_encoder_decoder": false, + "tie_word_embeddings": false, + "tokenizer_class": null, + "top_k": 50, + "top_p": 1.0, + "topk_group": 1, + "topk_method": "noaux_tc", + "torchscript": false, + "transformers_version": "4.56.2", + "typical_p": 1.0, + "use_bfloat16": false, + "use_cache": true, + "use_grouped_topk": true, + "v_head_dim": 128, + "vocab_size": 163840 + }, + "tie_word_embeddings": false, + "vision_config": { + "_attn_implementation": "flash_attention_2", + "activation_func": "gelu_pytorch_tanh", + "attn_bias": false, + "init_pos_emb_height": 64, + "init_pos_emb_time": 4, + "init_pos_emb_width": 64, + "linear_bias": false, + "merge_kernel_size": [ + 2, + 2 + ], + "merge_type": "sd2_tpool", + "mlp_type": "mlp2", + "mm_hidden_size": 1024, + "mm_projector_type": "patchmergerv2", + "norm_type": "rmsnorm", + "patch_embed_proj_bias": false, + "patch_size": 14, + "pos_emb_interpolation_mode": "bilinear", + "pos_emb_type": "divided_fixed", + "projector_hidden_act": "gelu", + "projector_ln_eps": 1e-05, + "qkv_hidden_size": 1536, + "text_hidden_size": 7168, + "vt_hidden_size": 1024, + "vt_intermediate_size": 4096, + "vt_num_attention_heads": 12, + "vt_num_hidden_layers": 27 + } +} diff --git a/configuration.json b/configuration.json new file mode 100644 index 0000000000000000000000000000000000000000..bbeeda1fc14cffa57c7fa531e87265bb80e0ccf0 --- /dev/null +++ b/configuration.json @@ -0,0 +1 @@ +{"framework": "pytorch", "task": "text-generation", "allow_remote": true} \ No newline at end of file diff --git a/configuration_kimi_k3.py b/configuration_kimi_k3.py new file mode 100644 index 0000000000000000000000000000000000000000..b38c4f8fcab1ce295aea236772ea1cba57f978c9 --- /dev/null +++ b/configuration_kimi_k3.py @@ -0,0 +1,285 @@ +from typing import Optional + +from transformers.configuration_utils import PretrainedConfig + + +class KimiLinearConfig(PretrainedConfig): + model_type = "kimi_linear" + keys_to_ignore_at_inference = ["past_key_values"] + + def __init__( + self, + model_type="kimi_linear", + vocab_size=163840, + hidden_size=4096, + head_dim=None, + intermediate_size=11008, + num_hidden_layers=32, + num_attention_heads=32, + num_key_value_heads=None, + hidden_act="silu", + initializer_range=0.02, + rms_norm_eps=1e-6, + use_cache=True, + pad_token_id=0, + bos_token_id=1, + eos_token_id=2, + rope_theta=10000.0, + rope_scaling=None, + tie_word_embeddings=False, + moe_intermediate_size: Optional[int] = None, + moe_renormalize: bool = True, + moe_router_activation_func: str = "sigmoid", + num_experts: Optional[int] = None, + num_experts_per_token: Optional[int] = None, + num_shared_experts: int = 0, + routed_scaling_factor: float = 1.0, + first_k_dense_replace: int = 0, + moe_layer_freq: int = 1, + use_grouped_topk: bool = True, + num_expert_group: int = 1, + topk_group: int = 1, + q_lora_rank: Optional[int] = None, + kv_lora_rank: Optional[int] = None, + qk_nope_head_dim: Optional[int] = None, + qk_rope_head_dim: Optional[int] = None, + v_head_dim: Optional[int] = None, + mla_use_nope: Optional[bool] = False, + mla_use_output_gate: Optional[bool] = False, + num_nextn_predict_layers: int = 0, + linear_attn_config: Optional[dict] = None, + attn_res_block_size: Optional[int] = None, + latent_moe_use_norm: bool = False, + activation_situ_beta: Optional[float] = None, + activation_situ_linear_beta: Optional[float] = None, + max_position_embeddings: int = 4096, + routed_expert_hidden_size: Optional[int] = None, + topk_method: str = "noaux_tc", + **kwargs, + ): + self.model_type = model_type + self.vocab_size = vocab_size + self.hidden_size = hidden_size + self.head_dim = ( + head_dim if head_dim is not None else hidden_size // num_attention_heads + ) + self.intermediate_size = intermediate_size + self.num_hidden_layers = num_hidden_layers + self.num_attention_heads = num_attention_heads + + # for backward compatibility + if num_key_value_heads is None: + num_key_value_heads = num_attention_heads + + self.num_key_value_heads = num_key_value_heads + self.hidden_act = hidden_act + self.initializer_range = initializer_range + self.rms_norm_eps = rms_norm_eps + self.use_cache = use_cache + self.rope_theta = rope_theta + self.rope_scaling = rope_scaling + + self.q_lora_rank = q_lora_rank + self.kv_lora_rank = kv_lora_rank + self.qk_nope_head_dim = qk_nope_head_dim + self.qk_rope_head_dim = qk_rope_head_dim + self.v_head_dim = v_head_dim + self.mla_use_nope = mla_use_nope + self.mla_use_output_gate = mla_use_output_gate + # moe config + self.num_experts = num_experts + self.num_experts_per_token = num_experts_per_token + self.moe_renormalize = moe_renormalize + self.num_shared_experts = num_shared_experts + self.routed_scaling_factor = routed_scaling_factor + self.moe_router_activation_func = moe_router_activation_func + assert self.moe_router_activation_func in ("softmax", "sigmoid") + self.moe_intermediate_size = moe_intermediate_size + self.first_k_dense_replace = first_k_dense_replace + self.moe_layer_freq = moe_layer_freq + self.use_grouped_topk = use_grouped_topk + self.num_expert_group = num_expert_group + self.topk_group = topk_group + self.num_nextn_predict_layers = num_nextn_predict_layers + + self.attn_res_block_size = attn_res_block_size + self.latent_moe_use_norm = latent_moe_use_norm + self.activation_situ_beta = activation_situ_beta + self.activation_situ_linear_beta = activation_situ_linear_beta + self.max_position_embeddings = max_position_embeddings + self.routed_expert_hidden_size = routed_expert_hidden_size + self.topk_method = topk_method + + if linear_attn_config is not None: + assert linear_attn_config["kda_layers"] is not None + assert linear_attn_config["full_attn_layers"] is not None + self.linear_attn_config = linear_attn_config + + super().__init__( + pad_token_id=pad_token_id, + bos_token_id=bos_token_id, + eos_token_id=eos_token_id, + tie_word_embeddings=tie_word_embeddings, + **kwargs, + ) + + @property + def is_mla(self): + return ( + self.q_lora_rank is not None + or self.kv_lora_rank is not None + or self.qk_nope_head_dim is not None + or self.qk_rope_head_dim is not None + or self.v_head_dim is not None + or self.mla_use_nope is True + ) + + @property + def is_moe(self): + return self.num_experts is not None + + @property + def is_linear_attn(self) -> bool: + return not ( + self.linear_attn_config is None + or ( + isinstance(self.linear_attn_config, dict) + and self.linear_attn_config["kda_layers"] is not None + and len(self.linear_attn_config["kda_layers"]) == 0 + ) + ) + + def is_kda_layer(self, layer_idx: int): + return ( + self.linear_attn_config is not None + and (layer_idx + 1) in self.linear_attn_config["kda_layers"] + ) + + +class KimiK3VisionConfig(PretrainedConfig): + + def __init__( + self, + patch_size: int = 14, + init_pos_emb_height: int = 64, + init_pos_emb_width: int = 64, + init_pos_emb_time: int = 4, + pos_emb_type: str = 'divided_fixed', + vt_num_attention_heads: int = 12, + vt_num_hidden_layers: int = 27, + vt_hidden_size: int = 1024, + vt_intermediate_size: int = 4096, + merge_kernel_size: tuple = (2, 2), + merge_type: str = 'sd2_tpool', + _attn_implementation: str = 'flash_attention_2', + # MM Projector parameters + mm_projector_type: str = 'patchmergerv2', + mm_hidden_size: int | None = None, + projector_hidden_act: str = "gelu", + projector_ln_eps: float = 1e-5, + # vision tower parameters + qkv_hidden_size: int = 1536, + norm_type: str = 'rmsnorm', + attn_bias: bool = False, + patch_embed_proj_bias: bool = False, + mlp_type: str = 'mlp2', + linear_bias: bool = False, + activation_func: str = 'gelu_pytorch_tanh', + pos_emb_interpolation_mode: str = 'bilinear', + # Other parameters + ignore_index: int = -100, + media_placeholder_token_id: int = 163605, + pad_token_id: int = 0, + text_hidden_size=7168, + **kwargs): + + self.patch_size = patch_size + self.init_pos_emb_height = init_pos_emb_height + self.init_pos_emb_width = init_pos_emb_width + self.init_pos_emb_time = init_pos_emb_time + self.pos_emb_type = pos_emb_type + self.vt_num_attention_heads = vt_num_attention_heads + self.vt_num_hidden_layers = vt_num_hidden_layers + self.vt_hidden_size = vt_hidden_size + self.vt_intermediate_size = vt_intermediate_size + self.merge_kernel_size = merge_kernel_size + self.merge_type = merge_type + self._attn_implementation = _attn_implementation + + # MM Projector config + self.mm_projector_type = mm_projector_type + self.mm_hidden_size = mm_hidden_size if mm_hidden_size is not None else vt_hidden_size + self.projector_hidden_act = projector_hidden_act + self.projector_ln_eps = projector_ln_eps + self.text_hidden_size = text_hidden_size + + # vision tower parameters + self.qkv_hidden_size = qkv_hidden_size + self.norm_type = norm_type + self.attn_bias = attn_bias + self.patch_embed_proj_bias = patch_embed_proj_bias + self.mlp_type = mlp_type + self.linear_bias = linear_bias + self.activation_func = activation_func + self.pos_emb_interpolation_mode = pos_emb_interpolation_mode + + super().__init__(**kwargs) + + +class KimiK3Config(PretrainedConfig): + """Kimi-K3 model configuration. + + Args: + text_config (dict | KimiLinearConfig): Configuration for the text model. + + Vision Tower Parameters (from MoonViT3dConfig): + patch_size (int): Patch size for vision tower. + init_pos_emb_height (int): Initial position embedding height. + init_pos_emb_width (int): Initial position embedding width. + init_pos_emb_time (int): Initial position embedding time dimension. + pos_emb_type (str): Type of position embedding. + vt_num_attention_heads (int): Number of attention heads in vision tower. + vt_num_hidden_layers (int): Number of hidden layers in vision tower. + vt_hidden_size (int): Hidden size of vision tower. + vt_intermediate_size (int): Intermediate size in vision tower FFN. + merge_kernel_size (tuple): Kernel size for patch merging. + merge_type (str): Type of merge operation. + _attn_implementation (str): Attention implementation type. + + MM Projector Parameters (from MultiModalProjectorConfig): + mm_projector_type (str): Type of multimodal projector. + mm_hidden_size (int): Hidden size from vision tower (should match vt_hidden_size). + projector_hidden_act (str): Activation function for projector. + projector_ln_eps (float): Layer norm epsilon for projector. + + Other Parameters: + ignore_index (int): The ignore index for the loss function. + media_placeholder_token_id (int): The token ID to use for media placeholders. + pad_token_id (int): The token ID to use for padding. + """ + + model_type = "kimi_k3" + + def __init__( + self, + text_config: dict | KimiLinearConfig = None, + vision_config: dict | KimiK3VisionConfig = None, + # Other parameters + ignore_index: int = -100, + media_placeholder_token_id: int = 163605, + pad_token_id: int = 0, + **kwargs, + ): + if isinstance(text_config, dict): + text_config = KimiLinearConfig(**text_config) + if isinstance(vision_config, dict): + vision_config = KimiK3VisionConfig(**vision_config) + self.text_config = text_config + self.vision_config = vision_config + # Other config + self.ignore_index = ignore_index + self.media_placeholder_token_id = media_placeholder_token_id + if getattr(self.text_config, "quantization_config", None) is not None: + self.quantization_config = self.text_config.quantization_config + + super().__init__(pad_token_id=pad_token_id, **kwargs) diff --git a/cubic_quantization_report.json b/cubic_quantization_report.json new file mode 100644 index 0000000000000000000000000000000000000000..42e64d74c96d2070457ab7a5cc04cc1f9eb60e80 --- /dev/null +++ b/cubic_quantization_report.json @@ -0,0 +1,105 @@ +{ + "manifest": { + "source": "moonshotai/Kimi-K3", + "output": "Kimi-K3-Cubic-2.5Bit", + "moe_schedule": "1-3:3@256,4-32:3@512,33-91:2@512,92:4@512", + "linear_schedule": "", + "conversion_hardware": { + "device_type": "cuda", + "device_count": 8 + }, + "shard_size_gib": 3.0, + "a8_carrier_aware": true, + "a8_correction_default": "enabled", + "fitting_objective": "groupwise-least-squares", + "reported_loss": "NRMSE = sqrt(joint SSE / source weight SSE)", + "row_chunk_size": -1, + "source_shards": 96, + "expert_payload_bits": 2.369565217391304, + "expert_effective_bits": 2.498641304347826, + "converted_tensor_effective_bits": 2.498641304347826, + "worker_scheduling": "dynamic_source_shard_queue", + "output_partitioning": "deterministic_source_shard_index", + "script": "quantize_k3.py", + "script_sha256": "89fe8836bb407a027a2663637bc0380bd1adb29ffb2778f0879e606dc8ed31f3", + "source_config_sha256": "9710e121a58d03ac92c8d6da287a19541994319afbbe6d6202af001ffd379213", + "source_index_sha256": "a1c5210650ce71d2d3ae9ec5a101ac4afd3cf4b10091be589853437eb967febd", + "output_shards": 341, + "output_total_bytes": 964943224704, + "combined_report": "cubic_quantization_report.json" + }, + "loss_statistics": { + "objective": "mean(continuous MSE, rounded-A8-carrier MSE)", + "normalization": "loss is sqrt(joint SSE / source weight SSE), i.e. NRMSE; the fitting objective itself remains least squares.", + "metadata_precision": "FP32 scale and FP16 a/b before recomputation", + "by_bit": { + "2": { + "bits": 2, + "loss": 0.4512510057287302, + "clipped_percent": 12.230740958337455, + "a8_correction_loss": 0.4512510057287302 + }, + "3": { + "bits": 3, + "loss": 0.18088323398973324, + "clipped_percent": 2.966870055819044, + "a8_correction_loss": 0.18091672638061443 + }, + "4": { + "bits": 4, + "loss": 0.0430471542191854, + "clipped_percent": 0.5635432713156114, + "a8_correction_loss": 0.04324462046872603 + } + }, + "by_bit_and_group_size": { + "2@512": { + "bits": 2, + "loss": 0.4512510057287302, + "clipped_percent": 12.230740958337455, + "a8_correction_loss": 0.4512510057287302, + "group_size": 512 + }, + "3@256": { + "bits": 3, + "loss": 0.17960835023454785, + "clipped_percent": 2.6970932295353056, + "a8_correction_loss": 0.1795795260456478, + "group_size": 256 + }, + "3@512": { + "bits": 3, + "loss": 0.18100745927884193, + "clipped_percent": 2.994778003365638, + "a8_correction_loss": 0.18104699922459405, + "group_size": 512 + }, + "4@512": { + "bits": 4, + "loss": 0.0430471542191854, + "clipped_percent": 0.5635432713156114, + "a8_correction_loss": 0.04324462046872603, + "group_size": 512 + } + } + }, + "audit": { + "checkpoint": "Kimi-K3-Cubic-2.5Bit", + "shards": 341, + "tensors": 991812, + "total_size": 964943224704, + "max_shard_bytes": 3221225472, + "widths_present": [ + 2, + 3, + 4 + ], + "converted_tensor_effective_bits": 2.498641304347826, + "dtype_counts": { + "BF16": 2122, + "F32": 247802, + "F16": 494592, + "U8": 247296 + } + } +} diff --git a/encoding_k3.py b/encoding_k3.py new file mode 100644 index 0000000000000000000000000000000000000000..44a56b7371fab32513da0eaed6b9a8a7c56499a2 --- /dev/null +++ b/encoding_k3.py @@ -0,0 +1,647 @@ +"""Kimi K3 XTML encoding helpers. + +This module keeps chat rendering in Python. +Callers that need token IDs should consume ``EncodeSegment`` objects directly: +structural markers may be encoded as tiktoken special tokens, while user/tool +text and attribute values are encoded as ordinary text. +""" + +from __future__ import annotations + +import json +from dataclasses import dataclass +from typing import Any, Iterable, Optional + +OPEN_TOKEN = "<|open|>" +CLOSE_TOKEN = "<|close|>" +SEP_TOKEN = "<|sep|>" +END_OF_MSG_TOKEN = "<|end_of_msg|>" +IMAGE_PLACEHOLDER = "<|kimi_image_placeholder|>" + +_VALID_THINKING_EFFORTS = {"low", "high", "max"} + + +@dataclass(frozen=True) +class EncodeSegment: + text: str + allow_special: bool = False + + +class _ImagePromptState: + def __init__(self, image_prompts: Optional[list[str]] = None): + self.image_prompts = image_prompts + self.index = 0 + + def next_prompt(self) -> str: + if self.image_prompts is None: + return IMAGE_PLACEHOLDER + if self.index >= len(self.image_prompts): + raise ValueError("More image placeholders than image prompts.") + prompt = self.image_prompts[self.index] + self.index += 1 + return prompt + + def assert_consumed(self) -> None: + if self.image_prompts is None: + return + if self.index != len(self.image_prompts): + raise ValueError( + f"image prompt count {len(self.image_prompts)} != " + f"consumed placeholder count {self.index}" + ) + + +def _segment(text: Any, *, allow_special: bool = False) -> list[EncodeSegment]: + text = str(text) + if not text: + return [] + return [EncodeSegment(text, allow_special=allow_special)] + + +def _control(text: str) -> list[EncodeSegment]: + return _segment(text, allow_special=True) + + +def _text(text: Any) -> list[EncodeSegment]: + return _segment(text, allow_special=False) + + +def _append_text( + segments: list[EncodeSegment], + text: Any, + image_state: _ImagePromptState, +) -> None: + text = str(text) + if text == "": + return + if image_state.image_prompts is None or IMAGE_PLACEHOLDER not in text: + segments.extend(_text(text)) + return + + parts = text.split(IMAGE_PLACEHOLDER) + for i, part in enumerate(parts): + segments.extend(_text(part)) + if i < len(parts) - 1: + segments.extend(_segment(image_state.next_prompt(), + allow_special=True)) + + +def _escape_attr_value(value: Any) -> str: + return str(value).replace("&", "&").replace('"', """) + + +def _attr(key: str, value: Any) -> list[EncodeSegment]: + return ( + _text(f" {key}") + + _text('="') + + _text(_escape_attr_value(value)) + + _text('"') + ) + + +def _open_tag(tag: str, attrs: Iterable[tuple[str, Any]] = ()) -> list[EncodeSegment]: + segments: list[EncodeSegment] = [] + segments.extend(_control(OPEN_TOKEN)) + segments.extend(_text(tag)) + for key, value in attrs: + segments.extend(_attr(key, value)) + segments.extend(_control(SEP_TOKEN)) + return segments + +def _close_tag(tag: str) -> list[EncodeSegment]: + segments: list[EncodeSegment] = [] + segments.extend(_control(CLOSE_TOKEN)) + segments.extend(_text(tag)) + segments.extend(_control(SEP_TOKEN)) + return segments + + +def _end_of_msg() -> list[EncodeSegment]: + return _control(END_OF_MSG_TOKEN) + + +def _json_compact(value: Any) -> str: + return json.dumps(value, ensure_ascii=False, separators=(",", ":")) + + +def _is_mapping(value: Any) -> bool: + return isinstance(value, dict) + + +def _xtml_type(value: Any) -> str: + if isinstance(value, bool): + return "boolean" + if value is None: + return "null" + if isinstance(value, (int, float)) and not isinstance(value, bool): + return "number" + if isinstance(value, str): + return "string" + if _is_mapping(value): + return "object" + return "array" + + +def _xtml_value(value: Any) -> str: + if isinstance(value, str): + return value + return json.dumps(value, ensure_ascii=False) + + +def _get_value(obj: Any, key: str, default: Any = None) -> Any: + if isinstance(obj, dict): + return obj.get(key, default) + return getattr(obj, key, default) + + +def extract_response_schema(response_format: Any) -> Any: + if response_format is None: + return None + + json_schema = _get_value(response_format, "json_schema") + if json_schema is None: + return None + + if isinstance(json_schema, dict): + return json_schema.get( + "schema", + json_schema.get("json_schema", json_schema), + ) + + schema = _get_value(json_schema, "schema") + if schema is not None: + return schema + + schema = _get_value(json_schema, "json_schema") + if schema is not None: + return schema + + return json_schema + + +def deep_sort_dict(obj: Any) -> Any: + if isinstance(obj, dict): + return {k: deep_sort_dict(v) for k, v in sorted(obj.items())} + if isinstance(obj, list): + return [deep_sort_dict(item) for item in obj] + return obj + + +def normalize_tool_arguments(arguments: Any) -> tuple[dict[str, Any], Optional[str]]: + if arguments is None: + return {}, None + if isinstance(arguments, dict): + return arguments, None + if isinstance(arguments, str): + if not arguments.strip(): + return {}, None + try: + parsed = json.loads(arguments) + except json.JSONDecodeError: + return {}, arguments + if not isinstance(parsed, dict): + raise ValueError("Kimi K3 tool call arguments must be a JSON object.") + return parsed, None + raise TypeError( + "Kimi K3 tool call arguments must be a dict or a JSON object string." + ) + + +def normalize_message(message: Any) -> Any: + if not isinstance(message, dict): + return message + + normalized = dict(message) + + tools = normalized.get("tools") + if tools is not None: + normalized["tools"] = deep_sort_dict(tools) + + tool_calls = normalized.get("tool_calls") + if not tool_calls: + return normalized + + normalized_calls = [] + for tool_call in tool_calls: + if not isinstance(tool_call, dict): + normalized_calls.append(tool_call) + continue + + tc = dict(tool_call) + function = tc.get("function") + if isinstance(function, dict): + fn = dict(function) + arguments, json_block = normalize_tool_arguments(fn.get("arguments")) + fn["arguments"] = arguments + if json_block is None: + fn.pop("_xtml_json_block", None) + else: + fn["_xtml_json_block"] = json_block + tc["function"] = fn + else: + arguments, json_block = normalize_tool_arguments(tc.get("arguments")) + tc["arguments"] = arguments + if json_block is None: + tc.pop("_xtml_json_block", None) + else: + tc["_xtml_json_block"] = json_block + normalized_calls.append(tc) + + normalized["tool_calls"] = normalized_calls + return normalized + + +def normalize_conversation(conversation: Any) -> Any: + if not isinstance(conversation, list): + return conversation + + def normalize_messages(messages: list[Any]) -> list[Any]: + return [normalize_message(message) for message in messages] + + if conversation and isinstance(conversation[0], list): + return [normalize_messages(messages) for messages in conversation] + return normalize_messages(conversation) + + +def _tool_call_id_index(tool_calls: Any) -> dict: + """Map assistant ``tool_calls[].id`` to ``(1-based position, function name)``. + + The position mirrors the chat template's enumeration over ``tool_calls`` + (every entry advances the position, even an id-less one). Duplicate ids keep + their first occurrence. + """ + index: dict = {} + if not isinstance(tool_calls, list): + return index + for position, tool_call in enumerate(tool_calls, start=1): + if not isinstance(tool_call, dict): + continue + call_id = tool_call.get("id") + if call_id is None: + continue + key = str(call_id) + if key in index: + continue + function = tool_call.get("function") + name = ( + function.get("name") if isinstance(function, dict) else tool_call.get("name") + ) + index[key] = (position, name) + return index + + +def normalize_xtml_tool_result_messages(messages: list[Any]) -> list[Any]: + """Re-sort K3 XTML tool results into assistant ``tool_calls`` order. + + Serving frameworks generally deliver tool results already in call order. A + direct Transformers caller, however, may pass OpenAI-style tool messages in any + order, so each run of consecutive tool messages is matched against the most + recent preceding assistant ``tool_calls`` by opaque ``tool_call_id`` == + ``tool_calls[].id`` (K3 drops the ``func:index`` format requirement) and + sorted by the matched 1-based position. The matched call is authoritative, + so each matched message's ``tool`` is set to that call's function name -- + this keeps an explicit (and possibly stale) ``tool``/``name`` from drifting + out of sync with the reordered position. ``index`` is still derived from the + rendered position by the chat template. A run that cannot be fully matched is + left untouched. Re-running is idempotent. + + This function is side-effect free: matched tool messages are shallow-copied + before their ``tool``/``name`` is rewritten, and every other message is + appended to the output as-is. The input list and its message objects are + never mutated. + """ + if not isinstance(messages, list): + return messages + + output: list[Any] = [] + current_index: dict = {} + i = 0 + n = len(messages) + + while i < n: + message = messages[i] + + if isinstance(message, dict) and message.get("role") == "assistant": + tool_calls = message.get("tool_calls") + current_index = _tool_call_id_index(tool_calls) if tool_calls else {} + output.append(message) + i += 1 + continue + + if not isinstance(message, dict) or message.get("role") != "tool": + output.append(message) + i += 1 + continue + + run: list[tuple] = [] # (position, original_offset, message, name) + unresolved = False + offset = 0 + while ( + i < n and isinstance(messages[i], dict) and messages[i].get("role") == "tool" + ): + tool_message = messages[i] + call_id = tool_message.get("tool_call_id", tool_message.get("id")) + matched = current_index.get(str(call_id)) if call_id is not None else None + if matched is None: + unresolved = True + run.append((None, offset, tool_message, None)) + else: + position, name = matched + run.append((position, offset, tool_message, name)) + offset += 1 + i += 1 + + if unresolved: + output.extend(item[2] for item in run) + else: + run.sort(key=lambda item: (item[0], item[1])) + for _, _, tool_message, name in run: + if name is None: + output.append(tool_message) + continue + # The id-matched call is authoritative: align tool (and any + # explicit name) so the rendered XTML tool attribute cannot + # disagree with the reordered position. Copy first so the + # caller's message object is never mutated. + resolved = dict(tool_message) + resolved["tool"] = name + if "name" in resolved: + resolved["name"] = name + output.append(resolved) + + return output + + +def is_batched_conversation(conversation: Any) -> bool: + return ( + isinstance(conversation, list) + and bool(conversation) + and isinstance(conversation[0], list) + ) + + +def _render_content_segments( + content: Any, + image_state: _ImagePromptState, +) -> list[EncodeSegment]: + segments: list[EncodeSegment] = [] + if isinstance(content, str): + _append_text(segments, content, image_state) + elif content is not None: + for part in content: + if part["type"] in ["image", "image_url"]: + segments.extend( + _segment(image_state.next_prompt(), allow_special=True)) + else: + _append_text(segments, part["text"], image_state) + return segments + + +def _internal_system_message(message_type: str, body: str) -> list[EncodeSegment]: + segments: list[EncodeSegment] = [] + segments.extend(_open_tag("message", [("role", "system"), ("type", message_type)])) + segments.extend(_text(body.strip())) + segments.extend(_close_tag("message")) + segments.extend(_end_of_msg()) + return segments + + +def _render_assistant_segments( + message: dict[str, Any], + image_state: _ImagePromptState, + thinking: bool = True, +) -> list[EncodeSegment]: + segments: list[EncodeSegment] = [] + # The channel is structural: in thinking mode every assistant + # message carries the open/close tags even when there is no reasoning + # content to fill in. In non-thinking mode the channel is dropped + # entirely. + if thinking: + reasoning_content = message.get("reasoning_content") or message.get( + "reasoning" + ) + segments.extend(_open_tag("think")) + if reasoning_content is not None and str(reasoning_content).strip(): + _append_text(segments, reasoning_content, image_state) + segments.extend(_close_tag("think")) + + segments.extend(_open_tag("response")) + segments.extend(_render_content_segments(message.get("content"), image_state)) + segments.extend(_close_tag("response")) + + tool_calls = message.get("tool_calls") + if tool_calls: + segments.extend(_open_tag("tools")) + for index, tool_call in enumerate(tool_calls, start=1): + fn = tool_call.get("function", tool_call) + segments.extend( + _open_tag("call", [("tool", fn["name"]), ("index", index)]) + ) + args = fn.get("arguments", {}) + json_block = fn.get("_xtml_json_block") + if json_block is not None: + segments.extend(_open_tag("json", [("type", "object")])) + _append_text(segments, json_block, image_state) + segments.extend(_close_tag("json")) + elif _is_mapping(args): + for key, value in args.items(): + segments.extend( + _open_tag( + "argument", + [("key", key), ("type", _xtml_type(value))], + ) + ) + _append_text(segments, _xtml_value(value), image_state) + segments.extend(_close_tag("argument")) + segments.extend(_close_tag("call")) + segments.extend(_close_tag("tools")) + + return segments + + +def _render_tool_declare(tools: Any, *, dynamic: bool = False) -> list[EncodeSegment]: + if dynamic: + body = ( + "## New Tools Available\n" + "The system dynamically extends the toolset via lazy-loading.\n" + "You have access to all existing and extended tools.\n" + "Here are the specs for the extended tools.\n\n" + "```json\n" + f"{_json_compact(tools)}\n" + "```" + ) + else: + body = ( + "# Tools\n" + "Here are the available tools, described in JSONSchema.\n\n" + "```json\n" + f"{_json_compact(tools)}\n" + "```" + ) + segments: list[EncodeSegment] = [] + segments.extend(_open_tag("message", [("role", "system"), ("type", "tool-declare")])) + segments.extend(_text(body)) + segments.extend(_close_tag("message")) + segments.extend(_end_of_msg()) + return segments + + +def build_chat_segments( + messages: list[Any], + tools: Optional[list[dict]] = None, + *, + add_generation_prompt: bool = True, + thinking: bool = True, + image_prompts: Optional[list[str]] = None, + **kwargs: Any, +) -> list[EncodeSegment]: + # Re-sort tool results by tool_call_id at the lowest layer so every caller + # (processor or direct tokenizer) gets correctly ordered XTML. The helper is + # side-effect free, so the caller's message objects are left untouched. + messages = normalize_xtml_tool_result_messages(messages) + messages = normalize_conversation(messages) + tools = deep_sort_dict(tools) + + kwargs = dict(kwargs) + response_format = kwargs.get("response_format") + if "response_schema" not in kwargs: + response_schema = extract_response_schema(response_format) + if response_schema is not None: + kwargs["response_schema"] = response_schema + if kwargs.get("response_schema") is not None: + kwargs["response_schema"] = deep_sort_dict(kwargs["response_schema"]) + + image_state = _ImagePromptState(image_prompts) + segments: list[EncodeSegment] = [] + + tool_calls = None + tool_index = 0 + + if tools: + segments.extend(_render_tool_declare(tools)) + + thinking_effort = kwargs.get("thinking_effort") + if thinking and thinking_effort is not None: + assert thinking_effort in _VALID_THINKING_EFFORTS, ( + f"Unsupported thinking_effort={thinking_effort!r}; " + f"supported values are {sorted(_VALID_THINKING_EFFORTS)}." + ) + if thinking and thinking_effort in _VALID_THINKING_EFFORTS: + segments.extend( + _internal_system_message( + "thinking-effort", + "`thinking_effort` guides on how much to think in your " + "thinking channel (not including the response channel), " + "supported values include `low`, `medium`, `high`, and `max`.\n" + f"Now the system is invoked with `thinking_effort={thinking_effort}`.", + ) + ) + + for message_index, message in enumerate(messages): + if not isinstance(message, dict): + continue + + role = message["role"] + if role == "user": + attrs = [("role", "user")] + if message.get("name"): + attrs.append(("name", message["name"])) + segments.extend(_open_tag("message", attrs)) + segments.extend(_render_content_segments(message.get("content"), image_state)) + segments.extend(_close_tag("message")) + segments.extend(_end_of_msg()) + elif role == "system" and message.get("tools"): + segments.extend(_render_tool_declare(message["tools"], dynamic=True)) + elif role == "system": + attrs = [("role", "system")] + if message.get("name"): + attrs.append(("name", message["name"])) + segments.extend(_open_tag("message", attrs)) + segments.extend(_render_content_segments(message.get("content"), image_state)) + segments.extend(_close_tag("message")) + segments.extend(_end_of_msg()) + elif role == "tool": + tool_index += 1 + tool_name = message.get("tool", message.get("name")) + if ( + tool_name is None + and tool_calls is not None + and tool_index <= len(tool_calls) + ): + tc = tool_calls[tool_index - 1] + fn = tc.get("function", tc) + tool_name = fn["name"] + if tool_name is None: + raise ValueError( + "Kimi K3 tool messages need a resolvable tool name: " + "carry `tool`/`name`, or match a preceding assistant " + "tool_call by order." + ) + segments.extend( + _open_tag( + "message", + [("role", "tool"), ("tool", tool_name), ("index", tool_index)], + ) + ) + segments.extend(_render_content_segments(message.get("content"), image_state)) + segments.extend(_close_tag("message")) + segments.extend(_end_of_msg()) + elif role == "assistant": + tool_calls = message.get("tool_calls") + tool_index = 0 + attrs = [("role", "assistant")] + if message.get("name"): + attrs.append(("name", message["name"])) + segments.extend(_open_tag("message", attrs)) + segments.extend(_render_assistant_segments(message, image_state, thinking)) + segments.extend(_close_tag("message")) + segments.extend(_end_of_msg()) + + tool_choice = kwargs.get("tool_choice") + if tool_choice == "required": + segments.extend( + _internal_system_message( + "tool-choice", + "The system is invoked with `tool_choice=required`.\n" + "You MUST call tools in the next message.", + ) + ) + elif tool_choice == "none": + segments.extend( + _internal_system_message( + "tool-choice", + "The system is invoked with `tool_choice=none`.\n" + "You MUST NOT call any tools in the next message.", + ) + ) + + rf = kwargs.get("response_format") + rf_type = _get_value(rf, "type", rf) if isinstance(rf, dict) else rf + if rf_type == "json_object": + segments.extend( + _internal_system_message( + "response-format", + "The system is invoked with `response_format=json_object`.\n" + "Your response must be raw JSON data without markdown code " + "blocks (```json) or any additional formatting.", + ) + ) + elif rf_type == "json_schema": + schema = _json_compact(kwargs.get("response_schema")) + segments.extend( + _internal_system_message( + "response-format", + "The system is invoked with `response_format=json_schema`.\n" + "Your response must be raw JSON data without markdown code " + "blocks (```json) or any additional formatting.\n" + "The JSON data must match the following schema:\n" + f"```json\n{schema}\n```", + ) + ) + + if add_generation_prompt: + segments.extend(_open_tag("message", [("role", "assistant")])) + segments.extend(_open_tag("think" if thinking else "response")) + + image_state.assert_consumed() + return segments diff --git a/generation_config.json b/generation_config.json new file mode 100644 index 0000000000000000000000000000000000000000..3908a4a5477122aa4b09386acab760fb7887c0fc --- /dev/null +++ b/generation_config.json @@ -0,0 +1,4 @@ +{ + "max_length": 1048576, + "eos_token_id": 163586 +} \ No newline at end of file diff --git a/kimi_k3_processor.py b/kimi_k3_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..033a5773885c144509788e89a445217b76d6c046 --- /dev/null +++ b/kimi_k3_processor.py @@ -0,0 +1,187 @@ +"""Kimi-K3 processor: wraps vision processor + tokenizer into a single interface. + +Chat rendering (including XTML tool-result ordering) is handled by the +tokenizer's Python encoder; this processor adds multimodal media preprocessing. +""" + +from transformers.feature_extraction_utils import BatchFeature +from transformers.processing_utils import ProcessorMixin +from transformers.utils import logging + +from .media_utils import ensure_media_type + +logger = logging.get_logger(__name__) + +# ── KimiK3Processor ─────────────────────────────────────────────────── + + +class KimiK3Processor(ProcessorMixin): + r""" + Constructs a KimiK3 processor which wraps a KimiK3 image processor + and a tokenizer into a single processor. + + [`KimiK3Processor`] offers all the functionalities of + [`KimiK3VisionProcessor`] and [`TikTokenTokenizer`]. + + Args: + image_processor ([`KimiK3VisionProcessor`], *optional*): + The image processor is a required input. + tokenizer ([`TikTokenTokenizer`], *optional*): + The tokenizer is a required input. + chat_template (`str`, *optional*): Kept for ProcessorMixin + compatibility. Kimi K3 chat encoding is implemented in Python by + the tokenizer. + """ + + attributes = ["image_processor", "tokenizer"] + valid_kwargs = ["chat_template"] + image_processor_class = "AutoImageProcessor" + tokenizer_class = "AutoTokenizer" + + def __init__( + self, + image_processor=None, + tokenizer=None, + chat_template=None, + **kwargs, + ): + super().__init__(image_processor, + tokenizer, + chat_template=chat_template) + self.media_processor = image_processor + self.image_placeholder = "<|kimi_image_placeholder|>" + + # ── Media preprocessing ──────────────────────────────────────────── + + def update_raw_text(self, text: str, image_prompts: list[str]) -> str: + # Replace image placeholders + image_count = text.count(self.image_placeholder) + if image_count > 0: + assert image_count == len(image_prompts), ( + f"image placeholder count {image_count} != " + f"image_prompts count {len(image_prompts)}") + text_parts = text.split(self.image_placeholder) + assert len(text_parts) == len(image_prompts) + 1 + text = "".join([ + text_parts[i] + image_prompts[i] + for i in range(len(image_prompts)) + ]) + text += text_parts[-1] + + return text + + def preprocess_medias(self, + medias: list[dict]) -> tuple[list[dict], list[str]]: + """Process media items and generate corresponding prompts. + + Returns: + A tuple of (updated_medias, image_prompts). + """ + updated_medias = [] + image_prompts = [] + for media in medias: + if media['type'] == 'image': + updated_medias.append(media) + img = ensure_media_type( + media, + transparent_bg_config=self.media_processor. + _transparent_bg_config, + transparent_bg_fill_stage=self.media_processor. + _transparent_bg_fill_stage, + )['image'] + w, h = img.size + image_prompts.append( + self.media_processor.make_image_prompt(w, h)) + else: + raise ValueError(f"unsupported media type: {media['type']}") + return updated_medias, image_prompts + + # ── Main entry points ────────────────────────────────────────────── + + def __call__(self, + messages: list[dict] = None, + medias: list[dict] = None, + text: str = None, + return_tensors: str = "pt", + **kwargs) -> BatchFeature: + """ + Process multimodal inputs for Kimi-K3 model. + + Args: + messages: List of message dicts with 'role' and 'content' fields. + If provided, medias and text will be extracted automatically. + medias: Pre-extracted list of media dicts. + text: Pre-formatted text string. + return_tensors: Format of returned tensors. Default: 'pt'. + **kwargs: Additional arguments passed to apply_chat_template. + + Returns: + BatchFeature with fields: input_ids, attention_mask, + pixel_values, grid_thws. + """ + if messages is None and (medias is None or text is None): + raise ValueError( + "Provide either 'messages' or both 'medias' and 'text'") + + if medias is not None and text is not None: + updated_medias, image_prompts = (self.preprocess_medias(medias)) + preprocessed = self.media_processor.preprocess( + updated_medias, return_tensors=return_tensors) + text = self.update_raw_text(text, image_prompts) + text_inputs = self.tokenizer(text, return_tensors=return_tensors) + return BatchFeature(data={**text_inputs, **preprocessed.data}) + + if medias is None: + medias = self._extract_medias_from_messages(messages) + updated_medias, image_prompts = (self.preprocess_medias(medias)) + preprocessed = self.media_processor.preprocess( + updated_medias, return_tensors=return_tensors) + + if text is None: + text_inputs = self.tokenizer.apply_chat_template( + messages, + tokenize=True, + return_tensors=return_tensors, + return_dict=True, + image_prompts=image_prompts, + **kwargs) + return BatchFeature(data={**text_inputs, **preprocessed.data}) + + text = self.update_raw_text(text, image_prompts) + text_inputs = self.tokenizer(text, return_tensors=return_tensors) + return BatchFeature(data={**text_inputs, **preprocessed.data}) + + @staticmethod + def _extract_medias_from_messages(messages: list[dict]) -> list[dict]: + """Extract media items from messages in a single pass.""" + medias = [] + for msg in messages: + if msg['role'] != 'user' or not msg.get('content'): + continue + + for content_part in msg['content']: + if not isinstance(content_part, dict): + continue + + content_type = content_part.get('type') + if content_type in ['image_url', 'image']: + image_data = content_part.get(content_type) + assert image_data is not None, f"image data is missing for content part: {content_part}" + medias.append({ + 'type': 'image', + 'image': image_data, + }) + return medias + + def apply_chat_template(self, messages, **kwargs): + return self.tokenizer.apply_chat_template(messages, **kwargs) + + def batch_decode(self, *args, **kwargs): + return self.tokenizer.batch_decode(*args, **kwargs) + + def decode(self, *args, **kwargs): + return self.tokenizer.decode(*args, **kwargs) + + @property + def model_input_names(self): + return ['input_ids', 'attention_mask', 'pixel_values', 'grid_thws'] diff --git a/kimi_k3_vision_processing.py b/kimi_k3_vision_processing.py new file mode 100644 index 0000000000000000000000000000000000000000..58154424ff951289570c8fb5578e7372bfbfaa8b --- /dev/null +++ b/kimi_k3_vision_processing.py @@ -0,0 +1,179 @@ +"""Image processor class for Kimi-K3. +""" + +import json +from typing import Any, Dict, Optional, Union + +import numpy as np +import torch +from PIL import Image +from transformers.image_processing_utils import (BaseImageProcessor, + BatchFeature) +from transformers.utils import TensorType + +from .media_utils import (MediaInput, TransparentBgConfig, _to_tensor, + ensure_media_type, image_to_np, navit_patchify, + navit_resize_image, normalize) + + +class KimiK3VisionProcessor(BaseImageProcessor): + model_type = "kimi_k3" + + def __init__( + self, + media_proc_cfg: dict, + **kwargs, + ): + super().__init__(**kwargs) + self.media_proc_cfg = media_proc_cfg + + @property + def _transparent_bg_config(self) -> Optional[TransparentBgConfig]: + cfg = self.media_proc_cfg.get("transparent_bg_config") + if cfg is None: + return None + if isinstance(cfg, TransparentBgConfig): + return cfg + return TransparentBgConfig(**cfg) + + @property + def _transparent_bg_fill_stage(self) -> str: + return self.media_proc_cfg.get("transparent_bg_fill_stage", + "before_resize") + + def media_tokens_calculator(self, media: MediaInput): + media = ensure_media_type( + media, + transparent_bg_config=self._transparent_bg_config, + transparent_bg_fill_stage=self._transparent_bg_fill_stage, + ) + ret = self.get_resize_config(media) + return ret['num_tokens'] + + @classmethod + def make_image_prompt(cls, width: int, height: int) -> str: + """Build the K3 image placeholder with resolution info.""" + return (f"<|media_begin|>image {width}x{height}" + f"<|media_content|><|media_pad|><|media_end|>") + + def get_resize_config(self, media_input: MediaInput) -> dict: + if media_input['type'] == 'image': + w, h = media_input['image'].size + ret = navit_resize_image( + w, h, self.media_proc_cfg['patch_size'], + self.media_proc_cfg['merge_kernel_size'], + self.media_proc_cfg['in_patch_limit'], + self.media_proc_cfg['patch_limit_on_one_side'], + self.media_proc_cfg['fixed_output_tokens']) + return ret + else: + raise ValueError("Unsupported type: {}".format( + media_input['type'])) + + def resize_image(self, image: Image.Image, new_width: int, new_height: int, + pad_width: int, pad_height: int) -> np.ndarray: + image_np = image_to_np( + image, + (new_width, new_height), + "resize", + transparent_bg_config=self._transparent_bg_config, + transparent_bg_fill_stage=self._transparent_bg_fill_stage, + ) + image_np = np.pad( + image_np, + ((0, pad_height), (0, pad_width), (0, 0)), + mode="constant", + constant_values=0, + ) + return image_np + + def preprocess( + self, + medias: list[MediaInput], + return_tensors: Optional[Union[str, TensorType]] = None, + ) -> BatchFeature: + """ + Preprocess a atom vision input (images) into model-ready tensors. + + Args: + medias: List of MediaInput. + return_tensors: Desired output format ('pt', 'np', 'tf', or None). + + Returns: + BatchFeature containing 'pixel_values' and 'grid_thws' tensors. + """ + if not isinstance(medias, list): + medias = [medias] + if medias: + pixel_values = [] + for item in medias: + item = ensure_media_type( + item, + transparent_bg_config=self._transparent_bg_config, + transparent_bg_fill_stage=self._transparent_bg_fill_stage, + ) + resize_config = self.get_resize_config(item) + new_width, new_height, pad_width, pad_height = resize_config[ + 'new_width'], resize_config['new_height'], resize_config[ + 'pad_width'], resize_config['pad_height'] + if item['type'] == 'image': + image = item['image'] + image_np = self.resize_image(image, new_width, new_height, + pad_width, pad_height) + pixel_values.append(np.expand_dims(image_np, axis=0)) + else: + raise ValueError("Unsupported type: {}".format( + item['type'])) + normalized_pixel_values = [] + image_std_inv = 1.0 / np.array(self.media_proc_cfg['image_std']) + image_mean = np.array(self.media_proc_cfg['image_mean']) + for pixels in pixel_values: + pixels = normalize(pixels, image_mean, image_std_inv) + pixels_and_thw = navit_patchify( + pixels, + self.media_proc_cfg['patch_size'], + ) + normalized_pixel_values.append(pixels_and_thw) + + pixel_values = torch.cat([ + _to_tensor(pixel_value['pixel_values']) + for pixel_value in normalized_pixel_values + ]) + grid_thws = torch.cat([ + _to_tensor(pixel_value['grid_thw'], + dtype=torch.int64).unsqueeze(0) + for pixel_value in normalized_pixel_values + ]) + + data = { + 'pixel_values': pixel_values, + 'grid_thws': grid_thws, + } + + else: + data = {} + + return BatchFeature(data=data, tensor_type=return_tensors) + + def __repr__(self): + return f"KimiK3VisionProcessor(media_proc_cfg={self.media_proc_cfg})" + + def to_dict(self) -> Dict[str, Any]: + output = super().to_dict() + output["media_proc_cfg"] = self.media_proc_cfg + if "media_processor" in output: + del output["media_processor"] + return output + + @classmethod + def from_dict(cls, config_dict: Dict[str, Any], **kwargs): + config = config_dict.copy() + media_proc_cfg = config.pop("media_proc_cfg", {}) + return cls(media_proc_cfg=media_proc_cfg, **config, **kwargs) + + def to_json_string(self): + dictionary = self.to_dict() + for key, value in dictionary.items(): + if hasattr(value, 'tolist'): + dictionary[key] = value.tolist() + return json.dumps(dictionary, indent=2, sort_keys=True) + "\n" diff --git a/media_utils.py b/media_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e8b2ae127e254e364e6b568b1093a7e12ac576e0 --- /dev/null +++ b/media_utils.py @@ -0,0 +1,376 @@ +import base64 +import functools +import io +import math +from dataclasses import dataclass +from typing import Literal, TypedDict + +import numpy as np +from PIL import Image + + +class ImageInput(TypedDict): + type: Literal['image'] + image: Image.Image + + +MediaInput = ImageInput + + +@dataclass +class TransparentBgConfig: + """The config of the transparent background.""" + + pattern: Literal["white", "black", "gray", "chessboard"] = "black" + """The pattern of the transparent background.""" + + chessboard_square_size: int = 16 + """The size of the squares in the chessboard background.""" + + chessboard_square_on_top_left: bool = True + """Whether to start the chessboard with a white square on the top left.""" + + chessboard_white_value: int = 255 + """The value of the white pixels in the background.""" + + chessboard_gray_value: int = 200 + """The value of the gray pixels in the background.""" + + +@functools.lru_cache(maxsize=256) +def _create_chessboard_background( + height: int, + width: int, + square_size: int, + square_on_top_left: bool, + white_value: int, + gray_value: int, +) -> np.ndarray: + """Create a chessboard background.""" + bg = np.ones((height, width, 3), dtype=np.uint8) * white_value + for y in range(0, height, square_size): + for x in range(0, width, square_size): + if (y // square_size + x // square_size) % 2 == ( + 1 if square_on_top_left else 0): + bg[y:y + square_size, x:x + square_size] = gray_value + return bg + + +def fill_transparent_bg_with( + image: Image.Image, + transparent_bg_config: TransparentBgConfig | None = None, +) -> Image.Image: + """Composite a (possibly) transparent image onto a configured background. + + When ``transparent_bg_config`` is ``None``, the image is simply converted + to RGB (preserving the historical behavior). Otherwise the alpha channel + is alpha-composited over a background generated according to the config. + """ + if transparent_bg_config is None: + return image.convert("RGB") + + if image.mode == "RGB": + return image + + has_alpha = "A" in image.getbands() or "transparency" in image.info + if not has_alpha: + return image.convert("RGB") + + img = np.array(image.convert("RGBA")) + height, width = img.shape[:2] + bg_pattern = transparent_bg_config.pattern + if bg_pattern == "white": + bg = np.full((height, width, 3), 255, dtype=np.uint8) + elif bg_pattern == "black": + bg = np.zeros((height, width, 3), dtype=np.uint8) + elif bg_pattern == "gray": + bg = np.full((height, width, 3), 128, dtype=np.uint8) + elif bg_pattern == "chessboard": + bg = _create_chessboard_background( + height, + width, + transparent_bg_config.chessboard_square_size, + transparent_bg_config.chessboard_square_on_top_left, + transparent_bg_config.chessboard_white_value, + transparent_bg_config.chessboard_gray_value, + ) + else: + raise ValueError(f"Invalid background pattern: {bg_pattern}") + + alpha = img[:, :, 3] + img_rgb = img[:, :, :3] + alpha_normalized = alpha.astype(np.float32) / 255.0 + alpha_3d = np.stack([alpha_normalized] * 3, axis=2) + result = alpha_3d * img_rgb + (1 - alpha_3d) * bg + result = result.astype(np.uint8) + return Image.fromarray(result) + + +def navit_resize_image( + width: int, + height: int, + patch_size: int, + merge_kernel_size: int, + in_patch_limit: int, + patch_limit_on_one_side: int, + fixed_output_tokens: int | None, +): + # Apply the patch limits. + s1 = math.sqrt( + in_patch_limit / + (max(1.0, width // patch_size) * max(1.0, height // patch_size))) + s2 = patch_limit_on_one_side * patch_size / width + s3 = patch_limit_on_one_side * patch_size / height + scale = min(1.0, s1, s2, s3) + new_w, new_h = max(1, int(width * scale)), max(1, int(height * scale)) + new_w = min(new_w, patch_limit_on_one_side * patch_size) + new_h = min(new_h, patch_limit_on_one_side * patch_size) + + # Calculate the padding to make the height and width divisible by the merge kernel size and patch size. + factor = merge_kernel_size * patch_size + + pad_height = (factor - new_h % factor) % factor + pad_width = (factor - new_w % factor) % factor + + if fixed_output_tokens is not None: + num_tokens = fixed_output_tokens + else: + # Calculate new dimensions after padding and patching + token_height = (new_h + pad_height) // factor + token_width = (new_w + pad_width) // factor + + assert token_height * merge_kernel_size <= patch_limit_on_one_side, ( + f"token_height {token_height} * merge_kernel_size {merge_kernel_size} > patch_limit_on_one_side {patch_limit_on_one_side}" + ) + assert token_width * merge_kernel_size <= patch_limit_on_one_side, ( + f"token_width {token_width} * merge_kernel_size {merge_kernel_size} > patch_limit_on_one_side {patch_limit_on_one_side}" + ) + + num_tokens = token_height * token_width + return { + "num_tokens": num_tokens, + "new_width": new_w, + "new_height": new_h, + "pad_width": pad_width, + "pad_height": pad_height, + "sampled_nframes": 1, + } + + +def _to_pil( + data: str | bytes | Image.Image, + transparent_bg_config: TransparentBgConfig | None = None, + to_rgb: bool = True, +) -> Image.Image: + """Load an image and (optionally) composite its transparent background. + + Args: + data: A PIL Image, a base64 ``data:`` URL, a file path, or raw bytes. + transparent_bg_config: The config used to fill the transparent + background. ``None`` keeps the historical behavior of converting + to RGB without compositing. + to_rgb: If ``False`` the image is returned as-is (the + ``transparent_bg_config`` is ignored). The caller is then + expected to call :func:`fill_transparent_bg_with` later — e.g. + after a resize. + """ + if isinstance(data, Image.Image): + image = data + elif isinstance(data, str): + if data.startswith("data:"): + raw_base64 = data.split(",")[1] + image = Image.open(io.BytesIO(base64.b64decode(raw_base64))) + else: + image = Image.open(data) + elif isinstance(data, bytes): + image = Image.open(io.BytesIO(data)) + else: + raise ValueError(f"Unsupported data type: {type(data)}") + + if not to_rgb: + return image + + return fill_transparent_bg_with(image, transparent_bg_config) + + +def ensure_media_type( + media: MediaInput, + transparent_bg_config: TransparentBgConfig | None = None, + transparent_bg_fill_stage: Literal["before_resize", + "after_resize"] = "before_resize", +) -> MediaInput: + if media['type'] == 'image': + media['image'] = _to_pil( + media['image'], + transparent_bg_config=transparent_bg_config, + to_rgb=transparent_bg_fill_stage == "before_resize", + ) + return media + else: + raise ValueError(f"Unsupported media type: {media['type']}") + + +def image_to_np( + image: Image.Image, + resize_to: tuple[int, int] | None = None, + mode: str = "resize", + raise_error_for_ill_resize: bool = True, + transparent_bg_config: TransparentBgConfig | None = None, + transparent_bg_fill_stage: Literal["before_resize", + "after_resize"] = "before_resize", +) -> np.ndarray: + """Convert an image to a numpy array. + + Args: + content: The image to convert. + resize_to: The size to resize the image to. + mode: The mode to resize the image to. + raise_error_for_ill_resize: Whether to raise an error for ill-sized resize. + transparent_bg_config: The config of the transparent background. Only + used when ``transparent_bg_fill_stage == "after_resize"`` (the + caller is responsible for filling before resize otherwise). + transparent_bg_fill_stage: When to composite the transparent + background — before or after the resize step. + + Returns: + A numpy array. + """ + assert isinstance(image, Image.Image), "image must be a PIL Image" + if resize_to is not None: + if mode == "resize": + image = image.resize(resize_to, resample=Image.Resampling.BICUBIC) + if transparent_bg_fill_stage == "after_resize": + image = fill_transparent_bg_with(image, transparent_bg_config) + + elif mode == "rescale_and_pad_to_center": + scale = min(resize_to[0] / image.width, + resize_to[1] / image.height, 1.0) + new_width = round(image.width * scale) + new_height = round(image.height * scale) + if new_width == 0 or new_height == 0: + if raise_error_for_ill_resize: + raise ValueError( + f"Invalid resize to: {resize_to}, from image size: {image.size}" + ) + else: + return np.zeros((resize_to[1], resize_to[0], 3), + dtype=np.uint8) + + image = image.resize((new_width, new_height), + resample=Image.Resampling.BICUBIC) + if transparent_bg_fill_stage == "after_resize": + image = fill_transparent_bg_with(image, transparent_bg_config) + padding_left = (resize_to[0] - new_width) // 2 + padding_right = resize_to[0] - new_width - padding_left + padding_top = (resize_to[1] - new_height) // 2 + padding_bottom = resize_to[1] - new_height - padding_top + image = np.asarray(image) + image = np.pad( + image, + ((padding_top, padding_bottom), (padding_left, padding_right), + (0, 0)), + mode="constant", + constant_values=0, + ) + assert image.shape == (resize_to[1], resize_to[0], 3) + + elif mode == "rescale_and_pad_to_rightbottom": + scale = min(resize_to[0] / image.width, + resize_to[1] / image.height, 1.0) + new_width = round(image.width * scale) + new_height = round(image.height * scale) + if new_width == 0 or new_height == 0: + if raise_error_for_ill_resize: + raise ValueError( + f"Invalid resize to: {resize_to}, from image size: {image.size}" + ) + else: + return np.zeros((resize_to[1], resize_to[0], 3), + dtype=np.uint8) + + image = image.resize((new_width, new_height), + resample=Image.Resampling.BICUBIC) + if transparent_bg_fill_stage == "after_resize": + image = fill_transparent_bg_with(image, transparent_bg_config) + padding_right = resize_to[0] - new_width + padding_bottom = resize_to[1] - new_height + image = np.asarray(image) + image = np.pad( + image, + ((0, padding_bottom), (0, padding_right), (0, 0)), + mode="constant", + constant_values=0, + ) + assert image.shape == (resize_to[1], resize_to[0], 3) + + else: + raise ValueError(f"Invalid mode: {mode}") + + if isinstance(image, Image.Image): + return np.asarray(image) + else: + return image + + +def navit_patchify(pixel_values: np.ndarray, + patch_size: int) -> dict[str, np.ndarray]: + """Reshape the pixel values to a navit shape. + + Args: + pixel_values: np.ndarray, shape (t, h, w, c) + patch_size: int + + Returns: + dict[str, np.ndarray] + - patches: np.ndarray, shape (t * h//patch_size * w//patch_size, c, patch_size, patch_size) + - grid_thw: np.ndarray, (t, h//patch_size, w//patch_size) + """ + T, H, W, C = pixel_values.shape + assert C == 3, "pixel_values must have 3 channels" + + patches = pixel_values.reshape(T, H // patch_size, patch_size, + W // patch_size, patch_size, C) + # (T, H//patch_size, W//patch_size, C, patch_size, patch_size) + patches = patches.transpose(0, 1, 3, 5, 2, 4) + patches = patches.reshape(-1, C, patch_size, patch_size) + grid_thw = np.array([T, H // patch_size, W // patch_size]) + return {"pixel_values": patches, "grid_thw": grid_thw} + + +def normalize(x: np.ndarray, + mean, + std_inv, + pixels_dtype: np.dtype = np.float32) -> np.ndarray: + """Normalize the image. + + Args: + x: The image to normalize. The shape is (..., 3). The dtype is uint8. The range is [0, 255]. + mean: The mean of the image. + std_inv: The inverse of the std of the image. + pixels_dtype: The dtype of the image. + Returns: + The normalized image. The shape is (..., 3). The dtype is determined by the pixels_dtype. + """ + x = (x / 255.0).astype(pixels_dtype) + x -= mean + x *= std_inv + return x + + +def _to_tensor(data, **kwargs): + import torch + + if isinstance(data, np.ndarray): + return torch.from_numpy(data).to(**kwargs) + elif isinstance(data, torch.Tensor): + return data.to(**kwargs) + elif isinstance(data, list): + return [_to_tensor(item, **kwargs) for item in data] + elif isinstance(data, tuple): + return tuple(_to_tensor(item, **kwargs) for item in data) + elif isinstance(data, dict): + return {k: _to_tensor(v, **kwargs) for k, v in data.items()} + elif data is None: + return None + else: + raise ValueError(f"Unsupported data type: {type(data)}") diff --git a/model-00001-of-00341.safetensors b/model-00001-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..fb73b5d245e724c978fbef56a653c3b44a9e2b83 --- /dev/null +++ b/model-00001-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:975584c00f85a95fce8ae0f840af8cef69c2ef4db00d34cab3e2cbdfc60f6e51 +size 2341216112 diff --git a/model-00002-of-00341.safetensors b/model-00002-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5e439bfabe1991de1038c65145d1077eca5b878c --- /dev/null +++ b/model-00002-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cfe50df5e9fdee2de430ea4bf9ad3cdd63169ac0029dd75d8818036b4578aef2 +size 3151058336 diff --git a/model-00003-of-00341.safetensors b/model-00003-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0b9fcf029505c0f108a02df92a34fa06114d6f49 --- /dev/null +++ b/model-00003-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac64941b38413878b41ecebc3acb9c6a718a213fa634cf18f0ed879b7ece01aa +size 3153759128 diff --git a/model-00004-of-00341.safetensors b/model-00004-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9ee51d392e13158e8252b9767bca662eb7dc81c8 --- /dev/null +++ b/model-00004-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a22f9a29d2d56c78d6f755f217636bb1333c58f871046e63e8616ed846b13327 +size 3153759056 diff --git a/model-00005-of-00341.safetensors b/model-00005-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cf39a4c1d5de0b9cbbfc951ff6313e9e60b46725 --- /dev/null +++ b/model-00005-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8baa9080692d3d44334538bca18dea6f52c320a1341b235b22b1d1edad7e1cb7 +size 3153759152 diff --git a/model-00006-of-00341.safetensors b/model-00006-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e68a5c5d059dbaac71fb1372c89241b719d576a4 --- /dev/null +++ b/model-00006-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d80191fa2c6cf2454322ee8630116f96c6b567adb0bb769cc6172892c99c94c1 +size 679958376 diff --git a/model-00007-of-00341.safetensors b/model-00007-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8abf8879d5d7bb79465bde919bbd170adb8ef8da --- /dev/null +++ b/model-00007-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6e103684ff6e4d1178ded2b71dfdc20312861e4685e63f9acc16cd0e6cd6719 +size 3151058336 diff --git a/model-00008-of-00341.safetensors b/model-00008-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1279926ecb6cf520c73b1b7dfddc9e3767246b0d --- /dev/null +++ b/model-00008-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8d3f7cfcf3c9f00eeb0d5dc193074e2a610a4b569b0ae46bce3a54bd3e88524b +size 3153759128 diff --git a/model-00009-of-00341.safetensors b/model-00009-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e98ab6917a8a114fda58293ccdb9cd888f7d3f4c --- /dev/null +++ b/model-00009-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8522c1de1948c2ce29649b53a0951dc675d56d31c0f681b7773f37ceaf960e0 +size 3153759056 diff --git a/model-00010-of-00341.safetensors b/model-00010-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..2711c2adf9e94a28fb011f2596766cada919d44e --- /dev/null +++ b/model-00010-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99bf54e2ecc22b1b41e0fea66381dfdc8c0d02dcd596f54ba80dd15f10373574 +size 3153759152 diff --git a/model-00011-of-00341.safetensors b/model-00011-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..59f9c5f4cbc76790a2116afa6d7e5674c009df62 --- /dev/null +++ b/model-00011-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ffd9ebe10ba0a3f4562e0d638b066e7a10e7d173216b58d4947540bb60f0ae6a +size 679958376 diff --git a/model-00012-of-00341.safetensors b/model-00012-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b9520dda33644831ed33342a6f4fd3fc54b8a924 --- /dev/null +++ b/model-00012-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8413527f55d82fcf7e30bb177da204f21ecb1b689f839f97d5c13c820cd434b3 +size 3152622456 diff --git a/model-00013-of-00341.safetensors b/model-00013-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f3362f91bb1c55ac2de37815d5a70c9c6f3dacb4 --- /dev/null +++ b/model-00013-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f29cf052b91e36a8e8bdac32070133f6f7e5df0a00f4b7312b6650b3e27bcb4f +size 3153759152 diff --git a/model-00014-of-00341.safetensors b/model-00014-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a7f6053ded782bfdcdd4d42ba751309df06e23fa --- /dev/null +++ b/model-00014-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b5861fedd81471f61f839982d7495295d236d9d94a5ad4d4642737d5af2ad38 +size 3153759048 diff --git a/model-00015-of-00341.safetensors b/model-00015-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c24fbc23a6d82f907e409562445ec68ac83a588e --- /dev/null +++ b/model-00015-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f71f4313344cb85587c8a9cd37215337335ce573b1c5aa0ff43fc828d605119e +size 3153759144 diff --git a/model-00016-of-00341.safetensors b/model-00016-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..87b2b4c187fa12a3b8c617376b4ca666943e6d99 --- /dev/null +++ b/model-00016-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:801545ceacf2ce9d5ff64625fe2492bdd6e0036208698865731b60ecfb6ad094 +size 254984256 diff --git a/model-00017-of-00341.safetensors b/model-00017-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..75ec072aee09fa25bb36c04abb8cd96b1caef665 --- /dev/null +++ b/model-00017-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:081f9c751f571001731b035fe48c23a402f8325307baa6f6b6957d9ff11cd062 +size 3151755048 diff --git a/model-00018-of-00341.safetensors b/model-00018-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..be522d427fb70fd673c4c7f5f52b2ff8d937a9a9 --- /dev/null +++ b/model-00018-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:22c53dc65484ccb86fed3a5521143b80a0560663ef493576f2920890c800c0d4 +size 3152911016 diff --git a/model-00019-of-00341.safetensors b/model-00019-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..827586231bda3e3658737c3198db546a522d033c --- /dev/null +++ b/model-00019-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:030b02bdfc6dd1746eb60ae1e63557154b979ed00f316f558869c672f91785d9 +size 3152910944 diff --git a/model-00020-of-00341.safetensors b/model-00020-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..dd964727b50aee03de26db13e885be5cf1239404 --- /dev/null +++ b/model-00020-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:368ed37924eee1914a33ab16e36fb4785e13a7bcf939decae5eb2f5627cafeb7 +size 3152911024 diff --git a/model-00021-of-00341.safetensors b/model-00021-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..47bc202232c0d7d207ae2c2f110c135343ad0562 --- /dev/null +++ b/model-00021-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fb5f522482fe0a2aa619e41f0db09420b001f02bdc106d9bd6dc9e72c1c7861 +size 219369792 diff --git a/model-00022-of-00341.safetensors b/model-00022-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b90677a4f9382f894eab3bfc337890fac405b3b2 --- /dev/null +++ b/model-00022-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9dcf4930e2d1e3c3ab8a082f2cdcff42c9f9d99a341173a01ab030821de8aa3f +size 3151755048 diff --git a/model-00023-of-00341.safetensors b/model-00023-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..641bdc9b67f44adb3cc1ab779f86ed5db242cc88 --- /dev/null +++ b/model-00023-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d87a41a0cce02553fce05cc1a2c32c9cdfccd5f949885c59deecaedd0d889798 +size 3152911016 diff --git a/model-00024-of-00341.safetensors b/model-00024-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..63673a4296e701ee5ef69be06326a1322cf3f61d --- /dev/null +++ b/model-00024-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:accf303ca172e242ff7ede846f676cf9ae7319c50595319bda56146c29efd6d4 +size 3152910944 diff --git a/model-00025-of-00341.safetensors b/model-00025-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3175e7d0e14daca2eebaf7ee43ddee9273891e2e --- /dev/null +++ b/model-00025-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77b73a697c99923a2c283c9866c73baa461340fa60a01a87374353b13cc57d58 +size 3152911024 diff --git a/model-00026-of-00341.safetensors b/model-00026-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c03063a357c0d917bea6e5a807531380e0c8d2aa --- /dev/null +++ b/model-00026-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:690f46759192f6fe514bc611f5a81622454a7a405721cbf21ee92ee6a3670ae7 +size 219369792 diff --git a/model-00027-of-00341.safetensors b/model-00027-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9f7710720bf6cdaf34896ee774c7db2060cfe2b1 --- /dev/null +++ b/model-00027-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:af62e96a0d7a2ba6830eacf30c2bc8a336c70aa8123e83fc9c02f516fbc53ddd +size 3151755048 diff --git a/model-00028-of-00341.safetensors b/model-00028-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..389ea5c98fb2f740c4a207276b7ea3aacf0b35bd --- /dev/null +++ b/model-00028-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84227790656ceb92b4234d375b143017015e9452e9b121f667348e1e8c57bf4c +size 3152911016 diff --git a/model-00029-of-00341.safetensors b/model-00029-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..54038c4ccee7f99b8cf55da543e912704c9482fc --- /dev/null +++ b/model-00029-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d556f70e73be466be23ba2dea39078769849bc4141bb5f75b40a455e8a728c8f +size 3152910944 diff --git a/model-00030-of-00341.safetensors b/model-00030-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..178e898ef96ee93bf4111432de3a2e5cdfa1ee07 --- /dev/null +++ b/model-00030-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8d6a91dfe9449c958061caf84d16e19985710b7f64785fa1ef3cb80a106339cf +size 3152911024 diff --git a/model-00031-of-00341.safetensors b/model-00031-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..46c906ad157a94aa5beebfd4f3b9f992f3e1e34a --- /dev/null +++ b/model-00031-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7bf393480ddc8049b4b0ac72a10e600f6a54d13c20ff29a5e2f52eb7ca882ca4 +size 219369792 diff --git a/model-00032-of-00341.safetensors b/model-00032-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..07b9f866d2fa5b44aa86ac348da755146e30d93d --- /dev/null +++ b/model-00032-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ffe7802a46e53fcf9e13a7993f1d955666ea9c37dc34a2b0f47f6d8d0aafe6a +size 3154180768 diff --git a/model-00033-of-00341.safetensors b/model-00033-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1381f37b32843b38c9b20e558fc4305e9a4493f1 --- /dev/null +++ b/model-00033-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6d5bab2d33347733d231887ca924cc30ef4dd1ec735931b330866869d6d7688 +size 3152911032 diff --git a/model-00034-of-00341.safetensors b/model-00034-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a6853b894bc01aa064d8d56e83f0dbe8c8384743 --- /dev/null +++ b/model-00034-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2e20f46ba9780dc03a244746972e7fab3309769df52fa1b96bb6e92e8d0af46 +size 3152910944 diff --git a/model-00035-of-00341.safetensors b/model-00035-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..197a501ddc037f148e98e67b21307548e140dd81 --- /dev/null +++ b/model-00035-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:628d151b2032db8b7923d799ac7c3d349d09808c9b881e6d56649420d60c3a3b +size 2946444424 diff --git a/model-00036-of-00341.safetensors b/model-00036-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..aab367685f6a5fdef0b06d467a20a17ccb4a8746 --- /dev/null +++ b/model-00036-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97de15d492d383339fc41e1caa0a6abddc34216f3344f128156abc70598d881a +size 3151755048 diff --git a/model-00037-of-00341.safetensors b/model-00037-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7ea76566b1eb09ab9279077c7b671936d42c0fba --- /dev/null +++ b/model-00037-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6c5efc9f22148e780a3e4aebeed275c7b7644880331fcfc59d641d459b3fd414 +size 3152911016 diff --git a/model-00038-of-00341.safetensors b/model-00038-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e448b49ea5a013bc19152c4a04eaca08bdfcd295 --- /dev/null +++ b/model-00038-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b59cdbc71d9147311fc0441a185a9ae83ea7e0b54617bcfb79988321c99a1328 +size 3152910944 diff --git a/model-00039-of-00341.safetensors b/model-00039-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..bbb7b535f929761060d293a8f820e2047236943e --- /dev/null +++ b/model-00039-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b59db7329b4836d4c961b9a05ade69edb01ae8140d55244b1d30cd0755f19fba +size 3152911024 diff --git a/model-00040-of-00341.safetensors b/model-00040-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..51159fd792086c636f252f2ac7787fd666ab42ea --- /dev/null +++ b/model-00040-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:491f1ced1917291ccae24a8fd6044a855cccb0c4559be5ab296ed458da4c3ca0 +size 219369792 diff --git a/model-00041-of-00341.safetensors b/model-00041-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a461fad9e696f563d8a6b17390d96fdf8a1b1cb3 --- /dev/null +++ b/model-00041-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63d5dfd08638df1e436f244718a9a80b5ef1e248b36ac970caa4bc90f65b5953 +size 3151755048 diff --git a/model-00042-of-00341.safetensors b/model-00042-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7956e17948f0a0dd476d989326ee5356d8796b42 --- /dev/null +++ b/model-00042-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e41dce94b3e455ef55b1471dd2f9bb1bfcfcf4e2199e890addceefee88641106 +size 3152911016 diff --git a/model-00043-of-00341.safetensors b/model-00043-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9eca8e4e3883dff8cb9835c4b6bf5c4d3805618f --- /dev/null +++ b/model-00043-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65fc6a3838eb2ec5e5085a6947f46f1359408372fce64076b4adaed8bf99c6e0 +size 3152910944 diff --git a/model-00044-of-00341.safetensors b/model-00044-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..63c85c078df46e4bad89561d601bbf37f2bf465d --- /dev/null +++ b/model-00044-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7665bfbc68cb2116c609aca31eb91b2a7b5e0728441e87eb8b19fc091c8a7e9e +size 3152911024 diff --git a/model-00045-of-00341.safetensors b/model-00045-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..511c660828752a4c592b84f4b5b3338c65dded1f --- /dev/null +++ b/model-00045-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7e27e78af7bc283a9385ec768bcfb64af47731eda7d8338ec3b01dfa608494c +size 219369792 diff --git a/model-00046-of-00341.safetensors b/model-00046-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4a370e431af14dc2282af99a51c480af36c9907a --- /dev/null +++ b/model-00046-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5891f194e0b9ec7ed3027d34a6191ca59f95a235035ece4a6938e9ddbffdc907 +size 3151756824 diff --git a/model-00047-of-00341.safetensors b/model-00047-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..86040cccd201ec5cefa6a7662cd71cec05230bd9 --- /dev/null +++ b/model-00047-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d7d910732b567fe31cac2eff550a55c5d044517e46137264cff41a108648a598 +size 3152913952 diff --git a/model-00048-of-00341.safetensors b/model-00048-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4eb78ccbc1429b2d35986711fb157b40a47cca13 --- /dev/null +++ b/model-00048-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe77cb949be22dd5e4e43f10b8ee9a44e346219a7390d039c9cd8b0a322dea28 +size 3152913880 diff --git a/model-00049-of-00341.safetensors b/model-00049-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..2bdaa8847508460cab09072607e8a47377766d2a --- /dev/null +++ b/model-00049-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7cb76906fcb48ea7a1467afc18666c9fd95650898650d7b3ac92bd499c3a8da3 +size 3152913960 diff --git a/model-00050-of-00341.safetensors b/model-00050-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d27d2a5768eeca4a03fd772e4badd357db89dac0 --- /dev/null +++ b/model-00050-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91080f74c0f5664cd882e7a2002ce121d08c72b7390ad2e61d4e456d7b388014 +size 219370000 diff --git a/model-00051-of-00341.safetensors b/model-00051-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..94ebed0aceff0ab380f1c4f57f89fd1a8881f50d --- /dev/null +++ b/model-00051-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9e3176d736aa3a6aec82394ad3ec52538d28cc8b2d0296f16455e1f84b77183 +size 3154182936 diff --git a/model-00052-of-00341.safetensors b/model-00052-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a9db49bc3c9b00e3b24a3076ae4bfc3718ee74e8 --- /dev/null +++ b/model-00052-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:761bd0b95ceabebe4cd7c8f0e49586bfaf1b594c59314928698717dad6d3cf9f +size 3152913960 diff --git a/model-00053-of-00341.safetensors b/model-00053-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..af0e08badac74c0f02257d35f6cdd9d5818028e6 --- /dev/null +++ b/model-00053-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a81252ab4d2f0486e9eeea6943f18f07659ed8035ab3f5a766fd009ab4f3ec5 +size 3152913872 diff --git a/model-00054-of-00341.safetensors b/model-00054-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a0c4be461b5657a2bcea5c130ee9be37729c05c5 --- /dev/null +++ b/model-00054-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c81fafcb7ddaa099df3b0d80c07d93ac2f14a33e8067d356bc36d0a6d0dc213 +size 2946447168 diff --git a/model-00055-of-00341.safetensors b/model-00055-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..653c90b65dab14160519863543123ce307893c5d --- /dev/null +++ b/model-00055-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:67a27264465187a1031edd79aacc5516fb333900283b2601d41cd90bd65a22a7 +size 3151756824 diff --git a/model-00056-of-00341.safetensors b/model-00056-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8293ddbffa41076cf2cd462dbdd33c99290bd277 --- /dev/null +++ b/model-00056-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:95a2c8b4cc15ff6cc0af5ef95641d59bd8e752f4f49ae303247226cbf8012ba4 +size 3152913952 diff --git a/model-00057-of-00341.safetensors b/model-00057-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..ae9f4b65488bafc81173376132d97e1312df48a0 --- /dev/null +++ b/model-00057-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e138c4dd4eff312bb35a8243559e216b5a30b9c71ce7442fe4cfd47eed95ade9 +size 3152913880 diff --git a/model-00058-of-00341.safetensors b/model-00058-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..bbf6e1a20c63296c55e5023900c5b5fbdc6e3480 --- /dev/null +++ b/model-00058-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6000917e77983ed5107408945fc63f1408078cad4278c0c886afb4245c43fe8e +size 3152913960 diff --git a/model-00059-of-00341.safetensors b/model-00059-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..05cbaa27d8f1726a621e53d4aa7c0298cee09412 --- /dev/null +++ b/model-00059-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:95763b2dec8f44570345c54dfddb73805c5f94ecf76e34078b061236d349361e +size 219370000 diff --git a/model-00060-of-00341.safetensors b/model-00060-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..fdb5824ab980f9b31b0b66bad26177acf8920833 --- /dev/null +++ b/model-00060-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd7597935a4d9c2fee25ec8589b639808fd3bf8effe43fd12b2bf0423fe4f4c9 +size 3151756824 diff --git a/model-00061-of-00341.safetensors b/model-00061-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1d8f4befc5eeef53df2e9bd6f2195bef638a3fb3 --- /dev/null +++ b/model-00061-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0957e9c4f3337d37de3472cb53ecde95dca89cbce58c06240674a162f4e950b +size 3152913952 diff --git a/model-00062-of-00341.safetensors b/model-00062-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..57fe6e84defecca643c3fdc3d4d83bb61abe251a --- /dev/null +++ b/model-00062-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:228bfa4a51650143ed85f2e9a16f0f609aac58cd37ed70b8d64bba89ef260b6d +size 3152913880 diff --git a/model-00063-of-00341.safetensors b/model-00063-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3b17df7e2b941097ddfdc1942ae63b8e930dcc49 --- /dev/null +++ b/model-00063-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0396d75b4d11a1533dc1469e8cb4a877d8d7b4f19a77c174d58c66d145821b3a +size 3152913960 diff --git a/model-00064-of-00341.safetensors b/model-00064-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8ee9a855f824a53fd1dfbf2e7575240f1fcca44d --- /dev/null +++ b/model-00064-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e8cb8306d8caedd8b0e529dcd61957cb92c46deb224df7bb6a7c330077f0472c +size 219370000 diff --git a/model-00065-of-00341.safetensors b/model-00065-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cf98e5dd0b16f11315a5f3a52ad5c7baf525b663 --- /dev/null +++ b/model-00065-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9e1caf8b182668d301ea20fde09759debf432fff7ceb1f0b1562bfeecad6c624 +size 3151756824 diff --git a/model-00066-of-00341.safetensors b/model-00066-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1b13eed33e3a2fe7a38cc37851dd6fe713a37a27 --- /dev/null +++ b/model-00066-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:67e8d3574c2a79b2fa6b93c431489796fb0f283282776a790d3d48fd28a185e7 +size 3152913952 diff --git a/model-00067-of-00341.safetensors b/model-00067-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e12e8b335fd080765ffd616897303e966f6662ae --- /dev/null +++ b/model-00067-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f9dffeac3e6d643bed2ceec4464229e9a956882a6dc5a7c53d4d29a382f7d4f +size 3152913880 diff --git a/model-00068-of-00341.safetensors b/model-00068-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..81d72745b1601f62109a6e6fe40ef5080524d479 --- /dev/null +++ b/model-00068-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be21139c8305cf5eeb746af3dfa8960a3409595c81b9ea51bf142423e98a1084 +size 3152913960 diff --git a/model-00069-of-00341.safetensors b/model-00069-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7dbc3f759f51df892776067d4d713ee3c76155e1 --- /dev/null +++ b/model-00069-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:80618e7e5f56b03dae0af560c45202691b88d182609834ce64e09feddbc3f927 +size 219370000 diff --git a/model-00070-of-00341.safetensors b/model-00070-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d5167dfd7b4c9612aaf7701c859f33e3df97a49b --- /dev/null +++ b/model-00070-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6ed4b983cd28b3a739cc8822b58e387a4e3f0ed9afbad0f2ba74dacf4837509 +size 3154182936 diff --git a/model-00071-of-00341.safetensors b/model-00071-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7114aeb9497eea92e115e9b8bee72cba0929e341 --- /dev/null +++ b/model-00071-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e468ceeb21d86ba6a820c40fd1314bb679f3f9db30c93f6d39051ddd209bcfd +size 3152913960 diff --git a/model-00072-of-00341.safetensors b/model-00072-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e1e97ffe79cc1541b61b5ca3a58ed29399e85714 --- /dev/null +++ b/model-00072-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:53257032d8909cb1cdf03ba8ae3d8b44ab303cc0293b58fbb66276611f3be089 +size 3152913872 diff --git a/model-00073-of-00341.safetensors b/model-00073-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d837f83a4e5cc31ad26d169b2b9f4a886fd70e01 --- /dev/null +++ b/model-00073-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f762cae99f4fe3362ebe4421faeb953cb0171b21382b259a276ba6743587a4f8 +size 2946447168 diff --git a/model-00074-of-00341.safetensors b/model-00074-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..ee605b505e9fafe8a82477bff321488835ce2718 --- /dev/null +++ b/model-00074-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00e98f31185d5c35a56b2ea116ea7eaae0f490ed5801904b56165d228394900a +size 3151756824 diff --git a/model-00075-of-00341.safetensors b/model-00075-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..93cf50f418aa8260ecde53e5c0caf8ac2cf36fdc --- /dev/null +++ b/model-00075-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab7a5dab8ab11220217976f844853b50e0837b4a552fb85709858363979bc757 +size 3152913952 diff --git a/model-00076-of-00341.safetensors b/model-00076-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..33acf58ed02b2cdbc3adbd8933f5e2bb70625f60 --- /dev/null +++ b/model-00076-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91d084427178db6a16aad34a7cb11a782bc05524520b3b3767a205804219281b +size 3152913880 diff --git a/model-00077-of-00341.safetensors b/model-00077-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b6cdd168ecc4a81eacc8ea7c5348682f51685759 --- /dev/null +++ b/model-00077-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f77343eae150ac736529d16f94112da6d36c0575b587f02d101aa6a4979ea97b +size 3152913960 diff --git a/model-00078-of-00341.safetensors b/model-00078-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..278396084dbec63693178f4e61b03f0b35b287c4 --- /dev/null +++ b/model-00078-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8f857191c1f66bd02ceb494465425b48882d2e2fb5900eedcf1de56ff0ac6fad +size 219370000 diff --git a/model-00079-of-00341.safetensors b/model-00079-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4335160718196abd1dbf04c5160dd4039ccecabd --- /dev/null +++ b/model-00079-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7306c99953241e075e5c2570f636963e654711c60a63f3579a0de1e3e3f78829 +size 3151756824 diff --git a/model-00080-of-00341.safetensors b/model-00080-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..af8d922d19abda4bf28b0cebe2c5345ed84f054e --- /dev/null +++ b/model-00080-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4850b392f76b226d775d08c7981d5bcc6e3aeaa6a274af634611481b267e6ef1 +size 3152913952 diff --git a/model-00081-of-00341.safetensors b/model-00081-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6c18830e9d7501e63fa01677cc055139e85772d2 --- /dev/null +++ b/model-00081-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f5e9521a1d0ad17fe2207fd162249b714ac8b80cb6933d2cd3f538601b03b0e6 +size 3152913880 diff --git a/model-00082-of-00341.safetensors b/model-00082-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f5ecfb582c770b3f0e4787b18af9507e4e581f82 --- /dev/null +++ b/model-00082-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c12178282fe00406a6e9cf54d049180572ea3b96e9856ad6dc1e880ae76342f4 +size 3152913960 diff --git a/model-00083-of-00341.safetensors b/model-00083-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..63bcbd3fba26460c5d039485ce40b92aee13bd26 --- /dev/null +++ b/model-00083-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dcbccdff15deb87c36f65c5169f70c8472a543d8f828a321f6bef31da509243a +size 219370000 diff --git a/model-00084-of-00341.safetensors b/model-00084-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c92b597bf7329e5271cb1f783d0be30edf53a9cc --- /dev/null +++ b/model-00084-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38cf5c4396c601d0d51562ced7a734b339075cfce77792db7de83a3072186e4d +size 3151756824 diff --git a/model-00085-of-00341.safetensors b/model-00085-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e4fbb482535f6ffc50fa652c1319f2cc69ad9c45 --- /dev/null +++ b/model-00085-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4e85824bbe51108f3b943213ba08831dd88884f68dd8b28ad84fbfae1ace8df +size 3152913952 diff --git a/model-00086-of-00341.safetensors b/model-00086-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..521e323ddda01684faea8d4489dd44a81c45e001 --- /dev/null +++ b/model-00086-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9145991e051ad2b779e7ab052f02c1857e37e633daf54c5dabe98129f3ab5581 +size 3152913880 diff --git a/model-00087-of-00341.safetensors b/model-00087-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d743eb877e2caf764b4582b473b208f564932384 --- /dev/null +++ b/model-00087-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5437caba3aa3bf665fe435ede836ef92de8b99a5056e9bf6ecf24ca63456e8a0 +size 3152913960 diff --git a/model-00088-of-00341.safetensors b/model-00088-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..90f2d33540e33d3e03501362fa439421e9fc5e89 --- /dev/null +++ b/model-00088-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1c0b7e039c45e68270c1d9877b7892e184e7830bf1d2da89ccc4b9fc8c06c31 +size 219370000 diff --git a/model-00089-of-00341.safetensors b/model-00089-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9b4479138f10bfb2d39eaef66bcb00ca0eb8fb41 --- /dev/null +++ b/model-00089-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3dbfe663c2198ff6a773f143e54ec37a13e0035db5181f2d1ec10af6b5200a4 +size 3154182936 diff --git a/model-00090-of-00341.safetensors b/model-00090-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0afcfe87d9e87d074b935b57fa9c0e52891599c1 --- /dev/null +++ b/model-00090-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49e9cf1b462692135db35076d7f71b04b93feb932b985b602a830fa63cbaede1 +size 3152913960 diff --git a/model-00091-of-00341.safetensors b/model-00091-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7dc568f87831b2fb726fd17ee3d53bd92fc26c1b --- /dev/null +++ b/model-00091-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac90a7c15b6e515e814d8737a907ec27fd72165733d813f25aa56a0ffc2b9fc3 +size 3152913872 diff --git a/model-00092-of-00341.safetensors b/model-00092-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b711c74bdda88a078aa79e529d27a741e957af30 --- /dev/null +++ b/model-00092-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9461dd5343af8f509598d290c5d0305a83db3db58c927c32c869f099cda0dc9f +size 2946447168 diff --git a/model-00093-of-00341.safetensors b/model-00093-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0951ad17b5c1e85b3ac1d8ab97edd7f562658afc --- /dev/null +++ b/model-00093-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aaf8afd8194c070579ac4962d92bff01e76e6a74443cb11c4e721f0a823ab600 +size 3151756824 diff --git a/model-00094-of-00341.safetensors b/model-00094-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4cc3058be42bbf5645e1f3ee3e530a140853fd61 --- /dev/null +++ b/model-00094-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d98956ee7ac21ea6929b80d3d43d4130f23c04880636fbe1ec44b78b8a537512 +size 3152913952 diff --git a/model-00095-of-00341.safetensors b/model-00095-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..97d8015ea07fad82f70b089bd55868a4cdc2ab5a --- /dev/null +++ b/model-00095-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fdd6b2b40f0d740adfd5f24de30bca3f991cf8fa524c9494584269fb4f0a1466 +size 3152913880 diff --git a/model-00096-of-00341.safetensors b/model-00096-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f2fac1d7a39bc3efdbf420dd9a8edfea2ee99818 --- /dev/null +++ b/model-00096-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e02226b5bd28bbd1395168ae11734fe07590259a690dbb45ca5c7eb9d4ef14b +size 3152913960 diff --git a/model-00097-of-00341.safetensors b/model-00097-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cf82568fea302e5e6bcd5e5f0465b81ea12ccec7 --- /dev/null +++ b/model-00097-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a123f355157dc473dc3884de3ad882e47b4341036b1b9975bf9dd4d3ae0f2b17 +size 219370000 diff --git a/model-00098-of-00341.safetensors b/model-00098-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..23bd97f1b8bc5c768e22e051feeba351fa164925 --- /dev/null +++ b/model-00098-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fa9aade5e1d4551c69272fdf27c79976a7af3612ff09bd9d60408b2436cf9bf +size 3151756824 diff --git a/model-00099-of-00341.safetensors b/model-00099-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a19902a5c17259a90189d4c612810b16662643ed --- /dev/null +++ b/model-00099-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92cef440ab99492500365559788c0ed931ba9dab93f7892505d051ab8f182a9a +size 3152913952 diff --git a/model-00100-of-00341.safetensors b/model-00100-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..403babbe14ad20f9874a2d2e6bb995b5aa75a2a6 --- /dev/null +++ b/model-00100-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b7e876add8f7c1d3530d0c10e67682daa1a8d868bd8ecf27ec416178b08251b +size 3152913880 diff --git a/model-00101-of-00341.safetensors b/model-00101-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5671a356815523e101a99bb66dc450ab3acd93ce --- /dev/null +++ b/model-00101-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e84314e5538d053ba8eabdaf6d2e4c07b4e36651fda74a4a0b13dc9ce787964 +size 3152913960 diff --git a/model-00102-of-00341.safetensors b/model-00102-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..874137435cbaaa71393e79561dc4a1252022a6ce --- /dev/null +++ b/model-00102-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9c10269832311f27f4f942cc17592678279727803e7bcfe64da6a4412b039fe +size 219370000 diff --git a/model-00103-of-00341.safetensors b/model-00103-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cb24b150ab04b1fb6390c78d175186f31ef03fb5 --- /dev/null +++ b/model-00103-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d1dccd56003db6ff8a264b98330d26bfa91dde1a00937916ba6fa4eb5a045d4 +size 3151756824 diff --git a/model-00104-of-00341.safetensors b/model-00104-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cca1adca38e67d37f982670f2732a4e6f30c42f5 --- /dev/null +++ b/model-00104-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02cbeba8818f2a58077f4b6ba9d2ec64870fa216ca685c282176daf91ee619d4 +size 3152913952 diff --git a/model-00105-of-00341.safetensors b/model-00105-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..a39d166a39b96c96f73228685561e1f83b65a0bb --- /dev/null +++ b/model-00105-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:630c6b0db34ddf6e98f19c8aaa7f4be92377550bdeba171c2a0226d04f2a6a9c +size 3152913880 diff --git a/model-00106-of-00341.safetensors b/model-00106-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..318a67e3ba32608566f6cd7aff4e144597103c5c --- /dev/null +++ b/model-00106-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3629a8ae99b0c0bbe55619d256f7972335b3a3544a93856a2c2c1a7616be3e9 +size 3152913960 diff --git a/model-00107-of-00341.safetensors b/model-00107-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..351024e74c3eab7a1c2579e0e81e1fb74eb5109a --- /dev/null +++ b/model-00107-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2050c2ab8a2ffd3ddf72b1c2a83ad7d9c34e2cc498b354348b6c007e3160b6b7 +size 219370000 diff --git a/model-00108-of-00341.safetensors b/model-00108-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..ebbbec579dfb70549209a45a3ce157ba148e14b6 --- /dev/null +++ b/model-00108-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34e4aa5953a769506fb22edb69e5137fdb473b3f75d09f26d503a761551f674b +size 3154182936 diff --git a/model-00109-of-00341.safetensors b/model-00109-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4141489cceed8ca602c1716109a4f1a13498a021 --- /dev/null +++ b/model-00109-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:573aca11b223f5b8a3a08a922ea05ad673c755e21952d893373e3aa21066158a +size 3152913960 diff --git a/model-00110-of-00341.safetensors b/model-00110-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1da8cc1de209311877304bad59dc7ad2bf86d667 --- /dev/null +++ b/model-00110-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:26f3cde7faa5328420dd9dabbefafbff272c92cdd2017907bc722f4c5688d6b2 +size 3152913872 diff --git a/model-00111-of-00341.safetensors b/model-00111-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..718daa76e9538d1b67c24a8aeaf08bffe7b29c8e --- /dev/null +++ b/model-00111-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f424be9846d1fd28125db0440471ca6d49718e3e0a2d5f5a703efbcc1e3b3e6d +size 2946447168 diff --git a/model-00112-of-00341.safetensors b/model-00112-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5a818bf9e2287c5a11bc981f95b5401b132cf339 --- /dev/null +++ b/model-00112-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:516c49f343440e125b7ea4a01db3ea052b99c2f9c412dd0c26a156d0b8448d02 +size 3151756824 diff --git a/model-00113-of-00341.safetensors b/model-00113-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3ed7f29652009ac9bb7cc6bbc8696c425693de15 --- /dev/null +++ b/model-00113-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25ad2d1d46474e264203d3fb45e731dc05e3f7454f8748688b4f20a3eff3170a +size 3152913952 diff --git a/model-00114-of-00341.safetensors b/model-00114-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3a37b3898d92d5d8e670c1d1148fe52aab55176b --- /dev/null +++ b/model-00114-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c848e8dcc046a9c7afc59e4f8ac5760c9dfeb5e5784b00ce087a4f7d65cffce +size 3152913880 diff --git a/model-00115-of-00341.safetensors b/model-00115-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..36e6dbde17708f8390f1d1a81ae15053f991f3a4 --- /dev/null +++ b/model-00115-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b4a0d99971b433424e5646543cc9efb0484b21b145f08b968687f1b59a507f54 +size 3152913960 diff --git a/model-00116-of-00341.safetensors b/model-00116-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1cffa18f6afd254a929294c8a1afa32444601f65 --- /dev/null +++ b/model-00116-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1013b0a4d525a81d1907d726501d12bf8cef032ca2f19809d97cc3cd1d59151b +size 219370000 diff --git a/model-00117-of-00341.safetensors b/model-00117-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4ff5ca736056bd3f48412400fd09e55977e87390 --- /dev/null +++ b/model-00117-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6bd2c51610b9606e3fea2f1ead85bd2b8201b318a1ddf9024ea5f517001d20c6 +size 3151756824 diff --git a/model-00118-of-00341.safetensors b/model-00118-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..41352aae5ed1bd7b13f46f6fa6680b9029738950 --- /dev/null +++ b/model-00118-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6b6858d4aae2e8a2d27ea7ba055bd2d2751355fe055007216be10b589b99633 +size 3152913952 diff --git a/model-00119-of-00341.safetensors b/model-00119-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1aa668a0d93ca34e15bed12ae89a75ccbee76c99 --- /dev/null +++ b/model-00119-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b98fdeedc764bd718ba50e19409363524400be75ad418d6f98aee9950749faf2 +size 3152913880 diff --git a/model-00120-of-00341.safetensors b/model-00120-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..14f219515203a9ab79bdd34b6968620ab4794ffe --- /dev/null +++ b/model-00120-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2904b0811f07cd9cc704c83ea7d0eebf93d00f451215ab9c9c26a879776e135b +size 3152913960 diff --git a/model-00121-of-00341.safetensors b/model-00121-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6720035efae3c611297972bdf5cfcbe3789898f9 --- /dev/null +++ b/model-00121-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7cd72e36b7bd205639d252dfe68bccf1246f9a9cec8d1c2e1e1298828394a63 +size 219370000 diff --git a/model-00122-of-00341.safetensors b/model-00122-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4a091e7ad3b8faa0582ea78f472cd0696894978d --- /dev/null +++ b/model-00122-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8e5474d0f2b17f1124e88f2344bc00a844877f8c061f78fa6c4e0c84945820a +size 3151756824 diff --git a/model-00123-of-00341.safetensors b/model-00123-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b151d09b4d1a3b965123c1df6aa774419765c861 --- /dev/null +++ b/model-00123-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c12a0c268f2b3c339f3d7cc6cc6e9b6d09b9065b0fac8bf40039dfc0be56f53 +size 3152913952 diff --git a/model-00124-of-00341.safetensors b/model-00124-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..95ab1fd49f1818cd86395ecafc495c191d9f2d44 --- /dev/null +++ b/model-00124-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc934f9ea79f6afd28fc89bf6daa69e587e3c313f081b7c0647c88d42415adcb +size 3152913880 diff --git a/model-00125-of-00341.safetensors b/model-00125-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..10c80665677cb1e058a1d9356074bacd32427329 --- /dev/null +++ b/model-00125-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f5d1b54878fc7d42d4dd73af571c590ad08438ef928e620b9cb7f24a2264ad1 +size 3152913960 diff --git a/model-00126-of-00341.safetensors b/model-00126-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3465efad5cc4e33d494d93e8d04516659c0bc962 --- /dev/null +++ b/model-00126-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c1e29a6407e66ec9fd5bfc5a7764aeb714a038cdf8fa66d1582316ccf2c274e8 +size 219370000 diff --git a/model-00127-of-00341.safetensors b/model-00127-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4f1916100e673b3554e0fe87e9090e7faf5f4896 --- /dev/null +++ b/model-00127-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c519c5ab285984e41514b6ca8d2cc0a18b654d0bcf3a7957fce837bb9b4af47 +size 3154182936 diff --git a/model-00128-of-00341.safetensors b/model-00128-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9018957a018a748ef8bad09352af841885e2bdab --- /dev/null +++ b/model-00128-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1a525644dc7d81020109f6dddf2e23fab96ed3c0810ec4a53f9edb1bb378c6f2 +size 3152913960 diff --git a/model-00129-of-00341.safetensors b/model-00129-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..486ccfe588361367dce0e47254833ffa030ffdd9 --- /dev/null +++ b/model-00129-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5603f3346f7833b99912a5b250431c9d35a17f64aa830c7efd625ec159a475c6 +size 3152913872 diff --git a/model-00130-of-00341.safetensors b/model-00130-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d4b743280becc58443e8b9a91e7f097ee5132f64 --- /dev/null +++ b/model-00130-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51cf00ceffb53a99be5d2f987e3914c547dfac31c9e0696d4e4421a0c4b855fb +size 2946447168 diff --git a/model-00131-of-00341.safetensors b/model-00131-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..54fed70c6b5df806d1187f7608da7f16025bd13f --- /dev/null +++ b/model-00131-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52e921b862f0a84d7da9dff0fe3d2b9133d0b4f41acf58c8c36f26cfb50b168f +size 3151756824 diff --git a/model-00132-of-00341.safetensors b/model-00132-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..2dbfd8a3419d0e3f24d14a708c7b01a48d524971 --- /dev/null +++ b/model-00132-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:93d63f58b4603218637f7b31f5b01fead5c6bd9141d1636478e5ba78b55803e1 +size 3152913952 diff --git a/model-00133-of-00341.safetensors b/model-00133-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1ad825d6fd3feb09c86019c8b84c90b7efe22f8e --- /dev/null +++ b/model-00133-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6484d3810356bae2ce0b8d120fedfd9cd84b89f3a9789bf26ae61f2df297fca7 +size 3152913880 diff --git a/model-00134-of-00341.safetensors b/model-00134-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7dddb47d81f2c0ba869a79e0b9296bd317ff9627 --- /dev/null +++ b/model-00134-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c796458d75bbd9d4cdcfc534ce7d1bfe2105738302be2aac802bcc5bc124cbe0 +size 3152913960 diff --git a/model-00135-of-00341.safetensors b/model-00135-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..514d660684a5aeed16d86f66f18d09c4acedeb67 --- /dev/null +++ b/model-00135-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f613371a3c9bcc817f2ce40ac5ab94b88e2957e39bdcca9bdc3d75164f3b12d +size 219370000 diff --git a/model-00136-of-00341.safetensors b/model-00136-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..32721e4ba3f5fa63ae3da6b146eeef2da629c9c8 --- /dev/null +++ b/model-00136-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb5564eaf0712fa16d7cdd4769ff0390f40360dbccecd84dafd23796af609429 +size 3151756824 diff --git a/model-00137-of-00341.safetensors b/model-00137-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..de9224b88feb106a360746d4ed863907ac2b462b --- /dev/null +++ b/model-00137-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1458f98c57ff93770fc02916c5df0256978c97fb66b3475ab29174613c6a7d52 +size 3152913952 diff --git a/model-00138-of-00341.safetensors b/model-00138-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..99c966dade8bf649f8f792f07126f45b599ceb11 --- /dev/null +++ b/model-00138-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16a51d0fda603650aa28069b55f2cec4974ff9865814027558a518e7ca91bbfb +size 3152913880 diff --git a/model-00139-of-00341.safetensors b/model-00139-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3071104dcb8d24d61e1d7710c4dc661b337e0c38 --- /dev/null +++ b/model-00139-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51cd159cd01439851c40acefa3454abe3e84e3ae173d980842569dc22808bf35 +size 3152913960 diff --git a/model-00140-of-00341.safetensors b/model-00140-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3c8708ceabc927b61edce23628968f9c1529f493 --- /dev/null +++ b/model-00140-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:48ce29527279e199d7ba068937f9bb04b2feae718bea435d7680ac906368f74f +size 219370000 diff --git a/model-00141-of-00341.safetensors b/model-00141-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..23169b936b30844d79be40383eff52ffc86c7a06 --- /dev/null +++ b/model-00141-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f8c4b10cadf493942e1c4b732ebb9936fbc41ef7d971acd4d18dee72ed675aa +size 3151756824 diff --git a/model-00142-of-00341.safetensors b/model-00142-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b554179deef330075bb200aaa953f219ff23fb78 --- /dev/null +++ b/model-00142-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c51c524b1e3028a6e69d3ed3baf315feecdf140aa4e029070f5689e60b5406c +size 3152913952 diff --git a/model-00143-of-00341.safetensors b/model-00143-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..113055bfd8dfd363666adc873f08e4a620b28270 --- /dev/null +++ b/model-00143-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1de1344093bd7cc8b8de5545b5adfe0f1f9566533796d7b2ca7e5d6be3fa185d +size 3152913880 diff --git a/model-00144-of-00341.safetensors b/model-00144-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..30424023d999ffdec32edf219612ff9a5026a77c --- /dev/null +++ b/model-00144-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4ad492bb31d71737c977756ef4c7b7b2e2eff2b4c83f64ecae86b7d0cb4386ff +size 3152913960 diff --git a/model-00145-of-00341.safetensors b/model-00145-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..995aba852d8f281810fcb8b374b21cdf60f4aee1 --- /dev/null +++ b/model-00145-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca55bfdf2747a696091cc794272773762abb65c7a69bff19860c9edc3292ad43 +size 219370000 diff --git a/model-00146-of-00341.safetensors b/model-00146-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..acaf4822112bd4ed294f408a6384c860ef367c18 --- /dev/null +++ b/model-00146-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b9a4bbdd7c875dbb2ef03e9feae9ebaefb7299f254de12a2f6137f1f7843103 +size 3154182936 diff --git a/model-00147-of-00341.safetensors b/model-00147-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f54636cde629b26a451223571518793dfb84247d --- /dev/null +++ b/model-00147-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:efb36fb28f6809d2502edf654b10337bd497ac92fcced21c06fbe908894cc4b4 +size 3152913960 diff --git a/model-00148-of-00341.safetensors b/model-00148-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..661971c8e380abb38d4c2d7a50146a9e780e602a --- /dev/null +++ b/model-00148-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed5d481be0b04da065475a0f450485ed696d476c8abc90ce81f146ff41fb8031 +size 3152913872 diff --git a/model-00149-of-00341.safetensors b/model-00149-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5c2b4b0874616598df8f82d5aed4d579865b574e --- /dev/null +++ b/model-00149-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f95e518bd1eabc49be2ecfb6acdb8d490bef2e2e335120aadcf57dc4c46283ce +size 2946447168 diff --git a/model-00150-of-00341.safetensors b/model-00150-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..810f6745e67c265228681557463809e9bf7bb05f --- /dev/null +++ b/model-00150-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44c5d921118979d7ccee8ad5721f5763438bdccffee58c3e1d86b68f35269cff +size 3151756824 diff --git a/model-00151-of-00341.safetensors b/model-00151-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b1748f256ee63b567ee3c691a7b87fab8af4bfa0 --- /dev/null +++ b/model-00151-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:578d554da79333db11e4391d37b92349e7b8ef422e35ca32bce96c7e61a699b6 +size 3152913952 diff --git a/model-00152-of-00341.safetensors b/model-00152-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5d17e75ea950b71e4454440a3a23b1e911c768b8 --- /dev/null +++ b/model-00152-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e5a935af0b4b4ede811ca936ab3f95a1a25112e4baacfae1ed0ff164b4a64e2 +size 3152913880 diff --git a/model-00153-of-00341.safetensors b/model-00153-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8315a5755b2728ae8f1faa7b5bc8b888ef1eeb10 --- /dev/null +++ b/model-00153-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ff3310dd7f624f1da317fb976d4c9cf9c578f53651c0b573834645679db1886 +size 3152913960 diff --git a/model-00154-of-00341.safetensors b/model-00154-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..23dc0e9cd493565e6eb230b8e5afaaad2688cb29 --- /dev/null +++ b/model-00154-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e03560429d6d8e504590f27f5c32cbcf49866d649ec3e077a33f08ad14b064f +size 219370000 diff --git a/model-00155-of-00341.safetensors b/model-00155-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4ff3b6814a0d5dd2dc1c7c6399ea021cddde07ef --- /dev/null +++ b/model-00155-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5cf7cfc8334dc27a059bdcf8dd3e9e84ca1ec2f527a6e0aea766e79f3c1e558e +size 3154458912 diff --git a/model-00156-of-00341.safetensors b/model-00156-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c99597e49607c7fcbd939810313ef92f2cda2d67 --- /dev/null +++ b/model-00156-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e0f97355b0e234eddc398d7a98607e6d348a5219b677c2d226ac576241da6ced +size 3153288488 diff --git a/model-00157-of-00341.safetensors b/model-00157-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cd172572a4a73aa04b44b6a9b3638291d138c5f6 --- /dev/null +++ b/model-00157-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9fbf77dc01ca4adb9950a2b2e07364fe34ee4dea3051e1695d5d24edcfe8885d +size 2822748248 diff --git a/model-00158-of-00341.safetensors b/model-00158-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0f905d99643abcb7e3686b551c6818db71808d61 --- /dev/null +++ b/model-00158-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c1209e97d334eb367af0b1191e3b628b22700e237cd5d7fdb11ec6838572e6c +size 3154458912 diff --git a/model-00159-of-00341.safetensors b/model-00159-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4590e94bdbc7d78d483118c3d3f5fcc62a735d0d --- /dev/null +++ b/model-00159-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e6ff74fc0ac2268bf55441d7c47286bb90ef6f86da00974ec21ea5a884f1606 +size 3153288488 diff --git a/model-00160-of-00341.safetensors b/model-00160-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..30381fe66d823ec5bfc54e3ea077be133cfd324b --- /dev/null +++ b/model-00160-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39be5695f963f957e6d4a817a0371c98526b2bbecedf58724947b6bb4d94f62b +size 2822748248 diff --git a/model-00161-of-00341.safetensors b/model-00161-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..65a60f467ef4933e1d1c1b158abe8975a90b167b --- /dev/null +++ b/model-00161-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1c668ea852d41a740bd3e13f6fae7834e072dbfb51dec68f8ddd188eeadc759f +size 3152265592 diff --git a/model-00162-of-00341.safetensors b/model-00162-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..fcd8ab648814004a96470913b26ddf1387601a00 --- /dev/null +++ b/model-00162-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b3f0f8fe511f651bf5b455ee226fc918d60dca7fab39550935379de771dd3960 +size 3153288400 diff --git a/model-00163-of-00341.safetensors b/model-00163-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c2f8d13d49f760904511fd75b00437025d0d6b33 --- /dev/null +++ b/model-00163-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b4b8ffd1ce73b35999685b091acb59fcb3d1975e67f96d36a76f88a56ab542a +size 2401529096 diff --git a/model-00164-of-00341.safetensors b/model-00164-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..899abe21f2579a9fa5c309545b02775f80f231d2 --- /dev/null +++ b/model-00164-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:edc84a44bde14f8067084440077b8429dd06e440b395e3f55263878255d0169f +size 3154458912 diff --git a/model-00165-of-00341.safetensors b/model-00165-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6ec8399dab9cbe7fea898e4d617c91c4afe00324 --- /dev/null +++ b/model-00165-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:514de0d65fc85b08a7a09a1088ebb466bbb38ffb8b56a5fa46e16cb3913f1525 +size 3153288488 diff --git a/model-00166-of-00341.safetensors b/model-00166-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0fa3d7161ee5cf2285595fc5b703b8135450297b --- /dev/null +++ b/model-00166-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9965f6a99d6e1b649f1f5cebfc1a5db84ea01cd430b63c4c479b229cef09f9b0 +size 2822748248 diff --git a/model-00167-of-00341.safetensors b/model-00167-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0f3543e60f78dcad4223193b07ba93782047fbd8 --- /dev/null +++ b/model-00167-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c876135774a242ada10bc0b62981861cbc667a5f3552e74351d1d70aff3a578 +size 3154458912 diff --git a/model-00168-of-00341.safetensors b/model-00168-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..0c4cfdc9111ae68824a178579ea117f088698ba8 --- /dev/null +++ b/model-00168-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f621a9c4c8fbd3cbd783946d80acf3bf29f56da2a95ca9b2f014172ed969662 +size 3153288488 diff --git a/model-00169-of-00341.safetensors b/model-00169-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c690ce41eb30ca787ac399da1faf74d27cd0a14d --- /dev/null +++ b/model-00169-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8008f5830d74ee20ec9b87a00384fe029b2e6693ad2fddf9ba97c2b45ac23c18 +size 2822748248 diff --git a/model-00170-of-00341.safetensors b/model-00170-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1f2f9bb0e0f60d646975dd997c55d4e10e7e2486 --- /dev/null +++ b/model-00170-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:88939ff8d8aa9a0864a245c4d34f3e5e6b426058bb1b52179bcbb510319b5b3e +size 3154458912 diff --git a/model-00171-of-00341.safetensors b/model-00171-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c2f418e54745b3b1a4d1e15d057822e981f795d4 --- /dev/null +++ b/model-00171-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91f1a4799cad154aac9aed69106d42f428c4ef6c71c0015d0878a3192df9307a +size 3153288488 diff --git a/model-00172-of-00341.safetensors b/model-00172-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8316503da1eaea30d3ac89bf4f39b57db4dafd4f --- /dev/null +++ b/model-00172-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf1dda139ff2b76d7f21155f418eff5b8c2d04887bdbcaf6b509a47d839fb1bf +size 2822748248 diff --git a/model-00173-of-00341.safetensors b/model-00173-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f19863d5417ae1aa75648f809590dec50f69474c --- /dev/null +++ b/model-00173-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a530d838e4f34491ce59cc0b1afa29a088aa392813271cd7bd9f77c6670ac111 +size 3152265592 diff --git a/model-00174-of-00341.safetensors b/model-00174-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..542dac711ff02f24f16fc195f5ad91c9256aa853 --- /dev/null +++ b/model-00174-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2b161104738eb4680309464cc26f620180456db7b261d165ad96635871ed55a +size 3153288400 diff --git a/model-00175-of-00341.safetensors b/model-00175-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c8c98506790a966c1c8501b3ce8957d757ed0466 --- /dev/null +++ b/model-00175-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76191418f0029572b47f7003393cd3680cadee97a5094661ef5099dba1905a9b +size 2401529096 diff --git a/model-00176-of-00341.safetensors b/model-00176-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..69a95a1a31941139d698fa6579b848ce1ef9a8ff --- /dev/null +++ b/model-00176-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:910fdfb522992e63f6b34eac4e7f1a7cf2c5a698a4f1da1577b02c6e29b29bbb +size 3154458912 diff --git a/model-00177-of-00341.safetensors b/model-00177-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e85391a93d04120fb025f265db44f3e46666412a --- /dev/null +++ b/model-00177-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbff8d50246305d88f91467473c6e6e75ec5a76dbb02f9a900749bdc695fa14d +size 3153288488 diff --git a/model-00178-of-00341.safetensors b/model-00178-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e8acd03f9eff9c340676ea15b137cfe7e3f57984 --- /dev/null +++ b/model-00178-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1a8d9b302bdd941aae612c8eedc516b08561d66c05b9c40e55786234a76262e5 +size 2822748248 diff --git a/model-00179-of-00341.safetensors b/model-00179-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7cbc7d477d8c1fa925fd54eb558654b619f1c6dc --- /dev/null +++ b/model-00179-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6fd40e1f5f3e090ac60e669e1ac4d93427ee2d6a4f4a3d459a156bacd5f9a35c +size 3154458912 diff --git a/model-00180-of-00341.safetensors b/model-00180-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d8cbae3e09f5fa4b4df11f28b0186d6e7b775157 --- /dev/null +++ b/model-00180-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3cddce261215e3697e27f62239d64d9b0d3922dd236c0245413f0166e4e4bd57 +size 3153288488 diff --git a/model-00181-of-00341.safetensors b/model-00181-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c773fadc5fc56386f2ef2d1669ede587085a9c1a --- /dev/null +++ b/model-00181-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ccabe5621b473e86e0545939c470ad121362e765f313572f62814a91394aac52 +size 2822748248 diff --git a/model-00182-of-00341.safetensors b/model-00182-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..72786e65b1c5062349b057a47032374197948253 --- /dev/null +++ b/model-00182-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e18770db2ad739111ec111b466ee2a3049f533b9e6a3d39acd11d908a47410ac +size 3154458912 diff --git a/model-00183-of-00341.safetensors b/model-00183-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..28188f851993bc8006dc882553d3eb4c82b20828 --- /dev/null +++ b/model-00183-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cfe461c82c07a77125f2a1522dbf789d6d7088436d34d64aa8d18693f17e4142 +size 3153288488 diff --git a/model-00184-of-00341.safetensors b/model-00184-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..55005daa1cf32e30241cd333dcb64b829f437036 --- /dev/null +++ b/model-00184-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b6f5431ae92f47679779a343b17775c52dc6c6ff0231400e46c5665a7f539ab0 +size 2822748248 diff --git a/model-00185-of-00341.safetensors b/model-00185-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e8bcf667ef018361c97d167c6f0ed1b2590b2fce --- /dev/null +++ b/model-00185-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5a470d7265fa191af413717491389c7ac58c3d1dae1353e09e88212265935ce +size 3152265592 diff --git a/model-00186-of-00341.safetensors b/model-00186-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..bccdefa1d8c6801a1c6e32b82849fd690b3a86e2 --- /dev/null +++ b/model-00186-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:08e47dbf625217eaa6bb4640a4bf390a7352a958c6f484b57c1341e669023925 +size 3153288400 diff --git a/model-00187-of-00341.safetensors b/model-00187-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..81f0d5bbbc438abcc41d14880b3e7da37c829a8c --- /dev/null +++ b/model-00187-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbcbc9a75b7ee0dee74d9df391c8e1a021d3abff47e42e2d438ec1028517a372 +size 2401529096 diff --git a/model-00188-of-00341.safetensors b/model-00188-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..60a31309f5435c86ec89b8973e25a36226f84adc --- /dev/null +++ b/model-00188-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:29c76d41eaa59ebc8f6857aafebacf34583820700b707addba6f8e0ed87130ed +size 3154458912 diff --git a/model-00189-of-00341.safetensors b/model-00189-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8cfe5239dc3dad24e8a555cc98a70022cbf08ff0 --- /dev/null +++ b/model-00189-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64743bd2994c168d7ad1986b9f1ad203cd8a6bc19bd0f19700b88a33d1e36a8b +size 3153288488 diff --git a/model-00190-of-00341.safetensors b/model-00190-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..8ddbd81e92418d46537937c6c6b56142e4b0f5dd --- /dev/null +++ b/model-00190-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2cf680431c37660a097dcd5c4d4664a1f6bdd7a3ac13cf78c6b10c1fbdbb04fb +size 2822748248 diff --git a/model-00191-of-00341.safetensors b/model-00191-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b30542f80b579e81df014ae45d980506ff4ba842 --- /dev/null +++ b/model-00191-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:179dae62e00713b3d5879e82ddbf1d8e86ae71c725ad8f79f030baa32c96c261 +size 3154458912 diff --git a/model-00192-of-00341.safetensors b/model-00192-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..1185519a35ec864e86a1087070bbe3731139af3a --- /dev/null +++ b/model-00192-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fc6865998aa75f01f800f11b732afd6f49cc851ab66aaf66699d8f39f6b4e959 +size 3153288488 diff --git a/model-00193-of-00341.safetensors b/model-00193-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3293c21154fe0287bc6b02c8951235b5265b7805 --- /dev/null +++ b/model-00193-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:180235052b6ed8e762fe3dd8002f6dd09070b79a5194eb569fc65c060e1d5e95 +size 2822748248 diff --git a/model-00194-of-00341.safetensors b/model-00194-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..eae817aafe264d7b9b535796192c34a664207c70 --- /dev/null +++ b/model-00194-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f995ff1fbda6c02b2341c2a9bd9c4819751ec16e7254a904b59b4ba4a2cc514d +size 3154458912 diff --git a/model-00195-of-00341.safetensors b/model-00195-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..91050f8d5a372af15e89aa8cd88f55b2d7b68e2c --- /dev/null +++ b/model-00195-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5034e7bb05c2c932464240826ffe4095d44e4956a9d7aab3a8e9761d6c496d68 +size 3153288488 diff --git a/model-00196-of-00341.safetensors b/model-00196-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..ea237d40cf714a3de5d75e5a77b4cc768c790af3 --- /dev/null +++ b/model-00196-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84a63d61ee5e25e8fe6480594424d6b4d4fb506f90d44824b4d99e8ff4ecb020 +size 2822748248 diff --git a/model-00197-of-00341.safetensors b/model-00197-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d5566145d570c498bc624efbb91d80909974318d --- /dev/null +++ b/model-00197-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8b7a8ee33d97ebeda257a6723e48cb3ed8d00056d090a35859d5ab48d5154125 +size 3152265592 diff --git a/model-00198-of-00341.safetensors b/model-00198-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..b2161fa35e41e497d9d213a3f726f92480394fb9 --- /dev/null +++ b/model-00198-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8c41667e6489156c7f76902ddd697ef0e6c7e050c5c2069e56cfae15ca56801f +size 3153288400 diff --git a/model-00199-of-00341.safetensors b/model-00199-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..2f7de50b41152b63cc48c50dc6e9cb061446e1fc --- /dev/null +++ b/model-00199-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10935475b0057c984b59d700d7d80352d2baf67883a52928a4e802f0c964f88d +size 2401529096 diff --git a/model-00200-of-00341.safetensors b/model-00200-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e90aade316a219fea1b7bde5efe73ee047119dbb --- /dev/null +++ b/model-00200-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:825eec0b8a3038611241674b2db5c49674b969a49d43ccec8c1ef4935e2a0eb2 +size 3154458912 diff --git a/model-00201-of-00341.safetensors b/model-00201-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..d997356e77067d3f0f58325243b286c10904ec08 --- /dev/null +++ b/model-00201-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30f74410bf7b8cc13a36793b20e3e24e251c9095929dd8bad6f1e8c84490ef51 +size 3153288488 diff --git a/model-00202-of-00341.safetensors b/model-00202-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5218019d62378487012c6ab8f079fa5e723ba9a6 --- /dev/null +++ b/model-00202-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be761a8f79db80b56af8cec42149ef3bb50c480af3d0e02452fc73203e80df0e +size 2822748248 diff --git a/model-00203-of-00341.safetensors b/model-00203-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..2f493dee6f5396f6acc17ca1e6c147e2788dee91 --- /dev/null +++ b/model-00203-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98d2c354a38f1dc5c11adc5b6c47002bd800612b84f4fc2be88ed6ac2e449484 +size 3154458912 diff --git a/model-00204-of-00341.safetensors b/model-00204-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..4f5d5bc983760ae2bd68bcda4e003e89f25edc41 --- /dev/null +++ b/model-00204-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c5d639c82f2875d12c2833b9d5c200423d58cd7113a998da2a1d3a32d3b69a4 +size 3153288488 diff --git a/model-00205-of-00341.safetensors b/model-00205-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..074d310e982437086e02c3e4fd7a6206bf88ab5e --- /dev/null +++ b/model-00205-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0762e57cba2527a931123b7d96bdb7e24763dca65554b4f150b74abda01f8793 +size 2822748248 diff --git a/model-00206-of-00341.safetensors b/model-00206-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..ad1be890b7d187a2b66fa22edd604637e0988e7e --- /dev/null +++ b/model-00206-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4c49bbeff50ffe8e38ee27b8cad7eacb709da49c57d1685deaa8e5e7fb4ebdfc +size 3154458912 diff --git a/model-00207-of-00341.safetensors b/model-00207-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..df50888f32a538113775533177a2b7a059ca4291 --- /dev/null +++ b/model-00207-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b6351560a72b16d22ec016ce2b1871d13412542de44bf654e517de9b3dffa82 +size 3153288488 diff --git a/model-00208-of-00341.safetensors b/model-00208-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..bca8136e06685566e158fe5986ca2556c27151c4 --- /dev/null +++ b/model-00208-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ce00fe88cdf8b4079242227d824842476203d30ee3dee393416753fb89a33c68 +size 2822748248 diff --git a/model-00209-of-00341.safetensors b/model-00209-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..fdc095ac9c386db84b54b5b4a44035665a367ddc --- /dev/null +++ b/model-00209-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d5762344598adbbb56f48dc2f407c7b9f96c81e6532d17a17c03a1a8d72188e6 +size 3152265592 diff --git a/model-00210-of-00341.safetensors b/model-00210-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..493df10c15c1c32fabc6e7bc90f2f8642e0bfc8f --- /dev/null +++ b/model-00210-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5692ee3c35a53aad34d0ad9dc668eb283ef8e245b9dda0bf11e173c4a420626 +size 3153288400 diff --git a/model-00211-of-00341.safetensors b/model-00211-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..cb99aeb8bfe8ef2bdc2048d2449552281a51dae4 --- /dev/null +++ b/model-00211-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea9063ef62cc26563fe4f6d4b75e2095f8e949e5071377bb26c83e39a7efe212 +size 2401529096 diff --git a/model-00212-of-00341.safetensors b/model-00212-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6625444e810ce85e2c7352763cf3ca88301c8976 --- /dev/null +++ b/model-00212-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5b3f415e9d95029e79683d2313f3a5d4b388efec818f22585d6aac96a39a2db +size 3154458912 diff --git a/model-00213-of-00341.safetensors b/model-00213-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..e281e5d004293b1ea27105c7c83db7c3969b072d --- /dev/null +++ b/model-00213-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:986e7ee841caf57380fa1a56a7acd45eaa16e523cd3d893f4e3f0b96db2a2aec +size 3153288488 diff --git a/model-00214-of-00341.safetensors b/model-00214-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5e163ecc4e87c0d9f4e56225367aecb7f13c7268 --- /dev/null +++ b/model-00214-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff9bac37133c4462eed5a3fa1044c525c5a713d40065760d453fb06fcf748454 +size 2822748248 diff --git a/model-00215-of-00341.safetensors b/model-00215-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..792085a6f5550e3cc632c0544252747b02544c6f --- /dev/null +++ b/model-00215-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e28de296d3955fb4d206c45b08374715eb414e48d6e4c8ba02958ee9de207cd +size 3154458912 diff --git a/model-00216-of-00341.safetensors b/model-00216-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f89898244d6b4aa7d0225986bbe5b64448b7fbe4 --- /dev/null +++ b/model-00216-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2818f86174f60d0c2b1a49a416edf3a4dc7800373cce14e66b825c160741cb04 +size 3153288488 diff --git a/model-00217-of-00341.safetensors b/model-00217-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..26d50f1def2f41f9ac1ba3e7c1266b71d5bf483d --- /dev/null +++ b/model-00217-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9db97a91c9410682b6a459946faae189eb562668038a7f2283f901f573e7a64 +size 2822748248 diff --git a/model-00218-of-00341.safetensors b/model-00218-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..48ba02e48ce681fec28a917e47e0a12ed74854dd --- /dev/null +++ b/model-00218-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7b0d79e0cf813f3baa0acfb99e9bb253c68fac5acd5821c0fee13e9c14073a1 +size 3154458912 diff --git a/model-00219-of-00341.safetensors b/model-00219-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6c378817840caf5dc153321dd489a1655de7ab45 --- /dev/null +++ b/model-00219-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6028d6b6e7bcbbb232549879d6f03fa7134b9e4a29b489f81d833de9450cf40d +size 3153288488 diff --git a/model-00220-of-00341.safetensors b/model-00220-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7cb134715ecb76ae70690a09e646b893249ff80d --- /dev/null +++ b/model-00220-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a606335deaea97708ba0739ef8313309f19f0f2838f494c9d864a6fb3cb546b9 +size 2822748248 diff --git a/model-00221-of-00341.safetensors b/model-00221-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..850afe10eab23bd1681cb47f1f8468664a29c710 --- /dev/null +++ b/model-00221-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6abf90ad518515dfe76555212696ebf364545c675952d5768fc4c7dc7d6e931 +size 3152265592 diff --git a/model-00222-of-00341.safetensors b/model-00222-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..24d349c26901ef00e375dc233fcf4aeacdb9f4fd --- /dev/null +++ b/model-00222-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49317c58cf61e091de8e802d735ca23df4ec1bbf5a4c5d06657aadcbee8ea2aa +size 3153288400 diff --git a/model-00223-of-00341.safetensors b/model-00223-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3d006a0c9cce84256d18ed865ab8b0ccfd59f24f --- /dev/null +++ b/model-00223-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c6300885c2e74ee45558c164d1417b751e9108f9c0ac176897021d74ca1880e +size 2401529096 diff --git a/model-00224-of-00341.safetensors b/model-00224-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..5933fa510a1149d581e062515ec5b1ef2135d209 --- /dev/null +++ b/model-00224-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf74b6006198bc2d4f9ddb512e150d4764a21222653be213c2ce3dc588b43f86 +size 3154458912 diff --git a/model-00225-of-00341.safetensors b/model-00225-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..52ce400ca8819542015f791ee1c9f52b540a5c4a --- /dev/null +++ b/model-00225-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d49947906b8fd8a0d776a067281616bd5331d39b4e661b765dbe4deb9da9a270 +size 3153288488 diff --git a/model-00226-of-00341.safetensors b/model-00226-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..aac91907d9eecee9253814dfdb1a6c9d7d720693 --- /dev/null +++ b/model-00226-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d54eb2532b8474f185701c350046a80f58433423a270ad73730271638fa2f29 +size 2822748248 diff --git a/model-00227-of-00341.safetensors b/model-00227-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..37092d3f5ab998082f9de6d0c915fc8032e32ff9 --- /dev/null +++ b/model-00227-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eed4aa1a2dd5d5869b96b14cf6b6a690832226e507eb6b7f4ea75e215bf00ec4 +size 3154458912 diff --git a/model-00228-of-00341.safetensors b/model-00228-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..08fe46934f46ea66fc2e4d74313328fc10b2c384 --- /dev/null +++ b/model-00228-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0995afd0fe6732b36d782c255f48192b55491be7d609c3fcc77cccfae6ac27af +size 3153288488 diff --git a/model-00229-of-00341.safetensors b/model-00229-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f1ba44dc4e06b5e3b20dbf8400e6030cd2d51283 --- /dev/null +++ b/model-00229-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:566ce5783195b469b6df6486e35ced95eb4c0f5b04f0231bd33bdf1db37f55a3 +size 2822748248 diff --git a/model-00230-of-00341.safetensors b/model-00230-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7162450fe6fb3894c3f2eb380be196bbfd88be77 --- /dev/null +++ b/model-00230-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60e3d1f02b5f7e243213f7872c4d9a6431b4888bea965ecaefa4c67015cb04e1 +size 3154458912 diff --git a/model-00231-of-00341.safetensors b/model-00231-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..3189b43cc54477501ecb8341d7eb14d02d4e30f9 --- /dev/null +++ b/model-00231-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e37356b02b31d026bdc5797a3185cb48d5001a493e8de0a3f1fd2b6a0660e4c0 +size 3153288488 diff --git a/model-00232-of-00341.safetensors b/model-00232-of-00341.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f0730445fcadeb675a555922ccfec09be6c83546 --- /dev/null +++ b/model-00232-of-00341.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1dd752e4038841dd4007c7bce31c701485776ef2269c8082c444f6cf0eede0ce +size 2822748248