Spaces:
Running on T4
Running on T4
Download src/controllers/model_controller.py from tisaconundrum/grassmann-ablation: direct link, hf CLI and curl.
- Browser
- Download file 3.46 kB
-
https://huggingface.co/spaces/tisaconundrum/grassmann-ablation/resolve/main/src/controllers/model_controller.py
- Command line
-
hf download hf://spaces/tisaconundrum/grassmann-ablation/src/controllers/model_controller.py
-
curl -L -o model_controller.py https://huggingface.co/spaces/tisaconundrum/grassmann-ablation/resolve/main/src/controllers/model_controller.py
3.46 kB
| """ | |
| ModelController: fluent API for model lifecycle. | |
| Provides the chainable interface: | |
| _model.build().train(...).test(...).save(...) | |
| """ | |
| from __future__ import annotations | |
| from typing import Any, Self | |
| import torch | |
| from src.interfaces import IModel | |
| from src.models.config import GrassmannConfig | |
| from src.models.grassmann_model import GrassmannTranscriptionModel | |
| from src.models.grassmann_seq2seq import GrassmannSeq2SeqModel | |
| from src.services.tokenizer_service import CharTokenizer | |
| from src.services.training_service import TrainingService | |
| from src.services.seq2seq_training_service import Seq2SeqTrainingService | |
| from src.views.console_view import ConsoleView | |
| class ModelController(IModel): | |
| """Orchestrates model building, training, evaluation, and inference.""" | |
| def __init__(self, config: GrassmannConfig, tokenizer: CharTokenizer): | |
| self.config = config | |
| self.tokenizer = tokenizer | |
| self.view = ConsoleView() | |
| self.nn_model: GrassmannTranscriptionModel | GrassmannSeq2SeqModel | None = None | |
| self.trainer: TrainingService | Seq2SeqTrainingService | None = None | |
| def build(self) -> Self: | |
| self.config.vocab_size = self.tokenizer.vocab_size | |
| if self.config.use_seq2seq: | |
| self.nn_model = GrassmannSeq2SeqModel(self.config) | |
| self.trainer = Seq2SeqTrainingService(self.nn_model, self.config) | |
| else: | |
| self.nn_model = GrassmannTranscriptionModel(self.config) | |
| self.trainer = TrainingService(self.nn_model, self.config) | |
| param_count = sum(p.numel() for p in self.nn_model.parameters()) | |
| self.view.show_model_info(self.config, param_count) | |
| return self | |
| def train(self, train_loader: Any, val_loader: Any, epochs: int | None = None) -> Self: | |
| assert self.trainer is not None, "Call build() first" | |
| epochs = epochs or self.config.epochs | |
| history = self.trainer.train_loop( | |
| train_loader, val_loader, epochs, callback=self.view | |
| ) | |
| self.view.show_training_complete(history) | |
| return self | |
| def test(self, test_loader: Any) -> dict: | |
| assert self.trainer is not None, "Call build() and train() first" | |
| test_loss = self.trainer.validate(test_loader) | |
| results = {"test_loss": test_loss} | |
| self.view.show_test_results(results) | |
| return results | |
| def fit(self, dataset: Any) -> Self: | |
| """Convenience: build + train + validate.""" | |
| self.build() | |
| train_loader = dataset.get_train_loader(self.config.batch_size) | |
| val_loader = dataset.get_val_loader(self.config.batch_size) | |
| self.train(train_loader, val_loader) | |
| return self | |
| def predict(self, audio: torch.Tensor) -> str: | |
| assert self.trainer is not None, "Call build() and train()/load() first" | |
| pred_tokens = self.trainer.greedy_decode(audio) | |
| text = self.tokenizer.decode(pred_tokens) | |
| return text | |
| def save(self, path: str) -> Self: | |
| assert self.nn_model is not None | |
| torch.save(self.nn_model.state_dict(), path) | |
| self.view.show_message(f"Model saved to {path}") | |
| return self | |
| def load(self, path: str) -> Self: | |
| if self.nn_model is None: | |
| self.build() | |
| assert self.nn_model is not None | |
| self.nn_model.load_state_dict(torch.load(path, weights_only=True)) | |
| self.view.show_message(f"Model loaded from {path}") | |
| return self | |