Upload folder using huggingface_hub

README.md

@@ -1,13 +1,22 @@
 ---
-title: Construction Code Cite
-emoji: 🌍
-colorFrom: purple
-colorTo: gray
+title: Construction Code-Citation Model
+emoji: 🏗️
+colorFrom: blue
+colorTo: yellow
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
+license: mit
+short_description: Qwen 2.5 1.5B + LoRA for OSHA hazard + code citation
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Construction Code-Citation Model
+
+Fine-tuned Qwen 2.5 1.5B for construction-safety incident classification and OSHA 29 CFR 1926 citation grounding.
+
+- **Base:** [Qwen/Qwen2.5-1.5B-Instruct](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct)
+- **Adapter:** [rigidhat/qwen-2.5-construction-codecite-v1](https://huggingface.co/rigidhat/qwen-2.5-construction-codecite-v1)
+- **Dataset:** [rigidhat/construction-code-corpus-v1](https://huggingface.co/datasets/rigidhat/construction-code-corpus-v1)
+
+Built for the [Adaption Labs AutoScientist Challenge](https://adaptionlabs.ai/auto-scientist), "All Other Domains" category. Credit to Adaptive Data by Adaption.

app.py

@@ -0,0 +1,273 @@
+"""HF Space demo for construction-code-cite (v1.1 LoRA).
+
+Uses transformers + peft (not mlx-lm) so it runs on Space Linux CPU.
+Fetches the OSHA 1926 corpus at cold boot from the public HF dataset,
+loads the LoRA adapter on top of Qwen 2.5 1.5B-Instruct, and serves
+strict-JSON hazard + citation predictions through Gradio.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from pathlib import Path
+
+import gradio as gr
+
+BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-1.5B-Instruct")
+ADAPTER_REPO = os.environ.get("ADAPTER_REPO", "rigidhat/qwen-2.5-construction-codecite-v1")
+DATASET_REPO = os.environ.get("DATASET_REPO", "rigidhat/construction-code-corpus-v1")
+MAX_NEW_TOKENS = 384
+RAG_K = 5
+
+CORPUS_PATH = Path(__file__).parent / "osha_1926_corpus.jsonl"
+
+
+def ensure_corpus() -> Path:
+    if CORPUS_PATH.exists():
+        return CORPUS_PATH
+    from huggingface_hub import hf_hub_download
+
+    downloaded = hf_hub_download(
+        repo_id=DATASET_REPO,
+        filename="osha_1926_corpus.jsonl",
+        repo_type="dataset",
+    )
+    Path(downloaded).replace(CORPUS_PATH)
+    return CORPUS_PATH
+
+
+_STANDARD_RE = re.compile(r"1926(?:\.\d+[A-Za-z]?)(?:\([a-zA-Z0-9ivxIVX]+\))*")
+
+
+def build_verifier(corpus_path: Path):
+    sections: dict[str, dict] = {}
+    with corpus_path.open("r", encoding="utf-8") as fh:
+        for line in fh:
+            rec = json.loads(line)
+            cite = (rec.get("citation") or "").strip()
+            match = _STANDARD_RE.search(cite)
+            if match:
+                section = match.group(0).split("(")[0]
+                sections[section] = rec
+
+    def verify(raw: str) -> tuple[bool, str]:
+        match = _STANDARD_RE.search(raw or "")
+        if not match:
+            return False, ""
+        section = match.group(0).split("(")[0]
+        rec = sections.get(section)
+        if not rec:
+            return False, ""
+        return True, rec.get("heading") or ""
+
+    return verify
+
+
+def build_bm25(corpus_path: Path):
+    from rank_bm25 import BM25Okapi
+
+    token_re = re.compile(r"[a-zA-Z][a-zA-Z\-]+|\d+")
+    stopwords = frozenset(
+        "the a an and or but of in on for to with at by from as is are be been being "
+        "this that these those it its which who whom whose what when where why how".split()
+    )
+
+    def tok(text: str) -> list[str]:
+        return [t.lower() for t in token_re.findall(text or "") if t.lower() not in stopwords]
+
+    records: list[dict] = []
+    tokens: list[list[str]] = []
+    with corpus_path.open("r", encoding="utf-8") as fh:
+        for line in fh:
+            rec = json.loads(line)
+            records.append(rec)
+            tokens.append(tok(f"{rec.get('heading', '')}\n{rec.get('text', '')}"))
+    bm25 = BM25Okapi(tokens)
+
+    def search(query: str, k: int = RAG_K):
+        query_tokens = tok(query)
+        if not query_tokens:
+            return []
+        scores = bm25.get_scores(query_tokens)
+        import numpy as np
+
+        top = np.argpartition(scores, -k)[-k:]
+        order = sorted(top, key=lambda i: scores[i], reverse=True)
+        hits = []
+        for i in order[:k]:
+            rec = records[i]
+            hits.append({
+                "section": rec.get("citation") or "",
+                "heading": rec.get("heading") or "",
+                "bm25": float(scores[i]),
+            })
+        return hits
+
+    return search
+
+
+PROMPT = """You are an OSHA-trained construction-safety classifier.
+
+Output STRICT JSON only with this shape (no prose, no markdown):
+{{"hazards":[{{"code_event":{{"id":"<OIICS event id>","title":"<short>"}},
+"code_source":{{"id":"<OIICS source id>","title":"<short>"}},
+"code_nature":{{"id":"<OIICS nature id>","title":"<short>"}},
+"code_body":{{"id":"<OIICS body id>","title":"<short>"}},
+"severity":"low|moderate|high"}}],
+"citations":[{{"standard":"<1926.X>","section_heading":"<heading>"}}]}}
+
+OIICS code IDs are short numeric strings (1-4 digits). Use "OTHER" only when
+no specific code applies. Cite 0-3 OSHA 1926 sections from the candidate list
+below if any apply.
+
+Retrieved OSHA 1926 sections (BM25-ranked candidates):
+{candidates}
+
+Incident narrative:
+\"\"\"{narrative}\"\"\"
+
+JSON:"""
+
+
+_JSON_RE = re.compile(r"\{.*\}", re.DOTALL)
+
+
+def parse_json(raw: str) -> dict:
+    if not raw:
+        return {}
+    match = _JSON_RE.search(raw)
+    if not match:
+        return {}
+    snippet = match.group(0)
+    try:
+        return json.loads(snippet)
+    except json.JSONDecodeError:
+        last = snippet.rfind("}")
+        if last != -1:
+            try:
+                return json.loads(snippet[: last + 1])
+            except json.JSONDecodeError:
+                pass
+    return {}
+
+
+_PIPELINE = None
+
+
+def get_pipeline():
+    global _PIPELINE
+    if _PIPELINE is not None:
+        return _PIPELINE
+    corpus = ensure_corpus()
+    verify = build_verifier(corpus)
+    search = build_bm25(corpus)
+
+    print(f"Loading base model: {BASE_MODEL}")
+    import torch
+    from peft import PeftModel
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
+    base = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL, torch_dtype=torch.float32, trust_remote_code=True
+    )
+    print(f"Loading LoRA adapter: {ADAPTER_REPO}")
+    model = PeftModel.from_pretrained(base, ADAPTER_REPO)
+
+    _PIPELINE = {
+        "tokenizer": tokenizer,
+        "model": model,
+        "search": search,
+        "verify": verify,
+        "torch": torch,
+    }
+    return _PIPELINE
+
+
+def format_candidates(hits) -> str:
+    if not hits:
+        return "(no high-confidence candidates)"
+    return "\n".join(f"- {h['section']}: {h['heading'][:80]}" for h in hits)
+
+
+def predict(narrative: str):
+    if not (narrative or "").strip():
+        return "{}", "(paste an incident narrative first)", "—"
+    t0 = time.time()
+    pipe = get_pipeline()
+    hits = pipe["search"](narrative, k=RAG_K)
+    prompt = PROMPT.format(candidates=format_candidates(hits), narrative=narrative[:1800])
+
+    messages = [{"role": "user", "content": prompt}]
+    chat = pipe["tokenizer"].apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+    inputs = pipe["tokenizer"](chat, return_tensors="pt")
+
+    with pipe["torch"].no_grad():
+        out = pipe["model"].generate(
+            **inputs,
+            max_new_tokens=MAX_NEW_TOKENS,
+            do_sample=False,
+            pad_token_id=pipe["tokenizer"].eos_token_id,
+        )
+    generated = out[0][inputs["input_ids"].shape[1]:]
+    raw = pipe["tokenizer"].decode(generated, skip_special_tokens=True)
+    parsed = parse_json(raw)
+
+    if parsed and "citations" in parsed:
+        for c in parsed["citations"]:
+            is_valid, heading = pipe["verify"](c.get("standard", ""))
+            c["verified"] = is_valid
+            if heading and not c.get("section_heading"):
+                c["section_heading"] = heading
+
+    rag_view = "\n".join(f"- {h['section']}: {h['heading'][:80]}" for h in hits)
+    return json.dumps(parsed, indent=2), rag_view, f"{time.time() - t0:.2f}s"
+
+
+EXAMPLES = [
+    "Worker fell from second-story scaffold platform while installing siding, sustained multiple fractures.",
+    "Employee's hand was caught between two pieces of trench shoring equipment causing partial amputation of two fingers.",
+    "Electrician contacted overhead power line while operating boom lift on a commercial roofing project.",
+]
+
+
+with gr.Blocks(title="Construction Code-Citation") as demo:
+    gr.Markdown("# Construction Code-Citation Model")
+    gr.Markdown(
+        "Qwen 2.5 1.5B fine-tuned on OSHA Severe Injury Reports for the "
+        "[AutoScientist Challenge](https://adaptionlabs.ai/auto-scientist) "
+        "\"All Other Domains\" category. Given a construction-site incident "
+        "narrative, returns strict JSON with OIICS hazard codes plus verified "
+        "OSHA 29 CFR 1926 citations. First request downloads the base model "
+        "(~3 GB, one-time)."
+    )
+    with gr.Row():
+        with gr.Column():
+            narrative = gr.Textbox(
+                label="Incident narrative",
+                lines=5,
+                placeholder="Describe the construction-site incident...",
+            )
+            submit = gr.Button("Classify", variant="primary")
+            gr.Examples(EXAMPLES, inputs=narrative)
+        with gr.Column():
+            output_json = gr.Code(label="Hazards + Citations (JSON)", language="json")
+            rag_view = gr.Textbox(label="OSHA 1926 RAG candidates (BM25)", lines=6)
+            elapsed = gr.Textbox(label="Latency", lines=1)
+
+    submit.click(predict, inputs=[narrative], outputs=[output_json, rag_view, elapsed])
+
+    gr.Markdown(
+        "**Artifacts:** "
+        "[Dataset](https://huggingface.co/datasets/rigidhat/construction-code-corpus-v1) · "
+        "[Model](https://huggingface.co/rigidhat/qwen-2.5-construction-codecite-v1) · "
+        "[Source](https://github.com/snakezilla/construction-code-llm)"
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.44
+transformers>=4.46
+peft>=0.13
+torch>=2.4
+huggingface_hub>=0.25
+rank-bm25>=0.2.2
+numpy