Backend restructuring and YOLOv8 removal

.gitattributes

@@ -1 +1,2 @@
 BACKEND/models/checkpoints/*.pth filter=lfs diff=lfs merge=lfs -text
+BACKEND/models/*.pth filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -19,62 +19,47 @@ Thumbs.db
 *.sublime-project
 *.sublime-workspace
 
-# --- Python & Backend (BACKEND/) ---
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
+# --- Backend (BACKEND/) ---
+BACKEND/__pycache__/
+BACKEND/*.py[cod]
+BACKEND/*$py.class
+BACKEND/*.so
+BACKEND/.Python
+BACKEND/build/
+BACKEND/develop-eggs/
+BACKEND/dist/
+BACKEND/downloads/
+BACKEND/eggs/
+BACKEND/.eggs/
+BACKEND/lib/
+BACKEND/lib64/
+BACKEND/parts/
+BACKEND/sdist/
+BACKEND/var/
+BACKEND/wheels/
+BACKEND/share/python-wheels/
+BACKEND/*.egg-info/
+BACKEND/.installed.cfg
+BACKEND/*.egg
+BACKEND/MANIFEST
 
 # Virtual Environments
-.venv/
-venv/
-ENV/
-env/
-env.bak/
-venv.bak/
+BACKEND/.venv/
+BACKEND/venv/
+BACKEND/ENV/
+BACKEND/env/
 
 # Jupyter Notebook
-.ipynb_checkpoints
+BACKEND/.ipynb_checkpoints/
 
 # --- Models & Data ---
-# Large model weights (Use Git LFS for these)
-# *.pt
-# *.pth
-# *.ckpt
-# *.h5
-# *.onnx
-# *.weights
-# *.pb
-
-# Model directories (Keep checkpoints for deployment if needed)
-# BACKEND/models/checkpoints/
+# Model logs and temporary results
 BACKEND/models/logs/
 BACKEND/results/
 BACKEND/data/
 BACKEND/logs/
-results/
-data/
-logs/
 
-# Exception: Keep configuration files in models
+# Exception: Keep configuration and mapping files
 !BACKEND/models/*.json
 !BACKEND/models/*.py
 !BACKEND/models/__init__.py
@@ -100,11 +85,7 @@ FRONTEND/pnpm-debug.log*
 .env.test.local
 .env.production.local
 *.env*
-kaggle.json
-
-# --- Vercel ---
-.vercel
 
 # --- Misc ---
-download_test.py
-# (Only if you don't want to share testing scripts)
+BACKEND/download_test.py
+kaggle.json

Dockerfile → BACKEND/Dockerfile

@@ -1,34 +1,25 @@
-# Python 3.10 tabanlı hafif bir imaj kullanıyoruz
 FROM python:3.10-slim
 
 # Çalışma dizinini ayarla
 WORKDIR /app
 
-# Sistem bağımlılıklarını yükle (OpenCV için gerekli)
-RUN apt-get update && apt-get install -y \
-    libgl1 \
+# Gerekli sistem kütüphanelerini kur (OpenCV / GLIB gereksinimleri için vb.)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1-mesa-glx \
     libglib2.0-0 \
-    libsm6 \
-    libxext6 \
     && rm -rf /var/lib/apt/lists/*
 
-
-# Bağımlılıkları kopyala ve yükle
+# Bağımlılıkları kopyala ve kur
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 RUN pip install --no-cache-dir uvicorn gunicorn
 
-# Proje dosyalarını kopyala
+# Proje kaynak kodlarını kopyala
 COPY . .
 
-# Veri ve model klasörlerini oluştur (boş olabilirler)
-RUN mkdir -p data models/checkpoints results
-
-# API portunu aç
+# FastAPI portunu dışa aç (Hugging Face Spaces için 7860)
 EXPOSE 7860
 
-# API'yi başlat (Hugging Face Spaces varsayılan olarak 7860 portunu bekler)
-# Gradio kullanacaksanız: python app.py
-# FastAPI kullanacaksanız: uvicorn api:app --host 0.0.0.0 --port 7860
+# Uvicorn ile API'yi başlat
 CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]
-# CMD ["python", "app.py"]

api.py → BACKEND/api.py

@@ -1,3 +1,13 @@
+"""
+API.PY - FastAPI Wheat Disease Analysis API
+
+Endpoints:
+    POST /analyze          -> Classification and quality analysis
+    GET  /health           -> System status
+    GET  /classes          -> Supported classes
+    GET  /docs             -> Swagger UI (automatic)
+"""
+
 import sys
 import time
 import json
@@ -8,7 +18,7 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI, File, UploadFile, HTTPException, Query
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 project_root = Path(__file__).resolve().parent
 if str(project_root) not in sys.path:
@@ -19,16 +29,19 @@ from pipeline import WheatDiseasePipeline, PipelineResult
 
 
 # ============================================================================
-# UYGULAMA BAŞLATMA
+# APP INITIALIZATION
 # ============================================================================
 
+# Pipeline object (loaded at startup)
 pipeline: Optional[WheatDiseasePipeline] = None
 startup_error: Optional[str] = None
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    """Load pipeline on startup."""
     global pipeline, startup_error
-    print("Pipeline yükleniyor...")
+    print("Pipeline yukleniyor...")
     try:
         pipeline = WheatDiseasePipeline(
             cls_checkpoint   = str(config.MODEL_CHECKPOINT_PATH),
@@ -36,20 +49,28 @@ async def lifespan(app: FastAPI):
             device           = str(config.DEVICE),
             cls_conf         = config.CONFIDENCE_THRESHOLD,
         )
-        print("Pipeline hazır, API isteklere açık.")
+        print("Pipeline hazir, API isteklere acik.")
     except Exception as e:
         startup_error = str(e)
-        print(f"Pipeline yüklenemedi: {e}")
+        print(f"Pipeline yuklenemedi: {e}")
     yield
-    print("API kapatılıyor.")
+    print("API kapatiliyor.")
+
 
 app = FastAPI(
-    title       = "Wheat Disease Classification API",
-    description = "Buğday hastalıklarını sınıflandıran yapay zeka (Swin-T) API'si.",
+    title       = "Wheat Disease Detection API",
+    description = (
+        "Wheat leaf and head disease classification API.\n\n"
+        "**Supported 15 Classes:** Aphid, Blast, Black Rust, Brown Rust, "
+        "Common Root Rot, Fusarium Head Blight, Healthy, Leaf Blight, "
+        "Mildew, Mite, Septoria, Smut, Stem fly, Tan spot, Yellow Rust\n\n"
+        "**Model:** Swin Transformer (Tiny)"
+    ),
     version     = "1.0.0",
     lifespan    = lifespan,
 )
 
+# CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins     = ["*"],
@@ -60,7 +81,7 @@ app.add_middleware(
 
 
 # ============================================================================
-# YANIT ŞEMALARI
+# SCHEMAS (Pydantic)
 # ============================================================================
 
 class ClassificationResult(BaseModel):
@@ -92,44 +113,55 @@ class HealthResponse(BaseModel):
     num_classes   : int
     error         : Optional[str] = None
 
+
 # ============================================================================
-# YARDIMCI
+# HELPERS
 # ============================================================================
 
 def _check_pipeline():
+    """Raise 503 if pipeline is not ready."""
     if pipeline is None:
         raise HTTPException(
             status_code=503,
             detail={
-                "error"  : "Pipeline yüklenemedi",
+                "error"  : "Pipeline yuklenemedi",
                 "message": startup_error or "Bilinmeyen hata",
+                "hint"   : "Model dosyalarinin var oldugundan emin olun.",
             },
         )
 
+
 def _validate_image(file: UploadFile):
-    allowed = {"image/jpeg", "image/jpg", "image/png", "image/bmp", "image/tiff", "image/webp"}
+    """Validate uploaded file is an image."""
+    allowed = {"image/jpeg", "image/jpg", "image/png",
+               "image/bmp", "image/tiff", "image/webp"}
     if file.content_type not in allowed:
-        raise HTTPException(status_code=415, detail="Desteklenmeyen format")
+        raise HTTPException(
+            status_code=415,
+            detail=f"Desteklenmeyen format: {file.content_type}. "
+                   f"Kabul edilenler: {', '.join(allowed)}",
+        )
+    # Size limit: 20MB
     MAX_SIZE = 20 * 1024 * 1024
     if file.size and file.size > MAX_SIZE:
-        raise HTTPException(status_code=413, detail="Dosya çok büyük (Maksimum: 20 MB)")
+        raise HTTPException(
+            status_code=413,
+            detail=f"Dosya cok buyuk ({file.size/1024/1024:.1f} MB). Maksimum: 20 MB",
+        )
 
 
 # ============================================================================
 # ENDPOINTS
 # ============================================================================
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Wheat Disease Classification API is running!",
-        "status": "online",
-        "docs": "/docs",
-        "endpoints": ["/analyze", "/health", "/classes"]
-    }
-
-@app.get("/health", response_model=HealthResponse)
+@app.get(
+    "/health",
+    response_model=HealthResponse,
+    summary="System Status",
+    tags=["System"],
+)
 async def health():
+    """Returns API and model status."""
     ready = pipeline is not None
     return HealthResponse(
         status        = "ok" if ready else "degraded",
@@ -140,8 +172,14 @@ async def health():
         error         = startup_error,
     )
 
-@app.get("/classes")
+
+@app.get(
+    "/classes",
+    summary="Supported Disease Classes",
+    tags=["Info"],
+)
 async def get_classes():
+    """Lists 15 disease classes."""
     mapping_path = config.MODELS_DIR / "class_mapping.json"
     if mapping_path.exists():
         with open(mapping_path, "r", encoding="utf-8") as f:
@@ -155,36 +193,41 @@ async def get_classes():
         "classes"    : classes,
     }
 
-@app.post("/analyze", response_model=AnalyzeResponse)
+
+@app.post(
+    "/analyze",
+    response_model=AnalyzeResponse,
+    summary="Image Analysis",
+    tags=["Analysis"],
+)
 async def analyze(
-    file        : UploadFile = File(...),
-    skip_quality: bool = Query(False),
+    file            : UploadFile = File(..., description="Wheat image (jpg/png)"),
+    skip_quality    : bool = Query(False, description="Skip quality filter"),
 ):
+    """Runs analysis on uploaded image."""
     _check_pipeline()
     _validate_image(file)
 
     image_bytes = await file.read()
     if not image_bytes:
-        raise HTTPException(status_code=400, detail="Boş dosya yüklendi")
+        raise HTTPException(status_code=400, detail="Empty file")
 
     try:
         result: PipelineResult = pipeline.run(image_bytes, skip_quality=skip_quality)
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Analiz hatası: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Analysis error: {str(e)}")
 
     return JSONResponse(content=pipeline.result_to_dict(result))
 
-@app.post("/classify", response_model=AnalyzeResponse)
-async def classify(
-    file        : UploadFile = File(...),
-    skip_quality: bool = Query(False),
-):
-    # Yalnızca sınıflandırma (Swin-T) kullanıldığı için analyze ile aynı
-    return await analyze(file, skip_quality)
 
+# ============================================================================
+# RUN
+# ============================================================================
 
 if __name__ == "__main__":
     import uvicorn
+
+    print("Wheat Disease API baslatiliyor...")
     uvicorn.run(
         "api:app",
         host    = config.API_HOST,

app.py → BACKEND/app.py

@@ -1,57 +1,52 @@
-import os
-import sys
 import gradio as gr
-from pathlib import Path
-from PIL import Image
-
-# Add current directory to path
-project_root = Path(__file__).resolve().parent
-if str(project_root) not in sys.path:
-    sys.path.append(str(project_root))
-
+import numpy as np
 from pipeline import WheatDiseasePipeline
 import config
+from pathlib import Path
 
-# Initialize Pipeline
+# Pipeline başlatma
 pipeline = WheatDiseasePipeline(
     cls_checkpoint = str(config.MODEL_CHECKPOINT_PATH),
     cls_mapping    = str(config.MODELS_DIR / "class_mapping.json"),
-    device         = "cpu", # Spaces typically use CPU unless paid
-    cls_conf       = 0.50,
+    device         = str(config.DEVICE),
+    cls_conf       = config.CONFIDENCE_THRESHOLD,
 )
 
 def predict(image):
     if image is None:
-        return "Lütfen bir görüntü yükleyin.", None, None
+        return "Görüntü yüklenmedi", {}, "N/A"
     
-    # Run pipeline
-    result = pipeline.run(image)
-    data = pipeline.result_to_dict(result)
+    # Görüntü Gradio'dan RGB numpy array olarak gelir, 
+    # pipeline ise bytes veya PIL bekler (veya numpy BGR).
+    # Biz bytes'a çevirip gönderelim ya da doğrudan numpy olarak işleyelim.
+    result = pipeline.run(image, skip_quality=False)
     
-    # Format results for Gradio
-    classification = data["classification"]
-    top3 = classification["top3_predictions"]
-    
-    label_output = {item["class"]: item["score"] for item in top3}
-    
-    # Quality info
-    quality = data["quality"]
-    quality_text = f"Geçerli: {quality['is_valid']}\nBulanıklık Skoru: {quality['blur_score']}\n"
-    if quality["warnings"]:
-        quality_text += f"Uyarılar: {', '.join(quality['warnings'])}"
+    if result.predicted_class == "Reddedildi":
+        return (
+            f"❌ Analiz Reddedildi: {result.rejection_reason}", 
+            {}, 
+            f"Bulanıklık: {result.blur_score:.1f} (Düşük kalite)"
+        )
+
+    # Olasılıkları Gradio Label formatına çevir
+    probs = {c: float(s) for c, s in result.top3_predictions}
     
-    return classification["predicted_class"], label_output, quality_text
+    quality_info = f"Görüntü Kalite Skoru: {result.blur_score:.1f}"
+    if result.quality_warnings:
+        quality_info += f"\nUyarılar: {', '.join(result.quality_warnings)}"
+
+    return result.predicted_class, probs, quality_info
 
-# Create Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🌾 Buğday Hastalık Teşhis Sistemi")
-    gr.Markdown("Bu uygulama, Swin Transformer (Tiny) mimarisini kullanarak buğday yapraklarındaki hastalıkları tespit eder.")
+# Gradio Arayüzü
+with gr.Blocks(theme=gr.themes.Soft(), title="Bugday Hastaligi Teshis Sistemi") as demo:
+    gr.Markdown("# Bugday Hastaligi Teshis Sistemi")
+    gr.Markdown("Swin Transformer tabanli derin ogrenme modeli ile 15 farkli bugday hastaligini teshis edin.")
     
     with gr.Row():
         with gr.Column():
-            input_img = gr.Image(type="pil", label="Buğday Yaprağı Görüntüsü")
-            btn = gr.Button("Teşhis Et", variant="primary")
-        
+            input_img = gr.Image(label="Buğday Yaprağı Fotoğrafı Yükleyin", type="numpy")
+            btn = gr.Button("🔍 Teşhis Et", variant="primary")
+            
         with gr.Column():
             output_label = gr.Textbox(label="En Olası Teşhis")
             output_probs = gr.Label(label="Sınıf Olasılıkları", num_top_classes=3)
@@ -59,10 +54,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
     btn.click(fn=predict, inputs=input_img, outputs=[output_label, output_probs, output_quality])
     
-    gr.Examples(
-        examples=[], # Add example images if available
-        inputs=input_img
-    )
+    gr.Markdown("""
+    ### ℹ️ Desteklenen Sınıflar
+    Aphid, Blast, Black Rust, Brown Rust, Common Root Rot, Fusarium Head Blight, Healthy, 
+    Leaf Blight, Mildew, Mite, Septoria, Smut, Stem fly, Tan spot, Yellow Rust
+    """)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)

config.py → BACKEND/config.py

@@ -3,8 +3,12 @@ import torch
 from pathlib import Path
 import logging
 
+# ============================================================================
+# 📋 CONFIG.PY - SWIN TRANSFORMER WHEAT DISEASE CLASSIFIER
 # Veri Seti: 15 Sınıf | Train: 13104 | Valid: 300 | Test: 750
+# ============================================================================
 
+# --- Dizin Ayarlaması ---
 BASE_DIR = Path(__file__).resolve().parent
 DATA_DIR = BASE_DIR / "data"
 MODELS_DIR = BASE_DIR / "models"
@@ -13,7 +17,9 @@ CHECKPOINTS_DIR = MODELS_DIR / "checkpoints"
 KNOWLEDGE_BASE_DIR = BASE_DIR / "knowledge_base"
 RESULTS_DIR = BASE_DIR / "results"
 
+# ============================================================================
 #  VERİ SETİ SINIF BİLGİLERİ
+# ============================================================================
 
 # Veri setindeki tüm sınıflar (train klasöründeki sırayla - alfabetik)
 DATASET_CLASSES = [
@@ -45,7 +51,11 @@ TOTAL_TRAIN = 13104
 TOTAL_VALID = 300
 TOTAL_TEST = 750
 
+# ============================================================================
+# ⚙️ EĞİTİM KONFİGÜRASYONU
+# ============================================================================
 
+# --- Temel Eğitim Parametreleri ---
 # Colab T4/A100 için 32 güvenli; OOM yaşarsanız 16'ya düşürün
 BATCH_SIZE = 8
 # Colab'da 2 en kararlı değerdir
@@ -62,18 +72,24 @@ LR_DIVISOR = 5
 # Scheduler minimum LR
 MIN_LEARNING_RATE = 1e-07
 
+# --- Model Konfigürasyonu ---
 MODEL_NAME = "swin_t"       # Swin Transformer Tiny
 IMG_SIZE = 224               
 PRETRAINED = True           # ImageNet pre-trained weights
 
+# --- Gelişmiş Eğitim Ayarları ---
 LABEL_SMOOTHING = 0.1       # Overconfidence engellemek için
 WEIGHT_DECAY = 0.05        # L2 regularization
 GRADIENT_CLIP_MAX_NORM = 0.5  # Transformer'larda gradient explosion önleme
 
+# --- Mixed Precision (AMP) ---
 # Colab GPU'da ~2x hız artışı, bellek tasarrufu sağlar
 USE_MIXED_PRECISION = False
 SCALER_INIT_SCALE = 65536.0
 
+# ============================================================================
+# 🔧 FINE-TUNING STRATEJİSİ
+# ============================================================================
 
 # Aşama 1 (Epoch 1-4):  Backbone dondurulur, sadece head eğitilir
 # Aşama 2 (Epoch 5+):   Backbone açılır, differential LR uygulanır
@@ -81,21 +97,33 @@ FREEZE_BACKBONE_INITIALLY = True
 UNFREEZE_EPOCH = 5
 DIFFERENTIAL_LR = True
 
+# ============================================================================
+# 📊 KAYDETME & CHECKPOINT
+# ============================================================================
 
 SAVE_BEST_MODEL = True
 SAVE_CHECKPOINT_INTERVAL = 5   # Her 5 epoch'ta checkpoint
 MODEL_CHECKPOINT_PATH = CHECKPOINTS_DIR / "best_swin_model.pth"
 FINAL_MODEL_PATH = MODELS_DIR / "final_swin_model.pth"
 
+# ============================================================================
+# ⏹️ EARLY STOPPING
+# ============================================================================
 
 USE_EARLY_STOPPING = True
 EARLY_STOPPING_PATIENCE = 15    # 12 epoch iyileşme olmazsa dur
 EARLY_STOPPING_DELTA = 0.001   # Minimum iyileşme eşiği
 
+# ============================================================================
+# 🎲 REPRODUCIBILITY
+# ============================================================================
 
 SEED = 42
 DETERMINISTIC = True
 
+# ============================================================================
+# 💻 CİHAZ AYARLARI
+# ============================================================================
 
 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 CUDA_AVAILABLE = torch.cuda.is_available()
@@ -111,6 +139,9 @@ else:
     GPU_NAME = "CPU"
     GPU_MEMORY = 0
 
+# ============================================================================
+# 📡 API & INFERENCE
+# ============================================================================
 
 API_HOST = "0.0.0.0"
 API_PORT = 8000
@@ -118,22 +149,34 @@ API_DEBUG = False
 INFERENCE_TIMEOUT = 30
 CONFIDENCE_THRESHOLD = 0.5     # Bu altında "Belirsiz" döndür
 
+# ============================================================================
+# 📝 LOGGING
+# ============================================================================
 
 LOG_LEVEL = logging.INFO
 LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
 CONSOLE_LOG = True
 FILE_LOG = True
 
+# ============================================================================
+# 🔍 VALİDASYON
+# ============================================================================
 
 CALCULATE_CLASS_WEIGHTS = True
 VALIDATION_INTERVAL = 1        # Her epoch validate et
 PRINT_INTERVAL = 20            # Her 20 batch'te log
 
+# ============================================================================
+# 📈 SCHEDULER
+# ============================================================================
 
 SCHEDULER_TYPE = "cosine"
 COSINE_T_MAX = EPOCHS
 COSINE_ETA_MIN = MIN_LEARNING_RATE
 
+# ============================================================================
+# 📊 METRİK TAKİBİ
+# ============================================================================
 
 TRACK_METRICS = [
     "train_loss",
@@ -152,6 +195,9 @@ RESULTS_JSON = RESULTS_DIR / "final_results.json"
 CLASS_TO_IDX = {}
 IDX_TO_CLASS = {}
 
+# ============================================================================
+# 📁 KLASÖR OLUŞTURMA
+# ============================================================================
 
 def create_directories():
     dirs = [DATA_DIR, MODELS_DIR, LOGS_DIR,
@@ -163,6 +209,9 @@ def create_directories():
 
 create_directories()
 
+# ============================================================================
+# ✅ KONFİGÜRASYON DOĞRULAMA
+# ============================================================================
 
 def validate_config():
     warnings = []
@@ -187,6 +236,9 @@ def validate_config():
 
 config_warnings = validate_config()
 
+# ============================================================================
+# 🖨️ KONFİGÜRASYON YAZDIR
+# ============================================================================
 
 def print_config():
     print("\n" + "=" * 80)
@@ -246,6 +298,9 @@ def print_config():
     print("\n" + "=" * 80 + "\n")
 
 
+# ============================================================================
+# 🔧 YARDIMCI FONKSİYONLAR
+# ============================================================================
 
 def get_device_info():
     return {

{inference → BACKEND/inference}/predict.py

@@ -16,6 +16,7 @@ from PIL import Image
 from pathlib import Path
 from typing import Optional
 
+# ── Proje path ayarı ──────────────────────────────────────────────────────────
 project_root = Path(__file__).resolve().parent
 if str(project_root) not in sys.path:
     sys.path.append(str(project_root))
@@ -24,6 +25,9 @@ from models.model import WheatDiseaseClassifier
 from utils.dataset import get_transforms
 
 
+# ============================================================================
+# 🔧 MODEL YÜKLEME
+# ============================================================================
 
 def load_model(
     model_path: str,
@@ -77,6 +81,9 @@ def load_model(
     return model
 
 
+# ============================================================================
+# 🔍 TEK GÖRÜNTÜ TAHMİN
+# ============================================================================
 
 def predict_single(
     image_path: str,
@@ -138,6 +145,9 @@ def predict_single(
     }
 
 
+# ============================================================================
+# 📁 KLASÖR TAHMİN
+# ============================================================================
 
 def predict_folder(
     folder_path: str,
@@ -184,6 +194,9 @@ def predict_folder(
     return results
 
 
+# ============================================================================
+# 🖨️ SONUÇ YAZDIR
+# ============================================================================
 
 def print_result(result: dict):
     if result is None:
@@ -200,6 +213,9 @@ def print_result(result: dict):
     print(f"{'─'*55}\n")
 
 
+# ============================================================================
+# 🎬 MAIN
+# ============================================================================
 
 def main():
     parser = argparse.ArgumentParser(
@@ -226,12 +242,14 @@ def main():
 
     args = parser.parse_args()
 
+    # ── Cihaz ─────────────────────────────────────────────────────────────────
     if args.cpu:
         device = torch.device("cpu")
     else:
         device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     print(f"💻 Cihaz: {device}")
 
+    # ── Class Mapping ──────────────────────────────────────────────────────────
     if not Path(args.mapping).exists():
         print(f"❌ Class mapping dosyası bulunamadı: {args.mapping}")
         print("   Önce train.py çalıştırın.")
@@ -243,10 +261,13 @@ def main():
     num_classes = len(idx_to_class)
     print(f"🗂️  Sınıf sayısı: {num_classes}")
 
+    # ── Model ─────────────────────────────────────────────────────────────────
     model = load_model(args.model, num_classes, device)
 
+    # ── Transform ─────────────────────────────────────────────────────────────
     _, val_test_transform = get_transforms()
 
+    # ── Tahmin ────────────────────────────────────────────────────────────────
     all_results = []
 
     if args.image:
@@ -279,6 +300,7 @@ def main():
             print(f"\n📊 Özet: {len(all_results)} görüntü | "
                   f"Kesin: {certain} | Belirsiz: {len(all_results)-certain}")
 
+    # ── JSON Kaydet ───────────────────────────────────────────────────────────
     if args.save and all_results:
         save_path = Path(args.save)
         save_path.parent.mkdir(parents=True, exist_ok=True)

BACKEND/models/checkpoints/best_swin_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d086c2b9ba82cfc3dfb6c47c08cf1108b26fd00b263480dbf7712e8d1fdf37bf
+size 335512043

{models → BACKEND/models}/evaluate.py

@@ -5,6 +5,7 @@ import torch
 import numpy as np
 from sklearn.metrics import classification_report, accuracy_score, f1_score
 
+# --- KRİTİK DÜZELTME: config.py'yi bulmak için proje ana dizinini sisteme tanıtıyoruz ---
 current_dir = Path(__file__).resolve().parent
 # Eğer evaluate.py 'models' klasöründeyse, bir üst klasöre (ana dizine) çık
 project_root = current_dir.parent if current_dir.name == "models" else current_dir
@@ -16,7 +17,6 @@ import config
 from utils.dataset import get_dataloaders
 from models.model import WheatDiseaseClassifier
 
-
 def evaluate_model(model_path):
     print("=" * 60)
     print("🔍 SWIN TRANSFORMER TEST DEĞERLENDİRMESİ BAŞLIYOR")
@@ -27,33 +27,13 @@ def evaluate_model(model_path):
     print(f"🖥️ Cihaz: {device}")
     # 2. Test Verisini Yükle (Sadece test_loader'a ihtiyacımız var)
     print("📦 Test verisi yükleniyor...")
-
-    # Sadece test klasörünü yüklü (train klasörü yoksa get_dataloaders hatası verir)
-    from torchvision import transforms, datasets
-    from utils.dataset import get_transforms, robust_pil_loader
-
-    test_dir = config.DATA_DIR / "test"
-    if not test_dir.exists():
-        print(f"❌ HATA: Test klasörü bulunamadı! Yol: {test_dir}")
-        return
-
-    _, val_test_transform = get_transforms()
-    test_dataset = datasets.ImageFolder(
-        root=str(test_dir),
-        transform=val_test_transform,
-        loader=robust_pil_loader,
-    )
-
-    test_loader = torch.utils.data.DataLoader(
-        test_dataset,
+    _, _, test_loader, class_to_idx, _ = get_dataloaders(
+        data_dir=str(config.DATA_DIR),
         batch_size=config.BATCH_SIZE,
-        shuffle=False,
         num_workers=config.NUM_WORKERS,
-        pin_memory=config.PIN_MEMORY,
+        pin_memory=config.PIN_MEMORY
     )
-
-    class_to_idx = test_dataset.class_to_idx
-
+    
     # Sınıf isimlerini index sırasına göre alalım (Raporlama için)
     idx_to_class = {v: k for k, v in class_to_idx.items()}
     class_names = [idx_to_class[i] for i in range(len(idx_to_class))]
@@ -63,7 +43,7 @@ def evaluate_model(model_path):
     model = WheatDiseaseClassifier(
         num_classes=config.NUM_CLASSES,
         model_name=config.MODEL_NAME,
-        pretrained=False,  # Zaten kendi eğittiğimiz ağırlıkları yükleyeceğiz
+        pretrained=False  # Zaten kendi eğittiğimiz ağırlıkları yükleyeceğiz
     ).to(device)
 
     # 4. Kayıtlı .pth Dosyasını Yükle
@@ -73,11 +53,11 @@ def evaluate_model(model_path):
         return
 
     checkpoint = torch.load(model_path, map_location=device)
-
+    
     # Eğitim sırasında "checkpoint" sözlüğü (dict) kaydettiysek:
-    if isinstance(checkpoint, dict) and "model_state_dict" in checkpoint:
-        model.load_state_dict(checkpoint["model_state_dict"])
-        epoch_info = checkpoint.get("epoch", "Bilinmiyor")
+    if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+        model.load_state_dict(checkpoint['model_state_dict'])
+        epoch_info = checkpoint.get('epoch', 'Bilinmiyor')
         print(f"✅ Checkpoint başarıyla yüklendi. (Kaydedildiği Epoch: {epoch_info})")
     else:
         # Eğer sadece ağırlıkları (state_dict) doğrudan kaydettiysek:
@@ -92,23 +72,23 @@ def evaluate_model(model_path):
     test_labels = []
 
     print("⏳ Test seti üzerinde tahminler yapılıyor, lütfen bekleyin...")
-
+    
     # torch.no_grad() ile RAM kullanımını düşürüp hızı artırıyoruz
     with torch.no_grad():
         for images, labels in test_loader:
             images = images.to(device)
             labels = labels.to(device)
-
+            
             outputs = model(images)
             _, predicted = torch.max(outputs, 1)
-
+            
             test_preds.extend(predicted.cpu().numpy())
             test_labels.extend(labels.cpu().numpy())
 
     # 7. Sonuçları ve Raporu Hesapla
     accuracy = accuracy_score(test_labels, test_preds)
     f1 = f1_score(test_labels, test_preds, average="weighted")
-
+    
     print("\n" + "=" * 60)
     print("🏆 FİNAL TEST SONUÇLARI")
     print("=" * 60)
@@ -116,16 +96,11 @@ def evaluate_model(model_path):
     print(f"📈 Test F1-Score : {f1 * 100:.2f}%")
     print("-" * 60)
     print("📋 Detaylı Sınıflandırma Raporu (Sklearn):")
-    print(
-        classification_report(
-            test_labels, test_preds, target_names=class_names, zero_division=0
-        )
-    )
+    print(classification_report(test_labels, test_preds, target_names=class_names, zero_division=0))
     print("=" * 60)
-
-
+    
 if __name__ == "__main__":
     # Yolu CHECKPOINTS_DIR olarak değiştirip doğru dosya adını yazıyoruz
     MODEL_PATH = config.CHECKPOINTS_DIR / "best_swin_model.pth"
-
-    evaluate_model(MODEL_PATH)
+    
+    evaluate_model(MODEL_PATH)

{models → BACKEND/models}/model.py

@@ -2,8 +2,10 @@ import torch
 import torch.nn as nn
 from torchvision.models import swin_t, Swin_T_Weights
 
-# 🤖 MODEL: SWIN TRANSFORMER WHEAT DISEASE CLASSIFIER
 
+# ============================================================================
+# 🤖 MODEL: SWIN TRANSFORMER WHEAT DISEASE CLASSIFIER
+# ============================================================================
 
 class WheatDiseaseClassifier(nn.Module):
     """
@@ -18,19 +20,19 @@ class WheatDiseaseClassifier(nn.Module):
         Aşama 2 (Epoch 5+)  : Backbone açılır, differential LR uygulanır.
     """
 
-    def __init__(
-        self, num_classes: int, model_name: str = "swin_t", pretrained: bool = True
-    ):
+    def __init__(self, num_classes: int, model_name: str = "swin_t", pretrained: bool = True):
         super(WheatDiseaseClassifier, self).__init__()
 
         self.num_classes = num_classes
-        self.model_name = model_name
+        self.model_name  = model_name
 
+        # ── Backbone ──────────────────────────────────────────────────────────
         if pretrained:
             self.base_model = swin_t(weights=Swin_T_Weights.DEFAULT)
         else:
             self.base_model = swin_t(weights=None)
 
+        # ── Sınıflandırma Kafası ──────────────────────────────────────────────
         # Swin-T çıkış boyutu: 768
         num_features = self.base_model.head.in_features
 
@@ -42,9 +44,13 @@ class WheatDiseaseClassifier(nn.Module):
             nn.Linear(512, num_classes),
         )
 
+    # ── Forward ───────────────────────────────────────────────────────────────
+
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         return self.base_model(x)
 
+    # ── Fine-tuning Yardımcıları ──────────────────────────────────────────────
+
     def freeze_backbone(self):
         """Backbone'u dondurur — yalnızca head eğitilir (Aşama 1)."""
         for param in self.base_model.features.parameters():
@@ -83,11 +89,13 @@ class WheatDiseaseClassifier(nn.Module):
             },
         ]
 
+    # ── Model Bilgisi ─────────────────────────────────────────────────────────
+
     def model_summary(self):
         """Parametre sayılarını yazdırır."""
-        total = sum(p.numel() for p in self.parameters())
+        total     = sum(p.numel() for p in self.parameters())
         trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
-        frozen = total - trainable
+        frozen    = total - trainable
         print(f"\n{'─'*50}")
         print(f"  Model          : {self.model_name}")
         print(f"  Num Classes    : {self.num_classes}")
@@ -97,6 +105,10 @@ class WheatDiseaseClassifier(nn.Module):
         print(f"{'─'*50}\n")
 
 
+# ============================================================================
+# 🧪 TEST
+# ============================================================================
+
 if __name__ == "__main__":
     model = WheatDiseaseClassifier(num_classes=15, pretrained=False)
     model.model_summary()
@@ -111,7 +123,7 @@ if __name__ == "__main__":
 
     # Forward pass testi
     dummy = torch.randn(2, 3, 224, 224)
-    out = model(dummy)
-    print(f"Output shape: {out.shape}")  # [2, 15]
+    out   = model(dummy)
+    print(f"Output shape: {out.shape}")   # [2, 15]
     assert out.shape == (2, 15), "❌ Output shape yanlış!"
-    print("✅ Model forward pass başarılı.")
+    print("✅ Model forward pass başarılı.")

pipeline.py → BACKEND/pipeline.py

@@ -1,10 +1,19 @@
+"""
+PIPELINE.PY - Combined Analysis Pipeline
+Flow:
+    Image -> Preprocessing -> Classification
+          -> API-ready dict
+"""
+
+import io
+import base64
 import time
 import torch
 import numpy as np
 import torch.nn.functional as F
 from PIL import Image
 from pathlib import Path
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 import sys
@@ -18,22 +27,51 @@ from utils.dataset import get_transforms
 
 import config
 
+
+# ============================================================================
+# OUTPUT DATASTRUCTURE
+# ============================================================================
+
 @dataclass
 class PipelineResult:
+    """Classification and quality output."""
+
+    # -- Classification --------------------------------------------------------
     predicted_class:    str
     confidence:         float
     is_certain:         bool
-    top3_predictions:   list
+    top3_predictions:   list          # [(class, score), ...]
 
+    # -- Quality ---------------------------------------------------------------
     quality_valid:      bool
     quality_warnings:   list
     blur_score:         float
     rejection_reason:   Optional[str]
 
+    # -- Meta ------------------------------------------------------------------
     processing_time_ms: float
-    image_size:         tuple
+    image_size:         tuple          # (W, H) original
+
+
+# ============================================================================
+# PIPELINE
+# ============================================================================
 
 class WheatDiseasePipeline:
+    """
+    Wheat disease analysis pipeline (Classification Only).
+
+    Modules:
+        1. ImagePreprocessor  -> CLAHE + quality filter
+        2. WheatDiseaseClassifier (Swin-T) -> 15 classes
+
+    Args:
+        cls_checkpoint  : Swin-T checkpoint path (.pth)
+        cls_mapping     : class_mapping.json path
+        device          : "cuda" | "cpu"
+        cls_conf         : Classification confidence threshold
+    """
+
     def __init__(
         self,
         cls_checkpoint:   str  = None,
@@ -41,9 +79,10 @@ class WheatDiseasePipeline:
         device:           str  = None,
         cls_conf:         float = 0.50,
     ):
-        self.device   = device or ("cuda" if torch.cuda.is_available() else "cpu")
-        self.cls_conf = cls_conf
+        self.device        = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.cls_conf      = cls_conf
 
+        # Default paths
         cls_checkpoint = cls_checkpoint or str(
             project_root / "models" / "checkpoints" / "best_swin_model.pth"
         )
@@ -51,40 +90,50 @@ class WheatDiseasePipeline:
             project_root / "models" / "class_mapping.json"
         )
 
-        self.preprocessor = ImagePreprocessor(target_size=(640, 640))
+        # -- Preprocessing -----------------------------------------------------
+        self.preprocessor = ImagePreprocessor(target_size=(224, 224))
+
+        # -- Classifier --------------------------------------------------------
         self.idx_to_class, self.num_classes = self._load_mapping(cls_mapping)
         self.classifier    = self._load_classifier(cls_checkpoint)
         _, self.cls_transform = get_transforms()
 
-        print(f"Pipeline hazır | device={self.device}")
+        print(f"Pipeline ready | device={self.device}")
+
+    # -- Main Method -----------------------------------------------------------
 
-    def run(self, source, skip_quality: bool = False) -> PipelineResult:
+    def run(
+        self,
+        source,                        # bytes | PIL.Image | np.ndarray | str path
+        skip_quality: bool = False,
+    ) -> PipelineResult:
+        """Runs analysis pipeline."""
         t0 = time.perf_counter()
+
+        # 1. -- Source -> numpy ------------------------------------------------
         bgr = self._to_bgr(source)
+
+        # 2. -- Preprocessing --------------------------------------------------
         pre: PreprocessResult = self.preprocessor.process(bgr, skip_quality_check=skip_quality)
 
+        # If quality fails, return early
         if not pre.quality.is_valid:
             elapsed = (time.perf_counter() - t0) * 1000
             return self._rejected_result(pre, elapsed)
 
+        # 3. -- Classification (Swin-T) ----------------------------------------
         cls_result = self._run_classification(pre.image_pil)
+
+        # 4. -- Combine Results ------------------------------------------------
         elapsed = (time.perf_counter() - t0) * 1000
+        return self._build_result(pre, cls_result, elapsed)
 
-        return PipelineResult(
-            predicted_class     = cls_result["predicted_class"],
-            confidence          = cls_result["confidence"],
-            is_certain          = cls_result["is_certain"],
-            top3_predictions    = cls_result["top3"],
-            quality_valid       = pre.quality.is_valid,
-            quality_warnings    = pre.quality.warnings,
-            blur_score          = pre.quality.blur_score,
-            rejection_reason    = None,
-            processing_time_ms  = round(elapsed, 1),
-            image_size          = pre.original_size,
-        )
+    # -- Classification --------------------------------------------------------
 
     def _run_classification(self, pil_image: Image.Image) -> dict:
+        """Classify image using Swin-T."""
         tensor = self.cls_transform(pil_image).unsqueeze(0).to(self.device)
+
         with torch.no_grad():
             logits = self.classifier(tensor)
             probs  = F.softmax(logits, dim=1)[0]
@@ -95,19 +144,41 @@ class WheatDiseasePipeline:
              round(p.item(), 4))
             for i, p in zip(top3_idx, top3_probs)
         ]
+
         best_class = top3[0][0]
         best_conf  = top3[0][1]
 
         return {
-            "predicted_class" : best_class if best_conf >= self.cls_conf else "Belirsiz",
+            "predicted_class" : best_class if best_conf >= self.cls_conf else "Uncertain",
             "confidence"      : best_conf,
             "is_certain"      : best_conf >= self.cls_conf,
             "top3"            : top3,
         }
 
+    # -- Build Result ----------------------------------------------------------
+
+    def _build_result(
+        self,
+        pre:        PreprocessResult,
+        cls:        dict,
+        elapsed_ms: float,
+    ) -> PipelineResult:
+        return PipelineResult(
+            predicted_class     = cls["predicted_class"],
+            confidence          = cls["confidence"],
+            is_certain          = cls["is_certain"],
+            top3_predictions    = cls["top3"],
+            quality_valid       = pre.quality.is_valid,
+            quality_warnings    = pre.quality.warnings,
+            blur_score          = pre.quality.blur_score,
+            rejection_reason    = None,
+            processing_time_ms  = round(elapsed_ms, 1),
+            image_size          = pre.original_size,
+        )
+
     def _rejected_result(self, pre: PreprocessResult, elapsed_ms: float) -> PipelineResult:
         return PipelineResult(
-            predicted_class     = "Reddedildi",
+            predicted_class     = "Rejected",
             confidence          = 0.0,
             is_certain          = False,
             top3_predictions    = [],
@@ -119,28 +190,33 @@ class WheatDiseasePipeline:
             image_size          = pre.original_size,
         )
 
+    # -- Helpers ---------------------------------------------------------------
+
     def _to_bgr(self, source) -> np.ndarray:
         import cv2
         if isinstance(source, bytes):
             arr = np.frombuffer(source, np.uint8)
             bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
             if bgr is None:
-                raise ValueError("Geçersiz görüntü bytes verisi")
+                raise ValueError("Invalid image bytes")
             return bgr
         if isinstance(source, Image.Image):
             return cv2.cvtColor(np.array(source.convert("RGB")), cv2.COLOR_RGB2BGR)
         if isinstance(source, np.ndarray):
             return source
+        # File path
         bgr = cv2.imread(str(source))
         if bgr is None:
-            raise FileNotFoundError(f"Görüntü bulunamadı: {source}")
+            raise FileNotFoundError(f"Image not found: {source}")
         return bgr
 
     def _load_mapping(self, mapping_path: str):
         import json
         path = Path(mapping_path)
         if not path.exists():
-            raise FileNotFoundError("class_mapping.json bulunamadı.")
+            raise FileNotFoundError(
+                f"class_mapping.json not found: {mapping_path}"
+            )
         with open(path, "r", encoding="utf-8") as f:
             idx_to_class = json.load(f)
         return idx_to_class, len(idx_to_class)
@@ -151,24 +227,19 @@ class WheatDiseasePipeline:
         )
         path = Path(checkpoint_path)
         if not path.exists():
-            print(f"⚠️  UYARI: Checkpoint bulunamadı: {checkpoint_path}")
-            print("💡 İPUCU: Modeli henüz eğitmediyseniz 'training/train.py' scriptini çalıştırın")
-            print("   veya hazır 'best_swin_model.pth' dosyasının doğru konumda olduğundan emin olun.")
-            return model # Boş model döner, tahminler hatalı olur ama API çökmez
-            
-        try:
-            ckpt = torch.load(checkpoint_path, map_location=self.device)
-            state = ckpt["model_state_dict"] if "model_state_dict" in ckpt else ckpt
-            model.load_state_dict(state)
-            model.to(self.device)
-            model.eval()
-            print(f"✅ Model başarıyla yüklendi: {path.name}")
-        except Exception as e:
-            print(f"❌ Model yükleme hatası: {e}")
-            
+            raise FileNotFoundError(
+                f"Checkpoint not found: {checkpoint_path}"
+            )
+        ckpt = torch.load(checkpoint_path, map_location=self.device)
+        state = ckpt["model_state_dict"] if "model_state_dict" in ckpt else ckpt
+        model.load_state_dict(state)
+        model.to(self.device)
+        model.eval()
+        print(f"Classifier loaded: {path.name}")
         return model
 
     def result_to_dict(self, r: PipelineResult) -> dict:
+        """JSON-serializable dict for FastAPI response."""
         return {
             "classification": {
                 "predicted_class" : r.predicted_class,

preprocessing.py → BACKEND/preprocessing.py

@@ -15,6 +15,9 @@ from dataclasses import dataclass, field
 from typing import Optional, Tuple
 
 
+# ============================================================================
+# 📦 VERİ YAPILARI
+# ============================================================================
 
 @dataclass
 class QualityReport:
@@ -39,6 +42,9 @@ class PreprocessResult:
     processed_size:  Tuple[int, int]
 
 
+# ============================================================================
+# ⚙️ KALİBRASYON EŞİKLERİ
+# ============================================================================
 
 class QualityThresholds:
     BLUR_MIN        = 80.0    # Bu altı → bulanık
@@ -51,6 +57,9 @@ class QualityThresholds:
     GREEN_MIN_RATIO = 0.05    # Görüntünün en az %5'i yeşil olmalı
 
 
+# ============================================================================
+# 🔧 ÖN İŞLEYİCİ
+# ============================================================================
 
 class ImagePreprocessor:
     """
@@ -85,6 +94,7 @@ class ImagePreprocessor:
             tileGridSize= clahe_grid,
         )
 
+    # ── Ana Metod ─────────────────────────────────────────────────────────────
 
     def process(
         self,
@@ -131,6 +141,7 @@ class ImagePreprocessor:
             processed_size = self.target_size,
         )
 
+    # ── Görüntü Yükleme ───────────────────────────────────────────────────────
 
     def _load_to_bgr(self, source) -> np.ndarray:
         """Her formatı BGR numpy array'e çevirir."""
@@ -153,6 +164,7 @@ class ImagePreprocessor:
             raise ValueError(f"Görüntü okunamadı: {path}")
         return bgr
 
+    # ── CLAHE ─────────────────────────────────────────────────────────────────
 
     def _apply_clahe(self, bgr: np.ndarray) -> np.ndarray:
         """
@@ -165,6 +177,7 @@ class ImagePreprocessor:
         lab_clahe = cv2.merge([l_clahe, a, b])
         return cv2.cvtColor(lab_clahe, cv2.COLOR_LAB2BGR)
 
+    # ── Kalite Kontrolü ───────────────────────────────────────────────────────
 
     def _check_quality(self, bgr: np.ndarray) -> QualityReport:
         t = self.thresholds
@@ -227,6 +240,7 @@ class ImagePreprocessor:
             warnings    = warnings,
         )
 
+    # ── Yardımcılar ───────────────────────────────────────────────────────────
 
     def quality_to_dict(self, q: QualityReport) -> dict:
         return {
@@ -240,6 +254,9 @@ class ImagePreprocessor:
         }
 
 
+# ============================================================================
+# 🧪 TEST
+# ============================================================================
 
 if __name__ == "__main__":
     import sys

requirements.txt → BACKEND/requirements.txt

@@ -13,5 +13,3 @@ pydantic>=2.0.0
 tqdm>=4.65.0
 kaggle>=1.6.0
 python-dotenv>=1.0.0
-gradio>=3.35.0
-opencv-python-headless

BACKEND/training/find_corrupt_images.py

@@ -0,0 +1,41 @@
+import os
+from glob import glob
+from PIL import Image
+
+def find_corrupt_images(data_dir):
+    print(f"Veri dizini aranıyor: {os.path.abspath(data_dir)}")
+    image_files = glob(os.path.join(data_dir, '**', '*.jpg'), recursive=True) + \
+                  glob(os.path.join(data_dir, '**', '*.jpeg'), recursive=True) + \
+                  glob(os.path.join(data_dir, '**', '*.png'), recursive=True)
+    
+    print(f"Toplam {len(image_files)} resim bulundu. Taranıyor...")
+    
+    corrupt_images = []
+    
+    for i, file_path in enumerate(image_files):
+        if i % 1000 == 0 and i > 0:
+            print(f"{i} resim tarandı...")
+            
+        try:
+            with Image.open(file_path) as img:
+                # verify() sadece dosyanın bir resim olduğunu doğrular
+                img.verify()
+            
+            # verify() kapatıp açmayı gerektirdiği için yeniden açıyoruz
+            # load() veriyi belleğe alır, bozuk byte kısımlarını burada yakalarız
+            with Image.open(file_path) as img:
+                img.load()
+                
+        except Exception as e:
+            print(f"Bozuk dosya bulundu: {file_path} - Hata: {str(e)}")
+            corrupt_images.append((file_path, str(e)))
+            
+    print("-" * 50)
+    print(f"Tarama bitti. Toplam {len(corrupt_images)} adet bozuk resim bulundu.")
+    for file, err in corrupt_images:
+        print(f"> {file}")
+        
+    return corrupt_images
+
+if __name__ == "__main__":
+    find_corrupt_images("../data")

BACKEND/training/find_corrupt_images_fast.py

@@ -0,0 +1,43 @@
+import os
+from glob import glob
+from PIL import Image
+from concurrent.futures import ProcessPoolExecutor
+
+def check_image(file_path):
+    try:
+        with Image.open(file_path) as img:
+            img.verify()
+        with Image.open(file_path) as img:
+            img.load()
+        return None
+    except Exception as e:
+        return (file_path, str(e))
+
+def find_corrupt_images(data_dir):
+    print(f"Hızlı tarama başlatılıyor: {os.path.abspath(data_dir)}")
+    image_files = glob(os.path.join(data_dir, '**', '*.jpg'), recursive=True) + \
+                  glob(os.path.join(data_dir, '**', '*.jpeg'), recursive=True) + \
+                  glob(os.path.join(data_dir, '**', '*.png'), recursive=True)
+    
+    print(f"Toplam {len(image_files)} resim taramaya alınıyor...")
+    
+    corrupt_images = []
+    with ProcessPoolExecutor() as executor:
+        results = executor.map(check_image, image_files)
+        
+        for i, res in enumerate(results):
+            if i % 2000 == 0 and i > 0:
+                print(f"{i} resim tarandı...")
+            if res is not None:
+                print(f"Bozuk dosya bulundu: {res[0]} - Hata: {res[1]}")
+                corrupt_images.append(res)
+                
+    print("-" * 50)
+    print(f"Tarama bitti. Toplam {len(corrupt_images)} adet bozuk resim bulundu.")
+    for file, err in corrupt_images:
+        print(f"> {file}")
+        
+    return corrupt_images
+
+if __name__ == "__main__":
+    find_corrupt_images("../data")

{training → BACKEND/training}/train.py

@@ -7,7 +7,7 @@ TRAIN.PY — Swin Transformer Wheat Disease Classifier
     • Aşamalı Fine-tuning (freeze → unfreeze)
     • Detaylı metrik takibi (Accuracy, F1, Precision, Recall)
     • Checkpoint kaydetme (best + periyodik)
-    • Kaldığı yerden devam etme (resume training)
+    • ✨ Kaldığı yerden devam etme (resume training)
 """
 
 import os
@@ -36,10 +36,9 @@ from sklearn.metrics import (
     classification_report,
 )
 
+# ── Proje path ayarı ──────────────────────────────────────────────────────────
 current_dir = Path(__file__).resolve().parent
-project_root = (
-    current_dir.parent if (current_dir.parent / "config.py").exists() else current_dir
-)
+project_root = current_dir.parent if (current_dir.parent / "config.py").exists() else current_dir
 if str(project_root) not in sys.path:
     sys.path.append(str(project_root))
 
@@ -48,6 +47,10 @@ from utils.dataset import get_dataloaders
 from models.model import WheatDiseaseClassifier
 
 
+# ============================================================================
+# 📝 LOGGER
+# ============================================================================
+
 def setup_logger() -> logging.Logger:
     logger = logging.getLogger("WheatTrainer")
     logger.setLevel(config.LOG_LEVEL)
@@ -60,9 +63,7 @@ def setup_logger() -> logging.Logger:
 
     if config.FILE_LOG:
         config.LOGS_DIR.mkdir(parents=True, exist_ok=True)
-        log_file = (
-            config.LOGS_DIR / f"train_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
-        )
+        log_file = config.LOGS_DIR / f"train_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
         fh = logging.FileHandler(log_file, encoding="utf-8")
         fh.setFormatter(formatter)
         logger.addHandler(fh)
@@ -71,6 +72,10 @@ def setup_logger() -> logging.Logger:
     return logger
 
 
+# ============================================================================
+# 🎲 REPRODUCIBILITY
+# ============================================================================
+
 def set_seed(seed: int = config.SEED):
     torch.manual_seed(seed)
     np.random.seed(seed)
@@ -81,24 +86,20 @@ def set_seed(seed: int = config.SEED):
         torch.backends.cudnn.benchmark = False
 
 
+# ============================================================================
+# 📊 METRİKLER
+# ============================================================================
+
 def calculate_metrics(preds: np.ndarray, labels: np.ndarray) -> dict:
     """Accuracy, Precision, Recall, F1 ve confusion matrix hesaplar."""
     return {
         "accuracy": float(accuracy_score(labels, preds)),
-        "precision": float(
-            precision_score(labels, preds, average="weighted", zero_division=0)
-        ),
-        "recall": float(
-            recall_score(labels, preds, average="weighted", zero_division=0)
-        ),
+        "precision": float(precision_score(labels, preds, average="weighted", zero_division=0)),
+        "recall": float(recall_score(labels, preds, average="weighted", zero_division=0)),
         "f1_score": float(f1_score(labels, preds, average="weighted", zero_division=0)),
         "per_class_f1": f1_score(labels, preds, average=None, zero_division=0).tolist(),
-        "per_class_precision": precision_score(
-            labels, preds, average=None, zero_division=0
-        ).tolist(),
-        "per_class_recall": recall_score(
-            labels, preds, average=None, zero_division=0
-        ).tolist(),
+        "per_class_precision": precision_score(labels, preds, average=None, zero_division=0).tolist(),
+        "per_class_recall": recall_score(labels, preds, average=None, zero_division=0).tolist(),
         "confusion_matrix": confusion_matrix(labels, preds).tolist(),
     }
 
@@ -106,7 +107,7 @@ def calculate_metrics(preds: np.ndarray, labels: np.ndarray) -> dict:
 def log_metrics(metrics: dict, class_names: list, stage: str, logger: logging.Logger):
     """Metrikleri okunabilir şekilde loglar."""
     logger.info(f"\n{'='*70}")
-    logger.info(f" {stage.upper()} METRİKLERİ")
+    logger.info(f"📊 {stage.upper()} METRİKLERİ")
     logger.info(f"{'='*70}")
     logger.info(f"  Accuracy  : {metrics['accuracy']*100:6.2f}%")
     logger.info(f"  Precision : {metrics['precision']*100:6.2f}%")
@@ -125,6 +126,10 @@ def log_metrics(metrics: dict, class_names: list, stage: str, logger: logging.Lo
     logger.info(f"{'='*70}\n")
 
 
+# ============================================================================
+# ⏹️ EARLY STOPPING
+# ============================================================================
+
 class EarlyStopping:
     """
     Validation accuracy belirli epoch boyunca iyileşmezse eğitimi durdurur.
@@ -162,6 +167,10 @@ class EarlyStopping:
         return self.stop
 
 
+# ============================================================================
+# 🏋️ EĞİTİM DÖNGÜSÜ
+# ============================================================================
+
 def train_model():
     logger = setup_logger()
     set_seed()
@@ -174,22 +183,22 @@ def train_model():
     config.print_config()
 
     device = config.DEVICE
-    logger.info(f" Cihaz: {device}")
+    logger.info(f"🚀 Cihaz: {device}")
     for k, v in config.get_device_info().items():
         logger.info(f"  • {k}: {v}")
 
+    # ── AMP Scaler ────────────────────────────────────────────────────────────
     use_amp = config.USE_MIXED_PRECISION and torch.cuda.is_available()
     scaler = GradScaler(init_scale=config.SCALER_INIT_SCALE) if use_amp else None
     logger.info(f"⚡ Mixed Precision (AMP): {'Aktif' if use_amp else 'Devre Dışı'}")
 
+    # ── Veri ──────────────────────────────────────────────────────────────────
     logger.info("📦 Veri setleri yükleniyor...")
-    train_loader, val_loader, test_loader, class_to_idx, class_weights = (
-        get_dataloaders(
-            data_dir=str(config.DATA_DIR),
-            batch_size=config.BATCH_SIZE,
-            num_workers=config.NUM_WORKERS,
-            pin_memory=config.PIN_MEMORY,
-        )
+    train_loader, val_loader, test_loader, class_to_idx, class_weights = get_dataloaders(
+        data_dir=str(config.DATA_DIR),
+        batch_size=config.BATCH_SIZE,
+        num_workers=config.NUM_WORKERS,
+        pin_memory=config.PIN_MEMORY,
     )
 
     config.CLASS_TO_IDX = class_to_idx
@@ -203,6 +212,7 @@ def train_model():
         json.dump(config.IDX_TO_CLASS, f, indent=4, ensure_ascii=False)
     logger.info(f"✅ Class mapping kaydedildi: {mapping_path}")
 
+    # ── Model ─────────────────────────────────────────────────────────────────
     logger.info("🤖 Model oluşturuluyor...")
     model = WheatDiseaseClassifier(
         num_classes=config.NUM_CLASSES,
@@ -215,25 +225,22 @@ def train_model():
     if config.FREEZE_BACKBONE_INITIALLY:
         model.freeze_backbone()
 
+    # ── Loss ──────────────────────────────────────────────────────────────────
     class_weights = class_weights.to(device)
     criterion = nn.CrossEntropyLoss(
         weight=class_weights,
         label_smoothing=config.LABEL_SMOOTHING,
     )
-    logger.info(
-        f"📉 Loss: CrossEntropyLoss | Label Smoothing: {config.LABEL_SMOOTHING}"
-    )
+    logger.info(f"📉 Loss: CrossEntropyLoss | Label Smoothing: {config.LABEL_SMOOTHING}")
 
-    early_stopping = (
-        EarlyStopping(
-            patience=config.EARLY_STOPPING_PATIENCE,
-            delta=config.EARLY_STOPPING_DELTA,
-            logger=logger,
-        )
-        if config.USE_EARLY_STOPPING
-        else None
-    )
+    # ── Early Stopping ────────────────────────────────────────────────────────
+    early_stopping = EarlyStopping(
+        patience=config.EARLY_STOPPING_PATIENCE,
+        delta=config.EARLY_STOPPING_DELTA,
+        logger=logger,
+    ) if config.USE_EARLY_STOPPING else None
 
+    # ── Tarihçe ───────────────────────────────────────────────────────────────
     history = {m: [] for m in config.TRACK_METRICS}
     history["val_f1"] = []
 
@@ -241,6 +248,7 @@ def train_model():
     best_val_f1 = 0.0
     val_metrics_log = []
 
+    # ── Checkpoint Resume (Sadece model ağırlıkları, optimizer/scheduler sıfır) ──
     resume_path = config.CHECKPOINTS_DIR / "checkpoint_epoch_030.pth"
     start_epoch = 1  # Eğitimi 1'den başlat (sadece ağırlıklar alınır)
 
@@ -248,15 +256,14 @@ def train_model():
         logger.info(f"♻️  Önceki model ağırlıkları yükleniyor: {resume_path}")
         checkpoint = torch.load(resume_path, map_location=device)
         # SADECE MODEL AĞIRLIKLARINI YÜKLE (optimizer/scheduler resetlenecek)
-        model.load_state_dict(checkpoint["model_state_dict"])
+        model.load_state_dict(checkpoint['model_state_dict'])
         # 384px'e geçtiğimiz için backbone'un açık olduğundan emin olalım
         model.unfreeze_backbone()
-        logger.info(
-            "✅ Model ağırlıkları aktarıldı. Optimizer ve scheduler sıfırdan başlatılıyor."
-        )
+        logger.info("✅ Model ağırlıkları aktarıldı. Optimizer ve scheduler sıfırdan başlatılıyor.")
     else:
         logger.warning("⚠️ Checkpoint bulunamadı, eğitim sıfırdan başlıyor!")
 
+    # ── Optimizer & Scheduler (Taze başlangıç) ─────────────────────────────────
     # Differential LR için parametre grupları
     backbone_lr = config.LEARNING_RATE / config.LR_DIVISOR
     head_lr = config.LEARNING_RATE
@@ -278,15 +285,16 @@ def train_model():
 
     total_start = time.time()
 
+    # ══════════════════════════════════════════════════════════════════════════
     # EPOCH DÖNGÜSÜ
+    # ══════════════════════════════════════════════════════════════════════════
     for epoch in range(start_epoch, config.EPOCHS + 1):
         epoch_start = time.time()
 
+        # ── Backbone Unfreeze (aşamalı fine-tuning) ───────────────────────────
         if epoch == config.UNFREEZE_EPOCH and config.FREEZE_BACKBONE_INITIALLY:
             logger.info(f"\n{'='*70}")
-            logger.info(
-                f"[Epoch {epoch}] 🔓 Backbone açılıyor — Differential LR uygulanıyor"
-            )
+            logger.info(f"[Epoch {epoch}] 🔓 Backbone açılıyor — Differential LR uygulanıyor")
             logger.info(f"{'='*70}")
 
             model.unfreeze_backbone()
@@ -306,6 +314,7 @@ def train_model():
                 logger.info(f"  Backbone LR : {backbone_lr}")
                 logger.info(f"  Head LR     : {head_lr}")
 
+        # ── TRAIN ─────────────────────────────────────────────────────────────
         model.train()
         running_loss = 0.0
         batch_count = 0
@@ -325,9 +334,7 @@ def train_model():
                     loss = criterion(outputs, labels)
                 scaler.scale(loss).backward()
                 scaler.unscale_(optimizer)
-                torch.nn.utils.clip_grad_norm_(
-                    model.parameters(), config.GRADIENT_CLIP_MAX_NORM
-                )
+                torch.nn.utils.clip_grad_norm_(model.parameters(), config.GRADIENT_CLIP_MAX_NORM)
                 scaler.step(optimizer)
                 scaler.update()
             else:
@@ -337,9 +344,7 @@ def train_model():
                     logger.error(f"❌ NaN loss — epoch {epoch}, batch {batch_idx}")
                     continue
                 loss.backward()
-                torch.nn.utils.clip_grad_norm_(
-                    model.parameters(), config.GRADIENT_CLIP_MAX_NORM
-                )
+                torch.nn.utils.clip_grad_norm_(model.parameters(), config.GRADIENT_CLIP_MAX_NORM)
                 optimizer.step()
 
             running_loss += loss.item() * images.size(0)
@@ -357,6 +362,7 @@ def train_model():
 
         epoch_train_loss = running_loss / len(train_loader.dataset)
 
+        # ── VALIDATION ────────────────────────────────────────────────────────
         if epoch % config.VALIDATION_INTERVAL == 0 or epoch == config.EPOCHS:
             model.eval()
             val_loss = 0.0
@@ -396,6 +402,7 @@ def train_model():
         current_lr = optimizer.param_groups[0]["lr"]
         epoch_time = time.time() - epoch_start
 
+        # ── History ───────────────────────────────────────────────────────────
         history["train_loss"].append(epoch_train_loss)
         history["val_loss"].append(epoch_val_loss)
         history["val_accuracy"].append(epoch_val_acc)
@@ -403,8 +410,9 @@ def train_model():
         history["learning_rate"].append(current_lr)
         history["epoch_time"].append(epoch_time)
 
+        # ── Epoch Özeti ───────────────────────────────────────────────────────
         logger.info(
-            f"\n Epoch {epoch:02d}/{config.EPOCHS} — "
+            f"\n✅ Epoch {epoch:02d}/{config.EPOCHS} — "
             f"Train Loss: {epoch_train_loss:.4f} | "
             f"Val Loss: {epoch_val_loss:.4f} | "
             f"Val Acc: {epoch_val_acc*100:.2f}% | "
@@ -413,6 +421,7 @@ def train_model():
             f"Süre: {epoch_time:.1f}s"
         )
 
+        # ── Best Model Kaydet ─────────────────────────────────────────────────
         if epoch_val_acc > best_val_acc:
             best_val_acc = epoch_val_acc
             best_val_f1 = epoch_val_f1
@@ -444,23 +453,22 @@ def train_model():
                 f"(Acc: {best_val_acc*100:.2f}% | F1: {best_val_f1*100:.2f}%)"
             )
 
+        # ── Periyodik Checkpoint ──────────────────────────────────────────────
         if epoch % config.SAVE_CHECKPOINT_INTERVAL == 0:
             periodic_path = config.CHECKPOINTS_DIR / f"checkpoint_epoch_{epoch:03d}.pth"
-            torch.save(
-                {
-                    "epoch": epoch,
-                    "model_state_dict": model.state_dict(),
-                    "optimizer_state_dict": optimizer.state_dict(),
-                    "scheduler_state_dict": scheduler.state_dict(),
-                    "val_acc": epoch_val_acc,
-                    "history": history,
-                },
-                periodic_path,
-            )
+            torch.save({
+                "epoch": epoch,
+                "model_state_dict": model.state_dict(),
+                "optimizer_state_dict": optimizer.state_dict(),
+                "scheduler_state_dict": scheduler.state_dict(),
+                "val_acc": epoch_val_acc,
+                "history": history,
+            }, periodic_path)
             logger.info(f"  📌 Periyodik checkpoint: {periodic_path.name}")
 
         logger.info("─" * 70)
 
+        # ── Early Stopping Kontrolü ───────────────────────────────────────────
         if early_stopping and early_stopping(epoch_val_acc):
             logger.info(f"⏹️  Early stopping tetiklendi — Epoch {epoch}")
             break
@@ -497,12 +505,9 @@ def train_model():
     log_metrics(test_metrics, class_names, "TEST", logger)
 
     # sklearn classification report
-    logger.info(
-        "📋 Sklearn Classification Report:\n"
-        + classification_report(
-            test_labels, test_preds, target_names=class_names, zero_division=0
-        )
-    )
+    logger.info("📋 Sklearn Classification Report:\n" +
+                classification_report(test_labels, test_preds,
+                                      target_names=class_names, zero_division=0))
 
     # ══════════════════════════════════════════════════════════════════════════
     # SONUÇ & KAYIT
@@ -542,9 +547,7 @@ def train_model():
     }
 
     config.RESULTS_DIR.mkdir(parents=True, exist_ok=True)
-    result_path = (
-        config.RESULTS_DIR / f"results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    )
+    result_path = config.RESULTS_DIR / f"results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
     with open(result_path, "w", encoding="utf-8") as f:
         json.dump(results, f, indent=4)
     logger.info(f"  📄 Sonuç raporu: {result_path}")
@@ -553,6 +556,10 @@ def train_model():
     return model, history, results
 
 
+# ============================================================================
+# 🎬 MAIN
+# ============================================================================
+
 if __name__ == "__main__":
     logger = setup_logger()
     logger.info("🚀 train.py başlatıldı")
@@ -563,4 +570,4 @@ if __name__ == "__main__":
         logger.warning("⚠️  Eğitim kullanıcı tarafından durduruldu (Ctrl+C)")
     except Exception as e:
         logger.error(f"❌ Eğitim hatası: {e}", exc_info=True)
-        raise
+        raise

BACKEND/utils/analyze_dataset.py

@@ -0,0 +1,50 @@
+import os
+import ssl
+from collections import Counter
+
+# To avoid ssl issues if any downloading happened in the future
+ssl._create_default_https_context = ssl._create_unverified_context
+
+def analyze_dataset(data_dir):
+    print(f"Veri Seti Analizi Başlıyor: {data_dir}\n" + "="*40)
+    
+    splits = ['train', 'valid', 'test']
+    total_images = 0
+    
+    for split in splits:
+        split_dir = os.path.join(data_dir, split)
+        if not os.path.exists(split_dir):
+            print(f"[UYARI] {split} klasörü bulunamadı!")
+            continue
+            
+        print(f"\n--- {split.upper()} Klasörü Sınıf Dağılımı ---")
+        class_counts = {}
+        split_total = 0
+        
+        for class_name in os.listdir(split_dir):
+            class_path = os.path.join(split_dir, class_name)
+            if os.path.isdir(class_path):
+                # Count only image files roughly
+                images = [f for f in os.listdir(class_path) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
+                count = len(images)
+                class_counts[class_name] = count
+                split_total += count
+                
+        # Print sorted by count
+        for class_name, count in sorted(class_counts.items(), key=lambda item: item[1], reverse=True):
+            print(f"  {class_name.ljust(25)}: {count} görsel")
+            
+        print(f"-> Toplam {split.upper()} Görseli: {split_total}")
+        total_images += split_total
+        
+    print("\n" + "="*40)
+    print(f"Toplanan Veri Seti Toplam Büyüklüğü (Tüm Görseller): {total_images}")
+
+if __name__ == "__main__":
+    # Script dosyasının bulunduğu klasöre göre 'data' klasörünün tam yolunu buluyoruz
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    data_path = os.path.join(project_root, "data")
+    
+    analyze_dataset(data_path)
+

{utils → BACKEND/utils}/dataset.py

@@ -7,12 +7,16 @@ from torchvision import transforms, datasets
 from torch.utils.data import DataLoader, Dataset
 
 
+# ============================================================================
 # 📐 GÖRÜNTÜ BOYUTU
+# ============================================================================
 
 IMG_SIZE = 224
 
 
+# ============================================================================
 # 🔄 VERİ DÖNÜŞÜMLER (TRANSFORMS)
+# ============================================================================
 
 def get_transforms():
     """
@@ -50,6 +54,9 @@ def get_transforms():
     return train_transform, val_test_transform
 
 
+# ============================================================================
+# 🖼️ GÜVENLİ GÖRÜNTÜ OKUYUCU
+# ============================================================================
 
 def robust_pil_loader(path: str):
     """
@@ -70,6 +77,9 @@ def robust_pil_loader(path: str):
                 raise e
 
 
+# ============================================================================
+# 🔧 VALID KLASÖRÜ SINIF ADINI DÜZELTİCİ
+# ============================================================================
 
 class RemappedImageFolder(datasets.ImageFolder):
     """
@@ -140,6 +150,9 @@ class RemappedImageFolder(datasets.ImageFolder):
             print(f"⚠️  Toplam {skipped} örnek atlandı (eşleşme bulunamadı)")
 
 
+# ============================================================================
+# ⚖️ CLASS WEIGHTS HESAPLAMA
+# ============================================================================
 
 def compute_class_weights(targets, num_classes):
     """
@@ -169,6 +182,9 @@ def compute_class_weights(targets, num_classes):
     return torch.FloatTensor(class_weights)
 
 
+# ============================================================================
+# 🚀 ANA FONKSİYON: DATALOADER'LAR
+# ============================================================================
 
 def get_dataloaders(
     data_dir: str,
@@ -206,7 +222,9 @@ def get_dataloaders(
 
     train_transform, val_test_transform = get_transforms()
 
+    # ------------------------------------------------------------------
     # 1. TRAIN DATASET
+    # ------------------------------------------------------------------
     train_dataset = datasets.ImageFolder(
         root=train_dir,
         transform=train_transform,
@@ -219,7 +237,9 @@ def get_dataloaders(
         count = train_dataset.targets.count(idx)
         print(f"   [{idx:2d}] {cls:<25} → {count} görsel")
 
+    # ------------------------------------------------------------------
     # 2. VALID DATASET (Remap ile)
+    # ------------------------------------------------------------------
     # Varsayılan remap: blast_test_valid → Blast
     if valid_remap is None:
         valid_remap = {"blast_test_valid": "Blast"}
@@ -233,7 +253,9 @@ def get_dataloaders(
     print(f"\n✅ Valid sınıfları ({len(valid_dataset.class_to_idx)} adet) — "
           f"Remap uygulandı: {valid_remap}")
 
+    # ------------------------------------------------------------------
     # 3. TEST DATASET
+    # ------------------------------------------------------------------
     test_dataset = datasets.ImageFolder(
         root=test_dir,
         transform=val_test_transform,
@@ -241,7 +263,9 @@ def get_dataloaders(
     )
     print(f"\n✅ Test sınıfları ({len(test_dataset.class_to_idx)} adet)")
 
+    # ------------------------------------------------------------------
     # 4. CLASS WEIGHTS (Dengesizlik için)
+    # ------------------------------------------------------------------
     class_weights = compute_class_weights(
         targets=train_dataset.targets,
         num_classes=len(class_to_idx)
@@ -251,7 +275,9 @@ def get_dataloaders(
     for i, w in enumerate(class_weights):
         print(f"   [{i:2d}] {idx_to_class[i]:<25} → weight: {w:.4f}")
 
+    # ------------------------------------------------------------------
     # 5. DATALOADERS
+    # ------------------------------------------------------------------
     train_loader = DataLoader(
         train_dataset,
         batch_size=batch_size,
@@ -285,6 +311,9 @@ def get_dataloaders(
     return train_loader, valid_loader, test_loader, class_to_idx, class_weights
 
 
+# ============================================================================
+# 🧪 TEST
+# ============================================================================
 
 if __name__ == "__main__":
     import sys

BACKEND/utils/fix_folders.py

@@ -0,0 +1,58 @@
+import os
+
+def fix_folder_names(data_dir):
+    """
+    valid ve test klasörlerindeki sınıf isimlerini train klasöründeki ile aynı yapar.
+    Örn: 'smut_valid' -> 'Smut'
+    """
+    train_dir = os.path.join(data_dir, 'train')
+    valid_dir = os.path.join(data_dir, 'valid')
+    test_dir = os.path.join(data_dir, 'test')
+    
+    # Train klasöründen hedeflenen isimleri çekelim
+    # Örn: 'Smut', 'Stem fly', vs.
+    target_names = [d for d in os.listdir(train_dir) if os.path.isdir(os.path.join(train_dir, d))]
+    
+    # İsimleri küçük harf ve boşluksuz/alt çizgili yapıya getirme haritası
+    # Örn: 'Smut' -> 'smut', 'Yellow Rust' -> 'yellow_rust'
+    name_map = {}
+    for name in target_names:
+        normalized = name.lower().replace(" ", "_").replace("-", "_")
+        name_map[normalized] = name
+
+    # valid için düzeltme
+    for subdir in os.listdir(valid_dir):
+        old_path = os.path.join(valid_dir, subdir)
+        if os.path.isdir(old_path):
+            # 'smut_valid' -> 'smut' bul
+            base_name = subdir.replace("_valid", "").replace("_val", "").lower()
+            if base_name in name_map:
+                new_path = os.path.join(valid_dir, name_map[base_name])
+                if not os.path.exists(new_path):
+                    os.rename(old_path, new_path)
+                    print(f"Renamed: {old_path} -> {new_path}")
+                else:
+                    print(f"Bypass (already exists): {new_path}")
+            else:
+                print(f"[UYARI] Eşleşme bulunamadı: {subdir}")
+
+    # test için düzeltme
+    for subdir in os.listdir(test_dir):
+        old_path = os.path.join(test_dir, subdir)
+        if os.path.isdir(old_path):
+            base_name = subdir.replace("_test", "").lower()
+            if base_name in name_map:
+                new_path = os.path.join(test_dir, name_map[base_name])
+                if not os.path.exists(new_path):
+                    os.rename(old_path, new_path)
+                    print(f"Renamed: {old_path} -> {new_path}")
+                else:
+                    print(f"Bypass (already exists): {new_path}")
+            else:
+                print(f"[UYARI] Eşleşme bulunamadı: {subdir}")
+
+if __name__ == "__main__":
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    data_path = os.path.join(project_root, "data")
+    fix_folder_names(data_path)

README.md

@@ -1,49 +1,37 @@
----
-title: Wheat Disease Detection
-emoji: 🌾
-colorFrom: green
-colorTo: yellow
-sdk: docker
-pinned: false
----
+# 🌾 Buğday Hastalık Tespiti ve Çözüm Motoru (Wheat Disease Detection)
 
-# 🌾 Buğday Hastalık Tespiti API (Wheat Disease Detection)
+Bu proje, buğday yaprağı ve başak görüntülerinden hastalıkları derin öğrenme (*Transfer Learning ile EfficientNet-B3*) tespit eden ve çıkan sonuca göre ziraat standartlarında **çözüm önerileri** üreten uçtan uca (End-to-End) bir çözümdür.
 
-Bu proje, buğday yaprağı ve başak görüntülerinden hastalıkları derin öğrenme (**Swin Transformer (Swin-T)**) modeli kullanarak tespit eden ve bir web API'si sunan uçtan uca (End-to-End) bir çözümdür.
-
-Proje, üretime hazır (production-ready) bir altyapıya sahip olup nesne tespiti veya karmaşık segmentasyon işlemlerinden arındırılmış, tamamen yüksek isabet oranlı görüntü sınıflandırmasına (Image Classification) odaklanmıştır.
+Proje safi bir yapay zeka modelinin ötesinde; bir web API'si sunacak şekilde tasarlanmış, üretime hazır (production-ready) bir altyapıya sahiptir.
 
 ---
 
 ## 🎯 Proje Özellikleri
 
-- **15 Farklı Sınıf Tespiti:** Sağlıklı durumlar ve buğdayda sık görülen çeşitli mantar/zararlı hastalıkları (Pas, Külleme, Septoria vb.) dâhil olmak üzere 15 farklı sınıfı ayırt eder.
-- **Model:** Görüntü işleme alanında son teknoloji olan **Swin Transformer Tiny (Swin-T)** mimarisi.
-- **Aşırı Öğrenme Kontrolleri:** Dinamik Learning Rate Scheduler (Cosine Annealing) ve Mixed Precision (AMP) ile optimize edilmiş PyTorch eğitim döngüsü.
-- **Yüksek Performanslı API:** Python tabanlı [FastAPI](https://fastapi.tiangolo.com/) kullanılarak geliştirilmiş, hızlı, asenkron RESTful entegrasyonu.
-- **Kalite Kontrol (Image Quality Control):** Yüklenen fotoğrafın bulanık (blur) olup olmadığını Laplasyan varyans yöntemiyle tespit ederek hatalı tahminlerin önüne geçer.
+- **7 Farklı Sınıf Tespiti:** Sağlıklı (Healthy), Sarı Pas (Yellow Rust), Kahverengi Pas (Brown Rust), Sap Pası (Stem Rust), Külleme (Powdery Mildew), Septoria ve Fusaryum.
+- **Model:** Transfer Learning ile pre-trained [EfficientNet-B3](https://arxiv.org/abs/1905.11946) mimarisi. (Hızlı çıkarım süresi ve yüksek doğruluk için seçilmiştir.)
+- **Aşırı Öğrenme Kontrolleri:** Dinamik Learning Rate Scheduler (Cosine Annealing), early-stopping (planlandı) ve zengin Veri Artırma (Data Augmentation).
+- **Zengin API Mimarisi:** Python tabanlı [FastAPI](https://fastapi.tiangolo.com/) kullanılarak yüksek performanslı RESTful entegrasyonu.
+- **Bilgi Tabanı (Knowledge Base):** Modele bağlı basit bir uzman sistem. Tespiti yapılan hastalığa göre kimyasal/doğal tarım çözümleri ve acil aksiyon planları sunar.
 
 ---
 
 ## 📂 Dizin Yapısı / Mimari
 
 ```text
-wheat_disease_project/
-├── api.py                 # FastAPI uç noktaları (Endpoints) ve Pydantic Şemaları
-├── pipeline.py            # Görüntü ön işleme ve Swin-T model tahmini (Pipeline)
-├── config.py              # Tüm hiperparametreler ve klasör yolları ayarları
-├── preprocessing.py       # Görüntü bulanıklık kontrolü ve boyutlandırma
-├── data/                  # İşlenmiş ve ham veri setleri (gitignore'da)
-├── models/                # class_mapping.json dosyası ve ağırlıklar
-│   ├── checkpoints/       # Eğitilmiş Swin-T .pth model ağırlık dosyaları
-│   ├── evaluate.py        # Modeli test verisi üzerinde değerlendirme betiği
-│   └── model.py           # Model tanımlama (Swin Transformer Backbone)
-├── training/              
-│   └── train.py           # Eğitim (Training & Validation) döngüleri
-├── inference/             
-│   └── predict.py         # Klasör ve resim bazlı yerel tahmin betiği
-├── utils/
-│   └── dataset.py         # PyTorch DataLoader işlemleri ve Augmentation
+wheat-project/
+├── api/
+│   ├── main.py            # FastAPI uç noktaları (Endpoints)
+│   └── knowledge_base.py  # Hastalık -> Çözüm mantık sözlükleri
+├── data/                  # İşlenmiş ve ham veri (gitignore'da)
+├── models/                # Eğitilmiş .pth model ağırlık dosyaları
+├── src/
+│   ├── dataset.py         # PyTorch DataLoader işlemleri ve Augmentation
+│   ├── model.py           # Model tanımlama (EfficientNet Backbone)
+│   ├── train.py           # Eğitim (Training & Validation) döngüleri
+│   └── inference.py       # API'nin modeli kullanmasını sağlayan tekil tahmin (Prediction) class'ı
+├── Dockerfile             # Konteynerizasyon
+├── requirements.txt       # Gerekli kütüphaneler
 └── README.md
 ```
 
@@ -56,79 +44,64 @@ wheat_disease_project/
 Proje için sanal bir ortam (virtual environment) oluşturmanız önerilir.
 
 ```bash
-# Repo klonlandıktan sonra ilgili klasöre gidin
-cd wheat_disease_project
+# Repo clonelandıktan sonra ilgili klasöre gidin
+cd wheat-project
 
-# Gerekli Python kütüphanelerini indirin
-pip install torch torchvision numpy opencv-python Pillow fastapi uvicorn pydantic python-multipart scikit-learn
+# Python paketlerini indirin
+pip install -r requirements.txt
 ```
 
 ### 2️⃣ Model Eğitimi (Training)
 
-Elinizdeki veri setini `data/train`, `data/valid` ve `data/test` altına (her sınıf için bir klasör olacak şekilde) yerleştirin. Ardından eğitimi başlatın:
+Elinizdeki veri setini (Örn: PlantVillage alt setini) `data/processed/train` ve `data/processed/val` altına yerleştirin. Ardından eğitimi başlatın:
 
 ```bash
-python training/train.py
+python src/train.py --data_dir data/processed --epochs 20 --batch_size 32
 ```
-*Not: En iyi ağırlıklar `models/checkpoints/best_swin_model.pth` içerisine otomatik olarak kaydedilecektir.*
+*Not: En iyi ağırlıklar `models/best_model.pth` içerisine kaydedilecektir.*
 
 ---
 
 ## 🌐 API Kullanımı (Inference)
 
-Eğitilmiş modelinizi diğer platformlardan veya frontend üzerinden çağırmak için FastAPI sunucusunu ayağa kaldırın:
+Eğitilmiş modelinizi diğer platformlardan çağırmak için FastAPI sunucusunu ayağa kaldırın:
 
 ```bash
-python api.py
+uvicorn api.main:app --reload
 ```
-*(Varsayılan olarak `http://localhost:8000` adresinde çalışmaya başlar.)*
-
-API çalışmaya başlayınca `http://127.0.0.1:8000/docs` adresinde **Swagger UI** üzerinden test edebilirsiniz. 
-
-### Önemli Uç Noktalar (Endpoints)
-
-- `GET /health` : API'nin ve modelin durumunu kontrol eder.
-- `GET /classes` : Modelin eğiltildiği tüm sınıfların listesini döndürür.
-- `POST /analyze` (veya `/classify`) : Fotoğraf yükleyerek analiz yaptırdığınız ana uç nokta.
+API çalışmaya başlayınca `http://127.0.0.1:8000/docs` adresinde **Swagger UI** üzerinden test edebilirsiniz. `POST /predict/` endpoint'ine bir yaprak görseli yüklemeniz yeterlidir.
 
 ### Örnek API Çıktısı (JSON Response)
-
 ```json
 {
-  "classification": {
-    "predicted_class": "Yellow Rust",
-    "confidence": 0.9821,
-    "is_certain": true,
-    "top3_predictions": [
-      {
-        "class": "Yellow Rust",
-        "score": 0.9821
-      },
-      {
-        "class": "Brown Rust",
-        "score": 0.0125
-      },
-      {
-        "class": "Healthy",
-        "score": 0.0054
-      }
-    ]
-  },
-  "quality": {
-    "is_valid": true,
-    "blur_score": 145.6,
-    "warnings": [],
-    "rejection_reason": null
+  "success": true,
+  "latency_seconds": 0.125,
+  "prediction": {
+    "class": "yellow_rust",
+    "confidence": 0.9821
   },
-  "meta": {
-    "processing_time_ms": 125.4,
-    "image_size": {
-      "width": 640,
-      "height": 640
-    }
+  "disease_details": {
+    "name_tr": "Sarı Pas (Yellow Rust)",
+    "description": "Yapraklarda sarı-portakal renginde püstüller...",
+    "action": "Acil ilaçlama yapılması tavsiye edilir...",
+    "solution": "1. Ruhsatlı triazol veya strobilurin grubu fungisitler kullanın..."
   }
 }
 ```
 
 ---
-**Not:** Bu proje, üretim ortamına (Production) alınmaya uygun, temizlenmiş ve optimize edilmiş bir kod tabanına sahiptir. Büyük model ağırlıkları (335MB+) `.gitignore` kapsamında olduğundan GitHub'a yüklenmez. Canlı sunucuya (VPS, AWS vb.) aktarırken model dosyalarını (`best_swin_model.pth`) manuel olarak veya S3 gibi servisler aracılığıyla sunucuya çekmeniz gerekmektedir.
+
+## 🐳 Docker ile Çalıştırma
+
+Uygulamayı ortam bağımsız (sunucu, cloud vb.) çalıştırmak için tek tuşla Dockerize edebilirsiniz.
+
+```bash
+# Docker imajını oluştur
+docker build -t wheat-disease-api .
+
+# Konteyneri başlat ve 8000 portuna bağla
+docker run -d -p 8000:8000 --name wheat-api wheat-disease-api
+```
+
+---
+**Geliştirici:** (Kendi İsminizi Yazın) | *Bu proje bir Makine Öğrenmesi & Yazılım Mühendisliği portfolyo projesidir.*