pytorch-precision-converter 2.0.0__tar.gz

pytorch_precision_converter-2.0.0/LICENSE

@@ -0,0 +1,9 @@
+# MIT License
+
+Copyright (c) 2023 Angelo Lamonaca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pytorch_precision_converter-2.0.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: pytorch-precision-converter
+Version: 2.0.0
+Summary: Convert PyTorch checkpoints and safetensors files to fp16, bf16 or fp8 without breaking them.
+Author: Angelo Lamonaca
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/angelolamonaca/PyTorch-Precision-Converter
+Project-URL: Issues, https://github.com/angelolamonaca/PyTorch-Precision-Converter/issues
+Project-URL: Changelog, https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/CHANGELOG.md
+Keywords: pytorch,safetensors,fp16,bf16,fp8,checkpoint,quantization,stable-diffusion,ema
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1
+Requires-Dist: safetensors>=0.4.3
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# PyTorch Precision Converter
+
+[![PyPI](https://img.shields.io/pypi/v/pytorch-precision-converter)](https://pypi.org/project/pytorch-precision-converter/)
+[![Tests](https://github.com/angelolamonaca/PyTorch-Precision-Converter/actions/workflows/ci.yml/badge.svg)](https://github.com/angelolamonaca/PyTorch-Precision-Converter/actions/workflows/ci.yml)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+![PyTorch](https://img.shields.io/badge/PyTorch-2.1%2B-orange)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/LICENSE)
+
+Make PyTorch checkpoints and `safetensors` files **half the size (a quarter with fp8)** by converting them to
+`fp16`, `bf16` or `fp8`, and strip the EMA weights you don't need for inference. One command, no model code
+needed, runs on the CPU.
+
+```console
+$ precision-convert model.ckpt -p fp16 -t ema-only -st
+Converted 280 tensors to fp16, left 1 unchanged, dropped 242 EMA entries
+Used the EMA weights for 240 tensors
+Saved model-ema-only-fp16.safetensors (29.93 MB, 27% of 109.23 MB)
+```
+
+## Why not just call `.half()`?
+
+A one-line cast quietly breaks things. This tool handles the details:
+
+- **Only floating-point tensors are cast.** Integer and bool tensors like `position_ids` or step counters keep
+  their dtype instead of turning into floats.
+- **No silent `inf` or `NaN`.** fp16 tops out at 65,504 and fp8 at 448. Values beyond the range are clamped
+  to it and you get a warning, rather than infinities appearing in your weights.
+- **Real EMA extraction.** `-t ema-only` puts the EMA weights where the model loads them from, for Stable
+  Diffusion and other latent-diffusion checkpoints (`model_ema.*`), then drops the duplicates.
+- **safetensors metadata survives.** LoRA training info (`ss_*` keys) and other metadata is copied to the output.
+- **Safe by default.** PyTorch checkpoints load with `weights_only=True`, so a malicious `.ckpt` can't run code.
+  Files that need full unpickling require an explicit `--unsafe-load`.
+- **Your files are safe too.** Output is written to a temporary file and moved into place when complete, the
+  input is never replaced, and existing files are only overwritten with `--overwrite`.
+- **Mixed precision when you need it.** `--keep-original "first_stage_model.*"` keeps matching tensors (here the
+  VAE) in their original dtype.
+
+## Install
+
+```bash
+pip install pytorch-precision-converter
+```
+
+For the latest unreleased changes, install from GitHub instead:
+`pip install git+https://github.com/angelolamonaca/PyTorch-Precision-Converter`.
+
+Either way you get the `precision-convert` command (`python -m precision_converter` works too). It needs Python 3.9+,
+PyTorch 2.1+ and `safetensors`.
+
+## Usage
+
+```bash
+precision-convert INPUT [-p PRECISION] [-t TYPE] [-st] [-o OUTPUT] [options]
+```
+
+| Option | What it does |
+|---|---|
+| `INPUT` | `.safetensors` file or PyTorch checkpoint (`.ckpt`, `.pt`, `.pth`, `.bin`). `-f INPUT` works too. |
+| `-p`, `--precision` | `fp32`, `fp16`, `bf16`, `fp8_e4m3fn`, `fp8_e5m2`, or `keep` (default: change no dtypes). |
+| `-t`, `--type` | `full` keeps everything (default). `ema-only` uses the EMA weights. `no-ema` drops the EMA weights. |
+| `-st`, `--safe-tensors` | Save as `.safetensors` instead of a PyTorch `.ckpt`. |
+| `-o`, `--output` | Output path; its extension picks the format. Default: `<input>-<type>-<precision>` next to the input. |
+| `--keep-original PATTERN` | Leave tensors whose key matches the glob in their original dtype. Repeatable. |
+| `--info` | Show the tensors, dtypes, sizes, EMA and metadata in the file, then exit. |
+| `--unsafe-load` | Fully unpickle PyTorch checkpoints. Only for files you trust. |
+| `--overwrite` | Replace the output file if it exists. |
+| `-v`, `--verbose` | List each tensor that had values clamped. |
+
+## Recipes
+
+**Shrink a Stable Diffusion training checkpoint for inference** (EMA weights, fp16, safetensors):
+
+```bash
+precision-convert model.ckpt -p fp16 -t ema-only -st
+```
+
+**Convert a LoRA to fp16 and keep its training metadata:**
+
+```bash
+precision-convert my-lora.safetensors -p fp16 -o my-lora-fp16.safetensors
+```
+
+**Store a large model in fp8** for UIs that load fp8 weights, such as ComfyUI, keeping normalization layers
+precise:
+
+```bash
+precision-convert model.safetensors -p fp8_e4m3fn -st --keep-original "*norm*"
+```
+
+**Keep the VAE in fp32** (fp16 VAEs can produce NaNs and black images in some models):
+
+```bash
+precision-convert model.safetensors -p fp16 -st --keep-original "first_stage_model.*"
+```
+
+**Turn a pickled checkpoint into safetensors without changing precision:**
+
+```bash
+precision-convert model.ckpt -st
+```
+
+**Check what's inside a file before converting:**
+
+```console
+$ precision-convert model.ckpt --info
+model.ckpt: 523 tensors, 27,274,319 values, 109.10 MB
+  float32              521 tensors   109.10 MB
+  int64                  1 tensor        616 B
+  int32                  1 tensor          4 B
+  EMA: 242 model_ema.* tensors (-t ema-only or -t no-ema removes them)
+```
+
+## Which precision should I pick?
+
+| Precision | Bytes per value | Largest value | Good for |
+|---|---|---|---|
+| `fp32` | 4 | 3.4 × 10³⁸ | Training, reference copies, upcasting half-precision files |
+| `bf16` | 2 | 3.4 × 10³⁸ | The safe 2-byte choice: same range as fp32, so nothing overflows |
+| `fp16` | 2 | 65,504 | GPUs without fast bf16, and tools that expect fp16 |
+| `fp8_e4m3fn` | 1 | 448 | Smallest files, for inference in tools that load fp8 weights; some quality loss |
+| `fp8_e5m2` | 1 | 57,344 | fp8 with more range and less precision than `e4m3fn` |
+
+The fp8 options cast each value directly, without per-tensor scaling factors.
+
+## Python API
+
+```python
+from precision_converter import convert_state_dict, load_checkpoint, save_checkpoint
+
+state_dict, metadata = load_checkpoint("model.safetensors")
+converted, report = convert_state_dict(state_dict, precision="bf16", conversion="no-ema")
+save_checkpoint(converted, "model-bf16.safetensors", metadata=metadata)
+
+print(f"{report.converted} tensors converted, {len(report.clamped)} had values clamped")
+```
+
+`convert_state_dict` takes any mapping of tensors, so `model.state_dict()` works too.
+
+## Upgrading from 1.x
+
+`python convert.py ...` still works, but 2.0 fixes bugs that changed what earlier versions wrote:
+
+- `-t ema-only` used to keep the regular weights and store the EMA weights under keys no model loads. It now
+  outputs the actual EMA weights.
+- Integer tensors are no longer cast to floating point, and overflowing values are clamped instead of
+  becoming `inf`.
+- The default precision is now `keep`. `-p fp32` used to change nothing; it now converts fp16 and bf16 tensors
+  to fp32. With the default precision the output name no longer ends in `-fp32`.
+- Checkpoints are loaded with `weights_only=True`. Use `--unsafe-load` for trusted files that need more.
+- Existing output files are no longer overwritten unless you pass `--overwrite`.
+
+See [CHANGELOG.md](https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/CHANGELOG.md) for details.
+
+## Contributing
+
+Issues and pull requests are welcome. To run the tests:
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT. See [LICENSE](https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/LICENSE).

pytorch_precision_converter-2.0.0/README.md

@@ -0,0 +1,165 @@
+# PyTorch Precision Converter
+
+[![PyPI](https://img.shields.io/pypi/v/pytorch-precision-converter)](https://pypi.org/project/pytorch-precision-converter/)
+[![Tests](https://github.com/angelolamonaca/PyTorch-Precision-Converter/actions/workflows/ci.yml/badge.svg)](https://github.com/angelolamonaca/PyTorch-Precision-Converter/actions/workflows/ci.yml)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+![PyTorch](https://img.shields.io/badge/PyTorch-2.1%2B-orange)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/LICENSE)
+
+Make PyTorch checkpoints and `safetensors` files **half the size (a quarter with fp8)** by converting them to
+`fp16`, `bf16` or `fp8`, and strip the EMA weights you don't need for inference. One command, no model code
+needed, runs on the CPU.
+
+```console
+$ precision-convert model.ckpt -p fp16 -t ema-only -st
+Converted 280 tensors to fp16, left 1 unchanged, dropped 242 EMA entries
+Used the EMA weights for 240 tensors
+Saved model-ema-only-fp16.safetensors (29.93 MB, 27% of 109.23 MB)
+```
+
+## Why not just call `.half()`?
+
+A one-line cast quietly breaks things. This tool handles the details:
+
+- **Only floating-point tensors are cast.** Integer and bool tensors like `position_ids` or step counters keep
+  their dtype instead of turning into floats.
+- **No silent `inf` or `NaN`.** fp16 tops out at 65,504 and fp8 at 448. Values beyond the range are clamped
+  to it and you get a warning, rather than infinities appearing in your weights.
+- **Real EMA extraction.** `-t ema-only` puts the EMA weights where the model loads them from, for Stable
+  Diffusion and other latent-diffusion checkpoints (`model_ema.*`), then drops the duplicates.
+- **safetensors metadata survives.** LoRA training info (`ss_*` keys) and other metadata is copied to the output.
+- **Safe by default.** PyTorch checkpoints load with `weights_only=True`, so a malicious `.ckpt` can't run code.
+  Files that need full unpickling require an explicit `--unsafe-load`.
+- **Your files are safe too.** Output is written to a temporary file and moved into place when complete, the
+  input is never replaced, and existing files are only overwritten with `--overwrite`.
+- **Mixed precision when you need it.** `--keep-original "first_stage_model.*"` keeps matching tensors (here the
+  VAE) in their original dtype.
+
+## Install
+
+```bash
+pip install pytorch-precision-converter
+```
+
+For the latest unreleased changes, install from GitHub instead:
+`pip install git+https://github.com/angelolamonaca/PyTorch-Precision-Converter`.
+
+Either way you get the `precision-convert` command (`python -m precision_converter` works too). It needs Python 3.9+,
+PyTorch 2.1+ and `safetensors`.
+
+## Usage
+
+```bash
+precision-convert INPUT [-p PRECISION] [-t TYPE] [-st] [-o OUTPUT] [options]
+```
+
+| Option | What it does |
+|---|---|
+| `INPUT` | `.safetensors` file or PyTorch checkpoint (`.ckpt`, `.pt`, `.pth`, `.bin`). `-f INPUT` works too. |
+| `-p`, `--precision` | `fp32`, `fp16`, `bf16`, `fp8_e4m3fn`, `fp8_e5m2`, or `keep` (default: change no dtypes). |
+| `-t`, `--type` | `full` keeps everything (default). `ema-only` uses the EMA weights. `no-ema` drops the EMA weights. |
+| `-st`, `--safe-tensors` | Save as `.safetensors` instead of a PyTorch `.ckpt`. |
+| `-o`, `--output` | Output path; its extension picks the format. Default: `<input>-<type>-<precision>` next to the input. |
+| `--keep-original PATTERN` | Leave tensors whose key matches the glob in their original dtype. Repeatable. |
+| `--info` | Show the tensors, dtypes, sizes, EMA and metadata in the file, then exit. |
+| `--unsafe-load` | Fully unpickle PyTorch checkpoints. Only for files you trust. |
+| `--overwrite` | Replace the output file if it exists. |
+| `-v`, `--verbose` | List each tensor that had values clamped. |
+
+## Recipes
+
+**Shrink a Stable Diffusion training checkpoint for inference** (EMA weights, fp16, safetensors):
+
+```bash
+precision-convert model.ckpt -p fp16 -t ema-only -st
+```
+
+**Convert a LoRA to fp16 and keep its training metadata:**
+
+```bash
+precision-convert my-lora.safetensors -p fp16 -o my-lora-fp16.safetensors
+```
+
+**Store a large model in fp8** for UIs that load fp8 weights, such as ComfyUI, keeping normalization layers
+precise:
+
+```bash
+precision-convert model.safetensors -p fp8_e4m3fn -st --keep-original "*norm*"
+```
+
+**Keep the VAE in fp32** (fp16 VAEs can produce NaNs and black images in some models):
+
+```bash
+precision-convert model.safetensors -p fp16 -st --keep-original "first_stage_model.*"
+```
+
+**Turn a pickled checkpoint into safetensors without changing precision:**
+
+```bash
+precision-convert model.ckpt -st
+```
+
+**Check what's inside a file before converting:**
+
+```console
+$ precision-convert model.ckpt --info
+model.ckpt: 523 tensors, 27,274,319 values, 109.10 MB
+  float32              521 tensors   109.10 MB
+  int64                  1 tensor        616 B
+  int32                  1 tensor          4 B
+  EMA: 242 model_ema.* tensors (-t ema-only or -t no-ema removes them)
+```
+
+## Which precision should I pick?
+
+| Precision | Bytes per value | Largest value | Good for |
+|---|---|---|---|
+| `fp32` | 4 | 3.4 × 10³⁸ | Training, reference copies, upcasting half-precision files |
+| `bf16` | 2 | 3.4 × 10³⁸ | The safe 2-byte choice: same range as fp32, so nothing overflows |
+| `fp16` | 2 | 65,504 | GPUs without fast bf16, and tools that expect fp16 |
+| `fp8_e4m3fn` | 1 | 448 | Smallest files, for inference in tools that load fp8 weights; some quality loss |
+| `fp8_e5m2` | 1 | 57,344 | fp8 with more range and less precision than `e4m3fn` |
+
+The fp8 options cast each value directly, without per-tensor scaling factors.
+
+## Python API
+
+```python
+from precision_converter import convert_state_dict, load_checkpoint, save_checkpoint
+
+state_dict, metadata = load_checkpoint("model.safetensors")
+converted, report = convert_state_dict(state_dict, precision="bf16", conversion="no-ema")
+save_checkpoint(converted, "model-bf16.safetensors", metadata=metadata)
+
+print(f"{report.converted} tensors converted, {len(report.clamped)} had values clamped")
+```
+
+`convert_state_dict` takes any mapping of tensors, so `model.state_dict()` works too.
+
+## Upgrading from 1.x
+
+`python convert.py ...` still works, but 2.0 fixes bugs that changed what earlier versions wrote:
+
+- `-t ema-only` used to keep the regular weights and store the EMA weights under keys no model loads. It now
+  outputs the actual EMA weights.
+- Integer tensors are no longer cast to floating point, and overflowing values are clamped instead of
+  becoming `inf`.
+- The default precision is now `keep`. `-p fp32` used to change nothing; it now converts fp16 and bf16 tensors
+  to fp32. With the default precision the output name no longer ends in `-fp32`.
+- Checkpoints are loaded with `weights_only=True`. Use `--unsafe-load` for trusted files that need more.
+- Existing output files are no longer overwritten unless you pass `--overwrite`.
+
+See [CHANGELOG.md](https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/CHANGELOG.md) for details.
+
+## Contributing
+
+Issues and pull requests are welcome. To run the tests:
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT. See [LICENSE](https://github.com/angelolamonaca/PyTorch-Precision-Converter/blob/main/LICENSE).

pytorch_precision_converter-2.0.0/precision_converter/__init__.py

@@ -0,0 +1,27 @@
+"""Convert the tensor precision of PyTorch checkpoints and safetensors files."""
+
+__version__ = "2.0.0"
+
+from .core import (  # noqa: E402
+    CONVERSION_TYPES,
+    PRECISIONS,
+    CheckpointInfo,
+    ConversionReport,
+    UnsafeCheckpointError,
+    convert_state_dict,
+    describe,
+    load_checkpoint,
+    save_checkpoint,
+)
+
+__all__ = [
+    "CONVERSION_TYPES",
+    "PRECISIONS",
+    "CheckpointInfo",
+    "ConversionReport",
+    "UnsafeCheckpointError",
+    "convert_state_dict",
+    "describe",
+    "load_checkpoint",
+    "save_checkpoint",
+]

pytorch_precision_converter-2.0.0/precision_converter/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

pytorch_precision_converter-2.0.0/precision_converter/cli.py

@@ -0,0 +1,181 @@
+"""Command-line interface: ``precision-convert``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import torch
+
+from . import __version__
+from .core import (
+    CONVERSION_TYPES,
+    PRECISIONS,
+    UnsafeCheckpointError,
+    convert_state_dict,
+    describe,
+    load_checkpoint,
+    save_checkpoint,
+)
+
+EXAMPLES = """\
+examples:
+  precision-convert model.safetensors -p fp16 -st
+  precision-convert sd-model.ckpt -p fp16 -t ema-only -st
+  precision-convert lora.safetensors -p bf16 -o lora-bf16.safetensors
+  precision-convert flux.safetensors -p fp8_e4m3fn -st --keep-original "*norm*"
+  precision-convert model.ckpt --info
+"""
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="precision-convert",
+        description="Convert the tensor precision of PyTorch checkpoints and safetensors files.",
+        epilog=EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "input", nargs="?", help="Model file: .safetensors or a PyTorch checkpoint (.ckpt, .pt, .pth, .bin)."
+    )
+    parser.add_argument("-f", "--file", help="Same as INPUT, kept for compatibility with 1.x.")
+    parser.add_argument(
+        "-p",
+        "--precision",
+        default="keep",
+        choices=PRECISIONS,
+        help="Target precision for floating-point tensors (default: keep, which changes no dtype).",
+    )
+    parser.add_argument(
+        "-t",
+        "--type",
+        default="full",
+        choices=CONVERSION_TYPES,
+        help="full: keep everything (default). ema-only: use the EMA weights and drop the EMA copies. "
+        "no-ema: drop the EMA copies.",
+    )
+    parser.add_argument(
+        "-st", "--safe-tensors", action="store_true", help="Save in safetensors format (default: PyTorch .ckpt)."
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Output path. Its extension picks the format (.safetensors or anything else for PyTorch). "
+        "Default: <input>-<type>-<precision> next to the input.",
+    )
+    parser.add_argument(
+        "--keep-original",
+        metavar="PATTERN",
+        action="append",
+        default=[],
+        help='Leave tensors whose key matches this glob in their original dtype, e.g. "first_stage_model.*". '
+        "Repeatable.",
+    )
+    parser.add_argument("--overwrite", action="store_true", help="Replace the output file if it already exists.")
+    parser.add_argument(
+        "--unsafe-load",
+        action="store_true",
+        help="Load PyTorch checkpoints with full unpickling (weights_only=False). Unpickling can run code "
+        "hidden in the file: only use this for files you trust.",
+    )
+    parser.add_argument("--info", action="store_true", help="Describe the input file and exit without converting.")
+    parser.add_argument("-v", "--verbose", action="store_true", help="List the tensors whose values were clamped.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def format_bytes(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1000 or unit == "GB":
+            return f"{n:.0f} {unit}" if unit == "B" else f"{n:.2f} {unit}"
+        n /= 1000
+    raise AssertionError("unreachable")
+
+
+def default_output(input_path: Path, conversion: str, precision: str, safetensors: bool) -> Path:
+    parts = [input_path.stem, conversion] + ([precision] if precision != "keep" else [])
+    return input_path.with_name("-".join(parts) + (".safetensors" if safetensors else ".ckpt"))
+
+
+def print_info(path: Path, state_dict: dict, metadata: dict | None) -> None:
+    info = describe(state_dict)
+    print(f"{path}: {info.tensors:,} tensors, {info.parameters:,} values, {format_bytes(info.bytes)}")
+    for dtype, (count, nbytes) in sorted(info.dtypes.items(), key=lambda item: -item[1][1]):
+        print(f"  {dtype:<16} {count:>7,} {'tensor ' if count == 1 else 'tensors'}  {format_bytes(nbytes):>10}")
+    if info.ema_tensors:
+        print(f"  EMA: {info.ema_tensors:,} model_ema.* tensors (-t ema-only or -t no-ema removes them)")
+    if info.other_keys:
+        print(f"  Non-tensor keys: {', '.join(info.other_keys)}")
+    if metadata:
+        print(f"  Metadata: {len(metadata)} entries ({', '.join(sorted(metadata)[:8])}{', ...' if len(metadata) > 8 else ''})")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.input and args.file:
+        parser.error("give the input file either as INPUT or with -f, not both")
+    input_path = Path(args.input or args.file or "model.ckpt")
+    if not input_path.is_file():
+        parser.error(f"input file not found: {input_path}")
+
+    if args.output:
+        output_path = Path(args.output)
+        if args.safe_tensors and output_path.suffix != ".safetensors":
+            parser.error("--safe-tensors needs an --output path ending in .safetensors")
+    else:
+        output_path = default_output(input_path, args.type, args.precision, args.safe_tensors)
+
+    try:
+        state_dict, metadata = load_checkpoint(input_path, unsafe=args.unsafe_load)
+    except (UnsafeCheckpointError, ValueError, OSError, RuntimeError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+
+    if args.info:
+        print_info(input_path, state_dict, metadata)
+        return 0
+
+    if output_path.resolve() == input_path.resolve():
+        parser.error("the output would replace the input file; choose another --output")
+    if output_path.exists() and not args.overwrite:
+        parser.error(f"{output_path} already exists; pass --overwrite to replace it")
+
+    converted, report = convert_state_dict(state_dict, args.precision, args.type, args.keep_original)
+
+    if args.precision == "keep":
+        summary = f"Kept every dtype as it was ({report.unchanged:,} entries)"
+    else:
+        summary = f"Converted {report.converted:,} tensors to {args.precision}, left {report.unchanged:,} unchanged"
+    if report.dropped:
+        summary += f", dropped {report.dropped:,} EMA entries"
+    print(summary)
+    if args.type == "ema-only":
+        if report.ema_swapped:
+            print(f"Used the EMA weights for {report.ema_swapped:,} tensors")
+        else:
+            print("warning: no EMA weights found; the output keeps the regular weights", file=sys.stderr)
+    if report.clamped:
+        limit = torch.finfo(PRECISIONS[args.precision]).max
+        print(
+            f"warning: {len(report.clamped):,} tensors had values outside the {args.precision} range "
+            f"(±{limit:g}); they were clamped instead of becoming inf/NaN",
+            file=sys.stderr,
+        )
+        if args.verbose:
+            for key, count in report.clamped.items():
+                print(f"  {key}: {count:,} values", file=sys.stderr)
+
+    skipped = save_checkpoint(converted, output_path, metadata=metadata)
+    if skipped:
+        print(f"warning: safetensors only stores tensors, left out: {', '.join(skipped)}", file=sys.stderr)
+
+    before, after = input_path.stat().st_size, output_path.stat().st_size
+    print(f"Saved {output_path} ({format_bytes(after)}, {after / before:.0%} of {format_bytes(before)})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())