الكشف عن أمراض أوراق النبات وتحديدها باستخدام YOLOv4

# استنساخ المستودع
git clone https://github.com/AlexeyAB/darknet.git
cd darknet
 
# تفعيل GPU و OpenCV في Makefile
sed -i 's/GPU=0/GPU=1/' Makefile
sed -i 's/CUDNN=0/CUDNN=1/' Makefile
sed -i 's/OPENCV=0/OPENCV=1/' Makefile
 
# التجميع
make -j$(nproc)

python3 -m venv yolov4-env
source yolov4-env/bin/activate
 
pip install opencv-python numpy matplotlib pillow
pip install torch torchvision  # اختياري — للتحليل والتقييم

# تنزيل من Kaggle
pip install kaggle
kaggle datasets download -d emmarex/plantdisease
unzip plantdisease.zip -d data/plantvillage

import os
import cv2
import random
from pathlib import Path
 
DATA_DIR = "data/plantvillage"
OUTPUT_DIR = "data/yolo_format"
CLASSES_FILE = "data/classes.txt"
 
# جمع الفئات
classes = sorted(os.listdir(DATA_DIR))
with open(CLASSES_FILE, "w") as f:
    for cls in classes:
        f.write(f"{cls}\n")
 
print(f"عدد الفئات: {len(classes)}")
 
# تحويل كل صورة إلى تنسيق YOLO
os.makedirs(f"{OUTPUT_DIR}/images/train", exist_ok=True)
os.makedirs(f"{OUTPUT_DIR}/images/val", exist_ok=True)
os.makedirs(f"{OUTPUT_DIR}/labels/train", exist_ok=True)
os.makedirs(f"{OUTPUT_DIR}/labels/val", exist_ok=True)
 
all_images = []
for class_idx, class_name in enumerate(classes):
    class_dir = os.path.join(DATA_DIR, class_name)
    for img_name in os.listdir(class_dir):
        if img_name.lower().endswith(('.jpg', '.jpeg', '.png')):
            all_images.append((
                os.path.join(class_dir, img_name),
                class_idx,
                img_name
            ))
 
# تقسيم 80/20 للتدريب والتحقق
random.shuffle(all_images)
split = int(0.8 * len(all_images))
train_set = all_images[:split]
val_set = all_images[split:]
 
def process_image(img_path, class_idx, img_name, split_name):
    """تحويل صورة واحدة إلى تنسيق YOLO"""
    img = cv2.imread(img_path)
    h, w = img.shape[:2]
 
    # نسخ الصورة
    dest = f"{OUTPUT_DIR}/images/{split_name}/{img_name}"
    cv2.imwrite(dest, img)
 
    # إنشاء ملف التعليقات — الورقة تشغل معظم الصورة
    # التنسيق: class_id center_x center_y width height (مُطبَّع)
    label_name = Path(img_name).stem + ".txt"
    label_path = f"{OUTPUT_DIR}/labels/{split_name}/{label_name}"
    with open(label_path, "w") as f:
        # المربع المحيط يغطي 90% من الصورة (الورقة هي الموضوع الرئيسي)
        f.write(f"{class_idx} 0.5 0.5 0.9 0.9\n")
 
print(f"تدريب: {len(train_set)} | تحقق: {len(val_set)}")
 
for img_path, cls_idx, name in train_set:
    process_image(img_path, cls_idx, name, "train")
 
for img_path, cls_idx, name in val_set:
    process_image(img_path, cls_idx, name, "val")

import numpy as np
import cv2
 
def normalize_image(img_path):
    """تطبيع قيم البكسل من [0, 255] إلى [0, 1]"""
    img = cv2.imread(img_path)
    img = img.astype(np.float32) / 255.0
 
    # تغيير الحجم إلى 416×416 (الحجم الافتراضي لـ YOLOv4)
    img = cv2.resize(img, (416, 416))
    return img
 
# تحقق من صورة عشوائية
sample = normalize_image("data/yolo_format/images/train/sample.jpg")
print(f"النطاق: [{sample.min():.2f}, {sample.max():.2f}]")
print(f"الشكل: {sample.shape}")  # (416, 416, 3)

pip install labelImg
labelImg data/yolo_format/images/train/ data/classes.txt

classes = 38
train = data/train.txt
valid = data/val.txt
names = data/classes.txt
backup = backup/

import glob
 
# قائمة صور التدريب
train_images = glob.glob("data/yolo_format/images/train/*.*")
with open("data/train.txt", "w") as f:
    f.write("\n".join(train_images))
 
# قائمة صور التحقق
val_images = glob.glob("data/yolo_format/images/val/*.*")
with open("data/val.txt", "w") as f:
    f.write("\n".join(val_images))
 
print(f"صور التدريب: {len(train_images)}")
print(f"صور التحقق: {len(val_images)}")

cp cfg/yolov4-custom.cfg cfg/yolov4-plant.cfg

[net]
batch = 64
subdivisions = 16
width = 416
height = 416
max_batches = 76000    # = عدد الفئات × 2000 = 38 × 2000
steps = 60800,68400    # = 80% و 90% من max_batches

# لكل طبقة [yolo] (3 طبقات)
[yolo]
classes = 38
 
# لكل طبقة [convolutional] قبل [yolo]
[convolutional]
filters = 129          # = (classes + 5) × 3 = (38 + 5) × 3

wget https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.conv.137

./darknet detector train \
    data/plant.data \
    cfg/yolov4-plant.cfg \
    yolov4.conv.137 \
    -map \
    -dont_show

./darknet detector map \
    data/plant.data \
    cfg/yolov4-plant.cfg \
    backup/yolov4-plant_best.weights

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
 
def evaluate_model(predictions, ground_truths, class_names):
    """إنشاء وعرض مصفوفة الارتباك"""
    cm = confusion_matrix(ground_truths, predictions)
 
    fig, ax = plt.subplots(figsize=(20, 20))
    disp = ConfusionMatrixDisplay(cm, display_labels=class_names)
    disp.plot(ax=ax, cmap='Greens', xticks_rotation=45)
    plt.title("مصفوفة الارتباك — YOLOv4 Plant Disease Detection")
    plt.tight_layout()
    plt.savefig("confusion_matrix.png", dpi=150)
    plt.show()
 
    # حساب المقاييس لكل فئة
    for i, name in enumerate(class_names):
        tp = cm[i, i]
        fp = cm[:, i].sum() - tp
        fn = cm[i, :].sum() - tp
        precision = tp / (tp + fp) if (tp + fp) > 0 else 0
        recall = tp / (tp + fn) if (tp + fn) > 0 else 0
        print(f"{name}: Precision={precision:.4f}, Recall={recall:.4f}")

./darknet detector test \
    data/plant.data \
    cfg/yolov4-plant.cfg \
    backup/yolov4-plant_best.weights \
    data/test/tomato_late_blight.jpg \
    -thresh 0.5

import cv2
import numpy as np
 
def detect_disease(image_path, config, weights, classes_file, conf_threshold=0.5):
    """كشف أمراض الأوراق في صورة"""
    # تحميل الشبكة
    net = cv2.dnn.readNetFromDarknet(config, weights)
    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)
 
    # تحميل أسماء الفئات
    with open(classes_file, "r") as f:
        classes = f.read().strip().split("\n")
 
    # تحضير الصورة
    img = cv2.imread(image_path)
    h, w = img.shape[:2]
    blob = cv2.dnn.blobFromImage(img, 1/255.0, (416, 416), swapRB=True, crop=False)
    net.setInput(blob)
 
    # الاستدلال
    layer_names = net.getLayerNames()
    output_layers = [layer_names[i - 1] for i in net.getUnconnectedOutLayers()]
    outputs = net.forward(output_layers)
 
    # معالجة النتائج
    boxes, confidences, class_ids = [], [], []
    for output in outputs:
        for detection in output:
            scores = detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
 
            if confidence > conf_threshold:
                center_x = int(detection[0] * w)
                center_y = int(detection[1] * h)
                bw = int(detection[2] * w)
                bh = int(detection[3] * h)
                x = int(center_x - bw / 2)
                y = int(center_y - bh / 2)
 
                boxes.append([x, y, bw, bh])
                confidences.append(float(confidence))
                class_ids.append(class_id)
 
    # إزالة التكرارات (NMS)
    indices = cv2.dnn.NMSBoxes(boxes, confidences, conf_threshold, 0.4)
 
    # رسم النتائج
    colors = np.random.uniform(0, 255, size=(len(classes), 3))
    for i in indices.flatten():
        x, y, bw, bh = boxes[i]
        label = f"{classes[class_ids[i]]}: {confidences[i]:.2f}"
        color = colors[class_ids[i]]
        cv2.rectangle(img, (x, y), (x + bw, y + bh), color, 2)
        cv2.putText(img, label, (x, y - 10),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
 
    return img, [(classes[class_ids[i]], confidences[i]) for i in indices.flatten()]
 
# الاستخدام
result_img, detections = detect_disease(
    "test_leaf.jpg",
    "cfg/yolov4-plant.cfg",
    "backup/yolov4-plant_best.weights",
    "data/classes.txt"
)
 
for disease, conf in detections:
    print(f"  {disease}: {conf:.1%}")
 
cv2.imwrite("result.jpg", result_img)

import cv2
 
cap = cv2.VideoCapture(0)  # أو مسار ملف فيديو
 
while True:
    ret, frame = cap.read()
    if not ret:
        break
 
    # تحضير الإطار
    blob = cv2.dnn.blobFromImage(frame, 1/255.0, (416, 416), swapRB=True)
    net.setInput(blob)
    outputs = net.forward(output_layers)
 
    # ... معالجة النتائج (نفس الكود أعلاه)
 
    cv2.imshow("Plant Disease Detection", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
cap.release()
cv2.destroyAllWindows()