Phase 03: Deep Learning Core

مقدمة لـ PyTorch

Type: Build

Languages: Python

Prerequisites: Lesson 03.10 (Build Your Own Mini Framework)

Time: ~75 minutes

أهداف التعلم

• بناء وتدريب شبكات عصبية باستخدام PyTorch nn.Module، nn.Sequential، و autograd
• استخدموا مؤشرات PyTorch، وتسارع GPU، ودورة التدريب القياسية (zero_grad، للأمام، الخسارة، الخلف، الخطوة)
• حول مكونات الإطار الصغرى من الصفر إلى ما يعادلها بـ PyTorch
• الملف الشخصي ومقارنة سرعة التدريب بين إطار Python Pure- و PyTorch على نفس المهمة

المشكلة

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

كما أنه بطيء 500x من PyTorch في نفس المشكلة.

يقوم PyTorch بإرسال نفس العمليات إلى أجزاء C ++ / CUDA المثلى التي تعمل على GPU. على NVIDIA A100 واحدة، يقوم PyTorch بتدريب ResNet-50 (25.6M ملامي الحدود) على ImageNet (1.28M الصور) في حوالي 6 ساعات. سيستغرق إطارك حوالي 3000 ساعة على نفس المهمة - إذا لم ينفذ من الذاكرة أولاً.

السرعة ليست الفجوة الوحيدة. لا يوجد دعم لـ GPU في إطار العمل الخاص بك. لا يوجد تمييز تلقائي -- كتبت يدوياً للخلف) لكل وحدات. لا توجد سلسلة. لا تدريب منتشر. لا توجد دقة مختلطة. لا توجد طريقة لإلغاء التدفق التدريجي دون بيانات الطباعة.

تقوم PyTorch بملء كل هذه الفجوات. وهي تفعل ذلك مع الحفاظ على نفس النموذج العقلي بالضبط الذي قمت بإنشائه بالفعل: الوحدة ، للأمام ((() ، المعلمات ((() ، والعودة ((() ، والتحسين. الخطوة ((().

المفهوم

لماذا فاز بيتورش

في عام 2015، طلب من TensorFlow تعريف الرسم البياني للحوسبة الدولية قبل تشغيل أي شيء. قمت ببناء الرسم البياني، ووضعها، ثم إرسال البيانات من خلالها. إعادة التشغيل يعني النظر في تصاميم الرسم البياني. تغيير الهندسة المعمارية يعني إعادة بناء الرسم البياني من الصفر.

بدأت PyTorch في عام 2017 مع فلسفة مختلفة: تنفيذ حريص. يمكنك كتابة Python.y = model(x)في الواقع يحسب y الآن، وليس "إضافة عقدة إلى الرسم البياني الذي سوف يحسب y في وقت لاحق". هذا يعني أدوات التحليل القياسية Python عملت. طباعة() عملت. pdb عملت. إذا /else في مرورك المقدمة عملت.

بحلول عام 2020 ، كان السوق قد تحدثت. ارتفع حصة PyTorch في ورق بحث ML من 7% (2017) إلى أكثر من 75% (2022). تستخدم Meta ، Google DeepMind ، OpenAI ، Anthropic ، و Hugging Face جميعًا PyTorch كإطار أساسي. تبنت TensorFlow 2.x تنفيذًا حريصًا رداً على ذلك - الاعتراف الصامت بأن تصميم PyTorch كان صحيحًا.

الدرس: تجربة المطورين المركبات إطار عمل بطيء بنسبة 10% ولكن أسرع بنسبة 50% لإزالة التشويق يفوز كل مرة

الجهاز

الجهاز هو مجموعة متعددة الأبعاد مع ثلاثة خصائص حاسمة: الشكل، dtype، والجهاز.

pythonCopyimport torch

x = torch.zeros(3, 4)           # shape: (3, 4), dtype: float32, device: cpu
x = torch.randn(2, 3, 224, 224) # batch of 2 RGB images, 224x224
x = torch.tensor([1, 2, 3])     # from a Python list

Shapeهو الامتعداد. وهو شكل (), وكتور هو (n,), ماتريكس هو (m, n), مجموعة من الصور هي (مجموعة, قنوات, ارتفاع, عرض).

Dtypeيسيطر على الدقة والذاكرة

Deviceيحدد أين يحدث الحساب.

pythonCopydevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(3, 4, device=device)
x = x.to("cuda")
x = x.cpu()

كل عملية تتطلب جميع الجهاز التنسورية نفسها. هذا هو الخطأ رقم 1 PyTorch المبتدئين ضرب: RuntimeError: Expected all tensors to be on the same deviceإصلاحها عن طريق نقل كل شيء إلى نفس الجهاز قبل الحساب.

Reshapingهو الوقت المستمر -- يغير البيانات المعدنية، وليس البيانات.

pythonCopyx = torch.randn(2, 3, 4)
x.view(2, 12)      # reshape to (2, 12) -- must be contiguous
x.reshape(6, 4)    # reshape to (6, 4) -- works always
x.permute(2, 0, 1) # reorder dimensions
x.unsqueeze(0)     # add dimension: (1, 2, 3, 4)
x.squeeze()        # remove size-1 dimensions

أوتوجراد

يتطلب منك إطار العمل الصغير تنفيذها للخلف (() لكل وحدات. لا يفعل PyTorch. يسجل كل عملية على العجلات في رسومة محمولة موجهة (الرسمة الحاسبية) ثم يمر عبر هذا الرسمة العكسي لحساب تراجعات تلقائيا.

graph LR
    x["x (leaf)"] --> mul["*"]
    w["w (leaf, requires_grad)"] --> mul
    mul --> add["+"]
    b["b (leaf, requires_grad)"] --> add
    add --> loss["loss"]
    loss --> |".backward()"| add
    add --> |"grad"| b
    add --> |"grad"| mul
    mul --> |"grad"| w

الفرق الرئيسي من إطارك: PyTorch يستخدم التشغيل الذاتي القائم على الشريط. كل عملية ترتبط بـ "الشريط" خلال المرور الأمامي. الاتصال .backward()يُعيد التسجيل في العكس

pythonCopyx = torch.randn(3, requires_grad=True)
y = x ** 2 + 3 * x
z = y.sum()
z.backward()
print(x.grad)  # dz/dx = 2x + 3

ثلاثة قواعد للدراسة الذاتية:

1. فقط الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " الـ " " الـ " " " " الـ " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " "requires_grad=Trueتراكم التدرج
2. الدرجات تتراكم بطبيعة الحال -- دعوة optimizer.zero_grad()قبل كل مرور خلفي
3. torch.no_grad()تعطيل تتبع التراجع (استخدام أثناء التقييم)

nn.مودول

nn.Moduleهي الصف الأساسي لكل مكون للشبكة العصبية في PyTorch. لقد بنيت هذا التجريد بالفعل في الدروس 10. إصدار PyTorch يضيف تسجيل المعلمات تلقائي، اكتشاف الوحدة التجاعدية، إدارة الجهاز، وتسلسل الحالة.

pythonCopyimport torch.nn as nn

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.layer2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        return x

عندما تعينnn.Moduleأوnn.Parameterكصفت في __init__"بيتورش" تسجلها تلقائياًmodel.parameters()هذا هو السبب في أنك لا تحتاج أبدا إلى جمع الوزن يدويا كما فعلت في الإطار الصغير.

أساسيات البناء:

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

(بايتورش) تسلم نسخ جاهزة للإنتاج من كل ما بنيته

Loss functions(منtorch.nn):

ملاحظة:CrossEntropyLossيجمعLogSoftmax+ NLLLossإضافة المواد الخام، وليس المخرجات المضمونة. هذا خطأ شائع ينتج التراجع الخاطئ بصمت.

Optimizers(منtorch.optim):

حلقة التدريب

كل حلقة تدريبية من PyTorch تتبع نفس النمط الخمس خطوات.

sequenceDiagram
    participant D as DataLoader
    participant M as Model
    participant L as Loss fn
    participant O as Optimizer

    loop Each Epoch
        D->>M: batch = next(dataloader)
        M->>L: predictions = model(batch)
        L->>L: loss = criterion(predictions, targets)
        L->>M: loss.backward()
        O->>M: optimizer.step()
        O->>O: optimizer.zero_grad()
    end

النمط القنوني:

pythonCopyfor epoch in range(num_epochs):
    model.train()
    for inputs, targets in train_loader:
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()

خمسة خطوط داخل حلقة اللحظة، خمسة خطوط تدرب GPT-4، Diffusion مستقر، و LLaMA. الهندسة المعمارية تتغير. البيانات تتغير. هذه الخطوط الخمسة لا.

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

(بيتورش)Datasetهو فئة تجريدية مع طريقتين: __len__و__getitem__. .DataLoaderيلفها مع إعادة التجميع، التدفق، وتحميل البيانات متعددة العمليات.

pythonCopyfrom torch.utils.data import Dataset, DataLoader

class MNISTDataset(Dataset):
    def __init__(self, images, labels):
        self.images = images
        self.labels = labels

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        return self.images[idx], self.labels[idx]

loader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=4)

num_workers=4يخلق 4 عمليات لحمل البيانات بالتوازي بينما تتدرب GPU على الحزمة الحالية. على أحمال عمل مرتبطة بالقرص (الصور الكبيرة، الصوت) ، وهذا وحده يمكن أن تضاعف سرعة التدريب.

تدريبات الجيبو

نقل النموذج إلى GPU:

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

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

pythonCopyinputs, targets = inputs.to(device), targets.to(device)

Mixed precisionيقلل من نصف استخدام الذاكرة ويضاعف من خلالها النمو على أجهزة المعالجة المعالجة المعالجة المعالجة الحديثة (A100، H100، RTX 4090) عن طريق التشغيل للأمام/الظهر في float16 مع الحفاظ على الأوزان الرئيسية في float32:

pythonCopyfrom torch.amp import autocast, GradScaler

scaler = GradScaler()
for inputs, targets in loader:
    with autocast(device_type="cuda"):
        outputs = model(inputs)
        loss = criterion(outputs, targets)
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
    optimizer.zero_grad()

مقارنة: Mini Framework vs PyTorch vs JAX

بناءها

(ميلف) ثلاث طبقات تدرب على (منست) باستخدام (بيتورش) البدائية فقط، لا يوجد غلفات عالية المستوىtorchvision.datasetsنحن ننزل ونحلل البيانات الخام بأنفسنا

الخطوة الأولى: تحميل MNIST من الملفات الخام

تم إرسال MNIST إلى البيانات بأربعة ملفات: صور التدريب (60,000 × 28 × 28) ، وملفات التدريب، وملفات الاختبار (10,000 × 28 × 28) ، وملفات الاختبار. ننزلها ونحلل النموذج الثنائي.

pythonCopyimport torch
import torch.nn as nn
import struct
import gzip
import urllib.request
import os

def download_mnist(path="./mnist_data"):
    base_url = "https://storage.googleapis.com/cvdf-datasets/mnist/"
    files = [
        "train-images-idx3-ubyte.gz",
        "train-labels-idx1-ubyte.gz",
        "t10k-images-idx3-ubyte.gz",
        "t10k-labels-idx1-ubyte.gz",
    ]
    os.makedirs(path, exist_ok=True)
    for f in files:
        filepath = os.path.join(path, f)
        if not os.path.exists(filepath):
            urllib.request.urlretrieve(base_url + f, filepath)

def load_images(filepath):
    with gzip.open(filepath, "rb") as f:
        magic, num, rows, cols = struct.unpack(">IIII", f.read(16))
        data = f.read()
        images = torch.frombuffer(bytearray(data), dtype=torch.uint8)
        images = images.reshape(num, rows * cols).float() / 255.0
    return images

def load_labels(filepath):
    with gzip.open(filepath, "rb") as f:
        magic, num = struct.unpack(">II", f.read(8))
        data = f.read()
        labels = torch.frombuffer(bytearray(data), dtype=torch.uint8).long()
    return labels

الخطوة الثانية: حدد النموذج

3-طبقة MLP: 784 -> 256 -> 128 -> 10. تنشيط ReLU. التخلي عن التنظيم. لا يوجد معيار لتحقيق البطولة.

pythonCopyclass MNISTModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(784, 256),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 10),
        )

    def forward(self, x):
        return self.net(x)

الطبقة الخارجة تنتج 10 logits خام (واحد لكل رقم). لا softmax -- CrossEntropyLossيتعامل مع ذلك داخلياً

عدد المعايير: 784256 + 256 + 256128 + 128 + 128*10 + 10 = 235,146. صغير بمعايير حديثة. GPT-2 صغير لديه 124M. هذا القطار في ثوان.

الخطوة الثالثة: حلقة التدريب

النمط القنوني للأمام-الخسارة-الخطوات الخلفية.

pythonCopydef train_one_epoch(model, loader, criterion, optimizer, device):
    model.train()
    total_loss = 0
    correct = 0
    total = 0
    for images, labels in loader:
        images, labels = images.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * images.size(0)
        _, predicted = outputs.max(1)
        correct += predicted.eq(labels).sum().item()
        total += labels.size(0)
    return total_loss / total, correct / total


def evaluate(model, loader, criterion, device):
    model.eval()
    total_loss = 0
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in loader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            loss = criterion(outputs, labels)
            total_loss += loss.item() * images.size(0)
            _, predicted = outputs.max(1)
            correct += predicted.eq(labels).sum().item()
            total += labels.size(0)
    return total_loss / total, correct / total

ملاحظةtorch.no_grad()هذا يعطى التحرر الذاتي، مما يقلل من استهلاك الذاكرة ويتسارع استنتاج. بدون ذلك، يقوم PyTorch ببناء الرسم البياني الحاسوبي الذي لا تستخدمه.

الخطوة الرابعة: قم بتجميع كل شيء

pythonCopydef main():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    download_mnist()
    train_images = load_images("./mnist_data/train-images-idx3-ubyte.gz")
    train_labels = load_labels("./mnist_data/train-labels-idx1-ubyte.gz")
    test_images = load_images("./mnist_data/t10k-images-idx3-ubyte.gz")
    test_labels = load_labels("./mnist_data/t10k-labels-idx1-ubyte.gz")

    train_dataset = torch.utils.data.TensorDataset(train_images, train_labels)
    test_dataset = torch.utils.data.TensorDataset(test_images, test_labels)
    train_loader = torch.utils.data.DataLoader(
        train_dataset, batch_size=64, shuffle=True
    )
    test_loader = torch.utils.data.DataLoader(
        test_dataset, batch_size=256, shuffle=False
    )

    model = MNISTModel().to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

    num_params = sum(p.numel() for p in model.parameters())
    print(f"Device: {device}")
    print(f"Parameters: {num_params:,}")
    print(f"Train samples: {len(train_dataset):,}")
    print(f"Test samples: {len(test_dataset):,}")
    print()

    for epoch in range(10):
        train_loss, train_acc = train_one_epoch(
            model, train_loader, criterion, optimizer, device
        )
        test_loss, test_acc = evaluate(
            model, test_loader, criterion, device
        )
        print(
            f"Epoch {epoch+1:2d} | "
            f"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f} | "
            f"Test Loss: {test_loss:.4f} | Test Acc: {test_acc:.4f}"
        )

    torch.save(model.state_dict(), "mnist_mlp.pt")
    print(f"\nModel saved to mnist_mlp.pt")
    print(f"Final test accuracy: {test_acc:.4f}")

الناتج المتوقع بعد 10 فترات: ~ 97.8٪ دقة الاختبار. وقت التدريب على المعالجة المركزية: ~ 30 ثانية. على GPU: ~ 5 ثانية. على الإطار الصغير مع نفس الهندسة المعمارية: ~ 45 دقيقة.

استخدمها

مقارنة سريعة: Mini Framework vs PyTorch

المقابلة متطابقة تقريباً، الفرق هو كل شيء تحت الغطاء

نموذجات حفظ وتحميل

pythonCopytorch.save(model.state_dict(), "model.pt")

model = MNISTModel()
model.load_state_dict(torch.load("model.pt", weights_only=True))
model.eval()

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

تخطيط معدلات التعلم

pythonCopyscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer, T_max=10
)
for epoch in range(10):
    train_one_epoch(model, train_loader, criterion, optimizer, device)
    scheduler.step()

تقوم بيتورش بنقل 15 خطة: StepLR، ExponentialLR، CosineAnnealingLR، OneCycleLR، ReduceLROnPlateau. جميعها متصلة بنفس واجهة التحسين.

أرسله

هذا الدروس يُنتج اثنين من الأثاث:

• outputs/prompt-pytorch-debugger.md-- تحذير لتشخيص فشل في تدريب PyTorch الشائع
• outputs/skill-pytorch-patterns.md-- مرجع مهارات لنمطات تدريب PyTorch

التمارين

1. Add batch normalization.إدراجnn.BatchNorm1dبعد كل طبقة خطية (قبل التشغيل). مقارنة دقة الاختبار وسرعة التدريب مقابل النسخة التي يتم إطلاقها فقط. يجب أن يصل معايير الحزمة إلى 98% + في فترات أقل.

1. Implement a learning rate finder.تدريب لمدة فترة مع زيادة معدلية للتعلم بشكل متسارع (من 1e-7 إلى 1.0). خسارة المساحة مقابل LR. يكون LR الأمثل قبل أن تبدأ الخسارة في التسلق. استخدم هذا لتحديد LR أفضل لنموذج MNIST.

1. Port to GPU with mixed precision.إضافةtorch.amp.autocastوGradScalerعلى حلقة التدريب. قياس التدفق (عينات/ثانية) مع ودون دقة مختلطة على GPU. على A100، توقع ~ 2x سرعة.

1. Build a custom Dataset.قم بتنزيل Fashion-MNIST (المثل في النموذج مثل MNIST ولكن مع أدوات الملابس). تنفيذ FashionMNISTDataset(Dataset)الفصل مع__getitem__و__len__. تدريب نفس MLP ومقارنة الدقة. الموضة-MNIST هو أصعب -- توقع ~ 88٪ مقابل ~ 98٪.

1. Replace Adam with SGD + momentum.القطار معSGD(params, lr=0.01, momentum=0.9). مقارنة منحنى التقارب. ثم أضفCosineAnnealingLRو نرى ما إذا كانت (إس جي دي) ستقبض على (آدم) بحلول العصر العاشر

الشروط الرئيسية

المزيد من القراءة

• پاسكيه وآخرون، "بيتورش: أسلوب إمبراطي، مكتبة التعلم العميق عالي الأداء" (2019) -- الورقة الأصلية التي تشرح تعادلات تصميم بيتورش
• دروس بيتورش: "تعلم بيتورش مع الأمثلة" (https://pytorch.org/tutorials/beginner/pytorch_with_examples.html) -- المسار الرسمي من الجهاز التنسوري إلى
• دليل تحديد أداء PyTorch (https://pytorch.org/tutorials/recipes/recipes/tuning_guide.html) -- الدقة المختلطة، وموظفي DataLoader، والذاكرة المثبتة، وغيرها من التحسينات الإنتاجية
• (هوراس هيه) ، "جعل التعلم العميق يذهب إلى (برر) "https://horace.io/brrr_intro.html) -- لماذا تدريب GPU سريع، مع استراتيجيات التحسين الخاصة بـ PyTorch

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.