دیدن جهان: راهنمای مبتدی برای شبکه های عصبی حلقوی (CNN) با Pytorch

به دنیای جذاب یادگیری عمیق خوش آمدید! اگر تا به حال فکر کرده اید که چگونه رایانه ها می توانند اشیاء موجود در تصاویر را تشخیص دهند ، بین انواع مختلف ابرها یا حتی سیستم های کنترل گذرنامه خودکار برق تمایز قائل شوند ، در حال کشف یکی از فن آوری های اصلی پشت آن هستید: شبکه های عصبی حلقوی (CNNS).

این شبکه های عصبی قدرتمند به طور خاص برای کنترل داده های تصویر طراحی شده اند و در طی یک دهه گذشته چشم انداز رایانه را متحول کرده اند.

چگونه رایانه ها تصاویر را می بینند

قبل از غواصی به CNN ، بیایید درک کنیم که چگونه رایانه ها تصاویر را درک می کنند. تصاویر دیجیتالی از مربع های ریز تشکیل شده اند پیکسلبشر

در یک تصویر خاکستری ، هر پیکسل دارای یک مقدار عددی است که سایه ای از خاکستری را نشان می دهد ، به طور معمول از 0 (سیاه) تا 255 (سفید). برای تصاویر رنگی ، هر پیکسل معمولاً دارای سه مقدار عددی است که شدت کانال های قرمز ، سبز و آبی (RGB) را نشان می دهد.

این مقادیر در یک تانسور (مانند یک آرایه چند بعدی) با ابعاد برای:

• کانال های رنگی (به عنوان مثال ، 3 برای RGB)
• ارتفاع (تعداد ردیف های پیکسل)
• عرض (تعداد ستون های پیکسل)

مشکل شبکه های عصبی سنتی برای تصاویر

ممکن است به یاد بیاورید که شبکه های عصبی سنتی از لایه های خطی استفاده می کنند که در آن هر نورون ورودی به هر نورون خروجی (شبکه های کاملاً متصل) وصل شده است. این معماری برای داده ها با تعداد کمی از ویژگی ها به خوبی کار می کند ، اما تصاویر یک چالش مهم را به وجود می آورند.

یک تصویر خاکستری ساده از 256 × 256 پیکسل را در نظر بگیرید:

• این تصویر منفرد بیش از 65000 ویژگی ورودی دارد
• اگر از یک لایه خطی با حتی 1000 نورون متوسط ​​استفاده کرده اید ، با بیش از 65 میلیون پارامتر فقط در آن لایه اول به پایان می رسید
• برای تصاویر رنگی ، این تعداد به طور قابل توجهی پرش می کند

چنین تعداد زیادی از پارامترها مشکلات مختلفی ایجاد می کنند:

1. آموزش بسیار کند می شود
2. خطر ابتلا به بیش از حد به طرز چشمگیری افزایش می یابد
3. از نظر انتقادی ، لایه های خطی ذاتاً الگوهای مکانی را درک نمی کنند

اگر یک لایه خطی یاد بگیرد که یک ویژگی را مانند گوش گربه در یک گوشه از تصویر تشخیص دهد ، اگر در یک مکان متفاوت ظاهر شود ، به طور خودکار همان گوش را تشخیص نمی دهد. تصاویر همه چیز در مورد الگوهای و روابط مکانی آنها است!

معرفی لایه های حلقوی

اینجاست که لایه های حلقوی وارد می شوند. CNN ها استفاده می کنند لایه های حلقوی به عنوان روشی بسیار کارآمدتر و مؤثرتر برای پردازش تصاویر.

به جای اتصال هر پیکسل ورودی به هر نورون ، لایه های حلقوی از شبکه های کوچکی از پارامترها استفاده می کنند فیلتر (یا هسته). این فیلترها روی تصویر ورودی (یا نقشه ویژگی از یک لایه قبلی) می چرخند و یک عملیات حلقوی را در هر موقعیت انجام می دهند.

عملیات Convolution در اصل یک محصول DOT بین فیلتر و یک تکه از داده های ورودی تحت پوشش فیلتر است. نتایج این عمل کشویی در هر موقعیت برای ایجاد a جمع آوری می شود نقشه مشخصهبشر

مزایای اصلی لایه های حلقوی:

1. بازده پارامتری: آنها از پارامترهای بسیار کمتری نسبت به لایه های خطی برای تصاویر استفاده می کنند
2. تغییر مکان: اگر یک فیلتر یاد بگیرد که یک الگوی را تشخیص دهد ، می تواند آن الگوی را بدون در نظر گرفتن محل ورودی آن در ورودی تشخیص دهد
3. یادگیری ویژگی سلسله مراتبی: لایه های اولیه می توانند ویژگی های ساده ای مانند لبه ها و بافت ها را تشخیص دهند ، در حالی که لایه های عمیق تر اینها را برای شناسایی ویژگی های پیچیده مانند شکل ها و اشیاء ترکیب می کنند

در Pytorch ، شما یک لایه حلقوی را با استفاده از آن تعریف می کنید nn.Conv2dبشر شما تعداد نقشه های ویژگی ورودی و خروجی (یا کانال ها) و اندازه هسته را مشخص می کنید:

# 3 input channels (RGB), 32 output feature maps, 3x3 filter size
conv_layer = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)

عملیات ضروری CNN: بالشتک و استخر

دو عمل مشترک دیگر در CNN ها ، بالشتک صفر و استخر هستند.

پتانسیل صفر

غالباً قبل از استفاده از یک لایه حلقوی ، صفرها در اطراف مرزهای ورودی اضافه می شوند. این روش کمک می کند:

• ابعاد مکانی خروجی را کنترل کنید
• اطمینان حاصل کنید که پیکسل ها در مرز تصویر به طور یکسان رفتار می شوند
• از از دست دادن اطلاعات در لبه ها جلوگیری کنید

در Pytorch می توانید با استفاده از padding بحث در nn.Conv2d:

# Add 1 pixel of padding around the borders
conv_layer = nn.Conv2d(
    in_channels=3, 
    out_channels=32, 
    kernel_size=3, 
    padding=1
 )

حداکثر استخر

این عمل به طور معمول از لایه های حلقوی پیروی می کند. یک پنجره غیر همپوشانی روی نقشه ویژگی می چرخد ​​و در هر موقعیت ، حداکثر مقدار درون پنجره انتخاب می شود.

به عنوان مثال ، با استفاده از یک پنجره 2 × 2 ، ارتفاع و عرض نقشه ویژگی را نصف می کند. جمع آوری حداکثر به:

• ابعاد مکانی را کاهش دهید
• تعداد پارامترها و پیچیدگی های محاسباتی را کاهش دهید
• مدل را به شیفت های کوچک و تحریف تغییر دهید

در Pytorch ، شما حداکثر استخر را با آن پیاده سازی می کنید nn.MaxPool2d:

# 2x2 max pooling
pool_layer = nn.MaxPool2d(kernel_size=2)

ساخت معماری CNN

CNN معمولی برای طبقه بندی تصویر دارای دو بخش اصلی است: الف استخراج کننده و الف طبقه بندی کنندهبشر

1. استخراج کننده ویژگی

این قسمت معمولاً از بلوک های مکرر تشکیل شده است:

• لایه های حلقوی
• توابع فعال سازی
• لایه های جمع آوری حداکثر

هدف آن پردازش داده های پیکسل خام و استخراج ویژگی های مربوطه است.

2. طبقه بندی کننده

این قسمت از خروجی مسطح استخراج کننده ویژگی (که اکنون یک بردار است) می گیرد و آن را از طریق یک یا چند لایه خطی عبور می دهد تا پیش بینی نهایی شود. بعد خروجی آخرین لایه خطی با تعداد کلاسهای هدف مطابقت دارد.

در اینجا یک معماری ساده CNN در Pytorch وجود دارد:

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()

        # Feature extractor
        self.features = nn.Sequential(
            # First block
            nn.Conv2d(in_channels=3, out_channels=16, 
                      kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),

            # Second block
            nn.Conv2d(in_channels=16, out_channels=32, 
                      kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),

            # Third block
            nn.Conv2d(in_channels=32, out_channels=64, 
                      kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2)
        )

        # Classifier
        self.classifier = nn.Sequential(
            # Assuming input image was 32x32, 
            # after 3 pooling layers it's 4x4

            nn.Flatten(),  # Flatten the 4x4x64 feature maps
            nn.Linear(4 * 4 * 64, 128),
            nn.ReLU(),
            nn.Linear(128, num_classes)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

توابع فعال سازی برای CNN

مانند سایر شبکه های عصبی ، CNN ها برای یادگیری الگوهای پیچیده به غیرخطی نیاز دارند. توابع فعال سازی برای این امر بسیار مهم است.

برای لایه های پنهان در استخراج کننده ویژگی ، گزینه های مشترک شامل موارد زیر است:

RELU (واحد خطی اصلاح شده)

• در صورت مثبت ، مقدار ورودی را خروجی می کند و در غیر این صورت صفر است
• از مشکل شیب ناپدید شده برای ورودی های مثبت جلوگیری می کند
• در دسترس است nn.ReLU
• متداول ترین انتخاب برای CNN

نشتی

• تنوع RELU که یک مقدار غیر صفر کوچک را برای ورودی های منفی خروجی می کند
• از مشکل “نورون در حال مرگ” که گاهی اوقات با RELU استاندارد دیده می شود جلوگیری می کند
• در دسترس است nn.LeakyReLU با negative_slope مشاجره

برای لایه خروجی:

• سیگموئید به طور معمول برای طبقه بندی باینری استفاده می شود
• نرم برای طبقه بندی چند طبقه استفاده می شود

رسیدگی به داده های تصویر در Pytorch

برای آموزش CNN ، باید داده های تصویر خود را تهیه کنید. وابسته به torchvision کتابخانه در اینجا بسیار مفید است.

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

import torch
import torchvision
import torchvision.transforms as transforms

from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader


# Define transformations for images
image_transforms = transforms.Compose([
    transforms.ToTensor(),        # Convert PIL Image to PyTorch Tensor
    transforms.Resize((128, 128)) # Resize image to 128x128
])

# Create a dataset using ImageFolder
# Assumes data is in a directory structure like:
# cloud_train/
#   ├── class1/
#   │   └── img1.jpg
#   └── class2/
#       └── img2.jpg

train_dataset = ImageFolder(root='cloud_train',transform=image_transforms)

# Create a DataLoader for efficient batching and shuffling
train_loader = DataLoader(train_dataset,batch_size=32, shuffle=True)

افزایش داده ها: مدل خود را قوی کنید

یک روش قدرتمند برای داده های تصویر ، به ویژه برای مبارزه با بیش از حد ، است افزایش داده هابشر این شامل اعمال تحولات تصادفی به تصاویر آموزشی است ، مانند:

• چرخش تصادفی: مدل را در زوایای مختلف در معرض اشیاء قرار می دهد
• تلنگر افقی: دیدگاه های مختلف را شبیه سازی می کند
• صدای جیر جیر: شرایط مختلف روشنایی را شبیه سازی می کند

این تحولات به طور مصنوعی اندازه و تنوع مجموعه آموزش شما را افزایش می دهد و باعث می شود مدل نسبت به تغییرات موجود در تصاویر دنیای واقعی قوی تر شود.

اجرای در Pytorch ساده است:

train_transforms = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(degrees=15),
    transforms.ColorJitter(brightness=0.1, contrast=0.1),
    transforms.ToTensor(),
    transforms.Resize((128, 128))
])

# Data augmentation only for training data, not validation/test
train_dataset = torchvision.datasets.ImageFolder(
    root='cloud_train',
    transform=train_transforms
)

به یاد داشته باشید که تقویت هایی را انتخاب کنید که برای کار خاص شما مناسب باشد. برخی از تقویت ها می توانند معنی تصویر را تغییر دهند (به عنوان مثال ، چرخش یک “W” به صورت عمودی ممکن است آن را مانند “M” به نظر برساند).

آموزش CNN خود

آموزش CNN شامل حلقه آموزش عمیق یادگیری عمیق است:

1. یک عملکرد از دست دادن را تعریف کنید (به عنوان مثال ، nn.CrossEntropyLoss برای طبقه بندی چند طبقه)
2. بهینه ساز را انتخاب کنید (به عنوان مثال ، optim.Adam یا optim.SGD)
3. حلقه از طریق چندین دوره (عبور کامل از طریق داده های آموزش)
4. در داخل هر دوره ، دسته های داده را از لودر داده پردازش کنید

در اینجا یک حلقه آموزش کامل وجود دارد:

import torch.optim as optim

# Instantiate model, loss function, and optimizer
model = SimpleCNN(num_classes=10)
criterion = nn.CrossEntropyLoss()  # For multiclass classification
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam optimizer

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Training loop
num_epochs = 10
for epoch in range(num_epochs):
    model.train()  # Set model to training mode
    running_loss = 0.0

    for inputs, labels in train_loader:
        # Move data to the same device as model
        inputs, labels = inputs.to(device), labels.to(device)

        # Zero the parameter gradients
        optimizer.zero_grad()

        # Forward pass
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # Backward pass and optimize
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {running_loss/len(train_loader):.4f}")

ارزیابی CNN شما

ارزیابی عملکرد مدل شما بسیار مهم است. داده ها به طور معمول به مجموعه های آموزش ، اعتبار سنجی و آزمون تقسیم می شوند.

معیارهای ارزیابی کلیدی برای طبقه بندی عبارتند از:

• دقت: فرکانس کلی پیش بینی های صحیح
• دقت: کسری از پیش بینی های مثبت صحیح در بین همه پیش بینی های مثبت
• یادآوری کردن: کسری از تمام نمونه های مثبت که به درستی پیش بینی شده بودند
• نمره F1: میانگین هارمونیک دقت و فراخوان

در اینجا یک حلقه ارزیابی وجود دارد:

# Evaluation loop
model.eval()  # Set model to evaluation mode
correct = 0
total = 0

with torch.no_grad():  # Disable gradient calculation
    for inputs, labels in test_loader:
        inputs, labels = inputs.to(device), labels.to(device)

        # Forward pass
        outputs = model(inputs)

        # Get predicted class
        _, predicted = torch.max(outputs, 1)

        # Update statistics
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print(f"Test Accuracy: {accuracy:.2f}%")

پیگیری از دست دادن آموزش در مقابل از دست دادن اعتبار سنجی (و دقت) برای تشخیص بیش از حد مهم است. اگر از دست دادن آموزش کاهش یابد اما از دست دادن اعتبار سنجی افزایش می یابد ، مدل شما بیش از حد است.

مبارزه با بیش از حد در CNN

علاوه بر افزایش داده ها ، سایر استراتژی ها برای مبارزه با بیش از حد شامل موارد زیر است:

1. ترک تحصیل

به طور تصادفی غیرفعال کردن کسری از نورون ها در طول آموزش ، جلوگیری از اتکا به ویژگی های خاص:

nn.Conv2d(32, 64, 3),
nn.ReLU(),
nn.Dropout(p=0.25),  # 25% dropout after activation
nn.MaxPool2d(2)

2. عادی سازی دسته ای

عادی سازی فعال سازی های لایه قبلی برای سرعت بخشیدن به تمرین و اضافه کردن مقداری تنظیم:

nn.Conv2d(32, 64, 3),
nn.BatchNorm2d(64),  # Batch normalization after convolution
nn.ReLU()

3. پوسیدگی وزن

اضافه کردن یک مجازات به عملکرد از دست دادن برای تشویق وزن های کوچکتر:

optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

4. توقف زود هنگام

نظارت بر عملکرد اعتبار سنجی و متوقف کردن آموزش هنگام شروع تخریب.

معماری مدرن CNN

در حالی که مثال ما از CNN ساده استفاده کرده است ، بسیاری از معماری های قدرتمند توسعه یافته اند:

• VGG: از فیلترهای بسیار کوچک 3 × 3 با لایه های زیادی استفاده می کند
• برگ: برای کمک به آموزش شبکه های بسیار عمیق ، اتصالات پرش را معرفی می کند
• شروع/گوگلنت: از مسیرهای موازی با اندازه های مختلف فیلتر استفاده می کند
• کارآمد: مقیاس عمق ، عرض و وضوح در کنار هم برای کارآیی

بسیاری از این موارد از قبل آموزش دیده در دسترس هستند torchvision.models و می تواند برای یادگیری انتقال استفاده شود.

پایان

CNN ستون فقرات مدرن رایانه است. با درک چگونگی پردازش تصاویر از طریق فیلترهای حلقوی ، جمع آوری و عملکردهای فعال سازی ، گام مهمی در ساخت مدل های قدرتمند برداشته اید که می توانند واقعاً جهان را “ببینند”.

بینش های کلیدی که باید به خاطر بسپارید:

• CNN ها بدون توجه به موقعیت مکانی آنها از فیلترهای کشویی برای تشخیص الگوها استفاده می کنند
• آنها بازنمایی های سلسله مراتبی را از ویژگی های ساده گرفته تا ویژگی های پیچیده می سازند
• تکنیک هایی مانند استخر و بالشتک به کنترل ابعاد مکانی کمک می کنند
• تکنیک های تقویت و تنظیم داده ها مانند Dropout برای مدل های قوی ضروری است

اکنون وقت آن رسیده است که مدل های CNN خود را آزمایش و بسازید! این که آیا شما به طبقه بندی تصویر ، تشخیص شیء یا کارهای پیشرفته تر مانند تقسیم تصویر علاقه مند هستید ، اصول تحت پوشش در اینجا به عنوان پایه و اساس شما خدمت می کنند.

📬 نویسنده را دنبال کنید

اگر از این مقاله لذت بردید و می خواهید بیشتر شبیه آن باشید ، دنبال کردن من در نظر بگیرید:

با تشکر از خواندن!