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

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

ما هو Vibe Coding؟

إن مصطلح فايب كودينج Vibe Coding هو اتجاه حديث في تطوير البرمجيات طرحه لأول مرة عالم الحاسوب أندريه كارباثي Andrej Karpathy، أحد المؤسسين المشاركين في شركة OpenAI والمدير السابق لفريق الذكاء الاصطناعي في تسلا يشير إلى أسلوب برمجة يعتمد على النماذج اللغوية الكبيرة LLMs، حيث يصف المطوّر التطبيق المطلوب بلغة طبيعية، ويتولى الذكاء الاصطناعي توليد الكود البرمجي لهذا التطبيق.

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

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

أهم أدوات Vibe Coding

تتوفر الكثير من الأدوات والمنصات التي تتيح لنا بناء التطبيقات باستخدام أسلوب Vibe Coding، ومن ضمنها:

Replit

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

بالنسبة للسعر، توفر المنصة خطط مدفوعة تبدأ من 20 دولار مجانًا، كما توفر خطة مجانية تسمح بإنشاء 3 تطبيقات عامة.

Lovable

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

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

Cursor

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

توفر المنصة خطة مجانية باسم Hobby تمكننا من تنفيذ 50 طلب، كما توفر عدة خطط مدفوعة، وتتيح لنا تجربة مجانية لمدة أسبوعين للخطة الاحترافية المدفوعة Pro التي تبلغ تكلفتها 20 دولار في الشهر.

GitHub Copilot Agent Mode

يوفر GitHub Copilot يسمى وضع الوكيل Agent Mode يحوله إلى من مجرد مساعد برمجي ذكي لمنصة تطويرية ذكية حيث يصبح بإمكانه تنفيذ مهام تطويرية متعددة، كإنشاء تطبيقات متكاملة وإعادة هيكلة أكوادها، واختبارها وتصحيح أخطائها، كما يمكنه تحديث التطبيقات القديمة وترحيلها إلى أطر عمل حديثة، وهو يتكامل مع محرر الأكواد فيجوال ستوديو كود Visual Studio Code ويدعم اختيار نماذج ذكاء اصطناعي مختلفة مثل GPT-4o و Claude 3.5 وGemini 2.0 Flash، كما يتكامل بشكل كبير معGitHub، ويدعم عدة لغات برمجة، لكن ميزة Agent Mode لا تزال حديثة نسبيًا، وقد تكون بعض الاقتراحات غير دقيقة أو غير مناسبة للسياق وتحتاج لمراجعة من قبل المبرمج.

فيما يخص التسعير يتيح GitHub Copilot خطة المجانية محدودة بـ50 طلبًا شهريًا، كما يوفر خطط مدفوعة تبدأ بتكلفة 10 دولار شهريًا أو 100 دولار سنويًا، ويمكن أيضًا الاشتراك في الخطط المدفوعة مجانًا لبعض الفئات مثل الطلاب والمعلمين والمساهمين في المشاريع مفتوحة المصدر.

OpenHands

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

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

تطوير تطبيق متكامل باستخدام Vibe Coding

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

الخطوة الأولى: اختيار منصة Vibe Coding

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

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

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

الخطوة الثانية: كتابة الموجهات

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

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

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

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

سنبدأ العمل بكتابة موجه بسيط من وكيل الذكاء الاصطناعي لإنشاء نموذج أولي على النحو التالي:

اقتباس

الموجه باللغة الإنجليزية:

Help me build an interactive Flask app for voting and ranking the most famous archaeological landmarks in the Arab world. The app should allow users to vote on landmarks head-to-head, then calculate a ranking for the landmarks based on the chess Elo system. The app should prominently display the matchup along with overall rankings and recent votes.

الموجه باللغة العربية:

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

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

اقتباس

الموجه باللغة الإنجليزية:

I want you to rely on the historical landmarks displayed on this page as a source of information. https://ar.wikipedia.org/wiki/قائمة_مواقع_التراث_العالمي_في_الدول_العربية 

الموجه باللغة العربية:

أريدك أن تعتمد على المعالم الأثرية المعروضة في هذه الصفحة كمصدر للمعلومات https://ar.wikipedia.org/wiki/قائمة_مواقع_التراث_العالمي_في_الدول_العربية

في هذه الحالة سنلاحظ ظهور خيارين للتعامل مع الرابط المرفق الأول هو التقاط لقطة شاشة Take screenshot من أجل التقاط صورة للمحتوى الموجود في الرابط وهو مفيد إذا كنا نريد حفظ شكل الصفحة أو مشاركتها كصورة. والثاني هو استخراج المحتوى النصي Get text content الذي يجلب المعلومات النصية الموجودة في الصفحة، بدون الصور أو التنسيقات المرئية وهو مفيد إذا كنا نريد تحليل النص واستخدمها في تطبيقنا.

سنكتب الآن الموجه الأول كاملًا كما في الصورة التالية ونرسله بالضغط على زر Start Building:

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

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

بداية لن تختار أيًا من المميزات الإضافية وسنبني التطبيق الأساسي فقط، ويمكننا إضافة ما نريده ميزات لاحقًا متى ما أردنا ذلك، لنضغط على زر Approve plan & start لتبدأ عملية إنشاء التطبيق.

ليس علينا الآن سوى الانتظار لدقائق معدودة، وترك المنصة تقوم بعملها وتنشئ التطبيق المطلوب باسم Arab World Heritage Sites مع توفير كافة ملفات المشروع وأكواده المطلوبة.

الخطوة الثالثة: اختبار التطبيق

الآن علينا تجربة الكود الناتج من خلال تشغيل التطبيق والتحقق من أدائه

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

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

الخطوة الرابعة: تحسين النتائج

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

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

لنكتب هذا الموجه لتنفيذ هذا التحسين.

اقتباس

الموجه باللغة الإنجليزية

The app is functioning properly, but it currently displays all content — except for the landmark names — in English. We need the entire application to be in Arabic, with full RTL layout support. Additionally, the current color scheme is too generic. Please update it to reflect earthy tones and shades of brown that better match the theme of historical and archaeological sites.

الموجه باللغة العربية

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

عند تطبيق الموجه السابق سنحصل على النتيجة التالية التي تعرض الصفحة الرئيسية للتطبيق:

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

لو تحقننا من ملفات الكود يمكن أن نرى أن التطبيق يخزن بيانات المعالم الأثرية في القاموس landmarks ضمن ملف models.py، ويخزن نتائج التصويت الأخيرة في قائمة بالاسم votes تحفظ آخر 50 نتيجة وتخزنها مؤقتًا في الذاكرة. ولجعل النتائج محفوظة بشكل دائم حتى بعد إعادة تشغيل التطبيق سنحتاج إلى إنشاء قاعدة بيانات مثل SQLite أو PostgreSQL ونحول landmarks و votes إلى جداول، كما سننشئ جدول للمستخدمين للسماح لهم بالتسجيل والتصويت.

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

اقتباس

الموجه باللغة الإنجليزية:

To ensure data is persistently stored and accessible across sessions and for all users, we will store it permanently in the database. We'll implement a user authentication system with registration and login functionality, using email and securely encrypted passwords. Voting will be restricted to authenticated users only. Once a user is logged in, each vote will be linked to their account to maintain accurate user-specific data.

الموجه باللغة العربية:

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

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

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

كما سنلاحظ أن نتائج التصويت أصبحت تحفظ عند إعادة تشغيل التطبيق.

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

ننوه لأن منصة Replit توفر لنا نقاط حفظ تلقائية أثناء تنفيذ تغييرات مهمة على التطبيق،يطلق على كل نقطة اسم checkpoint وهي بمثابة لقطة لحالة التطبيق في لحظة معينة تساعدنا على تتبع سير العمل وتتيح لنا التراجع Rollback لإلغاء التعديلات التي أجريناها في حال كانت غير مناسبة وأردنا العودة لحالة التطبيق السابقة، كما تمكننا من حفظ الكود الناتج من خلال النقر على خيارات التبويب الجانبي Files واختيار الأمر Download as zip ليحفظ لنا كافة الأكواد البرمجية التي أنشأها باسم LandmarkLegends.zip.

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

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

نلاحظ من اللوحة السابقة توفر عدة خيارات للنشر:

• Reserved VM الذي يوفر خادم محجوز بموارد مخصصة تضمن تشغيل تطبيقنا دون انقطاع
• Autoscale يوسع الموارد تلقائيًا حسب استخدام التطبيق
• Static مناسب للمواقع الثابتة التي لا تتطلب معالجة من طرف الخادم
• Scheduled مناسب للتطبيقات التي تعمل في أوقات محددة نختارها

بعد تحديد نوع النشر وإعداداته ستتيح لنا المنصة عنوان URL فريد خاص به يمكننا مشاركته مع المستخدمين، ويجب التأكد من أن نمط الخصوصية privacy mode لتطبيقنا هو عام public كي يتمكن الجميع من رؤيته، ويمكن مطالعة توثيق Replit للحصول على معلومات إضافية حول عملية النشر.

هل سيلغي Vibe Coding دور المبرمجين

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

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

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

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

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

أهمية Vibe Coding للمبرمجين

يوفر أسلوب Vibe Coding عدة فوائد للمطورين والمبرمجين، لنستعرض أبرزها:

تغير طبيعة العمل

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

بناء نماذج أولية بسرعة

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

توفير أسلوب تعلم مبتكر

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

تحسين مهارات كتابة الموجهات

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

الخاتمة

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

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

المصادر

1. دليل البدء مع منصة Replit لإنشاء وتشغيل المشاريع البرمجية
2. فايب كودينج Vibe Coding: المفهوم والتعريف العام
3. ما هو Vibe Coding؟ شرح مبسط لكيفية بناء التطبيقات باستخدام الذكاء الاصطناعي
4. Vibe Coding: اتجاه حديث في تطوير البرمجيات باستخدام الذكاء الاصطناعي
5. Vibe Coding: عصر جديد من البرمجة بالذكاء الاصطناعي مع تحدياته
6. ما هو Vibe Coding؟ المزايا والعيوب في تطوير التطبيقات بالذكاء الاصطناعي

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

تعريف اختبار البرامج

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

ويقسَّم اختبار البرامج من منظور آخر إلى اختبار وظيفي Functional testing واختبار غير وظيفي Non-Functional testing، حيث تقيس الاختبارات الوظيفية أداء الوظائف الأساسية المطلوبة من النظام مثل التحقق من معالجة البيانات المدخلة بشكل صحيح بينما يقيس الاختبار غير الوظيفي مزايا وصفية وليست وظيفية للنظام، مثل اختبار الأداء Performance testing أو اختبار قابلية الاستخدام Usability أو اختبار سهولة الوصول Accessibility.

متطلبات العمل

• تنزيل محرر أكواد مناسب مثل VS Code

• تثبيت إضافة BLACKBOXAI في VSCode

• تثبيت مكتبات بايثون التالية fastapi و uvicorn و locust باستخدام الطرفية:

pip install fastapi uvicorn locust

مستويات اختبار البرامج Software testing levels

ذكرنا أول المقال أننا نختبر البرامج لنضمن عملها وأداءها لوظائفها، وأدنى هذه المستويات هو اختبار الوحدة unit test، ثم اختبار التكامل Integration test الذي يقيس توافقية الوحدات البرمجية المختلفة مع بعضها البعض عند دمجها، يلي هذا اختبار النظام بشكل شامل System testing، ثم اختبارات القبول في المستوى النهائي التي ينفذها المستخدم حيث يختبر الوظائف المطلوبة بشكل كامل ليقيس جاهزيتها للتسليم.

اختبار الوحدات البرمجية unit test

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

اختبار تحويل الأموال في نظام بنكي

لنفرض أن لدينا نظام بنكي فيه صنف class اسمه BankAccount مسؤول عن إنشاء كائنات حسابات بنكية، ويحتوي تابع method باسم transfer مسؤول عن تحويل الأموال من حساب لآخر.

class BankAccount:
    def __init__(self, balance: float):
        self.balance = balance

    # دالة لإيداع الأموال
    def transfer(self, target_account, amount: float):
        # التحقق من أن الحساب ليس مديونًا أو مفلسًا
        if amount <= 0:
            raise ValueError("ينبغي أن يكون المبلغ أكبر من الصفر.")
        # التحقق من أن الرصيد كافي
        if self.balance < amount:
            raise ValueError("الرصيد غير كافي")

        # خصم المبلغ من الحساب المرسل
        self.balance -= amount
        # إيداع المبلغ في الحساب المستهدف
        target_account.balance += amount

نختبر الآن دالة تحويل الأموال في معزل عن باقي النظام باستخدام أداة BlackBox AI، من خلال توليد حالات اختبار مناسبة باستخدام مكتبة pytest لأنها من أبسط المكتبات المتاحة في لغة بايثون لتنفيذ اختبار على مستوى الوحدة، وبما أننا ثبتنا إضافة BlackBox AI في محرر Vscode فستكون موجودة في القائمة الجانبية في يسار المحرر، ونخبرها أن تنشئ ملف اختبار لوظيفة تحويل الأموال بين الحسابات البنكية كما يلي:

> create a test file in python using pytest library to test the method of transfer in BankAccount class @/BankAccount.py

نلاحظ أن BlackBoxAI وضعت خطة لتنفيذ الطلب ثم أنشأت ملف test_BanckAccount.py وتطلب مصادقتنا على التغييرات المقترحة والتي يمكن تصفحها قبل الموافقة عليها أو رفضها.

بالنظر في ملف test_BanckAccount.py سنجد أن الأداة قد ولدت الشيفرة التالية:

import pytest
from BankAccount import BankAccount

def test_transfer_successful_transfer():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    account1.transfer(account2, 50)
    assert account1.balance == 50
    assert account2.balance == 100

def test_transfer_with_zero_amount():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    with pytest.raises(ValueError, match="ينبغي أن يكون المبلغ أكبر من الصفر."):
        account1.transfer(account2, 0)

def test_transfer_with_negative_amount():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    with pytest.raises(ValueError, match="ينبغي أن يكون المبلغ أكبر من الصفر."):
        account1.transfer(account2, -10)

def test_transfer_with_insufficient_balance():
    account1 = BankAccount(50)
    account2 = BankAccount(100)
    with pytest.raises(ValueError, match="الرصيد غير كافي"):
        account1.transfer(account2, 100)

نشغل هذا الملف الاختباري بالأمر التالي في سطر الأوامر Terminal

pytest test_BankAccount.py

ونحصل على الخرج التالي:

===========================
platform win32 -- Python 3.9.12, pytest-7.1.1, pluggy-1.0.0
rootdir: F:\AI_tools\Article_4
plugins: anyio-3.5.0
collected 4 items

test_BankAccount.py ....
============================= 4 passed in 0.21s =====================[100%]

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

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

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

> I want to test edge cases to ensure all transactions are atomic, especially when a transaction fails. Specifically, I need to verify that the balance remains unchanged if the sending or receiving process fails, using pytest.

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

import pytest
from BankAccount import BankAccount

def test_transfer_successful_transfer():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    account1.transfer(account2, 50)
    assert account1.balance == 50
    assert account2.balance == 100

def test_transfer_with_zero_amount():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    with pytest.raises(ValueError, match="ينبغي أن يكون المبلغ أكبر من الصفر"):
        account1.transfer(account2, 0)

def test_transfer_with_negative_amount():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    with pytest.raises(ValueError, match="ينبغي أن يكون المبلغ أكبر من الصفر"):
        account1.transfer(account2, -10)

def test_transfer_with_insufficient_balance():
    account1 = BankAccount(50)
    account2 = BankAccount(100)
    with pytest.raises(ValueError, match="الرصيد غير كافي"):
        account1.transfer(account2, 100)

def test_transfer_mid_transaction_failure():
    """
    محاكاة فشل العملية بعد خصم المبلغ وقبل إيداعه.
    السلوك المتوقع: يجب ألا يفقد المرسل المال إذا فشلت العملية.
    """
    account1 = BankAccount(100)
    account2 = BankAccount(50)

    # إنشاء حساب يحتوي على خطأ محتمل عند محاولة إعادة تعيين الرصيد
    class ProblematicAccount:
        def __init__(self, balance):
            self.balance = balance

        # الحصول على الرصيد بشكل آمن
        # getter
        @property
        def balance(self):
            return self._balance

        # تعيين الرصيد بشكل آمن
        # setter
        @balance.setter
        def balance(self, value):
            if hasattr(self, '_balance'):  # إن كانت القيمة معرفة مسبقًا
                raise RuntimeError("Unexpected failure before deposit!")
            self._balance = value

    problem_account = ProblematicAccount(50)

    # اختبار نقل الأموال
    with pytest.raises(RuntimeError, match="Unexpected failure before deposit!"):
        account1.transfer(problem_account, 30)

    # التحقق من عدم فقدان المرسل للمال بشكل غير متوقع
    assert account1.balance == 100, "Sender lost money unexpectedly!"
    assert problem_account.balance == 50, "Receiver should not gain money!"

ينبغي أن نحصل على الخرج التالي بتشغيل تلك الشيفرة:

=========================== short test summary info ========================
FAILED test_BankAccount.py::test_transfer_mid_transaction_failure - AssertionError: Sender lost money unexpectedly!
================ 1 failed, 4 passed in 0.14s =================================

ندرك بهذا أن الدالة transfer تحتاج للتعديل لتتمكن من التعامل مع حالات الفشل غير المتوقعة، خاصة تحقيق مبدأ الذرية Atomic الذي ينص على أن العملية ينبغي أن تنجح بالكامل أو تفشل بالكامل، ونحقق ذلك بتطبيق آلية للتراجع في حالة حدوث خطأ غير متوقع، انظر الموجه التالي.

> Given that failure on the atomicity test case (test_transfer_mid_transaction_failure) ,fix the  BankAccount.py transfer method.

ينبغي أن نحصل على الشيفرة المعدلة لملف BankAccount.py

class BankAccount:
    def __init__(self, balance: float):
        self.balance = balance

    def transfer(self, target_account, amount: float):
        # التحقق من أن الحساب ليس مديونًا أو مفلسًا
        if amount <= 0:
            raise ValueError("ينبغي أن يكون المبلغ أكبر من الصفر.")
        # التحقق من أن الرصيد كافي
        if self.balance < amount:
            raise ValueError("الرصيد غير كافي")

        # حفظ الرصيد الحالي في حالة حدوث خطأ
        original_balance = self.balance

        try:
            # خصم المبلغ من الحساب المرسل
            self.balance -= amount
            # إيداع المبلغ في الحساب المستهدف
            target_account.balance += amount
        except Exception as e:
            # استعادة الرصيد الأصلي في حالة حدوث خطأ
            self.balance = original_balance
            # إعادة رفع الاستثناء
            raise e

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

================================ test session starts ==============
platform win32 -- Python 3.9.12, pytest-7.1.1, pluggy-1.0.0
rootdir: F:\Article_4
plugins: anyio-3.5.0
collected 5 items

test_BankAccount.py .....                                                                                                 [100%]
====================== 5 passed in 0.03s=========================

اختبار الانحدار

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

class BankAccount:
    def __init__(self, balance: float, fee_percentage: float = 0):
        self.balance = balance
        self.fee_percentage = fee_percentage

    def transfer(self, target_account, amount: float):
        # التحقق من أن الحساب ليس مديونًا أو مفلسًا
        if amount <= 0:
            raise ValueError("ينبغي أن يكون المبلغ أكبر من الصفر.")
        # حساب الرسوم المفروضة
        fee = self.get_fee_amount(amount)
        total_amount = amount + fee

        # التحقق من أن الرصيد كافي
        # مضيفين الرسوم إلى تكلفة التحويل
        if self.balance < total_amount:
            raise ValueError("الرصيد غير كافي")

        # حفظ الرصيد الحالي في حالة حدوث خطأ
        original_balance = self.balance

        try:
            # خصم المبلغ من الحساب المرسل
            self.balance -= total_amount
            # إيداع المبلغ في الحساب المستهدف
            # لا نودع إلا المبلغ المرسل فقد بدون الرسوم
            target_account.balance += amount
        except Exception as e:
            # استعادة الرصيد الأصلي في حالة حدوث خطأ
            self.balance = original_balance
            # إعادة رفع الاستثناء
            raise e
    def get_fee_amount(self, transfer_amount: float):
        """حساب مبلغ الرسوم لتحويل معين"""
        return transfer_amount * self.fee_percentage / 100

نحتاج لاختبار الميزة الجديدة لنتأكد من عمل الوظائف السابقة أولًا، حيث نختبر الحالة التي تكون الرسوم فيها 0% ثم اختبار التحويل حين تكون الرسوم أكبر من الصفر -2% مثلًا-، ونوجه BlackBoxAI حينئذ لتوليد ملف يختبر عمل الوظائف السابقة بالإضافة لاختبار الحالات الجديدة. لنستخدم الموجه التالي:

> Create a regression test for the newly implemented fee feature on money transfers. Ensure the test verifies that the new functionality works as expected, while also confirming that existing features remain unaffected.

ينبغي أن نحصل على ملف اختبار يكون كما يلي:

import pytest
from BankAccount import BankAccount

# ---------- اختبارات الانحدار (Regression Tests) ----------
# هذه هي الاختبارات الموجودة مسبقًا للتأكد من أن الوظائف الأساسية ما زالت تعمل

def test_transfer_successful_transfer():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    account1.transfer(account2, 50)
    assert account1.balance == 50
    assert account2.balance == 100

def test_transfer_with_zero_amount():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    with pytest.raises(ValueError, match="ينبغي أن يكون المبلغ أكبر من الصفر."):
        account1.transfer(account2, 0)

def test_transfer_with_negative_amount():
    account1 = BankAccount(100)
    account2 = BankAccount(50)
    with pytest.raises(ValueError, match="ينبغي أن يكون المبلغ أكبر من الصفر"):
        account1.transfer(account2, -10)

def test_transfer_with_insufficient_balance():
    account1 = BankAccount(50)
    account2 = BankAccount(100)
    with pytest.raises(ValueError, match="الرصيد غير كافي"):
        account1.transfer(account2, 100)

def test_transfer_mid_transaction_failure():
    """
    محاكاة فشل العملية بعد خصم المبلغ وقبل إيداعه.
    السلوك المتوقع: يجب ألا يفقد المرسل المال إذا فشلت العملية.
    """
    account1 = BankAccount(100)

    # إنشاء حساب يحتوي على خطأ محتمل عند محاولة إعادة تعيين الرصيد
    class ProblematicAccount:
        def __init__(self, balance):
            self.balance = balance

        # الحصول على الرصيد بشكل آمن
        @property
        def balance(self):
            return self._balance

        # تعيين الرصيد بشكل آمن
        @balance.setter
        def balance(self, value):
            if hasattr(self, '_balance'):  # إن كانت القيمة معرفة مسبقًا
                raise RuntimeError("Unexpected failure before deposit!")
            self._balance = value

    problem_account = ProblematicAccount(50)

    # اختبار نقل الأموال
    with pytest.raises(RuntimeError, match="Unexpected failure before deposit!"):
        account1.transfer(problem_account, 30)

    # التحقق من عدم فقدان المرسل للمال بشكل غير متوقع
    assert account1.balance == 100, "Sender lost money unexpectedly!"
    assert problem_account.balance == 50, "Receiver should not gain money!"

# ---------- اختبارات الميزة الجديدة (New Feature Tests) ----------
# اختبارات للتحقق من ميزة رسوم التحويل الجديدة

def test_transfer_with_fee():
    """اختبار التحويل مع وجود رسوم"""
    # %إنشاء حساب مع رسوم 2
    account1 = BankAccount(100, fee_percentage=2)
    account2 = BankAccount(50)

    # تحويل 50 وحدة مع رسوم 1
    account1.transfer(account2, 50)

    # التحقق من الأرصدة
    assert account1.balance == 49, "Should be 100 - 50 - 1(fee) = 49"
    assert account2.balance == 100, "Should be 50 + 50 = 100"

def test_transfer_with_fee_insufficient_balance():
    """اختبار فشل التحويل عند عدم كفاية الرصيد لتغطية المبلغ والرسوم"""
    # إنشاء حساب مع رسوم %10
    account1 = BankAccount(100, fee_percentage=10)
    account2 = BankAccount(50)

    # محاولة تحويل مبلغ 95 يتطلب مبلغ 9.5 إضافي للرسوم
    with pytest.raises(ValueError, match="الرصيد غير كافي"):
        account1.transfer(account2, 95)

    # التحقق من عدم تغيير الأرصدة
    assert account1.balance == 100
    assert account2.balance == 50

def test_get_fee_amount():
    """اختبار حساب مبلغ الرسوم"""
    account = BankAccount(1000, fee_percentage=2.5)

    fee = account.get_fee_amount(200)
    assert fee == 5, "2.5% of 200 should be 5"

def test_zero_fee_percentage():
    """اختبار أن الحساب يعمل بشكل طبيعي عندما تكون الرسوم صفرًا"""
    account1 = BankAccount(100, fee_percentage=0)
    account2 = BankAccount(50)

    account1.transfer(account2, 50)

    assert account1.balance == 50
    assert account2.balance == 100

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

اختبارات الأداء

تعد اختبارات الأداء Performance tests أحد الطرق الكمية لقياس المتطلبات غير الوظيفية non-functional requirements مثل قدرة تحمل التطبيق وسرعته في التحميل أو عدد المستخدمين الذين يستطيع التعامل معهم وغيرها من المعايير التي تساعدنا في تحديد حدود الاستخدام المناسبة للتطبيق وتحديد حاجتنا للموارد الحاسوبية من ذاكرة وصول عشوائي RAM أو CPU أو مساحة تخزين.

أنواع اختبارات الأداء Performance test

• اختبار الحمل Load test : يقيس أداء النظام تحت الظروف المتوقعة أو الطبيعية وسرعة الرد واستخدام الموارد

• اختبار الضغط Stress test : يختبر حدود النظام بتعريضه لحمل أكبر من المتوقع أو الطبيعي، لمعرفة مدى استقرار النظام ونقاط الفشل وقدرة النظام على التعافي

• اختبار الحمل المفاجئ Spike test : يختبر أداء النظام تحت حمل عالي ومفاجئ، ويختبر قدرته على التوسع السريع scale up والتعامل مع الضغط المفاجئ

اختبار الحمل في نظام إدارة مخزون

نفترض أن لدينا نظام إدارة مخزون Inventory بسيط يعمل من خلال واجهة تطبيق برمجية API مبنية بمكتبة FastAPI ويرتبط بقاعدة بيانات بسيطة من نوع Sqlite تحفظ العناصر وكميتها في جدول.

import sqlite3
from fastapi import FastAPI

app = FastAPI()

# تهيئة قاعدة البيانات
def init_db():
    conn = sqlite3.connect("inventory.db")
    cursor = conn.cursor()

    # إنشاء جدول البيانات إذا لم يكن موجودًا
    cursor.execute("CREATE TABLE IF NOT EXISTS inventory (id INTEGER PRIMARY KEY, name TEXT, quantity INTEGER)")

    # إضافة بيانات افتراضية إذا كانت الجدول فارغة
    cursor.execute("SELECT COUNT(*) FROM inventory")
    if cursor.fetchone()[0] == 0:
        sample_data = [
            ("Laptop", 10),
            ("Keyboard", 25),
            ("Mouse", 30),
            ("Monitor", 15)
        ]
        cursor.executemany("INSERT INTO inventory (name, quantity) VALUES (?, ?)", sample_data)
        conn.commit()

    conn.close()

init_db()  # تهيئة كائن قاعدة البيانات

# دالة لجلب العناصر الموجودة بالمخزون
@app.get("/inventory")
def get_inventory():
    conn = sqlite3.connect("inventory.db")
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM inventory")
    items = cursor.fetchall()
    conn.close()
    return {"inventory": items}

لتشغيل هذا التطبيق نكتب في الطرفية الأمر التالي :

uvicorn inventory_api:app --reload

بهذا تصبح واجهة التطبيق البرمجية API تعمل وجاهزة للاستخدام من خلال الرابط المحلي http://127.0.0.1:8000/inventory، أو الرابط http://127.0.0.1:8000/docs#/default/get_inventory_inventory_get الذي يسمح لنا بتجربة نقاط النهاية End-points للواجهة البرمجية API باستخدام واجهة صفحة ويب.

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

from locust import HttpUser, task, between

class InventoryUser(HttpUser):
    wait_time = between(1, 2)  # كل مستخدم ينتظر بين 1-2 ثانية بين الطلبات

    """ inventory محاكاة أكثر من مستخدم يتصل بنقطة النهاية """

    @task
    def load_test_inventory(self):
        ‫"""مستخدم افتراضي يقوم بطلب رابط inventory بشكل متكرر"""
        response = self.client.get("/inventory")
        if response.status_code != 200:
            response.failure("Failed to fetch inventory")

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

locust -f load_test.py --host=http://127.0.0.1:8000

سنحصل على الرابط التالي http://localhost:8089 لتجربة أداة الاختبار، حيث نجد عند فتح الصفحة بعض المدخلات التي نستطيع التحكم فيها، مثل عدد المستخدمين، وتزايد ذلك العدد في كل ثانية Ramp up حيث أن أداة الاختبار تضيف هذا العدد من المستخدمين كل ثانية حتى تصل لعدد المستخدمين الأقصى بشكل تدريجي، سنضبط عدد المستخدمين ليكون 1000 مستخدم، ومعدل تزايد المستخدمين ليكون 10 في الثانية.

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

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

وصلت نسبة الفشل إلى 88% حيث فشل 332008 طلب من أصل 377561، وكان متوسط سرعة الإجابة 174 ثانية، وهذا وقت طويل يدل أن النظام لم يستطع تحمل الزيادة في الحمل، كما نرى من الرسومات البيانية الموضحة بالأعلى أن النظام بدأ في التدهور عندما تجاوز عدد المستخدمين 50 ألف تقريبًا، هذه المعلومات تمكننا من تحسين كفاءة النظام تحت الضغط بإجراءات مثل تحجيم عدد الطلبات المسموح للمستخدم إرسالها في فترة زمنية محددة، واستخدام رتل Queue لتخزين الطلبات الفائضة عن سعة النظام لتعالج عندما يستطيع النظام استيعاب المزيد من الطلبات، فبدلًا من محاولة معالجة 100 ألف طلب نستطيع تخزين الطلبات في رتل Queue وندفع الطلبات للنظام على هيئة دفعات كل دفعة تتكون من 10000 طلب فقط.

خاتمة

تعرفنا في هذا المقال على كيفية استغلال قدرات أداة الذكاء الاصطناعي BlackBoxAI لتطبيق مبادئ اختبار البرامج Software testing بأنواعها المختلفة، مثل الاختبارات الوظيفية Functional testing كاختبار الوحدة Unit test واختبار الانحدار Regression test بالإضافة للاختبارات غير الوظيفية Non-functional testing التي تركز على اختبار أداء النظام وسرعة استجابته ونقاط الفشل المحتملة للنظام عن طريق محاكاة ظروف استخدام مختلفة، حيث استطعنا توليد الشيفرة المناسبة من خلال استخدام الموجهات Prompts المناسبة في BlackBoxAI وتحسينه حسب حاجتنا لذلك.

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

اقرأ أيضًا

• أفضل ممارسات هندسة المُوجِّهات Prompt Engineering: نصائح وحيل وأدوات

• اكتشف بدائل ChatGPT مفتوحة المصدر

• كيف ومتى نستخدم SQLite

• مدخل إلى الواجهات البرمجية API

• دمج مساعد الذكاء الاصطناعي GitHub Copilot مع محرر الأكواد VS Code

نسمع العديد من المصطلحات التي يخلط فيما بينها ضمن مجال الذكاء الاصطناعي Artificial Intelligence منها مصطلح تعلم الآلة Machine learning والتعلم العميق Deep learning، واللذان يعدان أساسيان في هذا المجال.

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

تعلم الآلة Machine learning

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

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

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

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

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

التعلم الموجه Supervised Learning

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

تنقسم الخوارزميات المستخدمة في التعلم الموجه لنوعين أساسيين بحسب نوع التنبؤات المطلوبة وهي:

التصنيف Classification لتقسيم البيانات إلى فئات كتصنيف رسائل البريد الإلكتروني إلى جيدة أو سيئة، ومن الخوارزميات المستخدمة فيه الانحدار اللوجستي Logistic Regression للتصنيف الثنائي، وأشجار القرار Decision Trees لتصنيف القرارات ونتائجها المحتملة

الانحدار Regression للتنبؤ بقيم رقمية، كسعر منتج معين أو درجة حرارة الطقس ومن الخوارزميات التي يستخدمها الانحدار الخطي Linear Regression والانحدار متعدد الحدود Polynomial Regression لاكتشاف العلاقة بين البيانات وتتوقع منها القيم للبيانات الجديدة

التعلم غير الموجه Unsupervised Learning

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

خوارزميات التجميع clustering وفيها يتم توزيع البيانات المتشابهة في مجموعات، كتصنيف زبائن متجر إلكتروني بحسب المشتريات او الاهتمامات، ومنها خوارزمية تجميع K-Means وخوارزمية التجميع الهيكلية Hierarchical Clustering

قاعدة الارتباط Association rule تستكشف العلاقات في البيانات وتستنتج منها قواعد شرطية تُعبّر عن وجود بيانات في حال وجود أخرى

تقليل الأبعاد Dimensionality Reduction تهدف لتقليل عدد المزايا أو المتغيرات في البيانات مع الحفاظ قدر الإمكان على المعلومات الموجودة في البيانات ومن خوارزمياتها تحليل مكون المبدأ Principal Component Analysis و التضمين المحلي الخطي Locally Linear Embedding

التعلم المعزز Reinforcement Learning

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

ويقسم إلى نوعين هما التعزيز الإيجابي Positive Reinforcement والذي يكافئ الأفعال التي تؤدي لحدث ما والتعزيز السلبي Negative Reinforcement والذي يكافئ الأفعال التي تسبب تجنب حدث ما.

التعلم العميق Deep learning

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

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

تُصنف طرق التعلم العميق ضمن الأنواع الثلاثة لتعلم الآلة التي ذكرناها سابقًا، ولكنها تتفوق بتنفيذها في التطبيقات المعقدة، مثل استخدامها لخوارزميات التصنيف Classification والانحدار Regression في التعلم الموجه، واستخدام التجميع Clustering في التعلم غير الموجه، وقدرته الممتازة في التفاعل ضمن البيئات الافتراضية في التعلم المعزز.

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

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

الفرق بين تعلم الآلة والتعلم العميق

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

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

خلاصة

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

اقرأ أيضًا

• الذكاء الاصطناعي: دليلك الشامل
• كتاب مدخل إلى الذكاء الاصطناعي وتعلم الآلة
• المفاهيم الأساسية للذكاء الاصطناعي
• كل ما تود معرفته عن دراسة الذكاء الاصطناعي

تُعدُّ الشبكات العصبية Neural Networks نموذجًا حاسوبيًا مستوحى من الدماغ البشري يحلل البيانات ويتعلم منها بعدة طرق، كالتعلم العميق الذي يمكنك الاطلاع عليه أكثر من مقال دليل المبتدئين لفهم أساسيات التعلم العميق، ومن فروعها الشبكات العصبية الالتفافية Convolutional Neural Networks - CNNs، المصممة لاستخراج المزايا والتعرف على الكائنات من البيانات، وتستخدم خصيصًا في مجال تصنيف الصور وتحليل محتوياتها.

تُمثَّل بيانات الإدخال input data لمعظم الشبكات العصبية بمصفوفة matrix شكلها يعتمد على نوع البيانات، فمثلًا يمكن تمثيل الصور بمصفوفة أبعادها هي الطول حجمه يساوي طول الصورة، والعرض حجمه يساوي عرض الصورة، واللون لكل بكسل pixel في الصورة يتألف من ثلاث ألوان الأحمر والأخضر والأزرق RGB أي حجمه يساوي 3، فيمكن تمثيل الصورة بمصفوفة ثلاثية الأبعاد حجمها الطول×العرض×3.

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

أنواع وترتيب طبقات الشبكات الالتفافية

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

1. الطبقة الالتفافية Convolutional layer
2. طبقة التجميع Pooling layer
3. الطبقة المتصلة كليًا Fully connected layer

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

الطبقة الالتفافية Convolutional layer

هي أساس الشبكات العصبية الالتفافية تحوّل مصفوفة البيانات المدخلة إليها إلى مصفوفة جديدة تعبّر عن المزايا الموجودة ضمنها، حيث تستخدم المُرشّح filter ويسمى أيضًا النواة kernal أو كاشف الميزة feature detector والذي يكون حجمه صغيرًا للالتفاف -لذا سُميت الطبقة بالالتفافية- على أجزاء من مصفوفة الدخل، وفي كل خطوة تُطبّق عملية الضرب النقطي dot product بين المرشح وجزء من مصفوفة الدخل لينتج عنها مصفوفة جديدة تدعى خارطة الميزة feature map أو خارطة التفعيل activation map أو الميزة المُلتفة convolved feature.

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

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

شكل مصفوفة المٌرشح Filter matrix

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

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

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

• الحشو الصحيح Valid padding بتجاهل عمليات المسح النهائية التي لا تتناسب بالحجم
• الحشو المماثل Same padding بإضافة أصفار لحواف مصفوفة المرشح ليكون حجم مصفوفة الخرج مساويًا لحجم مصفوفة بيانات الإدخال
• الحشو الكلي Full padding بإضافة أصفار في حواف مصفوفة البيانات لزيادة حجم مصفوفة الخرج

طبقة التجميع Pooling layer

وظيفتها تقليل أبعاد وشكل المصفوفة الداخلة إليها، وطريقة عملها تشبه طبقة الالتفاف، بتمرير مرشح على المصفوفة المدخلة إليها.

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

• التجميع الأعظمي Max pooling يُختار فيه أعلى القيم
• التجميع الوسطي Average pooling يُحسب فيه وسطي القيم

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

الطبقة المتصلة كليًا Fully connected layer

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

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

تطبيقات الشبكات العصبية الالتفافية

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

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

خلاصة

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

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

اقرأ أيضًا

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

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

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

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

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

آلية عمل خوارزمية التوصية في منصة تيكتوك

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

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

تهيئة بيئة العمل لبناء نظام توصية شبيه بنظام توصية تيكتوك

تعتمد خوارزميات تيكتوك كثيرًا على لغة البرمجة بايثون Python، خاصةً في تقنيات الذكاء الاصطناعي والتعلم الآلي لتطوير خوارزمياتها، بالإضافة إلى لغات برمجية أخرى مثل ++C و Java و Go.

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

• مكتبة pandas: لقراءة ومعالجة البيانات
• إطار العمل scikit-learn: لتحويل البيانات النصية إلى شكل يمكن لنموذج التوصية التعامل معه.
• قاعدة البيانات التي سنعمل على أساسها بهذا المقال

نثبت المكتبات وأطر العمل التي نحتاجها على النحو الآتي:

pip install pandas scikit-learn

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

سنطلب الآن قراءة البيانات وتحميلها من قاعدة البيانات المستخدمة وطباعة أول خمس صفوف منها باستخدام مكتبة Pandas.

    import pandas as pd  #DataFrames للتعامل مع البيانات وتحليلها باستخدام

    رابط ملف البيانات لتيكتوك بصيغة خام (raw) من GitHub #
    ratings_url = "https://raw.githubusercontent.com/Peter-Lankton/tik-tok-data/main/tik_tok_analytics.csv"
    ratings = pd.read_csv(ratings_url)
   عرض أول خمس صفوف من البيانات للتحقق من التحميل بنجاح #
    print(ratings.head())

وكما نلاحظ تتم قراءة خمس صفوف من قاعدة البيانات على النحو الآتي:

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

ستظهر لنا التعليمة التالية عدد الأعمدة و عدد الصفوف، بالاضافة الى نوع كل عمود و عدد القيم غير الفارغة:

ratings.info()

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

    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 102 entries, 0 to 101
    Data columns (total 17 columns):
    #   Column        Non-Null Count  Dtype  
    ---  ------        --------------  -----  
    0   Video_Name    102 non-null    object 
    1   Tech          101 non-null    float64
    2   Upload_time   102 non-null    int64  
    3   Day           102 non-null    int64  
    4   Q_and_A       102 non-null    int64  
    5   has_captions  102 non-null    int64  
    6   Views         102 non-null    int64  
    7   Shares        101 non-null    float64
    8   Comments      102 non-null    int64  
    9   Likes         102 non-null    int64  
    10  Hashtags      83 non-null     object 
    11  Cover         102 non-null    int64  
    12  Length        102 non-null    int64  
    13  avg_watch     102 non-null    int64  
    14  Location      101 non-null    float64
    15  Humor         101 non-null    float64
    16  Hat           100 non-null    float64
    dtypes: float64(5), int64(10), object(2)
    memory usage: 13.7+ KB

معالجة البيانات

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

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

# حساب عدد القيم المكررة في العمود
ratings.duplicated(subset='Video_Name').sum() # 11

# إزالة التكرار
df = ratings.drop_duplicates(subset='Video_Name')

# التأكد من إزالة التكرار
df.duplicated(subset='Video_Name').sum() # 0

أخذ عينات عشوائية

بعد التأكد من إزالة التكرارات، سنعمل على حل المشاكل التي قد تقع بها الذاكرة، وسنعمل على أخذ عينات عشوائية على النحو التالي:

sample_size = 91  # عدد البيانات في الصفوف
# أخذ العينة
df = df.sample(n=sample_size, replace=False, random_state=80)

# إعادة ضبط الفهرس
df = df.reset_index()

# إزالة عمود 'index' الناتج من reset_index()
df = df.drop('index', axis=1)

تنظيف البيانات

ستحتاج البيانات الموجودة بقاعدة البيانات المستخدمة في هذه المرحلة الى التنظيف، ويكون ذلك من خلال ازالة المسافات البيضاء من عمود Video_Name لتجنب حدوث الأخطاء، إذ لو اعتمدنا التسمية العادية دون تنظيف، فقد يتسبب هذا بالحصول على نظام أقل دقة وصحة؛ فقد يعد الفيديو ?strong math for ml مثلًا و الفيديو strong opinion متشابهين.

توضح الصورة التوضيحية التالية مثالًا عن ازالة المسافات البيضاء من أسماء الفيديوهات:

وسنتتبع هنا كل مرحلة من مراحل تنظيف قاعدة البيانات، لتشمل كل أسماء الفيديوهات كما هو موضح في الكود كالتالي:

def clean_Video_Name(Video_Name):
  result = str(Video_Name).lower() # تحويل النص إلى حروف صغيرة (lowercase)
  return(result.replace(' ','')) # إزالة المسافات من النص

  df['Video_Name'] = df['Video_Name'].apply(clean_Video_Name) # يتم تطبيق التنظيف على كل قيمة في العمود باستخدام الدالة "clean_Video_Name"
  df.head()

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

نحوّل الآن بيانات اسم الفيديو والوسوم إلى أحرف صغيرة:

# تحويل جميع القيم في عمود "Video_Name" إلى حروف صغيرة (lowercase)
df['Video_Name'] = df['Video_Name'].str.lower()

# تحويل جميع القيم في عمود "Hashtags" إلى حروف صغيرة (lowercase)
df['Hashtags'] = df['Hashtags'].str.lower()

# عرض أول خمس صفوف من DataFrame للتحقق من التغييرات
df.head()

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

# حذف الأعمدة غير المطلوبة
df2 = df.drop(['Tech', 'Upload_time', 'Day', 'Q_and_A', 'has_captions', 
            'Views', 'Shares', 'Comments', 'Likes', 'Cover', 'Length', 
            'avg_watch', 'Location', 'Humor', 'Hat'], axis=1)

# تحقق من الأعمدة المتبقية
print(df2.columns)
print(df2.head())

# دمج النصوص في الأعمدة المتبقية
df2['Data'] = df2[df2.columns[1:]].apply(
    lambda x: ' '.join(x.dropna().astype(str)),
    axis=1
)

# عرض النتيجة
    print(df2['Data'].head())

وستكون النتيجة كالتالي:

تحويل أطر البيانات Dataframe إلى تمثيلات عددية

من أجل تحويل النصوص إلى تمثيلات عددية تعبر عن تكرار الكلمات في مجموعة النصوص من أجل تسهيل فهم النصوص وتحليلها بدقة من طرف النموذج، سوف نستخدم دالة ()CountVectorizer من مكتبة Scikit-Learn كالتالي:

# استيراد CountVectorizer من مكتبة sklearn لتحويل النصوص إلى تمثيل عددي
from sklearn.feature_extraction.text import CountVectorizer

# إنشاء كائن CountVectorizer لتحويل النصوص إلى متجهات تمثل تكرار الكلمات
vectorizer = CountVectorizer()

# تطبيق fit_transform على عمود 'Data' في DataFrame df2  لتحويل النصوص إلى تمثيل عددي
# fit_transform تقوم بتدريب CountVectorizer على البيانات وتحويل النصوص إلى مصفوفة من التكرارات
vectorized = vectorizer.fit_transform(df2['Data'])

حساب تشابه الفيديوهات لبناء نظام التوصية

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

بمعنى آخر، يمكننا استخدام تشابه جيب التمام لقياس مدى تشابه الفيديوهات من خلال مقارنة تمثيل البيانات. اسم الفيديو والوسم.

# استيراد cosine_similarity من مكتبة sklearn  لحساب التشابه بين المتجهات باستخدام مقياس جيب التمام
from sklearn.metrics.pairwise import cosine_similarity

# حساب التشابه بين المتجهات التي تم إنشاؤها باستخدام CountVectorizer
# سيتم حساب تشابه جيب التمام بين كل زوج من المتجهات
similarities = cosine_similarity(vectorized)

# طباعة مصفوفة التشابه بين الفيديوهات أو النصوص
print(similarities)

نلاحظ النتيجة كالتالي :

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

ملاحظة : متجه التشابه هو تمثيل عددي يعبّر عن مدى التشابه بين كل فيديو وآخر. يتم حسابه باستخدام دالة Cosine Similarity، بحيث تكون كل قيمة في المتجه مؤشرًا على درجة القرب بين الفيديوهات بناءً على اسم الفيديو والوسم.

# تحويل مصفوفة التشابه إلى DataFrame باستخدام pandas
# نقوم بتحديد الأعمدة على أنها أسماء الفيديوهات (من العمود 'Video_Name')، والصفوف على أنها الوسوم (من العمود #'Hashtags')
df = pd.DataFrame(similarities, columns=df['Video_Name'], index=df['Hashtags']).reset_index()

# عرض أول 5 صفوف من DataFrame لتفقد النتيجة
df.head()

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

نلاحظ أيضًا أن الخط القطري يساوي دائمًا 1.000، وهو يعرض تشابه كل فيديو مع نفسه.

عرض التوصية للمستخدم

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

# إذا كانت لديك مصفوفة التشابه 'similarities' وبيانات الفيديو 'df2'
similarities_df = pd.DataFrame(
    similarities, 
    index=df2['Video_Name'], 
    columns=df2['Video_Name']
)

# دالة للحصول على التوصيات بناءً على الفيديو المدخل
def get_recommendations(video_name, top_n=5):
    if video_name in similarities_df.columns:
        recommendations = (
            similarities_df[video_name]
            .nlargest(top_n + 1)   # الحصول على أفضل N+1 (بما في ذلك الفيديو نفسه)
            .iloc[1:]   # إرجاع أسماء الفيديوهات الموصى بها
        )
        return recommendations.index.tolist()  
    else:
        return f"'{video_name}' not found in the video list."

# مثال للاستخدام
input_video = 'strongopinionk8s' # نستبدله بالفيديو الذي نرغب في الحصول على التوصيات بناءً عليه
recommended_videos = get_recommendations(input_video, top_n=5)

print("Recommended videos:")
print(recommended_videos)

وهنا سنلاحظ النتيجة المتمثلة في أحسن خمس فيديوهات مقترحة:

Recommended videos:
['housefoundation', 'showinghowresucanworks', 'recommendeddatacourses', 'softwareengineering?', 'firstdataanalyticshw']

الخاتمة

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

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

المصادر

• tik-tok-data
• TikTok Algorithm with Machine Learning
• Recommendation System in Python
• Understanding Social Media Recommendation Algorithms
• TikTokData

اقرأ أيضًا

• التمثيل المرئي للبيانات باستخدام Scikit-Learn مع Matplotlib و Seaborn
• خوارزميات الذكاء الاصطناعي
• التفاعل مع رسائل WhatsApp باستخدام الذكاء الاصطناعي

تعرفنا في المقال السابق على خوارزمية أقرب الجيران K-Nearest Neighbors، ووضحنا كيفية استخدامها عمليًا من خلال تمارين وتطبيقات متنوعة، وسنشرح اليوم خوارزمية أساسية من خوارزميات الذكاء الاصطناعي وهي خوارزمية الانحدار اللوجيستي Logistic Regression مع تطبيقات عملية باستخدام مكتبة ساي كيت ليرن ومجموعة بيانات أزهار آيرس Iris dataset.

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

مفهوم الانحدار اللوجيستي

تحليل الانحدار regression analysis هو أداة إحصائية مفيدة لفهم العلاقة بين متغيرات مختلفة، يساعدنا على تخمين أو توقع كيف يؤثر شيء ما يسمى المتغير المستقل independent variable على شيء آخر يسمى المتغير المعتمد dependent variable. مثلًا يمكننا معرفة كيف يؤثر عدد ساعات الدراسة على درجات الطلاب في الامتحان من خلال تحليل الانحدار واكتشاف العلاقة بين هذين المتغيرين وتحديد إن كان عدد الساعات يؤثر فعلاً في الدرجات أم لا، وفي  مجموعة بيانات  أزهار آيرس يمكننا استخدامه لاستكشاف العلاقة بين طول السبلة Sepal length وعرض البتلة Petal width على سبيل المثال.

هناك نوع خاص من الانحدار يطلق عليه اسم الانحدار اللوجيستي Logistic Regression نستخدمه عندما نريد التنبؤ بنتيجة تصنيف ثنائي binary classification نتيجته إما نعم أو لا، حيث تستخدم خوارزمية الانحدار اللوجيستي logistic regression دالة سينية sigmoid function تسمى بالدالة اللوجيستية logistic function والتي تحوّل المدخلات إلى قيم تقع بين الصفر والواحد مما يجعلها مناسبة لمهام التصنيف الثنائي.

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

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

يمكننا كذلك استخدام خوارزمية الانحدار اللوجيستي مع مشكلات التصنيف المتعدد multi classification باستخدام خدعة بسيطة تسمى واحد ضد الجميع One Vs All والتي تعرف اختصارًا OVA، حيث نعمل على تدريب عدد من المصنفات الثنائية binary classifiers يساوي عدد التصنيفات classes الموجودة في البيانات، وتكون مهمة كل مصنف classifier التمييز بين تصنيف محدد ونرمز له رقميًا بواحد 1 وما دون ذلك من التصنيفات نرمز لها جميعًا بصفر 0.

يمكننا في مكتبة scikit-learn، استخدام خوارزمية الانحدار اللوجستي لمهام التصنيف المتعدد باستخدام الدالة softmax التي تحدد احتمالية انتماء كل عينة إلى إحدى التصنيفات المتعددة، بحيث يكون مجموع الاحتمالات لجميع التصنيفات classes  مساويًا لواحد، بينما نستخدم الدالة sigmoid في مهام التصنيف الثنائي فقط.

استكشاف مجموعة البيانات Data Exploring

سنكتب برنامج بايثون لعرض المعلومات الإحصائية الأساسية لفصائل أزهار آيرس المختلفة Iris-setosa و Iris-versicolor و Iris-virginica على النحو التالي:

import pandas as pd

iris = pd.read_csv("iris.csv")
# قائمة بجميع الفصائل
SpeciesList = iris.Species.value_counts().index
# حلقة تكرارية لحساب الإحصائيات لكل فصيلة
for s in SpeciesList:
    print(f"Statistics about {s}")
    # حساب الإحصائيات لشريحة البيانات التي تنتمي للفصيلة الحالية
    print(iris[iris.Species == s].describe())

يعمل الكود السابق على توليد إحصائيات وصفية لكل فصيلة من فصائل الأزهار الموجودة في المجموعة. حيث يسمح لنا الشرط [iris[iris.Species == s باختيار العينات التي تحقق هذا الشرط، أي أننا سنختار في كل تكرار للحلقة العينات التي تنتمي للفصيلة s ثم سنستخدام التابع data.describe()‎ للحصول على معلومات إحصائية تخص هذه العينات، مثل أكبر وأصغر قيمة في البيانات والمتوسط الحسابي للقيم والانحراف المعياري.

عند تنفيذ الكود سنحصل على الخرج التالي:

Statistics about Iris-setosa
             Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm
count  50.00000       50.00000     50.000000      50.000000      50.00000
mean   25.50000        5.00600      3.418000       1.464000       0.24400
std    14.57738        0.35249      0.381024       0.173511       0.10721
min     1.00000        4.30000      2.300000       1.000000       0.10000
25%    13.25000        4.80000      3.125000       1.400000       0.20000
50%    25.50000        5.00000      3.400000       1.500000       0.20000
75%    37.75000        5.20000      3.675000       1.575000       0.30000
max    50.00000        5.80000      4.400000       1.900000       0.60000
Statistics about Iris-versicolor
              Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm
count   50.00000      50.000000     50.000000      50.000000     50.000000
mean    75.50000       5.936000      2.770000       4.260000      1.326000
std     14.57738       0.516171      0.313798       0.469911      0.197753
min     51.00000       4.900000      2.000000       3.000000      1.000000
25%     63.25000       5.600000      2.525000       4.000000      1.200000
50%     75.50000       5.900000      2.800000       4.350000      1.300000
75%     87.75000       6.300000      3.000000       4.600000      1.500000
max    100.00000       7.000000      3.400000       5.100000      1.800000
Statistics about Iris-virginica
              Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm
count   50.00000       50.00000     50.000000      50.000000      50.00000
mean   125.50000        6.58800      2.974000       5.552000       2.02600
std     14.57738        0.63588      0.322497       0.551895       0.27465
min    101.00000        4.90000      2.200000       4.500000       1.40000
25%    113.25000        6.22500      2.800000       5.100000       1.80000
50%    125.50000        6.50000      3.000000       5.550000       2.00000
75%    137.75000        6.90000      3.175000       5.875000       2.30000
max    150.00000        7.90000      3.800000       6.900000       2.50000
Index(['Id', 'SepalLengthCm', 'SepalWidth

عرض العلاقة بين البيانات باستخدام التمثيل المرئي Data Visualization

سننشئ الآن رسم بياني نقطي Scatter plot لعرض العلاقة بين طول السبلة Sepal length وعرض البتلة Petal width، لنحقق ذلك نكتب الكود التالي:

import matplotlib.pyplot as plt
import seaborn as sns

iris = pd.read_csv("iris.csv")
plt.figure(figsize=(7,7), dpi=150)
sns.scatterplot(data=iris, x="SepalLengthCm", y="PetalWidthCm", hue="Species")
plt.show()

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

بعدها مررنا للدالة sns.scatterplot المعامل data لتحديد مجموعة البيانات التي سنعمل عليها، وحددنا بأن المحور الأفقي سيكون طول السبلات، وأن المحور العمودي سيكون عرض البتلات، ستمثل كل زهرة بنقطة في الشكل الناتج وتلون كل نقطة وفقًا لانتمائها لأحد الفصائل الثلاثة في مجموعة بيانات أزهار آيرس.

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

تصنيف فصائل الأزهار باستخدام خوارزمية الانحدار اللوجستي

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

import pandas as pd
from sklearn.model_selection import train_test_split  
from sklearn import metrics
from sklearn.linear_model import LogisticRegression

iris = pd.read_csv("iris.csv")
# Id احذف عمود 
# لعدم أهميته في عملية التعلم
iris = iris.drop('Id',axis=1)
# خواص الأزهار
X = iris.iloc[:, :-1].values
# وسم الأزهار
y = iris.iloc[:, 4].values

# تقسيم مجموعة البيانات إلى مجموعة بيانات تدريب ومجموعة بيانات اختبار 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20) 

# إنشاء نموذج 
model = LogisticRegression(random_state=0, multi_class='multinomial')
model.fit(X_train,y_train)
prediction=model.predict(X_test)
print('The accuracy of the Logistic Regression is', metrics.accuracy_score(prediction,y_test))

استوردنا في البداية عددًا من الدوال والمكتبات التي ستساعدنا في تدريب وتقييم النموذج، واستدعينا الدالة train_test_split لتقسم خاصيات مجموعة البيانات dataset features ووسوم البيانات dataset labels إلى مجموعتي تدريب واختبار كل منها يمتلك جزءًا من خاصيات مجموعة البيانات والوسوم المقابلة للعينات المختارة، وحددنا نسبة التقسيم باستخدام التعليمة test_size=0.20 لجعل عشرين بالمائة من مجموعة البيانات مجموعة اختبار، والنسبة الباقية للتدريب، ستُقسَم البيانات بشكل عشوائي في كل مرة نشغل بها الكود، ثم عرفنا كائن model يطبق خوارزمية الانحدار اللوجيستي ومررنا له المتغير random_state=0 لنضمن ثبات نتيجة تدريب النموذج عند تشغيل الكود أكثر من مرة، وحددنا نوع المشكلة بأنه تصنيف متعدد بضبط قيمة المعامل multi_class إلى multinomial.

بعد أن هيئنا إعدادات النموذج سندربه على مجموعة بيانات التدريب باستخدام الدالة model.fit(X_train,y_train)‎، وبعد تدريب النموذج يمكننا استخدامه في تخمين الوسوم لمجموعة الاختبار باستخدام الدالة model.predict(X_test)‎. نخزن الناتج في القائمة prediction التي تحتوي محاولة النموذج لتوقع قيم y_test، ولتقييم دقة النموذج في هذه المحاولة نستخدم الدالة metrics.accuracy_score(prediction,y_test)‎ التي تحصي نسبة القيم التي توقعها النموذج بشكل صحيح إلى إجمالي جميع القيم.

عند تنفيذ الكود سنحصل على الخرج التالي:

The accuracy of the Logistic Regression is 0.9333333333333333

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

الخاتمة

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

اقرأ أيضًا

• المقال السابق: استخدام خوارزمية أقرب الجيران k-Nearest Neighbors في Scikit-Learn
• تعرف على مكتبة Scikit learn وأهم خوارزمياتها
• الانحدار الإحصائي regression ودوره في ملاءمة النماذج المختلفة مع أنواع البيانات المتاحة
• العلاقات بين المتغيرات الإحصائية وكيفية تنفيذها في بايثون

تخيل أن أمامك كومةً ضخمةً من ملفات PDF، وأنك بحاجة إلى إجابة سريعة على سؤال محدد. البحث اليدوي قد يستغرق ساعات، ولكن ماذا لو كان بالإمكان طرح سؤال على الآلة والحصول على إجابة دقيقة في ثوانٍ؟ أو ربما الحصول على تلخيص نصوص طويلة بلمسة زر واحدة؟

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

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

فكرة المشروع الذي تحتويه المقالة

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

سنعتمد في العمل على النظام على DeepSeek لاسترجاع المعلومات من الكتاب بدقة، بينما يُستخدم Ollama لإنشاء ردود ذكية قائمة على السياق المسترجع.

مع ذلك هناك أمر مهم جدًا يجب توضيحه، رغم قوة DeepSeek-R1 الذي سنستخدمه في المقال مع اللغات الأجنبية، إلا أنه وللأسف لا يقدم أداءً مثاليًا مع اللغة العربية بسبب محدودية التدريب على النصوص العربية مقارنةً باللغات الأخرى مثل الإنجليزية. ولحل هذه المشكلة، تطلب منا الأمر استخدام نماذج أكبر مثل DeepSeek R1-70B للحصول على النتائج الدقيقة عالية الجودة التي ستجدها بالمقال، لكن تطبيقك لشبيه به، سيعتمد على توفر موارد حاسوبية كافية؛ أما في حال لم تكن هذه الموارد متاحة، فيمكن الاستفادة من نفس الطريقة لتطبيق النظام على نماذج أخرى تدعم اللغة العربية بكفاءة أكبر مثل Qwen، أو استخدامه مع لغات أخرى مثل الإنجليزية التي تتمتع بدعم أفضل.

خطوات العمل على المشروع

يعتمد مشروعنا على دمج مرحلتين أساسيتين:

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

تحضير بيئة العمل على المشروع

من أجل تنفيذ هذا المشروع، سنحتاج إلى الأدوات الآتية:

تحميل مكتبات وأطر عمل لغة بايثون المطلوبة

سنستعمل في نظامنا المكتبات التالية:

• مكتبة HuggingFace Embeddings: وهي المكتبة المسئولة عن البصمات الرقمية للنصوص، حجمها خفيف وتلائم الأجهزة الضعيفة نسبيًا
• مكتبة PyPDFLoader: وهي المكتبة المسئولة عن التعامل مع ملفات PDF، سريعة المعالجة ولا تستهلك الكثير من الوقت
• مكتبة Faiss: وهي المكتبة المسئولة عن إنشاء قاعدة بيانات تخزن فيها المعلومات واسترجاعها عند الحاجة، وهي أشهر مكتبة حاليا

وسنستعمل أطر العمل Frameworks التالية:

• إطار العمل Langchain: وهو البيئة المسئولة عن بناء تطبيقات الذكاء الاصطناعي المتكاملة
• إطار العمل Streamlit: المسئول عن توفير واجهة ويب تفاعلية لعرض النتائج بوضوح، نستعملها لبساطتها ولأنها توفر في ذاكرة الوصول العشوائي RAM

إذا كنا نستعمل مثبّت conda أو mini-conda، فيمكننا تثبيت المكتبات والأطر المطلوبة عبر سطر الأوامر Terminal مباشرةً على النحو الآتي:

# تثبيت المكتبات وأطر العمل التي نحتاجها للعمل عبر مثبِّت conda
conda install -c conda-forge streamlit pdfplumber langchain faiss-cpu sentence-transformers pytorch huggingface_hub -y pip install langchain-community langchain-huggingface langchain-ollama arabic-support

أما إذا كنا نستخدم pip، فيمكن تثبيت المكتبات والأطر المشار المطلوبة عبر سطر الأوامر على النحو الآتي:

# تثبيت المكتبات وأطر العمل التي نحتاجها عبر مثبِّت pip
pip install streamlit pdfplumber langchain langchain-community langchain-huggingface langchain-ollama faiss-cpu sentence-transformers torch huggingface_hub arabic-support

تحميل Ollama و DeepSeek

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

بعد ذلك نضغط على خيار DeepSeek-R1 من نفس الواجهة ونختار النموذج المناسب لنا، وننسخ إعداداته التي نحتاجها لمقالنا من أجل تحميل DeepSeek، وهي في هذا المقال على النحو الآتي:

ollama pull deepseek-r1:70b

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

بدء كتابة كود المشروع

سنكتب الكود الآن بتدرج، وأول ما سنفعله هو استدعاء المكتبات والأُطر التي سنحتاجها، والتي سبق وثبتناها مع بداية المقال.

# استدعاء المكتبات والأُطر التي سنحتاجها
import tempfile
import re
import streamlit as st
from langchain_community.document_loaders import PDFPlumberLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_ollama import OllamaLLM
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

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

# تهيئة الواجهة لتتوافق مع اللغة العربية
from arabic_support import support_arabic_text
support_arabic_text(all=True)

بعد ذلك سنتبع ما يلي.

تهيئة الكتاب لإسترجاع المعلومات

من أجل استرجاع المعلومات ذات الصلة من ملف الكتاب، سنحتاج لاتّباع الخطوات الآتية:

• تحميل المستند: بحيث يتم رفع ملف PDF وتحميل محتوياته باستخدام PDFPlumberLoader لسرعته في القراءة
• تقسيم النصوص: حيث تُجزَّأ المحتويات إلى مقاطع باستخدام أداة RecursiveCharacterTextSplitter لنحافظ على السياق ونحسن دقة البحث
• إرسال البيانات الى مكتبة HuggingFaceEmbeddings: وذلك لانشاء البصمات للنصوص لتُخزن في قاعدة البيانات FAISS

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

ويكون الكود المكتوب على النحو الآتي:

 # تحميل وقراءة محتوى الملف 
docs = PDFPlumberLoader(temp_pdf_path).load()

# تحويل الكتاب إلى نصوص حاسوبية يمكنه فهمها والبحث فيها بكفاءة
embedder = HuggingFaceEmbeddings(model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")

chunk_size = max(500, min(1000, len(docs) // 10)) # تحديد حجم المقطع حسب طول المستند  
documents = RecursiveCharacterTextSplitter(
   chunk_size=chunk_size,   # تحديد حجم كل مقطع نصي
   chunk_overlap=chunk_size // 5   # السماح بتداخل بين المقاطع بنسبة 20% للحفاظ على السياق
).split_documents(docs) تنفيذ عملية التقسيم على المستند المحمّل

# انشاء مخزن البيانات ووضع البيانات التي استخرجت من الكتاب في المخزن الخاص بالنظام   
retriever = FAISS.from_documents(documents, embedder).as_retriever(search_kwargs={"k": 4})

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

توليد الإجابات النهائية من ملف الكتاب

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

• تهيئة نموذج اللغة في الكود: حيث يتم استخدام OllamaLLM وضبط DeepSeek R1 ليكون المصدر الأساسي للإجابة على الأسئلة.
• إعداد الأوامر Prompt Engineering: حيث يتم تصميم إنشاء قالب تعليمات باستخدام PromptTemplate لتوجيه النموذج حول كيفية الإجابة عند البحث في محتوى الكتاب
• انشاء سلسلة معالجة الإجابات: عن طريق دمج نموذج LLM مع تنقية FAISS Retriever لنضمن توليد النموذج الإجابات بناءً على المعلومات المسترجعة فقط، وهذا يوفر دقة الإجابات ويقلل احتمالية توليد معلومات غير صحيحة

# تهيئة نموذج اللغة
llm = OllamaLLM(model="deepseek-r1:70b") 

# إعداد الأوامر، تعريف الأوامر التي يتبعها النظام أثناء البحث في الكتاب    
template = """
    Use the following context to answer the question concisely in 3-4 sentences.
    If the answer is unknown, respond with "I don't know" without making anything up.
    Answer in Arabic if the given question is in Arabic.     
    Context: {context}  
    Question: {question}  
    Answer:
            """
rag_chain = (
                {"context": retriever, "question": RunnablePassthrough()} # تمرير السياق والسؤال 
                | PromptTemplate.from_template(template) # تجهيز السؤال بالتنسيق المطلوب
                | llm # إرسال البيانات إلى نموذج اللغة لمعالجتها
                | StrOutputParser() # استخراج الإجابة بصيغة نصية
            )

حتى هذه العملية تم توليد الإجابه بناءً على المعلومات المسترجعة.

انشاء واجهة الويب

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

# إعداد واجهة التطبيق
st.markdown("<h2 style='text-align: right;'>Ollama و Deepseek بإستخدام Pdf البحث ضمن ملف</h2>", unsafe_allow_html=True)

uploaded_file = st.file_uploader("Pdf رفع ملف", type="pdf")
if uploaded_file is not None:
     with st.spinner("..جاري المعالجة"):
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
             temp_pdf.write(uploaded_file.getvalue())             
             temp_pdf_path = temp_pdf.name

# إدخال المستخدم للسؤال
st.markdown(f'<div style="direction: rtl; font-size: 16px; font-weight: bold;">أدخل سؤالك هنا..</div>', unsafe_allow_html=True)
user_input = st.text_input(" ", key="user_question", label_visibility="hidden")

تحسين المخرجات

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

ولتسهيل العملية استخدمنا تعبير نمطي Regular Expression للبحث عن أي نص موجود بين العلامتين <think> و </think> داخل الإجابة في سطر cleaned_response، ثم يٌحذف لضمان عرض المحتوى النهائي فقط. بعد ذلك، يتم تنظيف النص وإزالة أي فراغات زائدة باستخدام .strip().

# معالجة إدخال المستخدم
if user_input:
    with st.spinner("..جاري البحث"):
        response = rag_chain.invoke(user_input) # استرجاع البيانات ثم توليد الإجابة
    cleaned_response = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
        st.markdown("### Answer:")
        st.write(cleaned_response)  # عرض الإجابة النهائية
else:
       st.info("Pdf من فضلك قم برفع ملف")

ولنفتح واجهة الويب، لا بد من كتابة الأمر التالي في Terminal الخاص بالبرنامج:

# فتح واجهة الويب
streamlit run Project.py  

ملاحظة: سنغير كلمة Project بناءً على اسم الملف.

اختبار كفاءة النظام

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

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

في حال عدم توفر الموارد يمكن استعمال النظام باللغة الإنجليزية مثلًا، وبكل بسهولة عن طريق استعمال نموذج لغة أصغر مثل Deepseek R1-7b، عن طريق تحميله عبر سطر الأوامر Terminal: ollama pull deepseek-r1

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

# تهيئة نموذج اللغة
llm = OllamaLLM(model="deepseek-r1") 

ثم نحذف الجزء المتعلق بتهيئة واجهة اللغة العربية من الكود وتصبح هذه هي النتيجة:

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

خاتمة

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

المصادر

• ?What is RAG (Retrieval-Augmented Generation)
• Developing Retrieval Augmented Generation (RAG) based LLM Systems
• How to build a RAG Using Langchain, Ollama, and Streamlit
• Building RAG-based LLM Applications
• Streamlit Arabic Support

اقرأ أيضًا

• استكشف مصطلحات الذكاء الاصطناعي التوليدي
• تشغيل Deepseek محليا على محرر الأكواد VS Code
• التفاعل مع رسائل WhatsApp باستخدام الذكاء الاصطناعي
• كيفية ربط بوت تلغرام مع جداول بيانات Google Sheets
• العمل مع مستندات PDF ومستندات Word باستخدام بايثون

في هذا المقال من سلسلة تطبيقات عملية على استخدام مكتبة ساي كيت ليرن سنستعرض خطوة بخطوة كيفية تطبيق واحدة من أشهر خوارزميات تعلم الآلة وهي خوارزمية أقرب الجيران k-Nearest Neighbors  -أو KNN اختصارًا- لتصنيف الأنواع المختلفة من الأزهار الموجودة ضمن مجموعة بيانات آيرس Iris dataset إحدى أكثر مجموعات البيانات استخدامًا في مجال تعلم الآلة والتي تعرفنا عليها في مقال سابق بعنوان أساسيات تحليل البيانات باستخدام Scikit-Learn.

آلية عمل خوارزمية k-Nearest Neighbors

يمكننا تعريف خوارزمية أقرب جار  K-Nearest Neighbors على أنها خوارزمية لا معاملية non-parametric بمعنى أنها لا تملك أوزان أو معاملات تحاول تحسينها كما تتبع خوارزميات ذكاء اصطناعي أخرى، فهي تستخدم في مهام التصنيف Classification وتوقع الانحدار Regression، وفي كلا الحالتين تعتمد على المعلومات المتاحة لدى أقرب k من النقاط المجاورة لمجموعة بيانات التدريب، وتختلف طريقة حساب المخرجات حسب مهمة التعلم.

في حالة التصنيف Classification

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

من المهم اختيار قيمة k مناسبة في خوارزمية الجار الأقرب، ويفضل أن تكون قيمة صغيرة نسبيًا، فعندما نحدد عدد النقاط المجاورة k=1 سيتأثر قرار النموذج بالضجيج noise في البيانات والنقاط الخارجة outliers وغير المألوفة بشكل كبير، مما يحدث حالة إفراط في التخصيص Overfitting ويضعف قدرته على التعميم لبيانات جديدة، بينما عندما نحدد عدد النقاط المجاورة برقم كبير n يساوي عدد العينات بمجموعة بيانات التدريب سيصبح النموذج أبسط من اللازم وتحدث لديه حالة إفراط في التبسيط Underfitting بالتالي لن يكون قادر على التعبير عن العلاقات المعقدة الموجودة في البيانات وسيأخذ قرارات اعتمادًا على نقاط بعيدة جدًا ولا تؤثر على نقطة الاستفسار الحالية.

في حالة توقع الانحدار Regression

يكون خرج النموذج عدد مستمر ناتج عن أخذ متوسط القيم من عدد محدد k من النقاط المجاورة لتقرير قيمة نقطة الاستفسار الحالية.

تعرض الصورة السابقة مثالًا على خوارزمية KNN لمهمة التصنيف، وتمثل النقطة الخضراء نقطة الاستفسار الحالية query point والتي نريد تصنيفها إما لصنف المربعات الزرقاء أو المثلثات الحمراء، فإذا قررنا أن عدد النقاط المجاورة k=3 تصبح النقاط الداخلة في القرار هي النقاط المحاطة بالدائرة المتصلة، وكما نرى فالأغلبية في هذا النطاق للمثلثات الحمراء 2 بينما الأقلية هي المربعات الزرقاء 1، بالتالي يمكننا تصنيف نقطة الاستفسار query point بأنها مثلث أحمر، بينما عند زيادة k لتصبح 5 ننظر للنقاط المحاطة بالدائرة المنقطة فنجد أن الأغلبية صارت للمربعات الزرقاء 3 مقابل 2 من المثلثات الحمراء، بالتالي يصبح التصنيف لنقطة الاستفسار مربع أزرق.

بعد أن تعرفنا على آلية عمل الخوارزمية، لنستعرض مجموعة من التدريبات العملية التي تساعدنا على فهم كيفية استخدام هذه الخوارزمية بشكل فعّال باستخدام مكتبة scikit-learn.

فصل مجموعة البيانات

من أولى خطوات التحضير لبناء أي نموذج تعلم آلة هي فصل الخصائص Features وهي البيانات التي نستخدمها لتوقع شيء ما عن الوسوم Labels وهي القيم التي نحاول التنبؤ بها، لنكتب برنامج بايثون لتقسيم مجموعة بيانات أزهار آيرس إلى خصائصها كطول و عرض بتلة الزهرة وسبلتها والتي سنخزنها في متغير X ، والوسوم التي سنخزنها في متغير Y. سيحتوي المتغير X أول أربعة أعمدة بينما يحتوي المتغير Y وسم كل زهرة بفصيلتها مثل Setosa أو Versicolor أو Virginica.

import pandas as pd
iris = pd.read_csv("iris.csv")
# Idاحذف عمود  
iris = iris.drop('Id',axis=1)
# iloc : تسمح باختيار شريحة من الصفوف والأعمدة 
#  يشير هذا الرمز إلى اختيار جميع العناصر":" 
X = iris.iloc[:, :-1].values 
y = iris.iloc[:, 4].values
print("الخصائص:")
print(X)
print("\nالوسوم:")
print(y)

كما نلاحظ فقد حذفنا في هذه الخطوة عمود المعرف Id من مجموعة البيانات، كونه لا يحمل أي معنى يتعلق بخصائص الأزهار، واستخدامه قد يؤدي لنموذج متحيز وغير دقيق. واستخدمنا التابع iloc لتحديد الخصائص X، والوسوم Y وأخيرًا، طبعنا كلًا من X و Y للتأكد من صحة التقسيم.

عند تنفيذ الكود سنحصل على الخرج التالي:

الخصائص:
[[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
 [5.  3.6 1.4 0.2]
...
 [6.7 3.  5.2 2.3]
 [6.3 2.5 5.  1.9]
 [6.5 3.  5.2 2. ]
 [6.2 3.4 5.4 2.3]
 [5.9 3.  5.1 1.8]]

الوسوم:
['Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
…
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica']

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

نحتاج لتقسيم البيانات إلى بيانات تدريب training وبيانات اختبار testing حتى نتمكن من معرفة فيما إذا كان النموذج يعمل جيدًا على بيانات جديدة لم يرها من قبل، سنكتب كود لتقسيم مجموعة بيانات آيرس إلى مجموعة تدريب تحتوي 80% من البيانات ومجموعة اختبار تحتوي 20%، بحيث يكون عدد العينات المستخدمة في التدريب هو 120 عينة والمستخدمة في الاختبار 30 عينة، ونطبع كلا المجموعتين.

import pandas as pd
from sklearn.model_selection import train_test_split

iris = pd.read_csv("iris.csv")
# Id احذف العمود    
iris = iris.drop('Id',axis=1)
# iloc : تسمح لنا باختيار شريحة من الصفوف والأعمدة 
#  يشير هذا الرمز إلى اختيار جميع العناصر":" 
X = iris.iloc[:, :-1].values 
y = iris.iloc[:, 4].values

# تقسم هذه الدالة مجموعة البيانات عشوائيًا وفقًا للنسب المحددة
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
print("\n70% train data:")
print(X_train)
print(y_train)
print("\n30% test data:")
print(X_test)
print(y_test)

فصلنا في البداية مجموعة البيانات إلى خاصيات X ووسوم Y كما في فعلنا في التطبيق السابق، ثم استدعينا الدالة train_test_split التي تقسم خاصيات ووسوم المجموعة إلى مجموعة تدريب ومجموعة اختبار، وحددنا نسبة التقسيم باستخدام test_size=0.20 لجعل 20% من مجموعة البيانات مخصصة للاختبار، بينما 80% منها للتدريب، سيجري تقسيم البيانات عشوائيًا في كل مرة نشغل بها الكود.
عند تنفيذ الكود السابق سنحصل على خرج مشابه لما يلي:

الخصائص:
[[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
 [5.  3.6 1.4 0.2]
 …
 [6.7 3.  5.2 2.3]
 [6.3 2.5 5.  1.9]
 [6.5 3.  5.2 2. ]
 [6.2 3.4 5.4 2.3]
 [5.9 3.  5.1 1.8]]

الوسوم:
['Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 … 
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica']

70% train data:
[[5.6 2.5 3.9 1.1]
 [5.6 2.9 3.6 1.3]
 [4.7 3.2 1.6 0.2]
 [5.4 3.9 1.7 0.4]
 [5.1 3.8 1.6 0.2]
 … 
 [4.8 3.  1.4 0.1]
 [6.  2.7 5.1 1.6]
 [5.6 2.8 4.9 2. ]
 [7.7 2.6 6.9 2.3]
 [7.2 3.6 6.1 2.5]
 [5.6 3.  4.5 1.5]]
['Iris-versicolor' 'Iris-versicolor' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica'
 'Iris-setosa' 'Iris-virginica' 'Iris-virginica' 'Iris-setosa'
 'Iris-virginica' 'Iris-virginica' 'Iris-versicolor' 'Iris-setosa'
 …
 'Iris-setosa' 'Iris-virginica' 'Iris-virginica' 'Iris-setosa'
 'Iris-setosa' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-virginica' 'Iris-setosa' 'Iris-versicolor' 'Iris-virginica'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-versicolor'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-versicolor']

30% test data:
[[5.5 2.3 4.  1.3]
 [6.4 3.1 5.5 1.8]
 [4.8 3.  1.4 0.3]
 [5.  3.2 1.2 0.2]
 [5.6 3.  4.1 1.3]
 …
 [6.4 2.8 5.6 2.2]
 [6.9 3.2 5.7 2.3]
 [6.1 2.6 5.6 1.4]
 [6.5 3.  5.2 2. ]
 [4.8 3.1 1.6 0.2]]
['Iris-versicolor' 'Iris-virginica' 'Iris-setosa' 'Iris-setosa'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica'
 'Iris-versicolor' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica'
 'Iris-setosa' 'Iris-virginica' 'Iris-setosa' 'Iris-virginica'
 'Iris-setosa' 'Iris-virginica' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-setosa']

ترقيم الفصائل النصية

الأن سنعمل على تطبيق يحوّل فصائل الأزهار في مجموعة بيانات آيرس من أسماء نصية إلى قيم رقمية، ولنفعل ذلك سنحتاج لتحويل كل قيمة إلى رقم ثابت لهذه القيمة، فمثلًا نجعل Iris-setosa:0 و Iris-versicolor:1 و Iris-virginica:2، ثم نطبع مجموعة بيانات التدريب ومجموعة بيانات الاختبار.

import pandas as pd
from sklearn.model_selection import train_test_split
# LabelEncoder استدعي   
# والذي سوف نستخدمه لتحويل الفصائل من قيم نصية إلى أرقام ثابته لكل فصيلة
from sklearn.preprocessing import LabelEncoder

iris = pd.read_csv("iris.csv")
# labelEncoder نهيئ الصنف البرمجي 
le = LabelEncoder()
# labelEncoder نستخدم الصنف البرمجي 
# لتحويل التصنيفات النصية إلى أرقم
iris.Species = le.fit_transform(iris.Species)
# Id نحذف العمود 
# حيث لا يحتوي معلومات مهمة للتعلم
iris = iris.drop('Id',axis=1)
X = iris.iloc[:, :-1].values
y = iris.iloc[:, 4].values
# نقسم مجموعة البيانات إلى مجموعة تدريب ومجموعة اختبار 
# كل منهما له خصائص ووسوم منفصلة
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
print("\n80% train data:")
print(X_train)
print(y_train)
print("\n20% test data:")
print(X_test)
print(y_test)

استخدمناLabelEncoder()‎ لنهيئ الكائن le والذي سنستخدمه لتحويل الفصائل النصية categorical classes لأرقام، حيث نرمز لكل صنف أو اسم برقم ثابت لهذا الصنف، ونستدعي هذا الكائن ليطبّق على البيانات باستخدام le.fit_transform(iris.Species)‎ حيث تتعرف هذه الدالة في البداية على الأصناف في عمود Species وتحدد القيم التي ستعطى لكل فصيل category وتسمى هذه العملية fit ويمكن تنفيذها بشكل مستقل، ومن ثم يتم تحويل القيم النصية القديمة إلى الأرقام المقابلة عند تنفيذ عملية transform التي يمكن فصلها لكي تنفّذ بعد عملية fit على أكثر من مجموعة من البيانات التي تتضمن نفس الفصائل، ولكن في كثير من الأحيان نستخدم الدالة التي تدمج الخطوتين معًا.

عند تنفيذ الكود سنحصل على الخرج التالي:

الخصائص:
[[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
 [5.  3.6 1.4 0.2]
 …
 [6.7 3.  5.2 2.3]
 [6.3 2.5 5.  1.9]
 [6.5 3.  5.2 2. ]
 [6.2 3.4 5.4 2.3]
 [5.9 3.  5.1 1.8]]

الوسوم:
['Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 …
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica']

70% train data:
[[5.6 2.5 3.9 1.1]
 [5.6 2.9 3.6 1.3]
 [4.7 3.2 1.6 0.2]
 [5.4 3.9 1.7 0.4]
 [5.1 3.8 1.6 0.2]
 …
 [5.6 2.8 4.9 2. ]
 [7.7 2.6 6.9 2.3]
 [7.2 3.6 6.1 2.5]
 [5.6 3.  4.5 1.5]]
['Iris-versicolor' 'Iris-versicolor' 'Iris-setosa' 'Iris-setosa'
 'Iris-setosa' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica'
 'Iris-setosa' 'Iris-virginica' 'Iris-virginica' 'Iris-setosa'
 'Iris-virginica' 'Iris-virginica' 'Iris-versicolor' 'Iris-setosa'
 …
 'Iris-setosa' 'Iris-virginica' 'Iris-virginica' 'Iris-setosa'
 'Iris-setosa' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-virginica' 'Iris-setosa' 'Iris-versicolor' 'Iris-virginica'
 'Iris-setosa' 'Iris-setosa' 'Iris-setosa' 'Iris-versicolor'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-versicolor']

30% test data:
[[5.5 2.3 4.  1.3]
 [6.4 3.1 5.5 1.8]
 [4.8 3.  1.4 0.3]
 [5.  3.2 1.2 0.2]
 [5.6 3.  4.1 1.3]
 …
 [6.4 2.8 5.6 2.2]
 [6.9 3.2 5.7 2.3]
 [6.1 2.6 5.6 1.4]
 [6.5 3.  5.2 2. ]
 [4.8 3.1 1.6 0.2]]
['Iris-versicolor' 'Iris-virginica' 'Iris-setosa' 'Iris-setosa'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica'
 'Iris-versicolor' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica'
 'Iris-setosa' 'Iris-virginica' 'Iris-setosa' 'Iris-virginica'
 'Iris-setosa' 'Iris-virginica' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-virginica'
 'Iris-setosa']

80% train data:
[[7.7 2.8 6.7 2. ]
 [6.7 3.1 5.6 2.4]
 [5.7 2.6 3.5 1. ]
 [6.3 2.8 5.1 1.5]
 [4.9 3.1 1.5 0.1]
  …
 [4.8 3.  1.4 0.3]
 [6.4 2.9 4.3 1.3]
 [4.8 3.  1.4 0.1]
 [5.5 2.6 4.4 1.2]
 [6.3 2.3 4.4 1.3]]
[2 2 1 2 0 0 0 2 2 2 2 2 0 0 2 2 1 2 1 0 1 2 0 1 2 0 1 2 2 0 1 1 1 2 0 1 0
 1 0 2 2 2 0 2 1 1 0 2 1 2 1 0 0 1 1 2 0 0 2 1 1 2 0 1 1 0 0 2 0 0 1 1 2 1
 0 1 2 2 0 1 0 0 2 0 0 2 0 1 1 2 2 0 0 1 2 0 1 1 1 0 0 1 0 2 2 0 0 0 2 2 0
 2 2 0 2 0 1 0 1 1]

20% test data:
[[6.8 3.2 5.9 2.3]
 [5.4 3.  4.5 1.5]
 [4.3 3.  1.1 0.1]
 [5.6 3.  4.1 1.3]
 [6.7 3.  5.  1.7]
 … 
 [5.8 2.7 3.9 1.2]
 [6.3 2.5 5.  1.9]
 [6.3 3.3 4.7 1.6]
 [5.1 3.7 1.5 0.4]
 [6.9 3.2 5.7 2.3]]
[2 1 0 1 1 0 2 2 2 1 0 2 1 1 1 1 1 2 1 1 1 0 2 0 0 1 2 1 0 2]

بناء نموذج K-Nearest Neighbors باستخدام ساي كيت ليرن Scikit-Learn

لنكتب كود برمجي لجعل نسبة تقسيم مجموعات البيانات 70% لمجموعة التدريب و30% لمجموعة الاختبار، حيث يصبح عدد العينات المستخدمة في التدريب 105 عينة وعدد عينات الاختبار 45، ثم نتوقع باستخدام نموذج KNN تصنيفات الفصائل لمجموعة الاختبار مع تحديد عدد النقاط المجاورة ليكون 5.

import pandas as pd
from sklearn.model_selection import train_test_split
# نستدعي المُصنف من مكتبة ساي كيت ليرن
from sklearn.neighbors import KNeighborsClassifier
iris = pd.read_csv("iris.csv")

iris = iris.drop('Id',axis=1)
X = iris.iloc[:, :-1].values
y = iris.iloc[:, 4].values
# تقسيم مجموعات البيانات
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30)

# KNN Classifier استدعي
# القيمة الافتراضية لعدد النقاط المجاورة التي لها حق التصويت هي 5
knn = KNeighborsClassifier(n_neighbors=5)
# درب النموذج باستخدام مجموعة بيانات التدريب 
# في عملية التدريب الخاضع للإشراف يستطيع النموذج أن يستخدم وسم البيانات
knn.fit(X_train, y_train)
# استخدم النموذج المدرب لتوقع مجموعة بيانات الاختبار 
print("Response for test dataset:")
y_pred = knn.predict(X_test)
print(y_pred)

استخدمنا دالة knn.fit(X_train, y_train)‎ لتدريب الكائن الذي يُطبق خوارزمية KNN في مكتبة ساي كيت ليرن، ولتدريب النموذج استخدمنا مجموعة خاصيات التدريب X_train والوسوم المقابلة لها y_train، وأثناء تهيئة الكائن عرفنا بعض الإعدادات والمعاملات مثل عدد النقاط المجاورة n_neighbors، وبعد تدريب النموذج استخدمناه لتوقع وسوم خاصيات مجموعة الاختبار X_test.

عند تنفيذ الكود سنحصل على الخرج التالي:

Response for test dataset:
['Iris-versicolor' 'Iris-setosa' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica'
 'Iris-versicolor' 'Iris-virginica' 'Iris-virginica' 'Iris-versicolor'
 'Iris-versicolor' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-versicolor' 'Iris-setosa' 'Iris-setosa' 'Iris-virginica'
 'Iris-setosa' 'Iris-setosa' 'Iris-virginica' 'Iris-versicolor'
 'Iris-setosa' 'Iris-versicolor' 'Iris-virginica' 'Iris-setosa'
 'Iris-versicolor' 'Iris-versicolor' 'Iris-virginica' 'Iris-setosa'
 'Iris-virginica' 'Iris-setosa' 'Iris-setosa' 'Iris-setosa'
 'Iris-virginica' 'Iris-virginica' 'Iris-versicolor' 'Iris-versicolor'
 'Iris-virginica' 'Iris-virginica' 'Iris-virginica' 'Iris-setosa'
 'Iris-virginica']

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

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

اختبار تأثير تغير عدد النقاط المجاورة K في خوارزمية KNN

سنكتب تطبيق لتقسيم مجموعة بيانات آيرس بنسبة 80% لمجموعة بيانات التدريب و20% لمجموعة بيانات الاختبار، ثم ندرب نموذج KNN على مجموعة بيانات التدريب ونحسب دقة النموذج في توقع وسوم مجموعة الاختبار، لنجرب قيمًا مختلفة لعدد النقاط المجاورة من 1 إلى 9  ونحسب دقة النموذج لكل قيمة.

import pandas as pd
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.model_selection import train_test_split  
iris = pd.read_csv("iris.csv")

iris = iris.drop('Id',axis=1)
X = iris.iloc[:, :-1].values
y = iris.iloc[:, 4].values
# تقسيم البيانات
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20) 

# k احسب الدقة لكل قيمة
# k=1,2,...,9
for k in range(1, 10):
    knn = KNeighborsClassifier(n_neighbors=k)  
    knn.fit(X_train, y_train)   
    print("For k = %d accuracy is"%k,knn.score(X_test,y_test))

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

عند تنفيذ الكود سنحصل على الخرج التالي:

For k = 1 accuracy is 0.9666666666666667
For k = 2 accuracy is 0.9666666666666667
For k = 3 accuracy is 0.9666666666666667
For k = 4 accuracy is 0.9333333333333333
For k = 5 accuracy is 0.9666666666666667
For k = 6 accuracy is 0.9666666666666667
For k = 7 accuracy is 0.9666666666666667
For k = 8 accuracy is 0.9333333333333333
For k = 9 accuracy is 0.9666666666666667

رسم بياني لدراسة تأثير تغير عدد النقاط المجاورة K في خوارزمية KNN

لنقسم الآن مجموعة بيانات آيرس بنسبة 80% لمجموعة بيانات التدريب و20% لمجموعة بيانات الاختبار، ثم ندرب نموذج KNN على مجموعة بيانات التدريب ونحسب دقة النموذج في توقع وسوم مجموعة الاختبار، لنجرب قيمًا مختلفة لعدد النقاط المجاورة من 1 إلى 9 ونحسب لكل قيمة دقة النموذج، ونرسم رسمًا بيانيًا جاعلين محور السينات x للقيم المختلفة لعدد النقاط المجاورة K، بينما محور الصادات y للدقة التي حققها النموذج باستخدام قيمة k.

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.model_selection import train_test_split  
# لضبط عرض النص العربي
from arabic_reshaper import reshape
from bidi.algorithm import get_display

iris = pd.read_csv("iris.csv")

iris = iris.drop('Id',axis=1)
X = iris.iloc[:, :-1].values
y = iris.iloc[:, 4].values
# تقسيم البيانات
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=10) 
# random_state معامل يضمن ثبات نتيجة التجربة عند تشغيل الكود مرة أخرى
# بدون هذا المعامل ستحصل على نتيجة مختلفة بكل مرة تشغل بها الكود

# accuracy نعرف قائمة لحفظ القيم الدقة  
acc = []
# k احسب الدقة لكل قيمة
# k=1,2,...,9
for k in range(1, 10):
    knn = KNeighborsClassifier(n_neighbors=k)  
    knn.fit(X_train, y_train) 
    score = knn.score(X_test,y_test) 
    acc.append(score)

plt.figure(figsize=(10, 5), dpi=150)
plt.plot([k for k in range(1, 10)], acc)
plt.title(get_display(reshape("العلاقة بين تغير عدد النقاط المجاورة والدقة")))
plt.xlabel(get_display(reshape("k عدد النقاط المجاورة")))
plt.ylabel(get_display(reshape("Accuracy الدقة")))
plt.show()

أنشانا في الكود السابق حلقة تكرارية حيث نجرب قيمًا مختلفة لعدد النقاط المجاورة k وندرب النموذج ونحسب دقته ونطبعها، وقد حفظنا دقة النموذج عند كل نقطة k في القائمة acc لنستخدمها في الرسم البياني، ويمكن أن نلاحظ أننا استخدمنا random_state=10 لتثبيت تقسيم البيانات العشوائي وجعل الكود يخرج نفس الرسم البياني في كل مرة.

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

مقارنة أداء النموذج بين مجموعة بيانات التدريب ومجموعة بيانات الاختبار

سنكتب برنامج لتقسيم مجموعة بيانات آيرس بنسبة 80% لمجموعة بيانات التدريب و20% لمجموعة بيانات الاختبار، ثم درب نموذج KNN على مجموعة بيانات التدريب ونحسب دقة النموذج في توقع وسوم مجموعة الاختبار، وكذلك دقته في توقع وسوم مجموعة التدريب، لنجرب قيمًا مختلفة لعدد النقاط المجاورة من 1 إلى 9  ونحسب لكل قيمة دقة النموذج، ونرسم رسمًا بيانيًا جاعلين محور السينات x للقيم المختلفة لعدد النقاط المجاورة K، بينما محور الصادات y للدقة التي حققها النموذج باستخدام قيمة k، سنستخدم هذا الرسم البياني للمقارنة بين أداء النموذج على مجموعة التدريب أمام أدائه على مجموعة الاختبار.

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.model_selection import train_test_split  
# لضبط عرض النص العربي
from arabic_reshaper import reshape
from bidi.algorithm import get_display

iris = pd.read_csv("iris.csv")

iris = iris.drop('Id',axis=1)
X = iris.iloc[:, :-1].values
y = iris.iloc[:, 4].values
# تقسيم البيانات
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=21) 
# random_state معامل يضمن ثبات نتيجة التجربة عند تشغيل الكود مرة أخرى
# بدون هذا المعامل ستحصل على نتيجة مختلفة بكل مرة تشغل بها الكود

# accuracy نعرف قائمة لحفظ القيم الدقة  
test_acc = [] 
train_acc = []
# k احسب الدقة لكل قيمة
# k=1,2,...,9
for k in range(1, 10):
    knn = KNeighborsClassifier(n_neighbors=k)  
    knn.fit(X_train, y_train) 
    test_score = knn.score(X_test,y_test) 
    train_score = knn.score(X_train, y_train)
    test_acc.append(test_score)
    train_acc.append(train_score)

plt.figure(figsize=(10, 5), dpi=150)
plt.plot([k for k in range(1, 10)], test_acc, label=get_display(reshape("دقة النموذج على بيانات الاختبار")), color='salmon')
plt.plot([k for k in range(1, 10)], train_acc, label=get_display(reshape("دقة النموذج على بيانات التدريب")), color="skyblue")
plt.title(get_display(reshape("العلاقة بين تغير عدد النقاط المجاورة والدقة")))
plt.xlabel(get_display(reshape("k عدد النقاط المجاورة")))
plt.ylabel(get_display(reshape("Accuracy الدقة")))
plt.legend()
plt.show()

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

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

الخاتمة

تناولنا في المقال الثالث من سلسلة تطبيقات ساي كيت ليرن مجموعة تدريبات على  خوارزمية أقرب الجيران K-Nearest Neighbors واستخدمناها لتصنيف فصائل أزهار آيرس، ودرسنا كيفية تقسيم البيانات لمجموعة تدريب ومجموعة اختبار مع تقييم النموذج وحساب دقة التوقعات،كما تعرفنا على تأثير عدد النقاط المجاورة في هذه الخوارزمية، سنتدرب في المقال القادم على استخدام خوارزمية الانحدار اللوجيستي Logistic Regression وهي أيضًا خوارزمية أساسية من خوازرميات التصنيف Classification وتستخدم في مهام عديدة مثل تشخيص الأمراض وتصنيف رسائل البريد.

اقرأ أيضًا

• المقال السابق: التمثيل المرئي للبيانات باستخدام Scikit-Learn مع Matplotlib و Seaborn
• تقييم واختيار نماذج تعلم الآلة
• مصطلحات الذكاء الاصطناعي للمبتدئين
• بناء مصنف بالاعتماد على طرق تعلم الآلة بلغة البايثون واستخدام Scikit-Learn

نشرح في هذا المقال التمثيل المرئي لمجموعة بيانات أزهار آيرس Iris dataset باستخدام مكتبة Scikit-Learn ومجموعة من المكتبات المفيدة الأخرى بهدف ملاحظة الأنماط وفهم العلاقات بين الخاصيات المختلفة لمجموعة بيانات الأزهار من خلال عرضها على شكل رسومات بيانية.

أهمية التمثيل المرئي للبيانات Data Visualization

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

تمثيل مرئي عام للمعلومات الإحصائية

سنكتب برنامج بايثون لإنشاء رسم بياني للحصول على المعلومات الإحصائية العامة عن مجموعة بيانات آيرس.

import pandas as pd
import matplotlib.pyplot as plt
iris = pd.read_csv("iris.csv")
iris.describe().plot(kind = "area",fontsize=16, figsize = (15,8), table = False, colormap="Accent")
plt.xlabel('Statistics',)
plt.ylabel('Value')
plt.title("General Statistics of Iris Dataset")
plt.show()

استوردنا في الكود السابق المكتبة pandas وهي مكتبة بايثون مفيدة لمعالجة البيانات وتحليلها، ومكتبة matplotlib والتي تتخصص في رسم الرسومات البيانية بمختلف أنواعها، وحمّلنا مجموعة البيانات في الكائن iris، ثم استخدمنا الدالةdescribe()‎ الذي تطرقنا له في الدرس السابق لعرض الإحصائيات الهامة عن مجموعة البيانات، بعدها استدعيناplot()‎  ومررنا له إعدادات الرسم مثل نوع الرسم البياني kind=area، وحجم الخط والألوان المستخدمة وأبعاد الرسم البياني وغيرها من الإعدادت، وأخيرًا عرضنا الرسم البياني باستخدام plt.show()‎.

عند تنفيذ الكود السابق سنحصل على الرسم البياني التالي:

رسم بياني شريطي Bar Plot

سنكتب الآن برنامج بايثون لإنشاء رسم بياني شريطي لرسم توزيع ثلاث فصائل من الأزهار وبيان تكرار ها في مجموعة البيانات.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
iris = pd.read_csv("iris.csv")
ax=plt.subplots(1,1,figsize=(10,8))
sns.countplot(data=iris)
plt.title("Iris Species Count")
plt.show()

أنشأنا باستخدام الدالةplt.subplots()‎ شكلًا بيانيًا يمكنه احتواء عدد من الرسومات البيانية الجزئية، ومررنا للدالة عدد الصفوف والأعمدة التي نرغب أن يتكون منها الشكل البياني وهي في حالتنا صف واحد وعمود واحد، أي سيحتوي الشكل البياني على رسم بياني جزئي واحد فقط، ثم ضبطنا أبعاد الرسم البياني، بعدها استخدمنا الدالةsns.countplot()‎ لإنشاء رسم شريطي Bar plot وهذه الدالة جزء من مكتبة seaborn التي تستخدم في الخلفية مكتبة matplotlib ولكنها تختصر العديد من الخطوات وتبسّطها حيث يمكن أن ننشئ العديد من الرسومات البيانية المعقدة بسطر برمجي واحد دون الدخول في تفاصيل معقدة.

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

رسم بياني دائري Pie Plot

سنكتب الآن برنامج بايثون لإنشاء رسم بياني دائري يوضح توزيع فصائل الأزهار وتكرارها في مجموعة البيانات.

import pandas as pd
import matplotlib.pyplot as plt
iris = pd.read_csv("iris.csv")
# ضبط أبعاد الرسم البياني
plt.figure(figsize=(10,8))
labels = iris['Species'].value_counts().index
# وسم كل شريحة
# Index(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype='object', name='Species')
values = iris['Species'].value_counts().values
#  تكرار كل فصيلة والتي يحسب منها نسبة كل شريحة
# array([50, 50, 50], dtype=int64)
plt.pie(x=values, labels=labels, autopct='%1.1f%%', shadow=True, explode=[0.1, 0.1, 0.1])

plt.title("Iris Species %")
plt.show()

استخدمنا هنا الدالةplt.pie()‎ لإنشاء الرسم البياني المطلوب ومررنا لها قائمة x=values تتضمن العدد في كل شريحة في الرسم البياني وقائمة أخرى labels=labels تتضمن وسم كل شريحة، وقد حصلنا على القيم ووسومها باستخدام iris['Species'].value_counts()‎ فباستخدام التابع index نحصل على القيم الفهرسية أو المفتاحية وهي أسماء فصائل الأزهار وباستخدام التابع values نحصل على عدد كل فصيلة، بينما تحدد باقي العوامل بعض التأثيرات الجمالية مثل طريقة عرض الأرقام في الرسم البياني وإضافة ظل على الرسم، بينما القائمة الممررة للمعامل explode يعبر كل عنصر بها عن مقدار ابتعاد الشريحة عن المركز حيث تجعل القيمة 0.1 كل شريحة تبتعد عن المركز بمسافة قدرها 10% من طول نصف القطر ويمكنكم تجربة تغير هذه القيم وملاحظة التأثير الناتج.

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

رسم بياني للنقاط المبعثرة Scatter plot لسبلات الأزهار

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

import matplotlib.pyplot as plt
import seaborn as sns
iris = pd.read_csv("iris.csv")
plt.figure(figsize=(10,8))
# Plotting 
sns.scatterplot(data=iris, x="SepalLengthCm", y="SepalWidthCm", hue="Species")
# Titles 
plt.xlabel("Sepal Length")
plt.ylabel("Sepal Width")
plt.title("Sepal Length VS Width")
plt.show()

استخدمنا الدالةsns.scatterplot()‎ لإنشاء رسم بياني للنقاط المبعثرة بين طول السبلة SepalLengthCm وعرض السبلة SepalWidthCm مع تلوين الفصائل المختلفة للأزهار وفقًا لتصنيفها باستخدام المعامل hue وضبطنا قيمته ليلون النقاط المبعثرة اعتمادًا على الوسوم Species، ثم استخدمنا مكتبة matplotlib لضبط إعدادات الرسم والعناوين.

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

رسم بياني للمدرّج التكراري Histogram Plot

سننشئ تطبيق يعرض رسم بياني من نوع Histogram ويوضح التوزيع لأبعاد كل من البتلات Petals والسبلات Sepals.

import pandas as pd
import matplotlib.pyplot as plt
iris = pd.read_csv("iris.csv")
# Drop id column
new_data = iris.drop('Id',axis=1)
new_data.hist(edgecolor='black', linewidth=1.2)
# gcf() -> get current figure 
fig=plt.gcf()
fig.set_size_inches(12,12)
plt.show()

استخدمنا التابع new_data.hist لإنشاء رسم بياني للمدرّج التكراري، حيث يوضح هذا النوع تكرار القيم في كل متغير، وضبطنا لون الحواف لكل شريط في الرسم البياني ليكون باللون الأسود باستخدام edgecolor، وعرض الحواف باستخدام linewidth،  واستخدامنا الدالة plt.gcf للحصول على الشكل البياني الحالي وتخزينه في الكائن fig حتى نتمكن من تعديله بحريّة. مثلًا يمكننا إعادة ضبط أبعاد الشكل البياني باستخدام الدالة fig.set_size_inches(12,12)‎ وهي دالة تابعة للكائن fig، ثم عرضنا الرسم البياني على النحو التالي:

رسم بياني مشترك Join Plot

سنكتب برنامج لإنشاء رسم بياني مشترك يصف توزيع كل متغير من متغيرات الأزهار بشكل منفرد ثم بشكل مشترك في نفس الرسمة البيانية.

اقتباس

ملاحظة : الرسم البياني المشترك join plot هو رسم بياني يوضح علاقة متغيرين من خلال رسم توزيع كل منهما بشكل منفرد على المحور الذي يمثل ذلك المتغير، ومن ثم رسم العلاقة بينهما.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
iris = pd.read_csv("iris.csv")
fig=sns.jointplot(x='SepalLengthCm', y='SepalWidthCm', data=iris, color='skyblue') 
plt.show()

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

ويمكننا إظهار مزيد من المعلومات باستخدام خاصية hue والتي تعطى لونًا مختلفًا لكل تصنيف.

fig=sns.jointplot(x='SepalLengthCm', y='SepalWidthCm', data=iris, color='skyblue', hue="Species") 

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

شبكة رسومات بيانية لأزواج من المتغيرات

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

# Import necessary modules
import pandas as pd
import seaborn as sns
iris = pd.read_csv("iris.csv")
#Drop id column
iris = iris.drop('Id',axis=1)
sns.pairplot(iris,hue='Species')

تسمح لنا الدالةsns.pairplot()‎ برسم العلاقة بين كل المتغيرات في مجموعة البيانات، حيث تقارن كل زوج من المتغيرات برسم بياني لتشكل مصفوفة متكاملة، يمكنك من خلالها ملاحظة العلاقة بين أي زوج من المتغيرات أو الخاصيات في مجموعة البيانات، ونمرر لهذه الدالة بشكل أساسي مجموعة البيانات iris وهذا كافٍ للحصول على نتيجة ولكن يمكننا إضافة المزيد من الألوان والأبعاد في مصفوفة الرسومات البيانية باستخدام معامل hue الذي يميز بين كل تصنيف في مجموعة البيانات بلون مميز في الرسم البياني، مما يسهّل علينا اكتشاف الأنماط المتعلقة بتصنيف محدد، حيث سنلاحظ أن أغلب النقاط التي تنتمي لتصنيف واحد أي لصنف واحد من الأزهار ستتجمع حول بعضها في بعض الأماكن في الرسم البياني.

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

الخريطة الحرارية Heat map

سنكتب برنامج بايثون لإيجاد الترابط Correlation بين المتغيرات في مجموعة بيانات آيرس، باستخدام خريطة حرارية Heatmap.

نوجد أولاً مصفوفة الترابط Correlation Matrix

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

iris = pd.read_csv("iris.csv")
corr_matrix = iris.drop(columns=["Id", "Species"]).corr()
print(corr_matrix)

عند تنفيذ الكود سنحصل على الخرج التالي:

               SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm
SepalLengthCm       1.000000     -0.109369       0.871754      0.817954
SepalWidthCm       -0.109369      1.000000      -0.420516     -0.356544
PetalLengthCm       0.871754     -0.420516       1.000000      0.962757
PetalWidthCm        0.817954     -0.356544       0.962757      1.000000

بعدها، نرسم الخريطة الحرارية Heat Map المعبرة عن مصفوفة الترابط Correlation Matrix

sns.heatmap(corr_matrix, annot=True, cmap="Blues")
plt.show() 

عند تنفيذ الكود سنحصل على الرسم البياني التالي:

الرسومات البيانية باللغة العربية

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

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

iris.describe().plot(kind = "area",fontsize=15, figsize = (15,8), table = False, colormap="Accent")
plt.xlabel('الاحصائيات',)
plt.ylabel('القيمة')
plt.title("معلومات احصائية عامة لمجموعة بيانات آيرس")
plt.show()

لتصحيح هذا الخطأ سنستخدم مكتبتين خارجيتين:

• مكتبة arabic_reshaper لحل مشكلة عدم اتصال الحروف ببعضها
• مكتبة python-bidi لحل مشكلة اتجاه الحروف المعكوس والسماح بدمج مناسب لنصوص عربية مع نصوص أجنبية

نستخدم الأوامر التالية لتثبيت المكتبات:

pip install arabic-reshaper 
pip install python-bidi 

الآن إذا حاولنا عرض العناوين العربية بعد استخدام المكتبات الخارجية كما يلي:

import pandas as pd
import matplotlib.pyplot as plt
from bidi.algorithm import get_display
import arabic_reshaper
def arabic(txt):
    return get_display(arabic_reshaper.reshape(txt))
iris = pd.read_csv("iris.csv")
iris.describe().plot(kind = "area",fontsize=16, figsize = (15,8), table = False, colormap="Accent")
plt.xlabel(arabic('الاحصائيات'))
plt.ylabel(arabic('القيمة'))
plt.title(arabic("معلومات احصائية عامة لمجموعة بيانات آيرس"))
plt.show()

الخاتمة

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

ترجمة -وبتصرف- للجزء الثاني من مقال Python: Machine learning - Scikit-learn Exercises, Practice, Solution

اقرأ أيضًا

• المقال السابق: أساسيات تحليل البيانات باستخدام Scikit-Learn مع Pandas
• تعرف على مكتبة Scikit learn وأهم خوارزمياتها
• الدليل الشامل إلى تحليل البيانات Data Analysis
• بناء مصنف بالاعتماد على طرق تعلم الآلة بلغة البايثون باستخدام مكتبة Scikit-Learn
• أفضل أدوات الذكاء الاصطناعي وتعلم الآلة للمطورين المبتدئين

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

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

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

متطلبات العمل

أهم المتطلبات اللازمة لتنفيذ هذا المقال بنجاح:

• الحصول على مفتاح الوصول Token لاستخدام واجهة برمجة التطبيقات API الخاصة بمنصة Hugging Face
• معرفة أساسية بلغة البرمجة بايثون
• تثبيت Python على الجهاز مع محرر أكواد مناسب مثل Jupyter Notebook أو Visual Studio Code

خطوات التطبيق العملي

لنستعرض بالتفصيل خطوات التطبيق العملي لأداتنا الذكية للتفاعل مع رسائل واتساب.

الخطوة 1: حفظ محادثات واتساب كملف PDF

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

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

بعد ذلك، يمكن فتح الملف الناتج بصيغة txt في أي تطبيق محرر نصوص مثل Microsoft Word أو Google Docs وتحويله إلى تنسيق pdf.

الخطوة 2: استخراج النصوص من ملف PDF

بعد حفظ محادثات واتساب بصيغة PDF، نحتاج إلى استخراج النصوص منها لمعالجتها وتحليلها. يمكننا تحقيق ذلك باستخدام مكتبة PyMuPDF مع LangChain، حيث تتيح لنا استخراج النصوص بسهولة من جميع صفحات ملف PDF على النحو التالي:

# تثبيت المكتبات اللازمة
!pip install langchain_community 
!pip install pymupdf
# لتحميل الملف PyMuPDFLoader  استيراد
from langchain.document_loaders import PyMuPDFLoader
# PDF تحميل ملف  
loader = PyMuPDFLoader("اسم الملف.pdf")
# استخراج محتوى الملف
pdf_text = loader.load()  
# دمج النصوص المستخرجة من جميع الصفحات في متغير واحد
text = "  ".join(page.page_content for page in pdf_text)

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

الخطوة 3: تقسيم النصوص إلى أجزاء صغيرة

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

# استيراد أداة تقسيم النصوص
from langchain.text_splitter import CharacterTextSplitter
# إعداد معلمات تقسيم النصوص
text_splitter = CharacterTextSplitter(
    separator="\n",   
    chunk_size=500,          
    chunk_overlap=100,     
    length_function=len      
)
# تقسيم النص إلى أجزاء
chunks = text_splitter.split_text(text)
# طباعة عدد الأجزاء
print(f"عدد الأجزاء: {len(chunks)}")

يقسم الكود السابق النص text لأجزاء صغيرة باستخدام الصنف CharacterTextSplitter من LangChain، حيث حددنا هنا الفاصل separator الذي يحدد أماكن تقسيم النص ليكون فاصل الأسطر n\، مع ضبط الحد الأقصى لحجم كل جزء من النص أو عدد الأحرف في كل مقطع chunk_size ليكون 500 وحددنا عدد الأحرف المتداخلة بين الأجزاء chunk_overlap بقيمة 100 لضمان الاحتفاظ بالسياق، واستخدمنا الدالة length_function لحساب طول كل جزء، ثم طباعة عدد الأجزاء الناتجة.

الخطوة 4: تحويل النصوص لتمثيلات رقمية Embeddings

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

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

# SentenceTransformer استيراد 
from sentence_transformers import SentenceTransformer
# تحميل نموذج يدعم العربية 
model = SentenceTransformer('aubmindlab/bert-base-arabertv02')
# تحويل الأجزاء النصية إلى تمثيلات رقمية
embeddings = model.encode(chunks, convert_to_tensor=True)

يعمل الكود على تحميل نموذج BERT الداعم للغة العربية، ثم يحوّل قائمة chunks التي تحتوي على الأجزاء النصية إلى تمثيلات رقمية Embedding Vectors مع تمكين تحويل النتائج إلى موترات أو تنسورات Tensors لتحسين الأداء في العمليات الحسابية، فالتعلمية convert_to_tensor=True تجعل الخرج كائنًا من نوع Tensor بدلًا من مصفوفة NumPy، مما يسهل التعامل معه عند استخدام مكتبات مثل PyTorch.

الخطوة 5: بناء قاعدة بيانات للبحث السريع باستخدام FAISS

بعد تحويل النصوص إلى تمثيلات رقمية Embeddings، نحتاج إلى تخزينها بطريقة تتيح البحث السريع واسترجاع النصوص الأكثر تطابقًا مع استفسارات المستخدم. لتحقيق ذلك، سنستخدم مكتبة FAISS وهي اختصار لعبارة Facebook AI Similarity Search والتي تعد مكتبة قوية مفتوحة المصدر طورتها ميتا لتسهيل البحث السريع عن العناصر الأكثر تشابهًا داخل مجموعات بيانات ضخمة من المتجهات vectors.

# FAISS تثبيت مكتبة 
pip install faiss-cpu
# استيراد المكتبات اللازمة
import faiss
import numpy as np
# تحديد أبعاد التمثيلات الرقمية
embedding_dim = embeddings.shape[1]  
# إنشاء قاعدة البيانات
index = faiss.IndexFlatL2(embedding_dim)
# إضافة التمثيلات الرقمية إلى قاعدة البيانات
index.add(np.array(embeddings.cpu()))

في هذا الكود ننشئ قاعدة بيانات باستخدام مكتبة FAISS، بهدف تنفيذ عمليات بحث فعّالة عن التشابه بين التمثيلات الرقمية، فبعد تثبيت المكتبة نستوردها إلى جانب استيراد المكتبة numpy. بعد ذلك، نحدد عدد أبعاد التمثيلات الرقمية embedding_dim الناتجة من النموذج وننشئ من خلال التعليمة (faiss.IndexFlatL2(embedding_dimفهرسًا أو قاعدة بيانات تستخدم مربع المسافة الإقليدية Squared Euclidean Distance لمقارنة التمثيلات والعثور على النصوص الأكثر تشابهًا ثم نضيف التمثيلات embeddings إلى قاعدة البيانات مع تحويلها لصيغة مصفوفة NumPy لاستخدامها في البحث السريع عن النصوص.

الخطوة 6: البحث عن المعلومات باستخدام RAG

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

# دالة البحث عن المعلومات داخل قاعدة البيانات
def search_query(query, top_k=3):
    # تحويل الاستفسار إلى تمثيلات رقمية
    query_embedding = model.encode([query], convert_to_tensor=True).cpu().numpy() 
    # البحث عن أقرب النصوص في قاعدة البيانات 
    distances, indices = index.search(query_embedding, top_k)
    # استرجاع النصوص الأكثر صلة بالاستفسار
    results = [chunks[i] for i in indices[0]]
    return results
# مثال على البحث داخل المحادثات
query = "السؤال ؟"
related_texts = search_query(query)
# طباعة النتائج 
for text in related_texts:
    print(text)

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

الخطوة 7: توليد الإجابة باستخدام نموذج الذكاء الاصطناعي التوليدي

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

import requests
# Hugging Face رابط واجهة النموذج على  
API_URL = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-Coder-32B-Instruct"
# Hugging Face نستبدل المفتاح التالي بمفتاح من  
headers = {"Authorization": "Bearer hf_XXXXXXXXXXXXXXXXXXXX"}
# إعداد الموجه
prompt = f"""
[SYSTEM]: أنت نموذج ذكاء اصطناعي متخصص في اللغة العربية.
سيتم إعطاؤك أسئلة مع معلومات ذات صلة.
مهمتك هي الإجابة عن الأسئلة بناءً على المعلومات المعطاة فقط.
[USER]: 
السؤال:
{query}
المعلومات المعطاة:
{related_texts}
[ASSISTANT]:
"""
# دالة لإرسال الطلب إلى النموذج واستقبال الرد
def query(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()
# استدعاء الدالة للحصول على الاستجابة من النموذج
output = query({"inputs": prompt})
# استخراج النص الناتج من الرد
generated_answer = output[0]['generated_text'].split("[ASSISTANT]:")[1]
# طباعة النتائج 
print(generated_answer)

يتواصل الكود أعلاه مع نموذج Qwen عبر الواجهة البرمجية Hugging Face API ويرسل موجه prompt للنموذج ليطلب منه الإجابة بناءً على المعلومات المعطاة فقط وكما نلاحظ يتضمن الموجه الأقسام [SYSTEM]و [USER] و [ASSISTANT] لتحديد أدوار المحادثة، بعد ذلك ينشئ دالةquery لإرسال الطلب إلى النموذج وإرجاع نص يتضمن الإجابة المستندة إلى المعلومات المتوفرة فقط، دون إضافة أي بيانات خارجية وطباعتها.

ملاحظة: تقسم المحادثة مع نموذج الذكاء الاصطناعي إلى ثلاثة أقسام وهي: [SYSTEM] لتحديد التعليمات والنظام، و [USER]لعرض السؤال والمعلومات المقدمة للنموذج، و [ASSISTANT]لتحديد المكان الذي يبدأ فيه النموذج بتوليد إجابته. وهذا يساعد على تنظيم الحوار وتوجيه النموذج بحيث يفصل بين السؤال والمعلومات والإجابة، مما يضمن أن يقتصر الرد على الجزء المطلوب دون الخلط مع باقي النص.

بناء أداة للتفاعل مع رسائل WhatsApp

بعد أن تعرفنا على الخطوات الأساسية للتفاعل مع نماذج الذكاء الاصطناعي،سنعمل الآن على تطوير أداة تفاعلية تعتمد على هذه النماذج لتحليل محادثات WhatsApp المخزنة في ملفات PDF، مما يتيح لنا البحث داخل محادثاتنا والحصول على إجابات ذكية بناءً على استفساراتنا. نبدأ بتحميل ملف PDF الخاص بالمحادثات، ثم استخراج النصوص باستخدام PyMuPDF، وتقسيمها إلى مقاطع صغيرة بواسطة CharacterTextSplitter لضمان تحليل دقيق. بعد ذلك، تحول النصوص إلى تمثيلات رقمية Embeddings باستخدام نموذج AraBERT المخصص للغة العربية، ثم تخزنها في قاعدة بيانات FAISS للبحث السريع عن النصوص ذات الصلة. عند إدخال استفسار، تعمل الأداة على البحث عن المقاطع الأكثر صلة بالاستفسار، داخل قاعدة البيانات، ثم ترسلها إلى نموذج Qwen لإنشاء إجابة ذكية تعتمد على البيانات المخزنة، ثم تعرضها عبر واجهة مستخدم تفاعلية مبنية باستخدام مكتبة بايثون تسمى Gradio وهي مكتبة مفتوحة المصدر لإنشاء واجهات مستخدم تفاعلية لنماذج التعلم الآلي والذكاء الاصطناعي تتيح لنا تصميم واجهات سهلة الاستخدام عبر متصفح الويب وتسهل علينا استفساراتنا والحصول على نتائج النموذج بشكل مباشر، دون الحاجة لكتابة أكواد معقدة.

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

import requests
import faiss
import numpy as np
import gradio as gr
from sentence_transformers import SentenceTransformer
from langchain.document_loaders import PyMuPDFLoader
from langchain.text_splitter import CharacterTextSplitter

# تحميل نموذج تحويل النصوص إلى تمثيلات رقمية 
model = SentenceTransformer('aubmindlab/bert-base-arabertv02')

# نموذج الذكاء الاصطناعي التوليدي
API_URL = "https://api-inference.huggingface.co/models/Qwen/Qwen2.5-Coder-32B-Instruct"
# Hugging Face نستبدل المفتاح التالي بمفتاح من  
headers = {"Authorization": "Bearer hf_XXXXXXXXXXXXXXXXXXXX"}

# دالة معالجة الملف وتحويله إلى تمثيلات رقمية
def process_pdf(pdf_file):
    loader = PyMuPDFLoader(pdf_file.name)
    pages = loader.load()

    text = "\n".join([page.page_content for page in pages])

    # تقسيم النص إلى أجزاء صغيرة
    text_splitter = CharacterTextSplitter(separator="\n", chunk_size=500, chunk_overlap=100, length_function=len)
    chunks = text_splitter.split_text(text)

    # تحويل الأجزاء إلى تمثيلات رقمية
    embeddings = model.encode(chunks, convert_to_tensor=True).cpu().numpy()

    # إنشاء قاعدة بيانات 
    embedding_dim = embeddings.shape[1]
    index = faiss.IndexFlatL2(embedding_dim)
    index.add(embeddings)

    return index, chunks

# دالة البحث داخل المحادثات
def search_query(query, index, documents, top_k=3):
    query_embedding = model.encode([query], convert_to_tensor=True).cpu().numpy()
    distances, indices = index.search(query_embedding, top_k)
    results = [documents[i] for i in indices[0]]
    return results

# دالة استدعاء النموذج التوليدي
def generate_answer(pdf_file, query):
    index, documents = process_pdf(pdf_file)
    related_texts = search_query(query, index, documents)

    prompt = f"""
    [SYSTEM]: أنت نموذج ذكاء اصطناعي متخصص في اللغة العربية.
    سيتم إعطاؤك أسئلة مع معلومات ذات صلة.
    مهمتك هي الإجابة عن الأسئلة بناءً على المعلومات المعطاة فقط.

    [USER]: 
    السؤال:
    {query}

    المعلومات المعطاة:
    {related_texts}

    [ASSISTANT]:
    """

    response = requests.post(API_URL, headers=headers, json={"inputs": prompt})
    output = response.json()

    return output[0]['generated_text'].split("[ASSISTANT]:")[1]

# Gradio إنشاء واجهة تفاعلية باستخدام 
with gr.Blocks() as app:
    gr.Markdown("# 📂 WhatsApp أداة للتفاعل مع محادثات 🔍")

    pdf_input = gr.File(label="📄 PDF تحميل ملف المحادثة بصيغة ")
    user_input = gr.Textbox(label="📝 أدخل سؤالك هنا")
    search_button = gr.Button("🔎 بحث وتحليل")
    output_box = gr.Textbox(label="🤖 الإجابة:")

    search_button.click(generate_answer, inputs=[pdf_input, user_input], outputs=output_box)
# تشغيل التطبيق
app.launch()

إذا شغلنا الكود أعلاه سنحصل على النتيجة التالية:

تطبيقات عملية للأداة

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

استرجاع المواعيد والمهام المجدولة

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

اقتباس

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

البحث السريع عن المعلومات المهمة وتلخيص أهم المواضيع

تتيح لنا الأداة للمستخدمين البحث بسرعة عن المعلومات المهمة داخل محادثات WhatsApp المخزنة، بالإضافة إلى تلخيص أهم المواضيع التي تمت مناقشتها. فعند إدخال استعلام مثل:

اقتباس

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

البحث في المحادثات القانونية

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

اقتباس

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

البحث في المحادثات الطبية

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

اقتباس

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

البحث في محادثات العمل

تساعد هذه الأداة في البحث داخل محادثات العمل لاستخراج آخر التحديثات حول المشاريع والمهام الجارية. على سبيل المثال، إذا أراد المستخدم معرفة:

اقتباس

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

نصائح لتحسين وتطوير الأداة

دعونا نستعرض عدة أفكار لتحسين تطبيق التفاعل مع رسائل واتساب وتحسين نتائجه:

استخدام طرق أخرى لقراءة ملفات PDF

تواجه بعض المكتبات في لغة Python تحديات في التعامل مع النصوص باللغة العربية، حيث يمكن أن يحدث فقدان في الحروف أو التنسيق عند استخراج النصوص من ملفات PDF. لتحسين ذلك، يمكن تجربة مكتبات أخرى مثل pdfplumber أو PyPDF2 التي قد توفر دقة أكبر في استخراج النصوص العربية. بالإضافة إلى ذلك، يمكن دمج تقنيات التعرف على النصوص OCR في حالة الملفات التي تحتوي على صور نصية، مما يضمن استخراج النصوص بدقة أعلى.

استخدام نماذج تضمين أفضل Embeddings

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

تجربة نماذج توليدية مختلفة

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

تحميل رسائل WhatsApp بطريقة تلقائية

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

ربط الأداة بأدوات أخرى

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

الخاتمة

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

اقرأ أيضًا

• بناء تطبيق بايثون يجيب على أسئلة ملف PDF باستخدام الذكاء الاصطناعي
• بناء روبوت دردشة باستخدام بايثون و OpenAI API
• كتابة استعلامات SQL بسهولة باستخدام الذكاء الاصطناعي
• استخدام نموذج الذكاء الاصطناعي Code Llama لكتابة وتصحيح أكواد CSS

نتناول في هذه السلسلة مجموعة متنوعة من التطبيقات العملية حول تعلم الآلة Machine Learning باستخدام إطار عمل ساي كيت ليرن Scikit-Learn الذي يوفر حزمة من الأدوات البرمجية مفتوحة المصدر تشمل خوارزميات تعلم الآلة كخوارزميات التصنيف Classification وتوقع الانحدار Regression وخوارزميات العنقدة Clustering، وقد صمم هذا الإطار ليعمل بكفاءة مع العديد من مكتبات بايثون القوية مثل NumPy و SciPy.

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

ما هي مجموعة بيانات أزهار آيرس؟

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

تتكون مجموعة البيانات من 50 عينة لكل فصيلة من الفصائل الثلاثة للأزهار، وهي Iris setosa و Iris virginica و Iris versicolor وقيست أربعة خصائص لكل عينة وهي:

• طول البتلة Petal length
• عرض البتلة Petal width
• طول السبلة Sepal length
• عرض السبلة Sepal width 

وباستخدام هذه التوليفة من الخصائص استطاع فيشر تطوير نموذج تميز خطي Linear discrimination قادر على التفريق بين الفصائل وبعضها.

تطبيقات أساسية باستخدام مكتبة باندا Pandas

سنتعرف على مجموعة من التطبيقات التي تستخدم مكتبة باندا Pandas لتحليل واستكشاف مجموعة البيانات والتي تعد خطوة أساسية في أي مشروع لتعلم الآلة.

تحميل مجموعة البيانات إلى إطار البيانات DataFrame

سنكتب برنامج بلغة برمجة بايثون لتحميل مجموعة بيانات آيرس من ملف csv إلى البنية  pandas  التي توفرها مكتبة dataframe ونطبع شكل البيانات ونوعها وأول ثلاثة صفوف منها.

import pandas as pd
data = pd.read_csv("iris.csv")
print("Shape of the data:")
print(data.shape)
print("\nData Type:")
print(type(data))
print("\nFirst 3 rows:")
print(data.head(3))

النمط DataFrame هو نمط توفره مكتبة pandas لتنظيم البيانات وتخزينها على هيئة جدول، وقد استوردنا في الكود السابق مكتبة pandas وقرأنا البيانات المطلوبة من الملف iris.csv وخزناها في متغير data من النمط DataFrame، ثم عرضنا عدد الأبعاد -أي عدد الصفوف والأعمدة الموجود في هذا الكائن- باستخدام التابع shape ونوع بياناته باستخدام التابع type وعرضنا أول 3 صفوف من البيانات فقط باستخدام التعليمة data.head(3)‎.

عند تنفيذ الكود، نحصل على الخرج التالي:

Shape of the data:
(150, 6)

Data Type:
<class 'pandas.core.frame.DataFrame'>

First 3 rows:
   Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm      Species
0   1            5.1           3.5            1.4           0.2  Iris-setosa
1   2            4.9           3.0            1.4           0.2  Iris-setosa
2   3            4.7           3.2            1.3           0.2  Iris-setosa

استعراض خصائص مجموعات بيانات آيرس

الآن، سكتب برنامج بايثون باستخدام ساي كيت ليرن Scikit-Learn لطباعة مفاتيح الأعمدة Keys وعدد الصفوف وعدد الأعمدة وأسماء الخاصيات والوصف لمجموعة بيانات آيرس.

import pandas as pd
iris_data = pd.read_csv("iris.csv")
print("\nKeys of Iris dataset:")
print(iris_data.keys())
print("\nNumber of rows and columns of Iris dataset:")
print(iris_data.shape) 

استخدمنا هنا أيضًا بنية DataFrame كما في المثال السابق لتخزين البيانات ضمن متغير باسم iris_data وعرضنا المفاتيح أو أسماء الأعمدة في مجموعة البيانات باستخدام الدالة iris_data.keys()‎ والتي تمثل المتغيرات أو الخصائص المختلفة بيانات الأزهار، وعرضنا أخيرًا عدد الصفوف والأعمدة باستخدام الدالة iris_data.shape.

سنحصل على الخرج التالي من تنفيذ الكود أعلاه:

Keys of Iris dataset:
Index(['Id', 'SepalLengthCm', 'SepalWidthCm', 'PetalLengthCm', 'PetalWidthCm',
       'Species'],
      dtype='object')

Number of rows and columns of Iris dataset:
(150, 6)

عرض عدد العينات وعدد القيم المفقودة في مجموعة بيانات آيرس

فيما يلي كود بايثون لمعرفة عدد العينات في مجموعة بيانات الأزهار، وعدد القيم المفقودة فيها.

import pandas as pd
iris = pd.read_csv("iris.csv")
print(iris.info())

استوردنا مجموعة البيانات بشكل بنية جدول DataFrame وخزناها في متغير باسم iris وطبعنا المعلومات التي نحتاجها باستخدام الدالة iris.info()‎ التي تعرض بعض المعلومات المهمة مثل عدد العينات ونوع العمود الفهرسي Index column وكذلك عدد القيم الفعلية non-null ونوع البيانات لكل عمود، بالإضافة للذاكرة RAM المستهلكة لتخزين البيانات.

نحصل على الخرج التالي من تنفيذ الكود أعلاه:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 6 columns):
 #   Column         Non-Null Count  Dtype  
---  ------         --------------  -----  
 0   Id             150 non-null    int64  
 1   SepalLengthCm  150 non-null    float64
 2   SepalWidthCm   150 non-null    float64
 3   PetalLengthCm  150 non-null    float64
 4   PetalWidthCm   150 non-null    float64
 5   Species        150 non-null    object 
dtypes: float64(4), int64(1), object(1)
memory usage: 7.2+ KB
None

المصفوفات المتناثرة Dense Matrices والمصفوفات عالية الكثافة Dense Matrices باستخدام NumPy و Scipy

سنعمل في هذه الفقرة على إنشاء مصفوفة ثنائية الأبعاد 2D array مليئة بالواحد في كل عناصرها لواقعة على القطر الرئيسي والقيمة الصفر فيما دون ذلك، ثم نحول المصفوفة من نوع NumPy array إلى مصفوفة SciPy sparse matrix أي مصفوفة متناثرة بتنسيق CSR هو أحد تنسيقات مكتبة SciPy لتمثيل المصفوفات.

وتعرف المصفوفة المتناثرة بأنها مصفوفة تحتوي في الغالب على أصفار Sparse matrix، وعلى النقيض تمامًا فإن المصفوفة الي يكون غالب عناصرها قيم لا تساوي الصفر تسمى  مصفوفة عالية الكثافة Dense matrix، ويعرف معدل التناثر sparsity على أنه عدد العناصر الصفرية مقسومة على إجمالي العناصر بالمصفوفة، ويساوي أيضًا 1 مطروحًا منه معدل الكثافة Density للمصفوفة، وباستخدام هذه التعريفات يمكننا تصنيف مصفوفة بأنها متناثرة sparse إن كان معدل تناثرها Sparsity أكبر من 0.5.

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

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

import numpy as np
from scipy import sparse
eye = np.eye(4)
print("NumPy array:\n", eye)
sparse_matrix = sparse.csr_matrix(eye)
print("\nSciPy sparse CSR matrix:\n", sparse_matrix)

بعد أن استوردنا مكتبتي NumPy و SciPy استخدمنا الدالة np.eye()‎ لإنشاء مصفوفة ثنائية الأبعاد تتكون جميع عناصرها من أصفار فيما عدا عناصر القطر الرئيسي للمصفوفة حيث تساوي عناصره الواحد، ومررنا للدالة العدد 4 وهو عدد الصفوف، وثم خزنا الناتج في الكائن eye وطبعنا المصفوفة التي يخزنها الكائن قبل أن تحويلها، واستخدمنا الدالة sparse.csr_matrix(eye)‎ لتحويل المصفوفة للصيغة المضغوطة CSR، وطبعنا الكائن الذي يحتوي المصفوفة الجديدة لنقارن بين الصيغتين.

سنحصل على الخرج التالي من تنفيذ الكود أعلاه:

NumPy array:
 [[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

SciPy sparse CSR matrix:
   (0, 0)    1.0
  (1, 1)    1.0
  (2, 2)    1.0
  (3, 3)    1.0

نلاحظ أن صيغة CSR لا تعرض كل عناصر المصفوفة، بل تُظهر العناصر التي تحتوي على أرقام غير صفرية فقط. وبما أن المصفوفة تحتوي على 1 في كل موقع قطري سنجد تساوي دليل الصف مع دليل العمود.

عرض الاحصائيات الأساسية عن مجموعة بيانات آيرس باستخدام باندا Pandas

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

import pandas as pd
data = pd.read_csv("iris.csv")
print(data.describe())

استخدمنا التابع data.describe()‎ للحصول على إحصائيات عن الكائن data من نوع DataFrame، مثل عدد القيم count والمتوسط الحسابي mean والانحراف المعياري standard deviation والتوزيع المئوي percentiles وهي إحصائية تقيس الترتيب النسبي لموقع نقطة في مجموعة البيانات، فمثلًا عند قولنا أن التوزيع المئوي 25% يساوي 38.25 فهذا يعني أن 25% من القيم الموجودة في البيانات أقل من هذا العدد، وتوجد ثلاث توزيعات مئوية أساسية هي 25% و 50% و75% تمثل الأرباع Q1 و Q2 و Q3 على الترتيب، ويعرف Q2 خاصةً بالوسيط median وهو الرقم الوسيط بين مجموعة من القيم المرتبة، وتعرض أيضًا القيمة العظمى لكل عمود، ولا تأخذ هذه الدالة في الاعتبار القيم المفقودة NAN، ولا تعمل إلا على الأعمدة الرقمية Numerical.

نحصل على الخرج التالي من تنفيذ الكود أعلاه:

               Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm
count  150.000000     150.000000    150.000000     150.000000    150.000000
mean    75.500000       5.843333      3.054000       3.758667      1.198667
std     43.445368       0.828066      0.433594       1.764420      0.763161
min      1.000000       4.300000      2.000000       1.000000      0.100000
25%     38.250000       5.100000      2.800000       1.600000      0.300000
50%     75.500000       5.800000      3.000000       4.350000      1.300000
75%    112.750000       6.400000      3.300000       5.100000      1.800000
max    150.000000       7.900000      4.400000       6.900000      2.500000

معرفة عدد عينات كل نوع Categorical values باستخدام Pandas

لنحصل على عدد عينات كل فصيلة من الفصائل في مجموعة بيانات الأزهار نكتب الكود على النحو التالي:

import pandas as pd
data = pd.read_csv("iris.csv")
print("Observations of each species:")
print(data['Species'].value_counts()) 

استخدمنا الدالة value_counts()‎ على العمود Species الذي يحتوى وسمًا لكل عينة في مجموعة البيانات، تسمح هذه الدالة بالحصول على عدد العينات في كل تصنيف، بمعنى أخر سنعرف كم عينة تنتمي لكل فصيلة من الأزهار. سنحصل على الخرج التالي من تنفيذ الكود أعلاه:

Observations of each species:
Iris-setosa        50
Iris-versicolor    50
Iris-virginica     50
Name: Species, dtype: int64

نلاحظ من الخرج السابق أن البيانات تحتوي على 150 زهرة موزعة بالتساوي على الفصائل الثلاثة.

حذف عمود من DataFrame باستخدام Pandas

لحذف عمود Id وطباعة أول خمسة صفوف حصلنا عليها بعد حذفه نكتب الكود التالي.

import pandas as pd
data = pd.read_csv("iris.csv")
print("Original Data:")
print(data.head())
new_data = data.drop('Id',axis=1)
print("After removing id column:")
print(new_data.head()) 

لحذف عمود من بنية DataFrame نستخدم الدالة drop()‎ ونمرر لها اسم العمود المطلوب والمعامل axis وهو معامل يقبل قيمتين إما 0 وتعني أننا نريد حذف عمود، أو 1 والتي تعني أننا نريد حذف صف، ثم نستدعي new_data.head()‎ لعرض أول خمسة صفوف من مجموعة البيانات الجديدة التي حصلنا عليها.

سنحصل على الخرج التالي من تنفيذ الكود أعلاه:

Original Data:
   Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm      Species
0   1            5.1           3.5            1.4           0.2  Iris-setosa
1   2            4.9           3.0            1.4           0.2  Iris-setosa
2   3            4.7           3.2            1.3           0.2  Iris-setosa
3   4            4.6           3.1            1.5           0.2  Iris-setosa
4   5            5.0           3.6            1.4           0.2  Iris-setosa
After removing id column:
   SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm      Species
0            5.1           3.5            1.4           0.2  Iris-setosa
1            4.9           3.0            1.4           0.2  Iris-setosa
2            4.7           3.2            1.3           0.2  Iris-setosa
3            4.6           3.1            1.5           0.2  Iris-setosa
4            5.0           3.6            1.4           0.2  Iris-setosa

اختيار شرائح معينة من مجموعة البيانات باستخدام Panda

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

import pandas as pd
data = pd.read_csv("iris.csv")
print("Original Data:")
print(data.head())
new_data = data.drop('Id',axis=1)
print("After removing id column:")
print(new_data.head())
x = data.iloc[:, [1, 2, 3, 4]].values
print(x) 

يسمح لنا التابع data.iloc[]‎ باختيار شريحة معينة من مجموعة البيانات، حيث نحدد قبل الفاصلة الأولى الصفوف التي نريد أن تدخل في الاختيار، وبعد الفاصلة الأعمدة التي نريد أن تدخل في الاختيار، وفي حالتنا اخترنا عرض قيم جميع الصفوف باستخدام الرمز : والموجودة في أعمدة محددة [1,2,3,4].

سنحصل على الخرج التالي من تنفيذ الكود أعلاه:

Original Data:
   Id  SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm      Species
0   1            5.1           3.5            1.4           0.2  Iris-setosa
1   2            4.9           3.0            1.4           0.2  Iris-setosa
2   3            4.7           3.2            1.3           0.2  Iris-setosa
3   4            4.6           3.1            1.5           0.2  Iris-setosa
4   5            5.0           3.6            1.4           0.2  Iris-setosa
After removing id column:
   SepalLengthCm  SepalWidthCm  PetalLengthCm  PetalWidthCm      Species
0            5.1           3.5            1.4           0.2  Iris-setosa
1            4.9           3.0            1.4           0.2  Iris-setosa
2            4.7           3.2            1.3           0.2  Iris-setosa
3            4.6           3.1            1.5           0.2  Iris-setosa
4            5.0           3.6            1.4           0.2  Iris-setosa
[[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
 [5.  3.6 1.4 0.2]
 … 
 [6.7 3.  5.2 2.3]
 [6.3 2.5 5.  1.9]
 [6.5 3.  5.2 2. ]
 [6.2 3.4 5.4 2.3]
 [5.9 3.  5.1 1.8]]

الخاتمة

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

اقرأ أيضًا

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

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

سنتعرف في هذه المقالة على مفاهيم أساسية في إطار عمل باي تورش PyTorch مثل مفهوم التفاضل التلقائي automatic differentiation، ومفهوم المخططات الرسومية الحسابية computation graphs، وكيفية تحقيق الاستفادة العظمى من المكتبات والأدوات التي يوفرها باي تورش واستخدامها لتطبيق هذه المفاهيم.

المتطلبات السابقة

يتطلب فهم هذه المقالة توفر الإلمام بالمواضيع التالية:

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

التفاضل التلقائي Automatic Differentiation

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

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

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

تمتلك معماريات الشبكات العصبية ملايين المعاملات parameters القابلة للتعلم، وتمر عملية تدريب أي شبكة عصبية بمرحلتين وهما:

1. مرحلة الانتشار الأمامي Forward pass التي تحسب قيمة الخسارة باستخدام دالة خسارة loss function
2. مرحلة الانتشار الخلفي Backward pass التي يحسب قيم التدرجات gradients لتحديث المعاملات القابلة للتعلم

يكون الانتشار الأمامي forward pass في غاية البساطة، فالمخرجات للطبقة الحالية هي مدخلات الطبقة التالية ويستمر هذا النمط في التكرار، ولكن الانتشار الخلفي backward pass أكثر تعقيدًا من الناحية الحسابية، فهو يتطلب استخدام قاعدة السلسلة التفاضلية chain rule من أجل حساب التدرجات بالنسبة لمعاملات دالة الخسارة loss function، بمعنى أبسط تُخبرنا التدرجات بكيفية تعديل الأوزان والمعاملات في الشبكة العصبية لتقليل الخسارة.

اقتباس

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

مثال بسيط

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

تصف المعادلات التالية هذه الشبكة العصبية البسيطة:

لنحسب التدرجات التصحيحية لكل معامل قابل للتعلم w:

حُسِبَت جميع هذه التدرجات gradients باستخدام قاعدة السلسلة chain rule، ويمكن أن نلاحظ أن جميع التدرجات الفردية في الجانب الأيمن من المعادلة يمكن حسابها بشكل مباشر بما أن البسط هو دالة ضمنية لتلك الموجودة في المقام.

المخططات البيانية الحسابية Computation Graphs

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

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

نلاحظ في الصورة التالية أننا رمزنا للمتغيرات الطرفية leaf variables بالرموز التالية a, w1, w2, w3, w4 من أجل التوضيح وسهولة التعامل، ولكنها ليست جزءًا أصيلًا من المخطط الرسومي graph، فما تمثله هو الحالة الخاصة التي ينشئ فيها المستخدم المتغيرات الخاصة به.

أنشئت المتغيرات التالية b,c,d كنتيجة للعمليات الحسابية، بينما تكون المتغيرات a,w1,w2,w3,w4 معرّفة ومدخلة بواسطة المستخدم، وبما أنها ليست متغيرات ناتجة أن أي عملية حسابية، فسنرمز للعقد التي تعبر عنها باسم المتغير الذي أنشأه المستخدم. وهذا ينطبق على كل العقد الطرفية leaf nodes في المخطط الحسابي.

حساب التدرجات Gradients

بعد التعرف على بعض المفاهيم الأساسية، لنتعرف الآن على آلية حساب التدرجات gradients باستخدام المخطط الحسابي computation graph، يمكن اعتبار كل عقدة node في المخطط -باستثناء العقد الطرفية- دالة تستقبل مدخلات وتعالجها وتدفع بالمخرجات لتنتشر خلال المخطط.

لنلقِ نظرة على العقدة التي تخرج المتغير  d بعد معالجة المدخلات w4×c و w3×b، يمكننا التعبير عنها كدالة على النحو التالي:

حيث تعبر d عن مخرجات الدالة f(x,y)=x+y.

يمكننا الآن وببساطة حساب التدرجات gradients للدالة f بالنسبة لمدخلاتها، وفق المعادلة التالية:

بعد حساب التدرجات gradients سنعمل على وسم الأسهم في الاتجاه المعاكس لها بقيمة التدرج الخاص بها، كما في الصورة التالية:

توضح الصورة التالية المخطط الحسابي كاملًا بعد أن طبقنا هذه على الخطوات عند كل العقد:

تاليًا، سنصف الخوارزمية التي تحسب القيمة المشتقة عند أي عقدة في المخطط الحسابي بالنسبة لدالة الخسارة L. لنقل أننا نريد حساب الاشتقاق التالي :

سنتبع أولًا كل المسارات الممكنة من d إلى w4 وفي حالتنا هناك مسار واحد يصل بين المتغيرين، ثم سنضرب قيم الحواف أو الوصلات edges الواقعة على هذا المسار. يمكن أن نلاحظ أن حاصل الضرب الناتج هو نفسه الذي حصلنا عليه عند استخدام قاعدة السلسلة chain rule، وإذا كان هناك أكثر من مسار يربط المتغير بدالة الخسارة L نضرب الوصلات في كل مسار ثم نجمع حاصل الضرب من كل مسار، كما في المثال التالي:

حساب التفاضل التلقائي في PyTorch Autograd

بعد أن تعرفنا بشكل مفصل على ماهية المخطط الحسابي computational graph، لنستكشف الآن آلية تطبيق المخطط الحسابي في باي تورش PyTorch بشكل آلي، سنستخدم هيكل بيانات يسمى التنسور أو المُوتِر Tensor وهو أساسي في باي تورش PyTorch، حيث يشبه نوعًا ما مصفوفات مكتبة نمباي NumPy arrays، ولكن على النقيض من نمباي NumPy، فإن التنسورات tensors مصممة للاستفادة من قدرات الحوسبة الفائقة على التوزاي التي توفرها وحدات المعالجة الرسومية GPUs، ويتشابه الكود وقواعد كتابته مع تلك الموجودة في نمباي NumPy.

للنشئ tensor من 3 صفوف و 5 اعمدة، ونهيأه بقيم عشوائية كما يلي:

In [1]:  import torch

In [2]: tsr = torch.Tensor(3,5)

In [3]: tsr
Out[3]: 
tensor([[ 0.0000e+00,  0.0000e+00,  8.4452e-29, -1.0842e-19,  1.2413e-35],
        [ 1.4013e-45,  1.2416e-35,  1.4013e-45,  2.3331e-35,  1.4013e-45],
        [ 1.0108e-36,  1.4013e-45,  8.3641e-37,  1.4013e-45,  1.0040e-36]])

لنضمن قيام باي تورش PyTorch بإنشاء مخطط حسابي للموترات tensor الذي عرفناه، ينبغي علينا ضبط قيمة المتغير requires_grad إلى True، فبدون هذه الخطوة سيكون الموتر مجرد هيكل بيانات تقليدي كالذي توفره مكتبة نمباي NumPy يمكن استخدامه للعمليات الجبر الخطي السريعة.

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

t1 = torch.randn((3,3), requires_grad = True) 
t2 = torch.FloatTensor(3,3) # لا تسمح هذه الدالة بضبط هذا المتغير وقت الإنشاء 
# لكن يمكن ضبطه بعد الإنشاء
t2.requires_grad = True

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

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

كما يمتلك كل موتر tensor خاصية تسمى grad_fn ، والتي تشير إلى إلى معامل رياضي operator يقوم بإنشاء المتغير، وحينما تكون خاصية requires_grad غير مفعلة False فتكون grad_fn قيمتها None.

سنجد في مثال d=f(w3b,w4c)، أن دالة التدرج grad function ستكون هي عملية الجمع، حيث تجمع الدالة f المدخلات معًا، وستكون عملية الجمع عقدة في المخطط الحسابي الذي يخرج  d، وفي حالة كون العقدة طرفية أي متغير معرف بواسطة المستخدم فستكون دالة التدرج الخاصة به grad_fn=None.

import torch 
a = torch.randn((3,3), requires_grad = True)
w1 = torch.randn((3,3), requires_grad = True)
w2 = torch.randn((3,3), requires_grad = True)
w3 = torch.randn((3,3), requires_grad = True)
w4 = torch.randn((3,3), requires_grad = True)
b = w1*a 
c = w2*a
d = w3*b + w4*c 
L = 10 - d
print("The grad fn for a is", a.grad_fn)
print("The grad fn for d is", d.grad_fn)

ينتج تشغيل هذا الكود الخرج التالي:

The grad fn for a is None
The grad fn for d is <AddBackward0 object at 0x1033afe48>

دوال الصنف Autograd.Function

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

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

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

مثال عملي

لنفهم الأمر بمثال عملي لنفرض أن لدينا دالة حسابية بسيطة تمثل جزءًا من شبكة عصبيةd = f(w3b , w4c)‎

d هنا هي موتر tensor، ودالة التدرج grad_fn هي <ThAddBackward> وهي عملية جميع بسيطة حيث أن الدالة التي أنشئت d تجمع المدخلات، وتتلقى دالة الانتشار الأمامي forward مدخلات دالة التدرج grad_fn حيث تتلقى w3b و w4c وتجمع المدخلات في دالة التدرج، ثم تتدفق النتيجة للأمام بعد أن تحفظ في الموتر d.

وتتلقى دالة التراجع backward الخاصة بالدالة <ThAddBackward> التدرجات الداخلة incoming gradient من الطبقات التالية لها كمدخلات أي الطبقات التي على يمين الطبقة الحالية، ما نحاول حسابه هو الاشتقاق الجزئي لدالة الخسارة L بالنسبة للمتغير d والتي تتكون من كل القيم الموجودة على الوصلات edges التي تربط بين L و d، ويمكن الوصول لقيم التدرجات gradients بالنسبة للمتغير d حيث تخزن في grad وهو خاصية للموتر، فتصل لها من خلال d.grad.

نحسب بعد هذا التدرجات المحلية local gradients، أي التفاضل الجزئي للمتغير  d أس الدالة التي تجمع بالنسبة للمدخلات w4c ومرة أخرى بالنسبة للمدخل w3b. تُضرب التدرجات gradients القادمة من الطبقات التالية مع التدرجات المحسوبة محليًا بواسطة دالة التراجع، ومن ثم ترسل التدرجات لتنتشر تراجعيًا ناحية المدخلات محفزة تفاعلًا متسلسلًا، تشغّل فيه دالة التراجع لحساب تدرجات الدالة grad_fn المرتبطة بالمدخلات السابقة.

نوضح الأمر بمثال، تقوم دالة التراجع backward المرتبطة بالدالة <ThAddBackward> الخاصة بالمتغير d بتحفيز دالة التراجع للمدخلات grad_fn والتي بدورها تحفز دالة التراجع للمدخل w4c، لاحظ أن w4c هو موتر انتقالي أي أنه مُنشَأ لحفظ ناتج العملية الوسيطة ودالة التدرجات gradient الخاصة به هي <ThMulBackward>، وحينما تستدعي هذه دالة التراجع backward لحساب عملية التدرجات gradients يمرر لها تدرج الاشتقاق الجزئي لدالة الخسارة L بالنسبة إلى المتغير d مضروبة في الاشتقاق الجزئي للمتغير d بالنسبة للمتغير w4c، وتوضح الصورة التالية المعادلة المعبرة عن هذه العملية:

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

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

def backward(self, incoming_gradients):
    # اضبط قيمة التدرج للموتر الحالي
    self.Tensor.grad = incoming_gradients

    # حلقة تكرارية لتنفيذ الانتشار التراجعي للتدرجات 
    for inp in self.inputs:
        if inp.grad_fn is not None:
            # احسب التدفقات القادمة تجاه المُدخل الحالي
            # Compute new incoming gradients for the input
            new_incoming_gradients = incoming_gradients * local_grad(self.Tensor, inp)
            # استدعِ دالة التراجع بشكل تعاودي 
            # Recursively call
            inp.grad_fn.backward(new_incoming_gradients)

نجد في هذا الكود أن self.Tensor هو موتر Tensor منشئ بواسطة Autograd.Function، والتي كانت في مثالنا d، وقد شرحنا سابقًا مفهوم التدرجات القادمة incoming gradients والتدرجات المحلية local gradients.

لنحسب المشتقات في الشبكة العصبية، سنحتاج لاستدعاء دالة التراجع backward وتطبيقها على Tensor الذي يمثل الخسارة loss، ونستمر في الرجوع للخلف backtrack خلال المخطط الحسابي بداية من العقدة التي تمثل دالة التدرج grad_fn الخاصة بدالة الخسارة.

وشرحنا سابقًا أن دالة التراجع backward تستدعى بشكل تعاودي recursive، فأثناء تتبع أثر التفرعات خلال الشبكة الحسابية نستدعي هذه الدالة، والتي بدورها تستدعي نفسها عندما تتراجع للمستوى السابق وهكذا حتى نصل لحالة التوقف الأساسية base case وهي العقد الطرفية leaf node والتي تكون دالة التدرج grad_fn فيه عديمة القيمة None.

ننبه لأن باي تورش PyTorch يعطي خطأ Error عندما نحاول استدعاء دالة التراجع backward وتطبيقها على موتر تتكون عناصره من متجهات متعددة القيم vector-valued Tensor، ويعني هذا أن دالة التراجع backward تعمل على موترات تحتوي قيمًا رقمية أحادية scalers.

import torch 
a = torch.randn((3,3), requires_grad = True)
w1 = torch.randn((3,3), requires_grad = True)
w2 = torch.randn((3,3), requires_grad = True)
w3 = torch.randn((3,3), requires_grad = True)
w4 = torch.randn((3,3), requires_grad = True)
b = w1*a 
c = w2*a
d = w3*b + w4*c 
L = (10 - d)
L.backward()

سوف يعطي تشغيل هذا الكود الخطأ التالي:

RuntimeError: grad can be implicitly created only for scalar outputs

يرجع سبب هذا الخطأ لكون قيم التدرجات gradient قابلة لأن تحسب بالنسبة لقيم رقمية أحادية scalers، السبب هو طريقة تعريف التدرج gradient definition، حيث لا يمكنها أن تفاضل متجهًا بالنسبة لمتجه آخر، ولتحقيق ذلك نستخدم عملية رياضية مختلفة تسمى Jacobian وهي خارج نطاق اهتمامنا في هذا المقال.

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

import torch 
a = torch.randn((3,3), requires_grad = True)
w1 = torch.randn((3,3), requires_grad = True)
w2 = torch.randn((3,3), requires_grad = True)
w3 = torch.randn((3,3), requires_grad = True)
w4 = torch.randn((3,3), requires_grad = True)
b = w1*a 
c = w2*a
d = w3*b + w4*c 

#  L = (10 - d) استبدلنا هذا 
# بهذا 
L = (10 -d).sum()
L.backward()