Spaces:
Running
Running
Download backend/app.py from thebickersteth/voxpreference: direct link, hf CLI and curl.
- Browser
- Download file 10.1 kB
-
https://huggingface.co/spaces/thebickersteth/voxpreference/resolve/main/backend/app.py
- Command line
-
hf download hf://spaces/thebickersteth/voxpreference/backend/app.py
-
curl -L -o app.py https://huggingface.co/spaces/thebickersteth/voxpreference/resolve/main/backend/app.py
10.1 kB
| from contextlib import asynccontextmanager | |
| from dataclasses import asdict | |
| import threading | |
| from typing import List, Optional | |
| import json | |
| import os | |
| from pathlib import Path | |
| from fastapi import FastAPI, File, Form, Request, UploadFile | |
| from fastapi.responses import FileResponse, JSONResponse | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.staticfiles import StaticFiles | |
| import io | |
| import librosa | |
| from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor | |
| from text_to_ipa import convert_to_ipa | |
| import torch | |
| from pg import audio as pg_audio | |
| from pg.ot import DEFAULT_RANKING, TENET_NAMES, TENETS, parse_ranking | |
| from pg.report import contrast_csv, html_report, subclusters_csv, tokens_csv | |
| from pg.tenets import load_units, settings_from | |
| async def lifespan(_app): | |
| # PG_WARM=1 (set in the Docker image) loads the models in the background as soon as the server starts | |
| if os.environ.get("PG_WARM") == "1": | |
| threading.Thread(target=lambda: get_analyzer().aligner, daemon=True).start() | |
| yield | |
| app = FastAPI(lifespan=lifespan) | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], | |
| allow_credentials=True, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| _asr = None | |
| def get_asr(): | |
| global _asr | |
| if _asr is None: | |
| processor = Wav2Vec2Processor.from_pretrained("thebickersteth/wav2vec2-nigerian-english") | |
| model = Wav2Vec2ForCTC.from_pretrained("thebickersteth/wav2vec2-nigerian-english").eval() | |
| _asr = (processor, model) | |
| return _asr | |
| FRONTEND_DIST = Path(os.environ.get("FRONTEND_DIST", Path(__file__).resolve().parents[1] / "frontend" / "dist")) | |
| if not FRONTEND_DIST.is_dir(): | |
| def root(): | |
| return {"message": "Welcome! This API is for transcription. Try /health or /transcribe."} | |
| def health(): | |
| return {"status": "ok"} | |
| async def transcribe(audioFile: UploadFile = File(...)): | |
| try: | |
| audio_bytes = await audioFile.read() | |
| audio_input, _ = librosa.load(io.BytesIO(audio_bytes), sr=16000) | |
| processor, model = get_asr() | |
| inputs = processor(audio_input, sampling_rate=16000, return_tensors="pt") | |
| with torch.no_grad(): | |
| logits = model(inputs.input_values).logits | |
| predicted_ids = torch.argmax(logits, dim=-1) | |
| transcription = processor.batch_decode(predicted_ids.numpy())[0] | |
| ipa_result = convert_to_ipa(transcription) | |
| ipa = ipa_result["ipa"] if ipa_result["success"] else None | |
| ipa_error = ipa_result["error"] if not ipa_result["success"] else None | |
| print(transcription, ipa, ipa_error) | |
| return JSONResponse( | |
| status_code=200, | |
| content={ | |
| "success": True, | |
| "transcription": transcription, | |
| "ipa": ipa, | |
| "ipa_error": ipa_error | |
| } | |
| ) | |
| except Exception as e: | |
| return JSONResponse( | |
| status_code=500, | |
| content={"success": False, "error": str(e)} | |
| ) | |
| _analyzer = None | |
| # one analysis at a time: the models take ~2 GB and every analysis uses all CPU cores | |
| _analysis_lock = threading.Lock() | |
| MAX_FILES = 300 | |
| MAX_FILE_BYTES = 50 * 1024 * 1024 | |
| _analyzer_lock = threading.Lock() | |
| def get_analyzer(): | |
| # the phone model is large, so it loads on the first PG request, or at start-up when PG_WARM=1 (see lifespan) | |
| global _analyzer | |
| with _analyzer_lock: | |
| if _analyzer is None: | |
| from pg.pipeline import Analyzer | |
| _analyzer = Analyzer() | |
| return _analyzer | |
| def pg_units(): | |
| return { | |
| "units": {k: asdict(u) for k, u in load_units().items()}, | |
| "tenets": [{"key": t, "name": TENET_NAMES[t]} for t in TENETS], | |
| "default_ranking": DEFAULT_RANKING, | |
| } | |
| def pg_analyze( | |
| files: List[UploadFile] = File(...), | |
| words: str = Form(...), | |
| unit: Optional[str] = Form(None), | |
| ranking: str = Form(DEFAULT_RANKING), | |
| transcripts: Optional[str] = Form(None), | |
| speakers: Optional[str] = Form(None), | |
| settings: Optional[str] = Form(None), | |
| asr: bool = Form(False), | |
| diarize: bool = Form(True), | |
| num_speakers: Optional[int] = Form(None), | |
| ): | |
| """files: recordings; words: comma-separated target words; transcripts/speakers: JSON objects | |
| keyed by file name (omit transcripts for single-word recordings; "auto" or asr=true finds the | |
| words in unscripted audio by speech recognition); diarize: separate the speakers inside unscripted | |
| recordings that have no speaker id; num_speakers: how many talk in each, if known; settings: JSON | |
| tenet thresholds.""" | |
| from pg.pipeline import Recording | |
| try: | |
| config = settings_from(json.loads(settings) if settings else None) | |
| parse_ranking(ranking) | |
| if len(files) > MAX_FILES: | |
| raise ValueError(f"at most {MAX_FILES} recordings per analysis") | |
| transcript_of = json.loads(transcripts) if transcripts else {} | |
| speaker_of = json.loads(speakers) if speakers else {} | |
| if num_speakers is not None and not 1 <= num_speakers <= 20: | |
| raise ValueError("num_speakers must be between 1 and 20") | |
| recordings = [] | |
| for f in files: | |
| data = f.file.read(MAX_FILE_BYTES + 1) | |
| if len(data) > MAX_FILE_BYTES: | |
| raise ValueError(f"{f.filename} is larger than {MAX_FILE_BYTES // 2**20} MB") | |
| try: | |
| audio = pg_audio.load(data) | |
| except RuntimeError as e: | |
| raise ValueError(f"{f.filename}: {e}") from e | |
| recordings.append(Recording(f.filename, audio, speaker=speaker_of.get(f.filename, ""), | |
| transcript=transcript_of.get(f.filename, "auto" if asr else ""), | |
| diarize=None if diarize else False, num_speakers=num_speakers)) | |
| with _analysis_lock: | |
| result = get_analyzer().analyse(recordings, words.split(","), unit or None, ranking, config) | |
| except (ValueError, KeyError) as e: | |
| return JSONResponse(status_code=400, content={"success": False, "error": str(e).strip("'\"")}) | |
| except Exception as e: | |
| return JSONResponse(status_code=500, content={"success": False, "error": str(e)}) | |
| body = result.to_dict() | |
| body["success"] = True | |
| body["files"] = { | |
| "tokens.csv": tokens_csv(result), | |
| "subclusters.csv": subclusters_csv(result), | |
| "contrast_matrix.csv": contrast_csv(result), | |
| "operability_table.csv": result.tableau.to_csv() if result.tableau else "", | |
| "report.html": html_report(result), | |
| } | |
| return body | |
| # The PG2 pages' attested variants: PG2's checks and validation summary (Ebube's engine from FULL_PG_TOOL: | |
| # backend/pg2), then the preferred form by Ugorji's strict ranking (pg/pg2_bridge.py) | |
| MAX_JSON_BYTES = 25 * 1024 * 1024 | |
| MAX_CSV_BYTES = 1024 * 1024 | |
| _strict = None | |
| def strict_scored(payload: dict, weighted: dict) -> JSONResponse: | |
| global _strict | |
| if not weighted.get("success"): | |
| return JSONResponse(status_code=400, content=weighted) | |
| try: | |
| with _analyzer_lock: | |
| if _strict is None: | |
| from pg.pg2_bridge import StrictScorer | |
| _strict = StrictScorer() | |
| return JSONResponse(status_code=200, content=_strict.score(payload, weighted)) | |
| except ValueError as e: | |
| return JSONResponse(status_code=400, content={"success": False, "errors": [str(e)]}) | |
| async def preference_analyze(request: Request): | |
| from pg2.pg_core import analyze_preference_grammar | |
| raw = await request.body() | |
| if len(raw) > MAX_JSON_BYTES: | |
| return JSONResponse(status_code=413, content={"success": False, "errors": ["Request is too large."]}) | |
| try: | |
| payload = json.loads(raw) | |
| except ValueError as e: | |
| return JSONResponse(status_code=400, content={"success": False, "errors": [f"Invalid JSON payload: {e}"]}) | |
| if not isinstance(payload, dict): | |
| return JSONResponse(status_code=400, content={"success": False, "errors": ["JSON payload must be an object."]}) | |
| return strict_scored(payload, analyze_preference_grammar(payload)) | |
| async def preference_analyze_csv(annotationFile: UploadFile = File(...), sliders_json: Optional[str] = Form(None)): | |
| from pg2.pg_core import analyze_preference_grammar | |
| from pg2.validation_import import aggregate_annotation_rows, rows_from_csv | |
| raw = await annotationFile.read(MAX_CSV_BYTES + 1) | |
| if len(raw) > MAX_CSV_BYTES: | |
| return JSONResponse(status_code=413, content={"success": False, "errors": ["CSV is too large. Limit is 1024 KB."]}) | |
| try: | |
| payload = aggregate_annotation_rows(rows_from_csv(io.StringIO(raw.decode("utf-8-sig")))) | |
| if not payload.get("success"): | |
| return JSONResponse(status_code=400, content=payload) | |
| if sliders_json: | |
| payload["sliders"] = json.loads(sliders_json) | |
| except UnicodeDecodeError as e: | |
| return JSONResponse(status_code=400, content={"success": False, "errors": [f"CSV must be UTF-8: {e}"]}) | |
| except ValueError as e: | |
| return JSONResponse(status_code=400, content={"success": False, "errors": [f"Invalid sliders_json: {e}"]}) | |
| result = analyze_preference_grammar(payload) | |
| result["annotationSummary"] = payload.get("annotation_summary") | |
| return strict_scored(payload, result) | |
| # the built frontend; any other path is a page of the single-page app (/upload, /results, ...) | |
| if FRONTEND_DIST.is_dir(): | |
| if (FRONTEND_DIST / "assets").is_dir(): | |
| app.mount("/assets", StaticFiles(directory=FRONTEND_DIST / "assets"), name="assets") | |
| def serve_page(full_path: str): | |
| requested = (FRONTEND_DIST / full_path).resolve() | |
| if requested.is_file() and FRONTEND_DIST.resolve() in requested.parents: | |
| return FileResponse(requested) | |
| return FileResponse(FRONTEND_DIST / "index.html") | |