Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

how to train RT-DETRv2 on custom dataset in python

  1. User

    how to train RT-DETRv2 on custom dataset in python

  2. Assistant

    برای آموزش مدل RT-DETRv2 روی یک دیتاست سفارشی با استفاده از پایتون، باید چند مرحله اساسی را دنبال کنید. RT-DETRv2 یکی از نسخه‌های پیشرفته DETR (Detection Transformer) است که برای تشخیص اشیاء در تصاویر بهینه‌سازی شده است. در این راهنما قدم به قدم به شما نشان داده می‌شود که چگونه این کار را انجام دهید:

    مرحله ۱: آماده‌سازی محیط کاری

    ۱.۱ نصب پایتون و ایجاد محیط مجازی

    ابتدا مطمئن شوید که پایتون ۳.۶ یا بالاتر بر روی سیستم شما نصب شده است. سپس یک محیط مجازی ایجاد کنید تا وابستگی‌ها به صورت جداگانه مدیریت شوند:

    # ایجاد محیط مجازی
    python -m venv rt-detrv2-env
    
    # فعال‌سازی محیط مجازی
    # برای ویندوز:
    rt-detrv2-env\Scripts\activate
    
    # برای macOS/Linux:
    source rt-detrv2-env/bin/activate
    

    ۱.۲ نصب وابستگی‌ها

    پس از فعال‌سازی محیط مجازی، بسته‌های مورد نیاز را نصب کنید. فرض بر این است که RT-DETRv2 بر پایه PyTorch ساخته شده است:

    pip install torch torchvision
    pip install numpy pandas matplotlib opencv-python
    pip install pycocotools  # اگر از فرمت COCO استفاده می‌کنید
    

    مرحله ۲: دریافت و راه‌اندازی RT-DETRv2

    ۲.۱ کلون کردن مخزن RT-DETRv2

    اگر RT-DETRv2 در یک مخزن عمومی مانند GitHub موجود است، آن را کلون کنید:

    git clone https://github.com/your-repo/rt-detrv2.git
    cd rt-detrv2
    

    نکته: جایگزین https://github.com/your-repo/rt-detrv2.git با URL واقعی مخزن RT-DETRv2 کنید.

    ۲.۲ نصب وابستگی‌های پروژه

    ممکن است مخزن دارای فایل requirements.txt باشد که وابستگی‌های مربوطه را مشخص می‌کند:

    pip install -r requirements.txt
    

    مرحله ۳: آماده‌سازی دیتاست سفارشی

    ۳.۱ ساختار دیتاست

    دیتاست شما باید شامل تصاویر و فایل‌های annotations باشد. به طور معمول، فرمت COCO برای DETR مناسب است که شامل فایل JSON با ساختار مشخص است. ساختار پایه به این صورت است:

    custom_dataset/
    ├── images/
    │   ├── train/
    │   │   ├── img1.jpg
    │   │   ├── img2.jpg
    │   │   └── ...
    │   └── val/
    │       ├── img1.jpg
    │       ├── img2.jpg
    │       └── ...
    └── annotations/
        ├── instances_train.json
        └── instances_val.json
    

    ۳.۲ تبدیل دیتاست به فرمت COCO (در صورت نیاز)

    اگر دیتاست شما در فرمت دیگری است، باید آن را به فرمت COCO تبدیل کنید. می‌توانید از ابزارهایی مانند LabelMe برای تبدیل استفاده کنید یا اسکریپت‌های دلخواه خود را بنویسید.

    مرحله ۴: تعریف DataLoader

    ۴.۱ پیاده‌سازی Dataset سفارشی

    یک کلاس Dataset سفارشی تعریف کنید که داده‌ها را به فرمت مناسب بارگذاری کند:

    import os
    import torch
    from torch.utils.data import Dataset, DataLoader
    from PIL import Image
    import json
    
    class CustomCOCODataset(Dataset):
        def __init__(self, images_dir, annotation_file, transforms=None):
            self.images_dir = images_dir
            with open(annotation_file) as f:
                self.coco = json.load(f)
            self.image_ids = [img['id'] for img in self.coco['images']]
            self.transforms = transforms
    
        def __len__(self):
            return len(self.image_ids)
    
        def __getitem__(self, idx):
            image_id = self.image_ids[idx]
            image_info = next(item for item in self.coco['images'] if item["id"] == image_id)
            image_path = os.path.join(self.images_dir, image_info['file_name'])
            image = Image.open(image_path).convert("RGB")
    
            annotations = [ann for ann in self.coco['annotations'] if ann['image_id'] == image_id]
            boxes = []
            labels = []
            for ann in annotations:
                x, y, w, h = ann['bbox']
                boxes.append([x, y, x + w, y + h])
                labels.append(ann['category_id'])
    
            boxes = torch.as_tensor(boxes, dtype=torch.float32)
            labels = torch.as_tensor(labels, dtype=torch.int64)
            target = {}
            target["boxes"] = boxes
            target["labels"] = labels
    
            if self.transforms:
                image = self.transforms(image)
    
            return image, target
    

    ۴.۲ تعریف Transforms

    تعاریف مربوط به پیش‌پردازش تصاویر:

    from torchvision import transforms
    
    transform = transforms.Compose([
        transforms.Resize((800, 800)),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])
    

    ۴.۳ ایجاد DataLoader

    train_dataset = CustomCOCODataset(
        images_dir='custom_dataset/images/train',
        annotation_file='custom_dataset/annotations/instances_train.json',
        transforms=transform
    )
    
    val_dataset = CustomCOCODataset(
        images_dir='custom_dataset/images/val',
        annotation_file='custom_dataset/annotations/instances_val.json',
        transforms=transform
    )
    
    def collate_fn(batch):
        return tuple(zip(*batch))
    
    train_loader = DataLoader(
        train_dataset,
        batch_size=4,
        shuffle=True,
        num_workers=4,
        collate_fn=collate_fn
    )
    
    val_loader = DataLoader(
        val_dataset,
        batch_size=4,
        shuffle=False,
        num_workers=4,
        collate_fn=collate_fn
    )
    

    مرحله ۵: تنظیم مدل RT-DETRv2

    ۵.۱ بارگذاری مدل و تنظیمات اولیه

    فرض بر این است که RT-DETRv2 در ماژول rt_detrv2 تعریف شده است:

    import torch
    import torch.nn as nn
    from rt_detrv2 import RT_DETRv2  # باید نام واقعی ماژول را جایگزین کنید
    
    # تعداد کلاس‌ها را بر اساس دیتاست خود تنظیم کنید
    num_classes = 10  # به عنوان مثال
    
    # ایجاد مدل
    model = RT_DETRv2(num_classes=num_classes)
    model.to('cuda' if torch.cuda.is_available() else 'cpu')
    

    ۵.۲ تنظیم بهینه‌ساز و Scheduler

    import torch.optim as optim
    
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = optim.AdamW(params, lr=1e-4)
    
    # Scheduler برای کاهش نرخ یادگیری
    lr_scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
    

    مرحله ۶: تعریف تابع از دست دادن

    مدل‌های DETR معمولاً از یک تابع از دست دادن ترکیبی استفاده می‌کنند که شامل جابجایی و طبقه‌بندی است. اگر مدل RT-DETRv2 شما دارای تابع از دست دادن داخلی است، می‌توانید از آن استفاده کنید. در غیر این صورت، می‌توانید آن را خودتان پیاده‌سازی کنید:

    import torch.nn.functional as F
    
    def loss_fn(outputs, targets):
        # فرض بر این است که خروجی‌ها شامل پیش‌بینی‌های موقعیت و کلاس هستند
        pred_logits, pred_boxes = outputs['logits'], outputs['boxes']
        target_labels = [t['labels'] for t in targets]
        target_boxes = [t['boxes'] for t in targets]
    
        # باید تطبیق بین پیش‌بینی‌ها و اهداف را مدیریت کنید
        # اینجا به عنوان نمونه ساده CrossEntropy و MSE برای مثال است
        loss_cls = F.cross_entropy(pred_logits, target_labels)
        loss_box = F.l1_loss(pred_boxes, target_boxes)
        return loss_cls + loss_box
    

    نکته: تابع از دست دادن باید با پیاده‌سازی خاص RT-DETRv2 هماهنگ شود. بهتر است مستندات مدل را بررسی کنید.

    مرحله ۷: اجرای حلقه آموزش

    ۷.۱ آموزش مدل

    import time
    from tqdm import tqdm
    
    num_epochs = 50
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    
    for epoch in range(num_epochs):
        model.train()
        epoch_loss = 0
        start_time = time.time()
    
        for images, targets in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs} - Training"):
            images = list(img.to(device) for img in images)
            targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
    
            optimizer.zero_grad()
            outputs = model(images, targets)
            loss = outputs['loss']  # فرض بر این است که مدل خروجی loss را دارد
            loss.backward()
            optimizer.step()
    
            epoch_loss += loss.item()
    
        lr_scheduler.step()
        end_time = time.time()
    
        print(f"Epoch [{epoch+1}/{num_epochs}] Loss: {epoch_loss/len(train_loader):.4f} Time: {end_time - start_time:.2f}s")
    
        # ذخیره مدل بعد از هر epoch
        torch.save(model.state_dict(), f"rt_detrv2_epoch_{epoch+1}.pth")
    
        # ارزیابی مدل
        model.eval()
        val_loss = 0
        with torch.no_grad():
            for images, targets in tqdm(val_loader, desc=f"Epoch {epoch+1}/{num_epochs} - Validation"):
                images = list(img.to(device) for img in images)
                targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
    
                outputs = model(images, targets)
                loss = outputs['loss']
                val_loss += loss.item()
    
        print(f"Validation Loss: {val_loss/len(val_loader):.4f}")
    

    ۷.۲ نکات مهم

    • توزیع کلاس‌ها: مطمئن شوید که توزیع کلاس‌ها در دیتاست آموزشی و اعتبارسنجی متعادل باشد.
    • افزایش داده‌ها (Data Augmentation): استفاده از تکنیک‌های افزایش داده ممکن است به بهبود عملکرد مدل کمک کند.
    • نظارت بر Overfitting: استفاده از تکنیک‌هایی مانند Dropout، Regularization و Early Stopping می‌تواند از بیش‌برازش جلوگیری کند.

    مرحله ۸: ارزیابی مدل

    پس از آموزش مدل، باید عملکرد آن را با استفاده از معیارهای مانند mAP (mean Average Precision) ارزیابی کنید. بسته به پیاده‌سازی RT-DETRv2، ممکن است ابزارهای ارزیابی داخلی داشته باشد.

    ۸.۱ محاسبه mAP

    from pycocotools.cocoeval import COCOeval
    
    def evaluate(model, data_loader, device):
        model.eval()
        coco_gt = data_loader.dataset.coco
        coco_dt = []
    
        with torch.no_grad():
            for images, targets in tqdm(data_loader, desc="Evaluating"):
                images = list(img.to(device) for img in images)
                outputs = model(images)
    
                for idx, output in enumerate(outputs):
                    image_id = data_loader.dataset.image_ids[idx]
                    boxes = output['boxes'].cpu().numpy()
                    scores = output['scores'].cpu().numpy()
                    labels = output['labels'].cpu().numpy()
    
                    for box, score, label in zip(boxes, scores, labels):
                        x_min, y_min, x_max, y_max = box
                        width = x_max - x_min
                        height = y_max - y_min
                        coco_dt.append({
                            'image_id': image_id,
                            'category_id': label,
                            'bbox': [x_min, y_min, width, height],
                            'score': score
                        })
    
        coco_gt = COCO(data_loader.dataset.annotation_file)
        coco_dt = coco_gt.loadRes(coco_dt)
        coco_eval = COCOeval(coco_gt, coco_dt, iouType='bbox')
        coco_eval.evaluate()
        coco_eval.accumulate()
        coco_eval.summarize()
    
    evaluate(model, val_loader, device)
    

    نکته: مطمئن شوید که خروجی مدل شامل boxes, scores و labels به درستی است.

    مرحله ۹: استفاده از مدل آموزش‌دیده

    پس از اتمام آموزش، می‌توانید مدل را برای تشخیص اشیاء در تصاویر جدید استفاده کنید:

    import matplotlib.pyplot as plt
    import torchvision.transforms as T
    
    # بارگذاری مدل آموزش‌دیده
    model = RT_DETRv2(num_classes=num_classes)
    model.load_state_dict(torch.load('rt_detrv2_epoch_50.pth'))
    model.to(device)
    model.eval()
    
    def predict(image_path, model, device, transform):
        image = Image.open(image_path).convert("RGB")
        img_tensor = transform(image).to(device).unsqueeze(0)
    
        with torch.no_grad():
            outputs = model(img_tensor)
    
        # استخراج نتایج
        scores = outputs['scores'].cpu().numpy()
        boxes = outputs['boxes'].cpu().numpy()
        labels = outputs['labels'].cpu().numpy()
    
        return image, boxes, labels, scores
    
    image, boxes, labels, scores = predict('path/to/test/image.jpg', model, device, transform)
    
    # نمایش نتایج
    plt.figure(figsize=(12, 8))
    plt.imshow(image)
    ax = plt.gca()
    
    for box, label, score in zip(boxes, labels, scores):
        if score > 0.5:  # آستانه امتیاز
            x_min, y_min, x_max, y_max = box
            rect = plt.Rectangle((x_min, y_min), x_max - x_min, y_max - y_min,
                                 fill=False, color='red', linewidth=2)
            ax.add_patch(rect)
            ax.text(x_min, y_min, f'{label}: {score:.2f}', bbox=dict(facecolor='yellow', alpha=0.5))
    
    plt.axis('off')
    plt.show()
    

    نکات نهایی

    1. مطالعه مستندات RT-DETRv2: هر پیاده‌سازی ممکن است جزئیات خاص خود را داشته باشد. حتماً مستندات مربوطه را مطالعه کنید.
    2. تنظیم هایپراپارامترها: پارامترهایی مانند نرخ یادگیری، اندازه بچ و تعداد epoch‌ها را براساس نیاز و منابع محاسباتی خود تنظیم کنید.
    3. استفاده از GPU: آموزش مدل‌های DETR-like زمان‌بر است. استفاده از GPU به طور قابل توجهی زمان آموزش را کاهش می‌دهد.
    4. ذخیره‌سازی منظم مدل: ذخیره‌سازی وزن‌های مدل به صورت منظم می‌تواند در مواقعی که آموزش متوقف می‌شود، از پیشرفت شما محافظت کند.
    5. بهبود مدل: پس از آموزش اولیه، می‌توانید مدل را با تکنیک‌هایی مانند افزایش داده‌ها، تنظیمات پیش‌پردازش و استفاده از backbone‌های مختلف بهبود دهید.

    با دنبال کردن این مراحل، شما قادر خواهید بود RT-DETRv2 را روی دیتاست سفارشی خود آموزش دهید و از آن برای تشخیص اشیاء در تصاویر جدید استفاده کنید.