AI & GPU
كيفية الاستفادة بسهولة من قدرات GPU في TensorFlow

كيفية الاستفادة بسهولة من قدرات GPU في TensorFlow

I. مقدمة في TensorFlow مع GPU

A. نظرة عامة على TensorFlow

1. ما هو TensorFlow؟

TensorFlow هو إطار عمل للتعلم الآلي مفتوح المصدر تم تطويره بواسطة Google. يستخدم أساسا في بناء ونشر نماذج التعلم العميق، ولكنه يمكن أيضا تطبيقه على مجموعة واسعة من مهام التعلم الآلي الأخرى. يوفر TensorFlow مجموعة شاملة من الأدوات والمكتبات لمعالجة البيانات، وتدريب النماذج، ونشرها.

2. الميزات والقدرات الرئيسية

  • الحوسبة الموزعة: يدعم TensorFlow التدريب الموزع للنماذج عبر عدة أجهزة، بما في ذلك وحدات المعالجة المركزية ووحدات البطاقات الرسومية، مما يسمح بتوزيع فعال للعمليات الحسابية.
  • التنفيذ الفوري: يقدم TensorFlow 2.x التنفيذ الفوري، والذي يتيح التقييم الفوري للعمليات، مما يجعل عملية التطوير أكثر سهولة ومرونة.
  • تصميم مرن: يمكن تخصيص وتكييف TensorFlow بسهولة نظرًا لتصميمه المرن، ويمكن دمجه بسهولة مع المكتبات والأطر الأخرى مثل Keras وPandas وscikit-learn.
  • مرونة النشر: يمكن نشر نماذج TensorFlow على مجموعة متنوعة من المنصات، بما في ذلك الأجهزة المحمولة ومتصفحات الويب وخوادم الإنتاج، مما يجعلها خيارًا متعدد الاستخدامات للتطبيقات العملية في العالم الحقيقي.

B. أهمية تسريع GPU للتعلم العميق

1. قيود الحساب المستندة إلى وحدة المعالجة المركزية (CPU)

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

2. فوائد التعلم العميق بدعم وحدات معالجة الرسومات (GPU)

تم تصميم وحدات معالجة الرسومات (GPUs) للحسابات المتوازية العالية، مما يجعلها مناسبة تمامًا لعمليات العمليات على المصفوفات وتحويلات التوتير التي تحتل مكاناً رئيسياً في التعلم العميق. يمكن أن يعزز تسريع GPU أداء تدريب وأداء نماذج التعلم العميق بشكل كبير، مما يتيح للنموذج التواصل الأسرع واستكشاف البنيات الأكثر تعقيدًا.

II. إعداد البيئة

A. متطلبات الأجهزة

1. المواصفات الدنيا لوحدة المعالجة المركزية (GPU)

لتشغيل TensorFlow بدعم GPU، ستحتاج إلى وحدة معالجة رسومات (GPU) متوافقة مع CUDA، منصة الحوسبة المتوازية لشركة NVIDIA. تتضمن المواصفات الدنيا لوحدة المعالجة المركزية (GPU) ما يلي:

  • وحدة المعالجة المركزية من NVIDIA بقدرة حسابية 3.5 أو أعلى
  • 2 جيجابايت على الأقل من ذاكرة وحدة المعالجة المركزية

2. تكوينات GPU الموصى بها

للحصول على أداء مثالي في مهام التعلم العميق، يوصى باستخدام وحدة معالجة رسومات (GPU) أقوى بالمواصفات التالية:

  • وحدة المعالجة المركزية من NVIDIA بقدرة حسابية 6.0 أو أعلى (مثل NVIDIA GTX 1080 أو RTX 2080 أو أعلى)
  • 8 جيجابايت على الأقل من ذاكرة وحدة المعالجة المركزية
  • ذاكرة النظام الكافية (RAM) لدعم وحدة المعالجة المركزية وعبء عمل التعلم العميق

B. تثبيت البرامج

1. تثبيت TensorFlow بدعم لوحدة المعالجة المركزية (GPU)

a. Windows

  1. قم بتثبيت أحدث برامج تشغيل وحدة المعالجة المركزية من NVIDIA للنظام الخاص بك.
  2. قم بتنزيل وتثبيت حزمة TensorFlow GPU المناسبة من موقع TensorFlow الرسمي.
  3. قم بالتحقق من التثبيت عن طريق تشغيل الكود البايثون التالي:
import tensorflow as tf
print("إصدار TensorFlow:", tf.__version__)
print("وحدة المعالجة المركزية:", "متوفرة" if tf.config.list_physical_devices('GPU') else "غير متوفرة")

ب. macOS

  1. قم بتثبيت أحدث برامج تشغيل وحدة المعالجة المركزية من NVIDIA للنظام الخاص بك (إذا كان ذلك مطبقًا).
  2. قم بتنزيل وتثبيت حزمة TensorFlow GPU لنظام macOS من موقع TensorFlow الرسمي.
  3. قم بالتحقق من التثبيت بتشغيل نفس الكود البايثون كما في القسم الخاص بنظام Windows.

ج. Linux

  1. قم بتثبيت أحدث برامج تشغيل وحدة المعالجة المركزية من NVIDIA للنظام الخاص بك.
  2. قم بتثبيت مكتبات CUDA و cuDNN المطلوبة لتوزيعة لينكس الخاصة بك.
  3. قم بتنزيل وتثبيت حزمة TensorFlow GPU المناسبة من موقع TensorFlow الرسمي.
  4. قم بالتحقق من التثبيت بتشغيل نفس الكود البايثون كما في القسم الخاص بنظام Windows.

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

أ. التحقق من إصدار TensorFlow

يمكنك التحقق من الإصدار المثبت من TensorFlow عن طريق تشغيل الكود البايثون التالي:

import tensorflow as tf
print("إصدار TensorFlow:", tf.__version__)

ب. التحقق من توفر وحدة المعالجة المركزية

للتحقق من قدرة TensorFlow على استخدام وحدة المعالجة المركزية، يمكنك تشغيل الكود البايثون التالي:

import tensorflow as tf
print("وحدة المعالجة المركزية:", "متوفرة" if tf.config.list_physical_devices('GPU') else "غير متوفرة")

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

III. فهم تكامل TensorFlow مع وحدة المعالجة المركزية (GPU)

A. إدارة أجهزة وحدة المعالجة المركزية (GPU) في TensorFlow

1. التعرف على أجهزة وحدة المعالجة المركزية (GPU) المتاحة

يوفر TensorFlow وظائف لرصد أجهزة وحدة المعالجة المركزية (GPU) المتاحة في النظام الخاص بك. يمكنك استخدام الشيفرة التالية للحصول على قائمة بأجهزة وحدة المعالجة المركزية (GPU):

import tensorflow as tf
gpu_devices = tf.config.list_physical_devices('GPU')
print(gpu_devices)

سيقوم بطباعة قائمة بأجهزة وحدة المعالجة المركزية (GPU) المتاحة، بما في ذلك أسماء الأجهزة والمعلومات الأخرى ذات الصلة.

2. تعيين العمليات إلى أجهزة وحدة المعالجة المركزية (GPU)

بشكل افتراضي، سيقوم TensorFlow بتعيين العمليات تلقائيًا إلى أجهزة وحدة المعالجة المركزية (GPU) المتاحة. ومع ذلك، يمكنك أيضا التحكم يدويا في تعيين العمليات إلى الأجهزة باستخدام سياق الإدارة with tf.device():

with tf.device('/gpu:0'):
    # ضع العمليات على الجهاز الأول
    a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
    b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
    c = tf.multiply(a, b)

سيضمن هذا أن العمليات داخل كتلة with tf.device() سيتم تنفيذها على الجهاز المتاح الأول من وحدة المعالجة المركزية (GPU).

B. العمليات الخاصة بوحدة المعالجة المركزية (GPU) في TensorFlow

1. عمليات الفتح على وحدة المعالجة المركزية (GPU)

يوفر TensorFlow مجموعة واسعة من عمليات التحويل التي يمكن تنفيذها بكفاءة على أجهزة وحدة المعالجة المركزية (GPU). تشمل هذه العمليات الحسابات الحسابية الأساسية، وضرب المصفوفات، والتوتيرات، وما إلى ذلك. يستفيد TensorFlow تلقائيًا من قدرات معالجة وحدة المعالجة المركزية (GPU) المتوازية لتسريع هذه العمليات التحويل.

2. طبقات الشبكات العصبية على وحدة المعالجة المركزية (GPU)

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

C. تحسين استخدام وحدة المعالجة المركزية (GPU)

1. إدارة الذاكرة

إدارة الذاكرة الفعالة مهمة جدًا عند العمل مع وحدات المعالجة المركزية، حيث يكون حجم الذاكرة المتاحة في وحدة المعالجة المركزية محدودًا مقارنة بذاكرة النظام. يوفر TensorFlow أدوات وتقنيات لتحسين استخدام الذاكرة، مثل:

  • ضبط حجم الدُفعة ليتناسب مع الذاكرة المتاحة في وحدة المعالجة المركزية.
  • استخدام أنواع بيانات فعالة للذاكرة (مثل float16) لمعلمات النموذج.
  • تنفيذ معالجة مسبقة للبيانات ودُفعات ذات وعي بالذاكرة.

2. حجم الدُفعة والتوازي

يمكن أن يؤثر حجم الدُفعة المستخدم أثناء تدريب النموذج بشكل كبير على استخدام وحدة المعالجة المركزية وأداءها العام. يسمح الحجم الأكبر للدُفعة عادة بتوازي أكثر كفاءة في وحدة المعالجة المركزية، ولكنه يمكن أيضًا أن يتطلب مزيدًا من ذاكرة وحدة المعالجة المركزية. إيجاد حجم الدُفعة المثلى لنموذجك الخاص وإعداد الأجهزة الخاصة بك هو جزء مهم من تحسين أداء وحدة المعالجة المركزية.

IV. تنفيذ نماذج التعلم العميق باستخدام تسريع وحدة المعالجة المركزية (GPU)

A. مثال بسيط لوحدة المعالجة المركزية (GPU) في TensorFlow

1. إنشاء شبكة عصبية بسيطة

لنبدأ بمثال بسيط لإنشاء شبكة عصبية باستخدام TensorFlow وتشغيلها على وحدة المعالجة المركزية (GPU):

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
 
# إنشاء شبكة عصبية بسيطة
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(10,)))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))
 
# تجميع النموذج
model.compile(optimizer='adam', loss='mean_squared_error')

2. تدريب النموذج باستخدام وحدة المعالجة المركزية (GPU)

لتدريب النموذج باستخدام وحدة المعالجة المركزية، يمكنك استخدام الشيفرة التالية:

# ضع النموذج على وحدة المعالجة المركزية (GPU)
with tf.device('/gpu:0'):
    # تدريب النموذج
    model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_val, y_val))

سوف يضمن ذلك تنفيذ عمليات تدريب النموذج على أول جهاز وحدة معالجة رسومات (GPU) المتاح.

B. شبكات الانتشار المحدودة (CNNs) على وحدة المعالجة المركزية (GPU)

1. إنشاء تصميم ال CNN

فيما يلي مثال لبناء شبكة عصبية محدودة الانتشار بسيطة (CNN) باستخدام TensorFlow و Keras:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
 
# إنشاء نموذج CNN
model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
 
# تجميع النموذج
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

2. تدريب وتقييم نموذج CNN على وحدة المعالجة المركزية (GPU)

لتدريب وتقييم نموذج CNN على وحدة المعالجة المركزية، يمكنك استخدام الشيفرة التالية:

# ضع النموذج على وحدة المعالجة المركزية (GPU)
with tf.device('/gpu:0'):
    # تدريب النموذج
    model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_val, y_val))
 
    # تقييم النموذج
    loss, accuracy = model.evaluate(X_test, y_test)
    print(f'خسارة الاختبار: {loss:.2f}')
    print(f'دقة الاختبار: {accuracy:.2f}')

سيتم تدريب نموذج CNN على الوحدة المركزية المركزة وسيتم تقييم أدائه على مجموعة الاختبار.

C. شبكات العصبية المتكررة (RNNs) على وحدة المعالجة المركزية (GPU)

1. تصميم نموذج RNN

فيما يلي مثال لبناء شبكة عصبية متكررة بسيطة (RNN) باستخدام TensorFlow و Keras:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
 
```# إنشاء نموذج RNN
النموذج = تسلسل()
النموذج.أضف(LSTM(64, input_shape=(طول_التسلسل, حجم_الميزة)))
النموذج.أضف(المتوالية(1, activation='linear'))
 
# تجميع النموذج
النموذج.تجميع(optimizer='adam', loss='mean_squared_error')

2. الاستفادة من تسارع GPU لتدريب RNN

لتدريب نموذج RNN على GPU ، يمكنك استخدام الرمز التالي:

# وضع النموذج على وحدة المعالجة الرسومية
مع tf.الجهاز('/gpu:0'):
    # تدريب النموذج
    النموذج.يناسب(X_train، y_train، epochs=10، batch_size=32، validation_data=(X_val، y_val))
 
    # تقييم النموذج
    خسارة = النموذج.التقييم(X_test، y_test)
    طباعة(f'Test loss: {loss:.2f}')

سيتأكد هذا من تنفيذ عمليات تدريب RNN على وحدة المعالجة الرسومية ، مستفيدًا من قدرات معالجة الباراللية لوحدة المعالجة الرسومية لتسريع عملية التدريب.

الشبكات العصبية التحويلية المتسلسلة (CNNs)

الشبكات العصبية التحويلية المتسلسلة (CNNs) هي نوع مختص من الشبكات العصبية التي تتناسب بشكل خاص مع معالجة وتحليل بيانات الصور. يتم تصميم CNNs لتعلم الميزات الهرمية المكانية بشكل تلقائي وملائم ، من الميزات ذات المستوى المنخفض (مثل الحواف والألوان والأنسجة) إلى الميزات ذات المستوى العالي (مثل أجزاء الكائن والكائنات).

المكونات الرئيسية لـ CNN هي:

  1. ** الطبقات التحويلية **: تقوم هذه الطبقات بتطبيق مجموعة من المرشحات التي يمكن تعلمها (أو نوى) على الصورة الناتجة ، حيث يستخرج كل مرشح ميزة محددة من الصورة. يُسمى ناتج هذه العملية خريطة الميزات.
  2. ** طبقات التقليل **: تقوم هذه الطبقات بتقليل الأبعاد المكانية لخرائط الميزات ، مما يساعد على تقليل عدد المعلمات والعمليات الحسابية في الشبكة.
  3. ** الطبقات المتصلة بالكامل **: تشبه هذه الطبقات الطبقات الخفية في الشبكة العصبية التقليدية وتستخدم لمهمة التصنيف أو التوقع النهائي.

فيما يلي مثال لتنفيذ بنية CNN بسيطة لتصنيف الصور:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D، MaxPooling2D، Flatten، Dense
 
# تعريف النموذج
النموذج = سيكونيال()
النموذج.أضف(Conv2D(32، (3، 3)، activation='relu'، input_shape=(28، 28، 1)))
النموذج.أضف(MaxPooling2D((2، 2)))
النموذج.أضف(Conv2D(64، (3، 3)، activation='relu'))
النموذج.أضف(MaxPooling2D((2، 2)))
النموذج.أضف(Conv2D(64، (3، 3)، activation='relu'))
النموذج.أضف(شطب())
النموذج.أضف(Mat(Dense(64، activation='relu')))
النموذج.أضف(Mat(Dense(10، activation='softmax')))
 
# تجميع النموذج
النموذج.تجميع(optimizer='adam'،
              loss='categorical_crossentropy'،
              metrics=['accuracy'])

في هذا المثال ، نحدد نموذج CNN يحتوي على ثلاثة طبقات تحويلية ، طبقتي تقليل الحد من أبعاد الميزات ، وطبقتين متصلتين بالكامل. المدخل إلى النموذج هو صورة رمادية بحجم 28 × 28 ، والمخرج هو متجه ذو 10 أبعاد يمثل احتمالات كل فئة (تفترض مشكلة تصنيف الفئة العشرة).

الشبكات العصبية التكرارية (RNNs)

الشبكات العصبية التكرارية (RNNs) هي نوع من الشبكة العصبية التي تتناسب بشكل خاص مع معالجة البيانات التسلسلية ، مثل النص والكلام أو بيانات السلاسل الزمنية. على عكس الشبكات العصبية التفرعية ، تحتوي الشبكات العصبية التكرارية على دورة ردود فعل تسمح لها بالاحتفاظ بـ "الذاكرة" من الإدخالات السابقة ، والتي يمكن أن تكون مفيدة لمهام مثل نمذجة اللغة والترجمة الآلية والتعرف على الكلام.

المكونات الرئيسية لـ RNN هي:

  1. ** الطبقات التكرارية **: تقوم هذه الطبقات بمعالجة سلسلة الإدخال عنصرًا واحدًا تلو الآخر ، ويعتمد ناتج الطبقة في كل خطوة زمنية على الإدخال الحالي والحالة المخفية من الخطوة الزمنية السابقة.
  2. ** الحالة المخفية **: الحالة المخفية هي ناقل يمثل "الذاكرة" لـ RNN ، ويتم تمريرها من خطوة زمنية إلى الخطوة التالية.
  3. ** الطبقة الناتجة **: تستخدم الطبقة الناتجة لإنشاء الناتج النهائي لـ RNN ، مثل كلمة متوقعة أو تصنيف معين.

فيما يلي مثال لتنفيذ RNN بسيط لتوليد النص:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding، LSTM، Dense
 
# تعريف النموذج
النموذج = سيكونيال()
النموذج.أضف(تضمين(input_dim=حجم_المفردات، output_dim=256، input_length=ذروة_التسلسل))
النموذج.أضف(LSTM(128))
النموذج.إضافة(Mat(Dense(حجم_المفردات، activation='softmax')))
 
# تجميع النموذج
النموذج.تجميع(optimizer='adam'، loss='categorical_crossentropy'، metrics=['accuracy'])

في هذا المثال ، نحدد نموذج RNN مع طبقة تضمين ، طبقة LSTM ، وطبقة إخراج غنية. تقوم طبقة التضمين بتطابق النص الوردي إلى تمثيلات ناقلة كثافة ، وتقوم طبقة LSTM بمعالجة التتابع وتوليد حالة مخفية ، وتستخدم الطبقة الداكنة الحالة المخفية للتنبؤ بالحرف التالي في التسلسل.

ذاكرة قصيرة الأجل (LSTMs)

ذاكرة قصيرة الأجل (LSTMs) هي نوع خاص من RNN مصمم للتغلب على مشكلة الانحناء الزاوي الناعم ، والتي يمكن أن تجعل من الصعب على RNNs التقلبات ذات الصلة طويلة الأجل في البيانات.

المكونات الرئيسية لـ LSTM هي:

  1. ** الحالة الخلوية **: الحالة الخلوية هي ناقل يمثل "الذاكرة" لـ LSTM ، ويتم تمريرها من خطوة زمنية إلى الخطوة التالية.
  2. ** البوابات **: تحتوي LSTMs على ثلاثة بوابات تتحكم في تدفق المعلومات إلى الحالة الخلوية والخروج منها: بوابة النسيان ، بوابة الإدخال ، وبوابة الإخراج.
  3. ** الحالة المخفية **: الحالة المخفية هي ناقل يمثل الإخراج المخفي لـ LSTM في كل خطوة زمنية ، ويتم إرساله إلى الخطوة التالية ويستخدم لتوليد الناتج النهائي.

فيما يلي مثال لتنفيذ LSTM بسيطة لتحليل المشاعر:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding، LSTM، Dense
 
# تعريف النموذج
النموذج = سيكونيال()
النموذج.أضف(تضمين(input_dim=حجم_المفردات، output_dim=256، input_length=ذروة_التسلسل))
النموذج.أضف(LSTM(128))
النموذج.أضف(Mat(Dense(1، activation='sigmoid')))
 
# تجميع النموذج
النموذج.تجميع(optimizer='adam'، loss='binary_crossentropy'، metrics=['accuracy'])

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

الشبكات المولدة العدائية (GANs)

الشبكات المولدة العدائية (GANs) هي نوع من النماذج العميقة التعلم التي يمكن استخدامها لإنشاء بيانات جديدة ، مثل الصور أو النصوص ، التي تماثل مجموعة بيانات معينة. GANs تتكون من اثنين من الشبكات العصبية التي يتم تدريبها في مسابقة مع بعضها البعض: شبكة المولد التي تنشئ بيانات جديدة ، وشبكة المميز التي تحاول التمييز بين البيانات التي تم إنشاؤها والبيانات الحقيقية.

المكونات الرئيسية لـ GAN هي:

  1. ** شبكة المولد **: تأخذ هذه الشبكة مدخلًا عشوائيًا (على سبيل المثال ، متجه ضوضاء) وتنشئ بيانات جديدة تشبه بيانات التدريب.
  2. ** شبكة المميز **: تأخذ هذه الشبكة إدخالًا (سواء كان حقيقيًا أو مزيفًا) وتحاول تصنيفه كحقيقي أو غير حقيقي.
  3. ** التدريب العدائي **: تتم تدريب شبكة المولد وشبكة المميز في طريقة تنافسية ، حيث يحاول المولد خداع المميز ويحاول المميز تصنيف البيانات المولدة بدقة.

إليك مثال لتنفيذ GAN بسيطة لإنشاء أرقام يدوية مكتوبة:

import tensorflow as tf
from tensorflow.keras.models import Sequential، Model
from tensorflow.keras.layers import Dense، Reshape، Flatten، Conv2D، LeakyReLU، Dropout
 
# تعريف شبكة المولد
المولد = سيكونيال()
المولد.أضف(Dense(128، input_dim=100، activation=LeakyReLU(alpha=0.2)))
المولد.أضف(Reshape((7، 7، 1)))
المولد.أضف(Conv2D(64، (5، 5)، padding='same'، activation=LeakyReLU(alpha=0.2)))
المولد.أضف(Conv2D(1، (5، 5)، padding='same'، activation='tanh'))
 
# تعريف شبكة المميز
المميز = سيكونيال()
المميز.أضف(Conv2D(64، (5، 5)، padding='same'، input_shape=(28، 28، 1)، activation=LeakyReLU(alpha=0.2)))
المميز.أضف(Dropout(0.3))
المميز.أضف(Conv2D(128، (5، 5)، padding='same'، activation=LeakyReLU(alpha=0.2)))
المميز.أضف(Dropout(0.3))
المميز.أضف(شطب())
المميز.أضف(Dense(1، activation='sigmoid'))
 
# تعريف نموذج GAN
غان = نموذج(المولد.الدخول، المميز.الإخراج))

في هذا المثال ، نحدد GAN بسيطة لإنشاء أرقام مكتوبة يدويًا. تأخذ شبكة المولد إدخالًا عشوائيًا وتنشئ صور رمادية بحجم 28 × 28 ، بينما تأخذ شبكة المميز صورة مدخل وتحاول تصنيفها كحقيقية أو مزيفة. تتم تدريب نموذج GAN بالطريقة المعادية ، حيث يحاول المولد خداع المميز ويحاول المميز تصنيف الصور المولدة بدقة.

الخاتمة

في هذا البرنامج التعليمي ، قمنا بشرح المفاهيم والهندسات الرئيسية لمختلف نماذج التعلم العميق ، بما في ذلك الشبكات العصبية التحويلية المتسلسلة (CNNs) والشبكات العصبية التكرارية (RNNs) وذاكرة قصيرة الأجل (LSTMs) والشبكات المولدة العدائية (GANs). كما قدمنا أمثلة محددة وشفرات مصدر لتوضيح تنفيذ هذه النماذج.

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

كيفية فهم ResNet بسهولة في PyTorchالمعالجة المتوازية في Python: دليل للمبتدئين