A newer version of the Gradio SDK is available:
5.43.1
QuakeAware AI – Aşırı Anlaşılır ve Detaylı Geliştirme Yol Haritası
İçindekiler
- Giriş
- Proje Hazırlık Aşaması
- Yapay Zekaya Talimat Verme Stratejisi
- Modül Geliştirme Aşaması
- Entegrasyon ve Test Aşaması
- Dağıtım ve Yayınlama
- Bakım ve Geliştirme
- Yapay Zeka ile İletişim İpuçları
- Zaman Çizelgesi ve Kilometre Taşları
- Kod Örnekleri ve Şablonlar
- Potansiyel Sorunlar ve Çözümleri
- Kaynaklar ve Referanslar
- 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:
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.
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ı.
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.
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ı:
- Proje dizin yapısını oluşturma
- Gerekli kütüphaneleri içeren requirements.txt dosyası hazırlama
- Temel Gradio arayüzünü oluşturma
- Modüller için iskelet kodları yazma
- 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ı:
- YOLOv8 modelini kurma ve optimize etme
- ADE20K veri setinden iç mekan görüntülerini filtreleme
- Tehlikeli obje sınıflarını belirleme ve model eğitimi/fine-tuning
- SAM modelini entegre etme ve hafif versiyonunu kullanma
- Güvenli alan algoritmasını geliştirme
- 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ı:
- AFAD API'sine bağlantı kurma
- JSON verilerini işleme ve temizleme
- Harita görselleştirme kütüphanesini kurma
- Deprem verilerini haritaya işleme
- Otomatik yenileme mekanizması oluşturma
- 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ı:
- Veri kaynaklarını toplama ve birleştirme
- Adres → koordinat dönüşümü için geocoding servisi entegrasyonu
- Özellik mühendisliği ve veri hazırlama
- Model seçimi ve hiperparametre optimizasyonu
- Model eğitimi ve değerlendirme
- 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ı:
- Dokümanları toplama ve ön işleme
- Vektör veritabanı oluşturma (FAISS)
- Llama-3 modelini optimize etme (quantization, LoRA)
- RAG sistemini kurma (LangChain veya benzeri)
- Soru-cevap mekanizmasını geliştirme
- 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ı:
- Modülleri tek bir Gradio uygulamasında birleştirme
- Modüller arası veri paylaşımı mekanizmaları oluşturma
- Kullanıcı deneyimini iyileştirme (UI/UX)
- Performans optimizasyonu
- 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ı:
- Birim testleri yazma
- Entegrasyon testleri yapma
- Performans testleri ve darboğaz analizi
- Kullanıcı arayüzü testleri
- Farklı giriş senaryolarıyla test
- 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ı:
- Hugging Face hesabı oluşturma
- Space için gerekli dosyaları hazırlama
- requirements.txt dosyasını optimize etme
- Modelleri küçültme ve optimize etme
- Gradio uygulamasını yapılandırma
- 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ı:
- README.md dosyası hazırlama
- Kurulum talimatları yazma
- Kullanım kılavuzu oluşturma
- Ekran görüntüleri ve örnekler ekleme
- Sık sorulan sorular bölümü hazırlama
- 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ı:
- Geri bildirim formu ekleme
- Hata takip sistemi kurma
- Kullanıcı davranışlarını analiz etme
- Düzenli güncellemeler planlama
- 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ı:
- Otomatik veri toplama mekanizmaları kurma
- Model yeniden eğitim süreçleri oluşturma
- A/B testleri yapma
- Sürüm kontrol sistemi kurma
- 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
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
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
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:
Model Küçültme:
# YOLOv8n (nano) gibi küçük modeller kullan model = YOLO("yolov8n.pt")
Quantization:
# 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 )
Batch Size Azaltma:
# Batch size'ı küçült results = model(image, batch=1)
Gradient Checkpoint:
# Gradient checkpoint kullan model.gradient_checkpointing_enable()
Bellek Temizleme:
# 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:
Hata Yakalama:
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()
Önbellekleme:
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
Yeniden Deneme Mekanizması:
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:
Durum Yönetimi:
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] )
Modüler Yapı:
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...
Hata İşleme:
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:
Veri Seti Filtreleme:
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
Etiket Dönüşümü:
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:
Teknik Kaynaklar:
9.2. Veri Kaynakları
Görsel Analiz:
Deprem Verileri:
Dokümanlar:
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:
- Adım adım ilerleme ve her aşamada test etme
- Yapay zeka ile etkili iletişim kurma
- Modelleri donanım kısıtlamalarına göre optimize etme
- 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.