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

ملاحظة: قد تصبح أدوات قياس الأداء الخاصة بمنصة Hugging Face مُهمَلة، ومن المفيد التحقق دومًا من هذه الملاحظات التي تشرح بالتفصيل كيفية قياس أداء نماذج Transformers.

قياس أداء نماذج المحولات Transformers

يسمح الصنفان PyTorchBenchmark و TensorFlowBenchmark بقياس أداء نماذج Transformers بمرونة كبيرة، حيث تسمح لنا أصناف قياس الأداء بقياس ذروة استخدام الذاكرة Peak Memory Usage، ومعرفة الوقت المطلوب Required Time لكل من الاستدلال Inference والتدريب Training.

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

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

يوضّح المثال التالي كيفية قياس أداء نموذج BERT من نوع bert-base-cased، في حال استخدام إطار عمل بايتورش Pytorch، فسنكتب ما يلي:

>>> from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments

>>> args = PyTorchBenchmarkArguments(models=["google-bert/bert-base-uncased"], batch_sizes=[8], sequence_lengths=[8, 32, 128, 512])
>>> benchmark = PyTorchBenchmark(args)

في حال استخدام إطار عمل تنسرفلو TensorFlow، فسنكتب ما يلي:

>>> from transformers import TensorFlowBenchmark, TensorFlowBenchmarkArguments

>>> args = TensorFlowBenchmarkArguments(
…    models=["google-bert/bert-base-uncased"], batch_sizes=[8], sequence_lengths=[8, 32, 128, 512]
… )
>>> benchmark = TensorFlowBenchmark(args)

تحتاج أصناف قياس الأداء لثلاثة وسطاء هي: models و batch_sizes و sequence_lengths، حيث يكون الوسيط models مطلوبًا ويمثل قائمة list من معرّفات النماذج المطلوب قياسها من مستودع النماذج. والوسيط batch_sizes اختياري ويستخدم لتحديد حجم الدفعات batch size أثناء قياس الأداء، والوسيط sequence_lengths اختياري لتحديد حجم معرّفات الدخل input_ids التي سيُقاس أداء النموذج عليها.

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

• src/transformers/benchmark/benchmark_args_utils.py
• src/transformers/benchmark/benchmark_args.py

والملف التالي لإطار عمل تنسرفلو Tensorflow:

• src/transformers/benchmark/benchmark_args_tf.py

 كما يمكن تشغيل أوامر الصدفة Shell التالية من المجلد الجذر لطباعة قائمة وصفية بجميع المعاملات القابلة للضبط لإطار عمل PyTorch و Tensorflow على التوالي.

سنستخدم الأمر التالي في إطار عمل PyTorch:

python examples/pytorch/benchmarking/run_benchmark.py --help

بعدها، يمكننا إنشاء كائن من صنف معين مخصص لقياس الأداء من خلال استدعاء التابع benchmark.run()‎:

>>> results = benchmark.run()
>>> print(results)
====================       INFERENCE - SPEED - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length     Time in s                  
--------------------------------------------------------------------------------
google-bert/bert-base-uncased          8               8             0.006     
google-bert/bert-base-uncased          8               32            0.006     
google-bert/bert-base-uncased          8              128            0.018     
google-bert/bert-base-uncased          8              512            0.088     
--------------------------------------------------------------------------------

====================      INFERENCE - MEMORY - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length    Memory in MB 
--------------------------------------------------------------------------------
google-bert/bert-base-uncased          8               8             1227
google-bert/bert-base-uncased          8               32            1281
google-bert/bert-base-uncased          8              128            1307
google-bert/bert-base-uncased          8              512            1539
--------------------------------------------------------------------------------

====================        ENVIRONMENT INFORMATION         ====================

- transformers_version: 2.11.0
- framework: PyTorch
- use_torchscript: False
- framework_version: 1.4.0
- python_version: 3.6.10
- system: Linux
- cpu: x86_64
- architecture: 64bit
- date: 2020-06-29
- time: 08:58:43.371351
- fp16: False
- use_multiprocessing: True
- only_pretrain_model: False
- cpu_ram_mb: 32088
- use_gpu: True
- num_gpus: 1
- gpu: TITAN RTX
- gpu_ram_mb: 24217
- gpu_power_watts: 280.0
- gpu_performance_state: 2
- use_tpu: False

وسنستخدم الأمر التالي في إطار عمل TensorFlow:

python examples/tensorflow/benchmarking/run_benchmark_tf.py --help

بعدها، يمكننا إنشاء كائن من صنف معين لقياس الأداء من خلال استدعاء التابع benchmark.run()‎:

>>> results = benchmark.run()
>>> print(results)
>>> results = benchmark.run()
>>> print(results)
====================       INFERENCE - SPEED - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length     Time in s                  
--------------------------------------------------------------------------------
google-bert/bert-base-uncased          8               8             0.005
google-bert/bert-base-uncased          8               32            0.008
google-bert/bert-base-uncased          8              128            0.022
google-bert/bert-base-uncased          8              512            0.105
--------------------------------------------------------------------------------

====================      INFERENCE - MEMORY - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length    Memory in MB 
--------------------------------------------------------------------------------
google-bert/bert-base-uncased          8               8             1330
google-bert/bert-base-uncased          8               32            1330
google-bert/bert-base-uncased          8              128            1330
google-bert/bert-base-uncased          8              512            1770
--------------------------------------------------------------------------------

====================        ENVIRONMENT INFORMATION         ====================

- transformers_version: 2.11.0
- framework: Tensorflow
- use_xla: False
- framework_version: 2.2.0
- python_version: 3.6.10
- system: Linux
- cpu: x86_64
- architecture: 64bit
- date: 2020-06-29
- time: 09:26:35.617317
- fp16: False
- use_multiprocessing: True
- only_pretrain_model: False
- cpu_ram_mb: 32088
- use_gpu: True
- num_gpus: 1
- gpu: TITAN RTX
- gpu_ram_mb: 24217
- gpu_power_watts: 280.0
- gpu_performance_state: 2
- use_tpu: False

يُقاس أداء الوقت المطلوب للاستدلال، ومقدار الذاكرة التي يحتاجها النموذج تلقائيًا دون الحاجة إلى تدخل يدوي من المستخدم. حيث يعرض القسم الأول والثاني من خرج المثال السابق النتيجة المقابلة لوقت الاستدلال وذاكرته، وتُطبَع جميع المعلومات ذات الصلة ببيئة الحوسبة ENVIRONMENT INFORMATIONمثل نوع وحدة معالجة الرسوميات GPU والنظام وإصدارات المكتبة وغير ذلك.

يمكننا حفظ هذه المعلومات اختياريًا في ملف ‎.csv عند إضافة الوسيط save_to_csv=True إلى الصنفين PyTorchBenchmarkArguments و TensorFlowBenchmarkArguments على التوالي، حيث يُحفَظ كل قسم في ملف منفصل، كما يمكننا تحديد مسار كل ملف ‎.csv اختياريًا.

قياس أداء النموذج BERT باستخدام إعدادات عشوائية

يمكننا قياس أداء نموذج model ما باستخدام إعدادات عشوائية بدلاً من قياس أداء نموذج مدرَّب مسبقًا باستخدام معرّف هذا النموذج، على سبيل المثال يمكن قياس أداء نموذج BERT باستخدام المعرف google-bert/bert-base-uncased، لنلقِ نظرة على المثال التالي الذي يستخدم إطار عمل بايتورش PyTorch لقياس أداء نماذج متعددة مستخدمًا إعدادات عشوائية:

>>> from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments, BertConfig

>>> args = PyTorchBenchmarkArguments(
…    models=["bert-base", "bert-384-hid", "bert-6-lay"], batch_sizes=[8], sequence_lengths=[8, 32, 128, 512]
… )
>>> config_base = BertConfig()
>>> config_384_hid = BertConfig(hidden_size=384)
>>> config_6_lay = BertConfig(num_hidden_layers=6)

>>> benchmark = PyTorchBenchmark(args, configs=[config_base, config_384_hid, config_6_lay])
>>> benchmark.run()
====================       INFERENCE - SPEED - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length       Time in s                  
--------------------------------------------------------------------------------
bert-base                  8              128            0.006
bert-base                  8              512            0.006
bert-base                  8              128            0.018     
bert-base                  8              512            0.088     
bert-384-hid              8               8             0.006     
bert-384-hid              8               32            0.006     
bert-384-hid              8              128            0.011     
bert-384-hid              8              512            0.054     
bert-6-lay                 8               8             0.003     
bert-6-lay                 8               32            0.004     
bert-6-lay                 8              128            0.009     
bert-6-lay                 8              512            0.044
--------------------------------------------------------------------------------

====================      INFERENCE - MEMORY - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length      Memory in MB 
--------------------------------------------------------------------------------
bert-base                  8               8             1277
bert-base                  8               32            1281
bert-base                  8              128            1307     
bert-base                  8              512            1539     
bert-384-hid              8               8             1005     
bert-384-hid              8               32            1027     
bert-384-hid              8              128            1035     
bert-384-hid              8              512            1255     
bert-6-lay                 8               8             1097     
bert-6-lay                 8               32            1101     
bert-6-lay                 8              128            1127     
bert-6-lay                 8              512            1359
--------------------------------------------------------------------------------

====================        ENVIRONMENT INFORMATION         ====================

- transformers_version: 2.11.0
- framework: PyTorch
- use_torchscript: False
- framework_version: 1.4.0
- python_version: 3.6.10
- system: Linux
- cpu: x86_64
- architecture: 64bit
- date: 2020-06-29
- time: 09:35:25.143267
- fp16: False
- use_multiprocessing: True
- only_pretrain_model: False
- cpu_ram_mb: 32088
- use_gpu: True
- num_gpus: 1
- gpu: TITAN RTX
- gpu_ram_mb: 24217
- gpu_power_watts: 280.0
- gpu_performance_state: 2
- use_tpu: False

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

>>> from transformers import TensorFlowBenchmark, TensorFlowBenchmarkArguments, BertConfig

>>> args = TensorFlowBenchmarkArguments(
…    models=["bert-base", "bert-384-hid", "bert-6-lay"], batch_sizes=[8], sequence_lengths=[8, 32, 128, 512]
… )
>>> config_base = BertConfig()
>>> config_384_hid = BertConfig(hidden_size=384)
>>> config_6_lay = BertConfig(num_hidden_layers=6)

>>> benchmark = TensorFlowBenchmark(args, configs=[config_base, config_384_hid, config_6_lay])
>>> benchmark.run()
====================       INFERENCE - SPEED - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length       Time in s                  
--------------------------------------------------------------------------------
bert-base                  8               8             0.005
bert-base                  8               32            0.008
bert-base                  8              128            0.022
bert-base                  8              512            0.106
bert-384-hid              8               8             0.005
bert-384-hid              8               32            0.007
bert-384-hid              8              128            0.018
bert-384-hid              8              512            0.064
bert-6-lay                 8               8             0.002
bert-6-lay                 8               32            0.003
bert-6-lay                 8              128            0.0011
bert-6-lay                 8              512            0.074
--------------------------------------------------------------------------------

====================      INFERENCE - MEMORY - RESULT       ====================
--------------------------------------------------------------------------------
Model Name             Batch Size     Seq Length      Memory in MB 
--------------------------------------------------------------------------------
bert-base                  8               8             1330
bert-base                  8               32            1330
bert-base                  8              128            1330
bert-base                  8              512            1770
bert-384-hid              8               8             1330
bert-384-hid              8               32            1330
bert-384-hid              8              128            1330
bert-384-hid              8              512            1540
bert-6-lay                 8               8             1330
bert-6-lay                 8               32            1330
bert-6-lay                 8              128            1330
bert-6-lay                 8              512            1540
--------------------------------------------------------------------------------

====================        ENVIRONMENT INFORMATION         ====================

- transformers_version: 2.11.0
- framework: Tensorflow
- use_xla: False
- framework_version: 2.2.0
- python_version: 3.6.10
- system: Linux
- cpu: x86_64
- architecture: 64bit
- date: 2020-06-29
- time: 09:38:15.487125
- fp16: False
- use_multiprocessing: True
- only_pretrain_model: False
- cpu_ram_mb: 32088
- use_gpu: True
- num_gpus: 1
- gpu: TITAN RTX
- gpu_ram_mb: 24217
- gpu_power_watts: 280.0
- gpu_performance_state: 2
- use_tpu: False

يُقاس الوقت والذاكرة المطلوبة للاستدلال للضبط المخصَّص الخاص بالصنف BertModel هذه المرة، وهذه الميزة مفيدة خاصة عند تحديد الضبط الذي يجب تدريب النموذج عليه.

أفضل ممارسات قياس الأداء

فيما يلي قائمة موجزة بأفضل الممارسات التي يجب علينا الانتباه لها عند قياس أداء نموذج model:

• قياس الأداء مدعوم حاليًا لجهاز واحد فقط، ويوصى عند قياسه على وحدة معالجة الرسوميات GPU تحديد الجهاز الذي سيُشغّل الشيفرة البرمجية عليه عن طريق ضبط متغير البيئة CUDA_VISIBLE_DEVICES بقيمة محددة قبل تشغيل هذه الشيفرة
• علينا ضبط الخيار no_multi_processing على القيمة True للاختبار وتنقيح الأخطاء فقط، ويوصى بتشغيل كل قياس ذاكرة في عملية منفصلة لضمان قياسها بدقة
• يجب دائمًا ذكر معلومات البيئة عند مشاركة نتائج قياس أداء النموذج، فقد تختلف النتائج بين أجهزة GPU المختلفة وإصدارات المكتبة المختلفة

مشاركة قياس الأداء

تمكنا من إجراء قياسات أداء لجميع النماذج الأساسية المتاحة لوقت الاستدلال على العديد من الإعدادات المختلفة مثل إطار عمل PyTorch مع استخدام TorchScript وبدونها، وإطار عمل TensorFlow مع استخدام XLA وبدونها. ونُفذّت جميع هذه الاختبارات -باستثناء TensorFlow XLA- عبر وحدات المعالجة المركزية CPU ووحدات معالجة الرسوميات GPU.

يمكن مطالعة طريقة قياس أداء Transformers ونتائجها بمزيد من التفصيل. وكما نلاحظ فقد أصبحت مشاركة نتائج قياس الأداء مع المجتمع أسهل من أي وقت مضى باستخدام أدوات قياس الأداء الجديدة مثل  نتائج قياس أداء TensorFlow.

الخاتمة

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

ترجمة -وبتصرّف- للقسم Benchmarks من توثيقات Hugging Face.

اقرأ أيضًا

• المقال السابق: تصدير نماذج المحولات Transformers إلى صيغة TorchScript
• جولة سريعة للبدء مع مكتبة المحوّلات Transformers
• تثبيت مكتبة المحوّلات Transformers
• تقييم واختيار نماذج تعلم الآلة

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

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

توجد وحدتان من وحدات باي تورش PyTorch هما الوحدة   JIT لترجمة نموذج باي تورش إلى كود يمكن تنفيذه مباشرة على الآلة، والوحدة  TRACE لتسريع الكود فهما تسمحان للمطورين بتصدير نماذجهم لإعادة استخدامها في برامج أخرى مثل برامج C++‎ التي تركز على الفعالية وتحسين الأداء والموارد المستخدمة.

سنوفر فيما يلي واجهة تتيح لنا تصدير نماذج مكتبة المحوِّلات Transformers إلى صيغة TorchScript حتى نتمكّن من إعادة استخدامها في بيئة مختلفة عن برامج بايثون Python المستندة إلى إطار عمل باي تورش PyTorch، وسنوضّح كيفية تصدير واستخدام النماذج باستخدام صيغة TorchScript.

يتطلب تصدير النموذج شيئين هما:

• إنشاء نسخة خاصة من النموذج متوافقة مع TorchScript باستخدام الراية torchscript
• تمرير بيانات تجريبية أو دخل وهمي إلى النموذج ليتمكن من تتبع العمليات الحسابية وتسجيلها بشكل صحيح

يتضمن هذان الأمران الضروريان عدة أمور يجب على المطورين توخي الحذر بشأنها كما سنوضّح فيما يلي.

راية TorchScript والأوزان المرتبطة Tied Weights

لا يدعم TorchScript تصدير النماذج التي تحتوي على أوزان مرتبطة، لذا يجب فصل هذه الأوزان ونسخها مسبقًا قبل التصدير. لذا تُعَد الراية torchscript ضرورية لأن معظم النماذج اللغوية في مكتبة المحولات Transformers لها أوزان تربط بين طبقة التضمين Embedding وطبقة فك الترميز Decoding. وبما أن صيغة TorchScript لا تسمح بتصدير النماذج التي لها أوزان مرتبطة، لذا من الضروري فك الارتباط ونسخ الأوزان مسبقًا. تُفصَل طبقة التضمين Embedding عن طبقة فك الترميز Decoding للنماذج التي تنسخها الراية torchscript، مما يعني أنه لا ينبغي تدريبها لاحقًا، إذ سيؤدي التدريب إلى عدم مزامنة الطبقتين، وسيعطي نتائج غير متوقعة.

لا ينطبق ذلك على النماذج التي لا تحتوي على رأس نموذج لغوي Language Model Head، فهذه النماذج لا تحتوي على أوزان مرتبطة، وبالتالي يمكن تصديرها بأمان بدون الراية torchscript.

الدخل الوهمي والأطوال المعيارية

عند تصدير نموذج باستخدام TorchScript، يجب تنفيذ تمرير أمامي على دخل وهمي. هذا الدخل هو بيانات افتراضية تُمرَّر عبر النموذج لمساعدة باي تورش PyTorch على تسجيل العمليات التي يجري تنفيذها على كل موتر Tensor أثناء انتقال القيم بين الطبقات.

لماذا نحتاج إلى الدخل الوهمي

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

`The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2`

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

استخدام صيغة TorchScript في بايثون Python

يوضّح هذا القسم كيفية حفظ النماذج وتحميلها وكيفية استخدام التعقّب للاستدلال.

حفظ النموذج

يمكن تصدير نموذج BertModel باستخدام صيغة TorchScript من خلال إنشاء نسخة BertModel من الصنف BertConfig ثم حفظها على القرص الصلب باسم الملف traced_bert.pt كما يلي:

from transformers import BertModel, BertTokenizer, BertConfig
import torch

enc = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")

# ‫ترميز Tokenizing النص المُدخل
text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]"
tokenized_text = enc.tokenize(text)

# تقنيع‫ Masking أحد رموز Tokens الدخل
masked_index = 8
tokenized_text[masked_index] = "[MASK]"
indexed_tokens = enc.convert_tokens_to_ids(tokenized_text)
segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

# إنشاء دخل وهمي
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])
dummy_input = [tokens_tensor, segments_tensors]

# ‫تهيئة النموذج باستخدام راية torchscript
# ضبط الراية على القيمة‫ True بالرغم من أن ذلك غير ضروري لأن هذا النموذج لا يحتوي على رأس النموذج اللغوي LM.
config = BertConfig(
    vocab_size_or_config_json_file=32000,
    hidden_size=768,
    num_hidden_layers=12,
    num_attention_heads=12,
    intermediate_size=3072,
    torchscript=True,
)

# إنشاء نسخة من النموذج
model = BertModel(config)

# يجب أن يكون النموذج في وضع التقييم
model.eval()

# إذا أردنا إنشاء نسخة من النموذج باستخدام‫ *from_pretrained*، فيمكن أيضًا ضبط راية TorchScript بسهولة
model = BertModel.from_pretrained("google-bert/bert-base-uncased", torchscript=True)

# إنشاء التعقّب
traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors])
torch.jit.save(traced_model, "traced_bert.pt")

تحميل النموذج

يمكننا الآن تحميل النموذج BertModel الذي حفظناه بالاسم traced_bert.pt من القرص الصلب واستخدامه مع الدخل الوهمي dummy_input المُهيَّأ مسبقًا كما يلي:

loaded_model = torch.jit.load("traced_bert.pt")
loaded_model.eval()

all_encoder_layers, pooled_output = loaded_model(*dummy_input)

استخدام نموذج مُتعقَّب للاستدلال

سنستخدم النموذج المتعقَّب للاستدلال باستخدام التابع السحري __call__ الخاص به كما يلي:

traced_model(tokens_tensor, segments_tensors)

نشر نماذج TorchScript من منصة Hugging Face على خدمة AWS

قدمت خدمة AWS عائلة من نسخ Amazon EC2 Inf1 لاستدلال التعلم الآلي منخفض التكلفة وعالي الأداء في السحابة، حيث تعمل نسخ Inf1 باستخدام شريحة AWS Inferentia، والتي هي مسرّع للعتاد المُخصّص ومتخصصة في أحمال استدلال التعلم العميق. و AWS Inferentia هي أداة SDK لشريحة Inferentia تدعم تعقّب نماذج المحوِّلات Transformers وتحسينها للنشر على Inf1، حيث توفر أداة Neuron SDK ما يلي:

1. واجهة برمجة تطبيقات API سهلة الاستخدام مع تغيير سطر واحد من الشيفرة البرمجية لتعقّب نموذج TorchScript وتحسينه للاستدلال في السحابة
2. تحسينات الأداء الجاهزة لتحسين تكلفة الأداء
3. دعم نماذج المحولات Transformers من منصة Hugging Face المبنية باستخدام إطار عمل PyTorch أو TensorFlow

النتائج

تعمل نماذج المحولات Transformers المستندة إلى بنية BERT  أي تمثيلات المشفّر ثنائية الاتجاه من مكتبة المحوِّلات أو Bidirectional Encoder Representations from Transformers أو أنواعها المختلفة مثل distilBERT و roBERTa بنجاح على Inf1 للمهام غير التوليدية مثل الإجابة على الأسئلة الاستخراجية وتصنيف التسلسلات وتصنيف الرموز، ولكن يمكن أيضًا تكييف مهام توليد النصوص لتشغيلها على Inf1. ويمكن العثور على مزيد من المعلومات حول النماذج التي يمكن تحويلها على Inferentia في قسم ملاءمة بنية النموذج في توثيق Neuron.

الاعتماديات Dependencies

يتطلب استخدام AWS Neuron لتحويل النماذج بيئةَ Neuron SDK التي تكون مضبوطة مسبقًا على AWS Deep Learning AMI.

تحويل النموذج لأداة AWS Neuron

سنحوّل النموذج لأداة AWS NEURON باستخدام الشيفرة البرمجية نفسها من قسم استخدام صيغة TorchScript في بايثون التي شرحناها سابقًا في هذا المقال لتعقّب النموذج BertModel، ونستورد امتداد إطار عمل torch.neuron للوصول إلى مكونات Neuron SDK من خلال واجهة برمجة تطبيقات بايثون كما يلي:

from transformers import BertModel, BertTokenizer, BertConfig
import torch
import torch.neuron

وكل ما علينا فعله هو تعديل السطر التالي:

- torch.jit.trace(model, [tokens_tensor, segments_tensors])
+ torch.neuron.trace(model, [token_tensor, segments_tensors])

هذا يتيح لأداة Neuron SDK تعقّب النموذج وتحسينه لنسخ Inf1.

وأخيرًا ننصح بمطالعة توثيق AWS NeuronSDK لمعرفة المزيد عن ميزات AWS Neuron SDK وأدواتها وبرامجها التعليمية وتحديثاتها الأخيرة.

الخلاصة

شرحنا في هذا المقال كيفية تصدير نماذج المحولات Transformers إلى صيغة TorchScript لاستخدامها في بيئات غير Python. يتطلب الأمر تطبيق راية torchscript على النموذج وفصل الأوزان المرتبطة بين الطبقات. كما وضحنا طريقة تمرير دخل وهمي لتسجيل العمليات الحسابية وتحويل النموذج إلى صيغة قابلة للتسلسل. وعرضنا كيفية استخدام هذا النموذج في Python بعد تصديره وحفظه. وأخيرًا شرحنا كيفية تحسين النماذج واستخدامها على خدمات AWS باستخدام Neuron SDK.

ترجمة -وبتصرّف- للقسم Export to TorchScript من توثيقات Hugging Face.

اقرأ أيضًا

• نظرة عامة على الصنف Trainer في مكتبة المحولات Transformers
• جولة سريعة للبدء مع مكتبة المحوّلات Transformers
• تثبيت مكتبة المحوّلات Transformers
• بناء نماذج مخصصة باستخدام مكتبة Transformers في Hugging Face

سنغطي في هذا المقال أسئلة واسعة حول تعلم الآلة Machine Learning، ومعالجة اللغات الطبيعية Natural Language Processing، والذكاء الاصطناعي Artificial Intelligence بهدف توسيع المهارات حول هذه التقنيات الحديثة، سنحاول الإجابة على مجموعة من الأسئلة المهمة بدءًا من أساسيات هذا المجال، والتقنيات الموصى بها، وصولًا إلى النماذج اللغوية المتقدمة مثل GPT 4، كما سنتناول التحديات التي تواجه المنتجات والأعمال المرتبطة بمعالجة اللغات الطبيعية ونناقش مستقبل هذا المجال.

أسئلة حول أساسيات معالجة اللغات الطبيعية

فيما يلي مجموعة أسئلة وإجابات حول أساسيات معالجة اللغات الطبيعية.

ما خطوات الانتقال من تطوير التطبيقات التقليدية لاحتراف مجال تعلم الآلة ML

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

أما بالنسبة للغات البرمجة، فلغة بايثون هي الخيار الأمثل للمطورين المبتدئين في تعلم الآلة فهي لغة برمجة عالية المستوى، وتحظى بشعبية واسعة، وتتميز بوجود مجتمع كبير يدعمها، كما تحتوي بايثون على مكتبات قوية في مجال تعلم الآلة مثل تنسرفلو  TensorFlow وساي كت ليرن Scikit-learn التي تسهّل الوصول إلى الأدوات اللازمة لتطبيق مفاهيم تعلم الآلة.

دورة الذكاء الاصطناعي

احترف برمجة الذكاء الاصطناعي AI وتحليل البيانات وتعلم كافة المعلومات التي تحتاجها لبناء نماذج ذكاء اصطناعي متخصصة.

اشترك الآن

هل تتطلب دراسة معالجة اللغة الطبيعية معرفة بمجال اللغويات Linguistics ونظرية المعلومات

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

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

ما هي نماذج BERT وGPT وما الأمثلة الواقعية عنها

نماذج BERT وGPT هما نوعان من النماذج اللغوية Language Models المدربة على كميات ضخمة من النصوص بهدف أداء مهام معينة مثل ملء المعلومات الناقصة في النصوص Text Infilling. إن هذه النماذج مهيأة بشكل خاص للاستخدام في التفاعل الحواري، حيث يمكنها فهم السياق اللغوي، والرد على الاستفسارات بطريقة طبيعية مشابهة لطريقة البشر.

كما تُظهر نماذج BERT وGPT أداء مذهلًا وتتفوق في العديد من التطبيقات الأخرى غير الحوارية، مثل حل المسائل الرياضية أو ترجمة النصوص. ويُظهِر كل من نموذج BERT الذي يعتمد على المعالجة ثنائية الاتجاه للنصوص Bidirectional Processing ونموذج GPT الذي يعتمد على النماذج اللغوية التوليدية Generative Language Models قدرة فائقة على فهم وتوليد اللغة في العديد من السياقات. وأحد الأمثلة الواقعية على استخدام GPT هو روبوت الدردشة ChatGPT، أما نموذج BERT فيستخدم بشكل رئيسي في تحسين محركات البحث SEO وأنظمة التوصية.

ما أبرز الأدوات المفيدة في مجال معالجة اللغات الطبيعية

من أبرز أدوات معالجة اللغة الطبيعية NLP نذكر:

• لغات البرمجة مثل بايثون Python و R
• الخدمات السحابية مثل Amazon Web Services و Microsoft Azure
• خدمات تسيير العمل مثل Apache Airflow و Amazon Neptune
• النماذج اللغوية مثل  GPT و BERT

أي لغة أفضل في تحليل النصوص لغة بايثون أم R

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

ما هي الخدمة السحابية الأفضل لبناء النماذج ونشرها

هناك العديد من الخدمات السحابية المتاحة لبناء النماذج Models ونشرها مثل خدمات AWS و Azure و Google، يمكن اختيار الخدمة التي تناسبنا وينصح الكاتب باستخدام منصة AWS لأنها تجنبنا مشكلة احتكار البائع Vendor Lock-in التي قد نواجهها عندما نعتمد على مزود سحابي معين، والتي قد تعيق انتقالنا إلى مزود آخر بسهولة وتكبدنا تكاليف ضخمة وتحديات كبيرة في نقل بيئة العمل.

هل يفيدنا استخدام أدوات تسيير العمل في خطوط عمل معالجة اللغة الطبيعية

نعم، تفيد أدوات تسيير العمل مثل Prefect أو Airflow أو Luigi أو Neptune بشكل فعّال في خطوط عمل معالجة اللغة الطبيعية NLP pipelines، لاسيما عندما يتطلب الأمر تنسيق عدة عمليات مع الحاجة لإضافة أو تعديل خطوط العمل في المستقبل.

فهذه الأدوات ضرورية في حالات معالجة البيانات الضخمة التي تتطلب عمليات استخراج البيانات Extract، وتحويلها Transform، وتحميلها Load، والمعروفة اختصارًا بعمليات ETL، وهي تساهم في إدارة العمليات بثقة ومرونة وتنظم تنفيذ العمليات المعقدة، وتُسهّل التعامل مع تدفقات البيانات وتحسن الكفاءة في مشاريع معالجة اللغة الطبيعية.

ما الأدوات التي يُوصى بها في مجال تعلم الآلة ومعالجة اللغات الطبيعية

ينصح الكاتب باستخدام التابع style من مكتبة Pandas لعرض البيانات وإجراء مقارنات سريعة بينها. كما ينصح باستخدام MLflow عند الحاجة لمشاركة نتائج تجربة معينة مع فريق من المبرمجين أو علماء البيانات، واستخدام مكتبة ploty بدلًا من matplotlib للحصول على تقارير تفاعلية، ويمكن استخدام منصة Weights & Biases في مجال التعلم العميق Deep Learning، لأن مراقبة الموترات أو التنسورات tensors -وهي البنية الأساسية للبيانات التي تعالجها الشبكة العصبية- أصعب بكثير من مراقبة المقاييس metrics بسبب طبيعة البيانات التي تعمل بها التنسورات، حيث تحتوي على معلومات متعددة الأبعاد قد تكون ضخمة ومعقدة، في حين أن المقاييس، مثل دقة النموذج accuracy و خسارة النموذج Loss فهي قيم واحدة مفردة يجري تحديثها باستمرار وعرضها خلال تدريب النموذج ومن السهل تتبعها وتحليلها.

نصائح وأسئلة حول العمل في مجال معالجة اللغة الطبيعية

فيما يلي مجموعة أسئلة وإجابات مرتبطة بالعمل في مجال معالجة اللغات الطبيعية.

كيف يمكن تقسيم المهام اليومية في تنظيف البيانات وبناء نماذج التطبيقات

يعد تنظيف البيانات Data Cleaning وهندسة الميزات Feature Engineering من المهام التي تتطلب وقتًا كبيرًا عند تطوير تطبيقات فعلية، نظرًا لأن جودة البيانات هي الأساس الذي يعتمد عليه تعلم الآلة في تقديم حلول فعّالة. لذا، يُنصح بتخصيص أكبر قدر ممكن من الوقت لبناء النماذج Models، خصوصًا عندما تكون متطلبات التطبيق بسيطة ومحدودة، ولا تحتاج إلى استخدام تقنيات معقدة أو حلول مبتكرة للوصول إلى النتائج المطلوبة.

كيف يمكن تحليل جدوى لنموذج تعلم آلة لا يحقق الأداء المطلوب

لو طُلب منا العمل على نموذج تعلم آلة لا يحقق الأداء المطلوب مهما درّبناه، وأردنا إجراء تحليل جدوى لتوفير الوقت وتقديم دليل على أن من الأفضل الانتقال إلى طرق أخر فيمكننا استخدام أسلوب التطوير المرن Lean الذي يهدف إلى تحقيق أفضل النتائج بأقل جهد ووقت، يجري ذلك من خلال معالجة بسيطة مسبقة للبيانات Data Preprocessing، واستخدام مجموعة نماذج بسيطة سهلة التنفيذ، واتباع ممارسات من شأنها ضمان عمل النموذ بشكل صحيح مثل فصل مجموعات التدريب، والتحقق من الصحة validation، واستخدام الاختبار والتقويم المتقاطع cross-validation عند الإمكان. فباستخدام هذه الخطوات البسيطة، يمكننا تقييم فيما إذا كان النموذج الحالي قابل للتحسين أو من الأفضل استخدام نماذج أخرى لتحقيق الأداء المطلوب.

هل يمكن بناء نماذج تعلم آلة تستخدم موارد أقل وبجودة النماذج الأكبر حجمًا

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

من الأمثلة الحديثة على ذلك نموذج Chinchilla من DeepMind، فعلى الرغم من أن هذا النموذج أصغر بكثير من النماذج القوية مثل GPT-3 من حيث الحجم الحسابي، إلا أنه يقدم أداء أفضل. وهذا يثبت أن تقنيات مثل التقليم يمكن أن تساعدنا في تحسين الكفاءة الحسابية وتحقيق نتائج عالية الأداء بنماذج أصغر.

أسئلة حول منتجات الذكاء الاصطناعي ورؤى الأعمال

فيما يلي مجموعة أمثلة وإجابات حول منتجات الذكاء الاصطناعي ورؤى الأعمال

ما هي الخطوات المتبعة في دورة تطوير منتجات تعلم الآلة

تتكون دورة تطوير منتجات تعلم الآلة من عدة خطوات أساسية: تبدأ الدورة بتحليل البيانات الاستكشافي Exploratory Data Analysis أو اختصارًا EDA من خلال فحص البيانات بعناية لتحديد ما هو ضروري للعمل على منتج تعلم الآلة، بعدها تُناقش نتائج التحليل مع الفريق وتقيّم أهداف المشروع لضمان وضوح التوجهات بعد تحديد الأهداف، ثم تُستَخدم نماذج بسيطة لتوليد نتائج مرجعية تساعد في تحديد أفضل الحلول، وأخيرًا يجري تحسين النماذج وتعديلها لتحقيق النتائج المثلى وفقًا لمقاييس الأداء. وخلال جميع الخطوات يجب أن يكون هناك تواصل مستمر مع العميل لضمان تطابق الحلول مع احتياجاته.

ما تحديات تطبيق الذكاء الاصطناعي وتعلم الآلة في تطوير المنتجات

في الوقت الحالي، هناك تحديان رئيسيان في مجال الذكاء الاصطناعي وتعلم الآلة: الأول هو الذكاء الاصطناعي العام Artificial General Intelligence أو AGI اختصارًا، والذي أصبح محور اهتمام كبير فهو نوع من الذكاء الاصطناعي يُفترض أن يكون قادرًا على أداء أي مهمة يمكن أن يؤديها الإنسان. لكن رغم الاهتمام الكبير به، لا زال تحقيقه غير ممكن في الوقت الحالي، وما زال أمامنا وقت طويل للوصول إلى تحقيق مستوى عالي من الكفاءة في أداء مهام متنوعة، ولا زال الذكاء الاصطناعي يواجه صعوبة في التعامل مع مشكلات لم يتعلم كيفية حلها مسبقًا.

الحد الثاني في الذكاء الاصطناعي هو التعلم المعزز Reinforcement Learning حيث يعتمد هذا النوع من التعلم على تحسين الأنظمة من خلال المحاولة والتجربة والتفاعل مع البيئة بدلاً من الاعتماد على البيانات الضخمة Big data. ورغم أنه يعد بديلاً للتعلم التقليدي القائم على البيانات الضخمة والتعلم الخاضع للإشراف Supervised learning، إلا أن جمع البيانات اللازمة لتعلم جميع المهام البشرية أمر يستغرق وقتًا طويلاً، وحتى إذا جمعنا البيانات المطلوبة، قد لا تكون كافية لإنشاء نموذج ذكي يعمل بنفس مستوى الكفاءة التي يعمل بها البشر، خاصة عندما تتغير الظروف والبيئات في المستقبل. فهذه التغيرات قد تؤثر على قدرة النموذج على التكيف مع التحديات الجديدة. لذا من غير المحتمل أن يتمكن مجتمع الذكاء الاصطناعي من حل هذه المشكلات قريبًا، وإذا تمكن من ذلك، ستتحول التحديات إلى أمور تتعلق بالكفاءة الحسابية.

ما حالات استخدام عمليات تعلم الآلة

تعد عمليات تعلم الآلة Machine Learning Operations أو MLOps اختصارًا، ممتازة لعديد من المنتجات والأهداف مثل الحلول المصممة بدون خادم Serverless والتي تُحَصَّل الرسوم فيها مقابل ما نستخدمه والتي لا نحتاج فيها إلى إدارة الخوادم أو القلق بشأن صيانتها، وكذلك تستخدم في واجهات برمجة تطبيقات تعلم الآلة التجارية مثل التنبؤ بالطلب على المنتجات أو تحسين تجربة العملاء، كما تُستخدم خدمات مجانية مثل MLflow لمتابعة ومراقبة التجارب أثناء تطوير النماذج في مراحلها الأولى، ومراقبة الأداء بعد نشر التطبيقات.

كيف نقنع العميل أو المدير باستخدام تعلم الآلة في التطبيقات

تتمتع عمليات تعلم الآلة بفوائد كبيرة في التطبيقات على مستوى المؤسسات، حيث تساهم في تحسين كفاءة عملية التطوير وتقليل التكاليف التقنية. ومع ذلك، من المهم تقييم مدى ملاءمة الحل المقترح للهدف المطلوب. على سبيل المثال، إذا كان لدينا خادم في مكتبنا ويمكن ضمان تلبية متطلبات اتفاقية مستوى الخدمة Service-level agreement أو اختصارًا SLA، ومعرفة عدد الطلبات المتوقعة، فلن نحتاج لاستخدام خدمات عمليات تعلم الآلة المُدارة managed MLOps service. تحدث المشكلات الشائعة عندما نفترض أن الخدمة المُدارة ستلبي جميع متطلبات المشروع، مثل أداء النموذج، ومتطلبات اتفاقية مستوى الخدمة SLA، وقابلية التوسع، وغيرها.

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

كيف تحدد المؤسسات احتياجات العميل بدقة وتنشئ نماذج تساعد في اتخاذ القرارات

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

أسئلة حول مستقبل معالجة اللغات الطبيعية

فيما يلي مجموعة أمثلة وإجابات حول مستقبل معالجة اللغات الطبيعية وتحديات تطبيقها.

ما مبرر ارتفاع استهلاك الطاقة الناتج عن الشبكات العصبية التلافيفية الكبيرة CNNs

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

هل استطاعت نماذج الذكاء الاصطناعي اكتساب وعي يماثل الوعي البشري

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

هل يجب أن نقلق بشأن القضايا الأخلاقية المتعلقة بالذكاء الاصطناعي وتعلم الآلة

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

الخاتمة

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

ترجمة، وبتصرّف، للمقال Ask an NLP Engineer: From GPT Models to the Ethics of AI، لكاتبه Daniel Pérez Rubio.

اقرأ أيضًا

• المفاهيم الأساسية لتعلم الآلة
• مجالات الذكاء الاصطناعي
• الذكاء الاصطناعي: أهم الإنجازات والاختراعات وكيف أثرت في حياتنا اليومية
• نظرة سريعة على مجال تعلم الآلة
• كل ما تود معرفته عن دراسة الذكاء الاصطناعي

يتطلب نشر نماذج مكتبة المحوِّلات Transformers التي توفرها منصة Huggingface في بيئات الإنتاج تصدير النماذج إلى صيغة متسلسلة Serialized أي إلى صيغة يمكن تحميلها وتنفيذها في أوقات تشغيل وعلى عتاد متخصص.

سنشرح في مقال اليوم كيفية تصدير نماذج Transformers باستخدام مكتبة Optimum وهي امتداد لمكتبة المحولات Transformers تتيح تصدير النماذج من إطار عمل باي تورش PyTorch أو تنسر فلو TensorFlow إلى صيغ متسلسلة مثل ONNX و TFLite عبر وحدة exporters، وتوفر المكتبة أيضًا مجموعة من أدوات تحسين الأداء لتدريب النماذج وتشغيلها بكفاءة.

تصدير نماذج Transformers إلى صيغة ONNX

صيغة ONNX هي اختصار لعبارة Open Neural Network eXchange وهي معيار مفتوح يحدّد مجموعة من المعاملات وصيغة ملفات مشتركة لتمثيل نماذج التعلم العميق Deep Leaning في مجموعة متنوعة من أطر العمل كإطار عمل باي تورش PyTorch وتنسرفلو TensorFlow، وتُستخدَم هذه المعاملات لإنشاء رسم بياني حسابي يُطلق عليه اسم التمثيل الوسيط Intermediate Representation يمثّل تدفق البيانات عبر الشبكة العصبونية عند تصدير النموذج إلى صيغة ONNX.

الهدف من صيغة ONNX هو تمكين تبادل النماذج بين أطر العمل المختلفة، وتسهيل نقل النماذج بين بيئات تطوير متعددة مع الحفاظ على تكاملها وأدائها، وتسهّل هذه الصيغة التبديل بين أطر العمل من خلال عرض رسم بياني باستخدام معاملات وأنواع بيانات معيارية، فمثلًا يمكن تصدير نموذج مُدرَّب في إطار عمل باي تورش PyTorch إلى صيغة ONNX، ثم استيراده في إطار عمل تنسرفلو TensorFlow والعكس صحيح.

بعد تصدير النموذج إلى صيغة ONNX سنتمكن من تنفيذ الأمور التالية:

• تحسين الاستدلال والتنبؤ من النموذج باستخدام تقنيات مثل تحسين الرسم البياني Graph Optimization والتكميم Quantization
• تشغيل مسرّع ONNX Runtime باستخدام أصناف ORTModelForXXX التي تتبع واجهة برمجة تطبيقات AutoModel المستخدمة أيضًا في مكتبة المحولات Transformers
• تشغيل خطوط أنابيب الاستدلال المُحسَّنة التي تملك نفس واجهة برمجة التطبيقات الخاصة بالدالة pipeline()‎ في مكتبة المحولات Transformers

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

هنالك طريقتان لتصدير نموذج Transformers إلى صيغة ONNX هما:

• التصدير باستخدام مكتبة Optimum عبر واجهة سطر الأوامر CLI
• التصدير باستخدام مكتبة Optimum عبر optimum.onnxruntime

تصدير النموذج إلى صيغة ONNX باستخدام واجهة سطر الأوامر

يمكن تصدير نموذج Transformers إلى صيغة ONNX عبر واجهة سطر الأوامر CLI من خلال تثبيت اعتمادية إضافية كما يلي:

pip install optimum[exporters]

يمكن مطالعة توثيق Optimum للتعرف على جميع الوسطاء المتاحة، أو استخدم الأمر التالي للمساعدة:

optimum-cli export onnx --help

يمكننا تصدير نقطة التحقق Checkpoint الخاصة بالنموذج من مستودع Hub على سبيل المثال النموذج
،distilbert/distilbert-base-uncased-distilled-squad هو نسخة من نموذج DistilBERT جرى تحسينه للعمل مع مجموعة بيانات الأسئلة والأجوبة SQuAD. ويمكننا تصدير هذا النموذج أو تحميله من خلال تشغيل الأمر التالي:

optimum-cli export onnx --model distilbert/distilbert-base-uncased-distilled-squad distilbert_base_uncased_squad_onnx/

يجب أن نرى السجلات التي تعرض التقدم ومكان حفظ ملف model.onnx الناتج بالشكل التالي:

Validating ONNX model distilbert_base_uncased_squad_onnx/model.onnx...
    -[✓] ONNX model output names match reference model (start_logits, end_logits)
    - Validating ONNX Model output "start_logits":
        -[✓] (2, 16) matches (2, 16)
        -[✓] all values close (atol: 0.0001)
    - Validating ONNX Model output "end_logits":
        -[✓] (2, 16) matches (2, 16)
        -[✓] all values close (atol: 0.0001)
The ONNX export succeeded and the exported model was saved at: distilbert_base_uncased_squad_onnx

يوضّح المثال السابق تصدير نقطة تحقق من مستودع Hub. علينا أن نتأكد أولًا من حفظ أوزان النموذج وملفات Tokenizer في نفس المجلد المُسمَّى local_path عند تصدير نموذج محلي. إذا استخدمنا واجهة سطر الأوامر CLI، فعلينا تمرير اسم المجلد local_path إلى الوسيط model بدلًا من اسم نقطة التحقق على مستودع Hub واستخدم الوسيط ‎--task الذي يمثل المهمة. ويمكن مطالعة المزيد حول قائمة المهام المدعومة في توثيق Optimum.

optimum-cli export onnx --model local_path --task question-answering distilbert_base_uncased_squad_onnx/

بعدها يمكننا تشغيل ملف النموذج المُصدّر model.onnx الناتج على أحد المسرّعات Accelerators المتعددة التي تدعم معيار ONNX، فمثلًا يمكن تحميل النموذج وتشغيله باستخدام المسرّع ONNX Runtime كما يلي:

>>> from transformers import AutoTokenizer
>>> from optimum.onnxruntime import ORTModelForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("distilbert_base_uncased_squad_onnx")
>>> model = ORTModelForQuestionAnswering.from_pretrained("distilbert_base_uncased_squad_onnx")
>>> inputs = tokenizer("What am I using?", "Using DistilBERT with ONNX Runtime!", return_tensors="pt")
>>> outputs = model(**inputs)

ينطبق الأمر نفسه على نقاط تحقق تنسرفلو TensorFlow على مستودع Hub، فمثلًا يمكننا تصدير نقطة تحقق TensorFlow خام غير مُعدّلة من مجموعة Keras كما يلي:

optimum-cli export onnx --model keras-io/transformers-qa distilbert_base_cased_squad_onnx/

تصدير النموذج إلى صيغة ONNX باستخدام optimum.onnxruntime

يمكننا تصدير نموذج Transformers إلى ONNX برمجيًا بدلًا من استخدام واجهة سطر الأوامر CLI كما يلي:

>>> from optimum.onnxruntime import ORTModelForSequenceClassification
>>> from transformers import AutoTokenizer

>>> model_checkpoint = "distilbert_base_uncased_squad"
>>> save_directory = "onnx/"

>>> # ‫تحميل نموذج من مكتبة Transformers وتصديره إلى صيغة ONNX
>>> ort_model = ORTModelForSequenceClassification.from_pretrained(model_checkpoint, export=True)
>>> tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

>>> # ‫حفظ نموذج onnx والمرمِّز
>>> ort_model.save_pretrained(save_directory)
>>> tokenizer.save_pretrained(save_directory)

تصدير النموذج إلى بنية غير مدعومة

إذا أردنا المساهمة بإضافة دعم لنموذج لا يمكن تصديره حاليًا، فيجب أن نتحقق أولًا فيما إذا كان مدعومًا في optimum.exporters.onnx، وإن كان غير مدعوم، فيمكن أن نساهم في Optimum مباشرةً.

تصدير نموذج باستخدام الحزمة transformers.onnx

ملاحظة: لم تَعُد هناك صيانة للحزمة tranformers.onnx، لذا علينا تصدير النماذج باستخدام المكتبة Optimum كما هو موضح في الأقسام السابقة، إذ سيُزال هذا القسم في الإصدارات المستقبلية.

يمكن تصدير نموذج Transformers إلى صيغة ONNX باستخدام الحزمة tranformers.onnx من خلال تثبيت اعتماديات إضافية كما يلي:

pip install transformers[onnx]

نستخدم حزمة transformers.onnx كما نستخدم وحدة بايثون Python لتصدير نقطة تحقق باستخدام ضبط Configuration جاهز كما يلي:

python -m transformers.onnx --model=distilbert/distilbert-base-uncased onnx/

سيؤدي هذا إلى تصدير رسم ONNX البياني لنقطة التحقق التي يحدّدها الوسيط ‎--model. علينا تمرير نقطة تحقق على مستودع Hub أو أي نقطة تحقق مُخزَّنة محليًا، ثم يمكننا تشغيل ملف model.onnx الناتج على أحد المسرِّعات التي تدعم معيار ONNX، فمثلًا يمكننا تحميل النموذج وتشغيله باستخدام المُسرّع ONNX Runtime كما يلي:

>>> from transformers import AutoTokenizer
>>> from onnxruntime import InferenceSession

>>> tokenizer = AutoTokenizer.from_pretrained("distilbert/distilbert-base-uncased")
>>> session = InferenceSession("onnx/model.onnx")
>>> # ‫يتوقع المسرّع ONNX Runtime وجود مصفوفات NumPy كدخل
>>> inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np")
>>> outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs))

يمكن الحصول على أسماء المخرجات المطلوبة مثل ‎["last_hidden_state"]‎ من خلال الاطّلاع على ضبط ONNX لكل نموذج، فمثلًا يكون لدينا ما يلي بالنسبة لنموذج DistilBERT:

>>> from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig

>>> config = DistilBertConfig()
>>> onnx_config = DistilBertOnnxConfig(config)
>>> print(list(onnx_config.outputs.keys()))
["last_hidden_state"]

ينطبق الأمر نفسه على نقاط تحقق تنسرفلو TensorFlow على مستودع Hub، حيث نصدّر نقطة تحقق تنسرفلو TensorFlow خام غير مُدرّبة كما يلي:

python -m transformers.onnx --model=keras-io/transformers-qa onnx/

يمكننا تصدير نموذج مُخزَّن محليًا من خلال حفظ أوزان النموذج وملفات Tokenizer الخاصة به في المجلد نفسه مثل local-pt-checkpoint، ثم نصدّره إلى صيغة ONNX من خلال توجيه الوسيط ‎--model الخاص بحزمة transformers.onnx إلى المجلد المطلوب كما يلي:

python -m transformers.onnx --model=local-pt-checkpoint onnx/

تصدير النماذج إلى صيغة TFLite باستخدام المكتبة Optimum

يُعدّ TensorFlow Lite أو TFLite اختصارًا إطار عمل خفيف الوزن لنشر نماذج تعلم الآلة على الأجهزة ذات الموارد المحدودة مثل الهواتف المحمولة والأنظمة المُضمَّنة وأجهزة إنترنت الأشياء IoT، فقد صُمِّم إطار عمل TFLite لتحسين النماذج وتشغيلها بكفاءة على هذه الأجهزة ذات القدرة الحاسوبية والذاكرة المحدودة. يُمثَّل نموذج TFLite بصيغة فعالة خاصة يمكن نقلها وتحدّدها لاحقة الملفات ‎.tflite.

كما توفر المكتبة Optimum دالة لتصدير نماذج المحولات Transformers إلى صيغة TFLite عبر وحدة exporters.tflite، وللحصول على قائمة ببنى النماذج المدعومة يمكن مطالعة توثيق Optimum.

يمكننا تصدير نموذج إلى صيغة TFLite من خلال تثبيت الاعتماديات المطلوبة كما يلي:

pip install optimum[exporters-tf]

ويمكن مطالعة توثيق Optimum للتعرف على جميع الوسطاء المتاحة، أو استخدم الأمر التالي للمساعدة:

optimum-cli export tflite --help

يمكن تصدير نقطة التحقق الخاصة بالنموذج من مستودع Hub مثل google-bert/bert-base-uncased من خلال تشغيل الأمر التالي:

optimum-cli export tflite --model google-bert/bert-base-uncased --sequence_length 128 bert_tflite/

يجب أن نرى السجلات التي تشير إلى التقدم ، ويظهر مكان حفظ ملف model.tflite الناتج كما يلي:

Validating TFLite model...
    -[✓] TFLite model output names match reference model (logits)
    - Validating TFLite Model output "logits":
        -[✓] (1, 128, 30522) matches (1, 128, 30522)
        -[x] values not close enough, max diff: 5.817413330078125e-05 (atol: 1e-05)
The TensorFlow Lite export succeeded with the warning: The maximum absolute difference between the output of the reference model and the TFLite exported model is not within the set tolerance 1e-05:
- logits: max diff = 5.817413330078125e-05.
 The exported model was saved at: bert_tflite

يوضح المثال السابق تصدير نقطة تحقق من مستودع Hub. يجب أن نتأكد أولًا من حفظ أوزان النموذج وملفات Tokenizer في المجلد نفسه local_path عند تصدير نموذج محلي. وإذا استخدمنا واجهة سطر الأوامر CLI، فعلينا تمرير اسم المجلد local_path إلى الوسيط model-- بدلًا من اسم نقطة التحقق على مستودع Hub.

الخاتمة

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

ترجمة -وبتصرّف- للقسمين Export to ONNX و Export to TFLite من توثيقات Hugging Face.

اقرأ أيضًا

• ما هي منصة Hugging Face للذكاء الاصطناعي
• استخدام مكتبة المرمزات Tokenizers في منصة Hugging Face
• إنشاء بنية مخصصة لنماذج Transformers في Hugging Face
• بناء نماذج مخصصة باستخدام مكتبة Transformers في Hugging Face

سنتعرف في هذا المقال على الصنف Trainer في مكتبة المحولات Transformers ضمن منصة Hugging Face، ونوضح طريقة الاستفادة منه في تدريب النماذج اللغوية الكبيرة، كما سنتعرف أيضًا على أصناف عديدة تفيدنا في تحسين وتسريع عملية التدريب.

ما هو الصنف Trainer

الصنف Trainer هو أداة تُسهّل تدريب النماذج المبنية باستخدام باي تورش PyTorch في مكتبة المحولات Transformers. فبدلًا من أن نضطر لكتابة الشيفرة الخاصة بتدريب النموذج من البداية، يتيح لنا هذا الصنف تمرير العناصر الأساسية مثل النموذج Model، والمُرمِّز Tokenizer، ومجموعة البيانات Dataset، ودالة التقييم Evaluation Function، ومعاملات التدريب الفائقة Hyperparameters، والبدء بعدها بالتدريب بسرعة دون الحاجة للتعامل مع الكثير من التفاصيل والإعدادات يدويًا، كما أن الصنف Trainer قابل للتخصيص وبإمكاننا تعديل إعداداته بما يوافق احتياجاتنا.

توفر مكتبة Transformers أيضًا الصنف Seq2SeqTrainer الذي يساعدنا في مهام تتطلب تحويل سلسلة نصية إلى سلسلة نصية أخرى مثل الترجمة أو التلخيص. يوجد أيضًا الصنف SFTTrainer من مكتبة TRL التي تغلِّف الصنف Trainer وهي مُحسَّنة لتدريب النماذج اللغوية مثل Llama-2 و Mistral باستخدام تقنيات الانحدار التلقائي Autoregressive التي تُمكِّن النموذج اللغوي من توليد النصوص بناءً على تسلسل الكلمات السابقة، مما يُحسن أداءه، ويدعم الصنف SFTTrainer أيضًا ميزات أخرى مثل Sequence Packing و LoRA وQuantization و DeepSpeed للتوسّع بكفاءة إلى أيّ حجم نموذج نحتاجه، مما يجعله مثاليًا لتدريب النماذج اللغوية المتقدمة.

ملاحظة: يُستحسن الاطلاع على توثيق Trainer لمعرفة المزيد حول الأصناف المختلفة ومتى نستخدم كل منها، فالصنف Trainer هو الخيار الأكثر تنوعًا ويناسب مجموعة واسعة من المهام، والصنف Seq2SeqTrainer مناسب لمهام تتطلب حويل تسلسل نصي إلى تسلسل نصي آخر كالترجمة والتلخيص، أما الصنف SFTTrainer فهو مناسب لتدريب النماذج اللغوية المتقدمة.

قبل البدء باستخدام الصنف Trainer، لنتأكد من تثبيت مكتبة Accelerate المفيدة لتفعيل وتشغيل تدريب نماذج باي تورش PyTorch في البيئات الموزعة بسرعة من خلال الأمر التالي:

pip install accelerate
# للترقية
pip install accelerate --upgrade

سنوفر في الفقرات التالية نظرة عامة على الصنف Trainer وطريقة استخدامه في مكتبة المحوّلات Transformers.

الاستخدام الأساسي للصنف Trainer

يتضمن الصنف Trainer الشيفرة البرمجية الموجودة في حلقة تدريب أساسية، والتي تتضمن ما يلي:

1. إجراء خطوة تدريب لحساب الخسارة
2. حساب التدرجات Gradients باستخدام التابع backward
3. تحديث الأوزان بناءً على التدرجات
4. تكرار هذه العملية حتى الوصول إلى عدد محدَّد مسبقًا من دورات التدريب Epochs

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

في حال أردنا تحديد خيارات التدريب فيمكننا العثور عليها في الصنف TrainingArguments. لنحدّد مثلًا مكان حفظ النموذج في المعامل output_dir ودفع النموذج إلى مستودع Hub بعد التدريب باستخدام المعامل push_to_hub=True كما يلي:

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="your-model",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=2,
    weight_decay=0.01,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    push_to_hub=True,
)

بعد إنشاء training_args علينا تمريره للصنف Trainer إلى جانب النموذج، ومجموعة البيانات، والمُعالِج المسبق لمجموعة البيانات إذ يمكن أن يكون هذا المُعالِج مرمِّزًا أو مستخرج ميزات أو معالج صور حسب نوع بياناتنا، كذلك علينا تمرير مجمِّع بيانات ودالة لحساب المقاييس التي نريد تتبعها أثناء التدريب، ثم نستدعي التابع train()‎ لبدء التدريب كما يلي:

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
)

trainer.train()

نقاط التحقق Checkpoints

يحفظ الصنف Trainer نقاط التحقق Checkpoints الخاصة بنموذجنا في المجلد المحدد في المعامل output_dir الخاص بالصنف TrainingArguments، حيث سنجد نقاط التحقق محفوظة في المجلد الفرعي checkpoint-000 وتقابل الأرقام في النهاية خطوة التدريب، ويُعَد حفظ نقاط التحقق مفيدًا لاستئناف التدريب لاحقًا.

# الاستئناف من نقطة التحقق الأخيرة
trainer.train(resume_from_checkpoint=True)

# الاستئناف من نقطة تحقق مُحدَّدة محفوظة في مجلد الخرج
trainer.train(resume_from_checkpoint="your-model/checkpoint-1000")

يمكننا حفظ نقاط التحقق الخاصة بنموذجنا، ولكن حالة المُحسِّن لن تُحفَظ افتراضيًا في مستودع Hub، فكي نحفظها يجب علينا ضبط المعامل push_to_hub=True في الصنف TrainingArguments لإيداعها Commit ودفعها إلى المستودع.

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

• يدفع الخيار hub_strategy="checkpoint"‎ أحدث نقطة تحقق إلى مجلد فرعي باسم last-checkpoint ، والذي يمكننا استئناف التدريب منه
• يدفع الخيار hub_strategy="all_checkpoints"‎ جميع نقاط التحقق إلى المجلد المحدَّد في المعامل output_dir، حيث سنرى نقطة تحقق واحدة لكل مجلد في مستودع النموذج

عند استئناف التدريب من نقطة تحقق محفوظة سابقًا، يحاول الصنف Trainer أن يحتفظ بنفس حالة الأرقام العشوائية RNG التي كانت في وقت الحفظ، سواء في Python أو NumPy أو PyTorch. ولكن بسبب بعض الإعدادات الافتراضية في باي تورش PyTorch، قد لا تكون الأرقام العشوائية هي نفسها عند استئناف التدريب. فإذا كنا نرغب في جعل كل شيء يحدث بنفس الطريقة تمامًا في كل مرة، يمكن تعديل بعض الإعدادات لجعل التدريب ينفذ دومًا بنفس الطريقة، لكن يجب أن نضع بالحسبان أن هذا قد يجعل التدريب أبطأ قليلاً، ويمكن الرجوع إلى دليل التحكم في العشوائية في PyTorch لمطالعة هذه الإعدادات التي يتوجب تفعيلها لتحقيق ذلك.

تخصيص الصنف Trainer

صُمِّم الصنف Trainer ليكون سهل الاستخدام والوصول، وهو يتميز أيضًا بسهولة التخصيص، إذ يمكننا إنشاء أصناف فرعية للعديد من توابع الصنف وتعديلها لدعم الوظيفة التي نريدها دون الحاجة إلى إعادة كتابة حلقة التدريب بالكامل من الصفر كي تتوافق مع هذه الوظيفة، وتتضمن هذه التوابع ما يلي:

• ينشئ التابع get_train_dataloader()‎ صنف DataLoader للتدريب
• ينشئ التابع get_eval_dataloader()‎ صنف DataLoader للتقييم
• ينشئ التابع get_test_dataloader()‎ صنف DataLoader للاختبار
• يسجّل التابع log()‎ معلومات حول الكائنات المختلفة التي تراقب التدريب
• يستخدم التابع create_optimizer_and_scheduler()‎  لإعداد المحسّن optimizer ومُجَدوِل معدل التعلم learning rate scheduler، ويمكن التخصيص أيضًا باستخدام التابعين create_optimizer()‎ و create_scheduler()‎
• يحسب التابع compute_loss()‎ الخسارة على دفعة من دخل التدريب
• يجري التابع training_step()‎ خطوة التدريب
• يجري التابع prediction_step()‎ خطوة التنبؤ والاختبار
• يقيّم التابع evaluate()‎ النموذج ويعيد مقاييس التقييم
• يجري التابع predict()‎ تنبؤات على مجموعة الاختبار باستخدام المقاييس إذا كانت التسميات Labels متاحة

يمكننا مثلًا تخصيص التابع compute_loss()‎ لاستخدام خسارة موزونة weighted loss كما يلي:

from torch import nn
from transformers import Trainer

class CustomTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False):
        labels = inputs.pop("labels")
        # تمرير أمامي
        outputs = model(**inputs)
        logits = outputs.get("logits")
        # حساب الخسارة المخصَّصة لثلاثة تسميات توضيحية بأوزان مختلفة
        loss_fct = nn.CrossEntropyLoss(weight=torch.tensor([1.0, 2.0, 3.0], device=model.device))
        loss = loss_fct(logits.view(-1, self.model.config.num_labels), labels.view(-1))
        return (loss, outputs) if return_outputs else loss

دوال رد النداء Callbacks

يوجد خيار آخر لتخصيص الصنف Trainer وهو استخدام دوال رد النداء Callbacks، لا تُغيّر هذه الدوال في حلقة التدريب نفسها، بل تراقب حالة الحلقة وتنفذ بعض الإجراءات مثل التوقف المبكر عن التنفيذ، أو تسجيل النتائج استنادًا إلى الحالة الحالية، وبالتالي لا يمكن استخدام دالة رد نداء لتنفيذ شيءٍ مخصص كتعريف دالة خسارة مخصَّصة باستخدامها، بل يجب في هذه الحالة إنشاء صنف فرعي وتعديل التابع compute_loss()‎ ضمنه.

على سبيل المثال، يمكننا إضافة دالة رد نداء للتوقف المبكر بعد 10 خطوات في حلقة التدريب على النحو التالي:

from transformers import TrainerCallback

class EarlyStoppingCallback(TrainerCallback):
    def __init__(self, num_steps=10):
        self.num_steps = num_steps

    def on_step_end(self, args, state, control, **kwargs):
        if state.global_step >= self.num_steps:
            return {"should_training_stop": True}
        else:
            return {}

ثم نمرّرها إلى المعامل callback الخاص بالصنف Trainer كما يلي:

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
    callback=[EarlyStoppingCallback()],
)

التسجيل Logging

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

يُضبَط الصنف Trainer على المستوى logging.INFO افتراضيًا والذي يبلّغ عن الأخطاء والتحذيرات والمعلومات الأساسية الأخرى، وتُضبَط نسخة الصنف Trainer في البيئات الموزعة على المستوى logging.WARNING الذي يبلّغ عن الأخطاء والتحذيرات فقط. يمكننا تغيير مستوى التسجيل باستخدام المعاملات log_level و log_level_replica في الصنف TrainingArguments.

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

ملاحظة1: من المفيد مطالعة توثيق واجهة برمجة التطبيقات الخاصة بالتسجيل Logging للحصول على مزيد من المعلومات حول مستويات التسجيل المختلفة ودور كل منها.

ملاحظة2: يحدّد الصنف Trainer مستوى السجل بطريقة منفصلة لكل جهاز في التابع Trainer.__init__()‎ المسؤول عن تهيئة كائن التدريب، لذا قد نرغب في التفكير في ضبط مستوى السجل مبكرًا في حال استخدمنا دوال مكتبة المحوّلات Transformers الأخرى قبل إنشاء الكائن.

يمكن مثلًا ضبط الشيفرة البرمجية الرئيسية لاستخدام مستوى السجل نفسه وفقًا لكل جهاز كما يلي:

logger = logging.getLogger(__name__)

logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
    datefmt="%m/%d/%Y %H:%M:%S",
    handlers=[logging.StreamHandler(sys.stdout)],
)

log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
datasets.utils.logging.set_verbosity(log_level)
transformers.utils.logging.set_verbosity(log_level)

trainer = Trainer(...)

استخدمنا مجموعات مختلفة من المعاملات log_level و log_level_replica لضبط ما يُسجَّل على كل جهاز، حيث إذا كان لدينا جهاز واحد، فنستخدم ما يلي:

my_app.py ... --log_level warning --log_level_replica error

ونضيف المعامل log_on_each_node 0 للبيئات متعددة الأجهزة كما يلي:

my_app.py ... --log_level warning --log_level_replica error --log_on_each_node 0

# الضبط للإبلاغ عن الأخطاء فقط
my_app.py ... --log_level error --log_level_replica error --log_on_each_node 0

تقنية NEFTune

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

يمكننا تفعيل هذه التقنية في الصنف Trainer من خلال ضبط المعامل neftune_noise_alpha داخل  الصنف TrainingArguments، فهذا المعامل يحدد مقدار الضجيج الذي سيُضاف إلى طبقة التضمين أثناء التدريب كما في المثال التالي:

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(..., neftune_noise_alpha=0.1)
trainer = Trainer(..., args=training_args)

بعد الانتهاء من التدريب، تُعطَّل تقنية NEFTune لاستعادة الطبقة الأصلية للتضمين بدون أي تعديلات عشوائية وتجنب أيّ سلوك غير متوقّع.

استراتيجية التدريب GaLore

إسقاط التدرج منخفض الرتبة Gradient Low-Rank Projection -أو GaLore اختصارًا- هي استراتيجية تدريب منخفضة الرتبة وتتميز بكفاءة في استخدام الذاكرة وتسمح بالتعلم الكامل للمعاملات، ولكنها أكثر كفاءة في استخدام الذاكرة من طرق التكيف منخفضة الرتبة التقليدية مثل LoRA.

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

pip install galore-torch

نحتاج بعد ذلك إلى تحديد كيفية تحسين النموذج بشكل دقيق وإضافة بعض الخيارات التي تحدد طريقة التحسين وأيضًا تحديد الوحدات المستهدفة التي نريد تعديلها، حيث نضيف الخيارات ["galore_adamw", "galore_adafactor", "galore_adamw_8bit"] في المعامل optim مع المعامل optim_target_modules الذي يمكن أن يكون قائمة من السلاسل النصية أو التعابير النمطية Regex أو مسارًا كاملًا مطابقًا لأسماء وحدات النموذج المستهدفة التي نريد تكييفها أثناء عملية التدريب.

فيما يلي مثال لسكربت لتدريب نموذج باستخدام مكتبة GaLore، لكن علينا التأكّد من استخدام الأمر التالي أولًا قبل تشغيل السكربت

pip install trl datasets

وفيما يلي السكربت المطلوب:

import torch
import datasets
import trl

from transformers import TrainingArguments, AutoConfig, AutoTokenizer, AutoModelForCausalLM

train_dataset = datasets.load_dataset('imdb', split='train')

args = TrainingArguments(
    output_dir="./test-galore",
    max_steps=100,
    per_device_train_batch_size=2,
    optim="galore_adamw",
    optim_target_modules=["attn", "mlp"]
)

model_id = "google/gemma-2b"

config = AutoConfig.from_pretrained(model_id)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_config(config).to(0)

trainer = trl.SFTTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    dataset_text_field='text',
    max_seq_length=512,
)

trainer.train()

يمكننا تمرير الوسطاء الإضافية التي تدعمها GaLore من خلال تمرير المعامل optim_args كما يلي:

import torch
import datasets
import trl

from transformers import TrainingArguments, AutoConfig, AutoTokenizer, AutoModelForCausalLM

train_dataset = datasets.load_dataset('imdb', split='train')

args = TrainingArguments(
    output_dir="./test-galore",
    max_steps=100,
    per_device_train_batch_size=2,
    optim="galore_adamw",
    optim_target_modules=["attn", "mlp"],
    optim_args="rank=64, update_proj_gap=100, scale=0.10",
)

model_id = "google/gemma-2b"

config = AutoConfig.from_pretrained(model_id)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_config(config).to(0)

trainer = trl.SFTTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    dataset_text_field='text',
    max_seq_length=512,
)

trainer.train()

يمكن مطالعة المزيد عن هذه طريقة GaLore في المستودع الأصلي.

يمكننا حاليًا تدريب الطبقات الخطية فقط باستخدام طريقة GaLore التي تستخدم طريقة التفكك منخفض الرتبة Low-Rank Decomposition، بينما ستظل الطبقات المتبقية تًدرّب وتُحسَّن بالطريقة التقليدية. وسنلاحظ أن عملية التحضير لبدء التدريب تستغرق بعض  الوقت مثلًا 3 دقائق لنموذج 2B على NVIDIA A100 ولكن يجب أن يعمل التدريب بسلاسة بعد ذلك.

يمكننا أيضًا إجراء تحسين على مستوى الطبقة من خلال إضافة الكلمة layerwise إلى نهاية اسم المحسِّن كما يلي:

import torch
import datasets
import trl

from transformers import TrainingArguments, AutoConfig, AutoTokenizer, AutoModelForCausalLM

train_dataset = datasets.load_dataset('imdb', split='train')

args = TrainingArguments(
    output_dir="./test-galore",
    max_steps=100,
    per_device_train_batch_size=2,
    optim="galore_adamw_layerwise",
    optim_target_modules=["attn", "mlp"]
)

model_id = "google/gemma-2b"

config = AutoConfig.from_pretrained(model_id)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_config(config).to(0)

trainer = trl.SFTTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    dataset_text_field='text',
    max_seq_length=512,
)

trainer.train()

نلاحظ أن التحسين على مستوى الطبقة Layer-wise Optimization تجريبي بعض الشيء ولا يدعم توزيع البيانات Distributed Data Parallel أو DDP اختصارًا، وبالتالي عند استخدام هذا النوع من التحسين فقد تتمكن من تشغيل التدريب على وحدة معالجة رسومية GPU واحدة فقط.

محسّن LOMO

محسّن LOMO هو أداة تُستخدم لتحسين النماذج اللغوية الكبيرة عندما تكون الموارد محدودة، وهو يساعد على تقليل استخدام الذاكرة أثناء التدريب. يُعد AdaLomo نوعًا من محسنات LOMO، وهو يعتمد على تقنية التعلم التكيفي Adaptive Learning لتحديث المعاملات بكفاءة، مما يعزز الأداء مع الحفاظ على استهلاك منخفض للذاكرة.

يعمل محسّن LOMO عن طريق دمج حساب التدرج وتحديث المعاملات في خطوة واحدة، مما يساعد على تسريع عملية التدريب وتقليل الحاجة إلى الذاكرة. المحسنات المتاحة في LOMO هي lomo و adalomo .

ملاحظة: يُوصَى باستخدام محسّن AdaLomo بدون تفعيل خيار حساب تدرجات النموذج grad_norm للحصول على أداء أفضل وإنتاجية أعلى.

 نثبّت أولًا LOMO من مستودع Pypi باستخدام الأمر التالي:

 pip install lomo-optim 

أو نثبّته من المصدر باستخدام الأمر التالي:

 pip install git+https://github.com/OpenLMLab/LOMO.git.

فيما يلي سكربت بسيط يوضح كيفية صقل نموذج google/gemma-2b مع مجموعة بيانات IMDB بدقة كاملة:

import torch
import datasets
from transformers import TrainingArguments, AutoTokenizer, AutoModelForCausalLM
import trl

train_dataset = datasets.load_dataset('imdb', split='train')

args = TrainingArguments(
    output_dir="./test-lomo",
    max_steps=1000,
    per_device_train_batch_size=4,
    optim="adalomo",
    gradient_checkpointing=True,
    logging_strategy="steps",
    logging_steps=1,
    learning_rate=2e-6,
    save_strategy="no",
    run_name="lomo-imdb",
)

model_id = "google/gemma-2b"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, low_cpu_mem_usage=True).to(0)

trainer = trl.SFTTrainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    dataset_text_field='text',
    max_seq_length=1024,
)

trainer.train()

مكتبة Accelerate والصنف Trainer

يعتمد الصنف Trainer على مكتبة Accelerate، والتي هي مكتبة لتدريب نماذج PyTorch بسهولة في البيئات الموزعة مع دعم التكاملات Integrations مثل FullyShardedDataParallel -أو FSDP اختصارًا- و DeepSpeed.

ملاحظة: يمكن مطالعة المزيد حول استراتيجيات تجزئة FSDP أو FSDP Sharding وتفريغ وحدة المعالجة المركزية CPU Offloading وغير ذلك باستخدام الصنف Trainer في دليل FSDP.

يمكننا استخدام مكتبة Accelerate مع الصنف Trainer من خلال تشغيل أمر accelerate.config لإعداد التدريب لبيئة التدريب الخاصة بنا، حيث ينشئ هذا الأمر ملف config_file.yaml الذي سيُستخدَم عند تشغيل سكربت التدريب. فيما يلي مثلًا بعض عمليات الضبط النموذجية التي يمكننا إعدادها:

عند استخدام DistributedDataParallel:

compute_environment: LOCAL_MACHINE                                                                                             
distributed_type: MULTI_GPU                                                                                                    
downcast_bf16: 'no'
gpu_ids: all
machine_rank: 0 # تغيير الرتبة حسب الجهاز
main_process_ip: 192.168.20.1
main_process_port: 9898
main_training_function: main
mixed_precision: fp16
num_machines: 2
num_processes: 8
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

عند استخدام FSDP:

compute_environment: LOCAL_MACHINE
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch_policy: BACKWARD_PRE
  fsdp_forward_prefetch: true
  fsdp_offload_params: false
  fsdp_sharding_strategy: 1
  fsdp_state_dict_type: FULL_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_transformer_layer_cls_to_wrap: BertLayer
  fsdp_use_orig_params: true
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

عند استخدام DeepSpeed:

compute_environment: LOCAL_MACHINE
deepspeed_config:
  deepspeed_config_file: /home/user/configs/ds_zero3_config.json
  zero3_init_flag: true
distributed_type: DEEPSPEED
downcast_bf16: 'no'
machine_rank: 0
main_training_function: main
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

عند استخدام DeepSpeed مع إضافة Accelerate:

compute_environment: LOCAL_MACHINE                                                                                             
deepspeed_config:                                                                                                              
  gradient_accumulation_steps: 1
  gradient_clipping: 0.7
  offload_optimizer_device: cpu
  offload_param_device: cpu
  zero3_init_flag: true
  zero_stage: 2
distributed_type: DEEPSPEED
downcast_bf16: 'no'
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

يُعَد أمر accelerate_launch الطريقة الموصَى بها لتشغيل سكربت التدريب على نظام موزع باستخدام مكتبة Accelerate والصنف Trainer مع المعاملات المُحدَّدة في الملف config_file.yaml الذي يُحفَظ في مجلد ذاكرة التخزين المؤقت للمكتبة Accelerate ويُحمَّل تلقائيًا عند تشغيل أمر accelerate_launch.

يمكننا مثلًا تشغيل سكربت التدريب run_glue.py مع ضبط FSDP كما يلي:

accelerate launch \
    ./examples/pytorch/text-classification/run_glue.py \
    --model_name_or_path google-bert/bert-base-cased \
    --task_name $TASK_NAME \
    --do_train \
    --do_eval \
    --max_seq_length 128 \
    --per_device_train_batch_size 16 \
    --learning_rate 5e-5 \
    --num_train_epochs 3 \
    --output_dir /tmp/$TASK_NAME/ \
    --overwrite_output_dir

ويمكن تحديد المعاملات من الملف config_file.yaml في سطر الأوامر كما يلي:

accelerate launch --num_processes=2 \
    --use_fsdp \
    --mixed_precision=bf16 \
    --fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP  \
    --fsdp_transformer_layer_cls_to_wrap="BertLayer" \
    --fsdp_sharding_strategy=1 \
    --fsdp_state_dict_type=FULL_STATE_DICT \
    ./examples/pytorch/text-classification/run_glue.py
    --model_name_or_path google-bert/bert-base-cased \
    --task_name $TASK_NAME \
    --do_train \
    --do_eval \
    --max_seq_length 128 \
    --per_device_train_batch_size 16 \
    --learning_rate 5e-5 \
    --num_train_epochs 3 \
    --output_dir /tmp/$TASK_NAME/ \
    --overwrite_output_dir

ويمكن مطالعة المقال الخاص بتشغيل سكربتات Accelerate على منصة Huggingface لمعرفة المزيد حول أمر accelerate_launch وعمليات الضبط المخصَّصة.

الخاتمة

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

ترجمة -وبتصرّف- للقسم Trainer من توثيقات Hugging Face.

اقرأ أيضًا

• المقال السابق: استخدام قوالب الدردشة Chat Templates للنماذج اللغوية الكبيرة LLMs
• إنشاء بنية مخصصة لنماذج Transformers في Hugging Face
• تعرف على مكتبة المحوّلات Transformers من منصة Hugging Face
• مشاركة نموذج ذكاء اصطناعي على منصة Hugging Face

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

ما هي تنسرفلو TensorFlow

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

طورت شركة جوجل منصة تنسرفلو TensorFlow عن طريق فريقها Google Brain في عام 2015 كي تكون بديلًا مفتوح المصدر للنظام السابق الذي كان يُستخدم في تدريب خوارزميات تعلم الآلة والمعروف باسم ديست بليف DistBelief، ومن أبرز مميزات تنسرفلو TensorFlow دعم مبدأ توزيع التدريب على عدة أجهزة لتعزيز كفاءة الأداء، وسهولة تعلمها، وكونها منصة مفتوحة المصدر مما يسمح للجميع بالمساهمة في تحسينها واستخدامها في مختلف المشاريع.

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

معنى Tensors

تُشتق تسمية تنسرفلو TensorFlow من العمليات التي تنفذها الشبكات العصبية على بيانات متعددة الأبعاد تعرف باسم تنسورات Tensors حيث تتدفق هذه البيانات Flow عبر الشبكات العصبية. لذا من الضروري توضيح معنى كلمة تنسور Tensor أو ما يعرف أيضًا باسم مُوتِّر فهو هيكل بيانات فالتنسور Tensor هو مفهوم أكثر شمولًا من المصفوفات Matrices والمتجهات Vectors وحتى القيم المفردة أو المضاعفات Scalars.

• المضاعف Scalar: عدد مفرد مثل العدد 5 وهو يُعد موترًا من الرتبة صفر. ونسميه مضاعف ضربه في موتر آخر سيضاعف القيم داخله
• المتجه Vector: مجموعة من الأرقام منظمة في صف واحد أو عمود واحد من القيم، ويُعد موترًا من الرتبة الأولى
• المصفوفة Matrix: مجموعة من الأرقام منظمة في صفوف وأعمدة، وتُعد المصفوفة موتر من الرتبة الثانية

ويمكن للتنسورات أن تمتد إلى رتب Ranks أعلى، فكلما علت الرتبة كلما احتوى التنسور على بيانات متعددة الأبعاد تُستخدم في النماذج المعقدة

على سبيل المثال يمكن استخدام تنسور Tensor من الرتبة الرابعة لتمثيل دفعة بيانات batch مكونة من مجموعة من الصور كما يلي:

• عدد الصورة في الدفعة: 4 صور
• ارتفاع الصورة: 64 بكسل
• عرض الصورة: 64 بكسل
• قنوات الألوان: ثلاثة هي الأحمر، الأخضر، الأزرق

وبالتالي يمكننا التعبير عن هذه المعلومات باستخدام تنسور Tensor من 4 أبعاد، حيث يعبر البعد الأول عن ترتيب الصورة في الدفعة، ويعبر البعد الثاني عن الارتفاع، والثالث عن العرض، والرابع عن عدد قنوات الألوان كما في الصورة التالية:

وبالتالي يمكن استخدام هذا التنسور Tensor لتعريف مدخلات الشبكات العصبية الالتفافية CNN التي تتعامل مع الصور، فهو يمكننا من معرفة عدد الصورة المدخلة بالدفعة وأبعادها وعدد قنوات الألوان بسهولة.

استخدامات تنسرفلو TensorFlow

شاع استخدام منصة تنسرفلو TensorFlow في مختلف مجالات الذكاء الاصطناعي، مثل تعلم الآلة وتحليل البيانات وتصنيف الصور والتعرف على الكائنات بالصور ومعالجة اللغات الطبيعية وتطبيقات الذكاء الاصطناعي التوليدي Generative AI.

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

النظام المتكامل لتنسرفلو TensorFlow Ecosystem

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

• تدريب النموذج Training
• توزيع التدريب Distribution strategy
• التشغيل Deployment
• الاستدلال Inference

لنشرح كل مرحلة من هذه المراحل بمزيد من التفصيل.

التدريب Training

تدريب النموذج هو الخطوة الأولى في بناء أي تطبيق ذكاء اصطناعي، ويتطلب الوصول لخطوة التدريب معالجة البيانات preprocessing حيث توفر تنسرفلو العديد من الأدوات لمعالجة البيانات وإعدادها لتدريب النماذج، كما توفر طريقة سهلة لبناء وتدريب الشبكات العصبية الاصطناعية Artificial Neural Networks من خلال مكتبة كيراس keras وهي مكتبة مختصة داخل الإطار الشامل لتنسرفلو TensorFlow.

توزيع التدريب Distribution strategy

يوفر إطار عمل تنسرفلو ميزة توزيع مهمة تدريب النموذج على عدة أجهزة من خلال الوحدة tf.distribute فبدلاً من تدريب النموذج على جهاز واحد فقط، يمكننا تقسيم عملية التدريب كي تنجز عبر معالجات متعددة. من الأفضل العمل في وضع شبكة العقد الحسابية Computational Graph mode لأنه مُصمم خصيصًا ليعمل بشكل أكثر كفاءة مع التدريب الموزع. أما إذا كنا نرغب في التجربة والتعديل للوصول إلى نموذج قابل للتطبيق على نطاق واسع، فيمكننا استخدام وضع التنفيذ الفوري Eager execution mode.

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

التشغيل Deployment

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

الاستدلال Inference

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

تساعدنا تنسرفلو TensorFlow في تحسين سرعة الاستدلال بعدة أدوات مثل:

• تحسين العمليات الحسابية باستخدام شبكة العقد الحسابية Computational graph
• تحسين تشغيل النماذج على مختلف أنواع العتاد كوحدات المعالجة المركزية CPUs، أو وحدات معالجة الرسومات GPUs، أو وحدات معالجة الموترات Tensor Processing Units TPUs
• استخدام المعالجة على التوازي Parallelism وهي طريقة لتقسيم الحسابات على أكثر من جهاز
• تقسيم الطلبات لدفعات Batching لتحسين استخدام سعة شبكات الانترنت Throughput فمع ملايين من الطلبات بنفس الوقت مرفقة بالبيانات قد تصبح سعة الشبكة غير قادرة على التعامل مع كل الطلبات ومعالجتها بسرعة كافية لذا علينا تقسيمها لدفعات أصغر

النسخة الخفيفة من تنسرفلو TensorFlow light

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

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

كيف نستخدم TensorFlow مع مختلف لغات البرمجة

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

كما تحظى تطبيقات الويب Web Applications بدعم خاص في منصة تنسرفلو، إذ يمكننا تشغيل وتطوير نماذجنا باستخدام JavaScript، مما يتيح لنا تطوير تطبيقات الذكاء الاصطناعي وتشغيلها مباشرة على المتصفح من خلال المكتبة TensorFlow.js.

مستودع النماذج مسبقة التدريب TensorFlow Hub

توفر TensorFlow مكتبة واسعة من النماذج مسبقة التدريب Pre-trained عبر مستودعها TensorFlow Hub، حيث يمكننا استخدام هذه النماذج وتشغيلها مباشرة دون الحاجة لتطويرها من الصفر. تتميز هذه النماذج بتوفير ميزة الصقل fine-tuning  وتخصيصها باستخدام بيانات مخصصة للمشكلة التي نسعى لحلها. وما يجعل هذه النماذج ذات قيمة كبيرة هو أنها تحتوي على معرفة مسبقة اكتسبتها من تدريبها على مجموعات بيانات ضخمة. لذا، يعد صقلها حلاً مثاليًا في العديد من التطبيقات، حيث يمكننا الحصول على نتائج دقيقة وفعالة بسرعة كبيرة بالاعتماد عليها.

التمثيل المرئي للبيانات Visualization في تنسرفلو

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

توفر Tensorboard إمكانية عرض العديد من الرسومات البيانية المفيدة مثل:

• رسم بياني لدقة النموذج accuracy وتغيرها بمرور الوقت
• رسم شبكة العٌقد الحسابية Computational graphs
• توفير رسومات بيانية لدراسة توزيع الأوزان والمعاملات التي تتغير مع الوقت
• عرض الصور والنصوص والصوتيات

دورة الذكاء الاصطناعي

احترف برمجة الذكاء الاصطناعي AI وتحليل البيانات وتعلم كافة المعلومات التي تحتاجها لبناء نماذج ذكاء اصطناعي متخصصة.

اشترك الآن

طريقة استخدام تنسرفلو TensorFlow

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

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

التعامل مع شبكة العقد الحسابية Computational graph

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

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

كما تستخدم تنسرفلو طريقة تسمى الحساب المسبق للثوابت Constant folding، تتعامل هذه الطريقة مع المتغيرات المعلومة أو التي يمكن حساب قيمتها بشكلٍ مباشر، فتحولها إلي قيمة ثابتة أثناء بناء شبكة العٌقد الحسابية Computational graph، حيث لا نحتاج لحساب هذه القيم وقت التنفيذ.

على سبيل المثال إذا كان a=2 ، b=3 و c=a+b فيمكننا إيجاد قيمة المتغير c=5 وعدم إجراء العملية الحسابية أينما وجد هذا المتغير مجددًا وقت التنفيذ، فهذا المتغير لا يعتمد سوى على ثوابت معلومة.

كما تعتمد أيضًا على عملية إعادة استخدام الحدود المتكررة Common Subexpression Elimination لتبسيط شبكة العٌقد الحسابية Computational graph بحساب العمليات التي تتكرر مرة واحدة وتستخدم الناتج أينما وجد تكرار للعملية الحسابية.

على سبيل المثال: إذا كان a=x+y، و b=x+y فإن a=b لذا نقوم بالعملية x+y مرة واحدة ونعوض عنها عندما نجد a أو b.

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

import tensorflow as tf

# قم بتعريف رقم عشري
number = 123.456

# حدد حجم المتغير الذي تريد أن تحفظ الرقم به ليكون 32
float32 = tf.constant(number, dtype=tf.float32)

# حدد حجم المتغير الذي تريد أن تحفظ الرقم به ليكون 16
float16 = tf.constant(number, dtype=tf.float16)

# لنرى الاختلاف في الدقة بين الرقمين
print("float32: ", float32.numpy())
print("float16: ", float16.numpy())

# حجم التخزين 
print("Size of float32: ", float32.numpy().nbytes, "bytes")
print("Size of float16: ", float16.numpy().nbytes, "bytes")

'''
output
float32:  123.456
float16:  123.44
Size of float32:  4 bytes
Size of float16:  2 bytes
'''

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

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

استخدام شبكة العقد الحسابية لتنفيذ العمليات

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

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

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

import tensorflow as tf

@tf.function # لجعل تنسرفلو يستخدم شبكة العٌقد الحسابية 
def add_numbers(a, b):
    return a + b

# نعرف ثابتين
a = tf.constant(5)
b = tf.constant(3)

# لنقم بعملية الجمع بطريقة شبكة العٌقد الحسابية
result = add_numbers(a, b)

# لنحصل على الخطوات التي قام بها تنسرفلو
graph_steps = add_numbers.get_concrete_function(a, b)
print("الخطوات")

print(graph_steps)

print("الخطوات بشكل مفصـل ومبسـط")
for op in graph_steps.graph.get_operations():
    print(op.name)

الخطــوات
ConcreteFunction Input Parameters:
  a (POSITIONAL_OR_KEYWORD): TensorSpec(shape=(), dtype=tf.int32, name=None)
  b (POSITIONAL_OR_KEYWORD): TensorSpec(shape=(), dtype=tf.int32, name=None)
Output Type:
  TensorSpec(shape=(), dtype=tf.int32, name=None)
Captures:
  None
الخطـوات بشكـــل مفصـل ومبسـط
a
b
a d d
I d e n t i t y

تقنية التنفيذ الفوري للعمليات الحسابية Eager execution

كانت عملية تطوير النماذج غير تفاعلية في الإصدار الأول من تنسرفلو TensorFlow 1.x، كما ذكرنا في الفقرة السابقة، حيث كان المطورون يكتبون الأكواد ثم ينتظرون لفترة طويلة لتحويل الأكواد إلى شبكة عُقد حسابية محسّنة، هذا جعل من الصعب اكتشاف الأخطاء وتحسين الأداء في الوقت الفعلي. لهذا السبب، وجدت طريقة التنفيذ الفوري للعمليات الحسابية Eager Execution في TensorFlow 2.x لتجعل عملية التطوير أكثر تفاعلية وسهولة.

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

لاحظ الكود التالي لاستخدام التنفيذ الفوري Eager Execution في تنسرفلو:

import tensorflow as tf

# Eager Mode مفعل بشكل افتراضي
a = tf.constant(5)
b = tf.constant(3)
c = a + b

print("ناتج العملية الفورية:", c.numpy())  
# ناتج العملية الفورية: 8

الخاتمة

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

اقرأ أيضًا

• ما هي منصة Hugging Face للذكاء الاصطناعي
• تعلم الذكاء الاصطناعي
• كل ما تود معرفته عن دراسة الذكاء الاصطناعي
• بناء شبكة عصبية للتعرف على الأرقام المكتوبة بخط اليد باستخدام مكتبة TensorFlow
• تعرف على أهم مشاريع الذكاء الاصطناعي
• تعرف على مكتبة المحوّلات Transformers من منصة Hugging Face

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

نشرح في هذا الدليل تطوير بوت متعددة الأنماط Multi-modal Bot يعتمد على النموذج اللغوي الكبير GPT-4 Large Language Models (LLM) للذكاء الاصطناعي التحاوري Conversational AI، ونموذج Whisper لتحويل الصوت المنطوق إلى نص مكتوب بدقة، ونموذج DALL-E لتوليد الصور، وكل من هذه النماذج الثلاثة مقدمة من شركة OpenAI. وسنستخدمها ضمن تطبيق جانغو Django ينشئ قصصًا مصورة حيث يمكن للمستخدمين تحديد موضوع القصة بالصوت أو بكتابة النص، ويستجيب التطبيق بتأليف قصة نصية مرفقة بصورة مناسبة.

سوف نتبع الخطوات التالية لتطوير بوتات متعددة الأنماط Multi-modal Bots باستخدام Django و GPT-4 و Whisper و DALL-E:

1. دمج OpenAI Whisper للتعرف على الكلام
2. توليد ردود نصية باستخدام GPT-4
3. توليد الصور باستخدام DALL-E
4. دمج الوسائط لتجربة متكاملة

متطلبات التطبيق

لإكمال هذا الدليل التعليمي، ستحتاج إلى التالي:

1. فهم أساسيات لغة بايثون وإطار عملها جانغو Django، وننصح بمطالعة مقال مدخل إلى إطار عمل الويب جانغو Django.
2. مفتاح واجهة برمجية API key من OpenAI لأننا سنتعامل مع نماذج GPT-4 و DALL-E من OpenAI والتي تتطلب مفتاح واجهة برمجية نحصل عليه من خلال إنشاء حساب OpenAI ومن ثم إنشاء مفتاح
3. تثبيت Whisper لتحويل المقاطع الصوتية إلى نص مكتوب، ويمكن مطالعة صفحة GitHub الخاصة بـ OpenAI Whisper لمعرفة خطوات التثبيت التفصيلية
4. تثبيت حزمة OpenAI الخاصة ببايثون للتفاعل مع نماذج OpenAI داخل البيئة الافتراضية للمشروع، ويمكن الرجوع للمقال إعداد بيئة تطوير تطبيقات جانغو Django

إذت أنجزنا المتطلبات أعلاه سنكون قد أنشأنا بيئة افتراضية لمشروعنا باسم env داخل مجلد العمل وليكن اسمه django-apps، ويجب التأكد من تفعيل هذه البيئة الافتراضيةوظهور اسمها بين قوسين في بداية السطر في الشاشة الطرفية Terminal. وذلك بكتابة الأمر التالي في نافذة الطرفية بعد الانتقال إلى مسار المجلد الذي يحتوي على ملفات تطبيق جانغو Django الخاص بنا كما يلي:

sammy@ubuntu:$ .env/bin/activate

بمجرد تفعيل البيئة الافتراضية، سنكتب الأمر التالي لتثبيت حزمة OpenAI الخاصة بلغة بايثون:

(env)sammy@ubuntu:$ pip install openai

إذا لم يسبق لكم استخدام حزمة OpenAI من قبل فننصح بالرجوع للمقال التالي دمج نماذج GPT من OpenAI في تطبيقات Django. بعدها سنكون قد انتهينا من إعداد بيئة العمل وجاهزين لبدء خطوات تنفيذ المشروع.

الخطوة الأولى: دمج OpenAI Whisper للتعرف على الكلام

في هذه الخطوة، سنُعدّ نموذج OpenAI Whisper في تطبيقنا من أجل تحويل الكلام المنطوق إلى نص مكتوب بدقة عالية. اخترنا  Whisper لكونه نموذجًا قويًا للتعرف على الكلام، مما يجعله خيارًا مثاليًا لدعم البوتات متعددة الأنماط Multi-modal Bots، فمن خلال دمج Whisper، سيكون تطبيقنا قادرًا على فهم المدخلات الصوتية بكفاءة.

أولاً، يجب التأكد من أننا نعمل داخل مجلد مشروع Django الخاص بنا، لننتقل إلى مجلد مشروعنا ونفعّل البيئة الافتراضية الخاصة بالمشروع من خلال كتابة التالي:

sammy@ubuntu:$ cd path_to_your_django_project 
sammy@ubuntu:$ source env/bin/activate

إعداد نموذج Whisper في تطبيق Django

ما يجب فعله الآن هو إنشاء دالة تستخدم Whisper لتحويل ملفات الصوت إلى نص. ننشئ في مجلد المشروع ملف بايثون جديد باسم whisper_transcribe.py.

(env)sammy@ubuntu:$ touch whisper_transcribe.py

ثم نفتح الملف whisper_transcribe.py في محرر الأكواد ونستورد مكتبة Whisper. بعد ذلك، ننشئ دالة تأخذ مسار ملف الصوت كمدخل، وتستخدم Whisper لمعالجة الملف، ثم تعيد النص الناتج على النحو التالي:

import whisper 
model = whisper.load_model("base")  

def transcribe_audio(audio_path):     
    result = model.transcribe(audio_path)     
    return result["text"]

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

اختبار تحويل الصوت لنص مكتوب Transcription

لاختبار عملية التفريغ الصوتي وتحويله لنص مكتوب، دعونا نحفظ ملف صوتي داخل مجلد المشروع بعد التأكد من أن هذا الملف بصيغة يدعمها Whisper مثل MP3 أو WAV. ثم نعدّل كود ملف بايثون whisper_transcribe.py بإضافة الكود التالي فى نهايته:

# لأغراض الاختبار 
if __name__ == "__main__":     
    print(transcribe_audio("path_to_your_audio_file"))

نشغل كود الملف whisper_transcribe.py في الطرفية ونتأكد هل تحول الملف الصوتي لكلام مكتوب بشكل صحيح أم لا:

(env)sammy@ubuntu:$ python whisper_transcribe.py

إذا أعددنا كل شيء بشكل صحيح فيجب أن نرى النص المُحوّل في الطرفية Termina. تعمل الوظيفة transcribe_audio كأساس للتفاعلات الصوتية داخل تطبيقنا.

الخطوة الثانية: توليد الاستجابات النصية باستخدام GPT-4

في هذه الخطوة، سنستخدم نموذج GPT-4 لتوليد ردود أو استجابات نصية استنادًا إلى النص الذي أدخله المستخدم أو النص المُحوَّل من الصوت في الخطوة السابقة. يتميز GPT-4 بقدرته على معالجة المدخلات اللغوية بذكاء عالي وتقديم استجابات متسقة وذات صلة بسياق الحوار، مما يجعله اختيارًا مثاليًا لتطوير روبوت متعدد الأنماط Multi-modal Bot.

قبل المتابعة، لنتأكد من تثبيت حزمة OpenAI الخاصة بلغة بايثون في البيئة الافتراضية، كما وضحنا في فقرة المتطلبات الأساسية، ومن المهم أيضًا ملاحظة أن نموذج GPT-4 يتطلب مفتاح الواجهة البرمجية API key للوصول. ولضمان الأمان، يُفضّل تخزين المفتاح كمتغير بيئة environment variable بدل من إضافته مباشرة في كود بايثون لتجنب اختراقه أو مشاركته عن غير قصد.

(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"

إعداد نموذج إكمال المحادثة

ننتقل من جديد لمجلد تطبيق Django الخاص بنا وننشئ ملف بايثون جديد باسم chat_completion.py. مهمة هذا الملف الجديد هو التعامل مع الاتصال بنموذج GPT-4 لتوليد استجابات بناءً على النص المُدخل من المستخدم.

import os from openai
import OpenAI 

client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(input_text):
    # استخدام الواجهة البرمجية لتوليد القصة    
    response = get_story(input_text)     
    # تنسيق وإرجاع الاستجابة     
    return format_response(response)

يتحقق الكود أعلاه من إعداد المفتاح الأساسي للمصادقة مع خدمات OpenAI. بعد ذلك، يستدعي دالة مخصصة باسم get_story للتواصل مع واجهة برمجة التطبيقات OpenAI API والتي ستولد لنا القصة المطلوبة، ثم يستدعي دالة أخرى باسم format_response وظيفتها تنسيق الاستجابة الواردة من الواجهة البرمجية API.

دعونافي البداية نركز على تنفيذ الدالة get_story. سنضيف ما يلي إلى نهاية ملف chat_completion.py:

def get_story(input_text):
    # إعداد الوصف للنظام. يمكن تجربة وصف مختلف.     
    system_prompt = f"""You are a story generator.
    You will be provided with a description of the story the user wants.
    Write a story using the description provided."""

    # التواصل مع الواجهة البرمجية
    response = client.chat.completions.create(         
        model="gpt-4",         
        messages=[             
            {"role": "system", "content": system_prompt},             
            {"role": "user", "content": input_text},         
        ],         
        temperature=0.8     
    )      

    # إرجاع استجابة الواجهة البرمجية
    return response

تعمل هذه الدالة على إعداد الوصف للنظام لإخبار النموذج بالمهمة التي يجب أن يؤديها، ثم تطلب من الواجهة البرمجية API الخاصة بإكمال المحادثة توليد قصة باستخدام الموجّه prompt أو النص المدخل من المستخدم لتوجيه النموذج.

أخيرًا، سنعمل على تنفيذ الدالة format_response. ونضيف ما يلي إلى نهاية ملف chat_completion.py:

def format_response(response):
    # استخراج القصة المولدة من الاستجابة     
    story = response.choices[0].message.content     
    # إزالة أي نص غير مرغوب فيه أو تنسيق     
    story = story.strip()     
    # إرجاع القصة المنسقة     
    return story

يستخرج الكود أعلاه القصة المُولّدة، وينسقها من خلال إزالة أي فراغات زائدة أو تنسيقات غير مرغوب بها.

اختبار الاستجابات المولدة

لاختبار توليد النص بشكل صحيح، سنعدّل كود الملف chat_completion.py بإضافة الكود التالي في نهايته:

# الاختبار 
if __name__ == "__main__":     
    user_input = "Tell me a story about a dragon"     
    print(generate_story(user_input))

نشغل ملف chat_completion.py لرؤية الاستجابة المولدة في الطرفية Terminal:

(env)sammy@ubuntu:$ python chat_completion.py

يجب أن نحصل الآن على استجابة مولدة بشكل إبداعي من GPT-4 بناءً على المُوجِّه prompt الذي أدخلناه للنموذج، يمكن أن نجرب مُوجّهات مختلفة لرؤية استجابات نصية متنوعة.

سنعمل في الخطوة التالية على إضافة صور إلى النص الناتج المولد من هذه الخطوة.

الخطوة الثالثة: إنتاج الصور باستخدام DALL-E

صُمّم نموذج DALL-E لتوليد صور مفصلة عن طريق الموجهات النصية Prompts. مما يتيح للبوتات متعددة الأنماط Multi-modal Bots تحسين القصص عن طريق الإبداع البصري.

ننشئ ملف بايثون جديد باسم image_generation.py في مجلد تطبيق جانغو Django الخاص بك. سيستخدم هذا الملف نموذج DALL-E في توليد الصور:

(env)sammy@ubuntu:$ touch image_generation.py

بعدها ننشئ دالة داخل ملف image_generator.py لترسل المُوجّه prompt إلى DALL-E وتستقبل الصورة الناتجة:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
# إرسال الموجه لتوليد الصورة
def generate_image(text_prompt):
    response = client.images.generate(
        model="dall-e-3",
        prompt=text_prompt,
        size="1024x1024",
        quality="standard",
        n=1,
    )
    image_url = response.data[0].url
    return image_url

سترسل الدالة طلب إلى نموذج DALL-E وتحدد المُوجِّه prompt، وعدد الصور المطلوب توليدها n=1، و أبعاد الصور وجودتها. ثم بعد ذلك تستخرج و تعيد رابط URL للصورة المولدة.

اختبار النص البرمجي

بهذا نكون قد انتهينا من كتابة تطبيقنا وحان وقت تجربته، يمكن إضافة المثال التالي في نهاية ملف image_generation.py :

# الاختبار
if __name__ == "__main__":
    prompt = "Generate an image of a horse and a child playing in a field."
    print(generate_image(prompt))

لننفذ الكود image_generation.py لتوليد صورة بناءً على النص المدخل:

(env)sammy@ubuntu:$ python image_generation.py

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

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

الخطوة الرابعة: دمج كافة الوسائط المُولّدة

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

إنشاء عرض متكامل بجمع كل مكونات التطبيق

أولاً، لنتأكد من تنظيم مشروع جانغو الخاص بنا، ومن وجود الملفات whisper_transcribe.py وchat_completion.py وimage_generation.py في مجلد التطبيق. سننشئ الآن ملف عرض view يجمع بين هذه المكونات.

نفتح ملف views.py ونستورد الوحدات والدوال اللازمة. ثم ننشئ عرضًا جديدًا باسم get_story_from_description كالتالي:

import uuid
from django.core.files.storage import FileSystemStorage
from django.shortcuts import render
from .whisper_transcribe import transcribe_audio
from .chat_completion import generate_story
from .image_generation import generate_image

# العروض الأخرى

def get_story_from_description(request):
    context = {}
    user_input = ""
    if request.method == "GET":
        return render(request, "story_template.html")
    else:
        if "text_input" in request.POST:
            user_input += request.POST.get("text_input") + "\n"
        if "voice_input" in request.FILES:
            audio_file = request.FILES["voice_input"]
            file_name = str(uuid.uuid4()) + (audio_file.name or "")
            FileSystemStorage(location="/tmp").save(file_name, audio_file)
            user_input += transcribe_audio(f"/tmp/{file_name}")

        generated_story = generate_story(user_input)
        image_prompt = (
            f"Generate an image that visually illustrates the essence of the following story: {generated_story}"
        )
        image_url = generate_image(image_prompt)

        context = {
            "user_input": user_input,
            "generated_story": generated_story.replace("\n", "<br/>"),
            "image_url": image_url,
        }

        return render(request, "story_template.html", context)

يستقبل هذا العرض View المدخلات النصية أو الصوتية من المستخدم. إذا كان هناك ملف صوتي، فإنه يُحفظ باسم فريد باستخدام مكتبة uuid ويستخدم دالة transcribe_audio لتحويل الكلام إلى نص. بعد ذلك، نستدعي الدالة generate_story لتوليد استجابة نصية، والدالة generate_image لتوليد صورة ذات صلة بالقصة. نمرر هذه المخرجات إلى متغير context الذي يشير إلى قاموس Dictionary به مخرجات الدوال السابقة، ثم نعرضها باستخدام قالب story_template.html

إنشاء قالب HTML

ننشئ ملف قالب باسم story_template.html ونضيف له الكود التالي:

<div style="padding:3em; font-size:14pt;">
    <form method="post" enctype="multipart/form-data">
        {% csrf_token %}
        <textarea name="text_input" placeholder="Describe the story you would like" style="width:30em;"></textarea>
        <br/><br/>
        <input type="file" name="voice_input" accept="audio/*" style="width:30em;">
        <br/><br/>
        <input type="submit" value="Submit" style="width:8em; height:3em;">
    </form>

    <p>
        <strong>{{ user_input }}</strong>
    </p>
    {% if image_url %}
        <p>
            <img src="{{ image_url }}" alt="Generated Image" style="max-width:80vw; width:30em; height:30em;">
        </p>
    {% endif %}
    {% if generated_story %}
        <p>{{ generated_story | safe }}</p>
    {% endif %}
</div>

تسمح هذه الاستمارة البسيطة للمستخدمين بإرسال المُوجِّهات prompts الخاصة بهم من خلال كتابة وضف نصي أو تحميل ملف صوتي يصف القصة المطلوب توليدها، بعد ذلك يعرض النص و الصورة التي أنشأها التطبيق.

إنشاء رابط URL لعرض التطبيق

الآن بعد أن أصبح العرض get_story_from_description جاهزًا، يجب جعله متاحًا من خلال إعداد رابط URL. نفتح ملف urls.py داخل تطبيق جانغو، ونضيف نمط Pattern لعرض خرج الدالة get_story_from_description:

from django.urls import path
from . import views

urlpatterns = [
    # other patterns
    path('generate-story/', views.get_story_from_description, 
    name='get_story_from_description'),
]

اختبار التكامل النهائي بعد ربط جميع عناصر التطبيق

بإمكاننا الآن زيارة الرابط http://your_domain/generate-story في متصفح الويب لرؤية الاستمارة form المعرفة بداخل قالب story_template.html. سنرسل من خلال الاستمارة نص المُوجّه prompt ضمن الحقل النصي، أو نرفع الملف الصوتي باستخدام حقل اختيار الملف. بعد إرسال الدخل المطلوب للتطبيق، سيعالج تطبيقنا المدخلات، ويولد لنا قصة وصورة مُرفقة، ويعرضهما على الصفحة.

على سبيل المثال، سنطلب توليد قصة بسيطة من المُوجًه prompt التالي لتوليد قصة عن ولد وحصان يلعبان في الحقل، ويمكن تجربة أي مُوجًه مناسب:

اقتباس

Tell me a story about a horse and a child playing in a field

النتيجة:

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

الخاتمة

تعلمنا في هذا الدرس التعليمي خطوات تطوير بوت متعدد الأنماط Multi-modal Bot باستخدام جانغو Django، مع دمج قدرات نموذج Whisper للتعرف على الكلام، و GPT-4 لتوليد النصوص، و DALL-E لتوليد الصور. يمكن لتطبيقنا فهم مدخلات المستخدم بعدة أشكال والاستجابة لها.
للتطوير المستقبلي، ننصحكم باستكشاف إصدارات بديلة من النماذج المستخدمة، وتحسين تصميم واجهة التطبيق، أو توسيع وظائف التطبيق لتشمل ميزات تفاعلية إضافية.

ترجمة وبتصرف للمقال Developing Multi-Modal Bots with Django, GPT-4, Whisper, and DALL-E لكاتبيه Evans Ehiorobo و Anish Singh Walia

اقرأ ايضًا

• الذكاء الاصطناعي: دليلك الشامل
• كل ما تود معرفته عن دراسة الذكاء الاصطناعي
• تطوير تطبيق لاقتراح وصفات الطعام باستخدام ChatGPT و DALL-E في PHP
• استخدام وكلاء مكتبة المحولات Transformers Agents في الذكاء الاصطناعي التوليدي

يعد روبوت الدردشة ChatGPT واحدًا من أشهر أدوات الذكاء الاصطناعي التوليدي Generative AI Tool، وقد طورته شركة OpenAI ليساعد للعاملين في مختلف المجالات، فهو يتيح طرح الأسئلة حول أي موضوع ويوفر إجابات تفصيلية.

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

أسباب البحث عن بدائل مفتوحة المصدر لشات جي بي تي

فيما يلي قائمة بأبرز الأسباب التي تدفعنا لاستخدام بدائل لروبوت الدردشة ChatGPT:

• المعرفة الكاملة بطريقة تعامل روبوت الدردشة مع بيانات المستخدمين ومعالجتها
• إمكانية بناء روبوت دردشة خاص بنا شبيه بروبوت الدردشة مفتوح المصدر دون الحاجة لدفع تكاليف لاستخدامه
• سهولة تعديل روبوت الدردشة وتخصيصه حسب احتياجاتنا الخاصة
• المرونة في السياسات وعدم الحاجة للالتزام بسياسات الشركة المالكة لروبوت الدردشة
• التطور السريع والمستمر في روبوت الدردشة نظرًا لمشاركة عدد ضخم من المطورين في تحديث البوت وترقيته

ملاحظة: لا يعني ذلك أنَّ بوت ChatGPT سيء بالطبع ولا ندعو لعدم استخدامه فقد وصل هذا البوت لدرجة عالية من الكفاءة قد تفوق البدائل مفتوحة المصدر، وإنما نقترح عليكم مطالعة هذه الحلول وتجربتها والنظر في إمكانية الاستفادة المثلى منها.

دعونا نستعرض معًا عدد من البدائل مفتوحة المصدر لبوت ChatGPT.

ديب سيك DeepSeek

تُعدّ DeepSeek منصة ذكاء صناعي مفتوحة المصدر مخصصة لإجراء عدة مهام باستخدام تقنيات معالجة اللغة الطبيعية وتعلم الآلة حيث توفر للمطورين نماذج متقدمة في الذكاء الاصطناعي صالحة لمختلف التطبيقات مثل نموذج DeepSeek-VL لفهم الوسائط المتعددة، ونموذج DeepSeek-Coder لتطوير البرمجيات، ونموذج DeepSeek-V2 الذي يركز على الكفاءة في الاستدلال، كما تقدم المنصة للمطورين إمكانية الوصول لواجهتها البرمجية API لمزيد من المرونة والتحكم. وتتضمن تطبيقًا مخصصًا للاستخدام على الهواتف المحمولة، بالإضافة إلى روبوت دردشة DeepSeek Chat للتفاعل المباشر مع الذكاء الصناعي والعديد من المميزات الأخرى.

هاجينج شات HuggingChat

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

دولي Doly

دولي Doly هو نموذج لغوي درَّبَته منصة تعلم الآلة المدفوعة داتا بريكس Databricks وهي منصة تقدم أدوات وتقنيات متقدمة لبناء وتشغيل تطبيقات الذكاء الاصطناعي وتحليل البيانات،  ويمكن الاطلاع على الشيفرات المصدرية للنموذج عبر مستودع جيت هاب، كما يمكن تجربة النموذج ذاته عبر منصة Huggingface.

كوالا Koala

كوالا Koala بوت دردشة تابع إلى EasyLM       وهو إطار عمل مفتوح المصدر يهدف إلى تبسيط وتسهيل استخدام النماذج اللغوية الكبيرة مثل GPT و BERT وغيرها. ويمكن استخدامه في العديد من التطبيقات مثل الترجمة الآلية وتحليل المشاعر والتلخيص والعديد من مهام معالجة اللغة الطبيعية. ويمكنك تشغيله محليًا عبر حاسوبك الخاص، وهو مبني على مجموعة بيانات LLaMA، ولمعرفة المزيد من التفاصيل يمكن مطالعة المدونة الرسمية للبوت.

فيكونا Vicuna

يعد فيكونا Vicuna بديلًا آخر مفتوح المصدر لشات جي بي تي، وقد تدرَّب على نموذج LLaMA الضخم الذي طورته Meta، وحسب مطوري البوت فإنَّ جودة نتائجه مقاربة لنتائج الإصدار الرابع من شات جي بي تي GPT-4، وللتحقق من هذا الادعاء يمكنكم تجربة البوت والتحقق من أدائه الفعلي عبر هذا الرابط، كما يمكنكم مطالعة المدونة الرسمية للبوت.

أوبن شات كيت OpenChatKit

يٌعدّ OpenChatKit بديلًا متكاملًا لبوت ChatGPT، وقد طورته شركة Together متعاونة مع منظمات بحثية مثل LAION لإنشاء مجموعة بيانات تدريبية تساعد البوت على التعلم والتطور، تعتمد شركة Together على نموذج الذكاء الاصطناعي RedPajama الذي يعد واحدًا من أهم وأشهر نماذج الذكاء الاصطناعي مفتوحة المصدر لتشغيل البوت OpenChatKit. ويمكن تجربة هذا البوت ومطالعة سائر تفاصيله التقنية عبر صفحة البوت على موقع جيت هاب.

ChatRWKV

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

ColossalChat

تشير Colossal AI إلى مبادرة تساعد المطورين على استخدام نماذج ذكاء اصطناعي مُدرَّبة مسبقًا لتطوير بوتات دردشة شبيهة بشات جي بي تي ChatGPT-Like، أما ColossalChat فهو شات بوت مبني باستخدام الأدوات التي توفرها مبادرة Colossal AI، ويمكنكم مطالعة مزيد من التفاصيل حوله عبر مستودع جيت هاب.

GPT4ALL

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

Alpaca-LoRA

يهدف نموذج ألباكا لوراAlpaca-LoRA إلى توفير نموذج لغوي باستخدام التكيُّف منخفض الرتبة Low-Rank Adaptation، أي يمكن تدريب النموذج وتحسين نتائجه باعتماد عدد قليل من البرامترات، وبالتالي يمكن أن يعمل النموذج بموارد قليلة وتكاليف منخفضة، ما يسمح لنا بتشغيله على الحواسيب المصغرة محدودة الموارد، مثل حاسوب راسبيري باي Raspberry Pi، ومن المثير أنه يمكن تدريب النموذج كاملًا باستخدام معالج الرسوميات RTX 4090 GPU خلال ساعات قليلة، ويمكن مطالعة المزيد عنه عبر مستودع البوت على جيت هاب.

 H2oGPT

يعد بوت H2oGPT مخصصًا لتلخيص المستندات النصية، وإن كان يمكنك محادثته واستفساره كسائر البوتات، فهو يسمح لنا برفع واستعراض المستندات وتلخيصها عبر واجهته الأمامية، كما تتوافر مثبتات Installers لبوت H2oGPT لنظامي تشغيل ويندوز Windows وماك أو إس MacOS، بينما نحتاج استخدام دوكر Docker لتنصيبه على نظام تشغيل لينكس Linux، ويمكن تجربته عبر المتصفح من موقع Huggingface، كما يمكن الاطلاع على شيفراته المصدرية عبر مستودع جيت هاب.

Cerebras-GPT

لا يعد Cerebras-GPT بوت دردشة في حد ذاته، ولكنه يوفر نماذج لغوية مفتوحة المصدر مُدرَّبة على بيانات بأحجام ضخمة وشبيهة بنموذج جي بي تي GPT-Like، يساعدنا استخدام هذه النماذج في تطوير البوت الخاص بنا على زيادة دقة البوت ورفع كفاءته الحسابية، ولمطالعة مزيد من المعلومات عن النموذج يمكن زيارة صفحته على Huggingface.

KoboldAI

يعد KoboldAI شات بوت يعمل مساعدًا شخصيًا للكُتَّاب، ولا سيما كتاب الروايات، ويُستخدم عبر المتصفح Browser-Based، ويمكن تشغيله مع برنامج Google Colab بسهولة، يتميز KoboldAI بقدرته على الكتابة بأساليب مختلفة، ليساعد الكتاب على إثراء نصوصهم ويساعدهم على توليد أفكار جديدة. ويمكن اختبار أداه والاطلاع على المزيد من التفاصيل حوله عبر مستودع جيت هاب.

الخاتمة

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

ترجمة -وبتصرف- لمقال Best Open Source ChatGPT Alternatives لكاتبه Ankush Das

اقرأ أيضًا

• تدريب بوت المحادثة ChatGPT وتعليمه كيف يتحدث ويتعلم
• تعرف على 11 طريقة يساعدك فيها ChatGPT كمطور ووردبريس
• دليل استخدام ChatGPT API لتحسين خدماتك عبر الإنترنت
• بناء روبوت دردشة باستخدام بايثون و OpenAI API

نشرح في هذا المقال قوالب الدردشة Chat Templates واستخدامها في النماذج اللغوية الكبيرة LLMs، فالدردشة تعتمد على محادثات مكونة من سلسلة رسائل متعددة بدلاً من النصوص المنفصلة كما هو الحال في النماذج اللغوية التقليدية، كما تحتوي كل رسالة في المحادثة على دور محدد مثل المستخدم User أو المساعد Assistant، بالإضافة إلى محتوى نص الرسالة، وبالتالي نحتاج إلى طريقة منظمة لتحويلها لصيغة تُمكّن النموذج Model من فهمها ومعالجتها بشكل صحيح وإنتاج استجابات ملائمة لها.

تتمثل وظيفة القوالب Chat Templates في تحويل هذه المحادثات إلى تنسيق يمكن للنموذج Model تحليله وفهمه بطريقة مناسبة تمامًا كما هو الحال في عملية الترميز Tokenization. وتُعدّ القوالب جزءًا أساسيًا من عملية التحضير للنموذج فهي تعمل كآلية تنظم تحويل المحادثات المكونة من قوائم من الرسائل مثل رسائل المستخدم وردود المساعد، إلى سلسلة نصية واحدة متكاملة ومُهيَّأة بطريقة تناسب متطلبات النموذج، مما يضمن فهم النموذج للمدخلات بشكل صحيح ومعالجتها بكفاءة.

مثال على قالب الدردشة باستخدام نموذج BlenderBot

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

from transformers import AutoTokenizer

# تحميل المحول
tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

# إعداد المحادثة
chat = [
    {"role": "user", "content": "مرحبًا، كيف حالك؟"},
    {"role": "assistant", "content": "أنا بخير. كيف يمكنني مساعدتك اليوم؟"},
    {"role": "user", "content": "أريد أن أظهر كيفية عمل قوالب الدردشة!"},
]

# تطبيق قالب الدردشة
tokenizer.apply_chat_template(chat, tokenize=False)

سنلاحظ بعدها اختصار المحادثة بأكملها في سلسلة نصية واحدة. وإذا استخدمنا الإعداد الافتراضي tokenize=True، فستخضع هذه السلسلة النصية لتحويل وستُرمَّز هذه السلسلة النصية بشكل وحدات ترميز tokens.

ملاحظة: وحدات الترميز tokens هي الأجزاء الأصغر من النص التي يمكن للنموذج معالجتها.

 مثال على قالب الدردشة باستخدام نموذج Mistral-7B-Instruct

لنستخدم الآن مثالًا أكثر تعقيدًا وهو النموذج mistralai/Mistral-7B-Instruct-v0.1 للمحادثة ونوضح كيفية استخدام قالب دردشة مختلف يختلف عن النموذج البسيط السابق BlenderBot.

from transformers import AutoTokenizer

# تحميل المحول
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1")

# إعداد المحادثة
chat = [
    {"role": "user", "content": "مرحبًا، كيف حالك؟"},
    {"role": "assistant", "content": "أنا بخير. كيف يمكنني مساعدتك اليوم؟"},
    {"role": "user", "content": "أريد أن أشرح كيفية عمل قالب الدردشة!"},
]

# تطبيق قالب الدردشة بدون ترميز بشكل tokens
formatted_chat = tokenizer.apply_chat_template(chat, tokenize=False)

# طباعة النتيجة
print(formatted_chat)

نلاحظ هنا أن المرمِّز أضاف رموز التحكم [INST] و ‎[/INST]‎ هذه المرة للإشارة إلى بداية ونهاية رسائل المستخدم دون استخدامها مع رسائل المساعد، تساعد هذه الرموز النموذج على فهم الرسائل بشكل أفضل لأنها تتماشى مع الطريقة التي تدرب عليها، حيث دُرِّب النموذج الحالي باستخدام هذه الرموز على عكس النموذج BlenderBot.

طريقة استخدام قوالب الدردشة

قوالب الدردشة سهلة الاستخدام، فلاستخدامها ليس علينا سوى إنشاء قائمة بالرسائل مع مفاتيح الدور role والمحتوى content، ثم تمريرها إلى التابع apply_chat_template()‎، وسنحصل على خرج جاهز للاستخدام. يُفضَّل أيضًا استخدام add_generation_prompt=True لإضافة موجِّه توليد Generation Prompt عند استخدام قوالب الدردشة كدخل لتوليد النموذج.

فيما يلي مثال لتجهيز الدخل للتابع model.generate()‎ باستخدام النموذج المساعد Zephyr:

from transformers import AutoModelForCausalLM, AutoTokenizer

# تعيين نقطة التحقق
checkpoint = "HuggingFaceH4/zephyr-7b-beta"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForCausalLM.from_pretrained(checkpoint) # قد ترغب باستخدام تنسيق bfloat16 أو الانتقال إلى وحدة معالجة الرسومات GPU هنا

# إعداد الرسائل
messages = [
    {
        "role": "system",
        "content": "أنت روبوت دردشة ودود ترد دائمًا بأسلوب القراصنة",
    },
    {"role": "user", "content": "كم عدد الطائرات المروحية التي يمكن للإنسان تناولها في وجبة واحدة؟"},
]

# تطبيق قالب الدردشة وتحويله لشكل ملائم للنموذج
tokenized_chat = tokenizer.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt")

# طباعة النص المستخرج بعد فك الترميز
print(tokenizer.decode(tokenized_chat[0]))

سيؤدي ذلك إلى الحصول على سلسلة نصية بتنسيق الدخل الذي يتوقعه النموذج Zephyr كما يلي:

<|system|> أنت روبوت دردشة ودود يرد دائمًا بأسلوب القراصنة </s>
<|user|> كم عدد الطائرات المروحية التي يمكن للإنسان تناولها في جلسة واحدة؟ </s>
<|assistant|>

نسّقنا الدخل ليناسب النموذج Zephyr وذلك على النحو التالي:

• <|system|>: يحدد أن المساعد هو روبوت دردشة ودود ويجب أن يجيب دائمًا بأسلوب القراصنة
• <|user|>: يحدد أن المستخدم يطرح السؤال
• <|assistant|>: يحدد الموضع الذي سيظهر فيه رد المساعد

يمكننا الآن استخدام النموذج لتوليد استجابة لسؤال المستخدم كما يلي:

outputs = model.generate(tokenized_chat, max_new_tokens=128)
print(tokenizer.decode(outputs[0]))

وسنحصل على النتيجة التالية:

<|system|> أنت روبوت دردشة ودود يرد دائمًا بأسلوب القراصنة </s>
<|user|> كم عدد الطائرات المروحية التي يمكن للإنسان تناولها في جلسة واحدة؟ </s>
<|assistant|> 
يا رفيقي، يؤسفني أن أخبرك أن البشر لا يستطيعون تناول الطائرات المروحية. الطائرات المروحية ليست طعامًا، بل هي آلات طائرة. الطعام مخصص للأكل، مثل طبق غني من الخمر، أو وعاء شهي من الحساء، أو رغيف لذيذ من الخبز. أما الطائرات المروحية، فهي للنقل والحركة، وليس للأكل. لذلك، أقول لا شيء، يا أصدقائي. لا شيء على الإطلاق. 

استخدام خط أنابيب Pipeline آلي للدردشة

خطوط الأنابيب Pipelines هي طريقة تلقائية ومبسطة لاستخدام النماذج اللغوية للدردشة، فهي عبارة عن واجهات جاهزة توفرها مكتبة Transformers من Hugging Face لتسهيل استخدام النماذج المختلفة دون الحاجة إلى كتابة الكثير من الكود. تدعم خطوط أنابيب توليد نصوص مدخلات الدردشة، مما يسهّل علينا استخدام نماذج الدردشة. وقد اعتدنا سابقًا على استخدام الصنف ConversationalPipeline المخصَّص، ولكنه أُهمِل الآن ودُمِجت وظائفه مع الصنف TextGenerationPipeline.

لنستخدم مثال Zephyr مرة أخرى، ولكن باستخدام خط أنابيب هذه المرة كما يلي:

from transformers import pipeline

# إنشاء أنبوب لتوليد النصوص باستخدام النموذج HuggingFaceH4/zephyr-7b-beta
pipe = pipeline("text-generation", "HuggingFaceH4/zephyr-7b-beta")

# تعريف الرسائل بين المستخدم والنظام
messages = [
    {
        "role": "system",  # دور النظام: تحديد سلوك المساعد
        "content": "أنت روبوت دردشة ودود يرد دائمًا بأسلوب القراصنة",  # محتوى النظام
    },
    {"role": "user", "content": "كم عدد طائرات الهليكوبتر التي يمكن للإنسان أن يأكلها في جلسة واحدة؟"},  # سؤال المستخدم
]

# توليد النص بناءً على الرسائل
print(pipe(messages, max_new_tokens=128)[0]['generated_text'][-1])  # طباعة آخر حرف من رد المساعد

وهذه هي استجابة النموذج:

{'role': 'assistant', 'content': "يا صديقي، أخشى أنني يجب أن أخبرك أن البشر لا يستطيعون أكل الطائرات الهليكوبتر. الطائرات الهليكوبتر ليست طعامًا، إنها آلات طيران. الطعام يجب أن يُؤكل، مثل طبق كبير من الخمر، أو وعاء شهي من الحساء، أو رغيف لذيذ من الخبز. ولكن الطائرات الهليكوبتر، هي للنقل والتحرك، وليست للأكل. لذلك، أقول لا شيء، يا أصدقائي. لا شيء على الإطلاق."}

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

ما هي موجّهات التوليد Generation Prompts

مُوجّهات التوليد Generation Prompts هي تعليمات أو إشارات تضاف إلى المحادثة أو المدخلات التي تقدمها إلى النموذج لتحفيز استجابة معينة. وفي سياق النماذج اللغوية مثل ChatGPT، نستخدم هذه الموجّهات لتحديد كيفية بدء الاستجابة أو توجيه النموذج للاستجابة بطريقة معينة.

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

نلاحظ أن التابع apply_chat_template يحتوي على الوسيط add_generation_prompt، حيث يخبر هذا الوسيط القالب Template بإضافة رموز tokens تشير إلى بداية استجابة البوت Bot، فمثلًا ليكن لدينا الدردشة التالية:

messages = [
    {"role": "user", "content": "مرحبًا"}, 
    {"role": "assistant", "content": "أهلًا تشرفت بلقائك"}, 
    {"role": "user", "content": "هل يمكنني طرح سؤال؟"}
]

وستكون النتيجة كما يلي بدون موجّه التوليد وباستخدام قالب ChatML الذي رأيناه في مثال نموذج Zephyr:

tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
"""<|im_start|>user
مرحبًا!<|im_end|>
<|im_start|>assistant
تشرفت بلقائك!<|im_end|>
<|im_start|>user
هل يمكنني طرح سؤال؟<|im_end|>
"""

وستكون النتيجة كما يلي عند استخدام موجّه التوليد:

tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
"""<|im_start|>user
مرحبًا!<|im_end|>
<|im_start|>assistant
تشرفت بلقائك!<|im_end|>
<|im_start|>user
هل يمكنني طرح سؤال؟<|im_end|>
<|im_start|>assistant
"""

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

فالموجه الذي نضيفه هنا مثل <|im_start|>assistant، سيخبر النموذج بأن هناك بداية لاستجابة البوت في هذه النقطة، وبدونه، قد يخطئ النموذج في فهم السياق ويبدأ في كتابة استجابة في مكان غير مناسب، مثل متابعة رسالة المستخدم.

ملاحظة: لا تحتاج كل النماذج إلى هذه الموجهات، فبعض النماذج مثل BlenderBot و LlaMA لا تستخدم أي رموز خاصة، لأن هذه النماذج تعرف تلقائيًا أين تبدأ استجابة البوت. وبالتالي، لن نحتاج لإضافة موجّهات توليد في هذه الحالة.

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

يمكن استخدام قوالب الدردشة في التدريب، وهي طريقة جيدة للتأكّد من أن قالب الدردشة يطابق الرموز التي يراها النموذج أثناء التدريب، لذا يُوصَى بتطبيق قالب الدردشة كخطوة معالجة مسبقَة لمجموعة بياناتك، ويمكننا بعد ذلك ببساطة المتابعة مثل أي مهمة لتدريب نموذج لغوي آخر. يجب عند التدريب ضبط add_generation_prompt=False لأن الرموز المضافة لموجّه استجابة المساعد لن تكون مفيدة أثناء التدريب. ليكن لدينا المثال التالي:

from transformers import AutoTokenizer
from datasets import Dataset

tokenizer = AutoTokenizer.from_pretrained("HuggingFaceH4/zephyr-7b-beta")

chat1 = [
    {"role": "user", "content": "أيّهما أكبر، القمر أم الشمس؟"},
    {"role": "assistant", "content": "الشمس."}
]
chat2 = [
    {"role": "user", "content": "أيّهما أكبر، الفيروس أم البكتيريا؟"},
    {"role": "assistant", "content": "البكتيريا."}
]

dataset = Dataset.from_dict({"chat": [chat1, chat2]})
dataset = dataset.map(lambda x: {"formatted_chat": tokenizer.apply_chat_template(x["chat"], tokenize=False, add_generation_prompt=False)})
print(dataset['formatted_chat'][0])

وسنحصل على النتيجة التالية:

<|user|>
أيّهما أكبر، القمر أم الشمس؟</s>
<|assistant|>
الشمس.</s>

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

ملاحظة: إذا نسّقنا النص باستخدام apply_chat_template(tokenize=False)‎ ثم رمّزناه في خطوة منفصلة، فيجب أن نضبط الوسيط add_special_tokens=False، وإذا استخدمنا apply_chat_template(tokenize=True)‎، فلا داعي للقلق بشأن ذلك.
تضيف بعض المرمِّزات رموزًا خاصة مثل <bos> و <eos> إلى النص الذي نرمّزه افتراضيًا، لذا يجب أن تتضمن قوالب الدردشة دائمًا جميع الرموز الخاصة التي نحتاجها، وبالتالي يمكن أن تؤدي إضافة رموز خاصة إضافية باستخدام add_special_tokens=True الافتراضي إلى ظهور رموز خاصة غير صحيحة أو مكرَّرة، مما سيضر بأداء النموذج.

متقدم: دخل إضافي لقوالب الدردشة

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

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

متقدم: استخدام الأدوات واستدعاء الدوال

يمكن للنماذج اللغوية الكبيرة LLMs الخاصة باستخدام الأدوات اختيار استدعاء الدوال كأدوات خارجية قبل توليد إجابة، حيث يمكن ببساطة تمرير قائمة من الدوال إلى الوسيط tools عند تمرير الأدوات إلى نموذج استخدام الأدوات Tool-use كما يلي:

import datetime

def current_time():
    """احصل على الوقت المحلي الحالي كسلسلة نصية."""
    return str(datetime.now())

def multiply(a: float, b: float):
    """
    دالة ضرب رقمين

    المعاملات:
        a: الرقم الأول 
        b: الرقم الثاني 
    """
    return a * b

tools = [current_time, multiply]

model_input = tokenizer.apply_chat_template(
    messages,
    tools=tools
)

علينا الدوال بالتنسيق السابق لكي تعمل بالطريقة الصحيحة، وبالتالي يمكن تحليلها تحليلًا صحيحًا بوصفها أدوات، لذا يجب علينا اتباع القواعد التالية:

• يجب أن يكون للدالة اسم يصف عملها
• يجب أن يكون لكل وسيط تلميح لنوعه Type Hint
• يجب أن يكون للدالة سلسلة نصية توثيقية Docstring وفق نمط جوجل Google المعياري أو وصف أولي للدالة، وتتبعه كتلة Args:‎ التي تصف الوسطاء، إلّا في حالة عدم احتواء الدالة على وسطاء
• لا تضمّن الأنواع في كتلة Args:‎  فمثلًا نكتب a:الرقم الأول وليس a(int):الرقم الأول  حيث يتوجب علينا وضع تلميحات الأنواع في ترويسة الدالة بدلًا من ذلك
• يمكن أن يكون للدالة نوع للقيمة المعادة وكتلة Returns:‎ في السلسلة النصية التوثيقية، ولكنها اختيارية لأن معظم نماذج استخدام الأدوات تتجاهلها

تمرير نتائج الأدوات إلى النموذج

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

1. نحلّل خرج النموذج للحصول على اسم أو أسماء الأدوات ووسطائها
2. نضيف استدعاء أو استدعاءات أداة النموذج إلى المحادثة
3. نستدعي الدالة أو الدوال المقابلة مع تلك الوسطاء
4. نضيف النتيجة أو النتائج إلى المحادثة

مثال كامل لاستخدام أداة

سنستخدم في هذا المثال نموذج Hermes-2-Pro بحجم 8B لأنه أحد أعلى نماذج استخدام الأدوات أداءً في فئته الحجمية حاليًا. إذا كان لدينا ذاكرة كافية، فيمكن التفكير في استخدام نموذج أكبر بدلًا من ذلك مثل النموذجين Command-R أو Mixtral-8x22B، ويدعم كلاهما استخدام الأدوات ويقدّمان أداءً أقوى.

لنحمّل أولًا النموذج والمرمِّز كما يلي:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

checkpoint = "NousResearch/Hermes-2-Pro-Llama-3-8B"

# تحميل المرمِّز Tokenizer باستخدام نقطة التحقق checkpoint وتحديد النسخة المناسبة
tokenizer = AutoTokenizer.from_pretrained(checkpoint, revision="pr/13")

# تحميل النموذج Model باستخدام نقطة التحقق checkpoint، مع تحديد نوع البيانات bfloat16 وتوزيع النموذج على الأجهزة device_map
model = AutoModelForCausalLM.from_pretrained(checkpoint, torch_dtype=torch.bfloat16, device_map="auto")

ثم نعرّف قائمة الأدوات كما يلي:

def get_current_temperature(location: str, unit: str) -> float:
    """
    الحصول على درجة الحرارة الحالية في موقع معين.

    Args:
        location: الموقع الذي سيتم الحصول على درجة حرارته، بصيغة "المدينة، البلد".
        unit: الوحدة التي سيتم إرجاع درجة الحرارة بها. (الخيارات: ["مئوية"، "فهرنهايت"]).
    Returns:
        درجة الحرارة الحالية في الموقع المحدد بوحدات القياس المحددة، كعدد عشري (float).
    """
    return 22.  # يُحتمل أن تقوم الدالة الحقيقية بالحصول على درجة الحرارة الفعلية

def get_current_wind_speed(location: str) -> float:
    """
    الحصول على سرعة الرياح الحالية بالكيلومتر في الساعة (km/h) في موقع معين.

    Args:
        location: الموقع الذي سيتم الحصول على سرعة الرياح فيه، بصيغة "المدينة، البلد".
    Returns:
        سرعة الرياح الحالية في الموقع المحدد بالكيلومتر في الساعة (km/h)، كعدد عشري (float).
    """
    return 6.  # يُحتمل أن تقوم الدالة الحقيقية بالحصول على سرعة الرياح الفعلية

tools = [get_current_temperature, get_current_wind_speed]

لنُعِدّ الآن محادثة البوت كما يلي:

messages = [
  {"role": "system", "content": "أنت بوت يجيب على استفسارات الطقس. يجب أن ترد بوحدة القياس المستخدمة في الموقع الذي تم الاستفسار عنه."},
  {"role": "user", "content": "مرحبًا، ما هي درجة الحرارة في باريس الآن؟"}
]

ونطبّق قالب الدردشة ونولّد استجابةً كما يلي:

inputs = tokenizer.apply_chat_template(messages, chat_template="tool_use", tools=tools, add_generation_prompt=True, return_dict=True, return_tensors="pt")
inputs = {k: v.to(model.device) for k, v in inputs.items()}
out = model.generate(**inputs, max_new_tokens=128)
print(tokenizer.decode(out[0][len(inputs["input_ids"][0]):]))

سنحصل على النتيجة التالية:

<tool_call>
{"arguments": {"location": "باريس، فرنسا", "unit": "مئوية"}, "name": "get_current_temperature"}
</tool_call><|im_end|>

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

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

tool_call_id = "vAHdf3"  # معرّف عشوائي، ويجب أن يكون فريدًا لكل استدعاء أداة
tool_call = {"name": "get_current_temperature", "arguments": {"location": "باريس، فرنسا", "unit": "مئوية"}}
messages.append({"role": "assistant", "tool_calls": [{"id": tool_call_id, "type": "function", "function": tool_call}]})

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

messages.append({"role": "tool", "tool_call_id": tool_call_id, "name": "get_current_temperature", "content": "22.0"})

أخيرًا، سندع المساعد يقرأ خرج الدالة ويتابع الدردشة مع المستخدم كما يلي:

inputs = tokenizer.apply_chat_template(messages, chat_template="tool_use", tools=tools, add_generation_prompt=True, return_dict=True, return_tensors="pt")
inputs = {k: v.to(model.device) for k, v in inputs.items()}
out = model.generate(**inputs, max_new_tokens=128)
print(tokenizer.decode(out[0][len(inputs["input_ids"][0]):]))

وسنحصل على النتيجة التالية:

درجة الحرارة الحالية في باريس، فرنسا هي 22.0 درجة مئوية

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

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

فهم مخططات الأدوات Tool Schemas

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

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

from transformers.utils import get_json_schema

def multiply(a: float, b: float):
    """
    دالة تقوم بضرب عددين

    الوسائط:
        a: العدد الأول الذي سيتم ضربه
        b: العدد الثاني الذي سيتم ضربه
    """
    return a * b

schema = get_json_schema(multiply)
print(schema)

وسنحصل على النتيجة التالية:

{
  "type": "function",
  "function": {
    "name": "multiply",
    "description": "دالة تقوم بضرب عددين",
    "parameters": {
      "type": "object",
      "properties": {
        "a": {
          "type": "number",
          "description": "العدد الأول الذي سيتم ضربه"
        },
        "b": {
          "type": "number",
          "description": "العدد الثاني الذي سيتم ضربه"
        }
      },
      "required": ["a", "b"]
    }
  }
}

يمكن أيضًا تعديل هذه المخططات أو كتابتها من الصفر بنفسنا بدون استخدام get_json_schema على الإطلاق، حيث يمكن تمرير مخططات JSON مباشرةً إلى الوسيط tools في apply_chat_template، مما يمنحنا قدرًا كبيرًا من القوة لتعريف مخططات دقيقة لدوال أكثر تعقيدًا، ولكن يجب توخي الحذر، فكلما كانت المخططات أكثر تعقيدًا، كلما زاد احتمال ارتباك النموذج عند التعامل معها. يُوصى باستخدام توقيعات دوال بسيطة simple function signatures إن أمكن ذلك مع إبقاء الحد الأدنى من الوسطاء وخاصة الوسطاء المعقدة والمتداخلة.

فيما يلي مثال لتعريف المخططات يدويًا وتمريرها إلى apply_chat_template مباشرة:

# دالة بسيطة لا تأخذ أي وسائط
current_time = {
  "type": "function",
  "function": {
    "name": "current_time",
    "description": "الحصول على الوقت المحلي الحالي كسلسلة نصية.",
    "parameters": {
      'type': 'object',
      'properties': {}
    }
  }
}

# دالة أكثر اكتمالًا تأخذ وسيطين عدديين
multiply = {
  'type': 'function',
  'function': {
    'name': 'multiply',
    'description': 'دالة لضرب عددين',
    'parameters': {
      'type': 'object',
      'properties': {
        'a': {
          'type': 'number',
          'description': 'العدد الأول الذي سيتم ضربه'
        },
        'b': {
          'type': 'number', 'description': 'العدد الثاني الذي سيتم ضربه'
        }
      },
      'required': ['a', 'b']
    }
  }
}

model_input = tokenizer.apply_chat_template(
    messages,
    tools=[current_time, multiply]
)

متقدم: التوليد المعزز بالاسترجاع Retrieval-augmented Generation

يمكن للتوليد المعزز بالاسترجاع Retrieval-augmented Generation -أو RAG اختصارًا- الخاص بالنماذج اللغوية الكبيرة LLM البحث في مجموعة من المستندات للحصول على معلومات قبل الرد على استعلام، مما يسمح للنماذج بتوسيع قاعدة المعرفة الخاصة بها بما يتجاوز حجم السياق المحدود. يجب أن يأخذ قالب نماذج RAG الوسيط documents، والذي يجب أن يمثّل قائمة من المستندات، حيث يكون كل مستند قاموسًا واحدًا مع مفتاحي العنوان title والمحتويات contents، وهما سلاسل نصية. لا توجد دوال مساعدة ضرورية لأن هذا التنسيق أبسط بكثير من مخططات JSON المُستخدَمة مع الأدوات.

فيما يلي مثال لقالب RAG:

document1 = {
    "title": "القمر: عدونا القديم",
    "contents": "لطالما حلم الإنسان بتدمير القمر. في هذه المقالة، سأناقش..."
}

document2 = {
    "title": "الشمس: صديقنا القديم",
    "contents": "على الرغم من قلة تقديرها في كثير من الأحيان، إلا أن الشمس تقدم العديد من الفوائد الملحوظة..."
}

model_input = tokenizer.apply_chat_template(
    messages,
    documents=[document1, document2]
)

متقدم: كيف تعمل قوالب الدردشة

يُخزَّن قالب الدردشة الخاص بالنموذج في السمة tokenizer.chat_template، ويُستخدَم القالب الافتراضي لصنف هذا النموذج عند عدم ضبط قالب دردشة. لنلقِ نظرة أولًا على قالب BlenderBot:

>>> from transformers import AutoTokenizer
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/blenderbot-400M-distill")

>>> tokenizer.default_chat_template
"{% for message in messages %}{% if message['role'] == 'user' %}{{ ' ' }}{% endif %}{{ message['content'] }}{% if not loop.last %}{{ '  ' }}{% endif %}{% endfor %}{{ eos_token }}"

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

{%- for message in messages %}
    {%- if message['role'] == 'user' %}
        {{- ' ' }}
    {%- endif %}
    {{- message['content'] }}
    {%- if not loop.last %}
        {{- '  ' }}
    {%- endif %}
{%- endfor %}
{{- eos_token }}

يُعَد ذلك محرك قوالب Jinja، والتي هي لغة قوالب تسمح بكتابة شيفرة برمجية بسيطة تولّد نصًا، حيث تشبه شيفرتها البرمجية وصياغتها لغة بايثون Python، إذ سيبدو القالب السابق في لغة بايثون كما يلي:

for idx, message in enumerate(messages):
    if message['role'] == 'user':
        print(' ')
    print(message['content'])
    if not idx == len(messages) - 1:  # التحقق من الرسالة الأخيرة في المحادثة
        print('  ')
print(eos_token)

ينجز هذا القالب ثلاثة أشياء هي:

1. إذا كانت الرسالة رسالة مستخدم، فسيضيف مسافة فارغة قبلها بالنسبة لكل رسالة، وإلا فلن يطبع شيئًا
2. يضيف محتوى الرسالة
3. إن لم تكن الرسالة هي الرسالة الأخيرة، فسيضيف مسافتَين بعدها، ويطبع رمز EOS بعد الرسالة الأخيرة

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

{%- for message in messages %}
    {%- if message['role'] == 'user' %}
        {{- bos_token + '[INST] ' + message['content'] + ' [/INST]' }}
    {%- elif message['role'] == 'system' %}
        {{- '<<SYS>>\\n' + message['content'] + '\\n<</SYS>>\\n\\n' }}
    {%- elif message['role'] == 'assistant' %}
        {{- ' '  + message['content'] + ' ' + eos_token }}
    {%- endif %}
{%- endfor %}

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

متقدم: إضافة وتعديل قوالب الدردشة

سنوضّح فيما يلي كيفية إضافة وتعديل قوالب الدردشة.

كيف ننشئ قالب دردشة Chat Templates

إنشاء قالب دردشة أمر بسيط، حيث نكتب قالب Jinja ونضبط السمة tokenizer.chat_template، ولكن قد نجد أن من الأسهل البدء بقالب موجود مسبقًا من نموذج آخر وتعديله لتلبية احتياجاتنا، فمثلًا يمكن أخذ قالب LLaMA السابق وإضافة الرموز "[ASST]" و"[‎/ASST]" إلى رسائل المساعد كما يلي:

{%- for message in messages %}
    {%- if message['role'] == 'user' %}
        {{- bos_token + '[INST] ' + message['content'].strip() + ' [/INST]' }}
    {%- elif message['role'] == 'system' %}
        {{- '<<SYS>>\\n' + message['content'].strip() + '\\n<</SYS>>\\n\\n' }}
    {%- elif message['role'] == 'assistant' %}
        {{- '[ASST] '  + message['content'] + ' [/ASST]' + eos_token }}
    {%- endif %}
{%- endfor %}

وما علينا الآن سوى ضبط السمة tokenizer.chat_template، وسيستخدم التابع apply_chat_template()‎ قالبنا الجديد في المرة التالية التي تستخدمه فيها. تُحفَظ هذه السمة في الملف tokenizer_config.json، لذا يمكننا استخدام التابع push_to_hub()‎ لتحميل القالب الجديد إلى مستودع FacHugging e Hub والتأكد من أن الجميع يستخدمون القالب الصحيح لنموذجنا.

template = tokenizer.chat_template
template = template.replace("SYS", "SYSTEM")  # تغيير رمز النظام
tokenizer.chat_template = template  # ضبط القالب الجديد
tokenizer.push_to_hub("model_name")  # رفع قالبك الجديد إلى مستودع‫ Hub

يستدعي الصنف TextGenerationPipeline التابع apply_chat_template()‎ الذي يستخدم قالب الدردشة الخاص بك، لذا سيصبح النموذج متوافقًا تلقائيًا مع هذا الصنف بعد ضبط قالب الدردشة الصحيح.

ملاحظة: عند صقل Fine-tune نموذج دردشة باستخدام قالب الدردشة، يجب إضافة رموز تحكم جديدة إلى المرمِّز بوصفها رموزًا خاصة. هذه الرموز لا تُقسَم أبدًا، مما يعني أنها ستظل دائمًا تعامل كرموز فردية بدلاً من أن تُقسَّم إلى أجزاء أثناء عملية الترميز. بالإضافة إلى ذلك، يجب تعيين سمة أداة المرمِّز eos_token إلى الرمز الذي يمثل نهاية عمليات التوليد الخاصة بالبوت في قالبنا. هذا يضمن أن أدوات توليد النص تتعرف بشكل صحيح على اللحظة التي يجب فيها التوقف عن توليد النص.

لماذا تحتوي بعض النماذج قوالب متعددة

تستخدم بعض النماذج قوالب مختلفة لحالات استخدام مختلفة، فمثلًا قد نستخدم قالبًا للدردشة العادية وقالبًا آخر لاستخدام الأداة أو التوليد المعزز بالاسترجاع، حيث تكون السمة tokenizer.chat_template قاموسًا في هذه الحالات. قد يؤدي ذلك إلى بعض الارتباك، لذا يُوصَى باستخدام قالب واحد لجميع حالات الاستخدام إن أمكننا ذلك. يمكننا استخدام تعليمات Jinja مثل if tools is defined وتعريفات ‎{% macro %}‎ لتغليف مسارات الشيفرة البرمجية المتعددة في قالب واحد بسهولة.

إذا كان للمرمِّز قوالب متعددة، فستكون السمة tokenizer.chat_template قاموسًا dict، حيث يكون كل مفتاح هو اسم القالب. يمتلك التابع apply_chat_template معالجة خاصة لأسماء قوالب معينة، حيث يبحث عن قالب باسم default في معظم الحالات، ويعطي خطأ إن لم يتمكن من العثور عليه، ولكن إذا كان القالب tool_use موجودًا عندما يمرّر المستخدم الوسيط tools، فسيستخدمه بدلًا من ذلك. يمكن الوصول إلى القوالب ذات الأسماء الأخرى من خلال تمرير اسم القالب الذي نريده إلى الوسيط chat_template الخاص بالتابع apply_chat_template()‎.

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

ما القالب الذي يجب استخدامه

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

إذا درّبنا نموذجًا من الصفر أو صقلنا نموذج لغوي أساسي للدردشة، فلدينا الحرية لاختيار قالب مناسب، حيث تتمتع النماذج اللغوية الكبيرة LLM بالذكاء الكافي لتعلّم كيفية التعامل مع الكثير من تنسيقات الدخل المختلفة، وأحد الخيارات الشائعة هو تنسيق ChatML الذي يُعَد خيارًا جيدًا ومرنًا للعديد من حالات الاستخدام، والذي يبدو كما يلي:

{%- for message in messages %}
    {{- '<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n' }}
{%- endfor %}

إذا أعجبنا التنسيق السابق، فلدينا صيغة مؤلفةً من سطر واحد وجاهزةً للنسخ في شيفرتنا البرمجية، حيث تتضمن هذه الصيغة دعمًا لموجّهات التوليد Generation Prompts، ولكنها لا تضيف رموز BOS أو EOS. إذا توقّع نموذجنا هذه الرموز، فلن يضيفها التابع apply_chat_template تلقائيًا، حيث سيُرمَّز النص باستخدام add_special_tokens=False لتجنب التعارضات المحتملة بين القالب والمنطق البرمجي add_special_tokens. إذا توقّع نموذجنا رموزًا خاصة، فعلينا التأكّد من إضافتها إلى القالب.

tokenizer.chat_template = "{% if not add_generation_prompt is defined %}{% set add_generation_prompt = false %}{% endif %}{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n' + message['content'] + '<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n' }}{% endif %}"

يغلّف هذا القالب كل رسالة برمزَي ‎<|im_start|>‎ و ‎<|im_end|>‎، ويكتب الدور كسلسلة نصية، مما يسمح بالمرونة في الأدوار التي تتدرب بها، وسيبدو الخرج كما يلي:

<|im_start|>system
أنت روبوت محادثة مفيد يبذل قصارى جهده لعدم قول شيء سخيف يجذب الانتباه على تويتر.<|im_end|>
<|im_start|>user
كيف حالك؟<|im_end|>
<|im_start|>assistant
أنا بأفضل حال!<|im_end|>

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

كيف نبدأ بإضافة قوالب الدردشة

إذا كان لدينا نموذج دردشة، فيجب ضبط السمة tokenizer.chat_template الخاصة به واختباره باستخدام التابع apply_chat_template()‎، ثم دفع المُرمِّز المحدَّث إلى مستودع Hugging Face Hub. يُطبَّق الشيء نفسه حتى إن لم نكن مالكي النموذج، فإذا استخدمنا نموذجًا مع قالب دردشة فارغ أو نموذجًا لا يزال يستخدم قالب الصنف الافتراضي، فيجب فتح طلب سحب Pull Request إلى مستودع النموذج حتى نتمكّن من ضبط هذه السمة بطريقة صحيحة.

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

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

متقدم: نصائح لكتابة القوالب

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

لنتذكّر أن معالج القالب سيستقبل سجل المحادثة كمتغير بالاسم messages، وسنتمكّن من الوصول إلى هذا المتغير في قالبنا كما تفعل في لغة بايثون، حيث يمكننا تكراره ضمن حلقة باستخدام التعليمة {% for message in messages %} أو الوصول إلى الرسائل الفردية باستخدام التعليمة ‎{{ messages[0] }}‎ مثلًا.

يمكن أيضًا استخدام النصائح التالية لتحويل شيفرتنا البرمجية إلى لغة القوالب Jinja.

إزالة المسافات البيضاء من السلاسل النصية

ستطبع لغة القوالب Jinja افتراضيًا أي مسافات Whitespace مثل الفراغات والسطور الجديدة تأتي قبل أو بعد كتلة ما، والذي قد يشكّل مشكلة بالنسبة لقوالب الدردشة التي نريد أن تكون دقيقة مع الفراغات، حيث يمكن تجنب ذلك من خلال كتابة قوالبك كما يلي:

{%- for message in messages %}
    {{- message['role'] + message['content'] }}
{%- endfor %}

بدلًا من الطريقة التالية:

{% for message in messages %}
    {{ message['role'] + message['content'] }}
{% endfor %}

ستؤدي إضافة الرمز - إلى إزالة أي مسافة بيضاء تأتي قبل الكتلة. قد يبدو أن المثال الثاني لا يسبب مشكلات، ولكنه قد يتضمّن الخرجُ السطرَ الجديد والمسافة البادئة، وهو الشيء الذي نريد تجنبّه.

حلقات For

تبدو حلقات For في لغة Jinja كما يلي:

{%- for message in messages %}
    {{- message['content'] }}
{%- endfor %}

نلاحظ أن كل ما يوجد ضمن {{ كتلة التعبير }} سيُطبَع في الخرج، ويمكنك استخدام معاملات مثل + لدمج السلاسل النصية ضمن كتل التعبير.

تعليمات If

تبدو تعليمات If في لغة Jinja كما يلي:

{%- if message['role'] == 'user' %}
    {{- message['content'] }}
{%- endif %}

تستخدم لغة بايثون المسافات البيضاء لتمييز بدايات ونهايات كتل for و if، وتطلب لغة Jinja إنهاءها صراحةً باستخدام {% endfor %} و {% endif %}.

المتغيرات الخاصة

يمكن الوصول إلى قائمة الرسائل messages داخل قالبنا، ولكن يمكنك أيضًا الوصول إلى العديد من المتغيرات الخاصة الأخرى، والتي تتضمّن الرموز الخاصة مثل bos_token و eos_token، بالإضافة إلى المتغير add_generation_prompt الذي ناقشناه سابقًا. يمكن أيضًا استخدام المتغير loop للوصول إلى معلومات حول تكرار الحلقة الحالي مثل استخدام ‎{% if loop.last %}‎ للتحقق مما إذا كانت الرسالة الحالية هي الرسالة الأخيرة في المحادثة.

فيما يلي مثال يجمع بين هذه الأفكار لإضافة موجّه توليد في نهاية المحادثة إذا كانت قيمة add_generation_prompt هي True:

{%- if loop.last and add_generation_prompt %}
    {{- bos_token + 'المساعد:\n' }}
{%- endif %}

التوافق مع لغة قوالب Jinja التي لا تستخدم لغة بايثون

توجد تطبيقات متعددة للغة قوالب Jinja التي تستخدم لغات مختلفة، ويكون لها عادةً الصياغة نفسها، ولكن الاختلاف الرئيسي هو إمكانية استخدام توابع بايثون عند كتابة قالب باستخدام بايثون مثل استخدام التابع ‎.lower()‎ مع السلاسل النصية أو التابع ‎.items()‎ مع القواميس. سيتوقف ذلك إذا حاول شخص ما استخدام قالبك على تطبيق للغة قوالب Jinja التي لا تستخدم لغة بايثون، فالتطبيقات التي لا تستخدم لغة بايثون شائعة الاستخدام وخاصةً في بيئات النشر حيث تحظى لغة جافاسكربت JS ورَست Rust بشعبية كبيرة.

فيما يلي بعض التغييرات السهلة التي يمكن إجراؤها على قوالبنا لضمان توافقها مع جميع تطبيقات Jinja:

• نستخدم مرشّحات Jinja بدل توابع بايثون، حيث يكون لها الاسم نفسه عادة، فمثلًا يتحوّل string.lower()‎ إلى string|lower، ويتحوّل dict.items()‎ إلى dict|items. أحد التغييرات الملحوظة هو أن string.strip()‎ يصبح string|trim. ويمكن مطالعة  قائمة المرشحات المضمنة في توثيق Jinja لمزيد من المعلومات
• نضع true و false و none بدل True و False و None الخاصة بلغة بايثون
• قد يؤدي عرض القاموس أو القائمة مباشرةً إلى نتائج مختلفة في تطبيقات أخرى، فمثلًا قد تتغير إدخالات السلسلة النصية من علامتي اقتباس مفردتين إلى علامتي اقتباس مزدوجتين، لذا يمكن أن تساعدنا إضافة مرشّح tojson في ضمان التناسق

الخاتمة

بهذا نكون وصلنا لختام مقالنا الشامل الذي شرحنا فيه كيفية تحويل الدردشات إلى تنسيق قابل للاستخدام في نماذج Hugging Face باستخدام قوالب الدردشة Chat Templates، وتعرفنا على أمثلة مختلفة توضح طريقة تطبيقها لتحسين التفاعل بين النظام والمستخدم والتأكد من أن البيانات المدخلة تتماشى مع طريقة تدريب النموذج.

ترجمة -وبتصرّف- للقسم Templates for Chat Models من توثيقات Hugging Face.

اقرأ أيضًا

• كيف تبدأ في مجال الذكاء الاصطناعي
• مشاركة نموذج ذكاء اصطناعي على منصة Hugging Face
• تدريب نموذج ذكاء اصطناعي على تلخيص النصوص باستخدام المكتبة Transformers
• أسئلة شائعة حول الذكاء الاصطناعي

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

ما هي مكتبة ساي كيت ليرن Scikit Learn

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

مميزات مكتبة ساي كيت ليرن Scikit Learn

تسهل مكتبة ساي كيت ليرن Scikit Learn تطوير نماذج تعلم الآلة على المبتدئين والراغبين باختبار الأمور بسرعة، وتوفر لهم العديد من المميزات التي سنسردها ونتعرف عليها مثل:

• التوثيق الجيد: تتميز المكتبة بوجود توثيق مفصل وأمثلة استخدام كثيرة تساعدنا في البدء بتطوير واستخدام الخوارزميات المختلفة ومعرفة المعاملات التي يمكن ضبطها لتغير أداء النموذج وطريقة تدريبها
• القيم الافتراضية لمعاملات التحكم : لا داعي للقلق إن كنا نتعلم خوارزمية جديدة ونرغب في تجربتها دون الدخول في جميع التفاصيل وتأثيرات ضبط قيم معاملات التحكم أوالمعاملات الفائقة hyperparameters حيث تضبط المكتبة أغلب العوامل بقيم  افتراضية مناسبة لأغلب الاستخدامات، لذا يمكننا التركيز على العوامل الأهم وفهمها بشكل أفضل
• أدوات للمفاضلة بين النماذج: مع تنوع الخوارزميات المبنية في المكتبة التي يمكنها القيام بنفس المهمة بطرق مختلفة يكون من الصعب على المبتدئ تقرير أي الخوارزميات هو الأفضل للمهمة التي يحاول إنجازها، لذلك توفر لنا المكتبة أدوات للمقارنة بين الخوارزميات المختلفة وعوامل التحكم المختلفة بسلاسة
• مكتبة غنية بالخوارزميات والأدوات: توفر المكتبة أغلب خوارزميات تعلم الآلة التقليدية، مما يغنينا عن عناء بناء هذه الخوارزميات من الصفر، إذ تتوفر عشرات الخوارزميات التي يمكن تطبيقها من خلال سطور معدودة من الكود، فيمكننا التركيز على تحسين معالجة البيانات وتحسين جودتها واختيار النموذج الأنسب للمشكلة التي لدينا
• التوافق مع المكتبات الأخرى: تعمل المكتبة بشكل سلس مع المكتبات الأخرى مثل باندا Pandas و نمباي NumPy التي توفر هياكل بيانات وعمليات تسهل اكتشاف أنماط البيانات وتحليلها ومعالجتها لتصبح جاهزة للنموذج الذي نحتاج لتدريبه

معالجة البيانات باستخدام ساي كيت ليرن

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

أمثلة على معالجة البيانات

• الترميز Encoding: هو عملية تبديل بعض البيانات بأرقام يسهل إجراء عمليات رياضية عليها، مع إمكانية إرجاعها لأصلها، يمكن ترميز البيانات في مكتبة Scikit Learn باستخدام الكود التالي:

from sklearn.preprocessing import LabelEncoder

# ترميز البيانات الوصفية 
city = ["القاهرة", "الرياض", "دمشق", "القاهرة"]

# نعرف المٌرمز الذي يعوض عن اسمٍ برقم يعبر عنه
encoder = LabelEncoder()

# تقوم هذه الدالة بتجهيز المٌرمز 
# حيث سيمكننا أن نستخدمه أكثر من مرة بعد هذه الخطوة لترميز البيانات المدخلة له بناءً على أول بيانات أعطت له
encoder.fit(city)

# الآن يمكننا استخدامه على أي بيانات أخرى لترميزها
city_encoded = encoder.transform(city)
print(city_encoded)  # Output: [1 0 2 1]
print(encoder.transform(["الرياض"]))  # Output: [0]

# عكس الترميز 
print(encoder.inverse_transform(city_encoded))  # Output: ['القاهرة' 'الرياض' 'دمشق' 'القاهرة']
print(encoder.inverse_transform([2, 1, 0, 0, 1]))  # Output: ['دمشق' 'القاهرة' 'الرياض' 'الرياض' 'القاهرة'](city_encoded)

• التعامل مع القيم المفقودة : قد تتضمن البيانات بعض القيم المفقودة ويمكن التعامل معها في مكتبة Scikit Learn بسهولة من خلال حذف الصفوف التي تحتوي قيمًا مفقودة إن كانت قليلة للغاية، أو التعويض عنها باستخدام المعلومات الإحصائية كالمتوسط الحسابي للقيم، أو بناء نموذج لتوقعها بحسب القيم الموجودة بالفعل.

خوارزميات تعلم الآلة في مكتبة Scikit Learn

تتضمن مكتبة Scikit Learn العديد من خوارزميات تعلم الآلة التي تساعدنا على تنفيذ مهام متنوعة، وفيما يلي نبذة عن أهم هذه الخوارزميات:

أولًا: خوارزميات التعلم الخاضع للإشراف

التعلم الخاضع للإشراف Supervised Learning هو نوع من التعلم الآلي يصف المهام التي تكون فيها البيانات المراد توقعها معلوم مخرجاتها الممكنة مسبقًا وتوجد بيانات تحتوي على ملاحظات سابقة تتضمن الوسوم Labels المراد تعليم النموذج توقعها، وسنوضح تاليًا أبرز الخوازرميات التي تندرج تحت هذه النوع.

خوارزميات توقع الانحدار Regression

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

أمثلة على خوارزميات توقع الانحدار:

• توقع الانحدار الخطي Linear Regression
• توقع الانحدار بالدوال متعددة الحدود Polynomial Regression

خوزارزميات التصنيف Classification

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

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

أمثلة على خوارزميات التصنيف

• الانحدار اللوجستي Logistic Regression
• مٌصنّف الجار الأقرب Nearest Neighbors Classification
• شجرة القرار Decision Tree

خوارزميات تجميع النماذج Models Ensemble

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

يمكن تجميع النماذج باستخدام التصويت Voting حيث نجري تدريب لعدد من النماذج ثم نأخذ بتوقع الأغلبية في حالة كون المشكلة تصنيفية، أما أن كانت المشكلة توقع انحدار يمكن أن تأخذ متوسط التوقعات، لنلاحظ الكود التالي:

from sklearn.ensemble import VotingClassifier
# التصنيف اللوجيستي
model1 = LogisticRegression()
# شجرة القرارات
model2 = tree.DecisionTreeClassifier()
#  مٌصنف أقرب الجيران 
model3 = KNeighborsClassifier(n_neighbors=3)
# تجميع لتوقعات النماذج باستخدام التصويت 
model = VotingClassifier(estimators=[('lr', model1), ('dt', model2), ('knn', model3)], voting='hard')
# تدريب النموذج
# لاحظ أن مدخلات هذه الدالة هي الخواص المطلوب من النموذج تعلم الأنماط بها
# بالإضافة إلى الوسم المٌراد توقعه
# تمثل هذه المدخلات التجارب المٌراد للنموذج التعلم منها
# يمكنك أن تستخدم هذه الدالة في تدريب أي نموذج في ساي كيت ليرن
model.fit(X_train, y_train)
# استخدام النموذج في التوقع
# البيانات المدخلة للنموذج لم يرها من قبل
# ولكنها تحتوي نفس الخواص والأعمدة التي تم تدريب النموذج عليها
# نرغب في تدريب النموذج على التعميم لبيانات لم يرها من قبل
y_pred = model.predict(X_test)

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

تقلل هذه الطريقة من فرص حفظ النموذج للبيانات وتمنحه مرونة أكثر لتعلم الأنماط الحقيقية التي تمكنه من توقع الإجابات الصحيحة عند تعرضه لبيانات جديدة عند تشغيل النموذج.

خوارزميات التعلم غير الخاضع للإشراف

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

خوزارميات العنقدة أو التصنيف العنقودي Clustering

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

تستخدم خوزارميات العنقدة في أنظمة التوصية Recommendation systems لتقديم اقتراحات شخصية للمستخدمين تناسب اهتماماتهم، أو فصل عناصر الصورة Image segmentation من خلال تحديد البكسلات التي تنتمي لنفس العنصر Object في الصورة بالتالي تفريقها عن باقي العناصر.

أمثلة على خوارزميات العنقدة:

• العنقدة حول عدد من نقاط التمركز k-means
• العنقدة الهرمية Hierarchical clustering

خوارزميات اختزال البيانات

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

من أمثلة خوارزميات اختزال البيانات خوارزمية تحليل العنصر الأساسي Principal Component Analysis التي تمكننا من اختزال عدد الأعمدة أو الأبعاد بالبيانات مع الاحتفاظ بأكبر قدر ممكن من المعلومات.

# تساعدنا هذه المكتبة على صنع هياكل بيانات مصفوفة 
# والقيام بالعديد من العمليات الحسابية
import numpy as np
# هذه الخوارزمية التي سنستخدمها لاختزال البيانات
from sklearn.decomposition import PCA
# في البداية لنصنع بيانات عشوائية لنقوم بالتجربة
# يضمن لنا هذا السطر ثبات القيم العشوائية عند إعادة تشغيل هذا الكود
np.random.seed(0)
# نعرف مصفوفة عشوائية التوليد، تتكون من 10 صفوف و100 عمود
X = np.random.rand(10, 100)
# لنعرف الخوارزمية التي استوردناها
pca = PCA(n_components=10) # نضع هنا عدد الأعمدة التي نرغب أن تصبح البيانات عليها
# لنقم بتشغيل الخوارزمية على البيانات التي معنا 
x_pca = pca.fit_transform(X) # هذا السطر يقوم بتدريب الخوارزمية على اختزال البيانات وفي نفس الوقت يقوم باختزال البيانات المدخلة

# لنرى النتائج
print("حجم البيانات قبل الاختزال", X.shape)
print("حجم البيانات بعد الاختزال", x_pca.shape)

'''
المـــــــــخــرجـــــــــــــات
-------------------------------------
حجم البيانات قبل الاختزال (10, 100)
حجم البيانات بعد الاختزال (10, 10)
'''

خوارزميات كشف الشذوذ

كشف الشذوذ Anomaly Detection هو عملية ملاحظة الغير مألوف والخارج عن الأغلبية في البيانات. يستخدم في حالات عددية مثل اكتشاف المعاملات الاحتيالية في البنوك، واكتشاف الأنماط غير المعتادة في تدفق الشبكات مما قد يساعد على منع هجمات إغراق الشبكة بالطلبات، واكتشاف المنتجات المعيبة في خطوط الإنتاج واكتشاف الأنماط غير المعتادة للمؤشرات الحيوية لجسم الإنسان التي تستخدمها تطبيقات الساعات الذكية التي تجمع هذه المؤشرات.

من الخوارزميات التي تطبق كشف الشذوذ خوارزمية غابة العزل  Isolation Forest، وفيما يلي مثال على طريقة استخدامها:

# استيراد نموذج كشف كشف الشذوذ
from sklearn.ensemble import IsolationForest
# سنستخدمها لتوليد بعض البيانات
import numpy as np

# نولد البيانات لتجربة النموذج
X = np.array([[10, 10], [12, 12], [8, 8], [9, 9], [200, 200]])  # يمكنك ملاحظة أن النقطة الأخيرة شاذة عن باقي النقاط

# لنقم بتعريف وتدريب النموذج
clf = IsolationForest(contamination=0.2)  # %يفترض هذا المعامل أن نسبة شذوذ 20
# لاحظ أن التدريب يتم بدون استخدام وسوم حيث أن هذا النموذج غير خاضع للإشراف
clf.fit(X)

# في حالة اكتشاف شذوذ سيتم وسمه بسالب واحد لتميزه
predictions = clf.predict(X)
print(predictions)  # Output: [ 1  1  1  1 -1]

خوارزميات التعلم الخاضع لإشراف جزئي

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

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

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

خوراززميات التعلم الذاتي Self Training

يمكننا استخدام التعلم الذاتي Self Training في ساي كيت ليرن Scikit Learn لتحويل أي نموذج تصنيف تقليدي إلى نموذج يمكنه التدريب على البيانات الموسومة وغير الموسومة معًا، شريطة أن يكون النموذج قادرًا على توقع التصنيفات كاحتمالات، ونحتاج لاستخدام نموذج يسمى SelfTrainingClassifier لتحويل النماذج العادية لنماذج خاضعة لإشراف جزئي، لاحظ الكود التالي:

from sklearn.tree import DecisionTreeClassifier
from sklearn.semi_supervised import SelfTrainingClassifier
# نعرف أي مصنف ليكون نموذج الأساس
base_classifier = DecisionTreeClassifier()
# نقوم بإحاطة نموذج الأساس ليصبح قادرًا على التعلم الذاتي
self_training_model = SelfTrainingClassifier(base_classifier)

# نقوم بتدريب النموذج مثل أي نموذج تقليدي
self_training_model.fit(X_train, y_train)

ملاحظة: عند تجهيزنا لبيانات التدريب نحتاج لوسم البيانات غير الموسومة بقيمة 1- حيث أننا لا نستطيع أن نمرر البيانات خلال النموذج وهي غير موسومة.

دورة الذكاء الاصطناعي

احترف برمجة الذكاء الاصطناعي AI وتحليل البيانات وتعلم كافة المعلومات التي تحتاجها لبناء نماذج ذكاء اصطناعي متخصصة.

اشترك الآن

اختيار النموذج المناسب

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

• الدقة Accuracy: عدد التوقعات الصحيحة التي توقعها النموذج مقسومًا على إجمالي البيانات. كلما كانت النسبة أعلى، كان النموذج أفضل
• خطأ المتوسط التربيعي Mean Squared Error: الفرق بين القيمة الفعلية التي نريد التنبؤ بها والقيمة التي توقعها النموذج، ثم تربيع هذا الفرق. وهو يساعد في تحديد مدى دقة التوقعات
• بحث مصفوفة المعاملات GridSearch: يستخدم لاختبار عدد من المعاملات أو إعدادات النماذج المختلفة دفعة واحدة والعثور على أفضل مجموعة معاملات تحقق أفضل أداء. تستهلك هذه الطريقة وقتًا وموارد حاسوبية كبيرة خاصة إذا كانت المعاملات كثيرة جدًا

مقارنة بين ساي كيت ليرن Scikit Learn و تنسورفلو TensorFlow

يكمن الفرق الرئيسي بين تنسورفلو TensorFlow وبين ساي كيت ليرن Scikit Learn في تخصص الاستخدام، حيث أن ساي كيت ليرن مكتبة متخصصة بخوارزميات تعلم الآلة التقليدية Traditional Machine Learning بينما تنسورفلو TensorFlow إطار عمل شامل لتطوير وتشغيل نماذج التعلم العميق Deep Learning المبنية على الشبكات العصبية الاصطناعية.

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

الخلاصة

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

اقرأ أيضًا

• الذكاء الاصطناعي: دليلك الشامل
• بناء مصنف بالاعتماد على طرق تعلم الآلة بلغة البايثون باستخدام مكتبة Scikit-Learn
• العمل مع ملفات CSV وبيانات JSON باستخدام لغة بايثون
• استخدام التدريب الموزع ومكتبة Accelerate لتسريع تدريب نماذج الذكاء الاصطناعي

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

سنشرح لكم في هذا المقال خطوات بناء ونشر بوت دردشة شخصي يعمل من خلال الطرفية Terminal باستخدام لغة البرمجة بايثون وواجهة برمجة التطبيقاتOpenAI API، ونوضح طريقة نشره على خادم ديجتال أوشن يعمل بنظام أبونتو Ubuntu. وبتنفيذ كامل الخطوات الموضحة في فقرات المقال سيكون لدينا روبوت دردشة كامل الوظائف يمكنه التعامل مع استفسارات المستخدمين مباشرة من الطرفية بفعالية وكفاءة.

المتطلبات الأساسية

قبل الدخول في شرح خطوات التنفيذ، يجب التأكد من توفر المتطلبات التالية:

1. خادم DigitalOcean Droplet بذاكرة وصول عشوائي Ram لا تقل عن 4 جيجابايت ووحدتي معالجة مركزية CPU، للحصول على تعليمات الإعداد يمكن مطالعة مقال التهيئة الأولية لخادم أوبونتو
2. نسخة بايثون Python 3.7 أو أعلى مثبتة على خادم Ubuntu الخاص بك
3. معرفة أساسية بلغة البرمجة بايثون
4. حساب OpenAI مع الوصول إلى الواجهات البرمجية OpenAI API

الخطوة الأولى: إعداد بيئة العمل

سنعمل بداية على إعداد بيئة العمل المخصصة لبناء ونشر روبوت ChatGPT الخاص بنا في الطرفية terminal على خادم ديجيتال أوشن DigitalOcean يعمل بنظام Ubuntu.

إنشاء خادم DigitalOcean Droplet

نسجل دخولنا إلى حساب في DigitalOcean، ثم ننشئ خادم افتراضي Droplet باتباع الخطوات التالية:

• ننتقل إلى قسم Droplets
• ننقر على Create Droplet
• نختار نظام التشغيل Ubuntu ويفضل أحدث إصدار ذي دعم طويل الأمد LTS
• نختار الخطة المناسبة بناء على متطلبات تطبيقنا
• نحدد منطقة مركز البيانات data center ويفضل اختيار البلد الأقرب لبلدنا
• نضيف مفاتيح SSH الخاصة بنا للاتصال الآمن مع الخادم
• ننقر على Create Droplet

الاتصال بخادم Droplet

نفتح الطرفية terminal على جهازنا المحلي، ثم نستخدم الأمر التالي لتسجيل الدخول إلى الخادم، مع الانتباه لاستبدال<your_droplet_ip> بعنوان IP لخادم Droplet الخاص بنا:

ssh root@<your_droplet_ip>

إعداد بيئة برمجة لغة بايثون

نشغل الأوامر التالية للتأكد من تحديث النظام:

sudo apt update 
sudo apt upgrade

بعدها نثبت لغة بايثون python ومدير الحزم pip باستخدام الأمر التالي:

sudo apt install python3 python3-pip

يفضل أن نثبت المكتبة virtualenv لتساعدنا على إنشاء بيئة افتراضية معزولة لتطبيقاتنا بكتابة الأمر التالي: