Skip to content

Commit bb08094

Browse files
kevalmorabia97claude
kevalmorabia97
and
claude
authored
Add Nemotron-Nano-9B-v2 → Pruned 7B e2e tutorial: Prune + Distill + Eval + Quantize + vLLM deployment (NVIDIA#1325)
## Summary End-to-end optimization walkthrough for Nemotron-Nano-9B-v2 showing how ModelOpt techniques stack: - **Pruning** — Minitron structured pruning 9B → 7B - **Distillation** — Megatron-Bridge knowledge distillation up to 80B tokens; near-parity with official 9B on MMLU Pro, GPQA, LCB, AIME, Math 500, IFEval, SciCode - **Evaluation** - using nemo-evaluator - **Quantization** — FP8 PTQ via \`hf_ptq.py\`; checkpoint deployable on vLLM/TRT-LLM/SGLang with no extra flags (quantization auto-detected from \`config.json\`) - **vLLM Throughput** — BF16 vs FP8 benchmark on single H100 <img width="2085" height="1740" alt="image" src="https://github.com/user-attachments/assets/8620a019-5c09-4a6b-a5d2-ca164aaa5d87" /> <img width="2085" height="810" alt="image" src="https://github.com/user-attachments/assets/742c8035-f1fb-4394-b11b-0c6c3ac4e843" /> ### Files changed - `examples/pruning/minitron/README.md` — index page for Minitron end-to-end tutorials - `examples/pruning/minitron/NVIDIA-Nemotron-Nano-9B-v2/README.md` — full repro doc with 6 sections: data prep, pruning, distillation, evaluation, FP8 quantization, vLLM benchmarking - `examples/pruning/minitron/NVIDIA-Nemotron-Nano-9B-v2/nemo_evaluator.yaml` — NeMo Evaluator config used for all benchmark numbers - `examples/pruning/puzzletron/README.md` — index page for Puzzletron distillation results - `examples/pruning/puzzletron/Llama-3.1-8B-Instruct.md` — Puzzletron distillation results (renamed from puzzletron.md) - `examples/pruning/README.md` — updated Results section with direct links to new locations - `examples/megatron_bridge/README.md` — updated results link to point to `examples/pruning/` - `examples/puzzletron/README.md` — updated distillation results link - `examples/dataset/MEGATRON_DATA_PREP.md` — tokenization commands for all datasets used in the data blend 🤖 Generated with [Claude Code](https://claude.com/claude-code) <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit ## Documentation * **New end-to-end tutorial** for model optimization covering Minitron pruning, knowledge distillation, FP8 quantization, and vLLM deployment with reproducibility steps and benchmark results * **Dataset preparation guide** with ready-to-run tokenization templates for Nemotron HuggingFace datasets * **Evaluation configuration** and results documentation including ablation studies across multiple benchmarks * **Updated navigation** across pruning, distillation, and dataset examples to streamline user workflows <!-- end of auto-generated comment: release notes by coderabbit.ai --> --------- Signed-off-by: Keval Morabia <28916987+kevalmorabia97@users.noreply.github.com> Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
1 parent 378366b commit bb08094

14 files changed

Lines changed: 911 additions & 93 deletions

File tree

‎CHANGELOG.rst‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@ Changelog
2525
**New Features**
2626

2727
- Support full Transformer Engine spec for Minitron pruning (``mcore_minitron``). Now we no longer need to use custom ModelOpt spec. Note that this does not affect the usage of the pruning workflow but makes pruning slightly faster and may result in slightly different pruned model because of different kernel and numerics.
28+
- Add end-to-end tutorial for Minitron pruning + distillation + quantization + evaluation + vLLM deployment for Nemotron-Nano-9B-v2 → Pruned 7B along with data blend preparation steps (and ablation study). See `examples/pruning/minitron/README.md <https://github.com/NVIDIA/Model-Optimizer/tree/main/examples/pruning/minitron/>`_ for details.
2829
- Add Puzzletron - a new algorithm for heterogeneous pruning of LLM and VLM models. See `examples/puzzletron/README.md <https://github.com/NVIDIA/Model-Optimizer/tree/main/examples/puzzletron>`_ for more details.
2930
- Added iterator interface using CalibrationDataReader in ONNX quantization workflow.
3031
- Add N:M sparse softmax support to the Triton flash attention kernel (``modelopt.torch.kernels.common.attention.triton_fa``). See `examples/llm_sparsity/attention_sparsity/README.md <https://github.com/NVIDIA/Model-Optimizer/tree/main/examples/llm_sparsity/attention_sparsity>`_ for usage.

‎examples/dataset/MEGATRON_DATA_PREP.md‎

Lines changed: 242 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,242 @@
1+
# Tokenizing for Megatron Frameworks
2+
3+
| **Section** | **Description** | **Link** |
4+
| :---: | :---: | :---: |
5+
| From JSONL files | Tokenize local JSONL files | \[[Link](#from-jsonl-files)\] |
6+
| From Hugging Face Hub | Stream or download HF datasets and tokenize | \[[Link](#from-hugging-face-hub)\] |
7+
| `reasoning_content` for Post-Training v3 | Control how chain-of-thought traces are handled | \[[Link](#reasoning_content-for-post-training-v3-datasets)\] |
8+
| Nemotron Pre/Post-Training Datasets | Ready-to-run commands for all Nemotron datasets | \[[Link](#ready-to-run-tokenization-commands)\] |
9+
10+
The distillation and pre-training scripts in Megatron-Bridge or Megatron-LM expect data pre-tokenized in Megatron's binary indexed format (`.bin` / `.idx`).
11+
Use the `megatron_preprocess_data` utility to tokenize any JSONL or Hugging Face dataset.
12+
The tokenization scripts below print the list of output prefixes (e.g. `tokenized_qwen3/data1_text`) that you can use for the `data_paths` argument (with relative weights on different files) in Megatron training scripts.
13+
14+
**Important Notes:**
15+
16+
- For Pretraining / raw-text data (`text` key) — use `--append_eod` so Megatron can tell where documents end when concatenating them into long sequences.
17+
- For Post-training chat data (`messages` key) — omit `--append_eod`; the chat template already appends EOS at the end of each conversation.
18+
- Set `--max_sequence_length 256_000` to avoid rare OOM errors if some text is very long.
19+
20+
## From JSONL files
21+
22+
```bash
23+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
24+
--jsonl_paths /path/to/data1.jsonl /path/to/data2.jsonl ... \
25+
--json_keys text \
26+
--tokenizer Qwen/Qwen3-0.6B \
27+
--output_dir tokenized_qwen3 \
28+
--workers 32 \
29+
--append_eod
30+
```
31+
32+
```bash
33+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
34+
--jsonl_paths /path/to/sft_data.jsonl \
35+
--json_keys messages \
36+
--tokenizer Qwen/Qwen3-0.6B \
37+
--output_dir tokenized_qwen3 \
38+
--workers 32
39+
```
40+
41+
Instead of `--jsonl_paths`, pass `--input_dir /path/to/dir` to tokenize all JSONL files in a directory (`.jsonl` and `.jsonl.gz` are both supported).
42+
43+
## From Hugging Face Hub
44+
45+
To tokenize a dataset directly from Hugging Face Hub:
46+
47+
```bash
48+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
49+
--hf_dataset nvidia/Nemotron-Pretraining-SFT-v1 \
50+
--hf_name Nemotron-SFT-Code \
51+
--hf_split train \
52+
--hf_max_samples_per_split 10_000_000 \
53+
--json_keys text \
54+
--tokenizer Qwen/Qwen3-0.6B \
55+
--output_dir tokenized_qwen3 \
56+
--workers 32 \
57+
--append_eod
58+
```
59+
60+
Omit `--hf_name` to process all subsets, `--hf_split` for all splits, or `--hf_max_samples_per_split` for all samples.
61+
To quickly test, use [nvidia/Nemotron-Pretraining-Dataset-sample](https://huggingface.co/datasets/nvidia/Nemotron-Pretraining-Dataset-sample).
62+
63+
For very large datasets (tens of millions of documents), or datasets with complex nested message schemas (e.g. `tool_calls`, `function_call` fields) that cause Arrow type-cast errors in non-streaming mode, add `--hf_streaming` to avoid downloading the full dataset — only the rows actually consumed are fetched. Optionally pair with `--hf_max_samples_per_split <num_samples>` to cap the row count; without it streaming still works but re-downloads on every run with no disk cache.
64+
65+
> **Performance note:** Non-streaming mode downloads all Parquet shards once and caches them as Arrow files on disk.
66+
> Re-runs read from cache and are much faster.
67+
> Streaming re-downloads on every run with no cache, so it is slower for full-dataset processing.
68+
69+
## `reasoning_content` for Post-Training v3 Datasets
70+
71+
v3 datasets include a `reasoning_content` field in assistant messages (chain-of-thought separate from
72+
the final answer). Use `--reasoning_content` to control how it is handled:
73+
74+
| Value | Behaviour |
75+
| --- | --- |
76+
| `strip` (default) | Field is discarded before `apply_chat_template`. Safe for any tokenizer. |
77+
| `inline` | Wrapped as `<think>…</think>` and prepended to `content`. Preserves reasoning in a tokenizer-agnostic way. |
78+
| `native` | Passed unchanged. Requires the tokenizer's chat template to handle the field (e.g. Qwen3). |
79+
80+
```bash
81+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
82+
--hf_dataset nvidia/Nemotron-Math-v2 \
83+
--hf_split high_part00 \
84+
--json_keys messages \
85+
--tokenizer nvidia/NVIDIA-Nemotron-Nano-9B-v2 \
86+
--output_dir tokenized_nemotron_v2 \
87+
--workers 32 \
88+
--reasoning_content inline
89+
```
90+
91+
---
92+
93+
## Ready-to-run tokenization commands
94+
95+
Tokenization commands for all Nemotron Pre-Training and Post-Training datasets used in Megatron-Bridge distillation experiments.
96+
97+
Two parameters vary by model — set them before running the commands below:
98+
99+
```bash
100+
TOKENIZER=nvidia/NVIDIA-Nemotron-Nano-9B-v2 # HuggingFace tokenizer (or local path)
101+
OUTPUT_DIR=tokenized_nemotron_v2 # Output directory for tokenized files
102+
```
103+
104+
> [!TIP]
105+
> Token count for a `.bin` file = file size in bytes ÷ 4. This is also printed by the tokenization script on completion.
106+
107+
> [!NOTE]
108+
> Tokenizing each of the datasets below will take anywhere between 10 minutes to few hours. You can tokenize all in parallel to speed up the process.
109+
>
110+
> You may tokenize more datasets or skip some datasets depending on your needs.
111+
112+
### Nemotron Pretraining dataset
113+
114+
**[nvidia/Nemotron-Pretraining-SFT-v1](https://huggingface.co/datasets/nvidia/Nemotron-Pretraining-SFT-v1)** — raw text; omitting `--hf_name` tokenizes all 3 subsets (Code, General, MATH) in one command, producing a separate output file per subset named after each:
115+
116+
```bash
117+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
118+
--hf_dataset nvidia/Nemotron-Pretraining-SFT-v1 \
119+
--hf_split train \
120+
--hf_streaming \
121+
--hf_max_samples_per_split 10_000_000 \
122+
--json_keys text \
123+
--tokenizer ${TOKENIZER} \
124+
--output_dir ${OUTPUT_DIR} \
125+
--workers 96 \
126+
--max_sequence_length 256_000 \
127+
--append_eod \
128+
--strip_newlines
129+
```
130+
131+
---
132+
133+
### Nemotron Post-training v1 dataset
134+
135+
**[nvidia/Nemotron-Post-Training-Dataset-v1](https://huggingface.co/datasets/nvidia/Nemotron-Post-Training-Dataset-v1)** — STEM subset, capped at 5M samples. v1 data does not contain reasoning traces:
136+
137+
```bash
138+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
139+
--hf_dataset nvidia/Nemotron-Post-Training-Dataset-v1 \
140+
--hf_name default \
141+
--hf_split stem \
142+
--hf_streaming \
143+
--hf_max_samples_per_split 5_000_000 \
144+
--json_keys messages \
145+
--tokenizer ${TOKENIZER} \
146+
--output_dir ${OUTPUT_DIR} \
147+
--workers 96 \
148+
--max_sequence_length 256_000
149+
```
150+
151+
---
152+
153+
### Nemotron Post-training v3 collection
154+
155+
Datasets below are from the [Nemotron Post-Training v3 collection](https://huggingface.co/collections/nvidia/nemotron-post-training-v3). All use `--reasoning_content inline` to preserve `<think>…</think>` traces. The collection contains many more datasets — if you care about benchmarks not covered here (e.g. multilingual, agentic/tool use, SWE, safety), pick the relevant datasets from the collection and tokenize them the same way.
156+
157+
**[nvidia/Nemotron-Math-v2](https://huggingface.co/datasets/nvidia/Nemotron-Math-v2)** — tokenize `high_part00` and `high_part01` separately:
158+
159+
```bash
160+
for SPLIT in high_part00 high_part01; do
161+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
162+
--hf_dataset nvidia/Nemotron-Math-v2 \
163+
--hf_split ${SPLIT} \
164+
--json_keys messages \
165+
--tokenizer ${TOKENIZER} \
166+
--output_dir ${OUTPUT_DIR} \
167+
--workers 96 \
168+
--max_sequence_length 256_000 \
169+
--reasoning_content inline
170+
done
171+
```
172+
173+
**[nvidia/Nemotron-SFT-Competitive-Programming-v2](https://huggingface.co/datasets/nvidia/Nemotron-SFT-Competitive-Programming-v2)** — stored as raw JSONL on HuggingFace, download before tokenizing:
174+
175+
```bash
176+
hf download nvidia/Nemotron-SFT-Competitive-Programming-v2 \
177+
--repo-type dataset \
178+
--local-dir datasets/Nemotron-SFT-Competitive-Programming-v2/
179+
for FILE in competitive_programming_python_00 competitive_programming_cpp_00; do
180+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
181+
--jsonl_paths datasets/Nemotron-SFT-Competitive-Programming-v2/data/${FILE}.jsonl \
182+
--json_keys messages \
183+
--tokenizer ${TOKENIZER} \
184+
--output_dir ${OUTPUT_DIR} \
185+
--workers 96 \
186+
--max_sequence_length 256_000 \
187+
--reasoning_content inline
188+
done
189+
```
190+
191+
**[nvidia/Nemotron-Science-v1](https://huggingface.co/datasets/nvidia/Nemotron-Science-v1)** — stored as raw JSONL on HuggingFace, download before tokenizing:
192+
193+
```bash
194+
hf download nvidia/Nemotron-Science-v1 \
195+
--repo-type dataset \
196+
--local-dir datasets/Nemotron-Science-v1/
197+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
198+
--input_dir datasets/Nemotron-Science-v1/data/ \
199+
--json_keys messages \
200+
--tokenizer ${TOKENIZER} \
201+
--output_dir ${OUTPUT_DIR} \
202+
--workers 96 \
203+
--max_sequence_length 256_000 \
204+
--reasoning_content inline
205+
```
206+
207+
**[nvidia/Nemotron-SFT-Instruction-Following-Chat-v2](https://huggingface.co/datasets/nvidia/Nemotron-SFT-Instruction-Following-Chat-v2)** — stored as raw JSONL on HuggingFace, download before tokenizing:
208+
209+
```bash
210+
hf download nvidia/Nemotron-SFT-Instruction-Following-Chat-v2 \
211+
--repo-type dataset \
212+
--local-dir datasets/Nemotron-SFT-Instruction-Following-Chat-v2/
213+
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
214+
--input_dir datasets/Nemotron-SFT-Instruction-Following-Chat-v2/data/ \
215+
--json_keys messages \
216+
--tokenizer ${TOKENIZER} \
217+
--output_dir ${OUTPUT_DIR} \
218+
--workers 96 \
219+
--max_sequence_length 256_000 \
220+
--reasoning_content inline
221+
```
222+
223+
---
224+
225+
### Expected output
226+
227+
After running all commands above, `${OUTPUT_DIR}/` should contain the following `.bin` / `.idx` file pairs:
228+
229+
```text
230+
nvidia--Nemotron-Pretraining-SFT-v1_Nemotron-SFT-Code_train_text_max10000000.{bin,idx}
231+
nvidia--Nemotron-Pretraining-SFT-v1_Nemotron-SFT-General_train_text_max10000000.{bin,idx}
232+
nvidia--Nemotron-Pretraining-SFT-v1_Nemotron-SFT-MATH_train_text_max10000000.{bin,idx}
233+
nvidia--Nemotron-Post-Training-Dataset-v1_default_stem_messages_max5000000.{bin,idx}
234+
nvidia--Nemotron-Math-v2_default_high_part00_messages.{bin,idx}
235+
nvidia--Nemotron-Math-v2_default_high_part01_messages.{bin,idx}
236+
competitive_programming_python_00_messages.{bin,idx}
237+
competitive_programming_cpp_00_messages.{bin,idx}
238+
MCQ_messages.{bin,idx}
239+
RQA_messages.{bin,idx}
240+
reasoning_off_messages.{bin,idx}
241+
reasoning_on_messages.{bin,idx}
242+
```

‎examples/dataset/README.md‎

Lines changed: 2 additions & 80 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
| **Section** | **Description** | **Link** |
66
| :------------: | :------------: | :------------: |
77
| Building Chat Datasets | Scripts to build conversation datasets from Nemotron and other HuggingFace sources | \[[Link](#building-chat-datasets)\] |
8-
| Tokenizing for Megatron Frameworks | Convert JSONL or HF datasets to Megatron binary format for distillation and pre-training | \[[Link](#tokenizing-for-megatron-frameworks)\] |
8+
| Tokenizing for Megatron Frameworks | Convert JSONL or HF datasets to Megatron binary format for distillation and pre-training | \[[Link](MEGATRON_DATA_PREP.md)\] |
99

1010
</div>
1111

@@ -140,85 +140,7 @@ In `generate` mode, assistant turns are stripped so the row ends with a user tur
140140

141141
## Tokenizing for Megatron Frameworks
142142

143-
The distillation and pre-training scripts in Megatron-Bridge or Megatron-LM expect data pre-tokenized in Megatron's binary indexed format (`.bin` / `.idx`).
144-
Use the `megatron_preprocess_data` utility to tokenize any JSONL or Hugging Face dataset.
145-
The tokenization scripts below prints the list of output prefixes (e.g. `tokenized_qwen3/data1_text`) that you can use for the `data_paths` argument (with relative weights on different files) in Megatron training scripts.
146-
147-
**Important Notes:**
148-
149-
- For Pretraining / raw-text data (`text` key) — use `--append_eod` so Megatron can tell where documents end when concatenating them into long sequences.
150-
- For Post-training chat data (`messages` key) — omit `--append_eod`; the chat template already appends EOS at the end of each conversation.
151-
- Set `--max_sequence_length 256_000` to avoid rare OOM errors if some text is very long.
152-
153-
### From JSONL files
154-
155-
```bash
156-
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
157-
--jsonl_paths /path/to/data1.jsonl /path/to/data2.jsonl ... \
158-
--json_keys text \
159-
--tokenizer Qwen/Qwen3-0.6B \
160-
--output_dir tokenized_qwen3 \
161-
--workers 32 \
162-
--append_eod
163-
```
164-
165-
```bash
166-
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
167-
--jsonl_paths /path/to/sft_data.jsonl \
168-
--json_keys messages \
169-
--tokenizer Qwen/Qwen3-0.6B \
170-
--output_dir tokenized_qwen3 \
171-
--workers 32
172-
```
173-
174-
Instead of `--jsonl_paths`, pass `--input_dir /path/to/dir` to tokenize all JSONL files in a directory (`.jsonl` and `.jsonl.gz` are both supported).
175-
176-
### From Hugging Face Hub
177-
178-
To tokenize a dataset directly from Hugging Face Hub:
179-
180-
```bash
181-
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
182-
--hf_dataset nvidia/Nemotron-Pretraining-SFT-v1 \
183-
--hf_name Nemotron-SFT-Code \
184-
--hf_split train \
185-
--hf_max_samples_per_split 10_000_000 \
186-
--json_keys text \
187-
--tokenizer Qwen/Qwen3-0.6B \
188-
--output_dir tokenized_qwen3 \
189-
--workers 32 \
190-
--append_eod
191-
```
192-
193-
Omit `--hf_name` to process all subsets, `--hf_split` for all splits, or `--hf_max_samples_per_split` for all samples.
194-
To quickly test, use [nvidia/Nemotron-Pretraining-Dataset-sample](https://huggingface.co/datasets/nvidia/Nemotron-Pretraining-Dataset-sample).
195-
196-
For **very large datasets** (tens of millions of documents), add `--hf_streaming --hf_max_samples_per_split <num_samples>` to avoid downloading the full dataset — only the rows actually consumed are fetched.
197-
198-
> **Performance note:** Non-streaming mode downloads all Parquet shards once and caches them as Arrow files on disk.
199-
> Re-runs read from cache and are much faster.
200-
> Streaming re-downloads on every run with no cache, so it is slower for full-dataset processing.
201-
202-
### Nemotron Post-Training v3 (`reasoning_content`)
203-
204-
v3 datasets include a `reasoning_content` field in assistant messages (chain-of-thought separate from
205-
the final answer). Use `--reasoning_content` to control how it is handled:
206-
207-
| Value | Behaviour |
208-
| --- | --- |
209-
| `strip` (default) | Field is discarded before `apply_chat_template`. Safe for any tokenizer. |
210-
| `inline` | Wrapped as `<think>…</think>` and prepended to `content`. Preserves reasoning in a tokenizer-agnostic way. |
211-
| `native` | Passed unchanged. Requires the tokenizer's chat template to handle the field (e.g. Qwen3). |
212-
213-
```bash
214-
python -m modelopt.torch.utils.plugins.megatron_preprocess_data \
215-
--hf_dataset nvidia/Nemotron-Post-Training-Dataset-v3 \
216-
--json_keys messages \
217-
--tokenizer Qwen/Qwen3-0.6B \
218-
--output_dir tokenized_qwen3 \
219-
--workers 32 \
220-
--reasoning_content inline
221-
```
143+
See **[MEGATRON_DATA_PREP.md](MEGATRON_DATA_PREP.md)** for full documentation: general usage with JSONL and Hugging Face Hub datasets, handling of Nemotron Post-Training v3 `reasoning_content` fields, and ready-to-run tokenization commands for all Nemotron Pre/Post-Training datasets.
222144

223145
## Synthetic Test Dataset
224146

‎examples/megatron_bridge/README.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ hf auth login --token <your token>
4747
```
4848

4949
> [!WARNING]
50-
> Use `python -m pip` instead of `pip` to avoid conflicts with the system-wide installed packages in the NeMo containers.
50+
> Use `python -m pip` instead of `pip` to avoid conflicts with the system-wide installed packages in the NeMo containers. You may also refer to this [doc](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/docker/common/README.md#installing-packages-inside-the-container) on how to correctly install packages in the NeMo containers without breaking existing torch installation.
5151
5252
## Pruning
5353

@@ -189,7 +189,7 @@ For more details, see the [Megatron-Bridge conversion README](https://github.com
189189

190190
### Distillation Results
191191

192-
See [results/puzzletron.md](results/puzzletron.md) for MMLU results demonstrating knowledge distillation on Puzzletron-compressed student models.
192+
See [examples/pruning/](../pruning/README.md#tutorials--results) for distillation experiment results covering Minitron and Puzzletron pruning algorithms.
193193

194194
## Post-Training Quantization
195195

0 commit comments

Comments
 (0)