Initial Deployment without large files

.gitattributes

@@ -0,0 +1,2 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+*.safetensors
+*.parquet

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /code
+
+# Copy requirements and install
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+# Create a non-root user (Hugging Face Spaces requirement)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copy the application code
+COPY --chown=user . $HOME/app
+
+# Expose port 7860
+EXPOSE 7860
+
+# Run the FastAPI server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,14 @@
+---
+title: PACE AI Inference
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+app_port: 7860
+---
+
+# PACE AI Inference Service
+
+This repository powers the AI backend for the PACE (Pipelined Actor-Critic Ensemble) system. 
+
+It exposes a FastAPI backend via Docker running on port 7860, serving multiple specialized pipelines for coding, research, and literacy.

core/config.py

@@ -0,0 +1,25 @@
+from functools import lru_cache
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(
+    BaseSettings
+):  # Renamed to 'Settings' following PEP 8 PascalCase conventions
+    gpu_device: str = Field("cuda:0")
+    max_vram_mb: int = Field(7500)
+    api_host: str = Field("0.0.0.0")
+    api_port: int = Field(8000)
+    models_dir: str = Field("./masteries")
+    max_sequence_length: int = Field(2048)
+    max_critic_iterations: int = Field(5)
+    log_level: str = Field("INFO")
+
+    # Tells Pydantic to read overrides from your .env file
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+
+    return Settings()

core/sandbox/__init__.py

@@ -0,0 +1 @@
+# sandbox package

core/sandbox/executor.py

@@ -0,0 +1,186 @@
+"""
+executor.py — Sandbox Verification Engine (Stream B / Mastery 1: Coding)
+
+Provides a secure, isolated Python subprocess executor that runs
+LLM-generated code snippets against unit tests with strict timeouts.
+
+The Coding Critic uses this to emit a binary reward signal:
+  PASS  → the generated code is functionally correct  (reward = +1)
+  FAIL  → the code has runtime errors or test failures (reward = -1)
+
+Security model:
+  - Code runs in a *child* subprocess — never eval()/exec() in the parent.
+  - stdout/stderr are captured; the parent process is never blocked beyond
+    ``timeout`` seconds.
+  - A minimal ``__builtins__`` restriction note is included in the harness
+    (full sandboxing requires OS-level isolation such as Docker; see
+    ``infra/docker/Dockerfile.sandbox``).
+"""
+
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_TIMEOUT: int = 10        # seconds before the subprocess is killed
+MAX_OUTPUT_CHARS: int = 8_000    # truncate stdout/stderr beyond this
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def run_code(
+    code: str,
+    test_code: Optional[str] = None,
+    timeout: int = DEFAULT_TIMEOUT,
+    python_executable: str = sys.executable,
+) -> dict:
+    """
+    Execute *code* in an isolated subprocess, optionally appending *test_code*.
+
+    The combined script is written to a temporary file, executed by the
+    *python_executable* interpreter, and the results are returned as a dict.
+
+    Args:
+        code:               The LLM-generated Python source to execute.
+        test_code:          Optional unit-test source appended after *code*.
+                            Should use ``assert`` statements or ``unittest``/
+                            ``pytest`` style. If provided, any ``AssertionError``
+                            is treated as a FAIL.
+        timeout:            Maximum wall-clock seconds allowed for execution.
+        python_executable:  Path to the Python interpreter (defaults to the
+                            running interpreter so the same environment is used).
+
+    Returns:
+        A dict with keys:
+          - ``"status"``       : ``"pass"`` | ``"fail"`` | ``"timeout"`` | ``"error"``
+          - ``"stdout"``       : captured standard output (str, truncated)
+          - ``"stderr"``       : captured standard error  (str, truncated)
+          - ``"return_code"``  : process exit code (int), or ``None`` on timeout
+          - ``"elapsed_ms"``   : wall-clock milliseconds spent
+          - ``"label"``        : 1 = pass, 0 = fail  (for Critic reward)
+    """
+    # Build the harness script
+    harness_parts = [textwrap.dedent(code)]
+    if test_code:
+        harness_parts.append("\n\n# --- TEST HARNESS ---\n")
+        harness_parts.append(textwrap.dedent(test_code))
+    full_script = "\n".join(harness_parts)
+
+    # Write to a temp file (auto-deleted after execution)
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        suffix=".py",
+        prefix="pace_sandbox_",
+        delete=False,
+        encoding="utf-8",
+    ) as tmp:
+        tmp.write(full_script)
+        tmp_path = Path(tmp.name)
+
+    start = time.perf_counter()
+    try:
+        proc = subprocess.run(
+            [python_executable, str(tmp_path)],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        elapsed_ms = int((time.perf_counter() - start) * 1000)
+
+        stdout = proc.stdout[:MAX_OUTPUT_CHARS]
+        stderr = proc.stderr[:MAX_OUTPUT_CHARS]
+        return_code = proc.returncode
+
+        if return_code == 0:
+            status = "pass"
+            label = 1
+        else:
+            status = "fail"
+            label = 0
+
+    except subprocess.TimeoutExpired:
+        elapsed_ms = timeout * 1000
+        stdout = ""
+        stderr = f"Execution timed out after {timeout}s."
+        return_code = None
+        status = "timeout"
+        label = 0
+
+    except Exception as exc:
+        elapsed_ms = int((time.perf_counter() - start) * 1000)
+        stdout = ""
+        stderr = str(exc)
+        return_code = -1
+        status = "error"
+        label = 0
+
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+    return {
+        "status": status,
+        "stdout": stdout,
+        "stderr": stderr,
+        "return_code": return_code,
+        "elapsed_ms": elapsed_ms,
+        "label": label,
+    }
+
+
+def batch_run(
+    code_test_pairs: list[tuple[str, Optional[str]]],
+    timeout: int = DEFAULT_TIMEOUT,
+) -> list[dict]:
+    """
+    Run multiple (code, test_code) pairs sequentially and return a list of
+    result dicts. Useful for batch evaluation during Critic training.
+
+    Args:
+        code_test_pairs: List of (code, test_code) tuples.
+        timeout:         Per-execution timeout in seconds.
+
+    Returns:
+        List of result dicts as returned by :func:`run_code`.
+    """
+    return [run_code(code, test, timeout=timeout) for code, test in code_test_pairs]
+
+
+# ---------------------------------------------------------------------------
+# CLI smoke-test
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    print("=== Sandbox Executor — Smoke Test ===\n")
+
+    # Test 1: correct code
+    result = run_code(
+        code="def add(a, b): return a + b",
+        test_code="assert add(2, 3) == 5\nassert add(-1, 1) == 0\nprint('Tests passed.')",
+    )
+    print(f"[PASS expected]  status={result['status']}  label={result['label']}")
+    print(f"  stdout: {result['stdout'].strip()}")
+
+    # Test 2: buggy code (assertion will fail)
+    result = run_code(
+        code="def add(a, b): return a - b",   # bug: subtraction instead of addition
+        test_code="assert add(2, 3) == 5",
+    )
+    print(f"\n[FAIL expected]  status={result['status']}  label={result['label']}")
+    print(f"  stderr: {result['stderr'].strip()[:200]}")
+
+    # Test 3: infinite loop → timeout
+    result = run_code(
+        code="while True: pass",
+        timeout=2,
+    )
+    print(f"\n[TIMEOUT expected]  status={result['status']}  label={result['label']}")

main.py

@@ -0,0 +1,69 @@
+import json
+import traceback
+from pydantic import BaseModel
+from typing import Optional
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import threading
+
+app = FastAPI(
+    title="PACE AI Inference Service",
+    description="Hugging Face Deployment for PACE Actor-Critic Ensemble",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class GenerateRequest(BaseModel):
+    text: str
+    mode: Optional[str] = "coding"
+    speed_mode: Optional[str] = "pro"
+
+_generate_lock = threading.Lock()
+
+@app.get("/")
+def root():
+    return {"status": "PACE AI Service Running"}
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+@app.post("/generate_stream")
+def generate_stream(request: GenerateRequest):
+    def event_stream():
+        if not _generate_lock.acquire(blocking=False):
+            yield json.dumps({"type": "status", "content": "Server busy"}) + "\n"
+            yield json.dumps({"type": "done"}) + "\n"
+            return
+            
+        try:
+            mode = request.mode
+            speed = request.speed_mode
+            
+            if mode == "literacy":
+                from masteries.literacy.inference.v4_orchestrator import literacy_pipeline as active_pipeline
+            elif mode == "research":
+                from masteries.research.inference.v4_orchestrator import research_pipeline as active_pipeline
+            else:
+                from masteries.coding.inference.v4_orchestrator import v4_pipeline as active_pipeline
+
+            for event in active_pipeline(request.text, speed_mode=speed):
+                # The event is already a dictionary.
+                yield json.dumps(event) + "\n"
+                
+            yield json.dumps({"type": "done"}) + "\n"
+        except Exception as e:
+            traceback.print_exc()
+            yield json.dumps({"type": "error", "content": str(e)}) + "\n"
+        finally:
+            _generate_lock.release()
+
+    return StreamingResponse(event_stream(), media_type="application/x-ndjson")

masteries/coding/__init__.py

@@ -0,0 +1 @@
+# masteries.coding package

masteries/coding/artifacts/critic_v1/config.json

@@ -0,0 +1,43 @@
+{
+  "_num_labels": 1,
+  "activation_function": "gelu_new",
+  "add_cross_attention": false,
+  "architectures": [
+    "GPT2ForSequenceClassification"
+  ],
+  "attn_pdrop": 0.1,
+  "bos_token_id": 50256,
+  "dtype": "float32",
+  "embd_pdrop": 0.1,
+  "eos_token_id": 50256,
+  "initializer_range": 0.02,
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "gpt2",
+  "n_ctx": 1024,
+  "n_embd": 768,
+  "n_head": 12,
+  "n_inner": null,
+  "n_layer": 6,
+  "n_positions": 1024,
+  "pad_token_id": 50256,
+  "problem_type": "single_label_classification",
+  "reorder_and_upcast_attn": false,
+  "resid_pdrop": 0.1,
+  "scale_attn_by_inverse_layer_idx": false,
+  "scale_attn_weights": true,
+  "summary_activation": null,
+  "summary_first_dropout": 0.1,
+  "summary_proj_to_labels": true,
+  "summary_type": "cls_index",
+  "summary_use_proj": true,
+  "task_specific_params": {
+    "text-generation": {
+      "do_sample": true,
+      "max_length": 50
+    }
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.13.0",
+  "use_cache": true,
+  "vocab_size": 50257
+}

masteries/coding/artifacts/critic_v1/tokenizer_config.json

@@ -0,0 +1,13 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "is_local": false,
+  "local_files_only": false,
+  "model_max_length": 1024,
+  "pad_token": "<|endoftext|>",
+  "tokenizer_class": "GPT2Tokenizer",
+  "unk_token": "<|endoftext|>"
+}

masteries/coding/data/check_langs.py

@@ -0,0 +1,16 @@
+import datasets
+
+def main():
+    ds = datasets.load_dataset("ByteDance-Seed/Code-Contests-Plus", split="train", streaming=True)
+    langs = set()
+    for i, item in enumerate(ds):
+        for sub in item.get('correct_submissions', []):
+            langs.add(sub.get('language', ''))
+        for sub in item.get('incorrect_submissions', []):
+            langs.add(sub.get('language', ''))
+        if i >= 100:
+            break
+    print("Available languages:", langs)
+
+if __name__ == "__main__":
+    main()

masteries/coding/data/continuous_learning.jsonl

@@ -0,0 +1 @@
+{"prompt": "write a code for binary search", "target_code": "# Generated by Critic due to Actor failure\ndef binary_search(arr, target):\n    low, high = 0, len(arr) - 1\n    \n    while low <= high:\n        mid = (low + high) // 2\n        if arr[mid] == target:\n            return mid\n        elif arr[mid] < target:\n            low = mid + 1\n        else:\n            high = mid - 1\n            \n    return -1"}

masteries/coding/data/download.py

@@ -0,0 +1,9 @@
+from datasets import load_dataset
+
+dataset = load_dataset("nuprl/stack-dedup-python-testgen-starcoder-filter-v2")
+
+
+print(dataset)
+print("Saving dataset to disk... please wait a few seconds...")
+dataset["train"].to_parquet("masteries/coding/data/raw/stack_python_157k.parquet")
+print("SUCCESS: File permanently saved to disk!")

masteries/coding/data/explore_hf_dataset.py

@@ -0,0 +1,23 @@
+import datasets
+
+print("Exploring open-r1/codeforces-submissions...")
+try:
+    ds1 = datasets.load_dataset("open-r1/codeforces-submissions", split="train", streaming=True)
+    for i, item in enumerate(ds1):
+        print("Codeforces Sample:", item.keys())
+        print(item)
+        break
+except Exception as e:
+    print(f"Error loading Codeforces: {e}")
+
+print("\nExploring ByteDance-Seed/Code-Contests-Plus...")
+try:
+    ds2 = datasets.load_dataset("ByteDance-Seed/Code-Contests-Plus", split="train", streaming=True)
+    for i, item in enumerate(ds2):
+        print("CodeContests+ Sample:", item.keys())
+        # Truncate some large strings if necessary
+        keys_to_print = {k: v[:200] if isinstance(v, str) else v for k, v in item.items()}
+        print(keys_to_print)
+        break
+except Exception as e:
+    print(f"Error loading CodeContests+: {e}")

masteries/coding/data/generate_codecontests_dataset.py

@@ -0,0 +1,75 @@
+import os
+import pandas as pd
+import datasets
+
+
+def main():
+    OUTPUT_DIR = "masteries/coding/data/raw"
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    OUTPUT_PATH = os.path.join(OUTPUT_DIR, "codecontests_fused_dataset.parquet")
+
+    print("Loading ByteDance-Seed/Code-Contests-Plus dataset (streaming mode)...")
+    ds = datasets.load_dataset(
+        "ByteDance-Seed/Code-Contests-Plus", split="train", streaming=True
+    )
+
+    clean_data = []
+    buggy_data = []
+
+    # Target dataset size: 50k clean, 50k buggy
+    TARGET_PER_CLASS = 50000
+
+    print(f"Extracting up to {TARGET_PER_CLASS} Python samples per class...")
+
+    for item in ds:
+        # Extract correct submissions (Clean / Label 0)
+        for sub in item.get("correct_submissions", []):
+            if (
+                "python" in str(sub.get("language", "")).lower()
+                and len(clean_data) < TARGET_PER_CLASS
+            ):
+                clean_data.append(
+                    {"mutated_code": sub.get("code", ""), "label": "CLEAN"}
+                )
+
+        # Extract incorrect submissions (Buggy / Label 1)
+        for sub in item.get("incorrect_submissions", []):
+            if (
+                "python" in str(sub.get("language", "")).lower()
+                and len(buggy_data) < TARGET_PER_CLASS
+            ):
+                buggy_data.append({"mutated_code": sub.get("code", ""), "label": "BUG"})
+
+        # Stop early if we have enough data
+        if len(clean_data) >= TARGET_PER_CLASS and len(buggy_data) >= TARGET_PER_CLASS:
+            break
+
+    print(f"Extracted {len(clean_data)} CLEAN samples.")
+    print(f"Extracted {len(buggy_data)} BUGGY samples.")
+
+    df_clean = pd.DataFrame(clean_data)
+    df_bugs = pd.DataFrame(buggy_data)
+
+    print("Fusing and randomizing dataset...")
+    df_fused = pd.concat([df_clean, df_bugs], ignore_index=True)
+
+    # Remove completely duplicated snippets
+    df_fused = df_fused.drop_duplicates(
+        subset=["mutated_code"], keep="first"
+    ).reset_index(drop=True)
+
+    # Final deep shuffle
+    df_fused = df_fused.sample(frac=1, random_state=42).reset_index(drop=True)
+
+    print(f"Saving to {OUTPUT_PATH}...")
+    df_fused.to_parquet(OUTPUT_PATH)
+
+    print(f"SUCCESS! Dataset saved to {OUTPUT_PATH}")
+    print(f"Total Rows: {len(df_fused)}")
+    print(
+        f"Clean Data: {(df_fused['label'] == 'CLEAN').sum()} | Bug Data: {(df_fused['label'] == 'BUG').sum()}"
+    )
+
+
+if __name__ == "__main__":
+    main()

masteries/coding/data/generate_codeforces_dataset.py

@@ -0,0 +1,72 @@
+import os
+import pandas as pd
+import datasets
+
+
+def main():
+    OUTPUT_DIR = "masteries/coding/data/raw"
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    OUTPUT_PATH = os.path.join(OUTPUT_DIR, "codeforces_fused_dataset.parquet")
+
+    print("Loading open-r1/codeforces-submissions dataset (streaming mode)...")
+    ds = datasets.load_dataset(
+        "open-r1/codeforces-submissions", split="train", streaming=True
+    )
+
+    clean_data = []
+    buggy_data = []
+
+    # Target dataset size: 50k clean, 50k buggy
+    TARGET_PER_CLASS = 50000
+
+    print(f"Extracting up to {TARGET_PER_CLASS} Python samples per class...")
+
+    for item in ds:
+        lang = str(item.get("programmingLanguage", "")).lower()
+        if "python" not in lang and "pypy" not in lang:
+            continue
+
+        verdict = item.get("verdict", "")
+        code = item.get("source", "")
+
+        if verdict == "OK" and len(clean_data) < TARGET_PER_CLASS:
+            clean_data.append({"mutated_code": code, "label": "CLEAN"})
+        elif (
+            verdict in ["WRONG_ANSWER", "TIME_LIMIT_EXCEEDED", "RUNTIME_ERROR"]
+            and len(buggy_data) < TARGET_PER_CLASS
+        ):
+            buggy_data.append({"mutated_code": code, "label": "BUG"})
+
+        # Stop early if we have enough data
+        if len(clean_data) >= TARGET_PER_CLASS and len(buggy_data) >= TARGET_PER_CLASS:
+            break
+
+    print(f"Extracted {len(clean_data)} CLEAN samples.")
+    print(f"Extracted {len(buggy_data)} BUGGY samples.")
+
+    df_clean = pd.DataFrame(clean_data)
+    df_bugs = pd.DataFrame(buggy_data)
+
+    print("Fusing and randomizing dataset...")
+    df_fused = pd.concat([df_clean, df_bugs], ignore_index=True)
+
+    # Remove completely duplicated snippets
+    df_fused = df_fused.drop_duplicates(
+        subset=["mutated_code"], keep="first"
+    ).reset_index(drop=True)
+
+    # Final deep shuffle
+    df_fused = df_fused.sample(frac=1, random_state=42).reset_index(drop=True)
+
+    print(f"Saving to {OUTPUT_PATH}...")
+    df_fused.to_parquet(OUTPUT_PATH)
+
+    print(f"SUCCESS! Dataset saved to {OUTPUT_PATH}")
+    print(f"Total Rows: {len(df_fused)}")
+    print(
+        f"Clean Data: {(df_fused['label'] == 'CLEAN').sum()} | Bug Data: {(df_fused['label'] == 'BUG').sum()}"
+    )
+
+
+if __name__ == "__main__":
+    main()

masteries/coding/data/generate_critic_datasets.py

@@ -0,0 +1,104 @@
+import os
+import pandas as pd
+import numpy as np
+
+# 1. Define paths
+RAW_PARQUET_PATH = "masteries/coding/data/raw/stack_python_157k.parquet"
+OUTPUT_DIR = "masteries/coding/data/raw"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+print("Loading the master dataset...")
+df_master = pd.read_parquet(RAW_PARQUET_PATH)
+
+# 2. SHUFFLE FIRST: Destroy any original order in the dataset
+print("Performing initial shuffle...")
+df_master = df_master.sample(frac=1, random_state=42).reset_index(drop=True)
+
+# 3. THE ROUND-ROBIN ALLOCATOR
+# We use modulo 6 to perfectly zipper the data (50% Clean, 50% Bugs spread across 3 types)
+# Pattern: 0=Clean, 1=Flip, 2=Clean, 3=Constant, 4=Clean, 5=Deletion
+print("Slicing into mutually exclusive categories...")
+conditions = [
+    (df_master.index % 6 == 0) | (df_master.index % 6 == 2) | (df_master.index % 6 == 4), # 50% Clean
+    (df_master.index % 6 == 1), # 16.6% Flip
+    (df_master.index % 6 == 3), # 16.6% Constant
+    (df_master.index % 6 == 5)  # 16.6% Deletion
+]
+choices = ['CLEAN', 'FLIP', 'CONSTANT', 'DELETION']
+df_master['assigned_type'] = np.select(conditions, choices, default='UNKNOWN')
+
+# Isolate the slices
+df_clean = df_master[df_master['assigned_type'] == 'CLEAN'].copy()
+df_flips = df_master[df_master['assigned_type'] == 'FLIP'].copy()
+df_constants = df_master[df_master['assigned_type'] == 'CONSTANT'].copy()
+df_deletions = df_master[df_master['assigned_type'] == 'DELETION'].copy()
+
+# ==========================================
+# APPLY MUTATIONS (Safely isolated)
+# ==========================================
+print(f"Applying mutations (Zero Overlap Guaranteed)...")
+
+# FLIPS
+df_flips["mutated_code"] = (
+    df_flips["content"]
+    .str.replace(" == ", " != ", regex=False)
+    .str.replace(" < ", " > ", regex=False)
+    .str.replace(" + ", " - ", regex=False)
+)
+df_flips["bug_type"] = "OPERATOR_FLIP"
+df_flips["label"] = "BUG"
+df_flips = df_flips[df_flips["mutated_code"] != df_flips["content"]].copy()
+
+# CONSTANTS
+df_constants["mutated_code"] = (
+    df_constants["content"]
+    .str.replace(" 0", " 1", regex=False)
+    .str.replace("True", "False", regex=False)
+    .str.replace("False", "True", regex=False)
+)
+df_constants["bug_type"] = "CONSTANT_SHIFT"
+df_constants["label"] = "BUG"
+df_constants = df_constants[df_constants["mutated_code"] != df_constants["content"]].copy()
+
+# DELETIONS
+def drop_return_statement(code_str):
+    lines = str(code_str).split("\n")
+    surviving_lines = [line for line in lines if "return " not in line]
+    return "\n".join(surviving_lines)
+
+df_deletions["mutated_code"] = df_deletions["content"].apply(drop_return_statement)
+df_deletions["bug_type"] = "STATEMENT_DELETION"
+df_deletions["label"] = "BUG"
+df_deletions = df_deletions[df_deletions["mutated_code"] != df_deletions["content"]].copy()
+
+# CLEAN
+df_clean["mutated_code"] = df_clean["content"]
+df_clean["bug_type"] = "CLEAN"
+df_clean["label"] = "CLEAN"
+
+# ==========================================
+# BALANCE THE CLASSES (50/50 MATCH)
+# ==========================================
+total_surviving_bugs = len(df_flips) + len(df_constants) + len(df_deletions)
+print(f"Trimming clean data from {len(df_clean)} down to {total_surviving_bugs}...")
+df_clean = df_clean.sample(n=total_surviving_bugs, random_state=42).copy()
+
+# ==========================================
+# RECOMBINE & FINAL SHUFFLE
+# ==========================================
+print("Fusing and randomizing final dataset...")
+df_fused = pd.concat([df_clean, df_flips, df_constants, df_deletions], ignore_index=True)
+
+# Remove rows sharing identical code logic (duplicates)
+df_fused = df_fused.drop_duplicates(subset=["mutated_code"], keep="first").reset_index(drop=True)
+
+# Final deep shuffle so the Critic learns no sequential patterns
+df_fused = df_fused.sample(frac=1, random_state=99).reset_index(drop=True)
+
+# Save
+fused_path = os.path.join(OUTPUT_DIR, "critic_fused_dataset.parquet")
+df_fused.to_parquet(fused_path)
+
+print(f"SUCCESS! Dataset saved to {fused_path}")
+print(f"Total Rows: {len(df_fused)}")
+print(f"Clean Data: {(df_fused['label'] == 'CLEAN').sum()} | Bug Data: {(df_fused['label'] == 'BUG').sum()}")

masteries/coding/data/generate_pyresbugs_dataset.py

@@ -0,0 +1,60 @@
+import os
+import pandas as pd
+from datasets import load_dataset
+
+# 1. Define paths
+OUTPUT_DIR = "masteries/coding/data/raw"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+OUTPUT_PATH = os.path.join(OUTPUT_DIR, "pyresbugs_fused_dataset.parquet")
+
+print("Downloading OSS-forge/PyResBugs dataset...")
+dataset = load_dataset("OSS-forge/PyResBugs")
+
+# PyResBugs only has a train split
+df_master = pd.DataFrame(dataset['train'])
+
+print(f"Loaded {len(df_master)} raw bugs from PyResBugs.")
+
+# 2. Extract CLEAN data (Fault Free Code)
+df_clean = pd.DataFrame({
+    "mutated_code": df_master["Fault Free Code"],
+    "bug_type": "CLEAN",
+    "label": "CLEAN"
+})
+
+# 3. Extract BUG data (Faulty Code)
+df_bugs = pd.DataFrame({
+    "mutated_code": df_master["Faulty Code"],
+    "bug_type": df_master["Fault_Acronym"].fillna("UNKNOWN_BUG"),
+    "label": "BUG"
+})
+
+# 4. Remove rows where Faulty and Fault Free code are identical (just in case)
+# We can do this by merging and comparing
+invalid_mask = df_master["Fault Free Code"] == df_master["Faulty Code"]
+num_invalid = invalid_mask.sum()
+if num_invalid > 0:
+    print(f"Warning: Found {num_invalid} rows where Faulty Code == Fault Free Code. Dropping them.")
+    df_clean = df_clean[~invalid_mask]
+    df_bugs = df_bugs[~invalid_mask]
+
+# Drop NaNs just in case
+df_clean = df_clean.dropna(subset=["mutated_code"])
+df_bugs = df_bugs.dropna(subset=["mutated_code"])
+
+# 5. Recombine & Shuffle
+print("Fusing and randomizing dataset...")
+df_fused = pd.concat([df_clean, df_bugs], ignore_index=True)
+
+# Remove completely duplicated snippets
+df_fused = df_fused.drop_duplicates(subset=["mutated_code"], keep="first").reset_index(drop=True)
+
+# Final deep shuffle
+df_fused = df_fused.sample(frac=1, random_state=42).reset_index(drop=True)
+
+# Save
+df_fused.to_parquet(OUTPUT_PATH)
+
+print(f"SUCCESS! Dataset saved to {OUTPUT_PATH}")
+print(f"Total Rows: {len(df_fused)}")
+print(f"Clean Data: {(df_fused['label'] == 'CLEAN').sum()} | Bug Data: {(df_fused['label'] == 'BUG').sum()}")

masteries/coding/data/inspect_data.py

@@ -0,0 +1,11 @@
+import pandas as pd
+
+df = pd.read_parquet("masteries/coding/data/raw/stack_python_157k.parquet")
+
+
+print("\n--- Here is Row 0: The First Code Example! ---")
+print("FUNCTION CODE:")
+print(df["content"].iloc[0])  # iloc[0] means "Index Location 0" (the first row)
+
+print("\nAUTOMATED UNIT TESTS:")
+print(df["tests"].iloc[0])

masteries/coding/data/test_sandbox.py

@@ -0,0 +1,39 @@
+import subprocess
+import sys
+
+# 1. Let's create a sample code string with a DELIBERATE bug (2 + 2 = 5!)
+buggy_code = """
+def add_numbers(a, b):
+    return a + b + 1  # BUG: Flipped logic / off-by-one error!
+"""
+
+# 2. Let's attach an objective unit test assertion
+unit_test = """
+assert add_numbers(2, 2) == 4, "Math failed: 2 + 2 should be 4!"
+print("ALL TESTS PASSED!")
+"""
+
+# We combine them into a single executable payload
+full_payload = buggy_code + "\n" + unit_test
+
+print("Launching isolated child subprocess to verify code...")
+
+try:
+    # 3. We spawn a child python process to execute the payload with a 2-second timeout!
+    result = subprocess.run(
+        [sys.executable, "-c", full_payload],
+        capture_output=True,  # Capture what prints to screen
+        text=True,  # Decode output as strings, not raw bytes
+        timeout=2.0,  # Kill process if it loops for more than 2 seconds
+    )
+
+    # 4. Evaluate the Exit Code (0 = Success, anything else = Crash/Test Failure)
+    if result.returncode == 0:
+        print("SANDBOX RESULT: CLEAN (All unit tests passed!)")
+        print("Output:", result.stdout.strip())
+    else:
+        print("SANDBOX RESULT: BUG DETECTED (Unit test failed!)")
+        print("Error Traceback:\n", result.stderr.strip())
+
+except subprocess.TimeoutExpired:
+    print("SANDBOX RESULT: INFINITE LOOP TERMINATED (Exceeded 2.0s limit!)")

masteries/coding/inference/__init__.py

@@ -0,0 +1 @@
+# masteries.coding.inference package

masteries/coding/inference/actor_generate.py

@@ -0,0 +1,80 @@
+"""
+PACE Actor Inference Node
+Task LE-1: Loads the trained Actor Model, generates multiple code fixes based on a prompt.
+"""
+
+import os
+import torch
+import gc
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+
+def generate_fixes(
+    prompt: str,
+    model_dir: str = "masteries/coding/models/actor_v1",
+    num_return_sequences: int = 3,
+    fallback_model: str = "bigcode/tiny_starcoder_py",
+) -> list[str]:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    target_dir = model_dir if os.path.exists(model_dir) else fallback_model
+
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(target_dir)
+    except Exception:
+        tokenizer = None
+
+    if tokenizer is None and target_dir != fallback_model:
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(fallback_model)
+        except Exception:
+            tokenizer = None
+
+    if tokenizer is None:
+        raise ValueError(
+            f"Failed to load tokenizer from '{target_dir}' or fallback '{fallback_model}'."
+        )
+
+    if getattr(tokenizer, "pad_token", None) is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # Load the custom 164M fine-tuned Actor (or fallback base model)
+    try:
+        model = AutoModelForCausalLM.from_pretrained(target_dir).to(device)
+    except Exception:
+        model = AutoModelForCausalLM.from_pretrained(fallback_model).to(device)
+
+    inputs = tokenizer(
+        prompt,
+        return_tensors="pt",
+        truncation=True,
+    )
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        generated_ids = model.generate(
+            **inputs,
+            max_new_tokens=256,
+            temperature=0.7,
+            do_sample=True,
+            num_return_sequences=num_return_sequences,
+        )
+
+    decoded_texts = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)
+
+    # VRAM PURGE: Destroy tensors and clear cache
+    del model, tokenizer, inputs, generated_ids
+    gc.collect()
+    if device.type == "cuda":
+        torch.cuda.empty_cache()
+        print(
+            f"[VRAM] Actor Purged. Idling Footprint: {torch.cuda.memory_allocated() / (1024**2):.2f} MB"
+        )
+
+    return decoded_texts
+
+
+if __name__ == "__main__":
+    print("[SYSTEM] Testing Actor Inference Engine")
+    test_prompt = "def linear_search(arr):"
+    print(generate_fixes(test_prompt, num_return_sequences=1))

masteries/coding/inference/critic_predict.py

@@ -0,0 +1,84 @@
+"""
+PACE Critic Inference Node
+Task LE-2: Loads the trained 125M CodeBERT Critic, evaluates a batch of code strings.
+"""
+
+import os
+import torch
+import gc
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+
+def evaluate_syntax_batch(
+    code_snippets: list[str],
+    model_dir: str = "masteries/coding/models/critic_v3",
+    fallback_model: str = "microsoft/codebert-base",
+) -> list[float]:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    target_dir = model_dir if os.path.exists(model_dir) else fallback_model
+
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(target_dir)
+    except Exception:
+        tokenizer = None
+
+    if tokenizer is None and target_dir != fallback_model:
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(fallback_model)
+        except Exception:
+            tokenizer = None
+
+    if tokenizer is None:
+        raise ValueError(
+            f"Failed to load tokenizer from '{target_dir}' or fallback '{fallback_model}'."
+        )
+
+    if getattr(tokenizer, "pad_token", None) is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    # Initialize with num_labels=2 for binary classification
+    try:
+        model = AutoModelForSequenceClassification.from_pretrained(
+            target_dir, num_labels=2
+        ).to(device)
+    except Exception:
+        model = AutoModelForSequenceClassification.from_pretrained(
+            fallback_model, num_labels=2
+        ).to(device)
+
+    inputs = tokenizer(
+        code_snippets,
+        truncation=True,
+        max_length=512,
+        padding="max_length",
+        return_tensors="pt",
+    )
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    # Convert raw logits to percentages (0.0 to 1.0)
+    probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+
+    # Extract the probability of Class 1 (Bug). Lower is better (closer to 0 / Clean).
+    bug_probs = probabilities[:, 1].tolist()
+
+    # VRAM PURGE: Destroy tensors and clear cache
+    del model, tokenizer, inputs, outputs, probabilities
+    gc.collect()
+    if device.type == "cuda":
+        torch.cuda.empty_cache()
+        print(
+            f"[VRAM] Critic Purged. Idling Footprint: {torch.cuda.memory_allocated() / (1024**2):.2f} MB"
+        )
+
+    return bug_probs
+
+
+if __name__ == "__main__":
+    print("[SYSTEM] Testing Critic Inference Engine...")
+    bad_code = ["def calculate_sum(a, b) return a + b"]
+    print("Testing Critic Inference Engine...")
+    print(evaluate_syntax_batch(bad_code))

masteries/coding/inference/test_critic_brain.py

@@ -0,0 +1,35 @@
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model_dir = "masteries/coding/models/critic_best"
+
+print("Loading Critic...")
+tokenizer = AutoTokenizer.from_pretrained(model_dir)
+model = AutoModelForSequenceClassification.from_pretrained(model_dir).to(device)
+model.eval()
+
+clean_code = """
+def multiply(a, b):
+    return a * b
+"""
+
+buggy_code = """
+def multiply(a, b):
+    return a + b
+"""
+
+
+def predict_bug(code_str):
+    inputs = tokenizer(
+        code_str, return_tensors="pt", truncation=True, max_length=512
+    ).to(device)
+    with torch.no_grad():
+        logits = model(**inputs).logits
+        probs = torch.softmax(logits, dim=1)
+        # Class 1 is "BUG"
+        return probs[0][1].item()
+
+
+print(f"\n[CLEAN CODE] Bug Probability: {predict_bug(clean_code):.4f}")
+print(f"[BUGGY CODE] Bug Probability: {predict_bug(buggy_code):.4f}")

masteries/coding/inference/v4_orchestrator.py

@@ -0,0 +1,127 @@
+import gc
+import sys
+import torch
+
+from masteries.coding.training.actor.alt_actor_model import ActorModel
+from masteries.coding.training.critic.alt_critic_model import QwenCritic
+
+# Global instances to avoid reloading models on every request
+_actor = None
+_critic = None
+
+
+def get_actor():
+    global _actor
+    if _actor is None:
+        print("Initializing Actor Model...")
+        _actor = ActorModel()
+    return _actor
+
+
+def get_critic():
+    global _critic
+    if _critic is None:
+        print("Initializing Critic Model...")
+        _critic = QwenCritic()
+    return _critic
+
+
+def flush_vram():
+    """Forces PyTorch to release memory back to the OS."""
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+def v4_pipeline(user_prompt, max_iterations=1, speed_mode="pro"):
+    """
+    PACE Dual-Engine Orchestrator.
+    Uses the Actor (3B) to generate code and Critic (1.5B) to review and revise.
+    """
+    yield {
+        "type": "status",
+        "content": f"Initializing Actor-Critic Ensemble (v4 - {speed_mode} mode)...",
+    }
+
+    # Load models
+    actor = get_actor()
+    if speed_mode == "pro":
+        critic = get_critic()
+
+    yield {"type": "status", "content": "Actor is generating initial code..."}
+
+    # Generate initial code
+    code_snippet = ""
+    for token in actor.generate_code(user_prompt):
+        code_snippet += token
+        yield {"type": "token", "content": token}
+
+    # Clear CUDA cache after Actor completes generation
+    flush_vram()
+
+    if speed_mode == "pro":
+        for i in range(max_iterations):
+            yield {
+                "type": "status",
+                "content": f"Critic is analyzing the code (Iteration {i+1})...",
+            }
+
+            # Critique the generated code
+            print(f"\n--- CRITIQUE (Iteration {i+1}) ---")
+            critique = ""
+            for token in critic.critique(code_snippet, context=user_prompt):
+                critique += token
+                print(token, end="", flush=True)
+            print("\n-----------------------------\n")
+
+            # Clear CUDA cache after Critic completes analysis
+            flush_vram()
+
+            # Check if critic is satisfied (basic heuristic)
+            lower_critique = critique.lower()
+            if (
+                "looks good" in lower_critique
+                or "no issues" in lower_critique
+                or "no bugs" in lower_critique
+                or "is correct" in lower_critique
+            ):
+                yield {"type": "status", "content": "Critic approved the code!"}
+                break
+
+            yield {
+                "type": "status",
+                "content": f"Critic found issues. Actor is revising (Iteration {i+1})...",
+            }
+            yield {"type": "clear"}  # Clear the chat window for the revised code
+
+            new_code_snippet = ""
+            for token in actor.revise_code(user_prompt, code_snippet, critique):
+                new_code_snippet += token
+                yield {"type": "token", "content": token}
+
+            code_snippet = new_code_snippet
+
+            # Clear CUDA cache after Actor completes revision
+            flush_vram()
+
+    yield {"type": "status", "content": "Ensemble Pipeline Complete."}
+
+
+# Alias for backward compatibility / streaming callers
+v4_stream_pipeline = v4_pipeline
+
+if __name__ == "__main__":
+    print("Testing v4_pipeline directly...")
+    test_prompt = "Write a Python function to calculate the factorial of a number."
+
+    for event in v4_pipeline(test_prompt):
+        if event["type"] == "token":
+            import sys
+
+            sys.stdout.write(event["content"])
+            sys.stdout.flush()
+        elif event["type"] == "status":
+            print(f"\n[STATUS] {event['content']}")
+        elif event["type"] == "clear":
+            print("\n[CLEAR] (Actor is revising...)")
+    print("\n\nTest execution finished.")

masteries/coding/inference/watchdog.py

@@ -0,0 +1,63 @@
+import subprocess
+import time
+
+MAX_TEMP = 83
+
+
+def get_gpu_temp():
+    try:
+        output = subprocess.check_output(
+            [
+                "nvidia-smi",
+                "--query-gpu=temperature.gpu",
+                "--format=csv,noheader,nounits",
+            ],
+            text=True,
+        )
+        temps = [
+            int(x.strip()) for x in output.strip().split("\n") if x.strip().isdigit()
+        ]
+        return max(temps) if temps else 0
+    except Exception as e:
+        print("Could not read GPU temp:", e)
+        return 0
+
+
+def kill_training_script():
+    print(f"CRITICAL: GPU Temp exceeded {MAX_TEMP}°C! Taking emergency action.")
+    try:
+        # Find train.py process and kill it
+        output = subprocess.check_output(
+            "wmic process where \"commandline like '%masteries/coding/training/critic/train.py%' and name='python.exe'\" get processid",
+            shell=True,
+            text=True,
+        )
+        lines = [line.strip() for line in output.split("\n") if line.strip()]
+        killed = False
+        for line in lines[1:]:  # skip header 'ProcessId'
+            if line.isdigit():
+                pid = line
+                print(f"Killing Train Script PID {pid}...")
+                subprocess.call(f"taskkill /F /PID {pid}", shell=True)
+                killed = True
+
+        if not killed:
+            print(
+                "Could not find specific train.py process. Not killing all python just in case."
+            )
+
+    except Exception as e:
+        print("Error while trying to kill process:", e)
+
+
+print(
+    f"Starting Hardware Watchdog. Monitoring GPU Temp every 60 seconds. Max Temp: {MAX_TEMP}°C"
+)
+while True:
+    temp = get_gpu_temp()
+    print(f"Current GPU Temp: {temp}°C")
+    if temp >= MAX_TEMP:
+        kill_training_script()
+        print("Watchdog emergency triggered. Exiting watchdog.")
+        break
+    time.sleep(60)

masteries/coding/models/actor_v1/config.json

@@ -0,0 +1,42 @@
+{
+  "activation_function": "gelu_pytorch_tanh",
+  "add_cross_attention": false,
+  "architectures": [
+    "GPTBigCodeForCausalLM"
+  ],
+  "attention_softmax_in_fp32": true,
+  "attn_pdrop": 0.1,
+  "bos_token_id": 0,
+  "dtype": "float32",
+  "embd_pdrop": 0.1,
+  "eos_token_id": 0,
+  "inference_runner": 0,
+  "initializer_range": 0.02,
+  "layer_norm_epsilon": 1e-05,
+  "max_batch_size": null,
+  "max_sequence_length": null,
+  "model_type": "gpt_bigcode",
+  "multi_query": true,
+  "n_embd": 768,
+  "n_head": 12,
+  "n_inner": 3072,
+  "n_layer": 20,
+  "n_positions": 8192,
+  "num_key_value_heads": 1,
+  "pad_key_length": true,
+  "pad_token_id": null,
+  "pre_allocate_kv_cache": false,
+  "resid_pdrop": 0.1,
+  "scale_attention_softmax_in_fp32": true,
+  "scale_attn_weights": true,
+  "summary_activation": null,
+  "summary_first_dropout": 0.1,
+  "summary_proj_to_labels": true,
+  "summary_type": "cls_index",
+  "summary_use_proj": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.13.0",
+  "use_cache": true,
+  "validate_runner_input": true,
+  "vocab_size": 49152
+}

masteries/coding/models/actor_v1/generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "transformers_version": "5.13.0"
+}

masteries/coding/models/actor_v1/tokenizer_config.json

@@ -0,0 +1,34 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "extra_special_tokens": [
+    "<|endoftext|>",
+    "<fim_prefix>",
+    "<fim_middle>",
+    "<fim_suffix>",
+    "<fim_pad>",
+    "<filename>",
+    "<gh_stars>",
+    "<issue_start>",
+    "<issue_comment>",
+    "<issue_closed>",
+    "<jupyter_start>",
+    "<jupyter_text>",
+    "<jupyter_code>",
+    "<jupyter_output>",
+    "<empty_output>",
+    "<commit_before>",
+    "<commit_msg>",
+    "<commit_after>",
+    "<reponame>"
+  ],
+  "is_local": false,
+  "local_files_only": false,
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<|endoftext|>",
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": "<|endoftext|>",
+  "vocab_size": 49152
+}

masteries/coding/models/critic_best/config.json

@@ -0,0 +1,30 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "RobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "is_decoder": false,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 1,
+  "problem_type": "single_label_classification",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.13.0",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 50265
+}

masteries/coding/models/critic_best/tokenizer_config.json

@@ -0,0 +1,17 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "errors": "replace",
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "</s>",
+  "sep_token": "</s>",
+  "tokenizer_class": "RobertaTokenizer",
+  "trim_offsets": true,
+  "unk_token": "<unk>"
+}

masteries/coding/models/critic_v1/config.json

@@ -0,0 +1,30 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "RobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "is_decoder": false,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 1,
+  "problem_type": "single_label_classification",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.13.0",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 50265
+}