البرنامج التعليمي لـ Keras: ما هو Keras؟ كيفية التثبيت في Python [مثال]

ما هو كيراس؟

Keras هي مكتبة شبكة عصبية مفتوحة المصدر مكتوبة بلغة Python الذي يعمل فوق Theano أو Tensorflow. لقد تم تصميمه ليكون معياريًا وسريعًا وسهل الاستخدام. تم تطويره بواسطة فرانسوا شوليه، أحد مهندسي Google. لا يتعامل Keras مع الحسابات ذات المستوى المنخفض. بدلاً من ذلك، فإنه يستخدم مكتبة أخرى للقيام بذلك، تسمى "Backend.

Keras عبارة عن غلاف API عالي المستوى لواجهة برمجة التطبيقات (API) ذات المستوى المنخفض، وهو قادر على العمل أعلى TensorFlow أو CNTK أو Theano. تتعامل واجهة برمجة التطبيقات Keras High-Level API مع الطريقة التي نصنع بها النماذج، أو نحدد الطبقات، أو ننشئ نماذج متعددة للمدخلات والمخرجات. في هذا المستوى، يقوم Keras أيضًا بتجميع نموذجنا مع وظائف الخسارة والمحسن، وعملية التدريب مع وظيفة الملاءمة. كيراس في Python لا يتعامل مع واجهة برمجة التطبيقات ذات المستوى المنخفض مثل إنشاء الرسم البياني الحسابي أو عمل الموترات أو المتغيرات الأخرى لأنه تم التعامل معها بواسطة محرك "الواجهة الخلفية".

ما هي الواجهة الخلفية؟

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

Theano و Tensorflow و CNTK Backend

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

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

محرك خلفي آخر لـ Keras هو Microsoft مجموعة الأدوات المعرفية أو CNTK. إنه إطار عمل مفتوح المصدر للتعلم العميق تم تطويره بواسطة Microsoft فريق. يمكن تشغيله على وحدات معالجة الرسومات المتعددة أو الأجهزة المتعددة لتدريب نموذج التعلم العميق على نطاق واسع. في بعض الحالات، تم الإبلاغ عن CNTK بشكل أسرع من الأطر الأخرى مثل Tensorflow أو Theano. بعد ذلك، في هذا البرنامج التعليمي لـ Keras CNN، سنقوم بمقارنة الواجهات الخلفية لـ Theano وTensorFlow وCNTK.

مقارنة الواجهات الخلفية

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

آخر اختبار القياس يتم تنفيذه بواسطة جاسميت بهاتيا. وذكر أن Theano أبطأ من Tensorflow في بعض الاختبارات. لكن الدقة الإجمالية هي نفسها تقريبًا لكل شبكة تم اختبارها.

لذلك، بين Theano وTensorflow وCTK، من الواضح أن TensorFlow أفضل من Theano. مع TensorFlow، يكون وقت الحساب أقصر بكثير وتكون CNN أفضل من غيرها.

التالي في هذا Keras Python البرنامج التعليمي، سوف نتعرف على الفرق بين Keras و TensorFlow (كيراس ضد تنسورفلو).

كيراس ضد تنسورفلو

المعلمات	Keras	Tensorflow
النوع	غلاف API عالي المستوى	واجهة برمجة التطبيقات ذات المستوى المنخفض
تعقيد	سهل الاستخدام إذا كنت Python لغة	أنت بحاجة إلى تعلم بناء جملة استخدام بعض وظائف Tensorflow
الهدف	النشر السريع لصنع النموذج بطبقات قياسية	يسمح لك بإنشاء رسم بياني حسابي أو طبقات نموذجية
الأدوات	يستخدم أداة تصحيح أخطاء API أخرى مثل TFDBG	يمكنك استخدام أدوات التصور Tensorboard
المجتمع	مجتمعات نشطة كبيرة	مجتمعات نشطة كبيرة وموارد مشتركة على نطاق واسع

مميزات كيراس

النشر السريع وسهل الفهم

Keras سريع جدًا في إنشاء نموذج للشبكة. إذا كنت تريد إنشاء نموذج شبكة بسيط يتكون من بضعة أسطر، Python يمكن أن يساعدك Keras في ذلك. انظر إلى مثال Keras أدناه:

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

نظرًا لواجهة برمجة التطبيقات (API) الودية، يمكننا فهم العملية بسهولة. كتابة الكود بوظيفة بسيطة دون الحاجة إلى تعيين معلمات متعددة.

دعم المجتمع الكبير

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

لديك واجهات خلفية متعددة

يمكنك اختيار Tensorflow وCNTK وTheano كواجهة خلفية لك مع Keras. يمكنك اختيار واجهة خلفية مختلفة لمشاريع مختلفة حسب احتياجاتك. كل خلفية لها ميزة فريدة خاصة بها.

نشر النماذج عبر الأنظمة الأساسية والسهلة

مع مجموعة متنوعة من الأجهزة والأنظمة الأساسية المدعومة، يمكنك نشر Keras على أي جهاز مثل

iOS مع CoreML
Android مع تنسورفلو Android,
متصفح ويب مع دعم .js
المحرك السحابي
فطيرة التوت

دعم وحدات معالجة الرسومات المتعددة

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

عيوب كيراس

لا يمكن التعامل مع واجهة برمجة التطبيقات ذات المستوى المنخفض

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

تثبيت كيراس

في هذا القسم، سننظر في الطرق المختلفة المتاحة لتثبيت Keras

التثبيت المباشر أو البيئة الافتراضية

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

على سبيل المثال، لدي مشروع يحتاج Python 3.5 باستخدام OpenCV 3.3 مع الواجهة الخلفية الأقدم لـ Keras-Theano ولكن في المشروع الآخر لا بد لي من استخدام Keras مع الإصدار الأحدث و Tensorflow كما هو الحال مع الواجهة الخلفية Python دعم 3.6.6

لا نريد أن تتعارض مكتبة Keras مع بعضها البعض، أليس كذلك؟ لذلك نستخدم بيئة افتراضية لتوطين المشروع بنوع معين من المكتبات أو يمكننا استخدام نظام أساسي آخر مثل Cloud Service لإجراء العمليات الحسابية لنا مثل Amazon خدمة ويب.

تثبيت Keras على Amazon خدمة الويب (AWS)

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

للحصول على تعليمات مفصلة حول كيفية استخدام AWS، راجع هذا البرنامج التعليمي

ملاحظة حول AMI: سيكون لديك AMI التالي متاحًا

AWS Deep Learning AMI هي بيئة افتراضية في خدمة AWS EC2 تساعد الباحثين أو الممارسين على العمل مع التعلم العميق. تقدم DLAMI محركات وحدات المعالجة المركزية الصغيرة حتى محركات وحدات معالجة الرسومات المتعددة عالية الطاقة مع CUDA وcuDNN التي تم تكوينها مسبقًا، وتأتي مع مجموعة متنوعة من أطر التعلم العميق.

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

ولكن إذا كنت ترغب في تجربة إطار عمل مخصص للتعلم العميق للبحث، فيجب عليك تثبيت Deep Learning Base AMI لأنه يأتي مع مكتبات أساسية مثل CUDA وcuDNN وبرامج تشغيل وحدات معالجة الرسومات والمكتبات الأخرى المطلوبة للتشغيل مع بيئة التعلم العميق الخاصة بك.

كيفية تثبيت كيراس على Amazon SageMaker

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

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

الخطوة 1) افتح Amazon SageMaker

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

الخطوة 2) أدخل التفاصيل

أدخل اسم دفتر الملاحظات الخاص بك.
قم بإنشاء دور IAM. سيتم إنشاء دور AMI Amazon دور IAM بتنسيق AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
وأخيرًا، اختر إنشاء مثيل دفتر ملاحظات. وبعد لحظات قليلة، Amazon تطلق Sagemaker مثيلًا للكمبيوتر الدفتري.

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

الخطوة 3) إطلاق المثيل

انقر فوق "فتح" لبدء تشغيل المثيل

الخطوة 4) ابدأ الترميز

In Jupyter، انقر فوق جديد> conda_tensorflow_p36 وستكون جاهزًا للترميز

تثبيت Keras في لينكس

لتمكين Keras مع Tensorflow كمحرك خلفي، نحتاج إلى تثبيت Tensorflow أولاً. قم بتشغيل هذا الأمر لتثبيت Tensorflow مع وحدة المعالجة المركزية (بدون GPU)

pip install --upgrade tensorflow

إذا كنت تريد تمكين دعم GPU لـ Tensorflow، فيمكنك استخدام هذا الأمر

pip install --upgrade tensorflow-gpu

دعونا نتحقق Python لمعرفة ما إذا كان التثبيت ناجحًا عن طريق الكتابة

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

إذا لم تكن هناك رسالة خطأ، فإن عملية التثبيت ناجحة

قم بتثبيت كيراس

بعد أن قمنا بتثبيت Tensorflow، لنبدأ في تثبيت keras. اكتب هذا الأمر في المحطة

pip install keras

سيبدأ في تثبيت Keras وأيضًا جميع تبعياته. يجب أن ترى شيئًا كهذا:

الآن تم تثبيت Keras في نظامنا!

التحقق

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

gedit ~/.keras/keras.json

يجب أن نرى شيئا من هذا القبيل

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

كما ترى، تستخدم "الواجهة الخلفية" Tensorflow. هذا يعني أن keras تستخدم Tensorflow كواجهة خلفية كما توقعنا

والآن قم بتشغيله على الجهاز عن طريق الكتابة

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>>

كيفية تثبيت كيراس على Windows

قبل أن نقوم بالتثبيت Tensorflow وKeras، يجب علينا تثبيت Pythonو pip و virtualenv. إذا قمت بالفعل بتثبيت هذه المكتبات، فيجب عليك الانتقال إلى الخطوة التالية، وإلا فافعل ما يلي:

تثبيت Python 3 عن طريق التحميل من هذا الصفحة

تثبيت النقطة عن طريق التشغيل

قم بتثبيت virtualenv باستخدام هذا الأمر

pip3 install –U pip virtualenv

تثبيت Microsoft مرئي C++ التحديث القابل لإعادة التوزيع لعام 2015 3

انتقل إلى موقع تنزيل Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
حدد العناصر القابلة لإعادة التوزيع وأدوات البناء
تحميل وتثبيت Microsoft مرئي C++ التحديث القابل لإعادة التوزيع لعام 2015 3

ثم قم بتشغيل هذا البرنامج النصي

pip3 install virtualenv

إعداد البيئة الافتراضية

يستخدم هذا لعزل نظام العمل عن النظام الرئيسي.

virtualenv –-system-site-packages –p python3 ./venv

تفعيل البيئة

.\venv\Scripts\activate

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

أساسيات Keras للتعلم العميق

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

فيما يلي كيفية إنشاء نموذج متسلسل وبعض الطبقات الشائعة الاستخدام في التعلم العميق

1. النموذج المتسلسل

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. طبقة تلافيفية

هذا كيراس Python مثال على الطبقة التلافيفية كطبقة الإدخال مع شكل الإدخال 320x320x3، مع 48 مرشحًا بحجم 3x3 واستخدام ReLU كوظيفة تنشيط.

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

نوع آخر هو

model.add(Conv2D(48, (3, 3), activation='relu'))

3. ماكسPoolinطبقة ز

لاختزال تمثيل الإدخال، استخدم MaxPool2d وحدد حجم kernel

model.add(MaxPooling2D(pool_size=(2, 2)))

4. طبقة كثيفة

إضافة طبقة متصلة بالكامل مع تحديد حجم الإخراج فقط

model.add(Dense(256, activation='relu'))

5. طبقة التسرب

إضافة طبقة التسرب مع احتمال 50٪

model.add(Dropout(0.5))

التجميع والتدريب والتقييم

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

model.compile(loss='mean_squared_error', optimizer='adam')

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

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

خطوتنا الأخيرة هي تقييم النموذج باستخدام بيانات الاختبار.

score = model.evaluate(x_test, y_test, batch_size=32)

دعونا نحاول استخدام الانحدار الخطي البسيط

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

بعد تدريب البيانات، يجب أن يبدو الإخراج هكذا

مع الوزن الأولي

Linear regression model is initialized with weights w: 0.37, b: 0.00

والوزن النهائي

Linear regression model is trained to have weight w: 3.70, b: 0.61

ضبط النماذج المدربة مسبقًا في Keras وكيفية استخدامها

لماذا نستخدم نماذج Fine Tune ومتى نستخدمها

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

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

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

إعداد نموذج الشبكة

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

VGG16
البداية V3
ريسنيت
موبايل نت
Xception
InceptionResNetV2

لكن في هذه العملية، سنستخدم نموذج الشبكة VGG16 وimageNet كثقل للنموذج. سنقوم بضبط الشبكة لتصنيف 8 أنواع مختلفة من الفئات باستخدام الصور من مجموعة بيانات الصور الطبيعية Kaggle

هندسة نموذج VGG16

مصدر

تحميل بياناتنا إلى AWS S3 Bucket

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

Amazon دلو S3

الخطوة 1) بعد تسجيل الدخول إلى حساب S3 الخاص بك، فلنقم بإنشاء مجموعة من خلال تسجيل الوقت إنشاء دلو

الخطوة 2) الآن اختر اسم الجرافة ومنطقتك وفقًا لحسابك. تأكد من توفر اسم الجرافة. بعد ذلك انقر خلق.

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

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

الخطوة 5) الآن انقر على الملف الخاص بك وانسخ الرابط حتى نتمكن من تنزيله.

تحضير البيانات

نحتاج إلى إنشاء بيانات التدريب الخاصة بنا باستخدام Keras ImageDataGenerator.

يجب عليك أولاً التنزيل باستخدام wget مع رابط ملفك من S3 Bucket.

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

بعد تنزيل البيانات لنبدأ عملية التدريب.

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

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

دعونا نرى صورنا بشكل عشوائي عن طريق رسمها باستخدام matplotlib

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

بعد ذلك، لنقم بإنشاء نموذج شبكتنا من VGG16 بوزن imageNet المُدرب مسبقًا. سنقوم بتجميد هذه الطبقات بحيث لا تكون الطبقات قابلة للتدريب لمساعدتنا في تقليل وقت الحساب.

إنشاء نموذجنا من VGG16

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

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

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

التدريب

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

النتائج

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

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

اختبار نموذجنا

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

واختبارنا كما هو موضح أدناه! تم توقع خطأ صورة واحدة فقط من اختبار مكون من 1 صورة!

الشبكة العصبية للتعرف على الوجوه باستخدام Keras

لماذا نحتاج إلى الاعتراف

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

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

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

نموذج الشبكة

سوف نستخدم نموذج الشبكة VGG16 ولكن بوزن VGGFace.

هندسة نموذج VGG16

ما هو VGGFace؟ إنه تطبيق Keras للتعرف العميق على الوجوه الذي قدمه Parkhi وOmkar M. وآخرون. "التعرف العميق على الوجوه". BMVC (2015). يستخدم الإطار VGG16 كهندسة للشبكة.

يمكنك تنزيل VGGFace من جيثب

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

كما ترون ملخص الشبكة

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

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

for layer in face_model.layers:
    layer.trainable = False

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

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

دعونا نرى ملخص شبكتنا

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

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

تحضير وجوهنا

الآن دعونا نجهز وجوهنا. لقد قمت بإنشاء دليل يتكون من 5 أشخاص مشهورين

جاك ما
جيسون ستاثام
جوني ديب
روبرت داوني جونيور
روان أتكينسون

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

سوف نستخدم مساعدة أداة Keras لمساعدتنا في إعداد البيانات. سيتم تكرار هذه الوظيفة في مجلد مجموعة البيانات ثم إعدادها بحيث يمكن استخدامها في التدريب.

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

train_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

valid_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

تدريب نموذجنا

لنبدأ عملية التدريب لدينا من خلال تجميع شبكتنا مع وظيفة الخسارة والمحسن. هنا، نستخدم sparse_categorical_crossentropy كدالة الخسارة، بمساعدة SGD كمُحسِّن التعلم الخاص بنا.

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

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

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

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

وباستخدام صورة روبرت داوني جونيور كصورة اختبارية، تظهر أن الوجه المتوقع صحيح!

التنبؤ باستخدام Live Cam!

ماذا لو اختبرنا مهارتنا في تنفيذها من خلال مدخلات من كاميرا الويب؟ باستخدام OpenCV مع Haar Face cascade للعثور على وجهنا وبمساعدة نموذج شبكتنا، يمكننا التعرف على الشخص.

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

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

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

أيهما أفضل؟ كيراس أو Tensorflow

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

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

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

الملخص

لذا دعونا نلخص كل ما ناقشناه وفعلناه في هذا البرنامج التعليمي.

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

قد ترغب: