Spaces:
Running on T4
Running on T4
File size: 3,606 Bytes
a7452cc | 1 2 3 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 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 92 93 94 95 96 97 98 99 100 101 102 103 | """
PipelineController: end-to-end orchestration.
Wires together dataset, model, and services into a single fluent pipeline.
"""
from __future__ import annotations
from typing import Self
from src.interfaces import IDataset
from src.models.config import GrassmannConfig
from src.services.audio_service import AudioService
from src.services.dataset_service import DatasetService
from src.services.tokenizer_service import CharTokenizer
from src.repositories.dataset_repository import DatasetRepository
from src.repositories.cache_repository import CacheRepository
from src.controllers.model_controller import ModelController
class PipelineController:
"""
Top-level controller for the full transcription pipeline.
Usage (local files):
pipeline = PipelineController(config)
pipeline.prepare_dataset("path/to/data")
.build_model()
.train()
.test()
.transcribe("path/to/audio.wav")
Usage (HuggingFace):
pipeline = PipelineController(config)
pipeline.prepare_hf_dataset("openslr/librispeech_asr",
split="train.clean.100")
.build_model()
.train()
.test()
"""
def __init__(self, config: GrassmannConfig | None = None,
cache_dir: str = "checkpoints/mel_cache"):
self.config = config or GrassmannConfig()
self.tokenizer = CharTokenizer()
self.audio_service = AudioService(self.config)
self._repo = DatasetRepository(self.config, self.tokenizer)
self._cache = CacheRepository(cache_dir)
self.dataset: DatasetService | None = None
self.model: ModelController | None = None
def prepare_hf_dataset(
self,
dataset_name: str,
config_name: str | None = None,
split: str | None = None,
max_samples: int | None = None,
) -> Self:
"""Load a dataset from HuggingFace Hub."""
self.dataset = DatasetService(self._repo, self._cache)
self.dataset.load_dataset(
dataset_name, split=split,
config_name=config_name,
max_samples=max_samples,
).clean().preprocess().split()
return self
def build_model(self) -> Self:
self.model = ModelController(self.config, self.tokenizer)
self.model.build()
return self
def train(self, epochs: int | None = None) -> Self:
assert self.model is not None and self.dataset is not None
train_loader = self.dataset.get_train_loader(self.config.batch_size)
val_loader = self.dataset.get_val_loader(self.config.batch_size)
self.model.train(train_loader, val_loader, epochs)
return self
def test(self) -> dict:
assert self.model is not None and self.dataset is not None
test_loader = self.dataset.get_test_loader(self.config.batch_size)
return self.model.test(test_loader)
def transcribe(self, audio_path: str) -> str:
assert self.model is not None
waveform = self.audio_service.load(audio_path)
mel = self.audio_service.extract_features(waveform)
mel = self.audio_service.normalize(mel)
return self.model.predict(mel)
def save_model(self, path: str) -> Self:
assert self.model is not None
self.model.save(path)
return self
def load_model(self, path: str) -> Self:
if self.model is None:
self.build_model()
assert self.model is not None
self.model.load(path)
return self
|