@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/examples/reranker/convert_to_torchscript.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""
+Convert MS-MARCO TinyBERT model to TorchScript format for rust-bert
+"""
+
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import os
+import sys
+
+def convert_to_torchscript(model_name="cross-encoder/ms-marco-TinyBERT-L-2-v2", output_dir="models/ms-marco-TinyBERT-L-2-v2"):
+    print(f"Converting {model_name} to TorchScript format...")
+    
+    # Create output directory
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Load model and tokenizer
+    print("Loading model...")
+    model = AutoModelForSequenceClassification.from_pretrained(model_name)
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    
+    # Set to eval mode
+    model.eval()
+    
+    # Create dummy inputs for tracing
+    dummy_text = "What is machine learning?"
+    dummy_inputs = tokenizer(
+        dummy_text, 
+        return_tensors="pt",
+        padding=True,
+        truncation=True,
+        max_length=512
+    )
+    
+    # Get the input tensors
+    input_ids = dummy_inputs["input_ids"]
+    attention_mask = dummy_inputs["attention_mask"]
+    token_type_ids = dummy_inputs.get("token_type_ids", torch.zeros_like(input_ids))
+    
+    print(f"Input shapes:")
+    print(f"  input_ids: {input_ids.shape}")
+    print(f"  attention_mask: {attention_mask.shape}")
+    print(f"  token_type_ids: {token_type_ids.shape}")
+    
+    # Trace the model
+    print("\nTracing model...")
+    try:
+        # Method 1: Trace with all inputs
+        traced_model = torch.jit.trace(
+            model, 
+            (input_ids, attention_mask, token_type_ids),
+            strict=False
+        )
+        print("✓ Model traced successfully with all inputs")
+    except Exception as e:
+        print(f"Failed to trace with all inputs: {e}")
+        # Method 2: Try with just input_ids
+        try:
+            traced_model = torch.jit.trace(model, input_ids)
+            print("✓ Model traced with input_ids only")
+        except Exception as e2:
+            print(f"Failed to trace with input_ids only: {e2}")
+            return False
+    
+    # Save the traced model
+    output_path = os.path.join(output_dir, "rust_model.ot")
+    traced_model.save(output_path)
+    print(f"\n✓ Saved TorchScript model to: {output_path}")
+    
+    # Also save the tokenizer vocab
+    tokenizer.save_pretrained(output_dir)
+    print(f"✓ Saved tokenizer files to: {output_dir}")
+    
+    # Test the traced model
+    print("\nTesting traced model...")
+    with torch.no_grad():
+        original_output = model(input_ids, attention_mask, token_type_ids)
+        traced_output = traced_model(input_ids, attention_mask, token_type_ids)
+        
+        orig_logits = original_output.logits[0][0].item()
+        traced_logits = traced_output.logits[0][0].item()
+        
+        print(f"Original model logits: {orig_logits:.6f}")
+        print(f"Traced model logits: {traced_logits:.6f}")
+        print(f"Difference: {abs(orig_logits - traced_logits):.6f}")
+        
+        if abs(orig_logits - traced_logits) < 1e-5:
+            print("✓ Models produce identical results!")
+        else:
+            print("⚠ Warning: Models produce different results")
+    
+    return True
+
+def main():
+    # Convert TinyBERT
+    if convert_to_torchscript():
+        print("\n" + "="*60)
+        print("Conversion successful!")
+        print("="*60)
+        print("\nTo use with rust-bert:")
+        print("1. Copy the rust_model.ot file to your rust project")
+        print("2. Use LocalResource to load the model")
+        print("3. The vocab files are also saved for tokenization")
+    else:
+        print("\nConversion failed!")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/data/probe/examples/reranker/debug_scoring.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+Focused debugging script for cross-encoder scoring issues.
+
+This script provides a minimal, easily modifiable test harness for debugging
+specific query-document pairs and comparing with Rust implementation results.
+
+Usage:
+    python debug_scoring.py
+    
+Or modify the test cases in the script and run again.
+"""
+
+import sys
+import torch
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# Configuration - MODIFY THESE FOR YOUR TESTS
+MODEL_NAME = "cross-encoder/ms-marco-TinyBERT-L-2-v2"
+MAX_LENGTH = 512
+
+# Test cases - MODIFY THESE FOR YOUR SPECIFIC DEBUGGING
+TEST_CASES = [
+    {
+        "name": "Relevant Query",
+        "query": "how does authentication work",
+        "document": """Authentication is the process of verifying the identity of a user, device, or system. 
+In web applications, authentication typically involves checking credentials like usernames 
+and passwords against a database. The authentication process usually follows these steps:
+- User provides credentials
+- System validates credentials against stored data
+- If valid, system grants access and creates a session"""
+    },
+    {
+        "name": "Irrelevant Query", 
+        "query": "foobar random nonsense gibberish",
+        "document": """Authentication is the process of verifying the identity of a user, device, or system. 
+In web applications, authentication typically involves checking credentials like usernames 
+and passwords against a database. The authentication process usually follows these steps:
+- User provides credentials
+- System validates credentials against stored data
+- If valid, system grants access and creates a session"""
+    }
+]
+
+def debug_single_case(tokenizer, model, query: str, document: str, case_name: str):
+    """Debug a single query-document pair with detailed output."""
+    print(f"\n{'='*60}")
+    print(f"DEBUGGING: {case_name}")
+    print(f"{'='*60}")
+    print(f"Query: '{query}'")
+    print(f"Document: '{document[:100]}...'")
+    
+    # Tokenize
+    encoded = tokenizer(
+        query, 
+        document,
+        truncation=True,
+        padding=True,
+        max_length=MAX_LENGTH,
+        return_tensors="pt",
+        return_attention_mask=True,
+        return_token_type_ids=True
+    )
+    
+    # Print tokenization info
+    input_ids = encoded['input_ids'][0]
+    attention_mask = encoded['attention_mask'][0]
+    token_type_ids = encoded.get('token_type_ids', [None])[0]
+    
+    print(f"\nTokenization:")
+    print(f"  Input IDs shape: {input_ids.shape}")
+    print(f"  Number of tokens: {len(input_ids)}")
+    print(f"  Attention mask sum: {attention_mask.sum().item()}")
+    
+    # Show first few and last few tokens
+    tokens = tokenizer.convert_ids_to_tokens(input_ids)
+    print(f"  First 10 tokens: {tokens[:10]}")
+    print(f"  Last 10 tokens: {tokens[-10:]}")
+    
+    # Find special tokens
+    cls_positions = [i for i, token in enumerate(tokens) if token == '[CLS]']
+    sep_positions = [i for i, token in enumerate(tokens) if token == '[SEP]']
+    print(f"  [CLS] positions: {cls_positions}")
+    print(f"  [SEP] positions: {sep_positions}")
+    
+    # Model inference
+    model.eval()
+    with torch.no_grad():
+        outputs = model(**encoded)
+        logits = outputs.logits
+    
+    print(f"\nModel Output:")
+    print(f"  Raw logits: {logits}")
+    print(f"  Logits shape: {logits.shape}")
+    
+    # Calculate different score interpretations
+    if logits.shape[-1] == 1:
+        # Single output - treat as regression
+        sigmoid_score = torch.sigmoid(logits[0, 0]).item()
+        raw_score = logits[0, 0].item()
+        print(f"  Raw score: {raw_score}")
+        print(f"  Sigmoid score: {sigmoid_score}")
+        final_score = sigmoid_score
+    else:
+        # Multiple outputs - treat as classification
+        probabilities = torch.softmax(logits, dim=-1)
+        print(f"  Softmax probabilities: {probabilities}")
+        if logits.shape[-1] == 2:
+            # Binary classification
+            final_score = probabilities[0, 1].item()
+            print(f"  Relevance probability (class 1): {final_score}")
+        else:
+            final_score = probabilities[0, 0].item()
+            print(f"  First class probability: {final_score}")
+    
+    print(f"\nFINAL SCORE: {final_score:.6f}")
+    
+    # Return data for comparison
+    return {
+        'case_name': case_name,
+        'query': query,
+        'document_preview': document[:100] + '...',
+        'num_tokens': len(input_ids),
+        'raw_logits': logits.cpu().numpy().tolist(),
+        'final_score': final_score
+    }
+
+def main():
+    """Run focused debugging tests."""
+    print("Cross-Encoder Scoring Debug Tool")
+    print(f"Model: {MODEL_NAME}")
+    print(f"PyTorch device: {'cuda' if torch.cuda.is_available() else 'cpu'}")
+    
+    # Load model and tokenizer
+    print("\nLoading model...")
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
+        print("✓ Model loaded successfully")
+    except Exception as e:
+        print(f"❌ Failed to load model: {e}")
+        sys.exit(1)
+    
+    # Run test cases
+    results = []
+    for test_case in TEST_CASES:
+        result = debug_single_case(
+            tokenizer, 
+            model, 
+            test_case["query"], 
+            test_case["document"], 
+            test_case["name"]
+        )
+        results.append(result)
+    
+    # Summary
+    print(f"\n{'='*60}")
+    print("SUMMARY")
+    print(f"{'='*60}")
+    
+    print(f"{'Case':<20} {'Tokens':<8} {'Score':<12} {'Expected':<12}")
+    print("-" * 52)
+    
+    for result in results:
+        expected = "HIGH (>0.5)" if "Relevant" in result['case_name'] else "LOW (<0.5)"
+        actual = "HIGH" if result['final_score'] > 0.5 else "LOW"
+        status = "✓" if (actual == "HIGH") == ("Relevant" in result['case_name']) else "❌"
+        
+        print(f"{result['case_name']:<20} {result['num_tokens']:<8} {result['final_score']:<12.6f} {expected:<12} {status}")
+    
+    # Score difference
+    if len(results) >= 2:
+        score_diff = abs(results[0]['final_score'] - results[1]['final_score'])
+        print(f"\nScore difference: {score_diff:.6f}")
+        if score_diff < 0.1:
+            print("⚠️  WARNING: Score difference is very small - model may not be discriminating well")
+        else:
+            print("✓ Good score separation between relevant and irrelevant queries")
+    
+    print("\nFor Rust debugging, compare:")
+    print("1. Token IDs and their order")
+    print("2. Raw logits values") 
+    print("3. Final score calculation method")
+    print("4. Model configuration and weights")
+
+if __name__ == "__main__":
+    main()

package/data/probe/examples/reranker/debug_tokenization.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""
+Debug script to understand exactly how the Python implementation works
+so we can ensure our Rust implementation matches it perfectly.
+"""
+
+import os
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+import json
+
+print("="*80)
+print("TOKENIZATION AND MODEL LOADING DEBUG")
+print("="*80)
+
+# Load model and tokenizer
+model_name = 'cross-encoder/ms-marco-TinyBERT-L-2-v2'
+print(f"Loading model: {model_name}")
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForSequenceClassification.from_pretrained(model_name)
+
+# Print tokenizer info
+print("\n--- TOKENIZER INFO ---")
+print(f"Tokenizer class: {type(tokenizer).__name__}")
+print(f"Vocab size: {tokenizer.vocab_size}")
+print(f"Model max length: {tokenizer.model_max_length}")
+print(f"Padding token: '{tokenizer.pad_token}' (ID: {tokenizer.pad_token_id})")
+print(f"SEP token: '{tokenizer.sep_token}' (ID: {tokenizer.sep_token_id})")
+print(f"CLS token: '{tokenizer.cls_token}' (ID: {tokenizer.cls_token_id})")
+
+# Test inputs
+query = "how does authentication work"
+document = "Authentication is the process of verifying the identity of a user."
+
+print(f"\nQuery: '{query}'")
+print(f"Document: '{document}'")
+
+# Method 1: Tokenize as pair (CORRECT for cross-encoder)
+print("\n--- METHOD 1: Tokenize as pair (query, document) ---")
+encoding = tokenizer(
+    query,
+    document,
+    padding=True,
+    truncation=True,
+    max_length=512,
+    return_tensors="pt"
+)
+
+print(f"Keys in encoding: {list(encoding.keys())}")
+print(f"Input IDs shape: {encoding['input_ids'].shape}")
+print(f"Input IDs: {encoding['input_ids'][0].tolist()}")
+
+# Decode to see what was tokenized
+decoded = tokenizer.decode(encoding['input_ids'][0])
+print(f"\nDecoded text: '{decoded}'")
+
+# Show token type IDs if present
+if 'token_type_ids' in encoding:
+    print(f"\nToken type IDs: {encoding['token_type_ids'][0].tolist()}")
+    # Find where document starts (token type switches from 0 to 1)
+    token_types = encoding['token_type_ids'][0].tolist()
+    for i, (token_id, token_type) in enumerate(zip(encoding['input_ids'][0].tolist(), token_types)):
+        if i < 30:  # Show first 30 tokens
+            token_text = tokenizer.decode([token_id])
+            print(f"  [{i}] '{token_text}' (ID: {token_id}, Type: {token_type})")
+
+# Method 2: Manual concatenation (WRONG - for comparison)
+print("\n--- METHOD 2: Manual concatenation (WRONG approach) ---")
+manual_text = f"{query} [SEP] {document}"
+encoding2 = tokenizer(
+    manual_text,
+    padding=True,
+    truncation=True,
+    max_length=512,
+    return_tensors="pt"
+)
+
+print(f"Input IDs: {encoding2['input_ids'][0].tolist()}")
+if 'token_type_ids' in encoding2:
+    print(f"Token type IDs: {encoding2['token_type_ids'][0].tolist()}")
+
+# Compare the two methods
+print("\n--- COMPARISON ---")
+ids1 = encoding['input_ids'][0].tolist()
+ids2 = encoding2['input_ids'][0].tolist()
+
+if ids1 == ids2:
+    print("✓ Both methods produce SAME token IDs")
+else:
+    print("❌ Methods produce DIFFERENT token IDs!")
+    print(f"  Length difference: {len(ids1)} vs {len(ids2)}")
+    # Find first difference
+    for i, (t1, t2) in enumerate(zip(ids1, ids2)):
+        if t1 != t2:
+            print(f"  First difference at position {i}: {t1} vs {t2}")
+            break
+
+# Test model forward pass
+print("\n--- MODEL FORWARD PASS ---")
+model.eval()
+
+# Show model configuration
+print(f"Model config:")
+print(f"  Hidden size: {model.config.hidden_size}")
+print(f"  Num labels: {model.config.num_labels}")
+print(f"  Problem type: {getattr(model.config, 'problem_type', 'Not specified')}")
+
+# Test both encodings
+with torch.no_grad():
+    # Correct tokenization
+    output1 = model(**encoding)
+    logits1 = output1.logits[0][0].item()
+    
+    # Manual concatenation
+    output2 = model(**encoding2)
+    logits2 = output2.logits[0][0].item()
+
+print(f"\nResults:")
+print(f"  Correct tokenization score: {logits1:.6f}")
+print(f"  Manual concatenation score: {logits2:.6f}")
+print(f"  Difference: {abs(logits1 - logits2):.6f}")
+
+if abs(logits1 - logits2) > 0.01:
+    print("  ⚠️  Significant difference! Tokenization method matters!")
+
+# Save tokenizer info for Rust comparison
+print("\n--- SAVING DEBUG INFO ---")
+debug_info = {
+    "model_name": model_name,
+    "tokenizer_class": type(tokenizer).__name__,
+    "vocab_size": tokenizer.vocab_size,
+    "special_tokens": {
+        "pad": {"token": tokenizer.pad_token, "id": tokenizer.pad_token_id},
+        "sep": {"token": tokenizer.sep_token, "id": tokenizer.sep_token_id},
+        "cls": {"token": tokenizer.cls_token, "id": tokenizer.cls_token_id},
+    },
+    "test_case": {
+        "query": query,
+        "document": document,
+        "correct_input_ids": ids1,
+        "correct_token_types": encoding['token_type_ids'][0].tolist() if 'token_type_ids' in encoding else None,
+        "correct_score": logits1,
+        "manual_concat_score": logits2,
+    }
+}
+
+with open("tokenizer_debug_info.json", "w") as f:
+    json.dump(debug_info, f, indent=2)
+
+print("Debug info saved to tokenizer_debug_info.json")
+print("\n✅ Use this info to verify your Rust implementation matches exactly!")

package/data/probe/examples/reranker/download_models.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+# Script to download MS-MARCO cross-encoder models for local use
+
+set -e
+
+echo "=== MS-MARCO Model Downloader ==="
+echo
+
+# Base directory for models
+MODEL_DIR="models"
+mkdir -p "$MODEL_DIR"
+
+# Function to download a model
+download_model() {
+    local model_name=$1
+    local model_dir=$2
+    
+    echo "Downloading $model_name..."
+    mkdir -p "$MODEL_DIR/$model_dir"
+    
+    # Download essential files
+    FILES=(
+        "config.json"
+        "tokenizer.json"
+        "tokenizer_config.json"
+        "vocab.txt"
+        "pytorch_model.bin"
+        "special_tokens_map.json"
+    )
+    
+    for file in "${FILES[@]}"; do
+        if [ -f "$MODEL_DIR/$model_dir/$file" ]; then
+            echo "  ✓ $file already exists"
+        else
+            echo "  ⬇ Downloading $file..."
+            curl -L -o "$MODEL_DIR/$model_dir/$file" \
+                "https://huggingface.co/$model_name/resolve/main/$file" 2>/dev/null || {
+                echo "  ⚠ $file not found (might be optional)"
+            }
+        fi
+    done
+    
+    echo "✓ $model_name download complete"
+    echo
+}
+
+# Download models
+echo "Downloading cross-encoder models..."
+echo
+
+# TinyBERT (4M params) - already have this
+if [ -d "$MODEL_DIR/ms-marco-TinyBERT-L-2-v2" ]; then
+    echo "✓ TinyBERT model already exists"
+else
+    download_model "cross-encoder/ms-marco-TinyBERT-L-2-v2" "ms-marco-TinyBERT-L-2-v2"
+fi
+
+# MiniLM-L6 (22M params)
+download_model "cross-encoder/ms-marco-MiniLM-L-6-v2" "ms-marco-MiniLM-L-6-v2"
+
+# MiniLM-L12 (33M params)
+download_model "cross-encoder/ms-marco-MiniLM-L-12-v2" "ms-marco-MiniLM-L-12-v2"
+
+echo "=== Download Complete ==="
+echo
+echo "Models available in $MODEL_DIR/:"
+ls -la "$MODEL_DIR/"
+echo
+echo "You can now use these rerankers:"
+echo "  --reranker ms-marco-tinybert    (4M params, fastest)"
+echo "  --reranker ms-marco-minilm-l6   (22M params, balanced)"
+echo "  --reranker ms-marco-minilm-l12  (33M params, most accurate)"

package/data/probe/examples/reranker/requirements.txt

@@ -0,0 +1,13 @@
+# Requirements for cross-encoder testing and debugging
+torch>=1.9.0
+transformers>=4.20.0
+sentence-transformers>=2.2.0
+numpy>=1.21.0
+
+# Optional but recommended for better performance
+tokenizers>=0.13.0
+
+# For additional debugging and analysis
+matplotlib>=3.5.0
+seaborn>=0.11.0
+pandas>=1.3.0

package/data/probe/examples/reranker/run_comprehensive_benchmark.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+
+echo "🚀 COMPREHENSIVE RERANKER PERFORMANCE ANALYSIS"
+echo "=============================================="
+echo ""
+
+# Build first
+echo "Building release binary..."
+cargo build --release
+echo ""
+
+# Test different document counts
+echo "=== SCALABILITY ANALYSIS ==="
+echo ""
+
+echo "Testing with 100 documents:"
+./target/release/benchmark --demo --query "search algorithm implementation" --num-docs 100 --iterations 5 --batch-size 20
+
+echo ""
+echo "Testing with 500 documents:"
+./target/release/benchmark --demo --query "search algorithm implementation" --num-docs 500 --iterations 5 --batch-size 50
+
+echo ""
+echo "Testing with 1000 documents:"
+./target/release/benchmark --demo --query "search algorithm implementation" --num-docs 1000 --iterations 5 --batch-size 100
+
+echo ""
+echo "Testing with 2000 documents:"
+./target/release/benchmark --demo --query "search algorithm implementation" --num-docs 2000 --iterations 3 --batch-size 200
+
+echo ""
+echo "=== QUERY COMPLEXITY ANALYSIS ==="
+echo ""
+
+echo "Simple query (2 words):"
+./target/release/benchmark --demo --query "rust async" --num-docs 500 --iterations 5 --batch-size 50
+
+echo ""
+echo "Medium query (4 words):"
+./target/release/benchmark --demo --query "vector search embedding similarity" --num-docs 500 --iterations 5 --batch-size 50
+
+echo ""
+echo "Complex query (8 words):"
+./target/release/benchmark --demo --query "distributed search engine indexing algorithm optimization performance tuning" --num-docs 500 --iterations 5 --batch-size 50
+
+echo ""
+echo "=== BATCH SIZE OPTIMIZATION ==="
+echo ""
+
+echo "Batch size 10:"
+./target/release/benchmark --demo --query "machine learning model" --num-docs 500 --iterations 3 --batch-size 10
+
+echo ""
+echo "Batch size 50:"
+./target/release/benchmark --demo --query "machine learning model" --num-docs 500 --iterations 3 --batch-size 50
+
+echo ""
+echo "Batch size 100:"
+./target/release/benchmark --demo --query "machine learning model" --num-docs 500 --iterations 3 --batch-size 100
+
+echo ""
+echo "Batch size 250:"
+./target/release/benchmark --demo --query "machine learning model" --num-docs 500 --iterations 3 --batch-size 250
+
+echo ""
+echo "=== FILE TYPE ANALYSIS ==="
+echo ""
+
+echo "Only Rust files:"
+./target/release/benchmark --demo --query "struct impl trait" --num-docs 200 --iterations 5 --batch-size 40 --extensions rs
+
+echo ""
+echo "Only JavaScript/TypeScript files:"
+./target/release/benchmark --demo --query "async function promise" --num-docs 200 --iterations 5 --batch-size 40 --extensions js --extensions ts
+
+echo ""
+echo "Multiple file types:"
+./target/release/benchmark --demo --query "algorithm optimization" --num-docs 200 --iterations 5 --batch-size 40 --extensions rs --extensions js --extensions ts --extensions go --extensions py --extensions java
+
+echo ""
+echo "=============================================="
+echo "✅ COMPREHENSIVE BENCHMARK COMPLETE"
+echo "=============================================="

package/data/probe/examples/reranker/rust_bert_test/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "rust-bert-reranker-test"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+rust-bert = "0.21"
+anyhow = "1.0"
+tokio = { version = "1.0", features = ["full"] }
+
+# For downloading model files
+tch = "0.13.0"

package/data/probe/examples/reranker/rust_bert_test/README.md

@@ -0,0 +1,54 @@
+# Rust-BERT Cross-Encoder Test
+
+This example tests cross-encoder functionality using rust-bert to compare with our Candle implementation.
+
+## Setup
+
+1. Install libtorch (required by rust-bert):
+   - macOS: `brew install pytorch`
+   - Linux: Download from https://pytorch.org/get-started/locally/
+
+2. Set environment variables:
+   ```bash
+   export LIBTORCH=/usr/local/opt/pytorch  # macOS with Homebrew
+   # or
+   export LIBTORCH=/path/to/libtorch       # Linux/custom installation
+   ```
+
+3. Build and run:
+   ```bash
+   cargo run --release
+   ```
+
+## Model Conversion
+
+To use the TinyBERT model with rust-bert, you need to convert it to the .ot format:
+
+```python
+# convert_model.py
+import torch
+from transformers import AutoModelForSequenceClassification
+
+model = AutoModelForSequenceClassification.from_pretrained('cross-encoder/ms-marco-TinyBERT-L-2-v2')
+traced = torch.jit.trace(model, (torch.zeros(1, 512, dtype=torch.long),))
+traced.save("rust_model.ot")
+```
+
+## Notes
+
+- rust-bert expects models in TorchScript format (.ot files)
+- The sequence classification pipeline is designed for classification, not regression
+- For true cross-encoder scoring, you may need to modify the pipeline
+- This example demonstrates the approach but may not give identical results to Python
+
+## Comparison with Candle
+
+Our Candle implementation:
+- Loads PyTorch .bin files directly
+- Implements cross-encoder architecture manually
+- Returns raw logits for scoring
+
+rust-bert approach:
+- Uses TorchScript format
+- Provides high-level pipelines
+- Returns classification labels with confidence scores