رحلة بناء الذكاء الاصطناعي - دليل شامل من الألف إلى الياء

إليك الكود الذي يقوم برسم منزل بسيط (جدران، وسقف هرمي) بأبعاد محددة:

الكود البرمجي (Python for Blender)

كيف تستخدم هذا الكود داخل بليندر؟
افتح برنامج Blender.

من القائمة العلوية، اختر تبويب Scripting.

اضغط على زر + New لفتح ملف نصي جديد.

قم بنسخ الكود أعلاه ولصقه في المحرر.

اضغط على زر Run Script (الموجود في القائمة العلوية للمحرر).

ستلاحظ فوراً ظهور منزل ثلاثي الأبعاد في مساحة العمل.

لماذا هذا المثال مهم لمهندس الأتمتة؟
البارامترية (Parametric Design): يمكنك تغيير الأرقام في آخر سطر بالكود (width, depth, height) 
وسيقوم الكود بإعادة رسم المنزل فوراً بالأبعاد الجديدة دون تدخل يدوي.
الربط مع البيانات: تخيل لو قمت بربط هذا الكود بملف Excel يحتوي على مئات الأبعاد للعقارات؛ 
سيقوم بليندر برسم مئات المنازل في ثوانٍ معدودة.
الذكاء الاصطناعي: يمكنك لاحقاً دمج نماذج مثل (Stable Diffusion) لتوليد "خامات" (Textures) 
واقعية للجدران والأسقف بناءً على وصف نصي، ليصبح العمل مؤتمتاً بالكامل من الرسم إلى الإخراج النهائي.

  
بناء الذكاء الاصطناعي بالاكواد
بناء الذكاء الاصطناعي بالأكواد يتطلب الانتقال من الأتمتة البسيطة إلى التعلم الآلي (Machine Learning)

والتعلم العميق (Deep Learning).

في هذا السياق، سنبني نموذج ذكاء اصطناعي حقيقي باستخدام لغة Python ومكتبة PyTorch 

(وهي المكتبة الأكثر حداثة واستخداماً في الأبحاث والشركات الكبرى حالياً).

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

الكود البرمجي الكامل المشروح (PyTorch) بلغة بايثون Python
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# ==========================================
# الخطوة 2: جمع وتحضير البيانات (Data Preparation)
# ==========================================
# تحويل الصور إلى "Tensor" وتجهيزها (Normalization)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# تحميل بيانات MNIST (أرقام مكتوبة بخط اليد) - بيانات التدريب واختبار
train_data = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST('./data', train=False, transform=transform)

# تقسيم البيانات إلى دفعات (Batches)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000, shuffle=False)


# ==========================================
# الخطوة 3: تعريف الشبكة العصبية (Model Definition)
# ==========================================
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        # الشبكة العصبية: طبقتين متصلتين بالكامل (Fully Connected Layers)
        self.fc1 = nn.Linear(28*28, 128) # 입력: صوره حجمها 28*28 미터 مربع
        self.fc2 = nn.Linear(128, 10)    # مخرج: 10 تصنيفات (من 0 إلى 9)

    def forward(self, x):
        # تحويل الصورة إلى متجهة مسطحة (Flatten)
        x = x.view(-1, 28*28)
        # تمرير البيانات عبر الطبقة الأولى + دالة التفعيل Relu
        x = torch.relu(self.fc1(x))
        # تمرير البيانات عبر الطبقة الثانية
        x = self.fc2(x)
        # دالة الخروج (Softmax) لإعطاء احتمالات
        return torch.log_softmax(x, dim=1)

# إنشاء كائن من الشبكة
model = SimpleNet()


# ==========================================
# الخطوة 4: التدريب (Model Training)
# ==========================================
# دالة الخسارة (Loss Function) لقياس الخطأ
criterion = nn.NLLLoss()
# المحسن (Optimizer) لضبط أوزان الشبكة العصبية
optimizer = optim.SGD(model.parameters(), lr=0.01)

def train(epochs):
    model.train()
    for epoch in range(epochs):
        for batch_idx, (data, target) in enumerate(train_loader):
            optimizer.zero_grad()  # تصغير المشتقة (Gradient)
            output = model(data)    # خطوة التنبؤ
            loss = criterion(output, target) # حساب الخطأ
            loss.backward()         # حساب المشتقات (Backpropagation)
            optimizer.step()        # ضبط الأوزان

            if batch_idx % 200 == 0:
                print(f'Epoch: {epoch+1} [{batch_idx*len(data)}/{len(train_loader.dataset)}]'
                      f'\tLoss: {loss.item():.6f}')

# ==========================================
# الخطوة 5: التقييم (Evaluation)
# ==========================================
def test():
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad(): # لا حاجة لحساب المشتقات أثناء التقييم
        for data, target in test_loader:
            output = model(data)
            test_loss += criterion(output, target).item()
            pred = output.argmax(dim=1, keepdim=True) # التنبؤ النهائي
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print(f'\nTest Set: Average loss: {test_loss:.4f}, '
          f'Accuracy: {correct}/{len(test_loader.dataset)} '
          f'({100. * correct / len(test_loader.dataset):.0f}%)\n')

# ==========================================
# تنفيذ الدورة كاملة
# ==========================================
print("بدء تدريب الذكاء الاصطناعي...")
train(epochs=2)  # تدريب لمدة جولتتين
test()          # اختبار دقة النموذج

شرح الأكواد (ماذا فعلنا؟)

البيانات (datasets.MNIST): قمنا بتحميل آلاف الصور لأرقام مكتوبة بخط اليد. الذكاء الاصطناعي لا يرى "صوراً"، 
بل يرى مصفوفات من الأرقام (Tensor) تمثل شدة إضاءة كل بكسل.

الشبكة العصبية (SimpleNet): صممنا بنية عصبية بسيطة. الطبقة الأولى تستقبل بكسلات الصورة (784 بكسل)، 
والطبقة الأخيرة تخرج 10 أرقام؛ كل رقم يمثل احتمال أن تكون الصورة هي الرقم (0، 1، 2... أو 9).

دالة الخسارة (criterion): هي المقياس الذي يخبر الذكاء الاصطناعي عن مدى سوء تنبؤاته.
هدفنا هو جعل هذا الرقم أقرب ما يمكن للصفر.

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


دورة التدريب (train): نكرر عملية (التنبؤ -> حساب الخطأ -> ضبط الأوزان) آلاف المرات.

النتيجة: بعد دقيقتين فقط من التدريب، ستجد أن النموذج قادر على التعرف على الأرقام بدقة تتجاوز 95%.

لتشغيل هذا الكود، ستحتاج لتثبيت بايثون مع مكتبة PyTorch عبر الأمر:

pip install torch torchvision