دليل المبتدئين في PyTorch: من الصفر إلى بطل التعلم العميق

ملخص

• PyTorch هو إطار عمل مرن للتعلم العميق يعتمد على لغة Python، ويُستخدم على نطاق واسع في الأبحاث والإنتاج.
• ستتعلم كيفية بناء وتدريب وتقييم الشبكات العصبية من الصفر.
• سنغطي الـ tensors، والـ autograd، والمحسنات (optimizers)، وأساسيات نشر النماذج.
• يتضمن أمثلة قابلة للتشغيل، ونصائح للأداء، والأخطاء الشائعة.
• مثالي لمطوري Python الذين يبدأون رحلتهم في التعلم العميق.

ما ستتعلمه

1. فهم أساسيات PyTorch وكيف يختلف عن أطر العمل الأخرى.
2. إنشاء ومعالجة الـ tensors للحسابات العددية.
3. بناء شبكات عصبية بسيطة وعميقة باستخدام torch.nn.
4. تدريب النماذج باستخدام خوارزمية الانحدار الاشتقاقي (gradient descent) ومراقبة الأداء.
5. تصحيح الأخطاء، وتحسين، ونشر نماذج PyTorch بفعالية.

المتطلبات الأساسية

قبل البدء، تأكد من توفر ما يلي:

• معرفة أساسية بلغة Python (الدوال، الفئات، تدفق التحكم)
• إلمام بمكتبة NumPy أو مفاهيم الجبر الخطي الأساسية
• تثبيت Python 3.10+ و PyTorch (استخدم pip install torch torchvision torchaudio)

للتحقق من التثبيت:

python -c "import torch; print(torch.__version__)"

المخرجات المتوقعة (الإصدار المستقر الحالي اعتباراً من 2026):

2.11.0

(قد يختلف إصدارك الدقيق بناءً على تاريخ الإصدار — أي إصدار في سلسلة 2.x سيتبع نفس واجهات البرمجة الموضحة في هذا الدليل.)

مقدمة: لماذا PyTorch؟

PyTorch هو إطار عمل مفتوح المصدر للتعلم الآلي تم تطويره في الأصل بواسطة فريق أبحاث الذكاء الاصطناعي الأساسي (FAIR) في Meta¹ وتديره الآن مؤسسة PyTorch التابعة لمؤسسة Linux. يشتهر برسمه البياني الحسابي الديناميكي — مما يعني أن النماذج يتم بناؤها وتعديلها أثناء التشغيل، مما يجعل التجريب بديهياً وتصحيح الأخطاء بسيطاً. على عكس أطر العمل ذات الرسوم البيانية الثابتة حيث يجب عليك تحديد الحساب بالكامل قبل التنفيذ، يقوم PyTorch بتنفيذ العمليات فوراً (التنفيذ العاجل - eager execution)، وهو ما يتماشى تماماً مع أسلوب Python الأصلي. منذ إصدار PyTorch 2.0 (مارس 2023)، قامت أداة torch.compile بسد الفجوة مع أنظمة الرسوم البيانية الثابتة، حيث تلتقط الكود العاجل وتحوله إلى رسم بياني محسن في الخلفية دون إجبارك على إعادة كتابة أي شيء.

المزايا الرئيسية

• نيردي وسهل الاستخدام: يبدو وكأنه كود Python عادي، مع توافق قوي مع NumPy.
• رسوم بيانية حسابية ديناميكية: رائع للأبحاث وبناء النماذج الأولية.
• دعم قوي لمعالجات الرسوميات (GPU): تسريع CUDA مدمج للتدريب عالي الأداء.
• تكامل مع النظام البيئي: يعمل بسلاسة مع TorchVision و TorchText و TorchAudio.
• جاهز للإنتاج: تتيح أدوات TorchScript و TorchServe نشر النماذج على نطاق واسع.

مقارنة: PyTorch مقابل TensorFlow

البداية: الـ Tensors والعمليات

الـ Tensors هي هيكل البيانات الأساسي في PyTorch — وهي مصفوفات متعددة الأبعاد تشبه مصفوفات NumPy، ولكن مع ميزة تسريع GPU.

إنشاء الـ Tensors

import torch

# من البيانات
data = [[1, 2], [3, 4]]
tensor = torch.tensor(data)

# من مصفوفة NumPy
import numpy as np
np_array = np.array(data)
tensor_from_np = torch.from_numpy(np_array)

# Tensor عشوائي
tensor_rand = torch.rand((2, 3))

print(tensor)
print(tensor_rand)

نقل الـ Tensors إلى GPU

device = "cuda" if torch.cuda.is_available() else "cpu"
tensor = tensor.to(device)
print(f"Tensor device: {tensor.device}")

مثال للمخرجات:

Tensor device: cuda

عمليات الـ Tensor

يدعم PyTorch مجموعة واسعة من العمليات:

a = torch.tensor([[1, 2], [3, 4]], dtype=torch.float32)
b = torch.tensor([[5, 6], [7, 8]], dtype=torch.float32)

print(torch.add(a, b))
print(torch.matmul(a, b))
print(a * b)  # ضرب عنصري (element-wise)

الاشتقاق التلقائي باستخدام Autograd

Autograd هو محرك الاشتقاق التلقائي في PyTorch². يقوم بتتبع العمليات على الـ tensors التي تحتوي على requires_grad=True ويحسب التدرجات (gradients) تلقائياً خلال مرحلة الانتشار العكسي (backward pass).

مثال: حساب تدرج بسيط

x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y * 3
out = z.mean()

out.backward()
print(x.grad)

المخرجات المتوقعة:

tensor([[4.5000, 4.5000], [4.5000, 4.5000]])

يتم حساب تدرج كل عنصر تلقائياً — لا حاجة للحساب اليدوي.

بناء شبكتك العصبية الأولى

دعنا نمر بمثال بسيط: تدريب شبكة عصبية أمامية (feedforward) على مجموعة بيانات MNIST.

الخطوة 1: استيراد المكتبات المطلوبة

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms

الخطوة 2: تعريف التحويلات ومحملات البيانات

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

الخطوة 3: تعريف النموذج

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28*28)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return F.log_softmax(x, dim=1)

الخطوة 4: تدريب النموذج

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(1, 4):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()

    print(f"Epoch {epoch}: Loss = {loss.item():.4f}")

مثال لمخرجات الطرفية (Terminal):

Epoch 1: Loss = 0.1873
Epoch 2: Loss = 0.0921
Epoch 3: Loss = 0.0654

متى تستخدم PyTorch ومتى لا تستخدمه

الأخطاء الشائعة والحلول

أفضل الممارسات

1. استخدام GPU بكفاءة

• استخدم torch.amp للتدريب بدقة مختلطة (تم إهمال مساحة الأسماء القديمة torch.cuda.amp في PyTorch 2.4 لصالح الموحدة torch.amp.autocast("cuda", ...) API)³.
• قم بتجميع البيانات في دفعات (Batch) بشكل فعال لزيادة استغلال GPU.
• استخدم أدوات التحليل مثل torch.utils.benchmark أو torch.profiler لتحديد اختناقات الأداء.

2. تحميل البيانات

• استخدم num_workers في DataLoader لتحميل البيانات بشكل متوازٍ.
• اضبط pin_memory=True عند نقل الدفعات إلى GPU.
• قم بتخزين البيانات المعالجة مسبقاً مؤقتاً (Cache) كلما أمكن ذلك.

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

• قم بتغليف نموذجك بـ torch.compile(model) (تم تقديمه في PyTorch 2.0، مارس 2023) لالتقاط رسم بياني (Graph) محسن عبر TorchDynamo + TorchInductor. تشهد معظم النماذج تسريعاً ملحوظاً على وحدات GPU المدعومة دون تغييرات في الكود.
• لالتقاط الرسم البياني وقت النشر، يفضل استخدام torch.export لخطوط المعالجة الجديدة؛ لا يزال TorchScript (torch.jit.trace / torch.jit.script) يعمل ولكنه في وضع الصيانة.
• يمكن لعمليات التكميم (Quantization) والتقليم (Pruning) تقليل حجم النموذج بشكل كبير.

اعتبارات أمنية

• تسلسل النموذج (Model Serialization): قم بتحميل نقاط التحقق (Checkpoints) فقط من المصادر الموثوقة. منذ إصدار PyTorch 2.6، يتم ضبط torch.load() افتراضياً على weights_only=True، مما يقيد عملية إلغاء التسلسل (Unpickling) على الموترات (Tensors) البسيطة والأنواع الأولية، ويقلل بشكل كبير من مخاطر تنفيذ الأكواد العشوائية التاريخية⁴. الكود القديم الذي يمرر صراحةً weights_only=False (أو يعمل على إصدار PyTorch أقل من 2.6) لا يزال بإمكانه تنفيذ كود عشوائي مدمج في نقطة تحقق خبيثة، لذا قم بمراجعة أي مواقع تحميل قديمة والتزم بأحدث إصدارات التصحيح.
• التحقق من المدخلات: قم دائماً بالتحقق من صحة وتطهير بيانات المدخلات لمنع الهجمات العدائية.
• قابلية التكرار: قم بضبط البذور العشوائية (Random Seeds) واستخدم خوارزميات حتمية للحصول على نتائج متوقعة.

torch.manual_seed(42)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

الاختبار والتحقق

يضمن الاختبار أن نموذجك يعمم بشكل جيد.

model.eval()
correct = 0
with torch.no_grad():
    for data, target in train_loader:
        data, target = data.to(device), target.to(device)
        output = model(data)
        pred = output.argmax(dim=1)
        correct += pred.eq(target.view_as(pred)).sum().item()

print(f'Accuracy: {100. * correct / len(train_loader.dataset):.2f}%')

المراقبة وقابلية الملاحظة

• استخدم تكامل TensorBoard (torch.utils.tensorboard) لتتبع الخسائر (Losses) والمقاييس.
• قم بتسجيل مقاييس التدريب، وإصدارات النماذج، والمعلمات الفائقة (Hyperparameters).
• راقب استخدام GPU باستخدام nvidia-smi أو torch.cuda.memory_summary() الخاص بـ PyTorch.

دراسة حالة واقعية: PyTorch في مرحلة الإنتاج

تستخدم شركات التكنولوجيا الكبرى والمؤسسات البحثية PyTorch لكل من التجريب والنشر على نطاق واسع⁵. على سبيل المثال:

• Meta: تستخدم PyTorch داخلياً لأبحاث الرؤية الحاسوبية ومعالجة اللغات الطبيعية، وترعى الإطار من خلال مؤسسة PyTorch Foundation.
• OpenAI: اعتمدت PyTorch رسمياً في عام 2020 لغالبية أبحاثها وأعمال الإنتاج، وقامت ببناء أدوات تكميلية فوقه (لاسيما لغة Triton لنواة GPU).
• Tesla: أفادت باستخدام PyTorch لإدراك القيادة الذاتية (بنية "HydraNet" متعددة المهام المستخدمة في Tesla Vision).

تسلط حالات الاستخدام هذه الضوء على مرونة PyTorch من بيئات البحث إلى بيئات الإنتاج.

القابلية للتوسع والنشر

يوفر PyTorch مسارات نشر متعددة:

• TorchScript: تحويل النماذج إلى صيغة متسلسلة لبيئة تشغيل C++.
• TorchServe: تقديم النماذج عبر REST APIs للاستدلال في مرحلة الإنتاج.
• تصدير ONNX: تحويل النماذج إلى تنسيق ONNX للتوافق بين الأطر المختلفة.

مخطط Mermaid: تدفق النشر

graph TD
A[PyTorch Model] --> B[TorchScript Conversion]
B --> C[TorchServe API]
C --> D[Production Clients]

الأخطاء الشائعة

1. نسيان استدعاء .eval() أثناء التقييم.
2. عدم فصل الموترات (Detaching tensors) أثناء التسجيل (Logging).
3. الخلط بين torch.Tensor (المنشئ) و torch.tensor() (دالة المصنع).
4. استخدام torch.load() على نقاط تحقق غير موثوقة مع weights_only=False (أو على إصدار PyTorch أقدم من 2.6).
5. تجاهل تسريبات ذاكرة CUDA بعدم مسح الذاكرة المؤقتة باستخدام torch.cuda.empty_cache().

تحدي "جربها بنفسك"

قم بتعديل مثال MNIST لـ:

1. إضافة طبقات Dropout لتقليل الإفراط في التخصيص (Overfitting).
2. تجربة محسن SGD بدلاً من Adam.
3. رسم خسارة التدريب باستخدام TensorBoard.

دليل استكشاف الأخطاء وإصلاحها

النقاط الرئيسية

يمكّن PyTorch المطورين من بناء وتدريب ونشر نماذج التعلم العميق بسهولة ومرونة.

• ابدأ صغيراً مع الموترات (Tensors) والاشتقاق التلقائي (Autograd).
• جرب نماذج بسيطة قبل التوسع.
• استخدم تسريع GPU وأدوات تحليل الأداء.
• تحقق دائماً من المدخلات وراقب الأداء.

الخطوات التالية / قراءات إضافية