الشبكات العصبية العميقة: دليل شامل

تقع الشبكات العصبية العميقة في صميم التطورات الأخيرة في الذكاء الاصطناعي. يستعرض هذا الدليل معمارياتها وتطبيقاتها.

1. المعماريات الأساسية

شبكة عصبية بسيطة

# مثال على تنفيذ شبكة عصبية بسيطة
import torch
import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.layer2 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.relu(self.layer1(x))
        x = self.layer2(x)
        return x

الشبكة العصبية الالتفافية

# مثال على تنفيذ شبكة CNN
class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 4 * 4, 512)
        self.fc2 = nn.Linear(512, 10)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = self.pool(self.relu(self.conv3(x)))
        x = x.view(-1, 64 * 4 * 4)
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

2. المعماريات المتقدمة

الشبكة العصبية المتكررة

# مثال على تنفيذ شبكة RNN
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super().__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        self.rnn = nn.RNN(
            input_size=input_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
            batch_first=True
        )
        
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.rnn(x, h0)
        out = self.fc(out[:, -1, :])
        return out

الشبكة العصبية ذات الذاكرة طويلة وقصيرة المدى (LSTM)

# مثال على تنفيذ شبكة LSTM
class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super().__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        self.lstm = nn.LSTM(
            input_size=input_size,
            hidden_size=hidden_size,
            num_layers=num_layers,
            batch_first=True
        )
        
        self.fc = nn.Linear(hidden_size, output_size)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

3. تقنيات التحسين

Dropout والتنظيم (Regularization)

# مثال على التنفيذ باستخدام dropout
class RegularizedNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.layer2 = nn.Linear(hidden_size, hidden_size)
        self.layer3 = nn.Linear(hidden_size, output_size)
        self.dropout = nn.Dropout(0.5)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.relu(self.layer1(x))
        x = self.dropout(x)
        x = self.relu(self.layer2(x))
        x = self.dropout(x)
        x = self.layer3(x)
        return x

Batch Normalization

# مثال على التنفيذ باستخدام batch normalization
class BatchNormNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)
        self.bn1 = nn.BatchNorm1d(hidden_size)
        self.layer2 = nn.Linear(hidden_size, output_size)
        self.bn2 = nn.BatchNorm1d(output_size)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.relu(self.bn1(self.layer1(x)))
        x = self.bn2(self.layer2(x))
        return x

4. التطبيقات العملية

تصنيف الصور

# مثال على تصنيف الصور باستخدام ResNet
from torchvision.models import resnet50

def image_classification(image_path):
    # تحميل النموذج المدرَّب مسبقًا
    model = resnet50(pretrained=True)
    model.eval()
    
    # تحضير الصورة
    transform = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406],
                           std=[0.229, 0.224, 0.225])
    ])
    
    image = transform(Image.open(image_path)).unsqueeze(0)
    
    # التنبؤ
    with torch.no_grad():
        outputs = model(image)
        _, predicted = torch.max(outputs, 1)
    
    return predicted.item()

معالجة اللغة الطبيعية

# مثال على معالجة النصوص باستخدام BERT
from transformers import BertTokenizer, BertModel

def text_processing(text):
    # تحميل النموذج
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    model = BertModel.from_pretrained('bert-base-uncased')
    
    # الترميز (Tokenization)
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    
    # التنبؤ
    with torch.no_grad():
        outputs = model(**inputs)
    
    return outputs.last_hidden_state

5. تقنيات التدريب

Learning Rate Scheduling

# مثال على learning rate scheduling
def train_with_scheduler(model, train_loader, epochs):
    optimizer = torch.optim.Adam(model.parameters())
    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
        optimizer, mode='min', factor=0.1, patience=5, verbose=True
    )
    
    for epoch in range(epochs):
        model.train()
        for batch in train_loader:
            optimizer.zero_grad()
            outputs = model(batch)
            loss = criterion(outputs, targets)
            loss.backward()
            optimizer.step()
        
        # تحديث معدل التعلم
        scheduler.step(loss)

Early Stopping

# مثال على early stopping
class EarlyStopping:
    def __init__(self, patience=7, min_delta=0):
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
        
    def __call__(self, val_loss):
        if self.best_loss is None:
            self.best_loss = val_loss
        elif val_loss > self.best_loss - self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0

الخاتمة

تقدّم الشبكات العصبية العميقة قدرات مبهرة:

• معالجة الصور
• معالجة اللغة الطبيعية
• التنبؤ بالسلاسل الزمنية
• توليد المحتوى
• التعلم المعزز

أهم النقاط الواجب تذكّرها:

• فهم المعماريات المختلفة
• إتقان تقنيات التحسين
• إدارة التدريب بكفاءة
• تقييم الأداء
• اتباع أفضل الممارسات