Clean API: Remove emojis, add colleague integration guide

API_KEYS_FOR_COLLEAGUE.md

@@ -0,0 +1,280 @@
+# A/B Test Predictor API - Integration Guide for Backend
+
+## API Endpoint
+```
+https://nitish-spz-abtestpredictorv2.hf.space
+```
+
+## Available Endpoints
+
+### 1. Auto-Categorization Prediction
+**Endpoint:** `/call/predict_with_auto_categorization`
+**Method:** POST
+**Description:** Automatically categorizes images and predicts A/B test winner
+
+**Request Format:**
+```json
+{
+  "data": [
+    {
+      "path": "uploaded_control_image_path",
+      "url": "https://nitish-spz-abtestpredictorv2.hf.space/file=uploaded_control_image_path",
+      "orig_name": "control.jpg",
+      "size": 123456,
+      "mime_type": "image/jpeg",
+      "meta": { "_type": "gradio.FileData" }
+    },
+    {
+      "path": "uploaded_variant_image_path", 
+      "url": "https://nitish-spz-abtestpredictorv2.hf.space/file=uploaded_variant_image_path",
+      "orig_name": "variant.jpg",
+      "size": 789012,
+      "mime_type": "image/jpeg",
+      "meta": { "_type": "gradio.FileData" }
+    }
+  ]
+}
+```
+
+**Response Format:**
+```json
+{
+  "prediction_results": {
+    "winner": "CONTROL WINS",
+    "probability": "0.041",
+    "model_confidence": "75.5%",
+    "training_data_samples": 477,
+    "historical_accuracy": "40/53 correct",
+    "win_loss_ratio": "24 wins in 53 tests"
+  },
+  "auto_detected_categories": {
+    "business_model": "SaaS",
+    "customer_type": "B2B", 
+    "conversion_type": "High-Intent Lead Gen",
+    "industry": "B2B Software & Tech",
+    "page_type": "Conversion"
+  },
+  "detected_pattern": {
+    "pattern": "Double Column Form",
+    "description": "The variant implements a 'Double Column Form' modification"
+  },
+  "processing_info": {
+    "total_processing_time": "32.36s",
+    "ai_categorization": "Perplexity Sonar Reasoning Pro",
+    "pattern_detection": "Gemini Pro Vision", 
+    "confidence_source": "B2B Software & Tech | Conversion",
+    "total_patterns_analyzed": 359
+  }
+}
+```
+
+### 2. Manual Categorization Prediction
+**Endpoint:** `/call/predict_single`
+**Method:** POST
+**Description:** Predicts A/B test winner with manually provided categories
+
+**Request Format:**
+```json
+{
+  "data": [
+    {
+      "path": "uploaded_control_image_path",
+      "url": "https://nitish-spz-abtestpredictorv2.hf.space/file=uploaded_control_image_path",
+      "orig_name": "control.jpg",
+      "size": 123456,
+      "mime_type": "image/jpeg",
+      "meta": { "_type": "gradio.FileData" }
+    },
+    {
+      "path": "uploaded_variant_image_path",
+      "url": "https://nitish-spz-abtestpredictorv2.hf.space/file=uploaded_variant_image_path", 
+      "orig_name": "variant.jpg",
+      "size": 789012,
+      "mime_type": "image/jpeg",
+      "meta": { "_type": "gradio.FileData" }
+    },
+    "E-Commerce",
+    "B2C", 
+    "Direct Purchase",
+    "Retail & E-commerce",
+    "Conversion"
+  ]
+}
+```
+
+**Response Format:**
+```json
+{
+  "winner": "VARIANT WINS",
+  "probability": "0.987",
+  "model_confidence": "82.3%",
+  "training_data_samples": 1205,
+  "historical_accuracy": "98/120 correct",
+  "win_loss_ratio": "67 wins in 120 tests"
+}
+```
+
+## File Upload Process
+
+### Step 1: Upload Images
+**Endpoint:** `/upload`
+**Method:** POST
+**Content-Type:** multipart/form-data
+
+```python
+import requests
+
+# Upload control image
+with open('control.jpg', 'rb') as f:
+    files = {'files': f}
+    response = requests.post('https://nitish-spz-abtestpredictorv2.hf.space/upload', files=files)
+    control_path = response.json()[0]
+
+# Upload variant image  
+with open('variant.jpg', 'rb') as f:
+    files = {'files': f}
+    response = requests.post('https://nitish-spz-abtestpredictorv2.hf.space/upload', files=files)
+    variant_path = response.json()[0]
+```
+
+### Step 2: Make Prediction Request
+```python
+import requests
+
+# Prepare FileData objects
+control_file_data = {
+    "path": control_path,
+    "url": f"https://nitish-spz-abtestpredictorv2.hf.space/file={control_path}",
+    "orig_name": "control.jpg",
+    "size": 123456,
+    "mime_type": "image/jpeg",
+    "meta": { "_type": "gradio.FileData" }
+}
+
+variant_file_data = {
+    "path": variant_path,
+    "url": f"https://nitish-spz-abtestpredictorv2.hf.space/file={variant_path}",
+    "orig_name": "variant.jpg", 
+    "size": 789012,
+    "mime_type": "image/jpeg",
+    "meta": { "_type": "gradio.FileData" }
+}
+
+# Make prediction request
+response = requests.post(
+    'https://nitish-spz-abtestpredictorv2.hf.space/call/predict_with_auto_categorization',
+    json={"data": [control_file_data, variant_file_data]}
+)
+
+result = response.json()
+```
+
+## Response Field Descriptions
+
+### Prediction Results
+- **winner**: "CONTROL WINS" or "VARIANT WINS"
+- **probability**: Float between 0-1 (probability of variant winning)
+- **model_confidence**: Percentage confidence based on historical data
+- **training_data_samples**: Number of training samples used for confidence
+- **historical_accuracy**: Accuracy of predictions on similar data
+- **win_loss_ratio**: Historical performance on similar tests
+
+### Auto-Detected Categories
+- **business_model**: "E-Commerce", "SaaS", "Lead Generation", "Other*"
+- **customer_type**: "B2B", "B2C", "Both", "Other*"
+- **conversion_type**: "Direct Purchase", "High-Intent Lead Gen", "Info/Content Lead Gen", "Location Search", "Non-Profit/Community", "Other Conversion"
+- **industry**: 14 categories including "B2B Software & Tech", "Retail & E-commerce", etc.
+- **page_type**: "Awareness & Discovery", "Consideration & Evaluation", "Conversion", "Internal & Navigation", "Post-Conversion & Other"
+
+### Detected Pattern
+- **pattern**: A/B test pattern name (e.g., "Button", "Form Over UI", "Hero Changes")
+- **description**: Human-readable description of the pattern
+
+### Processing Info
+- **total_processing_time**: Time taken for prediction (typically 20-40 seconds)
+- **ai_categorization**: AI service used for categorization
+- **pattern_detection**: AI service used for pattern detection
+- **confidence_source**: Data source for confidence scores
+- **total_patterns_analyzed**: Number of patterns in the detection database
+
+## Error Handling
+
+### Common Error Responses
+```json
+{
+  "error": "Prediction failed: [error message]",
+  "model_confidence": "50.0%",
+  "training_data_samples": 0,
+  "historical_accuracy": "0/0 correct", 
+  "win_loss_ratio": "0 wins in 0 tests"
+}
+```
+
+### HTTP Status Codes
+- **200**: Success
+- **400**: Bad request (invalid parameters)
+- **500**: Internal server error
+- **503**: Service unavailable (GPU quota exceeded)
+
+## Rate Limits
+- Free tier: Limited concurrent requests
+- Processing time: 20-40 seconds per prediction
+- GPU duration: 50-60 seconds maximum
+
+## Example Integration (Python)
+
+```python
+import requests
+import time
+
+class ABTestPredictor:
+    def __init__(self):
+        self.base_url = "https://nitish-spz-abtestpredictorv2.hf.space"
+    
+    def predict(self, control_image_path, variant_image_path):
+        # Step 1: Upload images
+        control_path = self._upload_image(control_image_path)
+        variant_path = self._upload_image(variant_image_path)
+        
+        # Step 2: Make prediction
+        return self._make_prediction(control_path, variant_path)
+    
+    def _upload_image(self, image_path):
+        with open(image_path, 'rb') as f:
+            files = {'files': f}
+            response = requests.post(f"{self.base_url}/upload", files=files)
+            return response.json()[0]
+    
+    def _make_prediction(self, control_path, variant_path):
+        control_data = self._create_file_data(control_path, "control.jpg")
+        variant_data = self._create_file_data(variant_path, "variant.jpg")
+        
+        response = requests.post(
+            f"{self.base_url}/call/predict_with_auto_categorization",
+            json={"data": [control_data, variant_data]}
+        )
+        
+        return response.json()
+    
+    def _create_file_data(self, path, orig_name):
+        return {
+            "path": path,
+            "url": f"{self.base_url}/file={path}",
+            "orig_name": orig_name,
+            "size": 0,  # Optional
+            "mime_type": "image/jpeg",
+            "meta": { "_type": "gradio.FileData" }
+        }
+
+# Usage
+predictor = ABTestPredictor()
+result = predictor.predict("control.jpg", "variant.jpg")
+print(f"Winner: {result['prediction_results']['winner']}")
+print(f"Probability: {result['prediction_results']['probability']}")
+```
+
+## Notes
+- Images are automatically deleted after processing
+- Maximum image size: 10MB
+- Supported formats: JPEG, PNG, WebP
+- Processing time varies based on image complexity and server load

app.py

@@ -848,24 +848,24 @@ def predict_with_auto_categorization(control_image, variant_image):
     
     # Create comprehensive result with prediction, categorization, and pattern detection
     enhanced_result = {
-        "🎯 Prediction Results": prediction_result,
-        "🤖 Auto-Detected Categories": {
-            "Business Model": business_model,
-            "Customer Type": customer_type,
-            "Conversion Type": conversion_type,
-            "Industry": industry,
-            "Page Type": page_type
+        "prediction_results": prediction_result,
+        "auto_detected_categories": {
+            "business_model": business_model,
+            "customer_type": customer_type,
+            "conversion_type": conversion_type,
+            "industry": industry,
+            "page_type": page_type
         },
-        "🎯 Detected A/B Test Pattern": {
-            "Pattern": detected_pattern,
-            "Description": f"The variant implements a '{detected_pattern}' modification"
+        "detected_pattern": {
+            "pattern": detected_pattern,
+            "description": f"The variant implements a '{detected_pattern}' modification"
         },
-        "📊 Processing Info": {
-            "Total Processing Time": f"{time.time() - start_time:.2f}s",
-            "AI Categorization": "✅ Perplexity Sonar Reasoning Pro" if PERPLEXITY_API_KEY else "⚠️ Fallback Mode",
-            "Pattern Detection": "✅ Gemini Pro Vision" if GEMINI_API_KEY else "⚠️ Fallback Mode",
-            "Confidence Source": f"{industry} | {page_type}",
-            "Total Patterns Analyzed": len(pattern_descriptions) if pattern_descriptions else 0
+        "processing_info": {
+            "total_processing_time": f"{time.time() - start_time:.2f}s",
+            "ai_categorization": "Perplexity Sonar Reasoning Pro" if PERPLEXITY_API_KEY else "Fallback Mode",
+            "pattern_detection": "Gemini Pro Vision" if GEMINI_API_KEY else "Fallback Mode",
+            "confidence_source": f"{industry} | {page_type}",
+            "total_patterns_analyzed": len(pattern_descriptions) if pattern_descriptions else 0
         }
     }
     
@@ -934,11 +934,12 @@ def predict_single(control_image, variant_image, business_model, customer_type,
         
         # Create enhanced output with confidence scores and training data info
         result = {
-            f"{winner}": f"{probability:.3f}",
-            f"Model Confidence": f"{confidence_percentage:.1f}%",
-            f"Training Data": f"{confidence_data['training_data_count']} samples",
-            f"Historical Accuracy": f"{confidence_data['correct_predictions']}/{confidence_data['count']} correct",
-            f"Win/Loss Ratio": f"{confidence_data['actual_wins']} wins in {confidence_data['count']} tests"
+            "winner": winner,
+            "probability": f"{probability:.3f}",
+            "model_confidence": f"{confidence_percentage:.1f}%",
+            "training_data_samples": confidence_data['training_data_count'],
+            "historical_accuracy": f"{confidence_data['correct_predictions']}/{confidence_data['count']} correct",
+            "win_loss_ratio": f"{confidence_data['actual_wins']} wins in {confidence_data['count']} tests"
         }
         
         print(f"🎯 Final result: {result}")
@@ -952,11 +953,11 @@ def predict_single(control_image, variant_image, business_model, customer_type,
         
         # Return error result with fallback confidence data
         return {
-            "❌ Error": f"Prediction failed: {str(e)}",
-            f"📊 Model Confidence": "50.0%",
-            f"📈 Training Data": "0 samples",
-            f"✅ Historical Accuracy": "0/0 correct",
-            f"🎯 Win/Loss Ratio": "0 wins in 0 tests"
+            "error": f"Prediction failed: {str(e)}",
+            "model_confidence": "50.0%",
+            "training_data_samples": 0,
+            "historical_accuracy": "0/0 correct",
+            "win_loss_ratio": "0 wins in 0 tests"
         }
 
 @spaces.GPU