system's picture
system HF Staff
Update VoxPreference
c4ad58f verified
Raw History Blame Contribute Delete
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
@asynccontextmanager
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():
@app.get("/")
def root():
return {"message": "Welcome! This API is for transcription. Try /health or /transcribe."}
@app.get("/health")
def health():
return {"status": "ok"}
@app.post("/transcribe")
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
@app.get("/pg/units")
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,
}
@app.post("/pg/analyze")
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)]})
@app.post("/preference/analyze")
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))
@app.post("/preference/analyze-csv")
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")
@app.get("/{full_path:path}")
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")