QuakeAware_AI_Roadmap.md

# QuakeAware AI – Aşırı Anlaşılır ve Detaylı Geliştirme Yol Haritası

## İçindekiler

1. [Giriş](#giriş)
2. [Proje Hazırlık Aşaması](#1-proje-hazırlık-aşaması-1-2-hafta)
3. [Yapay Zekaya Talimat Verme Stratejisi](#2-yapay-zekaya-talimat-verme-stratejisi-1-hafta)
4. [Modül Geliştirme Aşaması](#3-modül-geliştirme-aşaması-4-6-hafta)
5. [Entegrasyon ve Test Aşaması](#4-entegrasyon-ve-test-aşaması-2-hafta)
6. [Dağıtım ve Yayınlama](#5-dağıtım-ve-yayınlama-1-hafta)
7. [Bakım ve Geliştirme](#6-bakım-ve-geliştirme-sürekli)
8. [Yapay Zeka ile İletişim İpuçları](#7-yapay-zeka-ile-iletişim-ipuçları)
9. [Zaman Çizelgesi ve Kilometre Taşları](#8-zaman-çizelgesi-ve-kilometre-taşları)
10. [Kod Örnekleri ve Şablonlar](#kod-örnekleri-ve-şablonlar)
11. [Potansiyel Sorunlar ve Çözümleri](#potansiyel-sorunlar-ve-çözümleri)
12. [Kaynaklar ve Referanslar](#9-kaynaklar-ve-referanslar)
13. [Sonuç](#10-sonuç)

## Giriş

Bu doküman, QuakeAware AI projesinin bir yapay zeka tarafından geliştirilmesi için detaylı bir yol haritası sunmaktadır. Proje, deprem risk analizi, güvenli nokta önerisi ve farkındalık panosu içeren kapsamlı bir yapay zeka çözümüdür. Bu yol haritası, başlangıç seviyesindeki bir kullanıcının 4GB RTX4050 Ti GPU kullanarak projeyi bir yapay zekaya nasıl geliştirtebileceğini adım adım açıklamaktadır.

QuakeAware AI projesi dört ana bileşenden oluşmaktadır:

1. **Görsel Güvenli-Nokta Analizi:** Kullanıcı odasının fotoğrafını yükler, model olası devrilme/çarpma tehlikesi taşıyan eşyaları işaretler ve en güvenli konumu renkle vurgular.

2. **Adres Tabanlı Deprem Risk Skoru:** AFAD/USGS sarsıntı kayıtları, yerel zemin türü, bina yaşı/kat sayısı gibi girdilerle LightGBM/XGBoost modelinden 0-1 arası "Göreceli Risk" çıktısı.

3. **Gerçek-Zamanlı Sarsıntı Takip Paneli:** Son 12 saatteki deprem verilerini çek (AFAD açık API), Leaflet haritasına pin'le, LLM tabanlı RAG botu "Bu depremi hissettim, ne yapmalıyım?" sorularına yanıt versin.

4. **Hazırlık Rehberi Chatbot'u:** Kullanıcıya kişiselleştirilmiş deprem çantası önerisi, bina güçlendirme ipuçları, acil toplanma alanı linki sunar.

Bu bileşenler tek bir Gradio arayüzünde sekmelere ayrılarak Hugging Face Space olarak paylaşılacaktır.

## 1. Proje Hazırlık Aşaması (1-2 Hafta)

### 1.1. Geliştirme Ortamının Kurulumu

- **Yapay Zeka Seçimi:**
  - GPT-4 veya Claude gibi gelişmiş bir yapay zeka modeli seçin
  - GitHub Copilot veya Amazon CodeWhisperer gibi kod asistanlarını değerlendirin
  - Hugging Face Spaces'i proje geliştirme platformu olarak kullanın

- **Yerel Geliştirme Ortamı:**
  - Python 3.10+ kurulumu
  - Conda veya venv ile izole bir ortam oluşturma
  - Git kurulumu ve temel komutların öğrenilmesi
  - VS Code veya PyCharm gibi bir IDE kurulumu

- **GPU Optimizasyonu:**
  - CUDA ve cuDNN kurulumu (RTX4050 Ti için uygun sürüm)
  - PyTorch veya TensorFlow'un GPU destekli sürümlerinin kurulumu
  - GPU bellek kullanımını optimize etmek için stratejiler (model küçültme, düşük hassasiyetli veri tipleri)

### 1.2. Veri Toplama ve Hazırlama

- **ADE20K Veri Seti:**
  - Veri setini indirme ve yapılandırma
  - İç mekan görüntülerini filtreleme
  - Etiketlerin deprem güvenliği perspektifinden yeniden sınıflandırılması

- **Deprem Verileri:**
  - AFAD API'sine erişim için hesap oluşturma
  - Geçmiş deprem verilerini indirme ve temizleme
  - Zemin türü ve bina bilgilerini içeren veri setlerini toplama

- **Eğitim Materyalleri:**
  - Deprem güvenliği ile ilgili PDF'ler ve dokümanlar (AFAD, Kızılay, FEMA)
  - RAG chatbot için vektör veritabanı oluşturma materyalleri

## 2. Yapay Zekaya Talimat Verme Stratejisi (1 Hafta)

### 2.1. Proje Tanımlama ve Görev Bölümleme

- **Proje Tanımı:**
  ```
  "QuakeAware AI adlı bir deprem güvenliği yapay zeka projesi geliştirmek istiyorum. Bu proje dört ana bileşenden oluşacak: görsel güvenli-nokta analizi, adres tabanlı risk skoru, gerçek-zamanlı sarsıntı takibi ve hazırlık rehberi chatbot'u. Projeyi adım adım geliştirmeme yardımcı olur musun?"
  ```

- **Görev Bölümleme:**
  ```
  "Projeyi şu modüllere ayıralım ve sırayla geliştirelim:
  1. Temel proje yapısı ve Gradio arayüzü
  2. Görsel analiz modülü (YOLOv8 ile tehlikeli obje tespiti)
  3. AFAD API entegrasyonu ve harita görselleştirmesi
  4. Risk skoru modeli
  5. RAG chatbot sistemi
  Her modül için ayrı ayrı yardım isteyeceğim."
  ```

### 2.2. Etkili Prompt Mühendisliği

- **Açık ve Net Talimatlar:**
  ```
  "Şimdi görsel analiz modülünü geliştirmek istiyorum. YOLOv8 modelini kullanarak bir odadaki tehlikeli objeleri tespit eden ve işaretleyen bir sistem oluşturmak istiyorum. Bunun için:
  1. YOLOv8 modelini nasıl kuracağımı
  2. ADE20K veri setini nasıl kullanacağımı
  3. Tehlikeli objeleri nasıl tespit edeceğimi
  4. Sonuçları nasıl görselleştireceğimi
  adım adım açıklar mısın?"
  ```

- **Bağlam Sağlama:**
  ```
  "4GB GPU'ya sahibim ve modelleri bu sınırlı bellek içinde çalıştırmam gerekiyor. Ayrıca başlangıç seviyesindeyim, bu yüzden açıklamaların detaylı olması ve teknik jargonu minimum düzeyde tutman önemli."
  ```

- **İteratif Geliştirme:**
  ```
  "Yazdığın kodu test ettim ve şu hatayla karşılaştım: [HATA MESAJI]. Bu sorunu nasıl çözebiliriz?"
  ```

## 3. Modül Geliştirme Aşaması (4-6 Hafta)

### 3.1. Temel Proje Yapısı (1 Hafta)

- **Yapay Zekaya Talimat:**
  ```
  "QuakeAware AI projesi için temel dizin yapısını oluşturmak ve Gradio arayüzünü kurmak istiyorum. Proje yapısı dokümanımda belirtildiği gibi olmalı. Gradio arayüzü dört sekme içermeli: Görsel Analiz, Adres Risk Skoru, Canlı Depremler ve Hazırlık Sohbeti. Başlangıç için bu sekmelerin boş olması sorun değil, sadece yapıyı kurmak istiyorum."
  ```

- **Geliştirme Adımları:**
  1. Proje dizin yapısını oluşturma
  2. Gerekli kütüphaneleri içeren requirements.txt dosyası hazırlama
  3. Temel Gradio arayüzünü oluşturma
  4. Modüller için iskelet kodları yazma
  5. Yerel test ve hata ayıklama

### 3.2. Görsel Analiz Modülü (1-2 Hafta)

- **Yapay Zekaya Talimat:**
  ```
  "Görsel analiz modülünü geliştirmek istiyorum. Bu modül, kullanıcının yüklediği oda fotoğrafında:
  1. YOLOv8 ile tehlikeli objeleri (dolaplar, raflar, ağır eşyalar) tespit etmeli
  2. Bu objeleri işaretlemeli
  3. Segment Anything Model (SAM) ile en güvenli alanı belirlemeli
  4. Sonucu görselleştirmeli
  
  4GB GPU'mda çalışabilecek şekilde optimize edilmiş bir çözüm istiyorum. ADE20K veri setini nasıl kullanabileceğimi de açıklar mısın?"
  ```

- **Geliştirme Adımları:**
  1. YOLOv8 modelini kurma ve optimize etme
  2. ADE20K veri setinden iç mekan görüntülerini filtreleme
  3. Tehlikeli obje sınıflarını belirleme ve model eğitimi/fine-tuning
  4. SAM modelini entegre etme ve hafif versiyonunu kullanma
  5. Güvenli alan algoritmasını geliştirme
  6. Gradio arayüzüne entegrasyon

### 3.3. AFAD API ve Harita Entegrasyonu (1 Hafta)

- **Yapay Zekaya Talimat:**
  ```
  "AFAD'ın son depremler API'sini kullanarak gerçek zamanlı bir deprem haritası oluşturmak istiyorum. Bu harita:
  1. Son 12 saatteki depremleri göstermeli
  2. Depremleri büyüklüklerine göre farklı renklerle işaretlemeli
  3. Kullanıcı tıkladığında deprem detaylarını göstermeli
  4. Düzenli olarak otomatik yenilenmeli
  
  Folium veya Leaflet kullanarak bunu nasıl yapabilirim?"
  ```

- **Geliştirme Adımları:**
  1. AFAD API'sine bağlantı kurma
  2. JSON verilerini işleme ve temizleme
  3. Harita görselleştirme kütüphanesini kurma
  4. Deprem verilerini haritaya işleme
  5. Otomatik yenileme mekanizması oluşturma
  6. Gradio arayüzüne entegrasyon

### 3.4. Risk Skoru Modeli (1-2 Hafta)

- **Yapay Zekaya Talimat:**
  ```
  "Adres tabanlı bir deprem risk skoru modeli geliştirmek istiyorum. Bu model:
  1. Kullanıcının girdiği adres veya il/ilçe bilgisini almalı
  2. Geçmiş deprem verileri, zemin türü ve bina bilgilerini kullanmalı
  3. LightGBM veya XGBoost ile 0-1 arası bir risk skoru üretmeli
  4. Sonucu açıklamalı bir şekilde göstermeli
  
  Veri kaynaklarını nasıl birleştirebilirim ve modeli nasıl eğitebilirim?"
  ```

- **Geliştirme Adımları:**
  1. Veri kaynaklarını toplama ve birleştirme
  2. Adres → koordinat dönüşümü için geocoding servisi entegrasyonu
  3. Özellik mühendisliği ve veri hazırlama
  4. Model seçimi ve hiperparametre optimizasyonu
  5. Model eğitimi ve değerlendirme
  6. Gradio arayüzüne entegrasyon

### 3.5. RAG Chatbot Sistemi (1-2 Hafta)

- **Yapay Zekaya Talimat:**
  ```
  "Deprem hazırlığı konusunda bilgi veren bir RAG (Retrieval Augmented Generation) chatbot geliştirmek istiyorum. Bu chatbot:
  1. AFAD, Kızılay ve FEMA dokümanlarından bilgi içermeli
  2. Llama-3-Instruct-8B-Q modelini 4GB GPU'mda çalışacak şekilde optimize etmeli
  3. Kullanıcı sorularına doğru ve kapsamlı yanıtlar vermeli
  4. Kişiselleştirilmiş deprem çantası önerileri sunabilmeli
  
  Vektör veritabanını nasıl oluşturabilirim ve modeli nasıl optimize edebilirim?"
  ```

- **Geliştirme Adımları:**
  1. Dokümanları toplama ve ön işleme
  2. Vektör veritabanı oluşturma (FAISS)
  3. Llama-3 modelini optimize etme (quantization, LoRA)
  4. RAG sistemini kurma (LangChain veya benzeri)
  5. Soru-cevap mekanizmasını geliştirme
  6. Gradio arayüzüne entegrasyon

## 4. Entegrasyon ve Test Aşaması (2 Hafta)

### 4.1. Modül Entegrasyonu

- **Yapay Zekaya Talimat:**
  ```
  "Geliştirdiğimiz dört modülü (görsel analiz, harita, risk skoru ve chatbot) tek bir Gradio uygulamasında birleştirmek istiyorum. Modüller arasında veri paylaşımı olmalı mı? Örneğin, kullanıcının adresi risk skoru ve harita arasında paylaşılabilir mi? Entegrasyonu nasıl yapabilirim?"
  ```

- **Geliştirme Adımları:**
  1. Modülleri tek bir Gradio uygulamasında birleştirme
  2. Modüller arası veri paylaşımı mekanizmaları oluşturma
  3. Kullanıcı deneyimini iyileştirme (UI/UX)
  4. Performans optimizasyonu
  5. Hata yakalama ve işleme mekanizmaları ekleme

### 4.2. Kapsamlı Test

- **Yapay Zekaya Talimat:**
  ```
  "QuakeAware AI uygulamasını kapsamlı bir şekilde test etmek istiyorum. Her modül için test senaryoları neler olmalı? Performans darboğazlarını nasıl tespit edebilirim? 4GB GPU'mda tüm sistemin sorunsuz çalışması için nelere dikkat etmeliyim?"
  ```

- **Test Adımları:**
  1. Birim testleri yazma
  2. Entegrasyon testleri yapma
  3. Performans testleri ve darboğaz analizi
  4. Kullanıcı arayüzü testleri
  5. Farklı giriş senaryolarıyla test
  6. Hata senaryolarını test etme

## 5. Dağıtım ve Yayınlama (1 Hafta)

### 5.1. Hugging Face Space Dağıtımı

- **Yapay Zekaya Talimat:**
  ```
  "QuakeAware AI projemi Hugging Face Space'e yüklemek istiyorum. Bunun için:
  1. Gerekli dosyaları nasıl hazırlamalıyım?
  2. requirements.txt dosyası nasıl olmalı?
  3. Büyük modelleri nasıl optimize etmeliyim?
  4. Dağıtım sürecini adım adım açıklar mısın?"
  ```

- **Dağıtım Adımları:**
  1. Hugging Face hesabı oluşturma
  2. Space için gerekli dosyaları hazırlama
  3. requirements.txt dosyasını optimize etme
  4. Modelleri küçültme ve optimize etme
  5. Gradio uygulamasını yapılandırma
  6. Space'e yükleme ve test etme

### 5.2. Dokümantasyon ve Kullanım Kılavuzu

- **Yapay Zekaya Talimat:**
  ```
  "QuakeAware AI projesi için bir README.md dosyası ve kullanım kılavuzu hazırlamak istiyorum. Bu dokümantasyon:
  1. Projenin amacını ve özelliklerini açıklamalı
  2. Kurulum ve kullanım talimatlarını içermeli
  3. Her modülün nasıl kullanılacağını detaylandırmalı
  4. Sık sorulan sorulara yanıt vermeli
  
  Nasıl bir dokümantasyon hazırlamalıyım?"
  ```

- **Dokümantasyon Adımları:**
  1. README.md dosyası hazırlama
  2. Kurulum talimatları yazma
  3. Kullanım kılavuzu oluşturma
  4. Ekran görüntüleri ve örnekler ekleme
  5. Sık sorulan sorular bölümü hazırlama
  6. Katkı sağlama rehberi ekleme

## 6. Bakım ve Geliştirme (Sürekli)

### 6.1. Geri Bildirim ve İyileştirme

- **Yapay Zekaya Talimat:**
  ```
  "QuakeAware AI projesi için kullanıcı geri bildirimleri toplamak ve projeyi sürekli iyileştirmek istiyorum. Bunun için:
  1. Nasıl bir geri bildirim mekanizması kurmalıyım?
  2. Geri bildirimleri nasıl değerlendirmeliyim?
  3. İyileştirmeleri nasıl önceliklendirmeliyim?
  
  Sürdürülebilir bir geliştirme süreci için önerilerin neler?"
  ```

- **Bakım Adımları:**
  1. Geri bildirim formu ekleme
  2. Hata takip sistemi kurma
  3. Kullanıcı davranışlarını analiz etme
  4. Düzenli güncellemeler planlama
  5. Topluluk katılımını teşvik etme

### 6.2. Model Güncellemeleri

- **Yapay Zekaya Talimat:**
  ```
  "QuakeAware AI'daki modelleri düzenli olarak güncellemek istiyorum. Yeni deprem verileri geldikçe risk modelini, yeni dokümanlar eklendikçe RAG sistemini güncellemek için otomatik bir süreç kurabilir miyim? Bu güncellemeleri nasıl yönetmeliyim?"
  ```

- **Güncelleme Adımları:**
  1. Otomatik veri toplama mekanizmaları kurma
  2. Model yeniden eğitim süreçleri oluşturma
  3. A/B testleri yapma
  4. Sürüm kontrol sistemi kurma
  5. Değişiklik günlüğü tutma

## 7. Yapay Zeka ile İletişim İpuçları

### 7.1. Etkili İletişim Stratejileri

- **Açık ve Net Olun:**
  - Her talimatı tek bir görev etrafında yapılandırın
  - Karmaşık görevleri daha küçük, yönetilebilir parçalara bölün
  - Teknik jargonu azaltın ve açık bir dil kullanın

- **Bağlam Sağlayın:**
  - Projenin genel amacını ve hedeflerini belirtin
  - Kısıtlamaları ve gereksinimleri açıkça belirtin (4GB GPU gibi)
  - Önceki çalışmaları ve mevcut durumu özetleyin

- **İteratif Çalışın:**
  - Büyük kod bloklarını tek seferde istemek yerine, adım adım ilerleyin
  - Her adımdan sonra kodu test edin ve geri bildirim verin
  - Hataları ve sorunları detaylı bir şekilde açıklayın

### 7.2. Yaygın Sorunlar ve Çözümleri

- **Kod Tamamlanmadığında:**
  ```
  "Verdiğin kodun [DOSYA ADI] kısmı tamamlanmamış görünüyor. Lütfen [EKSİK KISIM] bölümünü de tamamlar mısın?"
  ```

- **Hata Aldığınızda:**
  ```
  "Kodunu çalıştırdığımda şu hatayı alıyorum: [HATA MESAJI]. Bu hatanın nedeni ne olabilir ve nasıl çözebiliriz?"
  ```

- **Açıklama İhtiyacı:**
  ```
  "Bu kodun [BÖLÜM] kısmını anlamadım. Bu kısım ne yapıyor ve neden gerekli? Daha detaylı açıklayabilir misin?"
  ```

## 8. Zaman Çizelgesi ve Kilometre Taşları

### 8.1. MVP (Minimum Uygulanabilir Ürün) - 4 Hafta

- **Hafta 1:** Proje yapısı ve Gradio arayüzü
- **Hafta 2:** Basit YOLOv8 entegrasyonu ve tehlikeli obje tespiti
- **Hafta 3:** AFAD API entegrasyonu ve harita görselleştirmesi
- **Hafta 4:** Test, hata ayıklama ve Hugging Face Space'e ilk dağıtım

### 8.2. v0.2 Sürümü - 4 Hafta

- **Hafta 5:** Risk skoru modeli geliştirme
- **Hafta 6:** Basit RAG chatbot entegrasyonu
- **Hafta 7:** Kullanıcı arayüzü iyileştirmeleri
- **Hafta 8:** Test, hata ayıklama ve ikinci dağıtım

### 8.3. v1.0 Sürümü - 4 Hafta

- **Hafta 9:** Segment Anything ile güvenli bölge analizi
- **Hafta 10:** Gelişmiş RAG chatbot (Llama-3 LoRA)
- **Hafta 11:** Kapsamlı test ve optimizasyon
- **Hafta 12:** Final dağıtım, dokümantasyon ve tanıtım

## Kod Örnekleri ve Şablonlar

### Temel Proje Yapısı

#### app.py

```python
import gradio as gr
import os

# Modülleri import et (henüz oluşturulmadı)
# from vision.detector import mark_dangers
# from risk.model import predict_risk
# from stream.afad_feed import get_latest_quakes
# from rag.chatbot import answer

def dummy_vision(image):
    """Geçici görsel analiz fonksiyonu"""
    return image

def dummy_risk(address):
    """Geçici risk skoru fonksiyonu"""
    return 0.5

def dummy_map():
    """Geçici harita fonksiyonu"""
    return "<div>Harita burada görüntülenecek</div>"

def dummy_chat(message):
    """Geçici chatbot fonksiyonu"""
    return f"Sorunuz: {message}. Bu özellik henüz geliştirilme aşamasındadır."

# Ana Gradio uygulaması
with gr.Blocks(title="QuakeAware AI") as demo:
    gr.Markdown("# QuakeAware AI - Deprem Risk Analizi ve Güvenlik Asistanı")
    
    with gr.Tab("Görsel Analiz"):
        gr.Markdown("## Oda Güvenlik Analizi")
        gr.Markdown("Odanızın fotoğrafını yükleyin, tehlikeli eşyaları işaretleyelim ve en güvenli konumu gösterelim.")
        
        with gr.Row():
            in_img = gr.Image(label="Oda Fotoğrafı")
            out_img = gr.Image(label="Analiz Sonucu")
        
        analyze_btn = gr.Button("Analiz Et")
        analyze_btn.click(fn=dummy_vision, inputs=in_img, outputs=out_img)

    with gr.Tab("Adres Risk Skoru"):
        gr.Markdown("## Adres Tabanlı Risk Analizi")
        gr.Markdown("Adresinizi veya il/ilçe bilgisini girin, deprem risk skorunu hesaplayalım.")
        
        addr = gr.Textbox(label="Adres veya İl/İlçe")
        score = gr.Number(label="Göreceli risk (0-1)")
        risk_btn = gr.Button("Risk Hesapla")
        risk_btn.click(fn=dummy_risk, inputs=addr, outputs=score)

    with gr.Tab("Canlı Depremler"):
        gr.Markdown("## Gerçek Zamanlı Deprem Takibi")
        gr.Markdown("Son 12 saatteki depremleri haritada görüntüleyin.")
        
        refresh = gr.Button("Güncelle")
        quake_map = gr.HTML()
        refresh.click(fn=dummy_map, inputs=None, outputs=quake_map)

    with gr.Tab("Hazırlık Sohbeti"):
        gr.Markdown("## Deprem Hazırlık Rehberi")
        gr.Markdown("Deprem hazırlığı konusunda sorularınızı sorun, kişiselleştirilmiş öneriler alın.")
        
        chat_in = gr.Textbox(label="Sorunuz")
        chat_out = gr.Textbox(label="Yanıt")
        chat_btn = gr.Button("Sor")
        chat_btn.click(fn=dummy_chat, inputs=chat_in, outputs=chat_out)

    gr.Markdown("---")
    gr.Markdown("© 2025 QuakeAware AI | Deprem güvenliği için yapay zeka çözümleri")

# Uygulamayı başlat
if __name__ == "__main__":
    demo.launch()
```

#### requirements.txt

```
gradio>=4.0.0
torch>=2.0.0
torchvision>=0.15.0
ultralytics>=8.0.0
segment-anything>=1.0
lightgbm>=3.3.5
xgboost>=1.7.5
folium>=0.14.0
requests>=2.28.2
langchain>=0.0.267
langchain-community>=0.0.10
sentence-transformers>=2.2.2
faiss-cpu>=1.7.4
pydantic>=2.0.0
```

### Görsel Analiz Modülü

#### vision/detector.py

```python
import torch
from ultralytics import YOLO
from PIL import Image, ImageDraw
import numpy as np
import os

# Model yolları
YOLO_MODEL_PATH = os.path.join(os.path.dirname(__file__), "yolov8n.pt")
# SAM modelini daha sonra ekleyeceğiz

# Tehlikeli obje sınıfları (COCO veri setindeki indeksler)
DANGEROUS_CLASSES = {
    "bookcase": 0.9,       # Kitaplık
    "cabinet": 0.8,        # Dolap
    "refrigerator": 0.7,   # Buzdolabı
    "oven": 0.6,           # Fırın
    "tv": 0.5,             # Televizyon
    "microwave": 0.5,      # Mikrodalga
    "chair": 0.3,          # Sandalye
    "couch": 0.4,          # Kanepe
    "bed": 0.4,            # Yatak
    "dining table": 0.6,   # Yemek masası
    "toilet": 0.3,         # Tuvalet
    "sink": 0.3,           # Lavabo
    "clock": 0.2,          # Saat
    "vase": 0.2,           # Vazo
    "scissors": 0.1,       # Makas
    "hair drier": 0.1,     # Saç kurutma makinesi
    "toothbrush": 0.1,     # Diş fırçası
}

class DangerDetector:
    def __init__(self):
        # GPU bellek optimizasyonu
        torch.cuda.empty_cache()
        
        # Model yükleme
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        print(f"Using device: {self.device}")
        
        # YOLOv8 modelini yükle
        if not os.path.exists(YOLO_MODEL_PATH):
            print("Downloading YOLOv8 model...")
            self.model = YOLO("yolov8n.pt")  # Otomatik indirecek
            self.model.save(YOLO_MODEL_PATH)
        else:
            self.model = YOLO(YOLO_MODEL_PATH)
        
        # Modeli GPU'ya taşı ve optimize et
        self.model.to(self.device)
        
        print("Danger detector initialized")
    
    def detect_dangers(self, image):
        """Görüntüdeki tehlikeli objeleri tespit et"""
        # Görüntüyü modele ver
        results = self.model(image, verbose=False)
        
        # Sonuçları işle
        detected_objects = []
        for result in results:
            boxes = result.boxes
            for box in boxes:
                class_id = int(box.cls.item())
                class_name = result.names[class_id]
                
                # Sadece tehlikeli sınıfları filtrele
                if class_name in DANGEROUS_CLASSES:
                    confidence = box.conf.item()
                    danger_score = DANGEROUS_CLASSES[class_name] * confidence
                    x1, y1, x2, y2 = box.xyxy[0].tolist()
                    
                    detected_objects.append({
                        "class": class_name,
                        "box": [x1, y1, x2, y2],
                        "confidence": confidence,
                        "danger_score": danger_score
                    })
        
        return detected_objects
    
    def mark_dangers(self, image):
        """Görüntüdeki tehlikeli objeleri işaretle ve en güvenli noktayı göster"""
        # NumPy dizisine dönüştür
        if isinstance(image, str):
            image = Image.open(image)
        elif isinstance(image, np.ndarray):
            image = Image.fromarray(image)
        
        # Tehlikeli objeleri tespit et
        dangers = self.detect_dangers(np.array(image))
        
        # Görüntü üzerine çizim yapmak için kopya oluştur
        result_image = image.copy()
        draw = ImageDraw.Draw(result_image)
        
        # Tehlikeli objeleri işaretle
        for obj in dangers:
            x1, y1, x2, y2 = obj["box"]
            class_name = obj["class"]
            danger_score = obj["danger_score"]
            
            # Tehlike skoruna göre renk belirle (kırmızı -> sarı)
            color = (255, int(255 * (1 - danger_score)), 0)
            
            # Kutuyu çiz
            draw.rectangle([x1, y1, x2, y2], outline=color, width=3)
            
            # Etiketi çiz
            draw.text((x1, y1-15), f"{class_name}: {danger_score:.2f}", fill=color)
        
        # Basit güvenli nokta hesaplama (ileride SAM ile geliştirilecek)
        safe_point = self._find_safe_point(np.array(image), dangers)
        
        # Güvenli noktayı işaretle
        if safe_point:
            x, y = safe_point
            radius = 20
            draw.ellipse((x-radius, y-radius, x+radius, y+radius), fill=(0, 255, 0, 128))
            draw.text((x+radius+5, y), "EN GÜVENLİ NOKTA", fill=(0, 255, 0))
        
        return np.array(result_image)
    
    def _find_safe_point(self, image, dangers):
        """En güvenli noktayı bul (basit versiyon)"""
        h, w = image.shape[:2]
        
        # Tehlike haritası oluştur
        danger_map = np.zeros((h, w), dtype=np.float32)
        
        # Her tehlikeli obje için tehlike alanı oluştur
        for obj in dangers:
            x1, y1, x2, y2 = obj["box"]
            danger_score = obj["danger_score"]
            
            # Objenin merkezi
            center_x = (x1 + x2) / 2
            center_y = (y1 + y2) / 2
            
            # Tüm pikseller için tehlike skorunu hesapla
            for y in range(h):
                for x in range(w):
                    # Mesafe hesapla
                    distance = np.sqrt((x - center_x)**2 + (y - center_y)**2)
                    
                    # Mesafeye bağlı tehlike skoru (uzaklık arttıkça azalır)
                    pixel_danger = danger_score * (1000 / (distance + 10))
                    
                    # Tehlike haritasını güncelle
                    danger_map[y, x] += pixel_danger
        
        # En güvenli nokta (en düşük tehlike skoru)
        min_danger = np.min(danger_map)
        safe_indices = np.where(danger_map == min_danger)
        
        if len(safe_indices[0]) > 0:
            # Birden fazla güvenli nokta varsa, rastgele birini seç
            idx = np.random.randint(0, len(safe_indices[0]))
            safe_y = safe_indices[0][idx]
            safe_x = safe_indices[1][idx]
            return (safe_x, safe_y)
        
        return None

# Singleton örneği
detector = None

def get_detector():
    """Detector singleton örneğini döndür"""
    global detector
    if detector is None:
        detector = DangerDetector()
    return detector

def mark_dangers(image):
    """Gradio arayüzü için wrapper fonksiyon"""
    detector = get_detector()
    return detector.mark_dangers(image)
```

### AFAD API ve Harita Entegrasyonu

#### stream/afad_feed.py

```python
import requests
import folium
import pandas as pd
from datetime import datetime, timedelta
import time

# AFAD API URL
AFAD_API_URL = "https://deprem.afad.gov.tr/apiv2/event/filter"

def get_afad_data(hours=12):
    """AFAD API'den son depremleri çek"""
    # Zaman aralığını hesapla
    end_time = datetime.now()
    start_time = end_time - timedelta(hours=hours)
    
    # API parametreleri
    params = {
        "start": start_time.strftime("%Y-%m-%d %H:%M:%S"),
        "end": end_time.strftime("%Y-%m-%d %H:%M:%S"),
        "minMag": 1.0,  # Minimum büyüklük
        "orderby": "timedesc"  # Zamana göre sırala (en yeni en üstte)
    }
    
    try:
        # API isteği gönder
        response = requests.get(AFAD_API_URL, params=params)
        response.raise_for_status()  # Hata kontrolü
        
        # JSON verisini al
        data = response.json()
        
        return data
    except Exception as e:
        print(f"AFAD API hatası: {e}")
        return {"result": []}

def create_quake_map(quake_data):
    """Deprem verilerini haritada göster"""
    # Boş veri kontrolü
    if not quake_data or "result" not in quake_data or not quake_data["result"]:
        # Boş harita döndür
        m = folium.Map(location=[39.0, 35.0], zoom_start=5)
        folium.Marker(
            [39.0, 35.0],
            popup="Deprem verisi bulunamadı",
            icon=folium.Icon(color="gray")
        ).add_to(m)
        return m
    
    # Deprem verilerini DataFrame'e dönüştür
    quakes = []
    for quake in quake_data["result"]:
        try:
            quakes.append({
                "id": quake.get("eventID", ""),
                "time": quake.get("date", ""),
                "latitude": float(quake.get("latitude", 0)),
                "longitude": float(quake.get("longitude", 0)),
                "depth": float(quake.get("depth", 0)),
                "magnitude": float(quake.get("magnitude", 0)),
                "location": quake.get("location", ""),
                "type": quake.get("type", "")
            })
        except (ValueError, TypeError) as e:
            print(f"Veri dönüştürme hatası: {e}")
            continue
    
    df = pd.DataFrame(quakes)
    
    if df.empty:
        # Boş harita döndür
        m = folium.Map(location=[39.0, 35.0], zoom_start=5)
        folium.Marker(
            [39.0, 35.0],
            popup="Deprem verisi bulunamadı",
            icon=folium.Icon(color="gray")
        ).add_to(m)
        return m
    
    # Türkiye'nin merkezi
    center_lat = df["latitude"].mean()
    center_lon = df["longitude"].mean()
    
    # Harita oluştur
    m = folium.Map(location=[center_lat, center_lon], zoom_start=6)
    
    # Depremleri haritaya ekle
    for _, row in df.iterrows():
        # Büyüklüğe göre renk belirle
        if row["magnitude"] >= 5.0:
            color = "red"
        elif row["magnitude"] >= 4.0:
            color = "orange"
        elif row["magnitude"] >= 3.0:
            color = "yellow"
        else:
            color = "green"
        
        # Büyüklüğe göre çap belirle
        radius = row["magnitude"] * 5000
        
        # Popup içeriği
        popup_html = f"""
        <div style="font-family: Arial; width: 200px;">
            <h4>Deprem Bilgisi</h4>
            <b>Tarih:</b> {row["time"]}<br>
            <b>Büyüklük:</b> {row["magnitude"]}<br>
            <b>Derinlik:</b> {row["depth"]} km<br>
            <b>Konum:</b> {row["location"]}<br>
        </div>
        """
        
        # Dairesel işaret ekle
        folium.Circle(
            location=[row["latitude"], row["longitude"]],
            radius=radius,
            color=color,
            fill=True,
            fill_color=color,
            fill_opacity=0.4,
            popup=folium.Popup(popup_html, max_width=300)
        ).add_to(m)
        
        # Merkez noktası ekle
        folium.CircleMarker(
            location=[row["latitude"], row["longitude"]],
            radius=5,
            color=color,
            fill=True,
            fill_color="white",
            fill_opacity=0.7,
            popup=folium.Popup(popup_html, max_width=300)
        ).add_to(m)
    
    # Lejant ekle
    legend_html = """
    <div style="position: fixed; bottom: 50px; left: 50px; z-index: 1000; background-color: white; padding: 10px; border: 2px solid grey; border-radius: 5px;">
        <p><b>Deprem Büyüklüğü</b></p>
        <p><i class="fa fa-circle" style="color: red;"></i> ≥ 5.0</p>
        <p><i class="fa fa-circle" style="color: orange;"></i> 4.0 - 4.9</p>
        <p><i class="fa fa-circle" style="color: yellow;"></i> 3.0 - 3.9</p>
        <p><i class="fa fa-circle" style="color: green;"></i> < 3.0</p>
    </div>
    """
    m.get_root().html.add_child(folium.Element(legend_html))
    
    return m

def get_latest_quakes(hours=12):
    """Son depremleri çek ve haritada göster"""
    # Verileri çek
    quake_data = get_afad_data(hours)
    
    # Harita oluştur
    quake_map = create_quake_map(quake_data)
    
    # Son güncelleme bilgisi ekle
    timestamp = datetime.now().strftime("%d.%m.%Y %H:%M:%S")
    quake_map.get_root().html.add_child(folium.Element(
        f'<div style="position: fixed; top: 10px; right: 10px; z-index: 1000; background-color: white; padding: 5px; border-radius: 5px;">'
        f'Son Güncelleme: {timestamp}</div>'
    ))
    
    return quake_map
```

## Potansiyel Sorunlar ve Çözümleri

### GPU Bellek Sorunları

**Sorun:** 4GB GPU belleği, özellikle büyük modeller (YOLOv8, SAM, Llama-3) için yetersiz kalabilir.

**Çözümler:**
1. **Model Küçültme:**
   ```python
   # YOLOv8n (nano) gibi küçük modeller kullan
   model = YOLO("yolov8n.pt")
   ```

2. **Quantization:**
   ```python
   # 4-bit quantization ile bellek kullanımını azalt
   quantization_config = BitsAndBytesConfig(
       load_in_4bit=True,
       bnb_4bit_compute_dtype=torch.float16,
       bnb_4bit_quant_type="nf4",
       bnb_4bit_use_double_quant=True
   )
   ```

3. **Batch Size Azaltma:**
   ```python
   # Batch size'ı küçült
   results = model(image, batch=1)
   ```

4. **Gradient Checkpoint:**
   ```python
   # Gradient checkpoint kullan
   model.gradient_checkpointing_enable()
   ```

5. **Bellek Temizleme:**
   ```python
   # Kullanılmayan belleği temizle
   torch.cuda.empty_cache()
   ```

### API Bağlantı Sorunları

**Sorun:** AFAD API veya diğer harici API'lere bağlanırken sorunlar yaşanabilir.

**Çözümler:**
1. **Hata Yakalama:**
   ```python
   try:
       response = requests.get(API_URL, params=params, timeout=10)
       response.raise_for_status()
       data = response.json()
   except requests.exceptions.RequestException as e:
       print(f"API hatası: {e}")
       # Yedek veri veya önbellek kullan
       data = load_cached_data()
   ```

2. **Önbellekleme:**
   ```python
   def get_cached_or_fresh_data(url, params, cache_file, max_age_hours=1):
       """Önbellekten veri al veya yeni veri çek"""
       if os.path.exists(cache_file):
           # Önbellek dosyasının yaşını kontrol et
           file_age = time.time() - os.path.getmtime(cache_file)
           if file_age < max_age_hours * 3600:
               with open(cache_file, 'r') as f:
                   return json.load(f)
       
       # Yeni veri çek
       response = requests.get(url, params=params, timeout=10)
       data = response.json()
       
       # Önbelleğe kaydet
       with open(cache_file, 'w') as f:
           json.dump(data, f)
       
       return data
   ```

3. **Yeniden Deneme Mekanizması:**
   ```python
   def request_with_retry(url, params, max_retries=3, backoff_factor=0.5):
       """Yeniden deneme mekanizması ile API isteği gönder"""
       for attempt in range(max_retries):
           try:
               response = requests.get(url, params=params, timeout=10)
               response.raise_for_status()
               return response.json()
           except requests.exceptions.RequestException as e:
               print(f"Deneme {attempt+1}/{max_retries} başarısız: {e}")
               if attempt < max_retries - 1:
                   # Üstel geri çekilme
                   sleep_time = backoff_factor * (2 ** attempt)
                   time.sleep(sleep_time)
       
       # Tüm denemeler başarısız oldu
       raise Exception(f"API'ye bağlanılamadı: {url}")
   ```

### Gradio Arayüz Sorunları

**Sorun:** Gradio arayüzünde modüller arası entegrasyon sorunları yaşanabilir.

**Çözümler:**
1. **Durum Yönetimi:**
   ```python
   with gr.Blocks() as demo:
       # Durum değişkenleri
       address_state = gr.State("")
       risk_score_state = gr.State(None)
       
       # Adres giriş alanı
       address_input = gr.Textbox(label="Adres")
       
       # Risk hesaplama butonu
       risk_button = gr.Button("Risk Hesapla")
       
       # Risk sonucu
       risk_output = gr.Number(label="Risk Skoru")
       
       # Harita gösterimi
       map_output = gr.HTML(label="Harita")
       
       # Risk hesaplama fonksiyonu
       def calculate_risk(address):
           risk = predict_risk(address)
           return address, risk
       
       # Harita güncelleme fonksiyonu
       def update_map(address, risk):
           # Adres koordinatlarını al ve haritada göster
           map_html = create_address_map(address, risk)
           return map_html
       
       # Buton tıklaması
       risk_button.click(
           calculate_risk,
           inputs=[address_input],
           outputs=[address_state, risk_score_state, risk_output]
       ).then(
           update_map,
           inputs=[address_state, risk_score_state],
           outputs=[map_output]
       )
   ```

2. **Modüler Yapı:**
   ```python
   def create_vision_tab():
       with gr.Tab("Görsel Analiz"):
           # Görsel analiz bileşenleri
           return input_components, output_components
   
   def create_risk_tab():
       with gr.Tab("Risk Analizi"):
           # Risk analizi bileşenleri
           return input_components, output_components
   
   with gr.Blocks() as demo:
       vision_inputs, vision_outputs = create_vision_tab()
       risk_inputs, risk_outputs = create_risk_tab()
       # Diğer sekmeler...
   ```

3. **Hata İşleme:**
   ```python
   def safe_predict_risk(address):
       try:
           result = predict_risk_with_details(address)
           if result["success"]:
               return result["risk_score"], result["risk_category"], result["explanation"], None
           else:
               return None, None, None, result["message"]
       except Exception as e:
           return None, None, None, f"Hata: {str(e)}"
   
   # Gradio arayüzünde
   risk_score, risk_category, explanation, error = gr.components.Group()
   
   risk_button.click(
       safe_predict_risk,
       inputs=[address_input],
       outputs=[risk_score, risk_category, explanation, error]
   )
   ```

### Veri Seti Sorunları

**Sorun:** ADE20K veri seti büyük olabilir ve deprem güvenliği için özel etiketlere ihtiyaç duyabilir.

**Çözümler:**
1. **Veri Seti Filtreleme:**
   ```python
   def filter_indoor_images(ade20k_path):
       """ADE20K veri setinden iç mekan görüntülerini filtrele"""
       indoor_categories = ["bedroom", "living_room", "kitchen", "bathroom", "office", "dining_room"]
       
       filtered_images = []
       
       # ADE20K index dosyasını oku
       index_file = os.path.join(ade20k_path, "index_ade20k.txt")
       with open(index_file, "r") as f:
           for line in f:
               parts = line.strip().split()
               image_path = parts[0]
               
               # İç mekan kategorilerini kontrol et
               for category in indoor_categories:
                   if category in image_path:
                       filtered_images.append(os.path.join(ade20k_path, image_path))
                       break
       
       return filtered_images
   ```

2. **Etiket Dönüşümü:**
   ```python
   def map_ade20k_to_danger_classes(ade20k_label):
       """ADE20K etiketlerini tehlike sınıflarına dönüştür"""
       danger_mapping = {
           "cabinet/cupboard": "cabinet",
           "bookcase/bookshelf": "bookcase",
           "refrigerator/fridge": "refrigerator",
           "television/tv": "tv",
           "microwave": "microwave",
           "chair": "chair",
           "sofa/couch": "couch",
           "bed": "bed",
           "dining_table": "dining table",
           "toilet": "toilet",
           "sink": "sink",
           "clock": "clock",
           "vase": "vase",
           # Diğer eşleştirmeler...
       }
       
       for ade_class, danger_class in danger_mapping.items():
           if ade_class in ade20k_label:
               return danger_class
       
       return None
   ```

## 9. Kaynaklar ve Referanslar

### 9.1. Öğrenme Kaynakları

- **Yapay Zeka ile Çalışma:**
  - [OpenAI Cookbook](https://github.com/openai/openai-cookbook)
  - [GitHub Copilot Dokümantasyonu](https://docs.github.com/en/copilot)

- **Teknik Kaynaklar:**
  - [Gradio Dokümantasyonu](https://www.gradio.app/docs/)
  - [YOLOv8 Rehberi](https://docs.ultralytics.com/)
  - [Segment Anything Model (SAM) Rehberi](https://segment-anything.com/)
  - [LangChain Dokümantasyonu](https://python.langchain.com/docs/get_started/introduction)

### 9.2. Veri Kaynakları

- **Görsel Analiz:**
  - [ADE20K Veri Seti](https://groups.csail.mit.edu/vision/datasets/ADE20K/)
  - [Kaggle Deprem Sonrası İç Mekan Veri Setleri](https://www.kaggle.com/datasets)

- **Deprem Verileri:**
  - [AFAD Deprem Kataloğu](https://deprem.afad.gov.tr/depremkatalogu)
  - [USGS Earthquake API](https://earthquake.usgs.gov/fdsnws/event/1/)

- **Dokümanlar:**
  - [AFAD Deprem Bilgilendirme](https://www.afad.gov.tr/afet-turleri/deprem)
  - [Kızılay Afet Hazırlık](https://www.kizilay.org.tr/neler-yapiyoruz/afet-hizmetleri)
  - [FEMA Earthquake Safety](https://www.fema.gov/emergency-managers/risk-management/earthquake)

## 10. Sonuç

Bu yol haritası, QuakeAware AI projesinin bir yapay zeka tarafından geliştirilmesi için kapsamlı bir rehber sunmaktadır. Başlangıç seviyesindeki bir kullanıcı için hazırlanmış olan bu plan, 4GB GPU kısıtlaması göz önünde bulundurularak optimize edilmiştir. ADE20K veri seti ve diğer açık kaynaklı araçlar kullanılarak, deprem güvenliği konusunda faydalı bir uygulama geliştirilebilir.

Projenin başarısı için en önemli faktörler:
1. Adım adım ilerleme ve her aşamada test etme
2. Yapay zeka ile etkili iletişim kurma
3. Modelleri donanım kısıtlamalarına göre optimize etme
4. Kullanıcı geri bildirimlerini dikkate alma

Bu yol haritasını takip ederek, 12 hafta içinde tam işlevsel bir QuakeAware AI uygulaması geliştirilebilir ve Hugging Face Space üzerinden kullanıcılara sunulabilir.