Upload folder using huggingface_hub

README.md

@@ -1,12 +1,14 @@
 ---
 title: 911 Urgency Prototype
-emoji: 😻
-colorFrom: pink
+emoji: 🚨
+colorFrom: indigo
 colorTo: red
 sdk: gradio
-sdk_version: 5.46.0
+sdk_version: 4.0.0
+python_version: 3.10
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Urgency-only prototype for 911 decision support (voice → transcript → score).

app.py

@@ -0,0 +1,48 @@
+
+import gradio as gr
+from inference import UrgencyModel
+from asr import Transcriber
+
+urg = UrgencyModel()
+asr = Transcriber()
+
+def transcribe_then_score(audio_file, thr=0.5):
+    urg.threshold = float(thr)
+    if audio_file is None:
+        return "", 0.0, "Non-Urgent", "No audio provided."
+    text = asr.transcribe_file(audio_file)
+    res = urg.predict(text)
+    return text, res["urgency_score"], res["urgent_label"], res["rationale"]
+
+def score_text(text, thr=0.5):
+    urg.threshold = float(thr)
+    res = urg.predict(text or "")
+    return res["urgency_score"], res["urgent_label"], res["rationale"]
+
+with gr.Blocks(title="911 Urgency Prototype") as demo:
+    gr.Markdown("# 911 Urgency Prototype\nDecision support (not dispatch).")
+    thr = gr.Slider(0, 1, value=0.5, step=0.01, label="Decision threshold")
+
+    with gr.Tab("Voice → Urgency"):
+        gr.Markdown("Record or upload a short clip (WAV/MP3).")
+        audio_in = gr.Audio(sources=["microphone","upload"], type="filepath")
+        btn_v = gr.Button("Transcribe & Score")
+        text_out = gr.Textbox(label="Transcript", lines=8)
+        score_out = gr.Number(label="Urgency Score (0–1)")
+        label_out = gr.Textbox(label="Urgent / Non-Urgent")
+        rationale_out = gr.Textbox(label="Rationale")
+        btn_v.click(transcribe_then_score, inputs=[audio_in, thr],
+                    outputs=[text_out, score_out, label_out, rationale_out])
+
+    with gr.Tab("Text → Urgency"):
+        txt_in = gr.Textbox(label="Paste transcript", lines=8, placeholder="Paste a transcript…")
+        btn_t = gr.Button("Score Text")
+        score_out2 = gr.Number(label="Urgency Score (0–1)")
+        label_out2 = gr.Textbox(label="Urgent / Non-Urgent")
+        rationale_out2 = gr.Textbox(label="Rationale")
+        btn_t.click(score_text, inputs=[txt_in, thr], outputs=[score_out2, label_out2, rationale_out2])
+
+    gr.Markdown("**Notes:** Prototype for QA/training. No PII stored; processing is in-memory.")
+
+if __name__ == "__main__":
+    demo.launch()  # Spaces handles networking

asr.py

@@ -0,0 +1,22 @@
+
+import torch
+from faster_whisper import WhisperModel
+
+def _pick():
+    if torch.cuda.is_available():
+        return dict(model_id="Systran/faster-whisper-small.en", device="cuda", compute_type="float16")
+    else:
+        return dict(model_id="Systran/faster-whisper-base.en", device="cpu", compute_type="int8")
+
+class Transcriber:
+    def __init__(self):
+        cfg = _pick()
+        try:
+            self.model = WhisperModel(cfg["model_id"], device=cfg["device"], compute_type=cfg["compute_type"])
+        except ValueError:
+            # Fallbacks if int8/float16 not supported
+            self.model = WhisperModel(cfg["model_id"], device="cpu", compute_type="float32")
+
+    def transcribe_file(self, audio_path: str) -> str:
+        segments, _ = self.model.transcribe(audio_path, beam_size=1, vad_filter=True, temperature=0.0)
+        return " ".join(s.text.strip() for s in segments).strip()

final_model/added_tokens.json

@@ -0,0 +1,3 @@
+{
+  "[MASK]": 128000
+}

final_model/config.json

@@ -0,0 +1,32 @@
+{
+  "attention_probs_dropout_prob": 0.1,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-07,
+  "legacy": true,
+  "max_position_embeddings": 512,
+  "max_relative_positions": -1,
+  "model_type": "deberta-v2",
+  "norm_rel_ebd": "layer_norm",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "pooler_dropout": 0,
+  "pooler_hidden_act": "gelu",
+  "pooler_hidden_size": 768,
+  "pos_att_type": [
+    "p2c",
+    "c2p"
+  ],
+  "position_biased_input": false,
+  "position_buckets": 256,
+  "relative_attention": true,
+  "share_att_key": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.52.4",
+  "type_vocab_size": 0,
+  "vocab_size": 128100
+}

final_model/label_spaces.json

@@ -0,0 +1,44 @@
+{
+  "id2label": {
+    "urgency": {
+      "0": "Non-Urgent",
+      "1": "Urgent"
+    },
+    "call_type": {
+      "0": "Active Shooter",
+      "1": "Aggravated Assault",
+      "2": "Armed Robbery",
+      "3": "Disturbance/Nuisance",
+      "4": "Domestic Violence",
+      "5": "EMS Assist",
+      "6": "Homicide",
+      "7": "Major Trauma",
+      "8": "Other",
+      "9": "Suspicious Person/Vehicle",
+      "10": "Theft/Larceny",
+      "11": "Traffic Crash",
+      "12": "Welfare Check"
+    }
+  },
+  "label2id": {
+    "urgency": {
+      "Non-Urgent": 0,
+      "Urgent": 1
+    },
+    "call_type": {
+      "Active Shooter": 0,
+      "Aggravated Assault": 1,
+      "Armed Robbery": 2,
+      "Disturbance/Nuisance": 3,
+      "Domestic Violence": 4,
+      "EMS Assist": 5,
+      "Homicide": 6,
+      "Major Trauma": 7,
+      "Other": 8,
+      "Suspicious Person/Vehicle": 9,
+      "Theft/Larceny": 10,
+      "Traffic Crash": 11,
+      "Welfare Check": 12
+    }
+  }
+}

final_model/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e535ce3ad77d5c158510e343c2d419b6a9d2643f91d2567e399aa8de37063e6
+size 565308274

final_model/special_tokens_map.json

@@ -0,0 +1,15 @@
+{
+  "bos_token": "[CLS]",
+  "cls_token": "[CLS]",
+  "eos_token": "[SEP]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

final_model/spm.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c679fbf93643d19aab7ee10c0b99e460bdbc02fedf34b92b05af343b4af586fd
+size 2464616

final_model/thresholds.json

@@ -0,0 +1,15 @@
+{
+  "Active Shooter": 0.49999999999999994,
+  "Aggravated Assault": 0.49999999999999994,
+  "Armed Robbery": 0.5499999999999999,
+  "Disturbance/Nuisance": 0.39999999999999997,
+  "Domestic Violence": 0.5,
+  "EMS Assist": 0.49999999999999994,
+  "Homicide": 0.44999999999999996,
+  "Major Trauma": 0.49999999999999994,
+  "Other": 0.49999999999999994,
+  "Suspicious Person/Vehicle": 0.49999999999999994,
+  "Theft/Larceny": 0.44999999999999996,
+  "Traffic Crash": 0.5499999999999999,
+  "Welfare Check": 0.5
+}

final_model/tokenizer_config.json

@@ -0,0 +1,59 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128000": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "bos_token": "[CLS]",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "eos_token": "[SEP]",
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "sp_model_kwargs": {},
+  "split_by_punct": false,
+  "tokenizer_class": "DebertaV2Tokenizer",
+  "unk_token": "[UNK]",
+  "vocab_type": "spm"
+}

inference.py

@@ -0,0 +1,91 @@
+
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import torch, json
+from transformers import AutoTokenizer, AutoConfig, AutoModelForSequenceClassification
+from transformers.models.deberta_v2 import DebertaV2ForSequenceClassification
+
+MODEL_DIR_DEFAULT = os.path.join(os.path.dirname(__file__), "final_model")
+
+def _strip_wrappers(k: str) -> str:
+    for p in ("model.", "module.", "net."):
+        if k.startswith(p): return k[len(p):]
+    return k
+
+def _remap_keys(sd: dict) -> dict:
+    new = {}
+    for k, v in sd.items():
+        k = _strip_wrappers(k)
+        if k.startswith("backbone."):
+            k = "deberta." + k[len("backbone."):]
+        elif k.startswith(("head.", "heads.", "cls.", "fc.")):
+            k = "classifier." + k.split(".", 1)[1]
+        elif k.startswith("encoder."):
+            k = "deberta." + k
+        new[k] = v
+    return new
+
+class UrgencyModel:
+    def __init__(self, model_dir=MODEL_DIR_DEFAULT, device=None, threshold=0.5):
+        self.model_dir = model_dir
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+
+        thr_path = os.path.join(model_dir, "thresholds.json")
+        if os.path.exists(thr_path):
+            try:
+                threshold = float(json.load(open(thr_path, encoding="utf-8")).get("urgency", threshold))
+            except Exception:
+                pass
+        self.threshold = threshold
+
+        try:
+            spaces = json.load(open(os.path.join(model_dir, "label_spaces.json"), encoding="utf-8"))
+            self.id2label = {int(k): v for k, v in spaces.get("id2label", {}).get("urgency", {}).items()}
+        except Exception:
+            self.id2label = {0: "Non-Urgent", 1: "Urgent"}
+
+        self.tokenizer = AutoTokenizer.from_pretrained(model_dir, local_files_only=True)
+        cfg = AutoConfig.from_pretrained(model_dir, local_files_only=True)
+        if getattr(cfg, "model_type", None) == "deberta-v2":
+            self.model = DebertaV2ForSequenceClassification(cfg)
+        else:
+            self.model = AutoModelForSequenceClassification.from_config(cfg)
+
+        sd = None
+        binp = os.path.join(model_dir, "pytorch_model.bin")
+        safep = os.path.join(model_dir, "model.safetensors")
+        if os.path.exists(binp):
+            sd = torch.load(binp, map_location="cpu")
+            if isinstance(sd, dict) and "state_dict" in sd and isinstance(sd["state_dict"], dict):
+                sd = sd["state_dict"]
+        elif os.path.exists(safep):
+            from safetensors.torch import load_file
+            sd = load_file(safep)
+        else:
+            raise FileNotFoundError("No model weights found.")
+
+        sd = _remap_keys(sd)
+        self.model.load_state_dict(sd, strict=False)
+        self.model.to(self.device).eval()
+
+    @torch.inference_mode()
+    def predict(self, text: str):
+        if not text or not text.strip():
+            return {"urgency_score": 0.0, "urgent_label": "Non-Urgent", "rationale": "Empty input."}
+        inputs = self.tokenizer(text, truncation=True, max_length=1024, return_tensors="pt").to(self.device)
+        logits = self.model(**inputs).logits
+        if logits.shape[-1] == 1:
+            score = torch.sigmoid(logits.squeeze(-1)).item()
+        else:
+            score = torch.softmax(logits, dim=-1).squeeze(0)[1].item()
+        label = self.id2label.get(int(score >= self.threshold), "Urgent" if score >= self.threshold else "Non-Urgent")
+        return {"urgency_score": round(float(score), 4), "urgent_label": label, "rationale": self._cheap_rationale(text)}
+
+    def _cheap_rationale(self, text: str, top_n: int = 3):
+        KEYS = ["shot","shooting","gun","stabbing","blood","not breathing","unconscious",
+                "heart","chest pain","stroke","seizure","screaming","help now","immediate",
+                "fire","trapped","domestic","assault","weapon"]
+        t = text.lower()
+        hits = [k for k in KEYS if k in t][:top_n]
+        return "Keywords: " + (", ".join(hits) if hits else "none detected")

requirements.txt

@@ -0,0 +1,9 @@
+torch
+transformers>=4.39
+accelerate
+gradio>=4.0
+faster-whisper==1.0.3
+soundfile
+ffmpeg-python
+safetensors
+huggingface_hub