fix: update notebook to work directly from HuggingFace

notebooks/SCU_Demo.ipynb

@@ -1,391 +1,385 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "header"
-      },
-      "source": [
-        "# Shannon Control Unit (SCU) Demo\n",
-        "\n",
-        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Hmbown/shannon-control-unit/blob/main/notebooks/SCU_Demo.ipynb)\n",
-        "\n",
-        "This notebook demonstrates the Shannon Control Unit - an adaptive regularization system that achieves **15.6% lower perplexity** without manual hyperparameter tuning."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "installation"
-      },
-      "source": [
-        "## 1. Installation\n",
-        "\n",
-        "First, install the required packages:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "install_packages"
-      },
-      "outputs": [],
-      "source": [
-        "!pip install -q transformers peft torch accelerate\n",
-        "!pip install -q matplotlib pandas numpy"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "load_model"
-      },
-      "source": [
-        "## 2. Load Model with SCU Adapter\n",
-        "\n",
-        "Load the base Llama model and apply the SCU-trained adapter:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "load_model_code"
-      },
-      "outputs": [],
-      "source": [
-        "import torch\n",
-        "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
-        "from peft import PeftModel\n",
-        "\n",
-        "# Check available device\n",
-        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
-        "print(f'Using device: {device}')\n",
-        "\n",
-        "# Load base model\n",
-        "base_model_id = 'meta-llama/Llama-3.2-1B'\n",
-        "print(f'Loading base model: {base_model_id}...')\n",
-        "\n",
-        "base_model = AutoModelForCausalLM.from_pretrained(\n",
-        "    base_model_id,\n",
-        "    device_map='auto',\n",
-        "    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,\n",
-        "    trust_remote_code=True\n",
-        ")\n",
-        "\n",
-        "tokenizer = AutoTokenizer.from_pretrained(base_model_id)\n",
-        "if tokenizer.pad_token is None:\n",
-        "    tokenizer.pad_token = tokenizer.eos_token\n",
-        "\n",
-        "print('Base model loaded successfully!')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "load_adapter"
-      },
-      "outputs": [],
-      "source": [
-        "# Load SCU adapter\n",
-        "adapter_id = 'hunterbown/shannon-control-unit'\n",
-        "print(f'Loading SCU adapter: {adapter_id}...')\n",
-        "\n",
-        "model = PeftModel.from_pretrained(base_model, adapter_id)\n",
-        "model.eval()\n",
-        "\n",
-        "print('SCU adapter loaded successfully!')\n",
-        "print(f'Model ready for inference on {device}')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "generation"
-      },
-      "source": [
-        "## 3. Generate Text\n",
-        "\n",
-        "Test the model with different prompts:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "generate_function"
-      },
-      "outputs": [],
-      "source": [
-        "def generate_text(prompt, max_length=100, temperature=0.7):\n",
-        "    \"\"\"Generate text using the SCU model.\"\"\"\n",
-        "    inputs = tokenizer(prompt, return_tensors='pt').to(device)\n",
-        "    \n",
-        "    with torch.no_grad():\n",
-        "        outputs = model.generate(\n",
-        "            **inputs,\n",
-        "            max_length=max_length,\n",
-        "            temperature=temperature,\n",
-        "            do_sample=True,\n",
-        "            pad_token_id=tokenizer.pad_token_id\n",
-        "        )\n",
-        "    \n",
-        "    generated = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
-        "    return generated\n",
-        "\n",
-        "# Test generation\n",
-        "test_prompt = 'The key to understanding information theory is'\n",
-        "print(f'Prompt: {test_prompt}')\n",
-        "print('-' * 50)\n",
-        "print(generate_text(test_prompt))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "examples"
-      },
-      "source": [
-        "## 4. Try Different Examples\n",
-        "\n",
-        "Test the model on various tasks:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "code_generation"
-      },
-      "outputs": [],
-      "source": [
-        "# Code generation\n",
-        "code_prompt = 'def fibonacci(n):'\n",
-        "print('Code Generation Example')\n",
-        "print('=' * 50)\n",
-        "print(generate_text(code_prompt, max_length=150, temperature=0.3))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "math_problem"
-      },
-      "outputs": [],
-      "source": [
-        "# Math explanation\n",
-        "math_prompt = 'To solve a quadratic equation, you need to'\n",
-        "print('Math Explanation Example')\n",
-        "print('=' * 50)\n",
-        "print(generate_text(math_prompt, max_length=120, temperature=0.5))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "creative_writing"
-      },
-      "outputs": [],
-      "source": [
-        "# Creative writing\n",
-        "story_prompt = 'In a world where AI controls'\n",
-        "print('Creative Writing Example')\n",
-        "print('=' * 50)\n",
-        "print(generate_text(story_prompt, max_length=150, temperature=0.9))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "evaluation"
-      },
-      "source": [
-        "## 5. Evaluate Performance\n",
-        "\n",
-        "Compare SCU model perplexity to baseline:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "evaluate_perplexity"
-      },
-      "outputs": [],
-      "source": [
-        "import math\n",
-        "\n",
-        "def calculate_perplexity(model, text, tokenizer):\n",
-        "    \"\"\"Calculate perplexity for given text.\"\"\"\n",
-        "    inputs = tokenizer(text, return_tensors='pt', truncation=True, max_length=512).to(device)\n",
-        "    \n",
-        "    with torch.no_grad():\n",
-        "        outputs = model(**inputs, labels=inputs['input_ids'])\n",
-        "        loss = outputs.loss\n",
-        "        perplexity = math.exp(loss.item())\n",
-        "    \n",
-        "    return perplexity\n",
-        "\n",
-        "# Test text for evaluation\n",
-        "test_text = \"\"\"\n",
-        "Machine learning is a subset of artificial intelligence that enables \n",
-        "systems to learn and improve from experience without being explicitly \n",
-        "programmed. It focuses on developing computer programs that can access \n",
-        "data and use it to learn for themselves.\n",
-        "\"\"\"\n",
-        "\n",
-        "# Calculate perplexity\n",
-        "scu_perplexity = calculate_perplexity(model, test_text, tokenizer)\n",
-        "print(f'SCU Model Perplexity: {scu_perplexity:.2f}')\n",
-        "print(f'Baseline Perplexity (reported): 15.14')\n",
-        "print(f'Improvement: {(15.14 - scu_perplexity) / 15.14 * 100:.1f}%')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "visualization"
-      },
-      "source": [
-        "## 6. Visualize Control Dynamics\n",
-        "\n",
-        "Show how SCU maintains the target compression ratio during training:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "plot_control"
-      },
-      "outputs": [],
-      "source": [
-        "import matplotlib.pyplot as plt\n",
-        "import numpy as np\n",
-        "\n",
-        "# Simulate control dynamics (for demonstration)\n",
-        "steps = np.arange(0, 270)\n",
-        "target_s = 0.01  # 1% target\n",
-        "deadband = 0.002  # ±0.2pp\n",
-        "\n",
-        "# Simulated S(t) converging to target\n",
-        "s_values = target_s + 0.02 * np.exp(-steps/50) * np.sin(steps/10) + np.random.normal(0, 0.0005, len(steps))\n",
-        "s_values = np.clip(s_values, 0, 0.03)\n",
-        "\n",
-        "# Plot\n",
-        "plt.figure(figsize=(10, 6))\n",
-        "plt.plot(steps, s_values * 100, 'b-', linewidth=2, label='S(t)')\n",
-        "plt.axhspan((target_s - deadband) * 100, (target_s + deadband) * 100, \n",
-        "            alpha=0.2, color='green', label=f'Target: {target_s*100:.1f}% ± {deadband*100:.1f}pp')\n",
-        "plt.axhline(target_s * 100, color='green', linestyle='--', alpha=0.5)\n",
-        "\n",
-        "plt.xlabel('Training Step', fontsize=12)\n",
-        "plt.ylabel('S (%)', fontsize=12)\n",
-        "plt.title('SCU Control: S(t) Tracking Target', fontsize=14, fontweight='bold')\n",
-        "plt.legend()\n",
-        "plt.grid(True, alpha=0.3)\n",
-        "plt.tight_layout()\n",
-        "plt.show()\n",
-        "\n",
-        "print('The plot shows how SCU maintains the compression ratio S within the target band.')\n",
-        "print('This automatic control eliminates the need for manual hyperparameter tuning.')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "comparison"
-      },
-      "source": [
-        "## 7. Performance Comparison\n",
-        "\n",
-        "Compare SCU with baseline model:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "compare_models"
-      },
-      "outputs": [],
-      "source": [
-        "# Performance metrics\n",
-        "results = {\n",
-        "    'Metric': ['Bits per Token', 'Perplexity', 'Compression Ratio'],\n",
-        "    'Baseline': [3.920, 15.14, '0.0%'],\n",
-        "    'SCU': [3.676, 12.78, '1.0%'],\n",
-        "    'Improvement': ['-6.2%', '-15.6%', 'Controlled']\n",
-        "}\n",
-        "\n",
-        "# Display as table\n",
-        "import pandas as pd\n",
-        "df = pd.DataFrame(results)\n",
-        "print('\\nPerformance Comparison: Baseline vs SCU')\n",
-        "print('=' * 60)\n",
-        "print(df.to_string(index=False))\n",
-        "print('=' * 60)\n",
-        "print('\\nKey Achievement: 15.6% perplexity reduction with automatic tuning!')"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "conclusion"
-      },
-      "source": [
-        "## 8. Conclusion\n",
-        "\n",
-        "The Shannon Control Unit demonstrates:\n",
-        "\n",
-        "- **15.6% lower perplexity** compared to baseline\n",
-        "- **Automatic regularization** without manual tuning\n",
-        "- **Stable control** maintaining 1% ± 0.2pp compression ratio\n",
-        "- **Generalizable approach** across model scales\n",
-        "\n",
-        "### Next Steps\n",
-        "\n",
-        "1. Try different prompts to explore model capabilities\n",
-        "2. Fine-tune your own models with SCU control\n",
-        "3. Read the [paper](https://arxiv.org/abs/xxxx.xxxxx) for technical details\n",
-        "\n",
-        "### Resources\n",
-        "\n",
-        "- Model: [hunterbown/shannon-control-unit](https://huggingface.co/hunterbown/shannon-control-unit)\n",
-        "- GitHub: [shannon-control-unit](https://github.com/Hmbown/shannon-control-unit)\n",
-        "- Contact: hunter@shannonlabs.dev"
-      ]
-    }
-  ],
-  "metadata": {
-    "accelerator": "GPU",
-    "colab": {
-      "name": "SCU_Demo.ipynb",
-      "provenance": [],
-      "toc_visible": true
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.10.12"
-    }
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "header"
+   },
+   "source": "# Shannon Control Unit (SCU) Demo\n\n[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://huggingface.co/hunterbown/shannon-control-unit/blob/main/notebooks/SCU_Demo.ipynb)\n\nThis notebook demonstrates the Shannon Control Unit - an adaptive regularization system that achieves **15.6% lower perplexity** without manual hyperparameter tuning.\n\n**Note:** Click the \"Open in Colab\" badge above, then in the Colab interface, click File → Save a copy in Drive to run the notebook."
   },
-  "nbformat": 4,
-  "nbformat_minor": 0
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "installation"
+   },
+   "source": [
+    "## 1. Installation\n",
+    "\n",
+    "First, install the required packages:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "install_packages"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install -q transformers peft torch accelerate\n",
+    "!pip install -q matplotlib pandas numpy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "load_model"
+   },
+   "source": [
+    "## 2. Load Model with SCU Adapter\n",
+    "\n",
+    "Load the base Llama model and apply the SCU-trained adapter:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "load_model_code"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
+    "from peft import PeftModel\n",
+    "\n",
+    "# Check available device\n",
+    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+    "print(f'Using device: {device}')\n",
+    "\n",
+    "# Load base model\n",
+    "base_model_id = 'meta-llama/Llama-3.2-1B'\n",
+    "print(f'Loading base model: {base_model_id}...')\n",
+    "\n",
+    "base_model = AutoModelForCausalLM.from_pretrained(\n",
+    "    base_model_id,\n",
+    "    device_map='auto',\n",
+    "    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,\n",
+    "    trust_remote_code=True\n",
+    ")\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(base_model_id)\n",
+    "if tokenizer.pad_token is None:\n",
+    "    tokenizer.pad_token = tokenizer.eos_token\n",
+    "\n",
+    "print('Base model loaded successfully!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "load_adapter"
+   },
+   "outputs": [],
+   "source": [
+    "# Load SCU adapter\n",
+    "adapter_id = 'hunterbown/shannon-control-unit'\n",
+    "print(f'Loading SCU adapter: {adapter_id}...')\n",
+    "\n",
+    "model = PeftModel.from_pretrained(base_model, adapter_id)\n",
+    "model.eval()\n",
+    "\n",
+    "print('SCU adapter loaded successfully!')\n",
+    "print(f'Model ready for inference on {device}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "generation"
+   },
+   "source": [
+    "## 3. Generate Text\n",
+    "\n",
+    "Test the model with different prompts:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "generate_function"
+   },
+   "outputs": [],
+   "source": [
+    "def generate_text(prompt, max_length=100, temperature=0.7):\n",
+    "    \"\"\"Generate text using the SCU model.\"\"\"\n",
+    "    inputs = tokenizer(prompt, return_tensors='pt').to(device)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        outputs = model.generate(\n",
+    "            **inputs,\n",
+    "            max_length=max_length,\n",
+    "            temperature=temperature,\n",
+    "            do_sample=True,\n",
+    "            pad_token_id=tokenizer.pad_token_id\n",
+    "        )\n",
+    "    \n",
+    "    generated = tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
+    "    return generated\n",
+    "\n",
+    "# Test generation\n",
+    "test_prompt = 'The key to understanding information theory is'\n",
+    "print(f'Prompt: {test_prompt}')\n",
+    "print('-' * 50)\n",
+    "print(generate_text(test_prompt))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "examples"
+   },
+   "source": [
+    "## 4. Try Different Examples\n",
+    "\n",
+    "Test the model on various tasks:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "code_generation"
+   },
+   "outputs": [],
+   "source": [
+    "# Code generation\n",
+    "code_prompt = 'def fibonacci(n):'\n",
+    "print('Code Generation Example')\n",
+    "print('=' * 50)\n",
+    "print(generate_text(code_prompt, max_length=150, temperature=0.3))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "math_problem"
+   },
+   "outputs": [],
+   "source": [
+    "# Math explanation\n",
+    "math_prompt = 'To solve a quadratic equation, you need to'\n",
+    "print('Math Explanation Example')\n",
+    "print('=' * 50)\n",
+    "print(generate_text(math_prompt, max_length=120, temperature=0.5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "creative_writing"
+   },
+   "outputs": [],
+   "source": [
+    "# Creative writing\n",
+    "story_prompt = 'In a world where AI controls'\n",
+    "print('Creative Writing Example')\n",
+    "print('=' * 50)\n",
+    "print(generate_text(story_prompt, max_length=150, temperature=0.9))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "evaluation"
+   },
+   "source": [
+    "## 5. Evaluate Performance\n",
+    "\n",
+    "Compare SCU model perplexity to baseline:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "evaluate_perplexity"
+   },
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "\n",
+    "def calculate_perplexity(model, text, tokenizer):\n",
+    "    \"\"\"Calculate perplexity for given text.\"\"\"\n",
+    "    inputs = tokenizer(text, return_tensors='pt', truncation=True, max_length=512).to(device)\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        outputs = model(**inputs, labels=inputs['input_ids'])\n",
+    "        loss = outputs.loss\n",
+    "        perplexity = math.exp(loss.item())\n",
+    "    \n",
+    "    return perplexity\n",
+    "\n",
+    "# Test text for evaluation\n",
+    "test_text = \"\"\"\n",
+    "Machine learning is a subset of artificial intelligence that enables \n",
+    "systems to learn and improve from experience without being explicitly \n",
+    "programmed. It focuses on developing computer programs that can access \n",
+    "data and use it to learn for themselves.\n",
+    "\"\"\"\n",
+    "\n",
+    "# Calculate perplexity\n",
+    "scu_perplexity = calculate_perplexity(model, test_text, tokenizer)\n",
+    "print(f'SCU Model Perplexity: {scu_perplexity:.2f}')\n",
+    "print(f'Baseline Perplexity (reported): 15.14')\n",
+    "print(f'Improvement: {(15.14 - scu_perplexity) / 15.14 * 100:.1f}%')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "visualization"
+   },
+   "source": [
+    "## 6. Visualize Control Dynamics\n",
+    "\n",
+    "Show how SCU maintains the target compression ratio during training:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "plot_control"
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# Simulate control dynamics (for demonstration)\n",
+    "steps = np.arange(0, 270)\n",
+    "target_s = 0.01  # 1% target\n",
+    "deadband = 0.002  # ±0.2pp\n",
+    "\n",
+    "# Simulated S(t) converging to target\n",
+    "s_values = target_s + 0.02 * np.exp(-steps/50) * np.sin(steps/10) + np.random.normal(0, 0.0005, len(steps))\n",
+    "s_values = np.clip(s_values, 0, 0.03)\n",
+    "\n",
+    "# Plot\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(steps, s_values * 100, 'b-', linewidth=2, label='S(t)')\n",
+    "plt.axhspan((target_s - deadband) * 100, (target_s + deadband) * 100, \n",
+    "            alpha=0.2, color='green', label=f'Target: {target_s*100:.1f}% ± {deadband*100:.1f}pp')\n",
+    "plt.axhline(target_s * 100, color='green', linestyle='--', alpha=0.5)\n",
+    "\n",
+    "plt.xlabel('Training Step', fontsize=12)\n",
+    "plt.ylabel('S (%)', fontsize=12)\n",
+    "plt.title('SCU Control: S(t) Tracking Target', fontsize=14, fontweight='bold')\n",
+    "plt.legend()\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print('The plot shows how SCU maintains the compression ratio S within the target band.')\n",
+    "print('This automatic control eliminates the need for manual hyperparameter tuning.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "comparison"
+   },
+   "source": [
+    "## 7. Performance Comparison\n",
+    "\n",
+    "Compare SCU with baseline model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "compare_models"
+   },
+   "outputs": [],
+   "source": [
+    "# Performance metrics\n",
+    "results = {\n",
+    "    'Metric': ['Bits per Token', 'Perplexity', 'Compression Ratio'],\n",
+    "    'Baseline': [3.920, 15.14, '0.0%'],\n",
+    "    'SCU': [3.676, 12.78, '1.0%'],\n",
+    "    'Improvement': ['-6.2%', '-15.6%', 'Controlled']\n",
+    "}\n",
+    "\n",
+    "# Display as table\n",
+    "import pandas as pd\n",
+    "df = pd.DataFrame(results)\n",
+    "print('\\nPerformance Comparison: Baseline vs SCU')\n",
+    "print('=' * 60)\n",
+    "print(df.to_string(index=False))\n",
+    "print('=' * 60)\n",
+    "print('\\nKey Achievement: 15.6% perplexity reduction with automatic tuning!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "conclusion"
+   },
+   "source": [
+    "## 8. Conclusion\n",
+    "\n",
+    "The Shannon Control Unit demonstrates:\n",
+    "\n",
+    "- **15.6% lower perplexity** compared to baseline\n",
+    "- **Automatic regularization** without manual tuning\n",
+    "- **Stable control** maintaining 1% ± 0.2pp compression ratio\n",
+    "- **Generalizable approach** across model scales\n",
+    "\n",
+    "### Next Steps\n",
+    "\n",
+    "1. Try different prompts to explore model capabilities\n",
+    "2. Fine-tune your own models with SCU control\n",
+    "3. Read the [paper](https://arxiv.org/abs/xxxx.xxxxx) for technical details\n",
+    "\n",
+    "### Resources\n",
+    "\n",
+    "- Model: [hunterbown/shannon-control-unit](https://huggingface.co/hunterbown/shannon-control-unit)\n",
+    "- GitHub: [shannon-control-unit](https://github.com/Hmbown/shannon-control-unit)\n",
+    "- Contact: hunter@shannonlabs.dev"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "name": "SCU_Demo.ipynb",
+   "provenance": [],
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
 }