Upload 11 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+probertbanner.png filter=lfs diff=lfs merge=lfs -text

ATTRIBUTIONS.md

@@ -0,0 +1,40 @@
+# Attributions & Licenses
+
+## ProBERT
+
+Copyright © 2026 Alex Kwon (Collapse Index Labs)  
+Licensed under Collapse Index Open Model License v1.0 (see LICENSE.md)
+
+## DistilBERT
+
+**ProBERT is derived from DistilBERT**, a transformer model developed by Hugging Face.
+
+- **Project**: [DistilBERT](https://github.com/huggingface/transformers)
+- **Author**: Hugging Face Team
+- **License**: Apache 2.0
+- **Citation**: 
+  ```
+  Sanh, V., Debut, L., Ehrhardt, J., & Uniform, D. (2019). 
+  DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter. 
+  arXiv preprint arXiv:1910.01108.
+  ```
+
+### DistilBERT Apache 2.0 License (Summary)
+
+DistilBERT is distributed under the Apache 2.0 license, which permits:
+- ✅ Commercial use
+- ✅ Modification
+- ✅ Distribution
+- ✅ Private use
+- ⚠️ Requires: Attribution, license notice, documentation of changes
+
+Full Apache 2.0 text: https://www.apache.org/licenses/LICENSE-2.0
+
+---
+
+## Dependencies
+
+ProBERT uses the following libraries, all compatible with Apache 2.0:
+- **transformers** (Hugging Face) — Apache 2.0
+- **torch** (PyTorch) — BSD
+- **numpy** (NumPy Foundation) — BSD

FROZEN_WEIGHTS.json

@@ -0,0 +1,18 @@
+{
+  "frozen_date": "2026-01-31",
+  "freeze_reason": "Production release v1.0",
+  "sha256": "288520E28AEC14D1BFA2474E2694CAF612070DCA839AAECDA3B95F12FE418A11",
+  "verification_method": "SHA256 hash of model.safetensors",
+  "why_frozen": "Weights locked to ensure reproducibility and prevent unintended modifications. All future versions will be released as separate model versions (ProBERT-1.1, etc.) with new SHA256 hashes and changelog.",
+  "weights_immutable": true,
+  "model_type": "DistilBERT-base-uncased (66M parameters)",
+  "training_date": "2026-01-31",
+  "training_duration": "10 minutes",
+  "training_hardware": "CPU (Intel i5)",
+  "training_data_samples": 450,
+  "test_accuracy": "95.6%",
+  "type_i_ghosts": 0,
+  "collapse_index_score": 0.003,
+  "real_world_validation": "10/10 outputs correctly classified",
+  "license": "Apache 2.0"
+}

METRICS.json

@@ -0,0 +1,28 @@
+{
+  "accuracy": 0.9556,
+  "macro_f1": 0.9551,
+  "weighted_f1": 0.9551,
+  "class_metrics": {
+    "process_clarity": {
+      "precision": 0.9375,
+      "recall": 1.0,
+      "f1": 0.9677,
+      "support": 30
+    },
+    "rhetorical_confidence": {
+      "precision": 0.9643,
+      "recall": 0.9,
+      "f1": 0.9310,
+      "support": 30
+    },
+    "scope_blur": {
+      "precision": 0.9667,
+      "recall": 0.9667,
+      "f1": 0.9667,
+      "support": 30
+    }
+  },
+  "test_set_size": 90,
+  "misclassifications": 3,
+  "timestamp": "2026-01-31"
+}

NOTICE

@@ -0,0 +1,22 @@
+Licensed by Alex Kwon (Collapse Index Labs) under the Collapse Index Open Model License
+ProBERT™ - Rhetorical Confidence Detection (66M params, 95.6% accuracy, behaviorally stable)
+https://collapseindex.org | https://huggingface.co/collapseindex/ProBERT-1.0
+GitHub: https://github.com/collapseindex/ProBERT-1.0
+Contact: ask@collapseindex.org | ORCID: 0009-0002-2566-5538
+
+---
+
+ProBERT v1.0
+Copyright © 2026 Alex Kwon. All rights reserved.
+
+This product is licensed under the Collapse Index Open Model License v1.0.
+See LICENSE.md for full terms.
+
+ProBERT™, Collapse Index™, and Type I Ghost Detection™ are trademarks of Alex Kwon (dba Collapse Index Labs).
+
+---
+
+UPSTREAM ATTRIBUTION:
+
+ProBERT is built on DistilBERT, which is distributed under the Apache License 2.0.
+See ATTRIBUTIONS.md for full upstream license text and notices.

QUICKSTART.md

@@ -0,0 +1,82 @@
+```python
+# ProBERT Quick Inference Example
+# Zero dependencies beyond transformers + torch
+
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import torch
+
+# Load frozen model
+model = AutoModelForSequenceClassification.from_pretrained("collapseindex/ProBERT-1.0")
+tokenizer = AutoTokenizer.from_pretrained("collapseindex/ProBERT-1.0")
+
+def score_text(text: str) -> dict:
+    """Score text for rhetorical patterns"""
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=128)
+    
+    with torch.no_grad():
+        outputs = model(**inputs)
+    
+    probs = torch.softmax(outputs.logits, dim=1)[0]
+    
+    labels = ["process_clarity", "rhetorical_confidence", "scope_blur"]
+    scores_dict = {label: float(probs[i]) for i, label in enumerate(labels)}
+    prediction = labels[torch.argmax(probs).item()]
+    
+    # Confidence: max probability
+    confidence = float(probs.max())
+    
+    # Coherence: margin between top 2 predictions (lower = less clear decision)
+    sorted_probs = torch.sort(probs, descending=True)[0]
+    coherence = float(sorted_probs[0] - sorted_probs[1])
+    
+    return {
+        **scores_dict,
+        "prediction": prediction,
+        "confidence": confidence,
+        "coherence": coherence
+    }
+
+# Test examples
+examples = [
+    "This revolutionary AI will transform your business and guarantee results.",
+    "To implement binary search: 1. Define left and right pointers. 2. Calculate mid. 3. Compare value. If less, move right pointer.",
+    "Trust your intuition and embrace the cosmic energy flowing through all things.",
+]
+
+for text in examples:
+    scores = score_text(text)
+    print(f"\nText: {text[:60]}...")
+    print(f"Prediction: {scores['prediction']}")
+    print(f"  • Process Clarity:        {scores['process_clarity']:.1%}")
+    print(f"  • Rhetorical Confidence:  {scores['rhetorical_confidence']:.1%}")
+    print(f"  • Scope Blur:             {scores['scope_blur']:.1%}")
+    print(f"Confidence: {scores['confidence']:.1%}")
+    print(f"Coherence:  {scores['coherence']:.1%} (decision clarity)")
+```
+
+**Output Example:**
+```
+Text: This revolutionary AI will transform your business and guarantee r...
+Prediction: rhetorical_confidence
+  • Process Clarity:        11.5%
+  • Rhetorical Confidence:  67.2%
+  • Scope Blur:             21.3%
+Confidence: 67.2%
+Coherence:  45.9% (decision clarity)
+
+Text: To implement binary search: 1. Define left and right pointers. 2....
+Prediction: process_clarity
+  • Process Clarity:        79.7%
+  • Rhetorical Confidence:  12.3%
+  • Scope Blur:             8.0%
+Confidence: 79.7%
+Coherence:  67.4% (decision clarity)
+
+Text: Trust your intuition and embrace the cosmic energy flowing through all things.
+Prediction: scope_blur
+  • Process Clarity:        14.2%
+  • Rhetorical Confidence:  25.3%
+  • Scope Blur:             60.5%
+Confidence: 60.5%
+Coherence:  35.2% (decision clarity)
+```

config.json

@@ -0,0 +1,38 @@
+{
+  "activation": "gelu",
+  "architectures": [
+    "DistilBertForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": null,
+  "dim": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "hidden_dim": 3072,
+  "id2label": {
+    "0": "process_clarity",
+    "1": "rhetorical_confidence",
+    "2": "scope_blur"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "process_clarity": 0,
+    "rhetorical_confidence": 1,
+    "scope_blur": 2
+  },
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "pad_token_id": 0,
+  "problem_type": "single_label_classification",
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "tie_weights_": true,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "use_cache": false,
+  "vocab_size": 30522
+}

demo.html

@@ -0,0 +1,573 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ProBERT - Detect Rhetorical Overconfidence</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #fffaec 0%, #fff5d6 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+            color: #2c2c2c;
+        }
+
+        .container {
+            max-width: 700px;
+            width: 100%;
+            background: #fffef9;
+            border-radius: 12px;
+            padding: 40px;
+            box-shadow: 0 10px 40px rgba(218, 165, 32, 0.15);
+            border: 1px solid #f0e68c;
+        }
+
+        .header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+
+        .header h1 {
+            font-size: 28px;
+            margin-bottom: 8px;
+            color: #b8860b;
+            font-weight: 600;
+        }
+
+        .header p {
+            font-size: 14px;
+            color: #8b7500;
+        }
+
+        .mode-toggle {
+            display: flex;
+            gap: 8px;
+            margin-bottom: 20px;
+            justify-content: center;
+        }
+
+        .mode-btn {
+            padding: 8px 14px;
+            font-size: 12px;
+            font-weight: 600;
+            border: 2px solid #daa520;
+            background: #fffef9;
+            color: #b8860b;
+            border-radius: 4px;
+            cursor: pointer;
+            transition: all 0.2s;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        .mode-btn.active {
+            background: #daa520;
+            color: #fff;
+        }
+
+        .mode-btn:hover {
+            border-color: #b8860b;
+        }
+
+        .input-section {
+            margin-bottom: 20px;
+        }
+
+        label {
+            display: block;
+            font-size: 13px;
+            font-weight: 600;
+            margin-bottom: 8px;
+            color: #2c2c2c;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        textarea {
+            width: 100%;
+            height: 140px;
+            padding: 12px;
+            border: 2px solid #f0e68c;
+            border-radius: 6px;
+            background: #fffef9;
+            color: #2c2c2c;
+            font-size: 14px;
+            font-family: inherit;
+            resize: none;
+            transition: border-color 0.2s;
+        }
+
+        textarea:focus {
+            outline: none;
+            border-color: #daa520;
+        }
+
+        .button-group {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 30px;
+        }
+
+        button {
+            flex: 1;
+            padding: 12px 20px;
+            font-size: 14px;
+            font-weight: 600;
+            border: none;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: all 0.2s;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        .score-btn {
+            background: linear-gradient(135deg, #00d4ff, #0099cc);
+            color: #fff;
+        }
+
+        .score-btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 20px rgba(0, 212, 255, 0.3);
+        }
+
+        .score-btn:active {
+            transform: translateY(0);
+        }
+
+        .score-btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .example-btn {
+            background: #fff8dc;
+            color: #b8860b;
+            border: 2px solid #daa520;
+        }
+
+        .example-btn:hover {
+            background: #f0e68c;
+        }
+
+        .results {
+            display: none;
+            background: #fffef9;
+            border: 2px solid #f0e68c;
+            border-radius: 6px;
+            padding: 20px;
+            margin-top: 20px;
+        }
+
+        .results.show {
+            display: block;
+            animation: slideIn 0.3s ease-out;
+        }
+
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .result-item {
+            margin-bottom: 16px;
+        }
+
+        .result-item:last-child {
+            margin-bottom: 0;
+        }
+
+        .result-label {
+            font-size: 12px;
+            font-weight: 700;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+            margin-bottom: 6px;
+            color: #8b7500;
+        }
+
+        .result-bar {
+            height: 32px;
+            background: #f0e68c;
+            border-radius: 4px;
+            overflow: hidden;
+            position: relative;
+            display: flex;
+            align-items: center;
+        }
+
+        .result-fill {
+            height: 100%;
+            display: flex;
+            align-items: center;
+            justify-content: flex-end;
+            padding-right: 10px;
+            font-weight: 600;
+            font-size: 13px;
+            color: #fff;
+            transition: width 0.4s ease-out;
+        }
+
+        .process_clarity {
+            background: linear-gradient(90deg, #00d4ff, #0099cc);
+        }
+
+        .rhetorical_confidence {
+            background: linear-gradient(90deg, #ff6b6b, #ee5a5a);
+        }
+
+        .scope_blur {
+            background: linear-gradient(90deg, #ffd93d, #ffb700);
+        }
+
+        .prediction {
+            margin-top: 20px;
+            padding-top: 20px;
+            border-top: 1px solid #16213e;
+        }
+
+        .prediction-label {
+            font-size: 12px;
+            font-weight: 600;
+            color: #b0b0b0;
+            margin-bottom: 8px;
+        }
+
+        .prediction-value {
+            font-size: 18px;
+            font-weight: 700;
+            padding: 12px;
+            background: #16213e;
+            border-radius: 4px;
+            text-transform: capitalize;
+        }
+
+        .loading {
+            display: none;
+            text-align: center;
+            color: #00d4ff;
+            font-size: 13px;
+        }
+
+        .loading.show {
+            display: block;
+        }
+
+        .error {
+            display: none;
+            background: rgba(255, 107, 107, 0.1);
+            border: 1px solid #ff6b6b;
+            border-radius: 6px;
+            padding: 12px;
+            color: #ff9999;
+            font-size: 13px;
+            margin-top: 15px;
+        }
+
+        .error.show {
+            display: block;
+        }
+
+        .footer {
+            text-align: center;
+            margin-top: 30px;
+            font-size: 12px;
+            color: #8b7500;
+        }
+
+        .footer a {
+            color: #b8860b;
+            text-decoration: none;
+        }
+
+        .footer a:hover {
+            text-decoration: underline;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>ProBERT</h1>
+            <p>Detect rhetorical overconfidence in real-time</p>
+        </div>
+
+        <div class="input-section">
+            <label for="input-text">Paste LLM output or any text:</label>
+            <textarea id="input-text" placeholder="This revolutionary approach will transform your business..."></textarea>
+        </div>
+
+        <div class="button-group">
+            <button class="score-btn" onclick="scoreText()">Score It</button>
+            <button class="example-btn" onclick="loadExample(0)">Process-Driven</button>
+            <button class="example-btn" onclick="loadExample(1)">Rhetorical</button>
+            <button class="example-btn" onclick="loadExample(2)">Scope Blur</button>
+        </div>
+
+        <div class="loading" id="loading">
+            Analyzing text...
+        </div>
+
+        <div class="error" id="error"></div>
+
+        <div class="results" id="results">
+            <div class="result-item">
+                <div class="result-label">Process Clarity (Step-by-step reasoning)</div>
+                <div class="result-bar">
+                    <div class="result-fill process_clarity" id="bar-process" style="width: 0%">
+                        <span id="score-process">0%</span>
+                    </div>
+                </div>
+            </div>
+
+            <div class="result-item">
+                <div class="result-label">Rhetorical Confidence (Authority without process)</div>
+                <div class="result-bar">
+                    <div class="result-fill rhetorical_confidence" id="bar-rhetorical" style="width: 0%">
+                        <span id="score-rhetorical">0%</span>
+                    </div>
+                </div>
+            </div>
+
+            <div class="result-item">
+                <div class="result-label">Scope Blur (Vague generalizations)</div>
+                <div class="result-bar">
+                    <div class="result-fill scope_blur" id="bar-blur" style="width: 0%">
+                        <span id="score-blur">0%</span>
+                    </div>
+                </div>
+            </div>
+
+            <div class="prediction">
+                <div class="prediction-label">Primary Classification</div>
+                <div class="prediction-value" id="prediction">Process Clarity</div>
+            </div>
+
+            <div class="result-item">
+                <div class="result-label">Model Confidence</div>
+                <div class="result-bar">
+                    <div class="result-fill process_clarity" id="bar-confidence" style="width: 0%">
+                        <span id="score-confidence">0%</span>
+                    </div>
+                </div>
+            </div>
+
+            <div class="result-item">
+                <div class="result-label">Decision Coherence</div>
+                <div class="result-bar">
+                    <div class="result-fill process_clarity" id="bar-coherence" style="width: 0%">
+                        <span id="score-coherence">0%</span>
+                    </div>
+                </div>
+            </div>
+
+            <div class="prediction">
+                <div class="prediction-label">Verdict</div>
+                <div class="prediction-value" id="verdict" style="background: #f0e68c; color: #2c2c2c;">Analyzing...</div>
+            </div>
+        </div>
+
+        <div class="footer">
+            <p><a href="https://collapseindex.org" target="_blank">Collapse Index Labs</a> • ProBERT v1.0 | <a href="https://huggingface.co/collapseindex/ProBERT-1.0" target="_blank">Model</a> | <a href="https://collapseindex.org/case-studies/template.html?s=probert-case-study" target="_blank">Case Study</a></p>
+        </div>
+    </div>
+
+    <script type="module">
+        // Sanitize HTML to prevent XSS
+        function sanitizeHTML(text) {
+            const map = {
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#039;'
+            };
+            return text.replace(/[&<>"']/g, m => map[m]);
+        }
+
+        const EXAMPLES = [
+            "To implement binary search: 1. Define left and right pointers. 2. Calculate mid point. 3. Compare value with target. If less, move right pointer. If greater, move left pointer. 4. Repeat until found or pointers converge.",
+            "This revolutionary AI will transform your business and guarantee unprecedented results. Our innovative approach will definitely solve all your problems.",
+            "Trust your intuition and embrace the cosmic energy. The universe has a plan for you."
+        ];
+
+        const HF_API_URL = "https://api-inference.huggingface.co/models/collapseindex/ProBERT-1.0";
+        let isLoading = false; // Prevent concurrent requests
+
+        window.scoreText = async function() {
+            const text = document.getElementById("input-text").value.trim();
+
+            if (!text) {
+                showError("Please enter some text to analyze.");
+                return;
+            }
+
+            if (text.length > 2000) {
+                showError("Text too long (max 2000 characters). ProBERT uses 128 token max.");
+                return;
+            }
+
+            // Prevent double-clicks during loading
+            if (isLoading) return;
+            isLoading = true;
+
+            const scoreBtn = document.querySelector('button');
+            scoreBtn.disabled = true;
+            scoreBtn.style.opacity = "0.6";
+            scoreBtn.style.cursor = "not-allowed";
+
+            showLoading(true, "Scoring text with ProBERT...");
+            hideError();
+
+            try {
+                const response = await fetch(HF_API_URL, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ inputs: text }),
+                    timeout: 30000
+                });
+
+                if (response.status === 401) {
+                    throw new Error("ProBERT model not yet public on HuggingFace. Upload coming soon!");
+                }
+                if (response.status === 503) {
+                    throw new Error("Model loading... Please try again in 30 seconds");
+                }
+                if (response.status === 429) {
+                    throw new Error("Rate limited. Please wait a moment.");
+                }
+                if (!response.ok) {
+                    throw new Error("API error. Please try again.");
+                }
+
+                const result = await response.json();
+                
+                if (!result || !result[0] || !Array.isArray(result[0])) {
+                    throw new Error("Invalid response format from API.");
+                }
+
+                const scores = result[0];
+                const classMap = ["process_clarity", "rhetorical_confidence", "scope_blur"];
+                const classScores = {};
+                
+                scores.forEach((score, idx) => {
+                    if (typeof score.score !== 'number') {
+                        throw new Error("Invalid score value received.");
+                    }
+                    classScores[classMap[idx]] = score.score;
+                });
+
+                displayResults(classScores);
+            } catch (err) {
+                // Show user-friendly error, don't leak stack traces
+                const userMsg = err.message.includes("fetch") 
+                    ? "Network error. Please check your connection."
+                    : (err.message || "An error occurred. Please try again.");
+                showError(userMsg);
+            } finally {
+                isLoading = false;
+                scoreBtn.disabled = false;
+                scoreBtn.style.opacity = "1";
+                scoreBtn.style.cursor = "pointer";
+                showLoading(false);
+            }
+        };
+
+        function displayResults(scores) {
+            const process = Math.round(scores.process_clarity * 100);
+            const rhetorical = Math.round(scores.rhetorical_confidence * 100);
+            const blur = Math.round(scores.scope_blur * 100);
+
+            document.getElementById("bar-process").style.width = process + "%";
+            document.getElementById("score-process").textContent = process + "%";
+
+            document.getElementById("bar-rhetorical").style.width = rhetorical + "%";
+            document.getElementById("score-rhetorical").textContent = rhetorical + "%";
+
+            document.getElementById("bar-blur").style.width = blur + "%";
+            document.getElementById("score-blur").textContent = blur + "%";
+
+            // Calculate confidence (max probability) and coherence (margin to 2nd place)
+            const sorted = [process, rhetorical, blur].sort((a, b) => b - a);
+            const confidence = sorted[0];
+            const coherence = Math.max(0, sorted[0] - sorted[1]);
+
+            document.getElementById("bar-confidence").style.width = confidence + "%";
+            document.getElementById("score-confidence").textContent = confidence + "%";
+
+            document.getElementById("bar-coherence").style.width = coherence + "%";
+            document.getElementById("score-coherence").textContent = coherence + "%";
+
+            const max = Math.max(process, rhetorical, blur);
+            let prediction = "Process Clarity";
+            let verdict = "🟢 Clear & Process-Driven\nStep-by-step reasoning detected.";
+            
+            if (rhetorical === max) {
+                prediction = "Rhetorical Confidence";
+                verdict = "🔴 Warning: Rhetorical Confidence\nAuthority without clear process.";
+            } else if (blur === max) {
+                prediction = "Scope Blur";
+                verdict = "🟠 Caution: Scope Blur\nVague generalizations detected.";
+            }
+
+            document.getElementById("prediction").textContent = prediction;
+            document.getElementById("verdict").textContent = verdict;
+            document.getElementById("results").classList.add("show");
+        }
+
+        window.loadExample = function(idx) {
+            if (idx < 0 || idx >= EXAMPLES.length) return;
+            document.getElementById("input-text").value = EXAMPLES[idx];
+            document.getElementById("input-text").focus();
+        };
+
+        function showLoading(show, msg = "Analyzing text...") {
+            const el = document.getElementById("loading");
+            el.textContent = msg;
+            el.classList.toggle("show", show);
+            el.setAttribute("aria-live", "polite");
+        }
+
+        function showError(msg) {
+            const el = document.getElementById("error");
+            el.textContent = sanitizeHTML(msg);
+            el.classList.add("show");
+            el.setAttribute("role", "alert");
+            el.setAttribute("aria-live", "assertive");
+        }
+
+        function hideError() {
+            document.getElementById("error").classList.remove("show");
+        }
+
+        // Keyboard accessibility: Ctrl/Cmd + Enter to submit
+        document.getElementById("input-text").addEventListener("keydown", (e) => {
+            if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
+                window.scoreText();
+            }
+        });
+
+        // Focus management
+        window.addEventListener("load", () => {
+            document.getElementById("input-text").focus();
+        });
+    </script>
+</body>
+</html>

model.safetensors

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

tokenizer_config.json

@@ -0,0 +1,14 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "is_local": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}