update

.claude/settings.local.json

@@ -8,7 +8,8 @@
       "Bash(git branch:*)",
       "Bash(git commit -m \"$\\(cat <<''EOF''\nFix Gradio compatibility for HuggingFace Spaces\n\n- Upgrade gradio to >=5.0.0 to fix API schema bug\n- Add server_name and server_port to demo.launch\\(\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
       "Bash(git commit:*)",
-      "Bash(git reset:*)"
+      "Bash(git reset:*)",
+      "Bash(and top-10 predictions\" to better reflect what users see in the tooltip.\nAlso updated color legend to match the swapped model positions.\n\nCo-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
     ]
   }
 }

app.py

@@ -35,6 +35,12 @@ _qwen_tokenizer = None
 _rwkv_model = None
 _rwkv_tokenizer = None
 _rwkv_model_path = None
+_stats_manager = None
+
+# Precomputed example cache
+_precomputed_html = None
+_precomputed_text = None
+PRECOMPUTED_DIR = SCRIPT_DIR / "precomputed"
 
 
 def download_rwkv_model(progress=None):
@@ -124,12 +130,36 @@ def validate_input(text: str) -> tuple[bool, str]:
     return True, text
 
 
+def load_precomputed_example():
+    """Load precomputed example visualization."""
+    global _precomputed_html, _precomputed_text
+
+    html_path = PRECOMPUTED_DIR / "example_visualization.html"
+    metadata_path = PRECOMPUTED_DIR / "example_metadata.json"
+
+    if html_path.exists() and metadata_path.exists():
+        import json
+        with open(html_path, "r", encoding="utf-8") as f:
+            _precomputed_html = f.read()
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            metadata = json.load(f)
+            _precomputed_text = metadata.get("example_text", "")
+        print(f"Loaded precomputed example ({len(_precomputed_text)} chars)")
+        return True
+    else:
+        print("No precomputed example found. Run precompute_example.py first.")
+        return False
+
+
 def initialize_models():
     """Initialize and cache both models at startup."""
-    global _qwen_model, _qwen_tokenizer, _rwkv_model, _rwkv_tokenizer, _rwkv_model_path
+    global _qwen_model, _qwen_tokenizer, _rwkv_model, _rwkv_tokenizer, _rwkv_model_path, _stats_manager
 
     print("Initializing models...")
 
+    # Load precomputed example first
+    load_precomputed_example()
+
     # Download RWKV model if needed
     print("Checking RWKV7 model...")
     _rwkv_model_path = download_rwkv_model()
@@ -142,6 +172,10 @@ def initialize_models():
     print("Loading RWKV7-G1C-1.5B...")
     _rwkv_model, _rwkv_tokenizer = load_rwkv7_model(_rwkv_model_path)
 
+    # Initialize stats manager
+    from core.inference_stats import InferenceStatsManager
+    _stats_manager = InferenceStatsManager()
+
     print("Models loaded successfully!")
 
 
@@ -165,7 +199,7 @@ def run_evaluation(text: str, progress=gr.Progress()):
     from visualization.html_generator import generate_comparison_html
 
     # Use cached models
-    global _qwen_model, _qwen_tokenizer, _rwkv_model, _rwkv_tokenizer
+    global _qwen_model, _qwen_tokenizer, _rwkv_model, _rwkv_tokenizer, _stats_manager
 
     # Validate input
     valid, result = validate_input(text)
@@ -177,12 +211,38 @@ def run_evaluation(text: str, progress=gr.Progress()):
     try:
         # Step 1: Evaluate Qwen (using cached model)
         progress(0, desc="Evaluating with Qwen3...")
+
+        # Get token count for prediction
+        qwen_inputs = _qwen_tokenizer(text, return_tensors="pt", add_special_tokens=False)
+        qwen_token_count = qwen_inputs["input_ids"].shape[-1]
+        qwen_predicted_time = _stats_manager.predict_time("qwen", qwen_token_count)
+
         result_qwen = evaluate_hf_single_sample(_qwen_model, _qwen_tokenizer, text, bos_mode="add_newline_token")
 
+        # Save stats and print comparison
+        _stats_manager.add_record("qwen", qwen_token_count, result_qwen["inference_time"])
+        if qwen_predicted_time is not None:
+            print(f"Qwen3 completed in {result_qwen['inference_time']:.2f}s (predicted: {qwen_predicted_time:.2f}s)")
+        else:
+            print(f"Qwen3 completed in {result_qwen['inference_time']:.2f}s")
+
         # Step 2: Evaluate RWKV7 (using cached model)
         progress(0, desc="Evaluating with RWKV7...")
+
+        # Get token count for prediction
+        rwkv_tokenized = _rwkv_tokenizer.encode(text)
+        rwkv_token_count = len(rwkv_tokenized.ids if hasattr(rwkv_tokenized, "ids") else rwkv_tokenized)
+        rwkv_predicted_time = _stats_manager.predict_time("rwkv", rwkv_token_count)
+
         result_rwkv = evaluate_rwkv7_single_sample(_rwkv_model, _rwkv_tokenizer, text)
 
+        # Save stats and print comparison
+        _stats_manager.add_record("rwkv", rwkv_token_count, result_rwkv["inference_time"])
+        if rwkv_predicted_time is not None:
+            print(f"RWKV7 completed in {result_rwkv['inference_time']:.2f}s (predicted: {rwkv_predicted_time:.2f}s)")
+        else:
+            print(f"RWKV7 completed in {result_rwkv['inference_time']:.2f}s")
+
         # Step 3: Generate visualization
         progress(0, desc="Generating visualization...")
         html = generate_comparison_html(
@@ -202,7 +262,24 @@ def run_evaluation(text: str, progress=gr.Progress()):
         # Wrap HTML for iframe display
         wrapped_html = wrap_html_in_iframe(html)
 
-        return wrapped_html
+        # Generate timing information for UI display
+        timing_lines = ["## ⏱️ Inference Timing\n"]
+
+        # Qwen timing
+        if qwen_predicted_time is not None:
+            timing_lines.append(f"**Qwen3-1.7B-Base**: {result_qwen['inference_time']:.2f}s (predicted: {qwen_predicted_time:.2f}s)")
+        else:
+            timing_lines.append(f"**Qwen3-1.7B-Base**: {result_qwen['inference_time']:.2f}s")
+
+        # RWKV timing
+        if rwkv_predicted_time is not None:
+            timing_lines.append(f"**RWKV7-G1C-1.5B**: {result_rwkv['inference_time']:.2f}s (predicted: {rwkv_predicted_time:.2f}s)")
+        else:
+            timing_lines.append(f"**RWKV7-G1C-1.5B**: {result_rwkv['inference_time']:.2f}s")
+
+        timing_text = "\n\n".join(timing_lines)
+
+        return wrapped_html, timing_text
 
     except torch.cuda.OutOfMemoryError:
         if torch.cuda.is_available():
@@ -218,7 +295,18 @@ def run_evaluation(text: str, progress=gr.Progress()):
 
 def clear_inputs():
     """Clear all inputs and outputs."""
-    return "", None
+    return "", None, ""
+
+
+def get_default_example():
+    """Get the default example for display on page load."""
+    global _precomputed_html, _precomputed_text
+
+    if _precomputed_html and _precomputed_text:
+        wrapped_html = wrap_html_in_iframe(_precomputed_html)
+        return _precomputed_text, wrapped_html, ""
+    else:
+        return "", None, ""
 
 
 # Build Gradio UI
@@ -245,14 +333,22 @@ with gr.Blocks(title="Compression-Lens: RWKV-7 vs Qwen3", theme=gr.themes.Soft()
 
     gr.Markdown("---")
 
+    # Timing information display
+    with gr.Row():
+        with gr.Column():
+            timing_info = gr.Markdown(label="Inference Timing")
+
     with gr.Row():
         with gr.Column():
             output_html = gr.HTML(label="Visualization")
 
     # Event handlers
-    clear_btn.click(fn=clear_inputs, outputs=[text_input, output_html])
+    clear_btn.click(fn=clear_inputs, outputs=[text_input, output_html, timing_info])
+
+    run_btn.click(fn=run_evaluation, inputs=[text_input], outputs=[output_html, timing_info])
 
-    run_btn.click(fn=run_evaluation, inputs=[text_input], outputs=[output_html])
+    # Load default example on page load
+    demo.load(fn=get_default_example, outputs=[text_input, output_html, timing_info])
 
 
 if __name__ == "__main__":

core/evaluator.py

@@ -7,6 +7,7 @@ Provides single-sample evaluation functions for Qwen3 and RWKV7 models.
 import gc
 import math
 import os
+import time
 from typing import List, Dict, Any, Optional
 
 import torch
@@ -95,6 +96,8 @@ def evaluate_hf_single_sample(model, tokenizer, text: str, bos_mode: str = "add_
     Returns:
         dict with byte_wise_losses, top5_predictions, compression_rate, etc.
     """
+    start_time = time.time()
+
     # Create token-to-bytes converter
     token2bytes_converter = TokenizerBytesConverter(model_name_or_path=tokenizer.name_or_path, tokenizer=tokenizer)
 
@@ -162,6 +165,7 @@ def evaluate_hf_single_sample(model, tokenizer, text: str, bos_mode: str = "add_
     num_bytes = len(text.encode("utf-8"))
     avg_loss = total_loss / seq_length
     compression_rate = avg_loss * COMPRESSION_RATE_FACTOR
+    inference_time = time.time() - start_time
 
     return {
         "byte_wise_losses": byte_wise_losses,
@@ -172,6 +176,7 @@ def evaluate_hf_single_sample(model, tokenizer, text: str, bos_mode: str = "add_
         "num_bytes": num_bytes,
         "model_name": getattr(model.config, "_name_or_path", "unknown"),
         "tokenizer": tokenizer,
+        "inference_time": inference_time,
     }
 
 
@@ -188,6 +193,8 @@ def evaluate_rwkv7_single_sample(model, tokenizer, text: str) -> Dict[str, Any]:
     Returns:
         dict with byte_wise_losses, top5_predictions, compression_rate, etc.
     """
+    start_time = time.time()
+
     # Tokenize
     tokenized = tokenizer.encode(text)
     if hasattr(tokenized, "ids"):
@@ -239,6 +246,7 @@ def evaluate_rwkv7_single_sample(model, tokenizer, text: str) -> Dict[str, Any]:
     num_bytes = len(text.encode("utf-8"))
     avg_loss = total_loss / input_length
     compression_rate = avg_loss * COMPRESSION_RATE_FACTOR
+    inference_time = time.time() - start_time
 
     return {
         "byte_wise_losses": byte_wise_losses,
@@ -249,4 +257,5 @@ def evaluate_rwkv7_single_sample(model, tokenizer, text: str) -> Dict[str, Any]:
         "num_bytes": num_bytes,
         "model_name": "RWKV7-G1C-1.5B",
         "tokenizer": tokenizer,
+        "inference_time": inference_time,
     }

core/inference_stats.py

@@ -0,0 +1,155 @@
+"""
+Inference statistics manager for tracking and predicting model inference times.
+
+This module provides functionality to:
+- Record historical inference statistics (token count, inference time)
+- Predict inference time using k-nearest neighbors algorithm
+- Persist statistics to disk for cross-session usage
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+class InferenceStatsManager:
+    """Manages inference statistics for time prediction."""
+
+    def __init__(self, cache_dir: Optional[str] = None):
+        """
+        Initialize the statistics manager.
+
+        Args:
+            cache_dir: Optional custom cache directory. If None, uses default.
+        """
+        if cache_dir is None:
+            # Use user's cache directory
+            if os.name == 'nt':  # Windows
+                base_cache = os.path.expandvars(r'%LOCALAPPDATA%')
+            else:  # Unix-like
+                base_cache = os.path.expanduser('~/.cache')
+
+            cache_dir = os.path.join(base_cache, 'uncheatableeval_lens')
+
+        self.cache_dir = Path(cache_dir)
+        self.stats_file = self.cache_dir / 'inference_stats.json'
+
+        # Create cache directory if it doesn't exist
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _load_stats(self) -> List[Dict]:
+        """
+        Load statistics from JSON file.
+
+        Returns:
+            List of statistics records, empty list if file doesn't exist.
+        """
+        if not self.stats_file.exists():
+            return []
+
+        try:
+            with open(self.stats_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Warning: Failed to load statistics file: {e}")
+            return []
+
+    def _save_stats(self, stats: List[Dict]) -> None:
+        """
+        Save statistics to JSON file.
+
+        Args:
+            stats: List of statistics records to save.
+        """
+        try:
+            with open(self.stats_file, 'w', encoding='utf-8') as f:
+                json.dump(stats, f, indent=2, ensure_ascii=False)
+        except IOError as e:
+            print(f"Warning: Failed to save statistics file: {e}")
+
+    def add_record(self, model_name: str, input_tokens: int, inference_time: float) -> None:
+        """
+        Add a new inference record to the statistics.
+
+        Args:
+            model_name: Name of the model ("qwen" or "rwkv")
+            input_tokens: Number of input tokens
+            inference_time: Inference time in seconds
+        """
+        stats = self._load_stats()
+
+        record = {
+            "model_name": model_name,
+            "input_tokens": input_tokens,
+            "inference_time": inference_time,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        stats.append(record)
+        self._save_stats(stats)
+
+    def _find_k_nearest(self, records: List[Dict], target_tokens: int, k: int) -> List[Tuple[Dict, float]]:
+        """
+        Find k nearest records by token count.
+
+        Args:
+            records: List of historical records
+            target_tokens: Target token count
+            k: Number of nearest neighbors to find
+
+        Returns:
+            List of (record, distance) tuples, sorted by distance
+        """
+        # Calculate distances
+        distances = []
+        for record in records:
+            distance = abs(record["input_tokens"] - target_tokens)
+            distances.append((record, distance))
+
+        # Sort by distance and return top k
+        distances.sort(key=lambda x: x[1])
+        return distances[:k]
+
+    def predict_time(self, model_name: str, input_tokens: int, k: int = 5) -> Optional[float]:
+        """
+        Predict inference time using k-nearest neighbors algorithm.
+
+        Args:
+            model_name: Name of the model ("qwen" or "rwkv")
+            input_tokens: Number of input tokens
+            k: Number of nearest neighbors to use (default: 5)
+
+        Returns:
+            Predicted inference time in seconds, or None if no historical data
+        """
+        stats = self._load_stats()
+
+        # Filter records for the specific model
+        model_records = [r for r in stats if r["model_name"] == model_name]
+
+        if not model_records:
+            return None
+
+        # Find k nearest neighbors
+        nearest = self._find_k_nearest(model_records, input_tokens, k)
+
+        if not nearest:
+            return None
+
+        # Calculate weighted average using inverse distance weighting
+        total_weight = 0.0
+        weighted_sum = 0.0
+
+        for record, distance in nearest:
+            # Inverse distance weighting: weight = 1 / (1 + distance)
+            weight = 1.0 / (1.0 + distance)
+            weighted_sum += weight * record["inference_time"]
+            total_weight += weight
+
+        if total_weight == 0:
+            return None
+
+        return weighted_sum / total_weight
+

precompute_example.py

@@ -0,0 +1,172 @@
+"""
+Precompute example evaluation results for the default demo.
+
+This script runs the evaluation on the example text and saves the results
+so they can be loaded instantly when users visit the page.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+import torch
+
+# Get the directory where this script is located
+SCRIPT_DIR = Path(__file__).parent.absolute()
+MODELS_DIR = SCRIPT_DIR / "models"
+SUPPORT_DIR = SCRIPT_DIR / "support"
+PRECOMPUTED_DIR = SCRIPT_DIR / "precomputed"
+
+# Model configuration
+QWEN_MODEL_ID = "Qwen/Qwen3-1.7B-Base"
+RWKV_MODEL_FILENAME = "rwkv7-g1c-1.5b-20260110-ctx8192.pth"
+
+# Detect device
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IS_CPU = DEVICE == "cpu"
+
+
+def download_rwkv_model():
+    """Download RWKV7 model if not exists."""
+    from huggingface_hub import hf_hub_download
+
+    model_path = MODELS_DIR / RWKV_MODEL_FILENAME
+
+    if model_path.exists():
+        return str(model_path)
+
+    MODELS_DIR.mkdir(parents=True, exist_ok=True)
+
+    downloaded_path = hf_hub_download(
+        repo_id="BlinkDL/rwkv7-g1", filename=RWKV_MODEL_FILENAME, local_dir=str(MODELS_DIR), local_dir_use_symlinks=False
+    )
+
+    return downloaded_path
+
+
+def load_qwen_model():
+    """Load Qwen3-1.7B-Base model."""
+    from transformers import AutoTokenizer, AutoModelForCausalLM
+
+    tokenizer = AutoTokenizer.from_pretrained(QWEN_MODEL_ID, trust_remote_code=True)
+
+    if IS_CPU:
+        model_kwargs = {"torch_dtype": torch.float32, "device_map": None, "trust_remote_code": True, "low_cpu_mem_usage": True}
+        model = AutoModelForCausalLM.from_pretrained(QWEN_MODEL_ID, **model_kwargs).eval()
+    else:
+        model_kwargs = {"torch_dtype": torch.bfloat16, "device_map": "auto", "trust_remote_code": True}
+        try:
+            model = AutoModelForCausalLM.from_pretrained(QWEN_MODEL_ID, attn_implementation="flash_attention_2", **model_kwargs).eval()
+        except Exception:
+            model = AutoModelForCausalLM.from_pretrained(QWEN_MODEL_ID, **model_kwargs).eval()
+
+    return model, tokenizer
+
+
+def load_rwkv7_model(model_path: str):
+    """Load RWKV7-G1C-1.5B model."""
+    os.environ["RWKV_JIT_ON"] = "1"
+    os.environ["RWKV_V7_ON"] = "1"
+
+    if IS_CPU:
+        os.environ["RWKV_CUDA_ON"] = "0"
+    else:
+        os.environ["RWKV_CUDA_ON"] = "1"
+
+    from rwkv.model import RWKV
+    from rwkv.rwkv_tokenizer import TRIE_TOKENIZER
+
+    if IS_CPU:
+        strategy = "cpu fp32"
+    else:
+        strategy = "cuda fp16"
+
+    if model_path.endswith(".pth"):
+        model_path = model_path[:-4]
+
+    model = RWKV(model=model_path, strategy=strategy)
+
+    vocab_path = str(SUPPORT_DIR / "rwkv_vocab_v20230424.txt")
+    tokenizer = TRIE_TOKENIZER(vocab_path)
+
+    return model, tokenizer
+
+
+def precompute_example():
+    """Precompute the example and save results."""
+    from core.evaluator import evaluate_hf_single_sample, evaluate_rwkv7_single_sample
+    from visualization.html_generator import generate_comparison_html
+
+    # Read example text
+    example_file = SCRIPT_DIR / "the_bitter_lesson.txt"
+    with open(example_file, "r", encoding="utf-8") as f:
+        example_text = f.read()
+
+    print(f"Example text length: {len(example_text)} characters")
+
+    # Download and load models
+    print("Downloading RWKV model if needed...")
+    rwkv_model_path = download_rwkv_model()
+
+    print("Loading Qwen3-1.7B-Base...")
+    qwen_model, qwen_tokenizer = load_qwen_model()
+
+    print("Loading RWKV7-G1C-1.5B...")
+    rwkv_model, rwkv_tokenizer = load_rwkv7_model(rwkv_model_path)
+
+    # Run evaluations
+    print("Evaluating with Qwen3...")
+    result_qwen = evaluate_hf_single_sample(qwen_model, qwen_tokenizer, example_text, bos_mode="add_newline_token")
+    print(f"Qwen3 completed in {result_qwen['inference_time']:.2f}s")
+
+    print("Evaluating with RWKV7...")
+    result_rwkv = evaluate_rwkv7_single_sample(rwkv_model, rwkv_tokenizer, example_text)
+    print(f"RWKV7 completed in {result_rwkv['inference_time']:.2f}s")
+
+    # Generate HTML visualization
+    print("Generating visualization...")
+    html = generate_comparison_html(
+        text=example_text,
+        byte_losses_a=result_rwkv["byte_wise_losses"],
+        byte_losses_b=result_qwen["byte_wise_losses"],
+        model_a_name="RWKV7-G1C-1.5B",
+        model_b_name="Qwen3-1.7B-Base",
+        topk_predictions_a=result_rwkv["top5_predictions"],
+        topk_predictions_b=result_qwen["top5_predictions"],
+        tokenizer_a=result_rwkv["tokenizer"],
+        tokenizer_b=result_qwen["tokenizer"],
+        model_type_a="rwkv7",
+        model_type_b="hf",
+    )
+
+    # Save precomputed results
+    PRECOMPUTED_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Save HTML
+    html_path = PRECOMPUTED_DIR / "example_visualization.html"
+    with open(html_path, "w", encoding="utf-8") as f:
+        f.write(html)
+    print(f"Saved HTML to {html_path}")
+
+    # Save metadata
+    metadata = {
+        "example_text": example_text,
+        "qwen_inference_time": result_qwen["inference_time"],
+        "rwkv_inference_time": result_rwkv["inference_time"],
+        "qwen_compression_rate": result_qwen["compression_rate"],
+        "rwkv_compression_rate": result_rwkv["compression_rate"],
+    }
+    metadata_path = PRECOMPUTED_DIR / "example_metadata.json"
+    with open(metadata_path, "w", encoding="utf-8") as f:
+        json.dump(metadata, f, ensure_ascii=False, indent=2)
+    print(f"Saved metadata to {metadata_path}")
+
+    print("Done! Precomputed example is ready.")
+
+
+if __name__ == "__main__":
+    precompute_example()

precomputed/example_metadata.json

@@ -0,0 +1,7 @@
+{
+  "example_text": "The Bitter Lesson\nRich Sutton\nMarch 13, 2019\nThe biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin. The ultimate reason for this is Moore's law, or rather its generalization of continued exponentially falling cost per unit of computation. Most AI research has been conducted as if the computation available to the agent were constant (in which case leveraging human knowledge would be one of the only ways to improve performance) but, over a slightly longer time than a typical research project, massively more computation inevitably becomes available. Seeking an improvement that makes a difference in the shorter term, researchers seek to leverage their human knowledge of the domain, but the only thing that matters in the long run is the leveraging of computation. These two need not run counter to each other, but in practice they tend to. Time spent on one is time not spent on the other. There are psychological commitments to investment in one approach or the other. And the human-knowledge approach tends to complicate methods in ways that make them less suited to taking advantage of general methods leveraging computation.  There were many examples of AI researchers' belated learning of this bitter lesson, and it is instructive to review some of the most prominent.\n\nIn computer chess, the methods that defeated the world champion, Kasparov, in 1997, were based on massive, deep search. At the time, this was looked upon with dismay by the majority of computer-chess researchers who had pursued methods that leveraged human understanding of the special structure of chess. When a simpler, search-based approach with special hardware and software proved vastly more effective, these human-knowledge-based chess researchers were not good losers. They said that ``brute force\" search may have won this time, but it was not a general strategy, and anyway it was not how people played chess. These researchers wanted methods based on human input to win and were disappointed when they did not.\n\nA similar pattern of research progress was seen in computer Go, only delayed by a further 20 years. Enormous initial efforts went into avoiding search by taking advantage of human knowledge, or of the special features of the game, but all those efforts proved irrelevant, or worse, once search was applied effectively at scale. Also important was the use of learning by self play to learn a value function (as it was in many other games and even in chess, although learning did not play a big role in the 1997 program that first beat a world champion). Learning by self play, and learning in general, is like search in that it enables massive computation to be brought to bear. Search and learning are the two most important classes of techniques for utilizing massive amounts of computation in AI research. In computer Go, as in computer chess, researchers' initial effort was directed towards utilizing human understanding (so that less search was needed) and only much later was much greater success had by embracing search and learning.\n\nIn speech recognition, there was an early competition, sponsored by DARPA, in the 1970s. Entrants included a host of special methods that took advantage of human knowledge---knowledge of words, of phonemes, of the human vocal tract, etc. On the other side were newer methods that were more statistical in nature and did much more computation, based on hidden Markov models (HMMs). Again, the statistical methods won out over the human-knowledge-based methods. This led to a major change in all of natural language processing, gradually over decades, where statistics and computation came to dominate the field. The recent rise of deep learning in speech recognition is the most recent step in this consistent direction. Deep learning methods rely even less on human knowledge, and use even more computation, together with learning on huge training sets, to produce dramatically better speech recognition systems. As in the games, researchers always tried to make systems that worked the way the researchers thought their own minds worked---they tried to put that knowledge in their systems---but it proved ultimately counterproductive, and a colossal waste of researcher's time, when, through Moore's law, massive computation became available and a means was found to put it to good use.\n\nIn computer vision, there has been a similar pattern. Early methods conceived of vision as searching for edges, or generalized cylinders, or in terms of SIFT features. But today all this is discarded. Modern deep-learning neural networks use only the notions of convolution and certain kinds of invariances, and perform much better.\n\nThis is a big lesson. As a field, we still have not thoroughly learned it, as we are continuing to make the same kind of mistakes. To see this, and to effectively resist it, we have to understand the appeal of these mistakes. We have to learn the bitter lesson that building in how we think we think does not work in the long run. The bitter lesson is based on the historical observations that 1) AI researchers have often tried to build knowledge into their agents, 2) this always helps in the short term, and is personally satisfying to the researcher, but 3) in the long run it plateaus and even inhibits further progress, and 4) breakthrough progress eventually arrives by an opposing approach based on scaling computation by search and learning. The eventual success is tinged with bitterness, and often incompletely digested, because it is success over a favored, human-centric approach.\n\nOne thing that should be learned from the bitter lesson is the great power of general purpose methods, of methods that continue to scale with increased computation even as the available computation becomes very great. The two methods that seem to scale arbitrarily in this way are search and learning.\n\nThe second general point to be learned from the bitter lesson is that the actual contents of minds are tremendously, irredeemably complex; we should stop trying to find simple ways to think about the contents of minds, such as simple ways to think about space, objects, multiple agents, or symmetries. All these are part of the arbitrary, intrinsically-complex, outside world. They are not what should be built in, as their complexity is endless; instead we should build in only the meta-methods that can find and capture this arbitrary complexity. Essential to these methods is that they can find good approximations, but the search for them should be by our methods, not by us. We want AI agents that can discover like we can, not which contain what we have discovered. Building in our discoveries only makes it harder to see how the discovering process can be done.\n",
+  "qwen_inference_time": 23.581797122955322,
+  "rwkv_inference_time": 34.39247703552246,
+  "qwen_compression_rate": 48.14428559434192,
+  "rwkv_compression_rate": 47.624574152536056
+}

the_bitter_lesson.txt

@@ -0,0 +1,18 @@
+The Bitter Lesson
+Rich Sutton
+March 13, 2019
+The biggest lesson that can be read from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin. The ultimate reason for this is Moore's law, or rather its generalization of continued exponentially falling cost per unit of computation. Most AI research has been conducted as if the computation available to the agent were constant (in which case leveraging human knowledge would be one of the only ways to improve performance) but, over a slightly longer time than a typical research project, massively more computation inevitably becomes available. Seeking an improvement that makes a difference in the shorter term, researchers seek to leverage their human knowledge of the domain, but the only thing that matters in the long run is the leveraging of computation. These two need not run counter to each other, but in practice they tend to. Time spent on one is time not spent on the other. There are psychological commitments to investment in one approach or the other. And the human-knowledge approach tends to complicate methods in ways that make them less suited to taking advantage of general methods leveraging computation.  There were many examples of AI researchers' belated learning of this bitter lesson, and it is instructive to review some of the most prominent.
+
+In computer chess, the methods that defeated the world champion, Kasparov, in 1997, were based on massive, deep search. At the time, this was looked upon with dismay by the majority of computer-chess researchers who had pursued methods that leveraged human understanding of the special structure of chess. When a simpler, search-based approach with special hardware and software proved vastly more effective, these human-knowledge-based chess researchers were not good losers. They said that ``brute force" search may have won this time, but it was not a general strategy, and anyway it was not how people played chess. These researchers wanted methods based on human input to win and were disappointed when they did not.
+
+A similar pattern of research progress was seen in computer Go, only delayed by a further 20 years. Enormous initial efforts went into avoiding search by taking advantage of human knowledge, or of the special features of the game, but all those efforts proved irrelevant, or worse, once search was applied effectively at scale. Also important was the use of learning by self play to learn a value function (as it was in many other games and even in chess, although learning did not play a big role in the 1997 program that first beat a world champion). Learning by self play, and learning in general, is like search in that it enables massive computation to be brought to bear. Search and learning are the two most important classes of techniques for utilizing massive amounts of computation in AI research. In computer Go, as in computer chess, researchers' initial effort was directed towards utilizing human understanding (so that less search was needed) and only much later was much greater success had by embracing search and learning.
+
+In speech recognition, there was an early competition, sponsored by DARPA, in the 1970s. Entrants included a host of special methods that took advantage of human knowledge---knowledge of words, of phonemes, of the human vocal tract, etc. On the other side were newer methods that were more statistical in nature and did much more computation, based on hidden Markov models (HMMs). Again, the statistical methods won out over the human-knowledge-based methods. This led to a major change in all of natural language processing, gradually over decades, where statistics and computation came to dominate the field. The recent rise of deep learning in speech recognition is the most recent step in this consistent direction. Deep learning methods rely even less on human knowledge, and use even more computation, together with learning on huge training sets, to produce dramatically better speech recognition systems. As in the games, researchers always tried to make systems that worked the way the researchers thought their own minds worked---they tried to put that knowledge in their systems---but it proved ultimately counterproductive, and a colossal waste of researcher's time, when, through Moore's law, massive computation became available and a means was found to put it to good use.
+
+In computer vision, there has been a similar pattern. Early methods conceived of vision as searching for edges, or generalized cylinders, or in terms of SIFT features. But today all this is discarded. Modern deep-learning neural networks use only the notions of convolution and certain kinds of invariances, and perform much better.
+
+This is a big lesson. As a field, we still have not thoroughly learned it, as we are continuing to make the same kind of mistakes. To see this, and to effectively resist it, we have to understand the appeal of these mistakes. We have to learn the bitter lesson that building in how we think we think does not work in the long run. The bitter lesson is based on the historical observations that 1) AI researchers have often tried to build knowledge into their agents, 2) this always helps in the short term, and is personally satisfying to the researcher, but 3) in the long run it plateaus and even inhibits further progress, and 4) breakthrough progress eventually arrives by an opposing approach based on scaling computation by search and learning. The eventual success is tinged with bitterness, and often incompletely digested, because it is success over a favored, human-centric approach.
+
+One thing that should be learned from the bitter lesson is the great power of general purpose methods, of methods that continue to scale with increased computation even as the available computation becomes very great. The two methods that seem to scale arbitrarily in this way are search and learning.
+
+The second general point to be learned from the bitter lesson is that the actual contents of minds are tremendously, irredeemably complex; we should stop trying to find simple ways to think about the contents of minds, such as simple ways to think about space, objects, multiple agents, or symmetries. All these are part of the arbitrary, intrinsically-complex, outside world. They are not what should be built in, as their complexity is endless; instead we should build in only the meta-methods that can find and capture this arbitrary complexity. Essential to these methods is that they can find good approximations, but the search for them should be by our methods, not by us. We want AI agents that can discover like we can, not which contain what we have discovered. Building in our discoveries only makes it harder to see how the discovering process can be done.