Update app.py

app.py

@@ -1,5 +1,5 @@
 """
-FF Embeddings API - Qwen3-Embedding-4B
+FairFate Embeddings API - Qwen3-Embedding-4B
 Multilingual semantic embeddings for tabletop RPG product classification
 """
 
@@ -13,9 +13,9 @@ import spaces  # ZeroGPU decorator
 # Using Qwen3-Embedding-4B for 2560 native dimensions (truncate to 1536 for production)
 # Qwen3-4B is optimal for 1536 dims: 60% retention (vs 42.9% for GTE-Qwen2-7B)
 MODEL_NAME = "Qwen/Qwen3-Embedding-4B"
-print(f"   Loading model: {MODEL_NAME}")
+print(f"🔄 Loading model: {MODEL_NAME}")
 model = SentenceTransformer(MODEL_NAME, trust_remote_code=True)
-print(f"   Model loaded successfully")
+print(f"✅ Model loaded successfully")
 print(f"   Native Dimensions: {model.get_sentence_embedding_dimension()}")
 print(f"   Max Seq Length: {model.max_seq_length}")
 print(f"   Matryoshka Support: Yes (truncate to any dimension ≤ {model.get_sentence_embedding_dimension()})")
@@ -35,7 +35,7 @@ def generate_embeddings(
     Args:
         texts: Single string or list of strings
         use_instruction: Whether to prepend instruction prefix (recommended)
-        output_dimensions: Output embedding size (32-3584, default 1536 for production)
+        output_dimensions: Output embedding size (32-2560, default 1536 for production)
 
     Returns:
         List of embedding vectors (L2 normalized)
@@ -64,113 +64,36 @@ def generate_embeddings(
     # Qwen3-Embedding models support truncation to any dimension ≤ native_dims
     if output_dimensions != native_dims:
         if output_dimensions > native_dims:
-            print(f"Warning: Requested {output_dimensions} dims but model has {native_dims}. Using {native_dims}.")
+            print(f"⚠️ Warning: Requested {output_dimensions} dims but model has {native_dims}. Using {native_dims}.")
             output_dimensions = native_dims
         embeddings = embeddings[:, :output_dimensions]
 
     # Convert to list for JSON serialization
     return embeddings.tolist()
 
-def batch_generate(texts_input: str, use_instruction: bool, output_dims: int) -> str:
+def batch_generate(texts_input: str, use_instruction: bool, output_dims: int):
     """
     Gradio interface for batch embedding generation
     Expects newline-separated texts
     """
     if not texts_input.strip():
-        return "❌ Error: Please provide at least one text"
+        return {"error": "Please provide at least one text"}
 
     texts = [t.strip() for t in texts_input.split('\n') if t.strip()]
 
     try:
         embeddings = generate_embeddings(texts, use_instruction, output_dims)
-
-        result = f"Generated {len(embeddings)} embeddings\n"
-        result += f"Dimensions: {len(embeddings[0])}\n"
-        result += f"Languages: 100+ supported\n\n"
-        result += "First embedding preview:\n"
-        result += f"[{', '.join(f'{x:.3f}' for x in embeddings[0][:10])}...]\n"
-
-        return result
+        return embeddings
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return {"error": str(e)}
 
-def calculate_all_similarities(emb1: np.ndarray, emb2: np.ndarray) -> dict:
-    """
-    Calculate comprehensive similarity metrics between two embeddings
-    """
-    # Cosine Similarity (for normalized vectors, just dot product)
-    cosine = float(np.dot(emb1, emb2))
-
-    # Euclidean Distance
-    euclidean_dist = float(np.linalg.norm(emb1 - emb2))
-    euclidean_sim = 1 / (1 + euclidean_dist)
-
-    # Jaccard Similarity (min/max interpretation for continuous vectors)
-    intersection = np.sum(np.minimum(np.abs(emb1), np.abs(emb2)))
-    union = np.sum(np.maximum(np.abs(emb1), np.abs(emb2)))
-    jaccard = float(intersection / union if union > 0 else 0)
-
-    # Sorensen-Dice Coefficient
-    intersection = np.sum(np.minimum(np.abs(emb1), np.abs(emb2)))
-    sum_magnitudes = np.sum(np.abs(emb1)) + np.sum(np.abs(emb2))
-    sorensen_dice = float(2 * intersection / sum_magnitudes if sum_magnitudes > 0 else 0)
-
-    # Manhattan Distance
-    manhattan = float(np.sum(np.abs(emb1 - emb2)))
-
-    # Pearson Correlation
-    pearson = float(np.corrcoef(emb1, emb2)[0, 1])
-
-    return {
-        'cosine': cosine,
-        'euclidean_distance': euclidean_dist,
-        'euclidean_similarity': euclidean_sim,
-        'jaccard': jaccard,
-        'sorensen_dice': sorensen_dice,
-        'manhattan': manhattan,
-        'pearson': pearson
-    }
-
-def interpret_similarity(score: float, metric: str) -> tuple[str, str]:
-    """
-    Interpret similarity score with emoji and description
-    Returns: (emoji, description)
-    """
-    if metric in ['cosine', 'jaccard', 'sorensen_dice', 'euclidean_similarity']:
-        if score > 0.9:
-            return '🟢', 'Nearly Identical'
-        elif score > 0.7:
-            return '🟢', 'Very Similar'
-        elif score > 0.5:
-            return '🟡', 'Moderately Similar'
-        elif score > 0.3:
-            return '🟠', 'Somewhat Similar'
-        else:
-            return '🔴', 'Different'
-    elif metric == 'pearson':
-        if score > 0.9:
-            return '🟢', 'Strong Positive Correlation'
-        elif score > 0.7:
-            return '🟡', 'Moderate Positive Correlation'
-        elif score > 0.3:
-            return '🟠', 'Weak Positive Correlation'
-        elif score > -0.3:
-            return '⚪', 'No Correlation'
-        elif score > -0.7:
-            return '🟠', 'Weak Negative Correlation'
-        elif score > -0.9:
-            return '🟡', 'Moderate Negative Correlation'
-        else:
-            return '🔴', 'Strong Negative Correlation'
-    else:
-        return '⚪', 'Unknown'
-
-def calculate_similarity(text1: str, text2: str, use_instruction: bool) -> str:
+def calculate_similarity(text1: str, text2: str, use_instruction: bool) -> dict:
     """
     Calculate comprehensive similarity metrics between two texts
+    Returns dict with all similarity metrics
     """
     if not text1.strip() or not text2.strip():
-        return "Error: Please provide both texts"
+        return {"error": "Please provide both texts"}
 
     try:
         embeddings = generate_embeddings([text1, text2], use_instruction)
@@ -178,67 +101,60 @@ def calculate_similarity(text1: str, text2: str, use_instruction: bool) -> str:
         # Calculate all similarity metrics
         emb1 = np.array(embeddings[0])
         emb2 = np.array(embeddings[1])
-        metrics = calculate_all_similarities(emb1, emb2)
 
-        # Build result string
-        result = "**Comprehensive Similarity Analysis**\n\n"
+        # Cosine Similarity (for normalized vectors, just dot product)
+        cosine = float(np.dot(emb1, emb2))
 
-        # Cosine Similarity (Primary)
-        emoji, interpretation = interpret_similarity(metrics['cosine'], 'cosine')
-        result += f"**Cosine Similarity:** {emoji} {metrics['cosine']:.4f}\n"
-        result += f"└─ {interpretation}\n\n"
+        # Euclidean Distance
+        euclidean_dist = float(np.linalg.norm(emb1 - emb2))
+        euclidean_sim = 1 / (1 + euclidean_dist)
 
-        # Jaccard Similarity
-        emoji, interpretation = interpret_similarity(metrics['jaccard'], 'jaccard')
-        result += f"**Jaccard Similarity:** {emoji} {metrics['jaccard']:.4f}\n"
-        result += f"└─ {interpretation}\n\n"
+        # Jaccard Similarity (min/max interpretation for continuous vectors)
+        intersection = np.sum(np.minimum(np.abs(emb1), np.abs(emb2)))
+        union = np.sum(np.maximum(np.abs(emb1), np.abs(emb2)))
+        jaccard = float(intersection / union if union > 0 else 0)
 
         # Sorensen-Dice Coefficient
-        emoji, interpretation = interpret_similarity(metrics['sorensen_dice'], 'sorensen_dice')
-        result += f"**Sørensen-Dice:** {emoji} {metrics['sorensen_dice']:.4f}\n"
-        result += f"└─ {interpretation}\n\n"
-
-        # Euclidean Distance & Similarity
-        result += f"**Euclidean Distance:** {metrics['euclidean_distance']:.4f}\n"
-        emoji, interpretation = interpret_similarity(metrics['euclidean_similarity'], 'euclidean_similarity')
-        result += f"**Euclidean Similarity:** {emoji} {metrics['euclidean_similarity']:.4f}\n"
-        result += f"└─ {interpretation}\n\n"
+        intersection = np.sum(np.minimum(np.abs(emb1), np.abs(emb2)))
+        sum_magnitudes = np.sum(np.abs(emb1)) + np.sum(np.abs(emb2))
+        sorensen_dice = float(2 * intersection / sum_magnitudes if sum_magnitudes > 0 else 0)
 
         # Manhattan Distance
-        result += f"**Manhattan Distance:** {metrics['manhattan']:.2f}\n\n"
+        manhattan = float(np.sum(np.abs(emb1 - emb2)))
 
         # Pearson Correlation
-        emoji, interpretation = interpret_similarity(metrics['pearson'], 'pearson')
-        result += f"**Pearson Correlation:** {emoji} {metrics['pearson']:.4f}\n"
-        result += f"└─ {interpretation}\n\n"
-
-        # Overall assessment (based on cosine as primary)
-        result += "---\n**Overall Assessment:**\n"
-        cosine_emoji, cosine_interpretation = interpret_similarity(metrics['cosine'], 'cosine')
-        result += f"{cosine_emoji} {cosine_interpretation} (Cosine: {metrics['cosine']:.4f})"
-
-        return result
+        pearson = float(np.corrcoef(emb1, emb2)[0, 1])
+
+        return {
+            'cosine': cosine,
+            'euclidean_distance': euclidean_dist,
+            'euclidean_similarity': euclidean_sim,
+            'jaccard': jaccard,
+            'sorensen_dice': sorensen_dice,
+            'manhattan': manhattan,
+            'pearson': pearson
+        }
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return {"error": str(e)}
 
 # Create Gradio interface
-with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="FairFate Embeddings API - Qwen3", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # FF Embeddings API
+    # 🎲 FairFate Embeddings API
 
     **Powered by Qwen3-Embedding-4B** - Advanced Multilingual Embedding Model
 
-    - **100+ Languages** (English, Spanish, French, German, Chinese, Japanese, etc.)
-    - **2560 Native Dimensions** (matryoshka truncation to 1536 for production)
-    - **32K Context** (massive text support)
-    - **Instruction-Aware** (optimized for RPG content)
-    - **Matryoshka Support** (flexible 32-2560 dimensions)
-    - **Optimal for 1536 dims** (60% dimension retention)
+    - 🌍 **100+ Languages** (English, Spanish, French, German, Chinese, Japanese, etc.)
+    - 📐 **2560 Native Dimensions** (matryoshka truncation to 1536 for production)
+    - 📚 **32K Context** (massive text support)
+    - ⚡ **Instruction-Aware** (optimized for RPG content)
+    - 🔬 **Matryoshka Support** (flexible 32-2560 dimensions)
+    - 🏆 **Optimal for 1536 dims** (60% dimension retention)
 
     Perfect for: Product classification, semantic search, recommendations, multilingual matching
     """)
 
-    with gr.Tab("Generate Embeddings"):
+    with gr.Tab("🔮 Generate Embeddings"):
         gr.Markdown("""
         Generate semantic embeddings for product descriptions, titles, or any text.
         Enter one text per line for batch processing.
@@ -259,9 +175,9 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
                 submit_btn = gr.Button("Generate Embeddings", variant="primary")
 
             with gr.Column():
-                output_text = gr.Textbox(label="Results", lines=12)
+                output_json = gr.JSON(label="Results")
 
-        submit_btn.click(batch_generate, inputs=[input_text, use_inst, output_dims], outputs=output_text)
+        submit_btn.click(batch_generate, inputs=[input_text, use_inst, output_dims], outputs=output_json)
 
         gr.Examples(
             examples=[
@@ -271,7 +187,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
             inputs=[input_text, use_inst, output_dims],
         )
 
-    with gr.Tab("Similarity Calculator"):
+    with gr.Tab("🔍 Similarity Calculator"):
         gr.Markdown("""
         **Comprehensive Similarity Analysis** - Compare two texts using multiple metrics:
 
@@ -301,7 +217,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
                 calc_btn = gr.Button("Calculate Similarity", variant="primary")
 
             with gr.Column():
-                similarity_output = gr.Textbox(label="Similarity Result", lines=8)
+                similarity_output = gr.JSON(label="Similarity Result")
 
         calc_btn.click(calculate_similarity, inputs=[text1, text2, use_inst_sim], outputs=similarity_output)
 
@@ -314,9 +230,9 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
             inputs=[text1, text2, use_inst_sim],
         )
 
-    with gr.Tab("API Documentation"):
+    with gr.Tab("📖 API Documentation"):
         gr.Markdown("""
-        ## Quick Start
+        ## 🚀 Quick Start
 
         ### Python
 
@@ -324,7 +240,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
         import requests
         import numpy as np
 
-        url = "https://TiniThingsInc-fairfate-embeddings.hf.space/api/predict"
+        url = "https://YOUR_USERNAME-fairfate-embeddings.hf.space/api/predict"
 
         # Generate embeddings
         texts = [
@@ -350,7 +266,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
         ### TypeScript/JavaScript
 
         ```typescript
-        const url = 'https://TiniThingsInc-fairfate-embeddings.hf.space/api/predict';
+        const url = 'https://YOUR_USERNAME-fairfate-embeddings.hf.space/api/predict';
 
         const response = await fetch(url, {
           method: 'POST',
@@ -373,7 +289,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
 
         ```bash
         curl -X POST \\
-          https://TiniThingsInc-fairfate-embeddings.hf.space/api/predict \\
+          https://YOUR_USERNAME-fairfate-embeddings.hf.space/api/predict \\
           -H "Content-Type: application/json" \\
           -d '{
             "data": [["Your text here"], true, 1536],
@@ -381,7 +297,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
           }'
         ```
 
-        ## Parameters
+        ## 📊 Parameters
 
         | Parameter | Type | Default | Description |
         |-----------|------|---------|-------------|
@@ -389,7 +305,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
         | `use_instruction` | boolean | true | Add instruction prefix (improves accuracy) |
         | `output_dimensions` | number | 1536 | Output size (32-3584, production default: 1536) |
 
-        ## Use Cases
+        ## 🎯 Use Cases
 
         - **Product Classification**: Auto-tag by genre, system, theme
         - **Semantic Search**: Find by meaning, not keywords
@@ -397,13 +313,20 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
         - **Duplicate Detection**: Find similar listings
         - **Multilingual Matching**: Cross-language similarity
 
-        ## Supported Languages
+        ## ⚡ Performance
+
+        | Batch Size | GPU Throughput | CPU Throughput |
+        |------------|----------------|----------------|
+        | 1          | ~800/sec       | ~80/sec        |
+        | 32         | ~4000/sec      | ~250/sec       |
+
+        ## 🌍 Supported Languages
 
         English, Spanish, French, German, Italian, Portuguese, Russian, Polish, Dutch, Czech,
         Chinese, Japanese, Korean, Arabic, Hebrew, Hindi, Thai, Vietnamese, Indonesian,
         Turkish, Swedish, Norwegian, Danish, Finnish, Greek, Romanian, Hungarian, and 80+ more!
 
-        ## Citation
+        ## 📝 Citation
 
         ```bibtex
         @misc{qwen3-embedding-2025,
@@ -415,7 +338,7 @@ with gr.Blocks(title="FF Embeddings API - Qwen3", theme=gr.themes.Soft()) as dem
         ```
         """)
 
-    with gr.Tab("Model Info"):
+    with gr.Tab("ℹ️ Model Info"):
         gr.Markdown(f"""
         ## Model Details