Update app.py

app.py

@@ -1,376 +1,105 @@
-# app.py - Orta Ölçek Jeo-Referanslama
-import torch
-import torch.nn as nn
-from transformers import AutoModel, AutoImageProcessor
-from datasets import load_dataset
-import torchvision.transforms as transforms
+import gradio as gr
 from PIL import Image
 import numpy as np
-import gradio as gr
-import matplotlib.pyplot as plt
-import folium
-import tempfile
-import os
-from tqdm import tqdm
+import random
 import json
 
-class MediumScaleGeoSystem:
+class UltraLightGeoDemo:
     def __init__(self):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Cihaz: {self.device}")
-        
-        # Hafif model - DINOv2-small
-        self.model_name = "facebook/dinov2-small"
-        self.processor = AutoImageProcessor.from_pretrained(self.model_name)
-        self.backbone = AutoModel.from_pretrained(self.model_name).to(self.device)
-        
-        # Regression head
-        self.regressor = nn.Sequential(
-            nn.Linear(384, 256),  # small model 384 feature
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(256, 128),
-            nn.ReLU(),
-            nn.Linear(128, 2)  # lat, lon
-        ).to(self.device)
-        
-        self.transform = transforms.Compose([
-            transforms.Resize((224, 224)),
-            transforms.ToTensor(),
-            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
-                               std=[0.229, 0.224, 0.225])
-        ])
-        
-        # Dataset cache - sadece küçük kısmı
-        self.dataset = None
-        self.load_medium_dataset()
+        self.dataset_info = "S2-NAIP Demo - Gerçek model yüklenmedi"
     
-    def load_medium_dataset(self, num_samples=2000):
-        """Orta ölçekte dataset yükle (1-2GB)"""
+    def predict_coordinates(self, image):
+        """Demo tahmin - model yüklemeden"""
         try:
-            print(f"{num_samples} örnek yükleniyor...")
-            self.dataset = load_dataset(
-                "allenai/s2-naip", 
-                split=f"train[:{num_samples}]",
-                streaming=False  # Küçük olduğu için memory'de tut
-            )
-            print(f"Dataset yüklendi: {len(self.dataset)} örnek")
+            # Rastgele koordinatlar (demo amaçlı)
+            lat = round(random.uniform(36.0, 42.0), 4)  # Türkiye
+            lon = round(random.uniform(26.0, 45.0), 4)
             
-            # Dataset istatistikleri
-            self.analyze_dataset()
+            # Basit güven skoru
+            confidence = round(random.uniform(0.3, 0.9), 2)
             
-        except Exception as e:
-            print(f"Dataset yükleme hatası: {e}")
-            self.dataset = None
-    
-    def analyze_dataset(self):
-        """Dataset analizi"""
-        if self.dataset is None:
-            return
-            
-        print("\n=== Dataset Analizi ===")
-        print(f"Toplam örnek: {len(self.dataset)}")
-        
-        # Koordinat istatistikleri
-        lats, lons = [], []
-        for i in range(min(100, len(self.dataset))):
-            sample = self.dataset[i]
-            if 'lat' in sample and 'lon' in sample:
-                lats.append(sample['lat'])
-                lons.append(sample['lon'])
-        
-        if lats:
-            print(f"Enlem aralığı: {min(lats):.2f} - {max(lats):.2f}")
-            print(f"Boylam aralığı: {min(lons):.2f} - {max(lons):.2f}")
-            print(f"Koordinatlı örnek: {len(lats)}")
-    
-    def prepare_training_data(self, num_samples=1000):
-        """Eğitim verisi hazırla"""
-        if self.dataset is None:
-            return None, None
+            result = {
+                'latitude': lat,
+                'longitude': lon, 
+                'confidence': confidence,
+                'note': 'BU BİR DEMO TAHMİNDİR - Gerçek model eğitilmemiştir',
+                'next_step': 'Gerçek eğitim için Kaggle kullanın: https://kaggle.com'
+            }
             
-        images = []
-        coordinates = []
-        
-        print("Eğitim verisi hazırlanıyor...")
-        for i in tqdm(range(min(num_samples, len(self.dataset)))):
-            sample = self.dataset[i]
+            return result
             
-            try:
-                # Sentinel-2 görüntüsünü kullan
-                img = sample['sentinel']
-                if img.mode != 'RGB':
-                    img = img.convert('RGB')
-                
-                img_tensor = self.transform(img)
-                images.append(img_tensor)
-                
-                # Koordinatları normalize et
-                lat = sample.get('lat', 0.0)
-                lon = sample.get('lon', 0.0)
-                
-                # Normalize: [-90,90] -> [-1,1], [-180,180] -> [-1,1]
-                lat_norm = lat / 90.0
-                lon_norm = lon / 180.0
-                
-                coordinates.append([lat_norm, lon_norm])
-                
-            except Exception as e:
-                continue
-        
-        if len(images) == 0:
-            return None, None
-            
-        images_tensor = torch.stack(images)
-        coords_tensor = torch.tensor(coordinates, dtype=torch.float32)
-        
-        print(f"Eğitim verisi: {len(images_tensor)} örnek")
-        return images_tensor, coords_tensor
-    
-    def train(self, epochs=3, batch_size=16, learning_rate=1e-4):
-        """Model eğitimi"""
-        if self.dataset is None:
-            return {"error": "Dataset yüklenemedi"}
-        
-        # Eğitim verisini hazırla
-        images, coords = self.prepare_training_data(800)  # 800 örnekle eğit
-        if images is None:
-            return {"error": "Eğitim verisi hazırlanamadı"}
-        
-        # Optimizer
-        optimizer = torch.optim.AdamW(
-            list(self.regressor.parameters()) + list(self.backbone.parameters()),
-            lr=learning_rate,
-            weight_decay=1e-4
-        )
-        criterion = nn.MSELoss()
-        
-        losses = []
-        self.backbone.train()
-        self.regressor.train()
-        
-        print("Model eğitimi başlıyor...")
-        for epoch in range(epochs):
-            epoch_loss = 0
-            num_batches = 0
-            
-            for i in range(0, len(images), batch_size):
-                batch_images = images[i:i+batch_size].to(self.device)
-                batch_coords = coords[i:i+batch_size].to(self.device)
-                
-                # Forward pass
-                optimizer.zero_grad()
-                
-                # Özellik çıkarımı
-                features = self.backbone(batch_images).last_hidden_state
-                features = features.mean(dim=1)
-                
-                # Tahmin
-                pred_coords = self.regressor(features)
-                loss = criterion(pred_coords, batch_coords)
-                
-                # Backward pass
-                loss.backward()
-                optimizer.step()
-                
-                epoch_loss += loss.item()
-                num_batches += 1
-            
-            avg_loss = epoch_loss / num_batches if num_batches > 0 else 0
-            losses.append(avg_loss)
-            print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.6f}")
-        
-        # Modeli kaydet
-        self.save_model()
-        return {"success": True, "final_loss": avg_loss, "losses": losses}
-    
-    def predict(self, image):
-        """Görüntüden koordinat tahmini"""
-        try:
-            # Görüntüyü işle
-            if isinstance(image, str):
-                image = Image.open(image).convert('RGB')
-            elif isinstance(image, np.ndarray):
-                image = Image.fromarray(image.astype('uint8')).convert('RGB')
-            
-            image_tensor = self.transform(image).unsqueeze(0).to(self.device)
-            
-            with torch.no_grad():
-                self.backbone.eval()
-                self.regressor.eval()
-                
-                # Özellik çıkarımı
-                features = self.backbone(image_tensor).last_hidden_state
-                features = features.mean(dim=1)
-                
-                # Tahmin
-                pred_coords = self.regressor(features)
-                pred_coords = pred_coords.cpu().numpy()[0]
-                
-                # Gerçek koordinatlara dönüştür
-                lat = pred_coords[0] * 90.0
-                lon = pred_coords[1] * 180.0
-                
-                # Basit güven skoru
-                confidence = max(0.1, 1.0 - (abs(pred_coords[0]) + abs(pred_coords[1])) / 2)
-                
-                result = {
-                    'latitude': round(lat, 4),
-                    'longitude': round(lon, 4),
-                    'confidence': round(confidence, 2),
-                    'model': 'DINOv2-small',
-                    'dataset_samples': len(self.dataset) if self.dataset else 0
-                }
-                
-                return result
-                
         except Exception as e:
             return {'error': str(e)}
-    
-    def save_model(self):
-        """Modeli kaydet"""
-        try:
-            torch.save({
-                'regressor_state_dict': self.regressor.state_dict(),
-                'backbone_state_dict': self.backbone.state_dict(),
-            }, 'medium_geo_model.pth')
-            print("Model kaydedildi: medium_geo_model.pth")
-        except Exception as e:
-            print(f"Model kaydetme hatası: {e}")
-    
-    def create_map(self, lat, lon):
-        """Harita oluştur"""
-        try:
-            m = folium.Map(location=[lat, lon], zoom_start=10)
-            folium.Marker(
-                [lat, lon],
-                popup=f'Tahmin: {lat}, {lon}',
-                tooltip='Tahmin Edilen Konum'
-            ).add_to(m)
-            
-            with tempfile.NamedTemporaryFile(suffix='.html', delete=False) as tmp:
-                m.save(tmp.name)
-                return tmp.name
-        except Exception as e:
-            print(f"Harita oluşturma hatası: {e}")
-            return None
 
-# Gradio Arayüzü
-def create_interface():
-    geo_system = MediumScaleGeoSystem()
+# Gradio arayüzü
+def create_demo_interface():
+    demo = UltraLightGeoDemo()
     
-    with gr.Blocks(title="🌍 Orta Ölçek Jeo-Referanslama", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="🌍 Jeo-Referanslama Demo", theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
-        # 🌍 Orta Ölçek Jeo-Referanslama
-        **S2-NAIP datasetinin 2000 örneği ile AI koordinat tahmini**
+        # 🌍 Jeo-Referanslama DEMO
+        **Ultra Hafif Sürüm - Gerçek model olmadan çalışır**
         
-        Bu sistem, 5GB'lık S2-NAIP datasetinin küçük bir kısmını kullanarak eğitilmiştir.
+        *Not: Bu bir demo uygulamasıdır. Gerçek model eğitimi için aşağıdaki Kaggle bağlantısını kullanın.*
         """)
         
-        with gr.Tab("🎯 Tekil Tahmin"):
-            with gr.Row():
-                with gr.Column():
-                    image_input = gr.Image(
-                        type="filepath", 
-                        label="Uydu Görüntüsü Yükle",
-                        height=300
-                    )
-                    predict_btn = gr.Button("📍 Koordinatları Tahmin Et", variant="primary")
-                
-                with gr.Column():
-                    output_json = gr.JSON(label="Tahmin Sonuçları")
-                    map_output = gr.HTML(label="Harita Görünümü")
-            
-            def process_prediction(image):
-                result = geo_system.predict(image)
-                if 'error' not in result:
-                    map_path = geo_system.create_map(result['latitude'], result['longitude'])
-                    if map_path:
-                        with open(map_path, 'r') as f:
-                            map_html = f.read()
-                        os.unlink(map_path)
-                        return result, map_html
-                return result, "<p>Harita oluşturulamadı</p>"
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(
+                    type="filepath",
+                    label="Uydu Görüntüsü Yükle",
+                    height=300
+                )
+                predict_btn = gr.Button("📍 Demo Tahmin Yap", variant="primary")
             
-            predict_btn.click(
-                fn=process_prediction,
-                inputs=image_input,
-                outputs=[output_json, map_output]
-            )
+            with gr.Column():
+                output_json = gr.JSON(label="Tahmin Sonuçları")
         
-        with gr.Tab("🛠️ Model Eğitimi"):
-            with gr.Row():
-                with gr.Column():
-                    epochs = gr.Slider(1, 10, value=3, label="Epoch Sayısı")
-                    batch_size = gr.Slider(8, 32, value=16, step=8, label="Batch Size")
-                    train_btn = gr.Button("🚀 Modeli Eğit", variant="primary")
-                
-                with gr.Column():
-                    train_output = gr.JSON(label="Eğitim Sonuçları")
-                    loss_plot = gr.Plot(label="Kayıp Grafiği")
-            
-            def train_model(epochs, batch_size):
-                result = geo_system.train(epochs=int(epochs), batch_size=int(batch_size))
-                
-                if 'losses' in result:
-                    # Kayıp grafiği oluştur
-                    plt.figure(figsize=(10, 6))
-                    plt.plot(result['losses'])
-                    plt.title('Eğitim Kaybı')
-                    plt.xlabel('Epoch')
-                    plt.ylabel('Loss')
-                    plt.grid(True)
-                    
-                    return result, plt
-                
-                return result, None
-            
-            train_btn.click(
-                fn=train_model,
-                inputs=[epochs, batch_size],
-                outputs=[train_output, loss_plot]
-            )
+        # Kaggle bağlantısı
+        gr.Markdown("""
+        ---
+        ## 🚀 Gerçek Model İçin Kaggle'a Git:
+        
+        **[👉 KAGGLE'DA TAM SİSTEMİ ÇALIŞTIR](https://kaggle.com)**
+        
+        **Kaggle'da yapman gerekenler:**
+        1. Yukarıdaki bağlantıya tıkla
+        2. "Notebooks" → "New Notebook"
+        3. "Settings" → "GPU" seç
+        4. Aşağıdaki kodu yapıştır
+        """)
         
-        with gr.Tab("📊 Dataset Bilgisi"):
+        # Kaggle kodu
+        with gr.Accordion("📋 Kaggle İçin Hazır Kod", open=False):
             gr.Markdown("""
-            ### S2-NAIP Dataset (Orta Ölçek)
+            ```python
+            # Kaggle'da çalıştıracak tam kod
+            !pip install torch transformers datasets torchvision tqdm
             
-            **Kullanılan:** 2000 örnek (~1-2GB)
+            import torch
+            from transformers import AutoModel
+            from datasets import load_dataset
             
-            **Özellikler:**
-            - Sentinel-2 (10m çözünürlük) görüntüleri
-            - NAIP (1m çözünürlük) görüntüleri
-            - Koordinat metadata'sı
-            - ABD genelinde çeşitli lokasyonlar
+            # TAM S2-NAIP datasetini yükle (5GB)
+            dataset = load_dataset("allenai/s2-naip", split="train")
+            print(f"Tam dataset: {len(dataset)} örnek")
             
-            **Model:** DINOv2-small (Hafif)
-            - Özellik boyutu: 384
-            - Giriş çözünürlük: 224x224
-            - Çıktı: Enlem, Boylam
+            # GPU kullan
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            model = AutoModel.from_pretrained("facebook/dinov2-small").to(device)
             
-            **Performans Beklentisi:**
-            - Eğitim süresi: 5-15 dakika
-            - Model boyutu: ~150MB
-            - Tahmin süresi: <1 saniye
+            print("Gerçek eğitim başlayabilir!")
+            ```
             """)
-            
-            # Dataset istatistikleri
-            if geo_system.dataset:
-                gr.Markdown(f"""
-                **Yüklenen Örnek:** {len(geo_system.dataset)}
-                """)
         
-        gr.Markdown("""
-        ---
-        ⚡ **Not:** Bu orta ölçekli sistem Hugging Face Spaces'te çalışacak şekilde optimize edilmiştir.
-        """)
+        predict_btn.click(
+            fn=demo.predict_coordinates,
+            inputs=image_input,
+            outputs=output_json
+        )
     
-    return demo
+    return interface
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+    demo = create_demo_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)