كيفية بناء أول شبكة Neural الخاصة بك للتنبؤ بأسعار المنازل مع Keras

دليل للمبتدئين الكامل خطوة بخطوة لبناء أول شبكة Neural الخاصة بك في سطرين من التعليمات البرمجية مثل Deep Learning pro!

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

  • استكشاف ومعالجة البيانات
  • بناء وتدريب شبكتنا العصبية
  • تصور الخسارة والدقة
  • مضيفا التنظيم إلى شبكتنا العصبية

في غضون 20 إلى 30 دقيقة فقط ، ستكون قد قمت بترميز شبكتك العصبية تمامًا مثلما يفعل ممارس التعلم العميق!

الشروط المسبقة:

يفترض هذا المنشور أنك قد قمت بإعداد دفتر ملاحظات Jupyter مع بيئة بها حزم الحزم keras و tensorflow و pandas وتعلم scikit وتعلم matplotlib. إذا لم تكن قد فعلت ذلك ، فالرجاء اتباع الإرشادات الموجودة في البرنامج التعليمي أدناه:

  • الشروع في العمل مع بيثون للتعلم العميق وعلوم البيانات

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

  • التعلم العميق بديهية الجزء 1 أ: مقدمة في الشبكات العصبية
  • التعلم العميق بديهية الجزء 1 ب: مقدمة في الشبكات العصبية

الموارد التي تحتاجها:

مجموعة البيانات التي سنستخدمها اليوم مقتبسة من بيانات المنافسة في Zillow's Home Value Prediction Kaggle. لقد خفضنا عدد ميزات الإدخال وقمنا بتغيير المهمة إلى التنبؤ بما إذا كان سعر المنزل أعلى أو أقل من القيمة المتوسطة. يرجى زيارة الرابط أدناه لتنزيل مجموعة البيانات المعدلة أدناه ووضعها في نفس الدليل مثل دفتر الملاحظات. يجب أن يكون رمز التنزيل في أعلى اليمين.

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

اختياريًا ، يمكنك أيضًا تنزيل دفتر ملاحظات Jupyter مفصل يحتوي على جميع الكودات المشمولة في هذا المنشور: Jupyter Notebook.

لاحظ أنه لتنزيل هذا الكمبيوتر الدفتري من Github ، يجب عليك الانتقال إلى الصفحة الأولى وتنزيل ZIP لتنزيل جميع الملفات:

والآن ، لنبدأ!

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

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

  • اقرأ في ملف CSV (قيم مفصولة بفواصل) وقم بتحويلها إلى صفائف. المصفوفات عبارة عن تنسيق بيانات يمكن للخوارزمية معالجته.
  • قسّم مجموعة البيانات الخاصة بنا إلى ميزات الإدخال (التي نسميها x) والتسمية (التي نسميها y).
  • قم بقياس البيانات (نسميها هذا التطبيع) بحيث يكون لميزات الإدخال أوامر مماثلة من حيث الحجم.
  • قسّم مجموعة البيانات الخاصة بنا إلى مجموعة التدريب ومجموعة التحقق من الصحة ومجموعة الاختبار. إذا كنت بحاجة إلى تجديد معلومات حول سبب حاجتنا إلى مجموعات البيانات الثلاث هذه ، فالرجاء الرجوع إلى الجزء 1b من التعلم العميق بديهية.

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

استيراد الباندا كما PD

هذا يعني فقط أنه إذا أردت الإشارة إلى الكود الموجود في الحزمة "الباندا" ، فسأشير إليها بالاسم pd. نقرأ بعد ذلك في ملف CSV عن طريق تشغيل سطر التعليمات البرمجية هذا:

df = pd.read_csv ('housepricedata.csv')

يعني سطر التعليمات البرمجية هذا أننا سنقرأ ملف csv "housepricedata.csv" (والذي يجب أن يكون في نفس الدليل مثل دفتر ملاحظاتك) وقم بتخزينه في المتغير "df". إذا كنا نريد معرفة ما هو موجود في df ، فاكتب df في المربع الرمادي وانقر على Alt-Enter:

مدافع

يجب أن يبدو الكمبيوتر الدفتري لديك مثل هذا:

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

  • مساحة الأرض (بالقدم المربع)
  • الجودة الشاملة (مقياس من 1 إلى 10)
  • الحالة العامة (مقياس من 1 إلى 10)
  • إجمالي مساحة الطابق السفلي (قدم مربع)
  • عدد الحمامات الكاملة
  • عدد الحمامات نصف
  • عدد غرف النوم فوق الأرض
  • إجمالي عدد الغرف فوق الأرض
  • عدد المواقد
  • مساحة الجراج (قدم مربع)

في العمود الأخير لدينا ، لدينا الميزة التي نود التنبؤ بها:

  • هل سعر المنزل أعلى من المتوسط ​​أم لا؟ (1 للنعم و 0 للرفض)

الآن وبعد أن رأينا كيف تبدو بياناتنا ، نريد تحويلها إلى صفائف لكي تتم معالجتها من قِبل الجهاز:

مجموعة البيانات = القيم

لتحويل dataframe إلى صفيف ، نقوم فقط بتخزين قيم df (عن طريق الوصول إلى df.values) إلى "مجموعة البيانات" المتغيرة. لمعرفة ما بداخل "مجموعة البيانات" المتغيرة ، ما عليك سوى كتابة "مجموعة البيانات" في مربع رمادي على الكمبيوتر الدفتري وتشغيل الخلية (Alt-Enter):

بيانات

كما ترون ، يتم تخزين كل شيء في صفيف الآن:

تحويل dataframe لدينا في مجموعة

نقوم الآن بتقسيم مجموعة البيانات الخاصة بنا إلى ميزات الإدخال (X) والميزة التي نود التنبؤ بها (Y). للقيام بهذا الانقسام ، نقوم ببساطة بتعيين الأعمدة العشرة الأولى من صفيفتنا إلى متغير يسمى X والعمود الأخير من الصفيف لدينا إلى متغير يسمى Y. رمز للقيام بالمهمة الأولى هو:

X = مجموعة البيانات [: ، 0:10]

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

نظرًا لأننا لا نقوم بتقسيم الصفوف ، فسنضع ":" أمام الفاصلة. هذا يعني أخذ جميع الصفوف في مجموعة البيانات ووضعها في X.

نريد استخراج الأعمدة العشرة الأولى ، وبالتالي فإن "0:10" بعد الفاصلة تعني أخذ الأعمدة من 0 إلى 9 ووضعها في X (لا ندرج العمود 10). تبدأ أعمدةنا من الفهرس 0 ، وبالتالي فإن الأعمدة العشرة الأولى هي أعمدة من 0 إلى 9.

ثم نقوم بتعيين العمود الأخير من الصفيف الخاص بنا إلى Y:

Y = مجموعة البيانات [: ، 10]

حسنًا ، لقد قمنا الآن بتقسيم مجموعة البيانات الخاصة بنا إلى ميزات إدخال (X) وتصنيف ما نريد التنبؤ به (ص).

تتمثل الخطوة التالية في معالجتنا في التأكد من تشابه حجم ميزات الإدخال. في الوقت الحالي ، يتم ترتيب الميزات مثل منطقة المساحة بالآلاف ، وتراوحت درجة الجودة الشاملة من 1 إلى 10 ، ويميل عدد المواقد إلى 0 أو 1 أو 2.

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

يتعين علينا أولاً استيراد الرمز الذي نريد استخدامه:

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

هذا يقول أنني أريد استخدام الكود في "المعالجة المسبقة" في حزمة sklearn. بعد ذلك ، نستخدم دالة تسمى قشارة min-max ، والتي تقيس مجموعة البيانات بحيث تكون جميع ميزات الإدخال بين 0 و 1 شاملة:

min_max_scaler = preprocessing.MinMaxScaler ()
X_scale = min_max_scaler.fit_transform (X)

لاحظ أننا اخترنا 0 و 1 عن عمد للمساعدة في تدريب شبكتنا العصبية. لن نذهب إلى النظرية وراء هذا. الآن ، يتم تخزين مجموعة البيانات المقاسة في الصفيف "X_scale". إذا كنت ترغب في رؤية الشكل "X_scale" ، فما عليك سوى تشغيل الخلية:

X_scale

يجب أن يبدو دفتر ملاحظات Jupyter الخاص بك الآن كما يلي:

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

سوف نستخدم الكود من scikit-learn المسمى ‘train_test_split، ، والذي يوحي الاسم ، نقسم مجموعة بياناتنا إلى مجموعة تدريب ومجموعة اختبار. نستورد الكود الذي نحتاجه أولاً:

من sklearn.model_selection استيراد train_test_split

بعد ذلك ، قم بتقسيم مجموعة البيانات الخاصة بك مثل هذا:

X_train ، X_val_and_test ، Y_train ، Y_val_and_test = train_test_split (X_scale ، Y ، test_size = 0.3)

هذا يخبر scikit - معرفة أن حجم val_and_test الخاص بك سيكون 30 ٪ من مجموعة البيانات الشاملة. سيقوم الرمز بتخزين تقسيم البيانات في المتغيرات الأربعة الأولى على يسار علامة المساواة كما توحي أسماء المتغيرات.

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

X_val ، X_test ، Y_val ، Y_test = train_test_split (X_val_and_test ، Y_val_and_test ، test_size = 0.5)

سوف يقسم الرمز أعلاه حجم val_and_test بالتساوي إلى مجموعة التحقق من الصحة ومجموعة الاختبار.

باختصار ، لدينا الآن ما مجموعه ستة متغيرات لمجموعات البيانات التي سنستخدمها:

  • X_train (10 ميزات إدخال ، 70٪ من مجموعة البيانات الكاملة)
  • X_val (10 ميزات إدخال ، 15٪ من مجموعة البيانات الكاملة)
  • X_test (10 ميزات إدخال ، 15٪ من مجموعة البيانات الكاملة)
  • Y_train (علامة واحدة ، 70٪ من مجموعة البيانات الكاملة)
  • Y_val (تسمية واحدة ، 15٪ من مجموعة البيانات الكاملة)
  • Y_test (علامة واحدة ، 15٪ من مجموعة البيانات الكاملة)

إذا كنت تريد أن ترى كيف هي أشكال المصفوفات لكل منها (أي ما هي أبعادها) ، فما عليك سوى تشغيل

طباعة (X_train.shape ، X_val.shape ، X_test.shape ، Y_train.shape ، Y_val.shape ، Y_test.shape)

هذه هي الطريقة التي يجب أن تبدو بها مفكرة Jupyter:

كما ترون ، تحتوي مجموعة التدريب على 1022 نقطة بيانات بينما تحتوي مجموعة التحقق من الصحة و 219 نقطة بيانات لكل منها. تحتوي متغيرات X على 10 ميزات إدخال ، بينما تحتوي المتغيرات Y على ميزة واحدة فقط للتنبؤ بها.

والآن ، بياناتنا جاهزة أخيرًا! تفو!

ملخص: عند معالجة البيانات ، قمنا بما يلي:

  • اقرأ في ملف CSV (قيم مفصولة بفواصل) وقم بتحويلها إلى صفائف.
  • قسّم مجموعة البيانات الخاصة بنا إلى ميزات الإدخال والتسمية.
  • قم بقياس البيانات بحيث يكون لميزات الإدخال أوامر مماثلة من حيث الحجم.
  • قسّم مجموعة البيانات الخاصة بنا إلى مجموعة التدريب ومجموعة التحقق من الصحة ومجموعة الاختبار.

بناء وتدريب شبكتنا العصبية الأولى

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

الخطوة الأولى: إنشاء العمارة

أول شيء يتعين علينا القيام به هو إنشاء الهندسة المعمارية. لنفكر أولاً في نوع بنية الشبكة العصبية التي نريدها. لنفترض أننا نريد هذه الشبكة العصبية:

بنية الشبكة العصبية التي سنستخدمها لمشكلتنا

بكلمات ، نريد أن يكون لدينا هذه الطبقات:

  • طبقة خفية 1: 32 الخلايا العصبية ، تنشيط ReLU
  • طبقة خفية 2: 32 الخلايا العصبية ، تنشيط ReLU
  • طبقة الإخراج: 1 الخلايا العصبية ، وتفعيل السيني

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

أولاً ، دعنا نستورد الكود الضروري من Keras:

من keras.models استيراد متسلسل
من keras.layers استيراد كثيفة

بعد ذلك ، نحدد ذلك في نموذج Keras المتسلسل الخاص بنا مثل هذا:

نموذج = متسلسل ([
    الكثافة (32 ، التنشيط = 'relu' ، input_shape = (10 ،)) ،
    كثيفة (32 ، التنشيط = 'relu') ،
    كثيفة (1 ، التنشيط = 'السيني') ،
])

ومثل هذا ، حدد مقتطف الشفرة أعلاه هيكلنا! يمكن تفسير الكود أعلاه كما يلي:

نموذج = متسلسل ([...])

يشير هذا إلى أننا سنخزن نموذجنا في "النموذج" المتغير ، وسنصفه بالتتابع (طبقة تلو الأخرى) بين الأقواس المربعة.

الكثافة (32 ، التنشيط = 'relu' ، input_shape = (10 ،)) ،

لدينا طبقتنا الأولى كطبقة كثيفة مع 32 خلية عصبية ، تنشيط RLU وشكل الإدخال هو 10 لأن لدينا 10 ميزات إدخال. لاحظ أن كلمة "كثيفة" تشير إلى طبقة متصلة بالكامل ، وهو ما سنستخدمه.

كثيفة (32 ، التنشيط = 'relu') ،

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

كثيفة (1 ، التنشيط = 'السيني') ،

الطبقة الثالثة لدينا هي طبقة كثيفة بها تنشيط لخلايا السيجويد.

ومثل هذا ، لقد كتبنا بنية نموذجنا (قالب) في الكود!

الخطوة الثانية: ملء أفضل الأرقام

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

  • إخباره بالخوارزمية التي تريد استخدامها للقيام بالتحسين
  • نقول ما وظيفة فقدان للاستخدام
  • إخباره بالمقاييس الأخرى التي تريد تتبعها بصرف النظر عن وظيفة الخسارة

تتطلب تهيئة النموذج بهذه الإعدادات استدعاء دالة model.compile ، مثل هذا:

model.compile (محسن = 'دولار سنغافوري،
              فقدان = 'binary_crossentropy،
              مقاييس = [ 'دقة'])

نضع الإعدادات التالية داخل الأقواس بعد model.compile:

محسن = 'SGD "

يشير "sgd" إلى نزول تدرج عشوائي (هنا ، يشير إلى نزول تدرج الدُفعات المصغرة) ، وهو ما رأيناه في الجزء 1 ب من التعلم العميق البديهي.

فقدان = 'binary_crossentropy "

تسمى وظيفة الفقد للمخرجات التي تأخذ القيم 1 أو 0 بانتروبيا الثنائية.

مقاييس = [ 'دقة']

أخيرًا ، نريد تتبع الدقة أعلى وظيفة الخسارة. الآن بمجرد تشغيل هذه الخلية ، نحن على استعداد للتدريب!

التدريب على البيانات بسيط جدًا ويتطلب منا كتابة سطر واحد من التعليمات البرمجية:

hist = model.fit (X_train، Y_train،
          batch_size = 32 ، عصر = 100 ،
          validation_data = (X_val ، Y_val))

تسمى الوظيفة "ملائمة" حيث نقوم بتركيب المعلمات على البيانات. يتعين علينا تحديد البيانات التي نتدرب عليها ، وهي X_train و Y_train. بعد ذلك ، نحدد حجم الدُفعة الصغيرة الخاصة بنا وطول المدة التي نرغب في تدريبها على (الحقائب). أخيرًا ، نحدد ماهية بيانات التحقق الخاصة بنا حتى يخبرنا النموذج بكيفية قيامنا ببيانات التحقق من الصحة في كل نقطة. هذه الوظيفة ستنتج محفوظات ، والتي نحفظها تحت متغير التاريخ. سنستخدم هذا المتغير لاحقًا عندما نصل إلى التصور.

الآن ، قم بتشغيل الخلية ومشاهدتها تتدرب! يجب أن يبدو دفتر Jupyter الخاص بك كما يلي:

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

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

model.evaluate (X_test، Y_test) [1]

السبب وراء امتلاكنا للفهرس 1 بعد الدالة model.evaluate هو أن الدالة ترجع الخسارة كعنصر أول ودقة كعنصر ثان. لإخراج الدقة فقط ، فقط قم بالوصول إلى العنصر الثاني (والذي تتم فهرسته بواسطة 1 ، حيث يبدأ العنصر الأول في الفهرسة من 0).

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

تقييم على مجموعة الاختبار

وهناك لديك ، لقد قمت بترميز شبكتك العصبية الأولى وقمت بتدريبها! تهانينا!

ملخص: يتطلب ترميز أول شبكة عصبية لدينا بضعة أسطر فقط من الكود:

  • نحدد الهندسة المعمارية مع نموذج Keras Sequential.
  • نحدد بعض إعداداتنا (محسن ، وظيفة الخسارة ، مقاييس لتتبع) مع model.compile
  • نقوم بتدريب نموذجنا (العثور على أفضل المعلمات لهندسة لدينا) مع بيانات التدريب مع model.fit
  • نحن تقييم نموذجنا على مجموعة اختبار مع model.evaluate

تصور الخسارة والدقة

تحدثنا في الجزء 1b للتعلم العميق البديهي عن عمليات التحليق وبعض أساليب التنظيم. كيف نعرف ما إذا كان نموذجنا حاليًا مناسبًا؟

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

استيراد matplotlib.pyplot كما PLT

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

plt.plot (hist.history [ 'الخسارة'])
plt.plot (hist.history [ 'val_loss'])
plt.title ('فقدان النموذج')
plt.ylabel ( 'الخسارة')
plt.xlabel ( 'عصر')
plt.legend (['Train'، 'Val']، loc = 'right right')
plt.show ()

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

يجب أن يبدو دفتر Jupyter الخاص بك كما يلي:

رسم بياني لفقدان النموذج يجب أن تراه في دفتر ملاحظات Jupyter

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

plt.plot (hist.history [ 'وفق'])
plt.plot (hist.history [ 'val_acc'])
plt.title ('دقة النموذج')
plt.ylabel ( 'الدقة')
plt.xlabel ( 'عصر')
plt.legend (['Train'، 'Val']، loc = 'right right')
plt.show ()

يجب أن تحصل على رسم بياني يشبه هذا قليلاً:

مؤامرة من دقة نموذج لمجموعة التدريب والتحقق من الصحة

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

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

مضيفا التنظيم إلى شبكتنا العصبية

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

model_2 = متسلسل ([
    الكثافة (1000 ، التنشيط = 'relu' ، input_shape = (10 ،)) ،
    كثيفة (1000 ، التنشيط = "relu") ،
    كثيفة (1000 ، التنشيط = "relu") ،
    كثيفة (1000 ، التنشيط = "relu") ،
    كثيفة (1 ، التنشيط = 'السيني') ،
])
model_2.compile (محسن = 'آدم'،
              فقدان = 'binary_crossentropy،
              مقاييس = [ 'دقة'])
hist_2 = model_2.fit (X_train ، Y_train ،
          batch_size = 32 ، عصر = 100 ،
          validation_data = (X_val ، Y_val))

هنا ، لقد صنعنا نموذجًا أكبر من ذلك بكثير ، واستخدمنا مُحسِّن Adam. يعد Adam أحد أكثر المحسّنين شيوعًا الذي نستخدمه ، حيث يضيف بعض التعديلات إلى نزول التدرج العشوائي بحيث يصل إلى وظيفة الخسارة المنخفضة بشكل أسرع. إذا قمنا بتشغيل هذا الرمز ورسمت الرسوم البيانية للخسارة لـ hist_2 باستخدام الكود أدناه (لاحظ أن الكود هو نفسه باستثناء أننا نستخدم "hist_2" بدلاً من "hist"):

plt.plot (hist_2.history [ 'الخسارة'])
plt.plot (hist_2.history [ 'val_loss'])
plt.title ('فقدان النموذج')
plt.ylabel ( 'الخسارة')
plt.xlabel ( 'عصر')
plt.legend (['Train'، 'Val']، loc = 'right right')
plt.show ()

نحصل على مؤامرة مثل هذا:

منحنيات الخسارة لنموذج الإفراط في التركيب

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

plt.plot (hist_2.history [ 'وفق'])
plt.plot (hist_2.history [ 'val_acc'])
plt.title ('دقة النموذج')
plt.ylabel ( 'الدقة')
plt.xlabel ( 'عصر')
plt.legend (['Train'، 'Val']، loc = 'right right')
plt.show ()

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

دقة التدريب والتحقق من صحة نموذج التجاوز لدينا

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

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

أولاً ، دعنا نستورد الكود الذي نحتاجه لتنظيم L2 وتسربه:

من keras.layers استيراد التسرب
من keras استيراد المنظمين

ثم نحدد نموذجنا الثالث مثل هذا:

model_3 = متسلسل ([
    الكثافة (1000 ، التنشيط = 'relu' ، kernel_regularizer = regularizers.l2 (0.01) ، input_shape = (10 ،)) ،
    التسرب (0.3)،
    الكثافة (1000 ، التنشيط = 'relu' ، kernel_regularizer = regularizers.l2 (0.01)) ،
    التسرب (0.3)،
    الكثافة (1000 ، التنشيط = 'relu' ، kernel_regularizer = regularizers.l2 (0.01)) ،
    التسرب (0.3)،
    الكثافة (1000 ، التنشيط = 'relu' ، kernel_regularizer = regularizers.l2 (0.01)) ،
    التسرب (0.3)،
    الكثافة (1 ، التنشيط = 'السيني' ، kernel_regularizer = regularizers.l2 (0.01)) ،
])

يمكنك اكتشاف الاختلافات بين النموذج 3 والنموذج 2؟ هناك نوعان من الاختلافات الرئيسية:

الفرق 1: لإضافة تنظيم L2 ، لاحظ أننا أضفنا بعضًا من الكود الإضافي في كل طبقة من طبقاتنا الكثيفة مثل:

kernel_regularizer = regularizers.l2 (0.01)

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

الفرق 2: لإضافة Dropout ، أضفنا طبقة جديدة مثل هذا:

التسرب (0.3)،

هذا يعني أن الخلايا العصبية في الطبقة السابقة لديها احتمال 0.3 في التسرب أثناء التدريب. دعنا نجمعها ونشغلها مع نفس المعلمات التي نستخدمها في النموذج 2 (النموذج الجاهز):

model_3.compile (محسن = 'آدم'،
              فقدان = 'binary_crossentropy،
              مقاييس = [ 'دقة'])
hist_3 = model_3.fit (X_train ، Y_train ،
          batch_size = 32 ، عصر = 100 ،
          validation_data = (X_val ، Y_val))

والآن ، لنرسم الرسوم البيانية للخسارة والدقة. ستلاحظ أن الخسارة أعلى كثيرًا في البداية ، وذلك لأننا قمنا بتغيير وظيفة الخسارة الخاصة بنا. للتخطيط بحيث يتم تكبير النافذة بين 0 و 1.2 للخسارة ، نضيف سطرًا إضافيًا من الكود (plt.ylim) عند التخطيط:

plt.plot (hist_3.history [ 'الخسارة'])
plt.plot (hist_3.history [ 'val_loss'])
plt.title ('فقدان النموذج')
plt.ylabel ( 'الخسارة')
plt.xlabel ( 'عصر')
plt.legend (['Train'، 'Val']، loc = 'right right')
plt.ylim (أعلى = 1.2 ، أسفل = 0)
plt.show ()

سنحصل على رسم بياني للخسائر يبدو كما يلي:

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

plt.plot (hist_3.history [ 'وفق'])
plt.plot (hist_3.history [ 'val_acc'])
plt.title ('دقة النموذج')
plt.ylabel ( 'الدقة')
plt.xlabel ( 'عصر')
plt.legend (['Train'، 'Val']، loc = 'right right')
plt.show ()

وسوف نحصل على مؤامرة مثل هذا:

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

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

  • L2 التنظيم
  • أوقع

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

ملخص موحد:

في هذا المنشور ، كتبنا شفرة Python إلى:

  • استكشاف ومعالجة البيانات
  • بناء وتدريب شبكتنا العصبية
  • تصور الخسارة والدقة
  • إضافة إلى تنظيم الشبكة العصبية لدينا

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

ما هو التالي: في رفيق الترميز التالي ، الجزء 2 ، سنستكشف كيفية ترميز شبكات العصبية التلافيفية الخاصة بنا (CNN) للقيام بالتعرف على الصور!

تأكد من الحصول أولاً على فهم بديهي لشبكات CNN هنا: الجزء الثاني من التعلم العميق: CNNs لرؤية الكمبيوتر

عن المؤلف:

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