Spaces:
Running
Running
Nicholas Finch
fix: default workers=0 (sequential) for Docker cache — ProcessPoolExecutor hangs on cpu-basic
d7013e6 Download src/services/export_service.py from tisaconundrum/grassmann-cache: direct link, hf CLI and curl.
- Browser
- Download file 4.46 kB
-
https://huggingface.co/spaces/tisaconundrum/grassmann-cache/resolve/main/src/services/export_service.py
- Command line
-
hf download hf://spaces/tisaconundrum/grassmann-cache/src/services/export_service.py
-
curl -L -o export_service.py https://huggingface.co/spaces/tisaconundrum/grassmann-cache/resolve/main/src/services/export_service.py
4.46 kB
| """ | |
| ONNX Export Service. | |
| Handles exporting Grassmann models to ONNX format for cross-platform inference. | |
| """ | |
| from __future__ import annotations | |
| from pathlib import Path | |
| import torch | |
| from src.models.config import GrassmannConfig | |
| class EncoderWrapper(torch.nn.Module): | |
| def __init__(self, encoder): | |
| super().__init__() | |
| self.encoder = encoder | |
| def forward(self, mel: torch.Tensor) -> torch.Tensor: | |
| return self.encoder(mel) | |
| class DecoderStepWrapper(torch.nn.Module): | |
| def __init__(self, decoder): | |
| super().__init__() | |
| self.decoder = decoder | |
| def forward(self, tokens: torch.Tensor, encoder_out: torch.Tensor) -> torch.Tensor: | |
| logits = self.decoder(tokens, encoder_out) | |
| return logits[:, -1:, :] | |
| class CTCModelWrapper(torch.nn.Module): | |
| def __init__(self, model): | |
| super().__init__() | |
| self.frontend = model.frontend | |
| self.pos_enc = model.pos_enc | |
| self.layers = model.layers | |
| self.output_proj = model.output_proj | |
| def forward(self, mel: torch.Tensor) -> torch.Tensor: | |
| x = self.frontend(mel) | |
| x = self.pos_enc(x) | |
| for layer in self.layers: | |
| x = layer(x) | |
| logits = self.output_proj(x) | |
| return logits.log_softmax(dim=-1) | |
| def export_seq2seq(model, config: GrassmannConfig, output_dir: str, opset: int = 18) -> None: | |
| model = model.cpu() | |
| model.eval() | |
| out = Path(output_dir) | |
| out.mkdir(parents=True, exist_ok=True) | |
| print(" Exporting encoder.onnx...") | |
| encoder_wrapper = EncoderWrapper(model.encoder) | |
| encoder_wrapper.eval() | |
| dummy_mel = torch.randn(1, config.n_mels, 200) | |
| torch.onnx.export( | |
| encoder_wrapper, (dummy_mel,), str(out / "encoder.onnx"), | |
| input_names=["mel"], output_names=["encoder_out"], | |
| dynamic_axes={"mel": {0: "batch", 2: "time"}, "encoder_out": {0: "batch", 1: "enc_time"}}, | |
| opset_version=opset, | |
| ) | |
| print(" Exporting decoder_step.onnx...") | |
| decoder_wrapper = DecoderStepWrapper(model.decoder) | |
| decoder_wrapper.eval() | |
| dummy_tokens = torch.tensor([[0, 5, 12]], dtype=torch.long) | |
| dummy_enc_out = torch.randn(1, 50, config.d_model) | |
| torch.onnx.export( | |
| decoder_wrapper, (dummy_tokens, dummy_enc_out), str(out / "decoder_step.onnx"), | |
| input_names=["tokens", "encoder_out"], output_names=["next_logits"], | |
| dynamic_axes={"tokens": {0: "batch", 1: "seq_len"}, "encoder_out": {0: "batch", 1: "enc_time"}, "next_logits": {0: "batch"}}, | |
| opset_version=opset, | |
| ) | |
| def export_ctc(model, config: GrassmannConfig, output_dir: str, opset: int = 18) -> None: | |
| model = model.cpu() | |
| model.eval() | |
| out = Path(output_dir) | |
| out.mkdir(parents=True, exist_ok=True) | |
| print(" Exporting model.onnx (CTC)...") | |
| wrapper = CTCModelWrapper(model) | |
| wrapper.eval() | |
| dummy_mel = torch.randn(1, config.n_mels, 200) | |
| torch.onnx.export( | |
| wrapper, (dummy_mel,), str(out / "model.onnx"), | |
| input_names=["mel"], output_names=["log_probs"], | |
| dynamic_axes={"mel": {0: "batch", 2: "time"}, "log_probs": {0: "batch", 1: "time"}}, | |
| opset_version=opset, | |
| ) | |
| def verify_onnx(output_dir: str, config: GrassmannConfig, is_seq2seq: bool) -> None: | |
| try: | |
| import onnxruntime as ort | |
| except ImportError: | |
| print(" Install onnxruntime to verify: pip install onnxruntime") | |
| return | |
| import numpy as np | |
| out = Path(output_dir) | |
| if is_seq2seq: | |
| print(" Verifying encoder.onnx...") | |
| enc_session = ort.InferenceSession(str(out / "encoder.onnx")) | |
| mel = np.random.randn(1, config.n_mels, 200).astype(np.float32) | |
| enc_out = enc_session.run(None, {"mel": mel})[0] | |
| print(f" Encoder output shape: {enc_out.shape}") | |
| print(" Verifying decoder_step.onnx...") | |
| dec_session = ort.InferenceSession(str(out / "decoder_step.onnx")) | |
| tokens = np.array([[0, 5, 12]], dtype=np.int64) | |
| logits = dec_session.run(None, {"tokens": tokens, "encoder_out": enc_out})[0] | |
| print(f" Decoder logits shape: {logits.shape}") | |
| else: | |
| print(" Verifying model.onnx (CTC)...") | |
| session = ort.InferenceSession(str(out / "model.onnx")) | |
| mel = np.random.randn(1, config.n_mels, 200).astype(np.float32) | |
| log_probs = session.run(None, {"mel": mel})[0] | |
| print(f" Output shape: {log_probs.shape}") | |
| print(" ONNX verification passed!") | |