كيفية فهم ResNet بسهولة في PyTorch

مقدمة إلى ResNet

ما هو ResNet؟

ResNet ، وهو اختصار لـ Residual Neural Network ، هو تصميم للتعلم العميق تم تقديمه عام 2015 من قبل الباحثين في شركة Microsoft. تم تصميمه لمعالجة مشكلة تلاشي التدرج / التصاعدي الشديدة ، وهي مشكلة شائعة تواجه عند تدريب الشبكات العصبية العميقة جدًا.

1. شبكة الشبكة العصبية السالبة: ResNet هو نوع من الشبكات العصبية التي تستخدم "توصيلات تخطي" أو "توصيلات متبقية" لتمكين تدريب نماذج أعمق بكثير. تسمح هذه التوصيلات بتجاوز بعض الطبقات في الشبكة ، مما يخلق عبورًا "انتقاليًا" يساعد في التخفيف من مشكلة تلاشي التدرج.

2. معالجة مشكلة تلاشي / تفاقم التدرج: في الشبكات العصبية العميقة جدًا ، يمكن أن تختفي القيم التدرجية المستخدمة للتدرج العكسي (تصبح صغيرة للغاية) أو تتفاقم (تصبح كبيرة للغاية) أثناء تنتشرها إلى الوراء عبر الشبكة. يمكن أن يجعل هذا الأمر صعبًا على الشبكة أن تتعلم بفعالية ، لا سيما في الطبقات الأعمق. تساعد توصيلات ResNet في معالجة هذه المشكلة عن طريق السماح للتدرجات بالتدفق بسهولة أكبر من خلال الشبكة.

مزايا ResNet

1. تحسين الأداء في الشبكات العصبية العميقة: تسمح توصيلات ResNet بتدريب الشبكات العصبية العميقة بكثير ، مما يمكن أن يؤدي إلى تحسين الأداء بشكل كبير في مجموعة متنوعة من المهام ، مثل تصنيف الصور واكتشاف الكائنات وتجزئة الشحنات.

2. سرعة التقارب أثناء التدريب: يمكن أن تساعد توصيلات الإحالة في ResNet أيضًا في سرعة التقارب أثناء عملية التدريب ، حيث يسمحون بتدفق التدرجات بكفاءة أكبر عبر الشبكة.

تنفيذ ResNet في PyTorch

إعداد البيئة

1. تثبيت PyTorch: للبدء في تنفيذ ResNet في PyTorch ، ستحتاج أولاً إلى تثبيت مكتبة PyTorch. يمكنك تنزيل وتثبيت PyTorch من الموقع الرسمي (https://pytorch.org/ (opens in a new tab)) استنادًا إلى نظام التشغيل الخاص بك وإصدار Python.

2. استيراد المكتبات اللازمة: بمجرد تثبيت PyTorch ، ستحتاج إلى استيراد المكتبات اللازمة لمشروعك. يشمل ذلك عادة PyTorch ، NumPy ، وأي مكتبات أخرى قد تحتاجها لمعالجة البيانات ، أو الرسوم المرئية ، أو المهام الأخرى.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt

تعريف بنية ResNet

فهم الكتل الأساسية

1. الطبقات التكاملية: يستخدم ResNet ، مثل العديد من نماذج التعلم العميق الأخرى ، طبقات التكامل ككتل بناءية رئيسية لاستخراج الميزات.

2. معيار الدُمج: يستخدم ResNet أيضًا طبقات معيار الدُمج "Batch Normalization" للمساعدة في تثبيت عملية التدريب وتحسين أداء النموذج.

3. دوال التنشيط: تستخدم بنية ResNet بشكل عام دوال التنشيط ReLU (وحدة الخطية المقوسة) كدالة تنشيط ، والتي تساعد في إدخال عدم الخطية إلى النموذج.

4. طبقات الاستنتاج: يمكن أن تشمل ResNet أيضًا طبقات الاستنتاج ، مثل الأقصى أو المتوسط ​​، لتقليل الأبعاد المكانية لخرائط الميزات وإدخال عدم الإزاحة.

تنفيذ كتلة ResNet

1. توصيل المتبقي: الابتكار الرئيسي لـ ResNet هو توصيل المتبقي ، مما يتيح للشبكة تجاوز بعض الطبقات عن طريق إضافة إدخال الطبقة إلى إخراجها. يساعد هذا في التخفيف من مشكلة تلاشي التدرج.

class ResNetBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResNetBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
 
    def forward(self, x):
        residual = self.shortcut(x)
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += residual
        out = self.relu(out)
        return out

2. وصلة اختصار: بالإضافة إلى توصيل المتبقي ، يستخدم ResNet أيضًا "وصلة اختصار" لمطابقة أبعاد إدخال وإخراج كتلة ResNet ، إن لزم الأمر.

بناء النموذج الكامل لـ ResNet

1. عدد من كتب ResNet: لإنشاء النموذج الكامل لـ ResNet ، ستحتاج إلى تكديس عدة كتل ResNet معًا ، وضبط عدد الطبقات وعدد المرشحات في كل كتلة.

2. ضبط عدد الطبقات: تأتي نماذج ResNet في إصدارات مختلفة ، مثل ResNet-18 و ResNet-34 و ResNet-50 و ResNet-101 و ResNet-152 ، والتي لديها أعداد طبقات مختلفة. يؤثر عدد الطبقات على تعقيد النموذج وأدائه.

تنفيذ ResNet-18 في PyTorch

تحديد نموذج ResNet-18

1. طبقة الإدخال: ستقبل طبقة الإدخال لنموذج ResNet-18 عادة صورة بحجم محدد ، مثل 224x224 بكسل.

2. الطبقات التكاملية: ستستخدم الطبقات التكاملية الأولية لنموذج ResNet-18 لاستخراج الميزات الأساسية من الصورة المدخلة.

3. كتل ResNet: جوهر نموذج ResNet-18 هو تكديس عدة كتل ResNet ، التي تستخدم التوصيلات المتبقية لتمكين تدريب شبكة أعمق.

4. طبقة متصلة بالكامل: بعد الطبقات التكاملية وكتل ResNet ، سيحتوي النموذج على طبقة متصلة بالكامل لأداء مهمة التصنيف أو التنبؤ النهائي.

5. طبقة الخرج: ستحتوي طبقة الخرج لنموذج ResNet-18 على عدد من الوحدات المطابقة لعدد الفئات في المشكلة التي يتم حلها.

class ResNet18(nn.Module):
    def __init__(self, num_classes=10):
        super(ResNet18, self).__init__()
        self.in_channels = 64
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
 
        self.layer1 = self._make_layer(64, 64, 2, stride=1)
        self.layer2 = self._make_layer(64, 128, 2, stride=2)
        self.layer3 = self._make_layer(128, 256, 2, stride=2)
        self.layer4 = self._make_layer(256, 512, 2, stride=2)
 
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)
 
    def _make_layer(self, in_channels, out_channels, num_blocks, stride):
        layers = []
        layers.append(ResNetBlock(in_channels, out_channels, stride))
        self.in_channels = out_channels
        for i in range(1, num_blocks):
            layers.append(ResNetBlock(out_channels, out_channels))
        return nn.Sequential(*layers)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
 
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
 
        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

تهيئة النموذج

لإنشاء مثيل من نموذج ResNet-18 ، يمكنك ببساطة إنشاء مثيل للفئة ResNet18:

model = ResNet18(num_classes=10)

طباعة ملخص النموذج

يمكنك طباعة ملخص لهندسة نموذج ResNet-18 باستخدام وظيفة summary() من مكتبة torchsummary:

from torchsummary import summary
summary(model, input_size=(3, 224, 224))

سيوفر هذا نظرة عامة مفصلة عن طبقات النموذج ، بما في ذلك عدد المعلمات وشكل الإخراج لكل طبقة.

تدريب نموذج ResNet-18

إعداد مجموعة البيانات

تنزيل وتحميل مجموعة البيانات

لهذا المثال ، سنستخدم مجموعة بيانات CIFAR-10 ، والتي هي مجموعة بيانات اختبار شائعة لمهام تصنيف الصور. يمكنك تنزيل مجموعة البيانات باستخدام وحدة torchvision.datasets.CIFAR10:

# تنزيل وتحميل مجموعة بيانات CIFAR-10
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())

معالجة البيانات الأولية

قبل تدريب النموذج ، ستحتاج إلى معالجة البيانات ، مثل تطبيع قيم البكسل وتطبيق تقنيات زيادة البيانات:

# تحديد تحويلات البيانات
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
 
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])
 
# إنشاء محمّلات البيانات
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)

تعريف حلقة التدريب

تعيين الجهاز (وحدة المعالجة المركزية أو وحدة المعالجة المركزية)

للاستفادة من التسريع باستخدام وحدة المعالجة المركزية ، يمكنك نقل النموذج والبيانات إلى وحدة المعالجة المركزية:

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

تحديد دالة الخسارة والمحسن

بعد ذلك ، ستحتاج إلى تعريف وظيفة الخسارة والمحسن المستخدمين أثناء عملية التدريب:

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)

تنفيذ حلقة التدريب

سوف تنطوي حلقة التدريب على الخطوات التالية:

1. الإعادة الأمامية عبر النموذج
2. حساب الخسارة
3. انتشار الرقع
4. تحديث معلمات النموذج
5. تتبع فقدان التدريب ودقة التصنيف

num_epochs = 100
تدريب_الخسائر = []
تدريب_الصحة = []
تدريب_التصنيف = []
فحة_الخسائر = []
فحة_الصحة = []
فحة_التصنيف = []
 
for فحة في نطاق ( num_epochs ):
    # مرحلة التدريب
    النموذج.train()
    فقدان_التشغيل = 0.0
    صحيح = 0
    مجموع = 0
    ل i, (inputs, labels) في enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)
        
        optimizer.zero_grad()
        النتائج = model(inputs)
        خسارة = الcritيون(النتائج, labels)
 
## أمثلة الهيكل التكنولوجي
 
### تعظيم المردود
 
التعظيم هو تقنية يتم استخدامها لمنع الضباب في النماذج العميقة لتعلم العميق. يحدث الضباب عندما يؤدي النموذج بشكل جيد على بيانات التدريب ولكن لا يجتاز بنجاح إلى بيانات جديدة غير معروفة. تساعد تقنيات التعظيم النموذج على التعميم بشكل أفضل عن طريق إدخال عقوبة للتعقيد أو عن طريق إضافة ضجيج إلى عملية التدريب.
 
تقنية التعظيم الشائعة هي تعظيم L2 ، المعروفة أيضًا باسم تمرير الوزن. تضيف هذه الطريقة عبارة عن عقوبة لدالة الخسارة تتناسب مع المربع المطلق لأوزان النموذج. يمكن كتابة دالة الخسارة مع تمرير L2 على النحو التالي:
 

خسارة = الخسارة الأصلية + لامبدا * مجموع(و^2)

حيث λ هو قوة التعظيم ، و w هي أوزان النموذج.

تقنية التعظيم الشائعة الأخرى هي Dropout. تعيين Dropout جزءًا من التنشيطات في طبقة إلى صفر بشكل عشوائي أثناء التدريب ، مما يقلل بشكل فعال من قدرة النموذج ويجبره على تعلم ميزات قوية. يساعد ذلك في منع الشحذ ويمكن تحسين أداء التعميم النموذج.

فيما يلي مثال لكيفية تطبيق Dropout في نموذج PyTorch:

```python
import torch.nn as nn

فئة MyModel (nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(64, 128)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

في هذا المثال ، يتم تطبيق طبقة Dropout بعد الطبقة المتصلة بالكامل الأولى ، بمعدل Dropout 0.5 ، مما يعني أن 50٪ من التنشيطات سيتم تعيينها عشوائيًا إلى صفر أثناء التدريب.

خوارزميات التحسين

اختيار خوارزمية التحسين يمكن أن يكون له تأثير كبير على أداء الطراز والتقارب. فيما يلي بعض خوارزميات التحسين الشائعة المستخدمة في تعلم العميق:

الانحراف النزول التدريجي (SGD)

SGD هو أبسط خوارزمية تحسين ، يتم حساب التدرج على مثال تدريب واحد أو مجموعة صغيرة من الأمثلة ، وتتم تحديث الأوزان وفقًا لذلك. يمكن أن يكون SGD بطيئًا في التقارب ، ولكنه بسيط وفعال.

import torch.optim as optim
 
النموذج = MyModel()
المحسن = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

آدم

آدم (تقدير اللحظة التكيفية) هو خوارزمية تحسين أكثر تقدمًا تحسب معدلات التعلم المتكيفة لكل معلمة. يجمع بين فوائد وزخم و RMSProp ، مما يجعلها خيارًا شائعًا للعديد من مهام التعلم العميق.

المحسن = optim.Adam(model.parameters(), lr=0.001)

آداجراد

آداجراد (تكييف التدرج) هو خوارزمية تحسين تعدد سرعات التعلم لكل معلمة بناءً على التدرجات التاريخية. فهو فعال للبيانات الدركية ، ولكنه قد يعاني من تقليل حاد في سرعة التعلم مع مرور الوقت.

المحسن = optim.Adagrad(model.parameters(), lr=0.01)

رمسبروب

رمسبروب (انتشار مربع الجذر المتوسط) هو خوارزمية التعلم التلقائي لمعدلات التدرج المتوسط المربع. يعد مفيدًا بشكل خاص للأهداف غير ثابتة ، مثل تلك الموجودة في الشبكات العصبية المتكررة.

المحسن = optim.RMSprop(model.parameters(), lr=0.001, alpha=0.99)

اختيار خوارزمية التحسين يعتمد على المشكلة المحددة ، وبنية النموذج ، وخصائص البيانات. غالبًا ما يكون من الجيد تجربة خوارزميات مختلفة ومقارنة أدائها على مهمتك.

نقل التعلم

نقل التعلم هي تقنية حيث يتم استخدام النموذج المدرب على مجموعة بيانات كبيرة كنقطة انطلاق لنموذج على مجموعة بيانات مختلفة ولكن ذات صلة بعض الشيء. يمكن أن يكون ذلك مفيدًا بشكل خاص عندما تكون مجموعة البيانات المستهدفة صغيرة ، حيث يسمح للنموذج بالاستفادة من الميزات التي تم تعلمها على مجموعة البيانات الأكبر.

أحد النهج الشائعة لنقل التعلم في تعلم العمق هو استخدام نموذج مدرب مسبقًا ، مثل تلك المتاحة لمهام الرؤية المرقمة أو معالجة اللغة الطبيعية الشائعة ، وتحسين النموذج على مجموعة البيانات المستهدفة. ينطوي ذلك على تجميد الطبقات السفلية للنموذج المدرب مسبقًا وتدريب الطبقات العليا فقط على البيانات الجديدة.

فيما يلي مثال لكيفية ضبط نموذج ResNet المدرب مسبقًا لمهمة تصنيف الصور في PyTorch:

import torchvision.models as models
import torch.nn as nn
 
# تحميل نموذج ResNet الذي تم تدريبه مسبقًا
resnet = models.resnet18(pretrained=True)
 
# تجميد معلمات الطبقة المدربة مسبقًا
for param in resnet.parameters():
    param.requires_grad = False
 
# استبدال الطبقة الأخيرة بطبقة متصلة جديدة
num_features = resnet.fc.in_features
resnet.fc = nn.Linear(num_features, 10)  # نفترض وجود 10 فئات
 
# تدريب النموذج على مجموعة البيانات الجديدة
optimizer = optim.Adam(resnet.fc.parameters(), lr=0.001)

في هذا المثال ، نحمل أولاً نموذج ResNet18 المدرب مسبقًا ويجمد المعلمات الطبقات الأدنى. بعد ذلك ، نقوم بإستبدال الطبقة الكاملة الأخيرة باستخدام طبقة متصلة جديدة بعدد من المخرجات المناسب لمهمتنا المستهدفة (10 فئات في هذه الحالة). وأخيراً ، نقوم بتدريب النموذج باستخدام المبعد ذلك ، ستحتاج إلى تعريف وظيفة الفقدان والمحسن المستخدمين أثناء عملية التدريب:

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)

تنفيذ حلقة التدريب

ستتضمن حلقة التدريب الخطوات التالية:

1. إرسال البيانات من خلال النموذج
2. حساب الفقدان
3. إجراء توصيل للخلف للتفاوض
4. تحديث معلمات النموذج
5. تتبع الفقدان والدقة في التدريب

num_epochs = 100
train_losses = []
train_accuracies = []
val_losses = []
val_accuracies = []
 
for epoch in range(num_epochs):
    # مرحلة التدريب
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    for i, (inputs, labels) in enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)
        
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)

تحسين النموذج

التنظيم

التنظيم هو تقنية تُستخدم لمنع إفراط في التدريب في نماذج التعلم العميق. يحدث الإفراط في التعليم عندما يؤدي النموذج بشكل جيد على بيانات التدريب ولكنه يفشل في التعميم على البيانات الجديدة غير المرئية. تساعد تقنيات التنظيم النموذج على التعميم بشكل أفضل من خلال إدخال عقوبة على التعقيد أو بواسطة إضافة ضوضاء إلى عملية التدريب.

تعتبر تقنية التنظيم المُشتهرة هي التنظيم L2 ، والمعروفة أيضًا بالتراجع الوزني. تعمل هذه الطريقة على إضافة عبارة غرامة إلى وظيفة الفقدان تتناسب مع مربع حجم أوزان النموذج. يمكن كتابة وظيفة الفقدان مع التنظيم L2 كما يلي:

الفقدان = الفقدان_الأصلي + لامبدا * مجموع (w^2)

حيث لامبدا هو قوة التنظيم و w هي وزنا النموذج.

تقنية التنظيم المشهورة الأخرى هي Dropout. إن Dropout يقوم بتعيين جزء من التنشيطات في طبقة إلى الصفر بشكل عشوائي أثناء التدريب ، مما يقلل بشكل فعال من قدرة النموذج ويجبره على تعلم ميزات قوية أكثر. يساعد هذا في منع الإفراط في التعلم ويمكن أن يحسن أداء التعميم للنموذج.

فيما يلي مثال لكيفية تنفيذ Dropout في نموذج PyTorch:

import torch.nn as nn
 
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(64, 128)
        self.dropout = nn.Dropout(p=0.5)
        self.fc2 = nn.Linear(128, 10)
 
    def forward(self, x):
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

في هذا المثال ، يتم تطبيق طبقة Dropout بعد الطبقة الخطية المتصلة الأولى ، بمعدل Dropout قدره 0.5 ، مما يعني أن 50٪ من التنشيطات سيتم تعيينها عشوائيًا على الصفر أثناء التدريب.

خوارزميات الأمثلة

اختيار خوارزمية الأمثل له تأثير كبير على أداء وتقارب نموذج التعلم العميق. فيما يلي بعض الخوارزميات الشائعة المستخدمة في التعلم العميق:

الانحدار التدرجي العشوائي (SGD)

SGD هو أبسط خوارزمية أمثل ، حيث يتم حساب التدرجات على مثال تدريب واحد أو دفعة صغيرة من الأمثلة ، وتتم تحديث الأوزان وفقًا لذلك. قد يستغرق SGD وقتًا طويلاً للتقارب ، ولكنه بسيط وفعّال.

import torch.optim as optim
 
model = MyModel()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

Adam

Adam (Adaptive Moment Estimation) هو خوارزمية أمثل متقدمة أكثر تحديث تعليم الأمثلة التكيفي لكل معلمة. يجمع بين فوائد الزخم و RMSProp ، مما يجعلها خيارًا شائعًا للعديد من مهام التعلم العميق.

optimizer = optim.Adam(model.parameters(), lr=0.001)

AdaGrad

AdaGrad (Adaptive Gradient) هي خوارزمية أمثل تكيف معدل التعلم لكل معلمة بناءً على التدرجات التاريخية. إنها فعالة للبيانات الفارغة ، ولكنها قد تعاني من تخفيض متهور لمعدل التعلم بمرور الوقت.

optimizer = optim.Adagrad(model.parameters(), lr=0.01)

RMSProp

RMSProp (Root Mean Square Propagation) هي خوارزمية تكييف معدل التعلم الأمثل الأخرى التي تحتفظ بمتوسط تحرك للتدرجات التربيعية. إنها مفيدة بشكل خاص للأهداف غير الثابتة ، مثل تلك التي توجد في الشبكات العصبية المتكررة.

optimizer = optim.RMSprop(model.parameters(), lr=0.001, alpha=0.99)

اختيار خوارزمية الأمثل يعتمد على المشكلة المحددة وهيكل النموذج وخصائص البيانات. غالبًا ما يكون من الجيد تجربة خوارزميات مختلفة ومقارنة أدائها على المهمة الخاصة بك.

نقل التعلم

نقل التعلم هي تقنية يتم استخدام نموذج مدرب على مجموعة بيانات كبيرة كنقطة انطلاق لنموذج على مهمة مختلفة ولكن ذات صلة. يمكن أن تكون هذه التقنية مفيدة بشكل خاص عندما تكون مجموعة البيانات المستهدفة صغيرة ، حيث يسمح باستغلال الميزات التي تم تعلمها على مجموعة البيانات الأكبر.

واحدة من الطرق المشتركة لنقل التعلم في التعلم العميق هي استخدام نموذج مدرب مسبقًا ، مثل تلك المتاحة للمهام الشهيرة في رؤية الكمبيوتر أو معالجة اللغة الطبيعية ، وضبط النموذج على مجموعة البيانات المستهدفة. يعني ذلك تجميد الطبقات الأدنى للنموذج المدرب مسبقًا وفقط تدريب الطبقات الأعلى على البيانات الجديدة.

فيما يلي مثال على كيفية ضبط نموذج ResNet المدرب مسبقًا لمهمة تصنيف الصور في PyTorch:

import torchvision.models as models
import torch.nn as nn
 
# تحميل نموذج ResNet المدرب مسبقًا
resnet = models.resnet18(pretrained=True)
 
# تجميد معلمات النموذج المدرب مسبقًا
for param in resnet.parameters():
    param.requires_grad = False
 
# استبدال الطبقة الأخيرة بطبقة متصلة جديدة
num_features = resnet.fc.in_features
resnet.fc = nn.Linear(num_features, 10)  # نفترض وجود 10 فئات
 
# تدريب النموذج على مجموعة البيانات الجديدة
optimizer = optim.Adam(resnet.fc.parameters(), lr=0.001)

في هذا المثال ، نقوم أولاً بتحميل نموذج ResNet18 المدرب مسبقًا وتجميد معلمات الطبقات الأدنى. ثم نستبدل آخر طبقة متصلة بطبقة متصلة جديدة لها عدد مناسب من المخرجات للمهمة المستهدفة (10 فئات في هذه الحالة على سبيل المثال). أخيرًا ، نقوم بتدريب النموذج باستخدام محسن Adam ، مع تحديث المعلمات الخاصة بالطبقة المتصلة الجديدة فقط.

يمكن لنقل التعلم أن يحسن بشكل كبير أداء نماذج التعلم العميق ، خاصةً عندما تكون مجموعة البيانات المستهدفة صغيرة. إنها تقنية قوية يمكن توفير الوقت والموارد خلال تطوير النموذج.

تمكين النموذج

مع تطور نماذج التعلم العميق وانتشارها ، أصبحت الحاجة إلى نماذج قابلة للتفسير أكثر أهمية. تتعلق قابلية التفسير بالقدرة على فهم وشرح عملية صنع القرار الداخلية للنموذج.

إحدى التقنيات الشائعة لتحسين قابلية التفسير للنموذج هي استخدام آليات الانتباه. يسمح الانتباه للنموذج بالتركيز على الأجزاء الأكثر صلة في الإدخال عند صنع تنبؤ ، ويمكن تصورها لفهم الميزات التي يستخدمها النموذج.

فيما يلي مثال على كيفية تنفيذ آلية الانتباه في نموذج PyTorch لمهمة معالجة اللغة الطبيعية:

import torch.nn as nn
import torch.nn.functional as F
 
class AttentionModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim):
        super(AttentionModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, bidirectional=True, batch_first=True)
        self.attention = nn.Linear(hidden_dim * 2, 1)
 
    def forward(self, input_ids):
        # تَضْمين الإدخال
        embedded = self.embedding(input_ids)
 
        # تَمرير الإدخال المضاف عبر LSTM
        lstm_output, _ = self.lstm(embedded)
 
        # حساب وزن الانتباه
        attention_weights = F.softmax(self.attention(lstm_output), dim=1)
 
        # حساب المجموع المرجح لإخراج LSTM
        context = torch.sum(attention_weights * lstm_output, dim=1)
 
        return context

في هذا المثال ، تم تنفيذ آلية الانتباه كطبقة خطية تأخذ مخرجات LSTM كإدخال وتنتج مجموعة من أوزان الانتباه. يتم استخدام هذه الأوزان ثم لحساب المجموع المرجح لمخرجات LSTM ، وهو الإخراج النهائي للنموذج.

من خلال تصور أوزان الانتباه ، يمكنك الحصول على رؤى حول الأجزاء التي يركز عليها النموذج عند صنع تنبؤ. يمكن أن يساعدك ذلك في فهم عملية اتخاذ القرار للنموذج وتحديد الانحيازات المحتملة أو المجالات التي يمكن تحسينها.

تقنية أخرى لتحسين قابلية التفسير هي استخدام تحليل أهمية الميزات. يشمل ذلك تحديد السمات الأكثر أهمية التي يستخدمها النموذج لاتخاذ التنبؤات. إحدى الطرق الشائعة لذلك هي قيم شابلي ، التي توفر طريقة لقياس إسهام كل ميزة في النموذج الناتج.

تحسين قابلية التفسير هو مجال بحث هام في التعلم العميق ، حيث يمكن أن يساعد في بناء الثقة في هذه النماذج القوية والتأكد من استخدامها بشكل مسؤول.

الاستنتاج

في هذا البرنامج التعليمي ، قمنا بتغطية مجموعة متنوعة من المواضيع المتعلقة بالتعلم العميق ، بما في ذلك تحسين النماذج ، ونقل التعلم ، وقابلية التفسير. لقد ناقشنا تقنيات مثل التنظيم وخوارزميات التحسين وآليات الانتباه ، وقدمنا أمثلة على كيفية تنفيذ هذه المفاهيم في PyTorch.

مع استمرار تطور وانتشار التعلم العميق ، من المهم فهم هذه المواضيع المتقدمة وكيفية تطبيقها في مشاريعك الخاصة. من خلال اتقان هذه التقنيات ، ستكون مجهزًا بشكل أفضل لبناء نماذج عميقة قادرة على أداء عالٍ ومتين وقابلة للتفسير يمكن أن تحل مجموعة متنوعة من المشكلات.

تذكر ، التعلم العميق هو مجال يتغير بسرعة ، ومن المهم أن تبقى على اطلاع بآخر الأبحاث وأفضل الممارسات. استمر في الاستكشاف والتجربة والتعلم ، وستكون على الطريق الصحيح لتصبح خبيرًا في التعلم العميق.