أساسيات Deep Learning باستخدام Keras وPython

تعلم الآلة العميق (Deep Learning) هو أحد الفروع المتقدمة لتعلم الآلة (Machine Learning) التي تعتمد على استخدام الشبكات العصبية الاصطناعية (Artificial Neural Networks). هذه الشبكات العصبية تتكون من عدة طبقات (Layers) متصلة معًا، مما يسمح للنموذج بفهم الأنماط المعقدة الموجودة في البيانات. في هذا الدرس الشامل، سنتعرف على كيفية بناء نموذج تعلم عميق باستخدام مكتبة Keras مع لغة البرمجة Python، وسنقوم بتدريب هذا النموذج على مجموعة بيانات شهيرة، وهي مجموعة بيانات MNIST. سنشرح بالتفصيل كل خطوة في الكود لتوفير فهم شامل لكيفية بناء وتدريب نماذج التعلم العميق بكفاءة وفعالية.

1. ما هو تعلم الآلة العميق (Deep Learning)؟

تعلم الآلة العميق هو نوع من الشبكات العصبية التي تحاكي طريقة عمل الدماغ البشري. على عكس خوارزميات تعلم الآلة التقليدية التي تعتمد على استخدام ميزات محددة مسبقًا (Handcrafted Features)، تعتمد الشبكات العصبية العميقة على التعلم من البيانات مباشرةً لاكتشاف الميزات المناسبة. تتكون هذه الشبكات من طبقات متعددة من الوحدات العصبية (Neurons)، وكل طبقة منها تستخرج مستويات مختلفة من المعلومات. الشبكات العصبية العميقة قادرة على تحقيق نتائج مذهلة في مجالات مثل التصنيف (Classification)، والتعرف على الصور (Image Recognition)، ومعالجة اللغة الطبيعية (Natural Language Processing) لأنها تستطيع التعلم من البيانات المعقدة والمتنوعة.

2. مقدمة عن مكتبة Keras

Keras هي مكتبة مفتوحة المصدر تهدف إلى تسهيل عملية بناء نماذج تعلم الآلة العميق. هي واجهة برمجة تطبيقات (API) عالية المستوى، مبنية على مكتبة TensorFlow. باستخدام Keras، يمكن للمبرمجين إنشاء نماذج التعلم العميق بسرعة وسهولة، لأنها توفر واجهة بسيطة للتفاعل مع الشبكات العصبية دون الحاجة للتعامل مع التفاصيل المعقدة. يتميز Keras بأنه يدعم كل من الشبكات العصبية العميقة البسيطة مثل Sequential، بالإضافة إلى النماذج الأكثر تعقيدًا باستخدام Functional API. بالإضافة إلى ذلك، يمكن استخدامه مع مكتبات خلفية مثل TensorFlow، مما يتيح لك الوصول إلى إمكانات كبيرة للحوسبة المتوازية على وحدات المعالجة المركزية (CPU) ووحدات معالجة الرسومات (GPU).

3. تثبيت مكتبات Keras وTensorFlow

قبل البدء في برمجة أي نموذج باستخدام Keras، يجب التأكد من تثبيت كل من Keras وTensorFlow. TensorFlow هو محرك التعلم العميق الذي يعمل خلف الكواليس لتدريب النماذج وتنفيذ العمليات الحسابية. يتم تثبيتهما باستخدام pip، وهو مدير الحزم الخاص بـPython. في هذا السياق، يُستخدم الأمر التالي لتثبيت المكتبتين:

pip install tensorflow keras

بعد تنفيذ الأمر أعلاه، سيتم تنزيل وتثبيت المكتبتين مباشرةً. يعد TensorFlow الخيار الأكثر شيوعًا لاستخدامه مع Keras لأنه يوفر إمكانات حسابية قوية يمكن استغلالها لتسريع عملية التدريب عبر استخدام وحدات معالجة الرسومات (GPUs) وأحيانًا حتى وحدات معالجة الرسومات المتعددة (Multiple GPUs).

4. إنشاء نموذج أول باستخدام Keras

بمجرد تثبيت المكتبات، يمكننا الآن البدء ببناء أول نموذج باستخدام Keras. النموذج الذي سنقوم بإنشائه هو شبكة عصبية بسيطة مكونة من ثلاث طبقات: طبقة إدخال (Input Layer)، طبقة مخفية (Hidden Layer)، وطبقة إخراج (Output Layer). هذا النموذج سيقوم بتصنيف الصور من مجموعة بيانات MNIST، التي تحتوي على صور بالأبيض والأسود لأرقام مكتوبة بخط اليد.

شرح الكود خطوة بخطوة

لنقم بإنشاء النموذج باستخدام Keras. سنقوم بإنشاء نموذج من النوع Sequential، وهو نموذج تسلسلي يتم فيه إضافة الطبقات الواحدة تلو الأخرى. الطبقة الأولى ستكون طبقة إدخال تتوقع بيانات بحجم 784 وحدة (حيث أن كل صورة في مجموعة بيانات MNIST عبارة عن مصفوفة 28×28، وعلينا تحويلها إلى متجه واحد بطول 784). ثم نضيف طبقة مخفية تحتوي على 128 وحدة (Neurons) مع دالة تفعيل ReLU، وهي دالة غير خطية شائعة الاستخدام في الشبكات العصبية. أخيرًا، نضيف طبقة الإخراج التي تحتوي على 10 وحدات، حيث يمثل كل ناتج أحد الأرقام الممكنة (من 0 إلى 9). دالة التفعيل هنا هي softmax، والتي تحول النواتج إلى احتمالات بحيث يكون مجموعها 1.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# إنشاء النموذج
model = Sequential()

# إضافة الطبقة المخفية الأولى
model.add(Dense(128, activation='relu', input_shape=(784,)))

# إضافة طبقة الإخراج
model.add(Dense(10, activation='softmax'))

# عرض ملخص النموذج
model.summary()

في هذا الجزء من الكود، قمنا بإنشاء طبقتين رئيسيتين:

• الطبقة المخفية: تحتوي على 128 وحدة، وتستخدم دالة التفعيل ReLU التي تساعد على تعلم الأنماط غير الخطية.
• طبقة الإخراج: تحتوي على 10 وحدات مع دالة التفعيل softmax لتحويل النواتج إلى احتمالات لكل فئة من الفئات العشر.

5. تجميع وتدريب النموذج

بعد إنشاء هيكل النموذج، نحتاج الآن إلى تجميعه وتحديد كيفية تدريبه. عملية التجميع تشمل اختيار دالة الخسارة (Loss Function) المناسبة، التي تُستخدم لقياس مدى دقة النموذج أثناء التدريب. في هذا المثال، سنستخدم دالة الخسارة categorical_crossentropy التي تُستخدم عادةً في مسائل التصنيف متعدد الفئات. كما سنستخدم خوارزمية التحسين adam، وهي خوارزمية تحسين تعتمد على التدرج وتستخدم بشكل واسع في تعلم الآلة العميق.

# تجميع النموذج
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

بعد تجميع النموذج، يمكننا البدء في عملية التدريب باستخدام بيانات التدريب. سنقوم بتدريب النموذج لمدة 10 دورات (Epochs) باستخدام دفعات (Batches) بحجم 32، وسنستخدم بيانات الاختبار كبيانات تحقق (Validation Data) لمراقبة أداء النموذج أثناء التدريب.

# تدريب النموذج
history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))

في هذا الجزء، نستخدم model.fit لتدريب النموذج. يتم تحديد عدد الدورات (Epochs) إلى 10، مما يعني أن النموذج سيقوم بمراجعة مجموعة التدريب بالكامل 10 مرات. بالإضافة إلى ذلك، نحدد حجم الدفعة (Batch Size) إلى 32، مما يعني أن النموذج سيقوم بتحديث الأوزان بعد كل 32 مثالًا. نستخدم validation_data لتقييم النموذج في كل دورة باستخدام بيانات الاختبار.

6. تجهيز البيانات لمجموعة MNIST

مجموعة بيانات MNIST تتكون من صور بالأبيض والأسود لأرقام مكتوبة بخط اليد، حيث كل صورة تمثل رقمًا من 0 إلى 9. كل صورة بحجم 28×28 بيكسل. لتجهيز البيانات للتدريب، نحتاج إلى تحويل هذه الصور إلى متجهات مسطحة، أي تحويل الصورة إلى متجه بطول 784. بالإضافة إلى ذلك، سنقوم بتطبيع البيانات بحيث تكون القيم بين 0 و1 بدلاً من 0 و255 (لأن القيم الأولية هي قيم بيكسل). أخيرًا، سنحول التصنيفات (Labels) إلى صيغة الفئات المتعددة (One-hot Encoding) باستخدام to_categorical.

from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# تحميل بيانات MNIST
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# تحويل البيانات إلى أشكال ملائمة
x_train = x_train.reshape(60000, 784).astype('float32') / 255
x_test = x_test.reshape(10000, 784).astype('float32') / 255

# تحويل التسميات إلى تنسيق الفئات
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

في هذا الكود، نقوم أولاً بتحميل بيانات MNIST باستخدام mnist.load_data، ثم نقوم بتغيير شكل بيانات الصور وتحويلها إلى متجهات مسطحة، وتطبيعها إلى القيم بين 0 و1. نستخدم to_categorical لتحويل التسميات إلى صيغة الفئات المتعددة، حيث يتم تمثيل كل فئة كمتجه يحتوي على قيمة 1 في موقع الرقم الصحيح والباقي 0.

7. تدريب النموذج باستخدام البيانات المحضرة

بعد تجهيز البيانات، نبدأ الآن في عملية التدريب. التدريب يتضمن تمرير بيانات التدريب إلى النموذج في دفعات صغيرة (Batches)، حيث يقوم النموذج بتحديث الأوزان بناءً على دالة الخسارة. في هذا المثال، سنقوم بتدريب النموذج لمدة 10 دورات (Epochs) باستخدام دفعات حجمها 32.

# تدريب النموذج
history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))

في هذا الجزء، نستخدم model.fit لتدريب النموذج. يتم تحديد عدد الدورات (Epochs) إلى 10، مما يعني أن النموذج سيقوم بمراجعة مجموعة التدريب بالكامل 10 مرات. بالإضافة إلى ذلك، نحدد حجم الدفعة (Batch Size) إلى 32، مما يعني أن النموذج سيقوم بتحديث الأوزان بعد كل 32 مثالًا. نستخدم validation_data لتقييم النموذج في كل دورة باستخدام بيانات الاختبار.

8. تقييم أداء النموذج

بعد الانتهاء من التدريب، يمكننا الآن تقييم أداء النموذج على بيانات الاختبار. يتم ذلك باستخدام model.evaluate، الذي يقوم بحساب دقة النموذج على بيانات لم يرها أثناء التدريب.

# تقييم النموذج
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc:.4f}')

الكود أعلاه يقوم بحساب الخسارة (Loss) والدقة (Accuracy) على بيانات الاختبار. هذه الدقة تعطي مؤشرًا على مدى قدرة النموذج على التعميم وتقديم نتائج جيدة على بيانات جديدة.

9. عرض نتائج التدريب

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

import matplotlib.pyplot as plt

# رسم منحنيات الخسارة
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Loss Over Epochs')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

# رسم منحنيات الدقة
plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy Over Epochs')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()

plt.tight_layout()
plt.show()

في هذا الجزء، نستخدم مكتبة matplotlib لرسم منحنيات الخسارة والدقة لكل من بيانات التدريب والاختبار. يساعد هذا في فهم كيفية تحسن النموذج مع مرور الوقت وتحديد ما إذا كان النموذج يعاني من مشاكل مثل الإفراط في التخصيص (Overfitting) أو نقص التخصيص (Underfitting).

10. حفظ النموذج واستعادته

بعد تدريب النموذج وتقييمه، قد ترغب في حفظ النموذج لاستخدامه لاحقًا دون الحاجة إلى إعادة التدريب. يمكننا القيام بذلك باستخدام وظائف Keras المدمجة.

# حفظ النموذج
model.save('mnist_model.h5')

# استعادة النموذج المحفوظ
from tensorflow.keras.models import load_model
saved_model = load_model('mnist_model.h5')

# تقييم النموذج المستعاد
test_loss, test_acc = saved_model.evaluate(x_test, y_test)
print(f'Saved model Test accuracy: {test_acc:.4f}')

في هذا الكود، نقوم بحفظ النموذج في ملف بصيغة .h5 باستخدام model.save. يمكننا لاحقًا استعادة النموذج باستخدام load_model من نفس الملف، مما يتيح لنا استخدام النموذج بدون الحاجة لإعادة تدريبه.

11. الخاتمة

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