Update app.py

app.py

@@ -1,191 +1,773 @@
 import gradio as gr
-from pathlib import Path
-from PIL import Image, ExifTags
-import json
-import os
-import logging
-import traceback
+import torch
+import torch.nn.functional as F
+from functools import lru_cache
 import folium
+from folium.plugins import HeatMap, MarkerCluster
+from typing import List, Dict, Tuple, Optional, Union, Any
+import numpy as np
+import matplotlib.pyplot as plt
 import io
-from typing import Dict, List, Any, Optional, Tuple, Union
+import base64
+from dataclasses import dataclass
+import logging
+import warnings
+from transformers import CLIPTokenizer
+from geoclip import GeoCLIP
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s"
+)
 logger = logging.getLogger(__name__)
 
-# Supported extensions
-SUPPORTED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.heic', '.tiff', '.bmp', '.webp'}
-
-def convert_to_degrees(value: tuple) -> Optional[float]:
-    """Convert GPS coordinates from DMS to decimal degrees."""
-    try:
-        d, m, s = value
-        return float(d) + (float(m) / 60.0) + (float(s) / 3600.0)
-    except Exception as e:
-        logger.error(f"GPS conversion error: {e}")
-        return None
-
-def extract_gps_info(gps_info: Dict[int, Any]) -> Optional[Dict[str, Any]]:
-    """Extract GPS data from EXIF."""
-    if not isinstance(gps_info, dict):
-        return None
-
-    gps_data = {}
-    try:
-        for key, val in gps_info.items():
-            tag_name = ExifTags.GPSTAGS.get(key, f"unknown_gps_tag_{key}")
-            gps_data[tag_name] = val
-
-        if 'GPSLatitude' in gps_data and 'GPSLongitude' in gps_data:
-            lat = convert_to_degrees(gps_data['GPSLatitude'])
-            lon = convert_to_degrees(gps_data['GPSLongitude'])
-            
-            if lat is None or lon is None:
-                return None
-
-            if gps_data.get('GPSLatitudeRef', 'N') == 'S':
-                lat = -lat
-            if gps_data.get('GPSLongitudeRef', 'E') == 'W':
-                lon = -lon
-
-            gps_data['Latitude'] = lat
-            gps_data['Longitude'] = lon
-
-        return gps_data
-    except Exception as e:
-        logger.error(f"GPS extraction error: {str(e)}")
-        return None
-
-def get_image_metadata(image_path: Path) -> Dict[str, Any]:
-    """Extract metadata from a single image."""
-    metadata = {"file_name": str(image_path.absolute())}
-    try:
-        with Image.open(image_path) as image:
-            metadata.update({
-                "format": image.format or "unknown",
-                "size": list(image.size)
-            })
-
-            exif_data = None
-            try:
-                exif_data = image._getexif()
-            except Exception:
-                metadata["exif_error"] = "No EXIF data available"
-
-            if exif_data and isinstance(exif_data, dict):
-                for tag_id, value in exif_data.items():
-                    try:
-                        tag_name = ExifTags.TAGS.get(tag_id, f"tag_{tag_id}").lower()
-                        if tag_name == "gpsinfo":
-                            gps_info = extract_gps_info(value)
-                            if gps_info:
-                                metadata["gps_info"] = gps_info
-                    except Exception:
-                        pass
-
-        return metadata
-    except Exception as e:
-        logger.error(f"Error processing {image_path}: {str(e)}")
-        return {"file_name": str(image_path.absolute()), "error": str(e)}
-
-def process_images(files) -> Tuple[str, List[Dict[str, Any]]]:
-    """Process uploaded image files."""
-    metadata_list = []
-    
-    try:
-        # Create temp directory for uploads
-        temp_dir = Path("./temp_uploads")
-        temp_dir.mkdir(exist_ok=True)
-        
-        # Save and process uploaded files
-        for file in files:
-            # Handle byte content from Gradio uploads
-            if hasattr(file, "name") and hasattr(file, "read"):
-                file_path = temp_dir / file.name
-                with open(file_path, "wb") as f:
-                    f.write(file.read())
-                
-                if file_path.suffix.lower() in SUPPORTED_EXTENSIONS:
-                    metadata = get_image_metadata(file_path)
-                    if metadata:
-                        metadata_list.append(metadata)
-        
-        if not metadata_list:
-            return "No valid images found", []
-            
-        # Count geotagged images
-        geotagged = sum(1 for m in metadata_list if "gps_info" in m)
-        
-        return f"Processed {len(metadata_list)} images ({geotagged} geotagged)", metadata_list
-        
-    except Exception as e:
-        logger.error(f"Error processing uploads: {traceback.format_exc()}")
-        return f"Error: {str(e)}", []
-
-def create_map(metadata_list: List[Dict[str, Any]]) -> str:
-    """Create a folium map with markers for geotagged images."""
-    try:
-        # Extract coordinates
-        coords = []
-        for entry in metadata_list:
-            gps_info = entry.get("gps_info", {})
-            if isinstance(gps_info, dict) and "Latitude" in gps_info and "Longitude" in gps_info:
-                coords.append((
-                    gps_info["Latitude"], 
-                    gps_info["Longitude"],
-                    os.path.basename(entry.get("file_name", "Unknown"))
+# Suppress transformer warnings
+warnings.filterwarnings("ignore", message="weights_only=False")
+
+@dataclass
+class LocationPrediction:
+    """Structured container for geographic predictions with confidence metrics."""
+    coordinates: Tuple[float, float]
+    confidence: float
+
+
+class GeoCLIPAnalyzer:
+    """High-performance GeoCLIP analyzer with cached operations and optimized tensor handling."""
+    
+    def __init__(self, cache_enabled: bool = True, cache_size: int = 128):
+        """
+        Initialize the analyzer with configurable caching.
+        
+        Args:
+            cache_enabled: Toggle for LRU caching mechanism
+            cache_size: Maximum cache entries per method
+        """
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"Initializing GeoCLIP on {self.device}")
+        
+        self.model = GeoCLIP().to(self.device)
+        self.tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
+        
+        # Apply LRU caching to high-compute methods
+        if cache_enabled:
+            self.predict_location = lru_cache(maxsize=cache_size)(self.predict_location)
+            self.analyze_temporal_variations = lru_cache(maxsize=cache_size)(self.analyze_temporal_variations)
+            self.find_related_locations = lru_cache(maxsize=cache_size)(self.find_related_locations)
+            logger.info(f"Method caching enabled with size {cache_size}")
+    
+    def predict_location(self, text: str, top_k: int = 5) -> List[LocationPrediction]:
+        """
+        Generate location predictions with confidence metrics for a text query.
+        
+        Args:
+            text: Descriptive location text query
+            top_k: Number of predictions to return
+            
+        Returns:
+            List of LocationPrediction objects sorted by confidence
+        """
+        with torch.no_grad():
+            # Generate text embeddings
+            text_inputs = self.tokenizer(text, return_tensors="pt", padding=True).to(self.device)
+            text_features = self.model.image_encoder.mlp(
+                self.model.image_encoder.CLIP.get_text_features(**text_inputs)
+            )
+            text_features = F.normalize(text_features, dim=1)
+            
+            # Retrieve and normalize location features
+            gps_gallery = self.model.gps_gallery.to(self.device)
+            location_features = self.model.location_encoder(gps_gallery)
+            location_features = F.normalize(location_features, dim=1)
+            
+            # Compute similarity and extract top predictions
+            similarity = self.model.logit_scale.exp() * (text_features @ location_features.T)
+            probs = similarity.softmax(dim=-1)
+            top_pred = torch.topk(probs[0], top_k)
+            
+            # Convert to Python native types for consistent serialization
+            predictions = []
+            for coord, conf in zip(
+                gps_gallery[top_pred.indices].cpu().numpy(),
+                top_pred.values.cpu().numpy()
+            ):
+                predictions.append(LocationPrediction(
+                    coordinates=(float(coord[0]), float(coord[1])),
+                    confidence=float(conf)
                 ))
+            
+            return predictions
+    
+    def create_location_map(
+        self, 
+        predictions: List[LocationPrediction], 
+        title: str, 
+        zoom: int = 5,
+        heatmap: bool = True,
+        cluster: bool = False
+    ) -> str:
+        """
+        Generate an interactive folium map visualization from location predictions.
         
-        if not coords:
-            return "No geotagged images found"
+        Args:
+            predictions: List of location predictions
+            title: Map title/description
+            zoom: Initial zoom level (higher = more zoomed in)
+            heatmap: Whether to add heatmap layer
+            cluster: Whether to cluster nearby markers
+            
+        Returns:
+            HTML string of rendered interactive map
+        """
+        # Calculate center from prediction distribution
+        center_lat = sum(p.coordinates[0] for p in predictions) / len(predictions)
+        center_lon = sum(p.coordinates[1] for p in predictions) / len(predictions)
         
-        # Calculate center
-        center_lat = sum(c[0] for c in coords) / len(coords)
-        center_lon = sum(c[1] for c in coords) / len(coords)
+        # Initialize map
+        m = folium.Map(location=[center_lat, center_lon], zoom_start=zoom)
         
-        # Create map
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=10)
+        # Add heatmap if requested
+        if heatmap and len(predictions) > 1:
+            heat_data = [
+                [pred.coordinates[0], pred.coordinates[1], pred.confidence]
+                for pred in predictions
+            ]
+            HeatMap(heat_data, radius=25, blur=15, min_opacity=0.4).add_to(m)
         
-        # Add markers
-        for lat, lon, name in coords:
+        # Add markers with clustering option
+        if cluster:
+            marker_cluster = MarkerCluster().add_to(m)
+            
+            for i, pred in enumerate(predictions):
+                popup_text = f"{title} #{i+1}<br>Coordinates: {pred.coordinates[0]:.6f}, {pred.coordinates[1]:.6f}<br>Confidence: {pred.confidence:.4f}"
+                
+                folium.Marker(
+                    location=pred.coordinates,
+                    popup=popup_text,
+                    icon=folium.Icon(color='red' if i == 0 else 'blue')
+                ).add_to(marker_cluster)
+        else:
+            # Add top prediction with distinctive marker
+            top_pred = predictions[0]
             folium.Marker(
-                location=[lat, lon],
-                popup=f"<b>{name}</b><br>Location: {lat:.6f}, {lon:.6f}"
+                location=top_pred.coordinates,
+                popup=f"{title}<br>Confidence: {top_pred.confidence:.4f}",
+                icon=folium.Icon(color='red', icon='info-sign')
             ).add_to(m)
+            
+            # Add remaining predictions with standard markers
+            for i, pred in enumerate(predictions[1:], 1):
+                folium.Marker(
+                    location=pred.coordinates,
+                    popup=f"{title} #{i+1}<br>Confidence: {pred.confidence:.4f}",
+                    icon=folium.Icon(color='blue')
+                ).add_to(m)
         
-        # Convert to HTML
-        map_html = m._repr_html_()
-        return map_html
-    
-    except Exception as e:
-        logger.error(f"Error creating map: {str(e)}")
-        return f"Error creating map: {str(e)}"
-
-def ui_process_files(files):
-    """Handle file processing for the UI."""
-    if not files:
-        return "No files uploaded", None, "No data to display"
-    
-    status, metadata = process_images(files)
-    map_html = create_map(metadata) if metadata else "No map data available"
-    
-    return status, metadata, map_html
-
-# Create the Gradio interface
-demo = gr.Interface(
-    fn=ui_process_files,
-    inputs=gr.Files(label="Upload Images"),
-    outputs=[
-        gr.Textbox(label="Status"),
-        gr.JSON(label="Metadata"),
-        gr.HTML(label="Map")
-    ],
-    title="Simple Geotagged Image Analyzer",
-    description="Upload images to extract EXIF data and view locations on a map.",
-    examples=[],
-    cache_examples=False,
-    allow_flagging=False,
-)
+        # Return HTML
+        return m._repr_html_()
+    
+    def analyze_at_scales(self, text: str) -> Dict[str, str]:
+        """
+        Perform multi-scale geospatial analysis with optimized visualization parameters.
+        
+        Args:
+            text: Location description text
+            
+        Returns:
+            Dictionary mapping scale names to HTML map visualizations
+        """
+        # Generate predictions
+        predictions = self.predict_location(text, top_k=10)
+        
+        # Define scale parameters (zoom level, display radius)
+        scales = {
+            'Street': {'zoom': 17, 'radius': 10},
+            'Neighborhood': {'zoom': 14, 'radius': 15},
+            'City': {'zoom': 11, 'radius': 20},
+            'Region': {'zoom': 8, 'radius': 25},
+            'Country': {'zoom': 5, 'radius': 30}
+        }
+        
+        # Generate visualizations at each scale
+        visualizations = {}
+        for scale_name, params in scales.items():
+            map_html = self.create_location_map(
+                predictions=predictions,
+                title=f"{scale_name} view of {text}",
+                zoom=params['zoom'],
+                heatmap=True if scale_name in ['Region', 'Country'] else False
+            )
+            visualizations[scale_name] = map_html
+        
+        return visualizations
+    
+    def analyze_temporal_variations(
+        self, 
+        base_location: str, 
+        time_periods: List[str]
+    ) -> Tuple[List[Tuple[str, Tuple[float, float], float]], str]:
+        """
+        Analyze location shifts across time periods with trajectory visualization.
+        
+        Args:
+            base_location: Base location descriptor
+            time_periods: List of time period identifiers
+            
+        Returns:
+            Tuple of (analysis_results, map_html)
+        """
+        results = []
+        m = folium.Map(zoom_start=4)
+        colors = ['red', 'blue', 'green', 'purple', 'orange', 'darkred', 'darkblue', 'cadetblue', 'darkgreen']
+        
+        for period, color in zip(time_periods, colors * (1 + len(time_periods) // len(colors))):
+            query = f"{base_location} in {period}"
+            predictions = self.predict_location(query, top_k=1)
+            
+            if predictions:
+                pred = predictions[0]
+                coords = pred.coordinates
+                conf = pred.confidence
+                
+                # Add marker with period information
+                folium.Marker(
+                    location=coords,
+                    popup=f"{period}<br>Confidence: {conf:.4f}",
+                    icon=folium.Icon(color=color, icon='info-sign')
+                ).add_to(m)
+                
+                results.append((period, coords, conf))
+        
+        # Connect points chronologically with polyline
+        if len(results) > 1:
+            points = [coords for _, coords, _ in results]
+            folium.PolyLine(points, weight=2, color='gray', opacity=0.8, 
+                           dash_array='5, 5').add_to(m)
+        
+        # Center map on middle point for optimal visualization
+        if results:
+            center_point = results[len(results)//2][1]
+            m.location = center_point
+        
+        return results, m._repr_html_()
+    
+    def find_related_locations(
+        self, 
+        reference: str, 
+        candidates: List[str]
+    ) -> List[Tuple[str, float]]:
+        """
+        Identify semantically related locations using embedding cosine similarity.
+        
+        Args:
+            reference: Reference location or concept
+            candidates: List of candidate locations to compare
+            
+        Returns:
+            List of (location, similarity_score) tuples sorted by relevance
+        """
+        with torch.no_grad():
+            # Generate reference embedding
+            text_inputs = self.tokenizer(reference, return_tensors="pt", padding=True).to(self.device)
+            ref_features = self.model.image_encoder.mlp(
+                self.model.image_encoder.CLIP.get_text_features(**text_inputs)
+            )
+            ref_features = F.normalize(ref_features, dim=1)
+            
+            results = []
+            for candidate in candidates:
+                # Generate candidate embedding
+                text_inputs = self.tokenizer(candidate, return_tensors="pt", padding=True).to(self.device)
+                cand_features = self.model.image_encoder.mlp(
+                    self.model.image_encoder.CLIP.get_text_features(**text_inputs)
+                )
+                cand_features = F.normalize(cand_features, dim=1)
+                
+                # Compute similarity
+                similarity = F.cosine_similarity(
+                    ref_features, cand_features
+                ).item()
+                
+                results.append((candidate, similarity))
+            
+            # Sort by similarity (descending)
+            return sorted(results, key=lambda x: x[1], reverse=True)
+    
+    def visualize_related_locations(
+        self, 
+        reference: str, 
+        candidates: List[str]
+    ) -> Tuple[List[Tuple[str, float]], str]:
+        """
+        Visualize semantically related locations with map integration.
+        
+        Args:
+            reference: Reference location or concept
+            candidates: List of candidate locations
+            
+        Returns:
+            Tuple of (similarity_results, map_html)
+        """
+        # Compute similarities
+        related_results = self.find_related_locations(reference, candidates)
+        
+        # Predict coordinates for all locations
+        marker_data = []
+        ref_predictions = self.predict_location(reference, top_k=1)
+        
+        if ref_predictions:
+            ref_coords = ref_predictions[0].coordinates
+            ref_conf = ref_predictions[0].confidence
+            marker_data.append((reference, ref_coords, ref_conf, 'red', 1.0))
+        
+            # Get coordinates for each candidate
+            for candidate, similarity in related_results:
+                predictions = self.predict_location(candidate, top_k=1)
+                if predictions:
+                    coords = predictions[0].coordinates
+                    conf = predictions[0].confidence
+                    marker_data.append((candidate, coords, conf, 'blue', similarity))
+        
+            # Create map
+            m = folium.Map()
+            
+            for name, coords, conf, color, sim in marker_data:
+                # Scale marker size by similarity
+                radius = 8 + (sim * 10) if name != reference else 15
+                
+                # Add circle marker
+                folium.CircleMarker(
+                    location=coords,
+                    radius=radius,
+                    popup=f"{name}<br>Similarity: {sim:.4f}<br>Confidence: {conf:.4f}",
+                    color=color,
+                    fill=True,
+                    fill_color=color
+                ).add_to(m)
+                
+                # Connect to reference with line
+                if name != reference:
+                    folium.PolyLine(
+                        [ref_coords, coords], 
+                        color=color,
+                        weight=sim * 5,  # Scale line weight by similarity
+                        opacity=0.7
+                    ).add_to(m)
+            
+            # Fit bounds to include all markers
+            if marker_data:
+                all_lats = [coords[0] for _, coords, _, _, _ in marker_data]
+                all_lons = [coords[1] for _, coords, _, _, _ in marker_data]
+                sw = [min(all_lats), min(all_lons)]
+                ne = [max(all_lats), max(all_lons)]
+                m.fit_bounds([sw, ne])
+            
+            return related_results, m._repr_html_()
+        
+        return related_results, ""
+
+    def comprehensive_analysis(self, location: str) -> Dict[str, Any]:
+        """
+        Execute comprehensive multi-faceted location analysis pipeline.
+        
+        Args:
+            location: Target location description
+            
+        Returns:
+            Dictionary containing all analysis results
+        """
+        results = {
+            "query": location,
+            "timestamp": None,  # Can be filled with current timestamp
+        }
+        
+        # Basic prediction
+        predictions = self.predict_location(location, top_k=5)
+        results["predictions"] = predictions
+        
+        # Create basic map
+        results["basic_map"] = self.create_location_map(
+            predictions, 
+            f"'{location}' Predictions"
+        )
+        
+        # Multi-scale analysis
+        results["scale_maps"] = self.analyze_at_scales(location)
+        
+        # Temporal analysis
+        time_periods = ["ancient times", "middle ages", "19th century", "modern day"]
+        temporal_results, temporal_map = self.analyze_temporal_variations(location, time_periods)
+        results["temporal_analysis"] = temporal_results
+        results["temporal_map"] = temporal_map
+        
+        # Related locations analysis
+        candidates = [
+            f"{location} business district",
+            f"{location} historic center",
+            f"{location} tourist area",
+            f"{location} downtown",
+            f"{location} suburbs"
+        ]
+        similarity_results, similarity_map = self.visualize_related_locations(
+            location, candidates
+        )
+        results["similarity_analysis"] = similarity_results
+        results["similarity_map"] = similarity_map
+        
+        return results
+
+
+def create_temporal_analysis_ui(analyzer):
+    """Create the temporal analysis interface component."""
+    with gr.Column():
+        gr.Markdown("## Temporal Analysis")
+        gr.Markdown("Analyze how a location changes across different time periods.")
+        
+        with gr.Row():
+            with gr.Column():
+                base_location = gr.Textbox(label="Base Location", placeholder="e.g., Constantinople")
+                with gr.Row():
+                    time_periods = gr.Textbox(
+                        label="Time Periods (comma-separated)", 
+                        placeholder="ancient times, middle ages, 19th century, modern day",
+                        value="ancient times, middle ages, 19th century, modern day"
+                    )
+                temporal_btn = gr.Button("Analyze Temporal Variations", variant="primary")
+            
+            with gr.Column():
+                temporal_results = gr.Dataframe(
+                    headers=["Time Period", "Latitude", "Longitude", "Confidence"],
+                    label="Temporal Analysis Results"
+                )
+                temporal_map = gr.HTML(label="Temporal Map")
+    
+    def run_temporal_analysis(location, periods_text):
+        if not location:
+            return None, "Please enter a base location"
+        
+        periods = [p.strip() for p in periods_text.split(",") if p.strip()]
+        if not periods:
+            return None, "Please enter at least one time period"
+        
+        try:
+            # Run analysis
+            results, map_html = analyzer.analyze_temporal_variations(location, periods)
+            
+            # Format results for dataframe
+            df_data = [
+                [period, coords[0], coords[1], conf]
+                for period, coords, conf in results
+            ]
+            
+            return df_data, map_html
+        except Exception as e:
+            logger.error(f"Error in temporal analysis: {str(e)}")
+            return None, f"Error: {str(e)}"
+    
+    temporal_btn.click(
+        fn=run_temporal_analysis,
+        inputs=[base_location, time_periods],
+        outputs=[temporal_results, temporal_map]
+    )
+    
+    return base_location, time_periods, temporal_btn, temporal_results, temporal_map
+
+
+def create_related_locations_ui(analyzer):
+    """Create the related locations interface component."""
+    with gr.Column():
+        gr.Markdown("## Related Locations Analysis")
+        gr.Markdown("Find semantically related locations based on GeoCLIP embeddings.")
+        
+        with gr.Row():
+            with gr.Column():
+                reference_location = gr.Textbox(
+                    label="Reference Location/Concept", 
+                    placeholder="e.g., technology hub"
+                )
+                candidate_locations = gr.Textbox(
+                    label="Candidate Locations (comma-separated)",
+                    placeholder="Silicon Valley, Shenzhen China, Bangalore India",
+                    value="Silicon Valley, Shenzhen China, Bangalore India, Tel Aviv Israel, London financial district"
+                )
+                related_btn = gr.Button("Find Related Locations", variant="primary")
+            
+            with gr.Column():
+                similarity_results = gr.Dataframe(
+                    headers=["Location", "Similarity Score"],
+                    label="Similarity Results"
+                )
+                similarity_map = gr.HTML(label="Similarity Map")
+    
+    def run_similarity_analysis(reference, candidates_text):
+        if not reference:
+            return None, "Please enter a reference location or concept"
+        
+        candidates = [c.strip() for c in candidates_text.split(",") if c.strip()]
+        if not candidates:
+            return None, "Please enter at least one candidate location"
+        
+        try:
+            # Run analysis
+            results, map_html = analyzer.visualize_related_locations(reference, candidates)
+            
+            # Format results for dataframe
+            df_data = [
+                [location, similarity]
+                for location, similarity in results
+            ]
+            
+            return df_data, map_html
+        except Exception as e:
+            logger.error(f"Error in similarity analysis: {str(e)}")
+            return None, f"Error: {str(e)}"
+    
+    related_btn.click(
+        fn=run_similarity_analysis,
+        inputs=[reference_location, candidate_locations],
+        outputs=[similarity_results, similarity_map]
+    )
+    
+    return reference_location, candidate_locations, related_btn, similarity_results, similarity_map
+
+
+def create_comprehensive_analysis_ui(analyzer):
+    """Create the comprehensive analysis interface component."""
+    with gr.Column():
+        gr.Markdown("## Comprehensive Analysis")
+        gr.Markdown("Perform a full multi-faceted analysis of a location.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                comp_location = gr.Textbox(
+                    label="Location", 
+                    placeholder="e.g., Tokyo Japan"
+                )
+                comp_btn = gr.Button("Run Comprehensive Analysis", variant="primary")
+            
+            with gr.Column(scale=3):
+                with gr.Tabs():
+                    with gr.TabItem("Basic Prediction"):
+                        basic_results = gr.Dataframe(
+                            headers=["Rank", "Latitude", "Longitude", "Confidence"],
+                            label="Top Predictions"
+                        )
+                        basic_map = gr.HTML(label="Map")
+                    
+                    with gr.TabItem("Multi-scale Analysis"):
+                        with gr.Tabs() as scale_tabs:
+                            scale_maps = {
+                                scale: gr.HTML(label=f"{scale} Scale")
+                                for scale in ["Street", "Neighborhood", "City", "Region", "Country"]
+                            }
+                    
+                    with gr.TabItem("Temporal Analysis"):
+                        comp_temporal_results = gr.Dataframe(
+                            headers=["Time Period", "Latitude", "Longitude", "Confidence"],
+                            label="Temporal Analysis"
+                        )
+                        comp_temporal_map = gr.HTML(label="Temporal Map")
+                    
+                    with gr.TabItem("Related Contexts"):
+                        comp_similarity_results = gr.Dataframe(
+                            headers=["Context", "Similarity Score"],
+                            label="Related Contexts"
+                        )
+                        comp_similarity_map = gr.HTML(label="Similarity Map")
+    
+    def run_comprehensive_analysis(location):
+        if not location:
+            return (
+                None, "", 
+                {"Street": "", "Neighborhood": "", "City": "", "Region": "", "Country": ""},
+                None, "", None, ""
+            )
+        
+        try:
+            # Run analysis
+            results = analyzer.comprehensive_analysis(location)
+            
+            # Format basic results
+            basic_df = [
+                [i+1, pred.coordinates[0], pred.coordinates[1], pred.confidence]
+                for i, pred in enumerate(results["predictions"])
+            ]
+            
+            # Format temporal results
+            temporal_df = [
+                [period, coords[0], coords[1], conf]
+                for period, coords, conf in results["temporal_analysis"]
+            ] if "temporal_analysis" in results else None
+            
+            # Format similarity results
+            similarity_df = [
+                [location, similarity]
+                for location, similarity in results["similarity_analysis"]
+            ] if "similarity_analysis" in results else None
+            
+            return (
+                basic_df, 
+                results["basic_map"],
+                results["scale_maps"],
+                temporal_df,
+                results["temporal_map"],
+                similarity_df,
+                results["similarity_map"]
+            )
+        except Exception as e:
+            logger.error(f"Error in comprehensive analysis: {str(e)}")
+            return (
+                None, f"Error: {str(e)}", 
+                {"Street": "", "Neighborhood": "", "City": "", "Region": "", "Country": ""},
+                None, "", None, ""
+            )
+    
+    comp_btn.click(
+        fn=run_comprehensive_analysis,
+        inputs=[comp_location],
+        outputs=[
+            basic_results, basic_map, 
+            gr.Dict(scale_maps),
+            comp_temporal_results, comp_temporal_map,
+            comp_similarity_results, comp_similarity_map
+        ]
+    )
+    
+    return comp_location, comp_btn, basic_results, basic_map, scale_maps, comp_temporal_results, comp_temporal_map, comp_similarity_results, comp_similarity_map
+
+
+def create_interface():
+    """Create the Gradio interface for the GeoCLIP Text-to-Location Analyzer."""
+    # Initialize the analyzer with caching
+    analyzer = GeoCLIPAnalyzer(cache_enabled=True)
+    
+    with gr.Blocks(title="GeoCLIP Text-to-Location Analyzer") as demo:
+        gr.Markdown("# 🌍 GeoCLIP Text-to-Location Analyzer")
+        gr.Markdown("""
+        This interface allows you to analyze geographic locations using GeoCLIP's text-to-location capabilities.
+        You can perform basic location predictions, temporal analysis, find related locations, and run comprehensive analyses.
+        """)
+        
+        # Basic prediction section
+        with gr.Column():
+            gr.Markdown("## Basic Location Prediction")
+            gr.Markdown("Enter a textual description of a location to get coordinate predictions.")
+            
+            with gr.Row():
+                with gr.Column():
+                    location_input = gr.Textbox(
+                        label="Location Description", 
+                        placeholder="e.g., Eiffel Tower Paris"
+                    )
+                    top_k = gr.Slider(
+                        minimum=1, maximum=10, value=5, step=1,
+                        label="Number of Predictions"
+                    )
+                    predict_btn = gr.Button("Predict Location", variant="primary")
+                
+                with gr.Column():
+                    prediction_results = gr.Dataframe(
+                        headers=["Rank", "Latitude", "Longitude", "Confidence"],
+                        label="Prediction Results"
+                    )
+                    map_output = gr.HTML(label="Map Visualization")
+        
+        # Add tab-based sections for different analyses
+        with gr.Tabs():
+            with gr.TabItem("Multi-scale Analysis"):
+                with gr.Row():
+                    with gr.Column():
+                        scale_location = gr.Textbox(
+                            label="Location Description", 
+                            placeholder="e.g., Central Park New York"
+                        )
+                        scale_btn = gr.Button("Analyze at Different Scales", variant="primary")
+                    
+                    with gr.Column():
+                        with gr.Tabs() as scale_tabs:
+                            street_map = gr.HTML(label="Street Level")
+                            neighborhood_map = gr.HTML(label="Neighborhood Level")
+                            city_map = gr.HTML(label="City Level")
+                            region_map = gr.HTML(label="Regional Level")
+                            country_map = gr.HTML(label="Country Level")
+            
+            with gr.TabItem("Temporal Analysis"):
+                base_location, time_periods, temporal_btn, temporal_results, temporal_map = create_temporal_analysis_ui(analyzer)
+            
+            with gr.TabItem("Related Locations"):
+                reference_location, candidate_locations, related_btn, similarity_results, similarity_map = create_related_locations_ui(analyzer)
+            
+            with gr.TabItem("Comprehensive Analysis"):
+                comp_location, comp_btn, basic_results, basic_map, scale_maps, comp_temporal_results, comp_temporal_map, comp_similarity_results, comp_similarity_map = create_comprehensive_analysis_ui(analyzer)
+        
+        # Basic prediction handler
+        def handle_prediction(text, k):
+            if not text:
+                return None, "Please enter a location description"
+            
+            try:
+                predictions = analyzer.predict_location(text, top_k=int(k))
+                
+                # Format for dataframe
+                df_data = [
+                    [i+1, pred.coordinates[0], pred.coordinates[1], pred.confidence]
+                    for i, pred in enumerate(predictions)
+                ]
+                
+                # Create map
+                map_html = analyzer.create_location_map(predictions, f"'{text}' Predictions")
+                
+                return df_data, map_html
+            except Exception as e:
+                logger.error(f"Error in prediction: {str(e)}")
+                return None, f"Error: {str(e)}"
+        
+        # Multi-scale analysis handler
+        def handle_scale_analysis(text):
+            if not text:
+                return "", "", "", "", ""
+            
+            try:
+                scale_maps = analyzer.analyze_at_scales(text)
+                return (
+                    scale_maps.get("Street", ""),
+                    scale_maps.get("Neighborhood", ""),
+                    scale_maps.get("City", ""),
+                    scale_maps.get("Region", ""),
+                    scale_maps.get("Country", "")
+                )
+            except Exception as e:
+                logger.error(f"Error in scale analysis: {str(e)}")
+                error_msg = f"<div class='error'>Error: {str(e)}</div>"
+                return error_msg, error_msg, error_msg, error_msg, error_msg
+        
+        # Set up event handlers
+        predict_btn.click(
+            fn=handle_prediction,
+            inputs=[location_input, top_k],
+            outputs=[prediction_results, map_output]
+        )
+        
+        scale_btn.click(
+            fn=handle_scale_analysis,
+            inputs=[scale_location],
+            outputs=[street_map, neighborhood_map, city_map, region_map, country_map]
+        )
+        
+        gr.Markdown("""
+        ## About GeoCLIP
+        
+        GeoCLIP is a CLIP-inspired model that aligns locations with images for effective worldwide geo-localization.
+        This interface uses GeoCLIP's text encoder to map textual descriptions to geographic coordinates.
+        
+        All operations use efficient LRU caching for improved performance on repeated queries.
+        
+        **Reference:** [GeoCLIP: Clip-Inspired Alignment between Locations and Images for Effective Worldwide Geo-localization](https://arxiv.org/abs/2309.16020)
+        """)
+    
+    return demo
+
 
 if __name__ == "__main__":
+    demo = create_interface()
     demo.launch()