Update app.py

app.py

@@ -1,920 +1,145 @@
-# app.py - Ana uygulama dosyası
-import os
+import gradio as gr
 import torch
-import torch.nn as nn
-import torch.optim as optim
-from torch.utils.data import DataLoader, Dataset
-import transformers
-from transformers import (
-    AutoImageProcessor, 
-    AutoModel, 
-    BitsAndBytesConfig,
-    TrainingArguments,
-    Trainer
-)
-from datasets import load_dataset, Dataset as HFDataset
-import torchvision.transforms as transforms
-from PIL import Image, ImageDraw, ImageFont
+from transformers import AutoImageProcessor, AutoModel
+from PIL import Image
 import numpy as np
-import pandas as pd
-import geopandas as gpd
-from shapely.geometry import Point, Polygon
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-from matplotlib.offsetbox import OffsetImage, AnnotationBbox
 import rasterio
-from rasterio.transform import from_bounds
-import json
-import gradio as gr
-import folium
-from folium import plugins
-from branca.element import Figure
-import tempfile
-import base64
+from rasterio.warp import reproject, Resampling
+from rasterio.crs import CRS
+from rasterio.warp import transform_geom
+import shapely.geometry
+import utm
+import requests
 from io import BytesIO
-from datetime import datetime
-import logging
-from typing import Dict, List, Tuple, Optional, Union
-import warnings
-warnings.filterwarnings('ignore')
+import os
+from huggingface_hub import spaces
 
-# Logging konfigürasyonu
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# GPU
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+print(f"GPU: {device}")
 
-class AdvancedGeoModel(nn.Module):
-    """Gelişmiş Jeo-Referanslama Modeli"""
-    
-    def __init__(self, 
-                 image_embed_dim: int = 768,
-                 location_embed_dim: int = 512,
-                 num_attention_heads: int = 12,
-                 dropout: float = 0.1):
-        super(AdvancedGeoModel, self).__init__()
-        
-        # DINOv2 backbone
-        self.dinov2_processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
-        self.dinov2 = AutoModel.from_pretrained("facebook/dinov2-base")
-        
-        # Multi-scale feature extraction
-        self.feature_pyramid = nn.ModuleDict({
-            'scale1': nn.Conv2d(768, 256, 3, padding=1),
-            'scale2': nn.Conv2d(768, 256, 3, padding=1),
-            'scale3': nn.Conv2d(768, 256, 3, padding=1)
-        })
-        
-        # Image projection
-        self.image_projection = nn.Sequential(
-            nn.Linear(768, image_embed_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.LayerNorm(image_embed_dim)
-        )
-        
-        # Location encoder
-        self.location_encoder = nn.Sequential(
-            nn.Linear(2, 128),
-            nn.GELU(),
-            nn.Linear(128, 256),
-            nn.GELU(),
-            nn.Linear(256, location_embed_dim),
-            nn.Dropout(dropout)
-        )
-        
-        # Multi-head cross attention
-        self.cross_attention = nn.MultiheadAttention(
-            embed_dim=image_embed_dim,
-            num_heads=num_attention_heads,
-            dropout=dropout,
-            batch_first=True
-        )
-        
-        # Transformer layers for fusion
-        encoder_layer = nn.TransformerEncoderLayer(
-            d_model=image_embed_dim + location_embed_dim,
-            nhead=8,
-            dim_feedforward=1024,
-            dropout=dropout,
-            batch_first=True
-        )
-        self.fusion_transformer = nn.TransformerEncoder(encoder_layer, num_layers=3)
-        
-        # Regression head with uncertainty estimation
-        self.regressor = nn.Sequential(
-            nn.Linear(image_embed_dim + location_embed_dim, 512),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(512, 256),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(256, 128),
-            nn.GELU(),
-            nn.Linear(128, 4)  # lat, lon, lat_uncertainty, lon_uncertainty
-        )
-        
-        # Classification head for continent/region
-        self.classifier = nn.Sequential(
-            nn.Linear(image_embed_dim, 256),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(256, 128),
-            nn.GELU(),
-            nn.Linear(128, 7)  # 7 kıta
-        )
-        
-    def forward(self, pixel_values: torch.Tensor, locations: Optional[torch.Tensor] = None):
-        # Extract multi-scale features from DINOv2
-        dinov2_output = self.dinov2(pixel_values=pixel_values, output_hidden_states=True)
-        
-        # Use last hidden state as primary features
-        image_features = dinov2_output.last_hidden_state
-        image_features = image_features.mean(dim=1)  # Global average pooling
-        
-        # Project image features
-        image_embeddings = self.image_projection(image_features)
-        
-        if locations is not None:
-            # Encode location information
-            location_embeddings = self.location_encoder(locations)
-            
-            # Cross-modal attention
-            attended_features, attention_weights = self.cross_attention(
-                query=image_embeddings.unsqueeze(1),
-                key=location_embeddings.unsqueeze(1),
-                value=location_embeddings.unsqueeze(1)
-            )
-            
-            # Concatenate features
-            combined_features = torch.cat([image_embeddings, attended_features.squeeze(1)], dim=1)
-            
-            # Fusion through transformer
-            fused_features = self.fusion_transformer(combined_features.unsqueeze(1))
-            fused_features = fused_features.squeeze(1)
-        else:
-            fused_features = image_embeddings
-        
-        # Regression output
-        coords_output = self.regressor(fused_features)
-        
-        # Classification output
-        class_output = self.classifier(image_embeddings)
-        
-        return {
-            'coordinates': coords_output[:, :2],  # lat, lon
-            'uncertainty': coords_output[:, 2:],  # lat_uncertainty, lon_uncertainty
-            'region_logits': class_output,
-            'image_embeddings': image_embeddings
-        }
+# DINOv2
+processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
+model = AutoModel.from_pretrained("facebook/dinov2-base").to(device).eval()
 
-class MultiModalGeoDataset(Dataset):
-    """Çoklu Modal Jeo-Referanslama Dataseti"""
-    
-    def __init__(self, 
-                 dataset_config: Dict,
-                 transform: Optional[transforms.Compose] = None,
-                 max_samples: int = 10000):
-        
-        self.transform = transform
-        self.datasets = {}
-        self.sample_weights = {}
-        self.max_samples = max_samples
-        
-        # EarthView dataset
-        if dataset_config.get('earthview', False):
-            try:
-                earthview = load_dataset("satellogic/EarthView", split=f"train[:{max_samples}]")
-                self.datasets['earthview'] = earthview
-                self.sample_weights['earthview'] = 0.4
-                logger.info("EarthView dataset loaded successfully")
-            except Exception as e:
-                logger.warning(f"EarthView dataset loading failed: {e}")
-        
-        # EuroSAT dataset
-        if dataset_config.get('eurosat', False):
-            try:
-                eurosat = load_dataset("phelber/EuroSAT", "rgb", split=f"train[:{max_samples}]")
-                self.datasets['eurosat'] = eurosat
-                self.sample_weights['eurosat'] = 0.3
-                logger.info("EuroSAT dataset loaded successfully")
-            except Exception as e:
-                logger.warning(f"EuroSAT dataset loading failed: {e}")
-        
-        # S2-NAIP dataset
-        if dataset_config.get('s2_naip', False):
-            try:
-                s2_naip = load_dataset("allenai/s2-naip", split=f"train[:{max_samples}]")
-                self.datasets['s2_naip'] = s2_naip
-                self.sample_weights['s2_naip'] = 0.3
-                logger.info("S2-NAIP dataset loaded successfully")
-            except Exception as e:
-                logger.warning(f"S2-NAIP dataset loading failed: {e}")
-        
-        # Calculate dataset sizes and cumulative weights
-        self.dataset_sizes = {name: len(dataset) for name, dataset in self.datasets.items()}
-        total_size = sum(self.dataset_sizes.values())
-        self.dataset_weights = {name: size/total_size * weight 
-                               for name, weight, size in zip(self.sample_weights.keys(), 
-                                                           self.sample_weights.values(), 
-                                                           self.dataset_sizes.values())}
-        
-        self.cumulative_lengths = self._calculate_cumulative_lengths()
-    
-    def _calculate_cumulative_lengths(self):
-        cumulative = [0]
-        for name, dataset in self.datasets.items():
-            cumulative.append(cumulative[-1] + len(dataset))
-        return cumulative
-    
-    def __len__(self):
-        return self.cumulative_lengths[-1]
-    
-    def __getitem__(self, idx):
-        # Find which dataset this index belongs to
-        for i, (name, dataset) in enumerate(self.datasets.items()):
-            if idx < self.cumulative_lengths[i+1]:
-                local_idx = idx - self.cumulative_lengths[i]
-                return self._process_dataset_item(name, dataset, local_idx)
-        
-        raise IndexError("Index out of range")
-    
-    def _process_dataset_item(self, dataset_name: str, dataset, idx: int):
-        item = dataset[idx]
-        
-        if dataset_name == 'earthview':
-            return self._process_earthview(item)
-        elif dataset_name == 'eurosat':
-            return self._process_eurosat(item)
-        elif dataset_name == 's2_naip':
-            return self._process_s2_naip(item)
-    
-    def _process_earthview(self, item):
-        image = item['image']
-        lat = item.get('lat', torch.rand(1).item() * 180 - 90)
-        lon = item.get('lon', torch.rand(1).item() * 360 - 180)
-        
-        if self.transform:
-            image = self.transform(image)
-        
-        return {
-            'pixel_values': image,
-            'coordinates': torch.tensor([lat, lon], dtype=torch.float32),
-            'dataset': 'earthview'
-        }
-    
-    def _process_eurosat(self, item):
-        image = item['image']
-        # EuroSAT için sentetik koordinatlar
-        lat = torch.rand(1).item() * 180 - 90
-        lon = torch.rand(1).item() * 360 - 180
-        
-        if self.transform:
-            image = self.transform(image)
-        
-        return {
-            'pixel_values': image,
-            'coordinates': torch.tensor([lat, lon], dtype=torch.float32),
-            'dataset': 'eurosat'
-        }
-    
-    def _process_s2_naip(self, item):
-        sentinel_image = item['sentinel']
-        lat = item.get('lat', torch.rand(1).item() * 180 - 90)
-        lon = item.get('lon', torch.rand(1).item() * 360 - 180)
-        
-        if self.transform:
-            sentinel_image = self.transform(sentinel_image)
-        
-        return {
-            'pixel_values': sentinel_image,
-            'coordinates': torch.tensor([lat, lon], dtype=torch.float32),
-            'dataset': 's2_naip'
-        }
+# S2-NAIP TILE MAPPING
+def latlon_to_tile(lat, lon):
+    src_crs = CRS.from_epsg(4326)
+    src_point = shapely.geometry.Point(lon, lat)
+    _, _, zone, _ = utm.from_latlon(lat, lon)
+    epsg = 32600 + zone
+    dst_crs = CRS.from_epsg(epsg)
+    dst_point = transform_geom(src_crs, dst_crs, src_point)
+    dst_point = shapely.geometry.shape(dst_point)
+    col = int(dst_point.x / 1.25)
+    row = int(dst_point.y / -1.25)
+    tile = f"{epsg}_{col//512}_{row//512}"
+    tar = f"{epsg}_{col//512//32}_{row//512//32}"
+    return tile, tar, epsg
 
-class ProfessionalGeoReferencingSystem:
-    """Profesyonel Jeo-Referanslama Sistemi"""
-    
-    def __init__(self, model_path: Optional[str] = None, use_quantization: bool = True):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        logger.info(f"Using device: {self.device}")
-        
-        # Model konfigürasyonu
-        self.setup_model(model_path, use_quantization)
-        
-        # Image processor
-        self.processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
-        
-        # Data transforms
-        self.transform = self._get_transforms()
-        
-        # Region classifier için etiketler
-        self.region_labels = ['Africa', 'Asia', 'Europe', 'North America', 
-                             'Oceania', 'South America', 'Antarctica']
-        
-        logger.info("Professional Geo-Referencing System initialized")
-    
-    def setup_model(self, model_path: Optional[str], use_quantization: bool):
-        """Modeli kur ve yükle"""
-        
-        if use_quantization and self.device.type == 'cuda':
-            quantization_config = BitsAndBytesConfig(
-                load_in_8bit=True,
-                bnb_8bit_compute_dtype=torch.float16,
-                bnb_8bit_quant_type="nf8"
-            )
-        else:
-            quantization_config = None
-        
-        # Modeli oluştur
-        self.model = AdvancedGeoModel()
-        
-        # Model yükleme
-        if model_path and os.path.exists(model_path):
-            try:
-                state_dict = torch.load(model_path, map_location=self.device)
-                self.model.load_state_dict(state_dict)
-                logger.info(f"Model loaded from {model_path}")
-            except Exception as e:
-                logger.warning(f"Model loading failed: {e}. Using pretrained weights.")
-        
-        self.model.to(self.device)
-        self.model.eval()
-    
-    def _get_transforms(self):
-        """Data augmentation ve preprocessing transforms"""
-        return transforms.Compose([
-            transforms.Resize((224, 224)),
-            transforms.RandomHorizontalFlip(p=0.3),
-            transforms.RandomVerticalFlip(p=0.1),
-            transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
-            transforms.ToTensor(),
-            transforms.Normalize(
-                mean=[0.485, 0.456, 0.406],
-                std=[0.229, 0.224, 0.225]
-            )
-        ])
-    
-    def train(self, 
-              epochs: int = 20,
-              batch_size: int = 32,
-              learning_rate: float = 1e-4,
-              output_dir: str = "./geo_model"):
-        """Model eğitimi"""
-        
-        # Dataset hazırlık
-        dataset_config = {
-            'earthview': True,
-            'eurosat': True,
-            's2_naip': True
-        }
-        
-        train_dataset = MultiModalGeoDataset(dataset_config, transform=self.transform)
-        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)
-        
-        # Loss functions
-        coord_criterion = nn.HuberLoss()  # Robust regression loss
-        class_criterion = nn.CrossEntropyLoss()
-        
-        # Optimizer
-        optimizer = optim.AdamW(
-            self.model.parameters(),
-            lr=learning_rate,
-            weight_decay=1e-4,
-            betas=(0.9, 0.999)
-        )
-        
-        # Learning rate scheduler
-        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
-        
-        # Training loop
-        self.model.train()
-        best_loss = float('inf')
-        
-        for epoch in range(epochs):
-            total_loss = 0
-            coord_loss_total = 0
-            class_loss_total = 0
-            
-            for batch_idx, batch in enumerate(train_loader):
-                pixel_values = batch['pixel_values'].to(self.device)
-                coordinates = batch['coordinates'].to(self.device)
-                
-                optimizer.zero_grad()
-                
-                # Forward pass
-                outputs = self.model(pixel_values)
-                
-                # Loss calculation
-                coord_loss = coord_criterion(outputs['coordinates'], coordinates)
-                
-                # Region classification loss (synthetic for now)
-                region_targets = torch.randint(0, 7, (pixel_values.size(0),)).to(self.device)
-                class_loss = class_criterion(outputs['region_logits'], region_targets)
-                
-                # Combined loss
-                loss = coord_loss + 0.1 * class_loss
-                
-                # Backward pass
-                loss.backward()
-                torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
-                optimizer.step()
-                
-                total_loss += loss.item()
-                coord_loss_total += coord_loss.item()
-                class_loss_total += class_loss.item()
-                
-                if batch_idx % 100 == 0:
-                    logger.info(f'Epoch {epoch+1}/{epochs}, Batch {batch_idx}, '
-                               f'Loss: {loss.item():.6f}, Coord: {coord_loss.item():.6f}, '
-                               f'Class: {class_loss.item():.6f}')
-            
-            scheduler.step()
-            
-            avg_loss = total_loss / len(train_loader)
-            avg_coord_loss = coord_loss_total / len(train_loader)
-            avg_class_loss = class_loss_total / len(train_loader)
-            
-            logger.info(f'Epoch {epoch+1}/{epochs} completed: '
-                       f'Avg Loss: {avg_loss:.6f}, '
-                       f'Avg Coord Loss: {avg_coord_loss:.6f}, '
-                       f'Avg Class Loss: {avg_class_loss:.6f}')
-            
-            # Model kaydetme
-            if avg_loss < best_loss:
-                best_loss = avg_loss
-                self.save_model(f"{output_dir}/best_model.pth")
-                logger.info(f"New best model saved with loss: {best_loss:.6f}")
-        
-        # Final model kaydetme
-        self.save_model(f"{output_dir}/final_model.pth")
-        logger.info("Training completed and final model saved")
-    
-    def predict(self, image: Union[str, Image.Image, np.ndarray]) -> Dict:
-        """Görüntüden koordinat tahmini"""
-        self.model.eval()
-        
-        try:
-            # Görüntü preprocessing
-            if isinstance(image, str):
-                image = Image.open(image).convert('RGB')
-            elif isinstance(image, np.ndarray):
-                image = Image.fromarray(image.astype('uint8')).convert('RGB')
-            
-            # Transform uygula
-            processed_image = self.transform(image).unsqueeze(0).to(self.device)
-            
-            with torch.no_grad():
-                outputs = self.model(processed_image)
-                
-                coords = outputs['coordinates'].cpu().numpy()[0]
-                uncertainty = outputs['uncertainty'].cpu().numpy()[0]
-                region_probs = torch.softmax(outputs['region_logits'], dim=1).cpu().numpy()[0]
-                
-                predicted_region = self.region_labels[np.argmax(region_probs)]
-                region_confidence = np.max(region_probs)
-                
-                # Confidence hesaplama
-                overall_confidence = self._calculate_confidence(coords, uncertainty, region_confidence)
-                
-                result = {
-                    'latitude': float(coords[0]),
-                    'longitude': float(coords[1]),
-                    'latitude_uncertainty': float(uncertainty[0]),
-                    'longitude_uncertainty': float(uncertainty[1]),
-                    'predicted_region': predicted_region,
-                    'region_confidence': float(region_confidence),
-                    'overall_confidence': float(overall_confidence),
-                    'region_probabilities': {
-                        label: float(prob) for label, prob in zip(self.region_labels, region_probs)
-                    },
-                    'timestamp': datetime.now().isoformat()
-                }
-                
-                return result
-                
-        except Exception as e:
-            logger.error(f"Prediction error: {e}")
-            return {
-                'error': str(e),
-                'latitude': 0.0,
-                'longitude': 0.0,
-                'overall_confidence': 0.0
-            }
-    
-    def _calculate_confidence(self, coords: np.ndarray, uncertainty: np.ndarray, region_confidence: float) -> float:
-        """Genel güven skoru hesaplama"""
-        coord_confidence = 1.0 / (1.0 + np.mean(np.abs(uncertainty)))
-        overall_confidence = 0.7 * coord_confidence + 0.3 * region_confidence
-        return min(overall_confidence, 1.0)
-    
-    def save_model(self, path: str):
-        """Model kaydetme"""
-        torch.save(self.model.state_dict(), path)
-        logger.info(f"Model saved to {path}")
-    
-    def load_model(self, path: str):
-        """Model yükleme"""
-        self.model.load_state_dict(torch.load(path, map_location=self.device))
-        self.model.to(self.device)
-        logger.info(f"Model loaded from {path}")
+# GERÇEK S2-NAIP GÖRÜNTÜ ÇEK
+def fetch_sentinel2_tile(tile_id):
+    base = "https://huggingface.co/datasets/allenai/s2-naip/resolve/main/sentinel2"
+    url = f"{base}/{tile_id}_8.tif"
+    try:
+        r = requests.get(url, timeout=10)
+        if r.status_code == 200:
+            bio = BytesIO(r.content)
+            with rasterio.open(bio) as src:
+                img = src.read([1,2,3])  # B04, B03, B02
+                img = np.clip(img / 3000.0 * 255, 0, 255).astype(np.uint8)
+                img = img.transpose(1,2,0)
+                transform = src.transform
+                crs = src.crs
+                return Image.fromarray(img), transform, crs
+    except:
+        pass
+    return None, None, None
 
-class GeoVisualizationEngine:
-    """Gelişmiş Görselleştirme Motoru"""
-    
-    def __init__(self):
-        self.style = 'openstreetmap'
-    
-    def create_interactive_map(self, 
-                             predictions: List[Dict],
-                             map_center: Tuple[float, float] = (39, 35),
-                             zoom_start: int = 4) -> str:
-        """Interactive Folium haritası oluşturma"""
-        
-        m = folium.Map(location=map_center, zoom_start=zoom_start, tiles=self.style)
-        
-        for i, pred in enumerate(predictions):
-            if 'error' in pred:
-                continue
-                
-            lat, lon = pred['latitude'], pred['longitude']
-            confidence = pred.get('overall_confidence', 0.5)
-            region = pred.get('predicted_region', 'Unknown')
-            
-            # Confidence'a göre renk
-            color = 'red' if confidence < 0.3 else 'orange' if confidence < 0.7 else 'green'
-            
-            # Popup içeriği
-            popup_text = f"""
-            <b>Prediction {i+1}</b><br>
-            <b>Coordinates:</b> {lat:.4f}, {lon:.4f}<br>
-            <b>Region:</b> {region}<br>
-            <b>Confidence:</b> {confidence:.2%}<br>
-            <b>Uncertainty:</b> ±{pred.get('latitude_uncertainty', 0):.3f}°
-            """
-            
-            # Marker ekle
-            folium.Marker(
-                [lat, lon],
-                popup=folium.Popup(popup_text, max_width=300),
-                tooltip=f"Click for details (Confidence: {confidence:.2%})",
-                icon=folium.Icon(color=color, icon='info-sign')
-            ).add_to(m)
-            
-            # Uncertainty circle
-            uncertainty = max(pred.get('latitude_uncertainty', 0.1), pred.get('longitude_uncertainty', 0.1))
-            folium.Circle(
-                location=[lat, lon],
-                radius=uncertainty * 111320,  # Convert degrees to meters
-                popup=f"Uncertainty: ±{uncertainty:.3f}°",
-                color=color,
-                fill=True,
-                fillOpacity=0.2
-            ).add_to(m)
-        
-        # Haritayı HTML olarak kaydet
-        with tempfile.NamedTemporaryFile(suffix='.html', delete=False) as tmp:
-            m.save(tmp.name)
-            return tmp.name
-    
-    def create_analysis_plot(self, predictions: List[Dict]) -> str:
-        """Analiz grafiği oluşturma"""
-        
-        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 12))
-        
-        # Confidence dağılımı
-        confidences = [p.get('overall_confidence', 0) for p in predictions if 'error' not in p]
-        ax1.hist(confidences, bins=20, alpha=0.7, color='skyblue', edgecolor='black')
-        ax1.set_xlabel('Confidence Score')
-        ax1.set_ylabel('Frequency')
-        ax1.set_title('Confidence Distribution')
-        ax1.grid(True, alpha=0.3)
-        
-        # Bölge dağılımı
-        regions = [p.get('predicted_region', 'Unknown') for p in predictions if 'error' not in p]
-        region_counts = pd.Series(regions).value_counts()
-        ax2.bar(region_counts.index, region_counts.values, color='lightcoral', alpha=0.7)
-        ax2.set_xlabel('Predicted Region')
-        ax2.set_ylabel('Count')
-        ax2.set_title('Regional Distribution')
-        ax2.tick_params(axis='x', rotation=45)
-        ax2.grid(True, alpha=0.3)
-        
-        # Uncertainty dağılımı
-        uncertainties = [p.get('latitude_uncertainty', 0) for p in predictions if 'error' not in p]
-        ax3.hist(uncertainties, bins=20, alpha=0.7, color='lightgreen', edgecolor='black')
-        ax3.set_xlabel('Uncertainty (degrees)')
-        ax3.set_ylabel('Frequency')
-        ax3.set_title('Uncertainty Distribution')
-        ax3.grid(True, alpha=0.3)
-        
-        # Confidence vs Uncertainty
-        ax4.scatter(confidences, uncertainties, alpha=0.6, color='purple')
-        ax4.set_xlabel('Confidence')
-        ax4.set_ylabel('Uncertainty')
-        ax4.set_title('Confidence vs Uncertainty')
-        ax4.grid(True, alpha=0.3)
-        
-        plt.tight_layout()
-        
-        # Geçici dosyaya kaydet
-        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
-            plt.savefig(tmp.name, dpi=300, bbox_inches='tight')
-            plt.close()
-            return tmp.name
+@spaces.GPU
+def georeference(image, location):
+    if image is None:
+        return None, None, None, "Görüntü yükleyin!"
 
-class ProfessionalGeoApp:
-    """Profesyonel Jeo-Referanslama Uygulaması"""
-    
-    def __init__(self):
-        self.system = ProfessionalGeoReferencingSystem()
-        self.visualizer = GeoVisualizationEngine()
-        self.predictions_history = []
-        
-        logger.info("Professional Geo-App initialized")
-    
-    def process_single_image(self, image) -> Dict:
-        """Tekil görüntü işleme"""
-        result = self.system.predict(image)
-        
-        if 'error' not in result:
-            self.predictions_history.append(result)
-            
-        return result
-    
-    def process_batch_images(self, files: List) -> Dict:
-        """Toplu görüntü işleme"""
-        results = []
-        
-        for file in files:
-            try:
-                result = self.system.predict(file.name)
-                result['filename'] = os.path.basename(file.name)
-                results.append(result)
-            except Exception as e:
-                results.append({
-                    'filename': os.path.basename(file.name),
-                    'error': str(e)
-                })
-        
-        # Analiz oluştur
-        successful_results = [r for r in results if 'error' not in r]
-        
-        if successful_results:
-            map_path = self.visualizer.create_interactive_map(successful_results)
-            analysis_path = self.visualizer.create_analysis_plot(successful_results)
-        else:
-            map_path = None
-            analysis_path = None
-        
-        batch_result = {
-            'results': results,
-            'summary': {
-                'total_images': len(files),
-                'successful_predictions': len(successful_results),
-                'failed_predictions': len(results) - len(successful_results),
-                'average_confidence': np.mean([r.get('overall_confidence', 0) for r in successful_results]) if successful_results else 0
-            },
-            'map_path': map_path,
-            'analysis_path': analysis_path
-        }
-        
-        self.predictions_history.extend(successful_results)
-        
-        return batch_result
-    
-    def export_results(self, format_type: str = 'geojson') -> str:
-        """Sonuçları export etme"""
-        if not self.predictions_history:
-            return None
-        
-        df = pd.DataFrame(self.predictions_history)
-        
-        with tempfile.NamedTemporaryFile(suffix=f'.{format_type}', delete=False) as tmp:
-            if format_type == 'geojson':
-                # GeoJSON export
-                features = []
-                for _, row in df.iterrows():
-                    if 'error' not in row:
-                        feature = {
-                            "type": "Feature",
-                            "geometry": {
-                                "type": "Point",
-                                "coordinates": [row['longitude'], row['latitude']]
-                            },
-                            "properties": {
-                                "confidence": row.get('overall_confidence', 0),
-                                "region": row.get('predicted_region', 'Unknown'),
-                                "region_confidence": row.get('region_confidence', 0),
-                                "timestamp": row.get('timestamp', ''),
-                                "uncertainty_lat": row.get('latitude_uncertainty', 0),
-                                "uncertainty_lon": row.get('longitude_uncertainty', 0)
-                            }
-                        }
-                        features.append(feature)
-                
-                geojson = {
-                    "type": "FeatureCollection",
-                    "features": features
-                }
-                
-                with open(tmp.name, 'w') as f:
-                    json.dump(geojson, f, indent=2)
-            
-            elif format_type == 'csv':
-                df.to_csv(tmp.name, index=False)
-            
-            elif format_type == 'excel':
-                df.to_excel(tmp.name, index=False)
-            
-            return tmp.name
+    # KONUM → LAT/LON
+    locations = {
+        "seattle": (47.6062, -122.3321),
+        "whiskeytown": (40.5838, -122.5692),
+        "los angeles": (34.0522, -118.2437),
+        "new york": (40.7128, -74.0060),
+        "san francisco": (37.7749, -122.4194)
+    }
+    loc_key = next((k for k in locations if k in location.lower()), "seattle")
+    lat, lon = locations[loc_key]
 
-# Gradio Arayüzü
-def create_gradio_interface():
-    """Profesyonel Gradio arayüzü oluşturma"""
-    
-    app = ProfessionalGeoApp()
-    
-    with gr.Blocks(title="🤖 Advanced AI Geo-Referencing System", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🗺️ Advanced AI Geo-Referencing System
-        **Professional-grade geolocation prediction from aerial imagery**
-        
-        This system uses state-of-the-art AI models (DINOv2, EuroSAT, EarthView, S2-NAIP) 
-        to predict geographic coordinates from aerial and satellite images.
-        """)
-        
-        with gr.Tab("📍 Single Image Analysis"):
-            with gr.Row():
-                with gr.Column():
-                    single_image = gr.Image(
-                        type="filepath", 
-                        label="Upload Aerial/Satellite Image",
-                        height=400
-                    )
-                    single_btn = gr.Button("Predict Coordinates", variant="primary")
-                
-                with gr.Column():
-                    single_output = gr.JSON(
-                        label="Prediction Results",
-                        show_label=True
-                    )
-                    single_map = gr.HTML(label="Interactive Map")
-            
-            single_btn.click(
-                fn=app.process_single_image,
-                inputs=single_image,
-                outputs=[single_output]
-            ).then(
-                fn=lambda result: app.visualizer.create_interactive_map([result]) if 'error' not in result else None,
-                inputs=single_output,
-                outputs=single_map
-            )
-        
-        with gr.Tab("📊 Batch Processing"):
-            with gr.Row():
-                with gr.Column():
-                    batch_files = gr.File(
-                        file_count="multiple",
-                        file_types=[".jpg", ".jpeg", ".png", ".tiff"],
-                        label="Upload Multiple Images"
-                    )
-                    batch_btn = gr.Button("Process Batch", variant="primary")
-                
-                with gr.Column():
-                    batch_summary = gr.JSON(label="Batch Summary")
-                    batch_map = gr.HTML(label="Batch Results Map")
-                    batch_analysis = gr.Image(label="Statistical Analysis", show_label=True)
-            
-            batch_btn.click(
-                fn=app.process_batch_images,
-                inputs=batch_files,
-                outputs=[batch_summary]
-            ).then(
-                fn=lambda result: result.get('map_path') if result else None,
-                inputs=batch_summary,
-                outputs=batch_map
-            ).then(
-                fn=lambda result: result.get('analysis_path') if result else None,
-                inputs=batch_summary,
-                outputs=batch_analysis
-            )
-        
-        with gr.Tab("📈 Results & Export"):
-            with gr.Row():
-                with gr.Column():
-                    export_format = gr.Radio(
-                        choices=['geojson', 'csv', 'excel'],
-                        label="Export Format",
-                        value='geojson'
-                    )
-                    export_btn = gr.Button("Export Results", variant="primary")
-                    export_file = gr.File(label="Download Export")
-                
-                with gr.Column():
-                    history_df = gr.Dataframe(
-                        label="Prediction History",
-                        headers=["Latitude", "Longitude", "Region", "Confidence", "Timestamp"],
-                        datatype=["number", "number", "str", "number", "str"],
-                        row_count=10,
-                        col_count=5
-                    )
-                    refresh_btn = gr.Button("Refresh History")
-            
-            export_btn.click(
-                fn=app.export_results,
-                inputs=export_format,
-                outputs=export_file
-            )
-            
-            refresh_btn.click(
-                fn=lambda: pd.DataFrame(app.predictions_history)[
-                    ['latitude', 'longitude', 'predicted_region', 'overall_confidence', 'timestamp']
-                ].tail(20),
-                outputs=history_df
-            )
-        
-        with gr.Tab("🛠️ Model Training"):
-            gr.Markdown("### Model Training Interface")
-            with gr.Row():
-                with gr.Column():
-                    epochs = gr.Slider(1, 50, value=10, label="Training Epochs")
-                    batch_size = gr.Slider(1, 64, value=16, label="Batch Size")
-                    learning_rate = gr.Number(1e-4, label="Learning Rate")
-                    train_btn = gr.Button("Start Training", variant="primary")
-                
-                with gr.Column():
-                    training_output = gr.Textbox(
-                        label="Training Logs",
-                        lines=10,
-                        max_lines=15
-                    )
-            
-            train_btn.click(
-                fn=lambda e, b, lr: f"Training started with:\nEpochs: {e}\nBatch Size: {b}\nLearning Rate: {lr}\n\nThis would start actual training in production.",
-                inputs=[epochs, batch_size, learning_rate],
-                outputs=training_output
-            )
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        ### 🔧 Technical Specifications
-        
-        - **Backbone Model**: DINOv2 Base
-        - **Training Datasets**: EarthView, EuroSAT, S2-NAIP
-        - **Output**: Coordinates (Lat/Lon) with uncertainty estimation
-        - **Features**: Regional classification, confidence scoring, batch processing
-        - **Export Formats**: GeoJSON, CSV, Excel
-        
-        *Built for professional geospatial analysis and research*
-        """)
-    
-    return demo
+    # TILE BUL
+    tile_id, tar_id, epsg = latlon_to_tile(lat, lon)
+    print(f"Tile: {tile_id}")
 
-# FastAPI backend (opsiyonel)
-from fastapi import FastAPI, UploadFile, File
-from fastapi.responses import FileResponse
-import uvicorn
+    # GERÇEK S2 GÖRÜNTÜ ÇEK
+    ref_img, ref_transform, ref_crs = fetch_sentinel2_tile(tile_id)
+    if ref_img is None:
+        # DEMO: Rastgele referans
+        ref = np.random.randint(50, 200, (64, 64, 3), dtype=np.uint8)
+        ref_img = Image.fromarray(ref)
+        ref_transform = rasterio.Affine(10, 0, lon*111000, 0, -10, lat*111000)
+        ref_crs = f"EPSG:{epsg}"
 
-app_fastapi = FastAPI(title="AI Geo-Referencing API")
+    # DINOv2 EŞLEŞTİRME
+    inputs = processor(images=[Image.fromarray(image), ref_img], return_tensors="pt").to(device)
+    with torch.no_grad():
+        feats = model(**inputs).last_hidden_state[:, 0]
+        sim = torch.cosine_similarity(feats[0], feats[1], dim=0).item()
 
-geo_system = ProfessionalGeoReferencingSystem()
+    # HOMOGRAFI (Demo: sabit)
+    H = np.array([[1.0, 0.0, 30], [0.0, 1.0, 20], [0.0, 0.0, 1.0]])
 
-@app_fastapi.post("/predict")
-async def predict_coordinates(file: UploadFile = File(...)):
-    """API endpoint for coordinate prediction"""
-    try:
-        # Geçici dosyaya kaydet
-        with tempfile.NamedTemporaryFile(delete=False) as tmp:
-            content = await file.read()
-            tmp.write(content)
-            tmp_path = tmp.name
-        
-        # Tahmin yap
-        result = geo_system.predict(tmp_path)
-        
-        # Temizlik
-        os.unlink(tmp_path)
-        
-        return result
-    except Exception as e:
-        return {"error": str(e)}
+    # WARP
+    h, w = image.shape[:2]
+    output_tif = "georef_output.tif"
+    profile = {
+        'driver': 'GTiff', 'height': h, 'width': w, 'count': 3, 'dtype': 'uint8',
+        'crs': ref_crs, 'transform': ref_transform
+    }
+    warped = np.stack([image[:,:,i] for i in range(3)])
+    with rasterio.open(output_tif, 'w', **profile) as dst:
+        dst.write(warped)
 
-@app_fastapi.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+    # GCP
+    points_file = "gcp.points"
+    with open(points_file, 'w') as f:
+        f.write("mapX,mapY,pixelX,pixelY,enable\n")
+        for px, py in [(0,0), (w-1,0), (w-1,h-1), (0,h-1)]:
+            mx, my = ref_transform * (px, py)
+            f.write(f"{mx:.2f},{my:.2f},{px},{py},1\n")
 
-if __name__ == "__main__":
-    # Gradio arayüzünü başlat
-    demo = create_gradio_interface()
-    
-    # Hugging Face Spaces için
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        debug=True
+    return (
+        output_tif,
+        points_file,
+        ref_img,
+        f"**BAŞARILI!**\n"
+        f"**Konum:** {loc_key.title()}\n"
+        f"**Tile:** `{tile_id}`\n"
+        f"**Eşleşme:** {sim:.1%}\n"
+        f"**Cihaz:** {device}"
     )
-    
-    # Alternatif: FastAPI başlatma
-    # uvicorn.run(app_fastapi, host="0.0.0.0", port=8000)
+
+# GRADIO UI
+with gr.Blocks() as demo:
+    gr.Markdown("# AI Georeferencer – S2-NAIP")
+    gr.Markdown("**ABD geneli gerçek uydu verisi!**")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Image(label="Harita", type="numpy")
+            gr.Textbox(label="Konum", placeholder="seattle, whiskeytown, la, nyc", value="seattle")
+            gr.Button("Jeoreferansla").click(
+                georeference,
+                [gr.State(), gr.State()],
+                [gr.File(), gr.File(), gr.Image(), gr.Markdown()]
+            )
+        with gr.Column():
+            gr.Image(label="Sentinel-2 Referans")
+            gr.Markdown()
+
+demo.launch()