كيفية فهم جدولة وحدة المعالجة الرسومية بسهولة وبسرعة

مقدمة في جدولة وحدة المعالجة الرسومية

I. مقدمة في جدولة وحدة المعالجة الرسومية

A. أهمية جدولة وحدة المعالجة الرسومية في التعلم العميق

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

B. نظرة عامة على بنية وحدة المعالجة الرسومية والمعالجة المتوازية

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

II. فهم جدولة وحدة المعالجة الرسومية

A. مبادئ جدولة وحدة المعالجة الرسومية

1. توزيع العبء

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

2. تخصيص الموارد

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

3. تحسين الجدولة

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

B. أنواع خوارزميات جدولة وحدة المعالجة الرسومية

1. التخطيط الثابت

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

2. جدولة ديناميكية

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

3. جدولة مختلطة

تجمع النهج المختلط بين عناصر الجدولة الثابتة والديناميكية ، واستغلال مزايا كل منها لتوفير حل جدولة شامل ومرن لأعباد العمل في التعلم العميق.

III. جدولة وحدة المعالجة الرسومية الثابتة

A. جدولة في وضع عدم الاتصال

1. ترتيب المهام بالأولوية

في جدولة عدم الاتصال ، يتم تحديد ترتيب المهام بناءً على عوامل مثل الموعد النهائي ، ومتطلبات الموارد ، أو أهمية المهمة ضمن سير العمل العام للتعلم العميق.

2. تخصيص الموارد

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

3. توازن العمل

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

B. جدولة قائمة على الحاجة

1. خوارزميات الجشع

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

def برنامج التخطيط_قسوة_لوحدة المعالجة الرسومية(tasks, gpu_resources):
    """
    برنامج تخطيط وحدة المعالجة الرسومية قائم على الجشع.
 
    Args:
        tasks (قائمة): قائمة المهام التي سيتم جدولتها.
        الموارد الرسومية (القاموس): قاموس الموارد المتاحة لوحدة المعالجة الرسومية.
 
    Returns:
        القاموس: ترسيم المهام إلى الموارد الرسومية.
    """
    الجدول = {}
    for المهمة في المهام:
        أفضل_وحدة_معالجة_رسومية = لا شيء
        الاستفادة_الدنيا = float('inf')
        for gpu، الموارد في gpu_resources.items():
            if الموارد['الذاكرة'] > = المهمة['الذاكرة'] and \
               الموارد['الحساب'] > = المهمة['الحساب']:
                التوظيف = (الموارد['الذاكرة'] - المهمة['الذاكرة']) / الموارد['الذاكرة'] + \
                              (الموارد['الحساب'] - المهمة['الحساب']) / الموارد['الحساب']
                if الموارد < الاستفادة_الدنيا:
                    أفضل_وحدة_معالجة_رسومية = gpu
                    الاستفادة_الدنيا = الموارد
        if أفضل_وحدة_معالجة_رسومية ليست بلا شك:
            الجدول[المهمة] = أفضل_وحدة_معالجة_رسومية
            gpu_resources[أفضل_وحدة_معالجة_رسومية]['الذاكرة'] - = المهمة['الذاكرة']
            الموارد[أفضل_وحدة_معالجة_رسومية]['الحساب'] - = المهمة['الحساب']
        else:
            raise ValueError(f"غير قادر على جدولة المهمة {المهمة}")
    العودة جدول

2. خوارزمات الجينات

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

3. التلدين المحاكاة

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

C. نهج الأمثلة الرياضية

1. البرمجة الخطية

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

import numpy as np
from scipy.optimize import linprog
 
def برمجة_خطية_وحدة المعالجة الرسومية_لمجدولة (مهام ، موارد_وحدة المعالجة الرسومية):
    """
    خوارزمية جدولة وحدة المعالجة الرسومية قائمة على البرمجة الخطية.
 
    Args:
        tasks (قائمة): قائمة المهام التي ستتم جدولتها.
        الموارد الرسومية (القاموس): قاموس الموارد المتاحة لوحدة المعالجة الرسومية.
 
    Returns:
        القاموس: ترسيم المهام إلى الموارد الرسومية.
    """
    num_tasks = len(tasks)
    num_gpus = len(gpu_resources)
    
    # تعريف معاملات وظيفة الهدف
    c = np.ones(num_tasks * num_gpus)
    
    # تعريف مصفوفة القيود
    A_eq = np.zeros((num_tasks + num_gpus, num_tasks * num_gpus))
    b_eq = np.zeros(num_tasks + num_gpus)
    
    # قيود المهمة
    for i in range(num_tasks):
        A_eq[i, i * num_gpus:(i + 1) * num_gpus] = 1
        b_eq[i] = 1
    
    # قيود موارد وحدة المعالجة الرسومية
    for j in range(num_gpus):
        A_eq[num_tasks + j, j::num_gpus] = [task['الذاكرة'] for task in tasks]
        A_eq[num_tasks + j, j::num_gpus] += [task['الحساب'] for task in tasks]
        b_eq[num_tasks + j] = موارد وحدة المعالجة الرسومية[j]['الذاكرة'] + الحساب_ولحدة المعالجة الرسومية[j]
    
    # حل مشكلة البرمجة الخطية
    x = linprog(c, A_eq=A_eq, b_eq=b_eq)
    
    # استخلاص مهمة إلى ترسيم وحدة المعالجة الرسومية
    جدول = {}
    for i in range(num_tasks):
        for j in range(num_gpus):
            if x.x[i * num_gpus + j] > 0:
                الجدول[tasks[i]] = list(gpu_resources.keys())[j]
    
    العودة جدول

2. البرمجة الصحيحة

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

3. البرمجة الرقابية

البرمجة الرقابية هي فئة من تقنيات أمثلة رياضية يمكن استخدامها لجدولة وحدة المعالجة الرسومية الثابتة ، حيث الهدف هو إيجاد التخصيص الأمثل لموارد وحدة المعالجة الرسومية للمهام مع ضمان أن وظيفة الهدف والقيود هي تقابلية.

IV. جدولة وحدة المعالجة الرسومية الديناميكية

A. جدولة في الوقت الحقيقي

1. إدارة أعباد العمل في الوقت الحقيقي

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

2. تخصيص موارد قابلة للتكييف

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

3. المصادرة والترحيل

قد تحتاج خوارزميات جدولة وحدة المعالجة الرسومية الديناميكية إلى دعم المصادرة والترحيل للمهام ، حيث يمكن تعليق المهام مؤقتًا واستئنافها في وقت لاحق على موارد وحدة المعالجة الرسومية مختلفة ، من أجل التكيف مع تغير ظروف عملية العمل.

B. جدولة قائمة على التعلم المعزز

1. عمليات القرار ماركوف

تكون خوارزميات جدولة وحدة المعالجة الرسومية المعتمدة على التعلم المعزز عمليات القرار ماركوف (MDPs) ، حيث يتخذ الجدول قرارات استنادًا إلى الحالة الحالية للنظام والمكافآت المستقبلية المتوقعة.

import gym
import numpy as np
from stable_baselines3 import PPO
 
class GPUSchedulingEnv(gym.Env):
    """
    بيئة Gym لجدولة وحدة المعالجة الرسومية باستخدام التعلم المعزز.
    """
    def __init__(self, tasks, gpu_resources):
        self.tasks = tasks
        self.gpu_resources = gpu_resources
        self.action_space = gym.spaces.Discrete(len(self.gpu_resources))
        self.observation_space = gym.spaces.Box(low=0, high=1, shape=(len(self.tasks) + len(self.gpu_resources),))
    
    def reset(self):
        self.task_queue = self.tasks.copy()
        self.gpu_utilization = [0.0] * len(self.gpu_resources)
        return self._get_observation()
    
    def step(self, action):
        # قم بتخصيص المهمة الحالية إلى وحدة المعالجة الرسومية المحددة
        task = self.task_queue.pop(0)

2. Deep Q-Networks

يمكن تعميم خوارزميات جدولة وحدة المعالجة الرسومية قائمة على التعلم المعزز باستخدام Deep Q-Networks (DQN) ، وهي شبكات عصبية تعلمية تستند إلى إطار عمل تعلم الماكينة لتحقيق القيمة العملية لحالات نظام الجدولة.

3. تعلم تقوية سياسة الممر المرجعي

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

gpu = list(self.gpu_resources.keys())[action] self.gpu_utilization[action] += task['memory'] + task['compute']

حساب الجائزة استنادًا إلى الحالة الحالية

reward = self._calculate_reward()

التحقق مما إذا كانت الحلقة مكتملة

done = len(self.task_queue) == 0

return self._get_observation(), reward, done,

def _get_observation(self): return np.concatenate((np.array([len(self.task_queue)]), self.gpu_utilization))

def _calculate_reward(self):

قم بتنفيذ وظيفة الجائزة الخاصة بك هنا

return -np.mean(self.gpu_utilization)

قم بتدريب وكيل PPO

env = GPUSchedulingEnv(tasks, gpu_resources) model = PPO('MlpPolicy', env, verbose=1) model.learn(total_timesteps=100000)


#### 2. Deep Q-Learning
Deep Q-Learning هو خوارزمية تعلم تعزيزي يمكن استخدامها لجدولة معالجات الرسوميات الديناميكية ، حيث يتعلم المخطط كيفية اتخاذ قرارات مثالية عن طريق تدريب شبكة عصبونية عميقة لتقريب وظيفة Q.

#### 3. السياسات التدرجية للسياسة
السياسات التدرجية للسياسة هي فئة من خوارزميات التعلم التعزيزي يمكن استخدامها لجدولة معالجات الرسوميات الدينامية ، حيث يتعلم المخطط كيفية اتخاذ قرارات مثالية عن طريق تحسين مباشر لوظيفة السياسة المعلمة.

### C. نماذج قوائم الانتظار
يمكن استخدام نظرية قوائم الانتظار لنمذجة سلوك جدولة معالجات الرسومات الدينامية ، حيث تصل المهام ويتم معالجتها بواسطة موارد معالجة الرسوميات المتاحة. يمكن لنماذج قوائم الانتظار أن توفر رؤى حول أداء نظام الجدولة وتساهم في تصميم خوارزميات جدولة أكثر فعالية.

#### 2. التحكم في القبول
يمكن أيضًا استخدام نهج قائمة الانتظار القائمة على نظرية قوائم الانتظار للتحكم في القبول في جدولة معالجات الرسوميات الدينامية ، حيث يقرر المخطط ما إذا كان يجب قبول أو رفض المهام الواردة استنادًا إلى الحالة الحالية للنظام والتأثير المتوقع على الأداء العام.

#### 3. سياسات الجدولة
يمكن استخدام نظرية قوائم الانتظار لتحليل أداء سياسات الجدولة المختلفة ، مثل الجدولة بالأولوية بناءً على الترتيب الزمني للمهام ، أو الجدولة بناءً على الترتيب الزمني للعمليات الأقصر ، أو الجدولة بناءً على الأولوية ، وتنمية تصميم خوارزميات جدولة معالجات الرسوميات الدينامية أكثر فعالية.

## V. جدولة معالجات الرسومات الهجينة

### أ. دمج التخطيط الثابت والديناميكي

#### 1. جدولة هرمية
قد تجمع نهجات جدولة معالجات الرسومات الهجينة بين تقنيات التخطيط الثابت والديناميكية ، حيث يقوم مخطط ثابت على مستوى عالٍ باتخاذ قرارات خشنة حول توزيع الموارد ، في حين يقوم مخطط دينامي بمستوى منخفض باتخاذ قرارات دقيقة حول جدولة المهام وإدارة الموارد.

#### 2. حمولات العمل المتنوعة
قد تكون نهجات جدولة معالجات الرسومات الهجينة مفيدة بشكل خاص للتعامل مع حمولات العمل المتنوعة ، حيث تحتوي أنواع المهام المختلفة على متطلبات وخصائص موارد مختلفة. يمكن للمخطط الثابت التعامل مع توزيع الموارد على المدى الطويل ، في حين يمكن للمخطط الدينامي التكيف مع تغيرات ظروف العمل.

#### 3. توقع حمولة العمل
قد تدمج نهجات جدولة معالجات الرسومات الهجينة أيضًا تقنيات توقع حمولة العمل ، حيث يستخدم المخطط الثابت خصائص المهمة المتوقعة ومتطلبات الموارد لاتخاذ قرارات أكثر اعتبارًا.

## الشبكات العصبية المتراكبة (CNNs)

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

مكونات أساسية في هندسة الشبكة العصبية المتراكبة هي:

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

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

```python
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# تعريف النموذج
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'])

في هذا المثال ، نقوم بتعريف نموذج CNN بثلاث طبقات تدرجية ، طبقتين تجمعيتين قصاصة وطبقتين متصلتين بالكامل. تأخذ الطبقة التدرجية الأولى صورة باللون الرمادي 28x28 (الشكل المدخل (28، 28، 1)) وتطبق 32 عامل تصفية بحجم 3x3 باستخدام وظيفة التنشيط Relu. تقوم الطبقة التجمعية بتقليل الأبعاد المكانية لخرائط الميزات بمعامل 2.

تستمر الطبقتين التدرجية الثانية والثالثة في استخلاص الميزات المعقدة أكثر ، تليهما طبقة تجميع أخرى. في النهاية ، يتم تمرير خرائط الميزات المسطحة من خلال طبقتين متصلتين بالكامل ، الأولى بـ 64 وحدة والثانية بـ 10 وحدات (تتوافق مع عدد الفئات في مهمة التصنيف).

تم تجميع النموذج باستخدام محسن Adam ووظيفة الخسارة cross-entropy الفئوية ، حيث أن هذه مشكلة تصنيف متعددة الفئات.

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

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

وتتكون مكونات مفتاحية في هندسة الشبكة العصبية المرتجحة من:

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

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

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, SimpleRNN, Dense
 
# تعريف النموذج
model = Sequential()
model.add(Embedding(input_dim=10000, output_dim=128, input_length=100))
model.add(SimpleRNN(64))
model.add(Dense(1, activation='sigmoid'))
 
# تجميع النموذج
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

في هذا المثال ، نعرف نموذج RNN مع ثلاث طبقات:

طبقة التضمين: تحول هذه الطبقة النص المدخل (الممثل بالتسلسل من مؤشرات الكلمات) إلى تمثيل متجه كثيف ، حيث تتمثل كل كلمة في متجه 128-بعدي.
طبقة SimpleRNN: هذه هي الطبقة الأساسية لنموذج RNN ، حيث يتم معالجة التسلسل المدخل وتحديث حالة الذاكرة والحالة المخفية في كل خطوة زمنية. الطبقة RNN بها 64 وحدة.
طبقة كثيفة: هذه هي الطبقة النهائية ، حيث يتم أخذ مخرج الطبقة RNN وتوليد قيمة مفردة للإخراج (تسمية تصنيف ثنائية في هذه الحالة).

تم تجميع النموذج باستخدام المحسن Adam ووظيفة الخسارة الفئوية الثنائية ، حيث أن هذه مشكلة تصنيف ثنائي.

الذاكرة القصيرة الطويلة (LSTMs)

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

تتألف المكونات الرئيسية لخلية LSTM من:

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

وفيما يلي مثال على نموذج LSTM لإنتاج النص:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
 
# تعريف النموذج
model = Sequential()
model.add(Embedding(input_dim=10000, output_dim=128, input_length=100))
model.add(LSTM(128))
model.add(Dense(10000, activation='softmax'))
 
# تجميع النموذج
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

في هذا المثال ، نقوم بتعريف نموذج LSTM مع طبقتين:

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

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

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

شبكات تحول تعلم الآلة التوليدية (GAN) هي نوع من نماذج التعلم العميق التي يتم تصميمها لتوليد بيانات جديدة ، مثل الصور ، التي تشبه مجموعة البيانات المعطاة. تتألف GAN من شبكتي تعلم عصبي يتم تدريبهما بطريقة تنافسية: شبكة مطلقة توليد وشبكة مطلقة تمييز.

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

شبكة المطلقة توليد: تتولى هذه الشبكة إنشاء بيانات جديدة (على سبيل المثال ، صور) التي تشبه بيانات التدريب.
شبكة المطلقة تمييز: تتولى هذه الشبكة التمييز بين البيانات الحقيقية (من مجموعة التدريب) والبيانات الوهمية (التي تم إنشاؤها بواسطة المولد).

عملية تدريب GAN تتضمن "لعبة" بين المولد والمميز ، حيث يحاول المولد إنتاج بيانات يمكن أن تخدع المميز ، والمميز يحاول التعرف بشكل صحيح على البيانات الحقيقية والوهمية.

فيما يلي مثال عن GAN بسيطة لتوليد أرقام مكتوبة يدويًا:

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, Reshape, Flatten, Conv2D, Conv2DTranspose, LeakyReLU, Dropout
 
# قم بتحميل مجموعة بيانات MNIST
(X_train، _)، (_, _) = mnist.load_data()
X_train = (X_train.astype('float32') - 127.5) / 127.5
X_train = X_train.reshape(X_train.shape[0]، 28، 28، 1)
 
# حدد المولد
generator = Sequential()
generator.add(Dense(7 * 7 * 256، input_dim=100))
generator.add(LeakyReLU(alpha=0.2))
generator.add(Reshape((7، 7، 256)))
generator.add(Conv2DTranspose(128، (5، 5)، strides=(1، 1)، padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(Conv2DTranspose(64، (5، 5)، strides=(2، 2)، padding='same'))
generator.add(LeakyReLU(alpha=0.2))
generator.add(Conv2DTranspose(1، (5، 5)، strides=(2، 2)، padding='same'، activation='tanh'))
 
# حدد المميز
discriminator = Sequential()
discriminator.add(Conv2D(64، (5، 5)، strides=(2، 2)، padding='same'، input_shape=(28، 28، 1)))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))
discriminator.add(Conv2D(128، (5، 5)، strides=(2، 2)، padding='same'))
discriminator.add(LeakyReLU(alpha=0.2))
discriminator.add(Dropout(0.3))
discriminator.add(Flatten())
discriminator.add(Dense(1، activation='sigmoid'))
 
# حدد GAN
gan = Model(generator.input، discriminator(generator.output))
discriminator.trainable = False
gan.compile(loss='binary_crossentropy'، optimizer='adam')

في هذا المثال ، نحدد GAN بسيطة لتوليد أرقام مكتوبة يدويًا. تتكون شبكة المولد من سلسلة من الطبقات التحويلية المنقلبة التي تحوّل متجه الإدخال ذو الأبعاد 100 إلى صورة باللون الرمادي بحجم 28 × 28. شبكة المميز هي شبكة عصبية تحويلية تأخذ صورة كإدخال وتخرج قيمة واحدة تشير إلى ما إذا كانت الصورة حقيقية (من مجموعة بيانات MNIST) أم مزيفة (تم إنشاؤها بواسطة المولد).

يتم ثم تحديد نموذج GAN عن طريق دمج شبكة المولد وشبكة المميز ، ويتم تجميد أوزان المميز أثناء تدريب GAN. يتم تجميع GAN بواسطة وظيفة فقد فقد فئوي ومحسن آدم.

الاستنتاج

في هذا البرنامج التعليمي ، قمنا بشرح العديد من بنى تعلم الآلة التحويلية وتطبيقاتها:

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

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

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

كيفية تحسين بطاقة الرسوميات بسهولة للحصول على الأداء الأمثل كيفية فهم أساسيات مجموعة أجهزة الحساب عالية الأداء بسهولة