1.0

README.md

@@ -1,12 +1,13 @@
 ---
 title: Wav2vec2 Cypriot ASR
-emoji: 🐨
-colorFrom: pink
-colorTo: green
+emoji: 🐠
+colorFrom: yellow
+colorTo: blue
 sdk: gradio
 sdk_version: 5.45.0
 app_file: app.py
 pinned: false
+license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,73 @@
+# app.py
+
+from __future__ import annotations
+import os
+import numpy as np
+import librosa
+import gradio as gr
+from transformers import pipeline
+import kenlm_asr_pipeline
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+MODEL_ID = "Elormiden/wav2vec2-cypriot-dialect"
+KENLM_FILE = "cypriot.klm"
+
+ASR = pipeline(
+    "automatic-speech-recognition-kenlm",
+    model=MODEL_ID,        
+    kenlm_filename=KENLM_FILE, 
+    alpha=0.4,
+    beta=0.9,
+    token=HF_TOKEN,
+    device=0,
+    model_id_or_path=MODEL_ID,
+)
+
+def transcribe(audio: tuple[int, np.ndarray] | None):
+    def wrap(msg: str) -> str:
+        msg = (msg or "").strip()
+        return f"Output: {msg if msg else '(empty)'}"
+
+    if audio is None:
+        return wrap("No audio.")
+    sr, data = audio
+
+    if isinstance(data, np.ndarray) and data.ndim == 2:
+        data = data.mean(axis=1)
+
+    target_sr = 16000
+    if sr != target_sr:
+        data = librosa.resample(data.astype(np.float32), orig_sr=sr, target_sr=target_sr)
+        sr = target_sr
+
+    if data.size == 0 or not np.isfinite(data).all():
+        return wrap("No valid audio.")
+
+    try:
+        out = ASR(data, sampling_rate=sr)
+        if isinstance(out, dict):
+            text = out.get("text", "")
+        elif isinstance(out, list) and out and isinstance(out[0], dict):
+            text = out[0].get("text", "")
+        elif isinstance(out, str):
+            text = out
+        else:
+            text = str(out)
+
+        return wrap(text)
+    except Exception as e:
+        return wrap(f"Error: {e}")
+
+
+with gr.Blocks(title="KenLM Wav2Vec2 ASR") as demo:
+    gr.Markdown("# KenLM Wav2Vec2 ASR\nUpload or record audio; decoding uses KenLM for better accuracy.")
+    audio = gr.Audio(sources=["microphone", "upload"], type="numpy", label="Audio (16kHz preferred)")
+    btn = gr.Button("Transcribe")
+    txt = gr.Textbox(label="Transcription")
+
+    btn.click(fn=transcribe, inputs=audio, outputs=txt)
+    audio.change(fn=transcribe, inputs=audio, outputs=txt)
+
+if __name__ == "__main__":
+    demo.launch()

apt.txt

@@ -0,0 +1,3 @@
+build-essential
+cmake
+libeigen3-dev

kenlm_asr_pipeline.py

@@ -0,0 +1,130 @@
+# kenlm_asr_pipeline.py
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from huggingface_hub import hf_hub_download
+from pyctcdecode import build_ctcdecoder
+from transformers import (
+    Pipeline,
+    Wav2Vec2ForCTC,
+    Wav2Vec2Processor,
+)
+from transformers.pipelines import PIPELINE_REGISTRY
+
+
+class KenLMWav2Vec2Pipeline(Pipeline):
+    def __init__(
+        self,
+        model: Wav2Vec2ForCTC,          
+        tokenizer=None,
+        feature_extractor=None,
+        *,
+        alpha: float = 0.4,
+        beta: float = 0.9,
+        kenlm_filename: str = "cypriot.klm",
+        suppress_token_ids: Optional[Sequence[int]] = None,
+        quiet: bool = True,
+        token: Optional[str] = None,
+        model_id_or_path: Optional[str] = None,   # for .klm
+        **kwargs,
+    ) -> None:
+        if quiet:
+            import warnings, logging  
+            warnings.filterwarnings("ignore")
+            logging.getLogger("pyctcdecode").setLevel(logging.CRITICAL)
+            logging.getLogger("pyctcdecode.decoder").setLevel(logging.CRITICAL)
+
+        # HF Pipeline contract
+        super().__init__(
+            model=model,
+            tokenizer=tokenizer,
+            feature_extractor=feature_extractor,
+            **kwargs, 
+        )
+
+        # Собираем processor из имеющихся частей
+        if self.tokenizer is None or self.feature_extractor is None:
+            raise ValueError("Tokenizer and feature_extractor are required.")
+        self.processor = Wav2Vec2Processor(
+            feature_extractor=self.feature_extractor, tokenizer=self.tokenizer
+        )
+
+        # bottleneck
+        vocab = self.processor.tokenizer.get_vocab()
+        kenlm_vocab_list = []
+        for tok, idx in sorted(vocab.items(), key=lambda x: x[1]):
+            if idx not in [55, 56]:  # excluding <s>, </s> tokens
+                kenlm_vocab_list.append(tok)
+
+        if os.path.isfile(kenlm_filename):
+            kenlm_path = kenlm_filename
+        elif model_id_or_path and os.path.isdir(model_id_or_path) and os.path.isfile(os.path.join(model_id_or_path, kenlm_filename)):
+            kenlm_path = os.path.join(model_id_or_path, kenlm_filename)
+        elif model_id_or_path and "/" in model_id_or_path:
+            kenlm_path = hf_hub_download(model_id_or_path, kenlm_filename, token=token)
+        else:
+            name_or_path = getattr(self.model.config, "_name_or_path", None)
+            if name_or_path and os.path.isdir(name_or_path) and os.path.isfile(os.path.join(name_or_path, kenlm_filename)):
+                kenlm_path = os.path.join(name_or_path, kenlm_filename)
+            elif name_or_path and "/" in name_or_path:
+                kenlm_path = hf_hub_download(name_or_path, kenlm_filename, token=token)
+            else:
+                raise FileNotFoundError(f"KenLM file '{kenlm_filename}' not found")
+
+        self.ctc_decoder = build_ctcdecoder(labels=kenlm_vocab_list, kenlm_model_path=kenlm_path, alpha=alpha, beta=beta)
+        self.suppress_token_ids: Sequence[int] = tuple(suppress_token_ids or ())
+        self.model.eval()
+
+        # hugging face api stuff
+    def _sanitize_parameters(self, **kwargs):
+        pre, fwd, post = {}, {}, {}
+        if "sampling_rate" in kwargs:
+            pre["sampling_rate"] = kwargs["sampling_rate"]
+        if "return_timestamps" in kwargs:
+            post["return_timestamps"] = kwargs["return_timestamps"]
+        return pre, fwd, post
+
+    def preprocess(
+        self,
+        inputs: Union[np.ndarray, List[np.ndarray], Dict[str, Any], List[Dict[str, Any]]],
+        sampling_rate: int = 16000,
+    ) -> Dict[str, torch.Tensor]:
+        if isinstance(inputs, dict) and "array" in inputs:
+            arrays = [np.asarray(inputs["array"])]
+        elif isinstance(inputs, list):
+            if len(inputs) == 0:
+                raise ValueError("Empty input list.")
+            arrays = [np.asarray(x["array"] if isinstance(x, dict) and "array" in x else x) for x in inputs]
+        else:
+            arrays = [np.asarray(inputs)]
+
+        proc = self.processor(arrays, sampling_rate=sampling_rate, return_tensors="pt", padding=True)
+        return {k: (v.to(self.device) if torch.is_tensor(v) else v) for k, v in proc.items()}
+
+    @torch.inference_mode()
+    def _forward(self, model_inputs: Dict[str, torch.Tensor]):
+        outputs = self.model(**model_inputs)
+        logits = outputs.logits  # (B, T, V)
+        for tid in self.suppress_token_ids:
+            logits[..., tid] = -float("inf")
+        log_probs = F.log_softmax(logits, dim=-1)
+        return {"log_probs": log_probs}
+
+    def postprocess(self, model_outputs, return_timestamps: bool = False):
+        log_probs = model_outputs["log_probs"].detach().cpu().numpy()  # (B, T, V)
+        texts = [{"text": self.ctc_decoder.decode(lp)} for lp in log_probs]
+        return texts[0] if len(texts) == 1 else texts
+
+
+PIPELINE_REGISTRY.register_pipeline(
+    task="automatic-speech-recognition-kenlm",
+    pipeline_class=KenLMWav2Vec2Pipeline,
+    pt_model=Wav2Vec2ForCTC,
+    default={"pt": (Wav2Vec2ForCTC, Wav2Vec2Processor)},
+)

requirements.txt

@@ -0,0 +1,21 @@
+gradio>=4.0.0
+
+transformers[torch]>=4.40.0
+torch           # можно убрать, если берёшь предустановленный образ с PyTorch
+huggingface_hub>=0.23.0
+
+pyctcdecode>=0.5.0
+kenlm>=0.2.0
+
+librosa>=0.10.1
+
+tf-keras
+
+datasets==3.6.0
+transformers
+
+evaluate
+librosa
+jiwer
+numpy==1.26.4
+pyctcdecode