new app

app.py

@@ -0,0 +1,256 @@
+import gradio as gr
+import requests
+import numpy as np
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+import logging
+import os
+from collections import defaultdict
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+NEURONPEDIA_API_URL = "https://www.neuronpedia.org/api"
+
+
+@dataclass
+class FeatureResult:
+    """Structure to hold feature analysis results"""
+
+    feature_id: int
+    layer: str
+    name: str
+    description: str
+    activation_score: float
+    max_activation: float
+    category: str
+    interpretation: str
+
+
+class MarketingAnalyzer:
+    def __init__(self, api_key: str = None):
+        """Initialize the analyzer with API credentials"""
+        self.api_key = api_key or os.getenv("NEURONPEDIA_API_KEY")
+        if not self.api_key:
+            raise ValueError("Neuronpedia API key is required")
+
+        self.headers = {"Content-Type": "application/json", "X-Api-Key": self.api_key}
+
+    def _search_features(
+        self, text: str, layer: str = "20-gemmascope-mlp-16k"
+    ) -> List[Dict]:
+        """Search for relevant features based on text content"""
+        url = f"{NEURONPEDIA_API_URL}/explanation/search"
+
+        payload = {"modelId": "gemma-2b", "layers": [layer], "query": text, "offset": 0}
+
+        try:
+            response = requests.post(url, headers=self.headers, json=payload)
+            response.raise_for_status()
+            return response.json().get("results", [])
+        except Exception as e:
+            logger.error(f"Error searching features: {str(e)}")
+            return []
+
+    def _get_activation_values(self, text: str, feature: Dict) -> Dict:
+        """Get activation values for specific text and feature"""
+        url = f"{NEURONPEDIA_API_URL}/activation/new"
+
+        payload = {
+            "feature": {
+                "modelId": "gemma-2b",
+                "layer": feature["layer"],
+                "index": int(feature["index"]),
+            },
+            "customText": text,
+        }
+
+        try:
+            response = requests.post(url, headers=self.headers, json=payload)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"Error getting activations: {str(e)}")
+            return None
+
+    def _interpret_activation(self, activation: float) -> str:
+        """Interpret activation level"""
+        if activation > 0.8:
+            return "Very strong match"
+        elif activation > 0.5:
+            return "Moderate match"
+        return "Limited match"
+
+    def analyze_content(self, text: str) -> Dict:
+        """Analyze content using Neuronpedia APIs"""
+        results = {
+            "text": text,
+            "features": {},
+            "categories": defaultdict(list),
+            "recommendations": [],
+        }
+
+        try:
+            # Search for relevant features
+            features = self._search_features(text)
+
+            # Analyze top features
+            for feature in features[:5]:  # Analyze top 5 features
+                feature_id = int(feature["index"])
+
+                # Get activation values
+                activation_data = self._get_activation_values(text, feature)
+                if not activation_data:
+                    continue
+
+                # Get maximum activation
+                max_activation = activation_data.get("activations", {}).get(
+                    "maxValue", 0
+                )
+                mean_activation = np.mean(
+                    activation_data.get("activations", {}).get("values", [0])
+                )
+
+                # Create feature result
+                feature_result = FeatureResult(
+                    feature_id=feature_id,
+                    layer=feature["layer"],
+                    name=feature.get("description", f"Feature {feature_id}"),
+                    description=feature.get("description", ""),
+                    activation_score=mean_activation,
+                    max_activation=max_activation,
+                    category=self._categorize_feature(feature),
+                    interpretation=self._interpret_activation(max_activation),
+                )
+
+                results["features"][feature_id] = feature_result
+                results["categories"][feature_result.category].append(feature_result)
+
+            # Generate recommendations
+            if results["features"]:
+                max_activation = max(
+                    f.max_activation for f in results["features"].values()
+                )
+                if max_activation > 0.8:
+                    results["recommendations"].append(
+                        "Content shows strong alignment with marketing-relevant features. Consider emphasizing these elements."
+                    )
+                elif max_activation < 0.3:
+                    results["recommendations"].append(
+                        "Content could benefit from more distinctive marketing elements."
+                    )
+
+        except Exception as e:
+            logger.error(f"Error analyzing content: {str(e)}")
+            results["error"] = str(e)
+
+        return results
+
+    def _categorize_feature(self, feature: Dict) -> str:
+        """Categorize feature based on description and patterns"""
+        description = feature.get("description", "").lower()
+
+        categories = {
+            "marketing": ["brand", "product", "market", "customer"],
+            "technical": ["technical", "technology", "software"],
+            "emotional": ["emotion", "feeling", "sentiment"],
+            "seo": ["search", "keyword", "ranking"],
+        }
+
+        for category, keywords in categories.items():
+            if any(keyword in description for keyword in keywords):
+                return category
+
+        return "general"
+
+
+def create_gradio_interface():
+    analyzer = MarketingAnalyzer()
+
+    def analyze(text):
+        results = analyzer.analyze_content(text)
+
+        output = "# Content Analysis Results\n\n"
+
+        # Category scores
+        output += "## Category Scores\n"
+        for category, features in results["categories"].items():
+            if features:
+                avg_score = np.mean([f.activation_score for f in features])
+                output += f"**{category.title()}**: {avg_score:.2f}\n"
+
+        # Feature details
+        output += "\n## Feature Details\n"
+        for feature_id, feature in results["features"].items():
+            output += f"\n### {feature.name}\n"
+            output += f"**Score**: {feature.activation_score:.2f}\n"
+            output += f"**Max Activation**: {feature.max_activation:.2f}\n"
+            output += f"**Interpretation**: {feature.interpretation}\n"
+            if feature.description:
+                output += f"**Description**: {feature.description}\n"
+            output += f"[View on Neuronpedia](https://neuronpedia.org/gemma-2b/{feature.layer}/{feature_id})\n"
+
+        # Recommendations
+        if results.get("recommendations"):
+            output += "\n## Recommendations\n"
+            for rec in results["recommendations"]:
+                output += f"- {rec}\n"
+
+        # Get dashboard URL for highest activating feature
+        if results["features"]:
+            feature_id = max(
+                results["features"].items(), key=lambda x: x[1].activation_score
+            )[0]
+            feature = results["features"][feature_id]
+            dashboard_url = f"https://neuronpedia.org/gemma-2b/{feature.layer}/{feature_id}?embed=true&embedexplanation=true&embedplots=true&embedtest=true&height=300"
+        else:
+            dashboard_url = ""
+            feature_id = None
+
+        return (
+            output,
+            dashboard_url,
+            f"Currently viewing Feature {feature_id}" if feature_id else "",
+        )
+
+    # Create Gradio interface
+    with gr.Blocks(theme=gr.themes.Default()) as interface:
+        gr.Markdown("# Marketing Content Analyzer")
+        gr.Markdown("Analyze your marketing content using neural features")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_text = gr.Textbox(
+                    lines=5,
+                    placeholder="Enter your marketing content here...",
+                    label="Marketing Content",
+                )
+                analyze_btn = gr.Button("Analyze", variant="primary")
+                gr.Examples(
+                    examples=[
+                        "Our AI-powered solution revolutionizes workflow efficiency",
+                        "Experience seamless integration with our platform",
+                        "Transform your business with cutting-edge technology",
+                    ],
+                    inputs=input_text,
+                )
+
+            with gr.Column(scale=2):
+                output_text = gr.Markdown(label="Analysis Results")
+                with gr.Group():
+                    gr.Markdown("## Feature Dashboard")
+                    feature_id_text = gr.Text(show_label=False)
+                    dashboard_frame = gr.HTML(label="Feature Dashboard")
+
+        analyze_btn.click(
+            fn=analyze,
+            inputs=input_text,
+            outputs=[output_text, dashboard_frame, feature_id_text],
+        )
+
+    return interface
+
+
+if __name__ == "__main__":
+    iface = create_gradio_interface()
+    iface.launch()