llm4smeft 0.1.0__tar.gz

llm4smeft-0.1.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: llm4smeft
+Version: 0.1.0
+Summary: LLM-driven interactive hypothesis generation for SMEFT global fits
+Author: HEP
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy<2
+Requires-Dist: pandas
+Requires-Dist: huggingface-hub<1.0.0,>=0.33.4
+Requires-Dist: transformers<4.52.0,>=4.45.0
+Requires-Dist: accelerate<1.0.0,>=0.26.0
+Requires-Dist: langchain>=0.3.0
+Requires-Dist: langchain-huggingface<1.3.0,>=0.1.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: torch
+Requires-Dist: python-dotenv
+
+# LLM4SMEFT
+
+LLM-driven interactive hypothesis generation for SMEFT global fits. It works as a prior hyptheses inference to SMEFiT package. 
+
+## Install
+
+```bash
+pip install llm4smeft
+```
+
+
+## Run
+
+```bash
+llm4smeft
+```
+
+This launches the interactive session (equivalent to the old
+`./run.sh` / `python src/experiments/run_interactive.py`).
+
+## Data
+
+The SMEFiT summary records used by the retrieval module ship inside the
+package (`llm4smeft/data/*.json`) and are located relative to the
+installed package files, not the current working directory — so
+`llm4smeft` works from any directory after `pip install`. Session
+records accepted during a run are written back into that same
+installed `data/` folder unless `LLM4SMEFT_DATA_DIR` is set to another
+path.

llm4smeft-0.1.0/README.md

@@ -0,0 +1,29 @@
+# LLM4SMEFT
+
+LLM-driven interactive hypothesis generation for SMEFT global fits. It works as a prior hyptheses inference to SMEFiT package. 
+
+## Install
+
+```bash
+pip install llm4smeft
+```
+
+
+## Run
+
+```bash
+llm4smeft
+```
+
+This launches the interactive session (equivalent to the old
+`./run.sh` / `python src/experiments/run_interactive.py`).
+
+## Data
+
+The SMEFiT summary records used by the retrieval module ship inside the
+package (`llm4smeft/data/*.json`) and are located relative to the
+installed package files, not the current working directory — so
+`llm4smeft` works from any directory after `pip install`. Session
+records accepted during a run are written back into that same
+installed `data/` folder unless `LLM4SMEFT_DATA_DIR` is set to another
+path.

llm4smeft-0.1.0/llm4smeft/benchmarks/cases.py

@@ -0,0 +1,25 @@
+"""Data structures for benchmark cases."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+ALLOWED_CASE_TYPES = {"synthetic", "uv", "null"}
+
+
+@dataclass(slots=True)
+class BenchmarkCase:
+
+
+    case_id: str
+    case_type: str
+    true_support: list[str] | None = None
+    true_coeffs: dict[str, float] | None = None
+    metadata: dict[str, object] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Validate that the benchmark category is supported."""
+        if self.case_type not in ALLOWED_CASE_TYPES:
+            allowed = ", ".join(sorted(ALLOWED_CASE_TYPES))
+            raise ValueError(f"case_type must be one of: {allowed}")

llm4smeft-0.1.0/llm4smeft/chat/session.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+
+@dataclass
+class TurnRecord:
+    """All data produced in one propose → feedback round."""
+    turn:        int
+    role:        str                       # "user" | "assistant"
+    content:     str                       # raw text sent / received
+    subtype:     str | None  = None        # "summary" | "feedback" | None
+    reasoning:   str | None  = None        # CoT reasoning block (assistant only)
+    hypotheses:  list[dict]  = field(default_factory=list)
+    evaluations: list[dict]  = field(default_factory=list)
+    timestamp:   str         = field(default_factory=lambda: _now())
+
+
+# ---------------------------------------------
+# ChatSession
+# ---------------------------------------------
+
+
+class ChatSession:
+    """Manages the message list for one multi-turn SMEFT interaction.
+    """
+
+    def __init__(
+        self,
+        case_id:           str,
+        model:             str,
+        allowed_operators: list[str] | None = None,
+        max_support:       int = 3,
+        session_id:        str | None = None,
+    ) -> None:
+        self.session_id:        str        = session_id or str(uuid.uuid4())[:8]
+        self.case_id:           str        = case_id
+        self.model:             str        = model
+        self.allowed_operators: list[str]  = allowed_operators or []
+        self.max_support:       int        = max_support
+        self.started_at:        str        = _now()
+        self.finished_at:       str | None = None
+        self.accepted_turn:     int | None = None
+
+        self._messages: list[dict[str, str]] = []
+        self._records:  list[TurnRecord]     = []
+        self.current_turn: int = 0
+
+    # ---------------------------------------------
+    # Building the conversation
+    # ---------------------------------------------
+
+    def set_system_message(self, content: str) -> None:
+        """Set (or replace) the system message. Called once at session start."""
+        self._messages = [m for m in self._messages if m["role"] != "system"]
+        self._messages.insert(0, {"role": "system", "content": content})
+
+    def add_summary_message(self, content: str) -> None:
+        """Add the initial physics summary as the first user message."""
+        self.current_turn = 1
+        self._messages.append({"role": "user", "content": content})
+        self._records.append(TurnRecord(
+            turn=self.current_turn,
+            role="user",
+            content=content,
+            subtype="summary",
+        ))
+
+    def add_feedback(self, feedback: str) -> None:
+        """Add a user feedback message, wrapped with full context for the LLM.
+
+        """
+        self.current_turn += 1
+
+
+        enriched = self._build_feedback_message(feedback)
+
+        self._messages.append({"role": "user", "content": enriched})
+        # Store the raw user text in records (clean for human reading)
+        self._records.append(TurnRecord(
+            turn=self.current_turn,
+            role="user",
+            content=feedback,          
+            subtype="feedback",
+        ))
+
+    def _build_feedback_message(self, raw_feedback: str) -> str:
+        
+        prev_hyps = self.last_hypotheses()
+        if prev_hyps:
+            lines = []
+            for i, h in enumerate(prev_hyps, 1):
+                ops = ", ".join(h.get("operators", []))
+                tag = h.get("theory_tag") or ""
+                rat = h.get("rationale") or ""
+                lines.append(f"  {i}. operators=[{ops}]  tag={tag}")
+                if rat:
+                    lines.append(f'     "{rat}"')
+            hyp_block = "\n".join(lines)
+        else:
+            hyp_block = "  (none)"
+
+        ops_str = ", ".join(self.allowed_operators) if self.allowed_operators else "(not set)"
+
+        return (
+            f"[REVISION REQUEST — Turn {self.current_turn}]\n\n"
+            f"Your previous hypotheses:\n{hyp_block}\n\n"
+            f"User feedback: {raw_feedback}\n\n"
+            f"Please revise your hypotheses based on this feedback.\n"
+            f"Constraints remain unchanged:\n"
+            f"  - Allowed operators: {ops_str}\n"
+            f"  - At most {self.max_support} operators per hypothesis\n"
+            f"  - Return the <reasoning>...</reasoning>"
+            f"<hypotheses>...</hypotheses> format"
+        )
+
+    def add_assistant_turn(
+        self,
+        raw_response:  str,
+        reasoning:     str | None,
+        hypotheses:    list[Any],
+        evaluations:   list[Any] | None = None,
+    ) -> None:
+        """Record the LLM's response for the current turn."""
+        self._messages.append({"role": "assistant", "content": raw_response or ""})
+        self._records.append(TurnRecord(
+            turn=self.current_turn,
+            role="assistant",
+            content=raw_response,
+            reasoning=reasoning,
+            hypotheses=[_hyp_to_dict(h) for h in hypotheses],
+            evaluations=[_eval_to_dict(e) for e in (evaluations or [])],
+        ))
+
+    def close(self, accepted_turn: int | None = None) -> None:
+        """Mark the session as finished."""
+        self.finished_at   = _now()
+        self.accepted_turn = accepted_turn
+
+    # ---------------------------------------------
+    # Accessors
+    # ---------------------------------------------
+
+    def messages_for_llm(self, flatten: bool = False) -> list[dict[str, str]]:
+        
+        if not flatten:
+            return list(self._messages)
+
+        system = [m for m in self._messages if m["role"] == "system"]
+        return system + [{"role": "user", "content": self.combined_user_message()}]
+
+    def combined_user_message(self) -> str:
+        
+        summary_msg = next(
+            (r.content for r in self._records if r.subtype == "summary"), "")
+
+        transcript: list[str] = []
+        for rec in self._records:
+            if rec.subtype == "summary":
+                continue
+            if rec.role == "assistant":
+                if rec.hypotheses:
+                    lines = []
+                    for i, h in enumerate(rec.hypotheses, 1):
+                        ops = ", ".join(h.get("operators", []))
+                        tag = h.get("theory_tag") or ""
+                        lines.append(f"    {i}) operators ({ops}), tag: {tag}")
+                    transcript.append(
+                        f"[Turn {rec.turn} — your hypotheses]\n" + "\n".join(lines))
+                else:
+                    transcript.append(
+                        f"[Turn {rec.turn} — your hypotheses]\n    (none parsed)")
+            elif rec.subtype == "feedback":
+                transcript.append(
+                    f"[Turn {rec.turn} — user feedback]\n    {rec.content}")
+
+        ops_str = ", ".join(self.allowed_operators) \
+            if self.allowed_operators else "(not set)"
+
+        parts = [summary_msg]
+        if transcript:
+            parts.append(
+                "--- Conversation so far (compact notation, for reference "
+                "ONLY — do NOT reply in this notation) ---\n"
+                + "\n\n".join(transcript))
+            parts.append(
+                "[Current request]\n"
+                "Revise your hypotheses now, taking EVERY piece of user feedback "
+                "above into account (not only the most recent one).\n"
+                "Constraints remain unchanged:\n"
+                f"  - Allowed operators: {ops_str}\n"
+                f"  - At most {self.max_support} operators per hypothesis\n"
+                "Respond in EXACTLY the output format required by the system "
+                "instructions — the four sentinels, each exactly once, "
+                "nothing before or after:\n"
+                "<<<REASONING>>>\n"
+                "(your analysis — one step per line, each starting with '- ')\n"
+                "<<<END_REASONING>>>\n"
+                "<<<HYPOTHESES>>>\n"
+                "(the JSON object only)\n"
+                "<<<END_HYPOTHESES>>>"
+            )
+        return "\n\n".join(p for p in parts if p)
+
+    def last_hypotheses(self) -> list[dict]:
+        """Return the hypotheses from the most recent assistant turn."""
+        for record in reversed(self._records):
+            if record.role == "assistant":
+                return record.hypotheses
+        return []
+
+    def n_turns(self) -> int:
+        return self.current_turn
+
+    # ------------------------------------------------------
+    # Serialisation
+    # ------------------------------------------------------
+
+
+
+# ------------------------------------------------------
+# Helpers
+# ------------------------------------------------------
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _hyp_to_dict(h: Any) -> dict:
+    if isinstance(h, dict):
+        return h
+    return {
+        "operators":  getattr(h, "operators",  []),
+        "relations":  getattr(h, "relations",  None),
+        "theory_tag": getattr(h, "theory_tag", None),
+        "rationale":  getattr(h, "rationale",  None),
+    }
+
+
+def _eval_to_dict(e: Any) -> dict:
+    if isinstance(e, dict):
+        return e
+    return {
+        "chi2":     getattr(e, "chi2",     None),
+        "aic":      getattr(e, "aic",      None),
+        "bic":      getattr(e, "bic",      None),
+        "n_params": getattr(e, "n_params", None),
+        "metadata": getattr(e, "metadata", {}),
+    }
+
+
+__all__ = ["ChatSession"]

llm4smeft-0.1.0/llm4smeft/chat/store.py

@@ -0,0 +1,93 @@
+"""ChatHistoryStore — saves completed ChatSession objects to disk as JSON files.
+
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .session import ChatSession
+
+
+class ChatHistoryStore:
+    """Save and load chat sessions to/from a directory of JSON files.
+
+    Parameters
+    ----------
+    directory:
+        Path to the storage directory. Created automatically if absent.
+    """
+
+    def __init__(self, directory: str | Path = "chat_history") -> None:
+        self.directory = Path(directory)
+        self.directory.mkdir(parents=True, exist_ok=True)
+
+    # ------------------------------------------------------
+    # Save
+    # ------------------------------------------------------
+
+    def save(self, session: ChatSession) -> Path:
+
+
+        ts       = session.started_at.replace(":", "-")
+        filename = f"{_safe(session.case_id)}_{session.session_id}_{ts}.json"
+        path     = self.directory / filename
+
+        document = {
+            "meta": {
+                "session_id":    session.session_id,
+                "case_id":       session.case_id,
+                "model":         session.model,
+                "started_at":    session.started_at,
+                "finished_at":   session.finished_at,
+                "total_turns":   session.n_turns(),
+                "accepted_turn": session.accepted_turn,
+            },
+            "messages": [
+                {
+                    "turn":       rec.turn,
+                    "role":       rec.role,
+                    "subtype":    rec.subtype,
+                    "content":    rec.content,
+                    "timestamp":  rec.timestamp,
+                    "reasoning":  rec.reasoning,
+                    "hypotheses": rec.hypotheses,
+                    "evaluations": rec.evaluations,
+                }
+                for rec in session._records
+            ],
+            "summary": {
+                "total_turns":      session.n_turns(),
+                "accepted_turn":    session.accepted_turn,
+                "final_hypotheses": session.last_hypotheses(),
+            },
+        }
+
+        path.write_text(json.dumps(document, indent=2), encoding="utf-8")
+        print(f"Session saved → {path}")
+        return path
+
+    # ------------------------------------------------------
+    # Load
+    # ------------------------------------------------------
+
+    def load(self, path: str | Path) -> dict:
+        """Load a single session file. Returns the parsed JSON document."""
+        return json.loads(Path(path).read_text(encoding="utf-8"))
+
+    def list_sessions(self) -> list[Path]:
+        """Return sorted list of all session file paths."""
+        return sorted(self.directory.glob("*.json"))
+
+    def load_all(self) -> list[dict]:
+        """Load and return all session files as a list of dicts."""
+        return [self.load(p) for p in self.list_sessions()]
+
+
+
+def _safe(text: str) -> str:
+    return "".join(c if c.isalnum() or c in "-_" else "_" for c in text)
+
+
+__all__ = ["ChatHistoryStore"]