Upload moderat_speed_test.ipynb with huggingface_hub

moderat_speed_test.ipynb

@@ -0,0 +1,239 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "name": "moderat-speed-test.ipynb"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🛡️ moderat - Speed Test & Benchmark\n",
+        "\n",
+        "Test inference speeds for the dual-mode content moderation model.\n",
+        "\n",
+        "**Model:** [darwinkernelpanic/moderat](https://huggingface.co/darwinkernelpanic/moderat)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 1. Install dependencies\n",
+        "!pip install -q scikit-learn huggingface-hub"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 2. Download model from Hugging Face\n",
+        "from huggingface_hub import hf_hub_download\n",
+        "import pickle\n",
+        "\n",
+        "MODEL_REPO = \"darwinkernelpanic/moderat\"\n",
+        "\n",
+        "# Download model\n",
+        "model_path = hf_hub_download(\n",
+        "    repo_id=MODEL_REPO,\n",
+        "    filename=\"moderation_model.pkl\"\n",
+        ")\n",
+        "\n",
+        "# Load model\n",
+        "with open(model_path, 'rb') as f:\n",
+        "    pipeline = pickle.load(f)\n",
+        "\n",
+        "print(f\"✅ Model loaded from {MODEL_REPO}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 3. Define inference functions\n",
+        "from enum import Enum\n",
+        "import time\n",
+        "\n",
+        "class ContentLabel(Enum):\n",
+        "    SAFE = 0\n",
+        "    HARASSMENT = 1\n",
+        "    SWEARING_REACTION = 2\n",
+        "    SWEARING_AGGRESSIVE = 3\n",
+        "    HATE_SPEECH = 4\n",
+        "    SPAM = 5\n",
+        "\n",
+        "def predict(text):\n",
+        "    \"\"\"Run inference and return label + confidence\"\"\"\n",
+        "    prediction = pipeline.predict([text])[0]\n",
+        "    probs = pipeline.predict_proba([text])[0]\n",
+        "    confidence = max(probs)\n",
+        "    return ContentLabel(prediction), confidence\n",
+        "\n",
+        "def check_content(text, age):\n",
+        "    \"\"\"Dual-mode filter\"\"\"\n",
+        "    label, confidence = predict(text)\n",
+        "    \n",
+        "    under_13_blocked = [1, 2, 3, 4, 5]\n",
+        "    teen_plus_blocked = [1, 3, 4, 5]\n",
+        "    \n",
+        "    if age >= 13:\n",
+        "        allowed = label.value not in teen_plus_blocked\n",
+        "    else:\n",
+        "        allowed = label.value not in under_13_blocked\n",
+        "    \n",
+        "    # Allow reaction swearing for 13+\n",
+        "    if not allowed and label == ContentLabel.SWEARING_REACTION and age >= 13:\n",
+        "        allowed = True\n",
+        "    \n",
+        "    return {\n",
+        "        \"allowed\": allowed,\n",
+        "        \"label\": label.name,\n",
+        "        \"confidence\": confidence\n",
+        "    }"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 4. Single inference speed test\n",
+        "test_text = \"damn that's crazy\"\n",
+        "\n",
+        "# Warm up\n",
+        "_ = predict(test_text)\n",
+        "\n",
+        "# Time single inference\n",
+        "times = []\n",
+        "for _ in range(100):\n",
+        "    start = time.perf_counter()\n",
+        "    result = predict(test_text)\n",
+        "    end = time.perf_counter()\n",
+        "    times.append((end - start) * 1000)  # Convert to ms\n",
+        "\n",
+        "avg_time = sum(times) / len(times)\n",
+        "min_time = min(times)\n",
+        "max_time = max(times)\n",
+        "\n",
+        "print(f\"📊 Single Inference Speed (100 runs)\")\n",
+        "print(f\"   Average: {avg_time:.3f} ms\")\n",
+        "print(f\"   Min: {min_time:.3f} ms\")\n",
+        "print(f\"   Max: {max_time:.3f} ms\")\n",
+        "print(f\"   Throughput: {1000/avg_time:.1f} inferences/second\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 5. Batch inference speed test\n",
+        "test_texts = [\n",
+        "    \"that was a great game\",\n",
+        "    \"shit that sucks\",\n",
+        "    \"you're a piece of shit\",\n",
+        "    \"kill yourself\",\n",
+        "    \"i love this song\",\n",
+        "    \"damn that's crazy\",\n",
+        "    \"click here for free robux\",\n",
+        "    \"congratulations\",\n",
+        "] * 100  # 800 total texts\n",
+        "\n",
+        "print(f\"Testing batch of {len(test_texts)} texts...\")\n",
+        "\n",
+        "start = time.perf_counter()\n",
+        "results = [predict(t) for t in test_texts]\n",
+        "end = time.perf_counter()\n",
+        "\n",
+        "total_time = (end - start) * 1000\n",
+        "avg_per_text = total_time / len(test_texts)\n",
+        "\n",
+        "print(f\"\\n📊 Batch Inference Results\")\n",
+        "print(f\"   Total time: {total_time:.1f} ms\")\n",
+        "print(f\"   Average per text: {avg_per_text:.3f} ms\")\n",
+        "print(f\"   Throughput: {len(test_texts)/(total_time/1000):.1f} texts/second\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 6. Dual-mode comparison test\n",
+        "test_cases = [\n",
+        "    (\"that was a great game\", 10),\n",
+        "    (\"that was a great game\", 15),\n",
+        "    (\"shit that sucks\", 10),\n",
+        "    (\"shit that sucks\", 15),\n",
+        "    (\"you're a piece of shit\", 10),\n",
+        "    (\"you're a piece of shit\", 15),\n",
+        "    (\"kill yourself\", 10),\n",
+        "    (\"kill yourself\", 15),\n",
+        "]\n",
+        "\n",
+        "print(\"📋 Dual-Mode Filter Results\\n\")\n",
+        "print(f\"{'Text':<30} {'Age':<6} {'Status':<10} {'Label':<20} {'Conf':<6}\")\n",
+        "print(\"-\" * 75)\n",
+        "\n",
+        "for text, age in test_cases:\n",
+        "    result = check_content(text, age)\n",
+        "    status = \"✅ ALLOW\" if result[\"allowed\"] else \"❌ BLOCK\"\n",
+        "    print(f\"{text:<30} {age:<6} {status:<10} {result['label']:<20} {result['confidence']:.2f}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# @title 7. Memory usage check\n",
+        "import sys\n",
+        "\n",
+        "# Estimate model size in memory\n",
+        "model_size = sys.getsizeof(pipeline) / 1024 / 1024\n",
+        "print(f\"💾 Model memory usage: ~{model_size:.2f} MB\")\n",
+        "\n",
+        "# Check if GPU available (Colab usually has CPU only for sklearn)\n",
+        "import os\n",
+        "gpu_available = 'COLAB_GPU' in os.environ\n",
+        "print(f\"🔥 GPU available: {gpu_available}\")\n",
+        "print(f\"⚡ Running on: CPU (sklearn uses CPU)\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 📊 Expected Results\n",
+        "\n",
+        "On Google Colab (CPU):\n",
+        "- **Single inference:** ~0.5-2ms\n",
+        "- **Throughput:** ~500-2000 inferences/second\n",
+        "- **Memory:** ~5-15MB\n",
+        "\n",
+        "## 🔗 Links\n",
+        "\n",
+        "- Model: https://huggingface.co/darwinkernelpanic/moderat\n",
+        "- GitHub: Add your repo here"
+      ]
+    }
+  ]
+}