Ali Haidar Ahmad

هي دالة تكلفة (loss) في كيراس وتنسرفلو ويتم استخدامها مع مسائل التصنيف المتعدد أي عندما يكون لدينا أكثر من فئة (Class label)
الصيغة الرياضية:

تعتمد هذه الدالة على المفهوم الشهير في نظرية المعلومات والمعروف ب Cross Entropy أو الإنتروبيا المتقطعة، وهي مقياس لمدى تشابه توزعين احتماليين مختلفين لنفس الحدث وفي ال ML نستخدم هذا التعريف وقانونه لكي نقوم بحساب ال Loss (التكلفة Cost). حيث يكون الخرج الخاص بالشبكة العصبية هو توزيع احتمالي لعدة فئات classes.
تابع التنشيط هنا إما Sigmoid أو Softmax فهما تابعي التنشيط الوحيدين المتوافقين مع دالة التكلفة CCE.
كنصيحة لنتائج أفضل دوماً اعتمد على ال Softmax.
عند استخدامك لهذه الوظيفة يجب عليك أن تقوم أولاً بترميز فئات البيانات لديك باستخدام الترميز One-Hot.
يتم استيرادها من الموديول:
tensorflow.keras.losses مثال:
from tensorflow.keras.losses import CategoricalCrossentropy # إنشاء داتا مزيفة لنجرب عليها # قمنا بتشكيل عينتين ولدينا 3 فئات y_true = [[0, 1, 0], [1, 0, 1]] #تمثل القيم الحقيقية One-Hot مصفوفة من ال y_pred = [[0.01, 0.9, 0], [0.77, 0.6, 0.8]] # مصفوفة القيم المتوقعة # CategoricalCrossentropy إنشاء غرض cce =CategoricalCrossentropy() # حساب الخسارة cce(y_true, y_pred).numpy() # 1.0225062 لاستخدامها في نموذجك:
# كالتالي compile لاستخدامه مع النموذج نقوم بتمريره إلى # نقوم أولاً باستيرادها model.compile( loss=tf.keras.losses.CategoricalCrossentropy(), ... ) # أو يمكن تمريرها بسهولة بالشكل التالي model.compile( loss='categorical_crossentropy', ... ) سأقوم بتطبيقها مع مجموعة بيانات routers، حيث أن هذه البيانات لديها 46 فئة (صنف) مختلف:
# تحميل الداتا from keras.datasets import reuters (train_data, train_labels), (test_data, test_labels) = reuters.load_data( num_words=1000) #ترميز الفئات المختلفة للبيانات #كما أشرنا One-Hot-Enoding طبعاً يجب أن نستخدم الترميز from keras.utils.np_utils import to_categorical # One-Hot-Enoding one_hot_train_labels = to_categorical(train_labels) one_hot_test_labels = to_categorical(test_labels) # قمنا بعرض فئة أول عينة من بيانات التدريب print('one_hot_train_labels[0]:\n',one_hot_train_labels[0]) ''' one_hot_train_labels[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] ''' # قمنا بعرض فئة أول عينة من بيانات الاختبار print('one_hot_test_labels[0]:\n',one_hot_test_labels[0]) ''' one_hot_test_labels[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] ''' #أي الفئات target انتهينا من ترميز قيم ال # الآن لنقم بترميز بيانات التدريب import numpy as np #One-Hot قمت بإنشاء تابع يقوم بتحويل بياناتي إلى الترميز # بإمكانك أيضاً استخدام تابع تحويل جاهز def vectorize_sequences(sequences, dimension=1000): results = np.zeros((len(sequences), dimension)) for i, sequence in enumerate(sequences): results[i, sequence] = 1. return results x_train = vectorize_sequences(train_data) x_test = vectorize_sequences(test_data) # بناء الشبكة from keras import models from keras import layers model = models.Sequential() model.add(layers.Dense(64, activation='relu', input_shape=(1000,))) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(46, activation='softmax')) # تجميع النموذج model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) # لاحظ كيف قمنا بتمرير دالة التكلفة إلى النموذج # التدريب history = model.fit(x_train, one_hot_train_labels, epochs=8, batch_size=512, validation_split=0.2) # الخرج ''' one_hot_train_labels[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] one_hot_test_labels[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] Epoch 1/8 15/15 [==============================] - 1s 26ms/step - loss: 3.3072 - accuracy: 0.2687 - val_loss: 2.0882 - val_accuracy: 0.5598 Epoch 2/8 15/15 [==============================] - 0s 14ms/step - loss: 1.9363 - accuracy: 0.5923 - val_loss: 1.6561 - val_accuracy: 0.6689 Epoch 3/8 15/15 [==============================] - 0s 14ms/step - loss: 1.5366 - accuracy: 0.6684 - val_loss: 1.4629 - val_accuracy: 0.6789 Epoch 4/8 15/15 [==============================] - 0s 13ms/step - loss: 1.3725 - accuracy: 0.7010 - val_loss: 1.3563 - val_accuracy: 0.7067 Epoch 5/8 15/15 [==============================] - 0s 13ms/step - loss: 1.1850 - accuracy: 0.7418 - val_loss: 1.2387 - val_accuracy: 0.7329 Epoch 6/8 15/15 [==============================] - 0s 13ms/step - loss: 1.1154 - accuracy: 0.7538 - val_loss: 1.1835 - val_accuracy: 0.7390 Epoch 7/8 15/15 [==============================] - 0s 12ms/step - loss: 1.0090 - accuracy: 0.7659 - val_loss: 1.1342 - val_accuracy: 0.7524 Epoch 8/8 15/15 [==============================] - 0s 26ms/step - loss: 0.9243 - accuracy: 0.7887 - val_loss: 1.0994 - val_accuracy: 0.7618 '''  

النمط String لايقبل الإضافة إليه، بحيث أي طريقة يتم استدعاءها على String تنشئ غرض جديد new String وترده وهذا لأن ال String غير قابل للتعديل، ولا يمكنه تغيير حالته الداخلية. أما StringBuilder فيمكنه ذلك باستخدام الطريقة append. وبالتالي يكون التعامل معه أسرع بكثير وأقل كلفة في الذاكرة فهو لايقوم بإنشاء غرض جديد (استهلاك وقت وذاكرة).
مثال يبين أهم فرق بينهما:
// String استخدام String s=""; for(int i=0;i<5000;i++) s+=String.valueOf(i); // 4828ms //ٍ StringBuilder أما باستخدام ٍStringBuilder sb=new ٍStringBuilder(); for(int i=0;i<5000;i++) sb.append(String.valueOf(i)); // 4ms باستخدام  ال String نحتاح إلى 4828ms على جهازي أما باستخدام Builder فقط 4ms وهذا فرق كبير جداً.
أي يمكنك استخدام الاثنين لكن ال StringBuilder  أكثر كفاءة مهما كانت المهمة سواءاً قراءة ملف أو التعديل عليه.

في Keras، طبقة الإدخال هي ال input shape وهي ليست طبقة بحد ذاتها ، لكنها موتر (tensor) أو مصفوفة ترسله إلى أول طبقة مخفية. ويجب أن يكون لهذا الموتر نفس شكل بيانات التدريب الخاصة بك.
فمثلاً:إذا كان لديك 20 صورة بحجم 150 × 150 بكسل في RGB (3 قنوات) ، يكون شكل بيانات الإدخال (30،50،50،3). وبالتالي فإن موتر طبقة الإدخال يجب أن يكون متطابقاً معه.
كل نوع من الطبقات يتطلب إدخالًا بعدد معين من الأبعاد:
Dense: تطلب (batch_size, input_size)، أو (batch_size, optional,...,optional, input_size) 2D convolutional layers: فهناك حالتان وكل منهما يتعلق بترتيب وجود وسيط القنوات.
(batch_size, imageside1, imageside2, channels) أو (batch_size, channels, imageside1, imageside2) 1D convolutions: وأيضاً الطبقات المتكررة مثل RNN و LSTM تحتاج إلى (batch_size, sequence_length, features). لذا سيكون حل مشكلتك كل التالي فسببها هو طريقتك الخاطئة بتمرير الأبعاد:
#Dense نقوم بإعادة تعيين الأبعاد بطريقة تناسب الدخل الذي تحتاجه الطبقة التي لديك وهي X_train = X_train.reshape((60000, 28 * 28)) X_test = X_test.reshape((10000, 28 * 28)) #وبعد ذلك تدريب البيانات الجديدة على الشبكة التالية model = models.Sequential() model.add(layers.Dense(512, activation='relu', input_shape=(28* 28,))) model.add(layers.Dense(1, activation='softmax')) model.compile(optimizer='Adam',loss='categorical_crossentropy',metrics=['accuracy']) model.fit(X_train,y_train) نقوم بتحديد ال input shape في أول طبقة فقط، ثم بعد ذلك يتم استنتاجه تلقائياُ بدون التصريح عن ذلك بشكل صريح في الطبقات الأخرى.

تسطيع حل المشكلة بطريقتن فقط ضع قبل keras مكتبة tensorflow. مكتبة كيراس هي مثل واجهة أمامية ل tensorflow
يصبح الكود كالتالي:
from tensorflow.keras.utils import to_categorical y_train=to_categorical(y_train) الطريقه الثانيه هي أن to_categorical موجودة في الوحدة الوظيفة np_utils ضمن utils
وبتالي يصبح الكود:
from keras.utils.np_utils import to_categorical y_train=to_categorical(y_train)  

معظم مسائل الـ deep learning تعمل بشكل أفضل عندما تعتمد على داتاست كبيرة الحجم مثلاً من رتبة 10 مليون أو أعلى (big data) وستصبح عملية التدريب في الشبكات العصبونية بطيئة نظراً لضخامة الداتاست وفي هذه الحالات نحتاج لوجود خوارزميات تحسين سريعة والتي تساعد في زيادة الفعالية.
خوارزمية Batch Gradient Descent هي النوع المعروف والشكل الأصلي لخوارزمية Gradient Descent حيث تمر على كل الداتاست ثم تتقدم خطوة واحدة (تحدث قيم الأوزان) ثم تمر على كامل الداتاست مرة أخرى ثم تتقدم خطوة ثانية وهكذا حتى يتم التقارب Converge. لكن المشكلة فيها أنه عندما تكون الداتاست كبيرة مثلاً من رتبة 5 مليون (طبعاً هذا الرقم ضخم وفي الحقيقة حتى عندما تكون الداتا من رتبة مئات الآلاف يظهر عيبها) ستصبح الخوارزمية بطيئة في التقدم أو التدرج لأنه في كل تكرار تمر على كامل الداتاست، لذلك في Mini Batch Gradient Descent يتم تقسيم الداتاست إلى مجموعات داتاست أصغر وهذه المجموعات تسمى mini-batches والوسيط batch_size يدل على حجم هذه المجموعة في كيراس وتنسرفلو. إن هذا التقسيم يجعل عملية التقارب أسرع بكثير من الطريقة العادية فهو لاينتظر المرور على كامل الداتاسيت حتى يتقدم خطوة (تحديث الأوزان) وإنما على جزء منها.
أما فيما يتعلق بالخوارزمية الأخيرة Stochastic Gradient Descent فهي الأسرع، حيث يتم تحديث الأوزان بعد المرور على عينة واحدة فقط أي من أجل كل عينة في الداتاسيت سيتم تحديث الأوزان، لكن عيبها هو أنها في غالب الأحيان لن تستطيع التقارب من القيم الدنيا للتكلفة.
لذا فالخيار الأفضل هو تجنب النوع الأول والثالث واستخدام ال Mini-Batch (فهي توازن بين الاثنين -السرعة والدقة-).
Batch Gradient Descent: بطيئة ودقيقة.
Stochastic Gradient Descent: سريعة جداً وغير دقيقة.
Mini Batch Gradient Descent: توازن بين السرعة والدقة.
وفي كيراس نستخدم الوسيط batch_size لتحديد عدد الباتشات (عدد التقسيمات للداتا)، فمثلاً 64 باتش تعني أنه سيتم تقسيم البيانات إلى 64 قسم وكل قسم يحوي عدد عينات يساوي (عدد العينات في الداتا مقسوم على 64).
عدم تعيين قيمة لل batch_size  يعني أنك ستستخدم Batch Gradient Descent واختيارك ل 1 يعني أنك ستستخدم Stochastic .
لنأخذ مثال ونلاحظ الفرق:
دربنا الموديل على الداتا المعرفه في keras والتي تدعى mnist وسوف نقوم بتدريب نفس الموديل ولكن مع اختلاف أن الأول ينفذ Batch Gradient Descent والثاني Mini Batch Gradient Descent:
from keras.models import Sequential from keras import layers from keras.datasets import mnist (X_train,y_train),(X_test,y_test)=mnist.load_data() X_train = X_train.reshape((60000, 28 * 28))/255.0 X_test = X_test.reshape((10000, 28 * 28))/255.0 model = Sequential() model.add(layers.Dense(512, activation='relu', input_shape=(28*28,))) model.add(layers.Dense(10, activation='softmax')) model.compile(optimizer='Adam',loss='sparse_categorical_crossentropy',metrics=['accuracy']) model.fit(X_train,y_train,epochs=1) #الخرج ''' 1875/1875 [==============================] - 8s 4ms/step - loss: 0.3400 - accuracy: 0.9004 الكود الثاني نفس السابق مع إضافة batch_size ''' #Mini-Batch model = Sequential() model.add(layers.Dense(512, activation='relu', input_shape=(28*28,))) model.add(layers.Dense(10, activation='softmax')) model.compile(optimizer='Adam',loss='sparse_categorical_crossentropy',metrics=['accuracy']) model.fit(X_train,y_train, batch_size=60,epochs=1) #الخرج ''' 1000/1000 [==============================] - 5s 5ms/step - loss: 0.3865 - accuracy: 0.8889 الفرق واضح من الخرج في كل كود الأول الذي يحوي gradient descent كان أبطئ واستغرف 8s في حين الثاني الذي يحوي mini-batch gradient descent صحيح أن الدقه ليست كالأول ولكن السرعه كانت أفضل استغرق 5s وطبعا هنا كانت الداتاست صغيره مقارنتا بالداتاست المعياريه '''  

هي دالة تكلفة (loss) في كيراس وتنسرفلو ويتم استخدامها مع مسائل التصنيف الثنائي أي عندما يكون الخرج 1 أو 0.
الصيغة الرياضية:

تعتمد هذه الدالة على المفهوم الشهير في نظرية المعلومات والمعروف ب Cross Entropy أو الإنتروبيا المتقطعة، وهي مقياس لمدى تشابه توزعين احتماليين مختلفين لنفس الحدث وفي ال ML نستخدم هذا التعريف وقانونه لكي نقوم بحساب ال Loss (التكلفة Cost). حيث يكون الخرج الخاص بالشبكة العصبية هو توزيع احتمالي لعدة فئات classes.
تابع التنشيط Sigmoid هو تابع التنشيط الوحيد المتوافق مع دالة التكلفة Binary CE.
له الشكل التالي في كيراس:
#في كيراس BinaryCrossentropy الكلاس tf.keras.losses.BinaryCrossentropy( from_logits=False, name="binary_crossentropy", ) # True عندما يكون مجال القيم المتوقعة غير محدود # False عندما يكون مجال القيم المتوقعة بين الصفر والواحد مثال:
import tensorflow as tf # إنشاء قيم حقيقية وفيم متوقعة y_true = [1, 1, 0] y_pred1 = [0.7, 0.61, 0.04] # قيم متوقعة بين 0 و 1 y_pred2 = [-11.2, 1.51, 3.94] # قيم متوقعة بين الناقص لانهاية والزائد لانهاية # إنشاء كائن من هذا الكلاس c1 = tf.keras.losses.BinaryCrossentropy(from_logits=False) c2 = tf.keras.losses.BinaryCrossentropy(from_logits=True) # استخدامه وطباعة الناتج print(c1(y_true, y_pred1).numpy()) # 0.29726425 print(c2(y_true, y_pred2).numpy()) # 5.1196237 ولاستخدمها مع الدالة Compile:
# كالتالي compile لاستخدامه مع النموذج نقوم بتمريره إلى model.compile( loss=tf.keras.losses.BinaryCrossentropy(), ... ) # أو يمكن تمريرها بسهولة بالشكل التالي model.compile( loss='binary_crossentropy', ... ) في المثال التالي سأبين لك استخدامها، سوف أقوم ببناء Baseline لمسألة تصنيف مشاعر ثنائية مع مجموعة بيانات imdb:
# مثال بسيط # تحميل وتجهيز البيانات from keras.datasets import imdb from keras import preprocessing max_features = 100 maxlen = 20 (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features) x_train = preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen) x_test = preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen) # بناء النموذج from keras.models import Sequential from keras.layers import Flatten, Dense,Embedding model = Sequential() model.add(Embedding(10000, 8, input_length=maxlen)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid')) # تجميع النموذج model.compile(optimizer='rmsprop', loss=tf.keras.losses.BinaryCrossentropy(from_logits=False), metrics=['acc']) # لاحظ كيف قمنا بتمرير دالة التكلفة # عرض ملخص للنموذج model.summary() # تدريب النموذج history = model.fit(x_train, y_train, epochs=2, batch_size=32, validation_split=0.2) #---------------------------------------------------------- ''' Model: "sequential_2" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= embedding_1 (Embedding) (None, 20, 8) 80000 _________________________________________________________________ flatten_1 (Flatten) (None, 160) 0 _________________________________________________________________ dense_1 (Dense) (None, 1) 161 ================================================================= Total params: 80,161 Trainable params: 80,161 Non-trainable params: 0 _________________________________________________________________ Epoch 1/2 625/625 [==============================] - 2s 2ms/step - loss: 0.6919 - acc: 0.5179 - val_loss: 0.6806 - val_acc: 0.5912 Epoch 2/2 625/625 [==============================] - 1s 2ms/step - loss: 0.6671 - acc: 0.6126 - val_loss: 0.6530 - val_acc: 0.6128 '''  

المشكلة هنا هي أنك تحاول تثبيت Keras  مع إصدار من Numpy لا يحتوي على الوظائف التي تتطلبها Keras، لحل المشكلة يجب ترقية numpy وتنسرفلو:
pip install -U numpy pip install -U tensorflow  

يمكنك استخدامها عبر الموديول:
keras.utils.np_utils يقوم التابع  to_categorical بتحويل البيانات العددية إلى بيانات فئوية ممثلة بأصفار و واحدات ، حيث يقوم بترميز كل قيمة عددية مميزة  (ال class) في شعاع طوله بعدد الفئات Classes المختلفة الموجودة في بياناتنا.
وبشكل أكثر وضوح:
بعد أن يتم إعطاء كل class في مجموعة البيانات  رقمً تعريف فريد Classid  يتراوح بين 1 و | Classes | .
حيث Classes هي مجموعة الفئات (الأصناف) الموجودة لدينا . ثم يتم تمثيل كل فئة  عبر متجه بأبعاد مقدارها | Classes | مملوء كلها بـ صفر باستثناء الفهرس ، حيث index = Classid. حيث نضع في هذا الفهرس ببساطة 1. 
ونستخدمه عادة عندما يكون لدينا مهمة تصنيف متعدد (عندما يكون لدينا عدة فئات).
في المثال التالي لدي شعاع y فيه 3 كلاسات مختلفة وبالتالي كل كلاس سوف يتم تمثيله بشعاع له 3 أبعاد.
# استيراد التابع from keras.utils.np_utils import to_categorical # خرج مزيف y=[0,1,0,2,1,0,1,2,0,1,2] # استخدام المحول الفئوي y=to_categorical(y) #طباعة النتائج print(y) ''' array([[1., 0., 0.], [0., 1., 0.], [1., 0., 0.], [0., 0., 1.], [0., 1., 0.], [1., 0., 0.], [0., 1., 0.], [0., 0., 1.], [1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], dtype=float32) ''' سأقوم بتطبيق هذا التابع لترميز مجموعة بيانات routers، حيث أن هذه البيانات لديها 46 فئة (صنف) مختلف:
# تحميل الداتا from keras.datasets import reuters (train_data, train_labels), (test_data, test_labels) = reuters.load_data( num_words=100) # ترميز الفئات المختلفة للبيانات from keras.utils.np_utils import to_categorical # One-Hot-Enoding one_hot_train_labels = to_categorical(train_labels) one_hot_test_labels = to_categorical(test_labels) # قمنا بعرض فئة أول عينة من بيانات التدريب print('one_hot_train_labels[0]:\n',one_hot_train_labels[0]) ''' one_hot_train_labels[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] ''' # قمنا بعرض فئة أول عينة من بيانات الاختبار print('one_hot_test_labels[0]:\n',one_hot_test_labels[0]) ''' one_hot_test_labels[0]: [0. 0. 0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] ''' ملاحظة: هذا الترميز هو نفسه ال One-Hot-Encoding

لقد سبق وظهرت لي ذات المشكلة، غالباً السبب أن هناك مشكلة في عملية التثبيت أو في المسار، قم بمايلي وسيتم حل المشكلة من جذورها.
قم بتثبيت كل مما يلي:
# قم بحذفهم pip uninstall pydot pip uninstall pydotplus pip uninstall graphviz # ثم أعد تنزيلهم pip install pydot pip install pydotplus pip install graphviz أو باستخدام conda:
# قم بحذفهم أولاً conda uninstall pydot conda uninstall pydotplus conda uninstall graphviz # ثم أعد تنزيلهم conda install pydot conda install pydotplus conda install graphviz ثم قم بتثبيت graphviz binaries على جهازك ثم أضف مسار ال graphviz bin في ال system PATH أثناء التثبيت.

إن بنية المعطيات الأساسية  (data structure)  في Keras  هي "Model" هذا المودل يسمح لنا بتعريف و تصميم  وتنظيم طبقات الشبكة العصبية المطلوب بناءها.
في كيراس فإن أحد أشكال بنية المعطيات هذه (model)  هو الهيكلية التي تسمى Sequential. وهو أبسط أشكال النماذج (طبقات مكدسة فوق بعضها بشكل خطي) وأشهرها وأكثرها استخداماً (مستخدم في أكثر من  95% من النماذج والمهام).
إن دخل كل طبقة في هذه البنية هو tensor  (مصفوفة) واحدة بالضبط وخرجها tensor واحدة بالضبط  (exactly one input tensor and one output tensor).
لتعريف بنية المعطيات Sequential واستخدامها لتصميم وتنظيم شبكة عصبية يجب علينا أولاً أن نقوم باستيرادها، ويتم ذلك من خلال الموديول التالي: keras.models
هناك طريقتان لإضافة وتنظيم الطبقات إلى هذه البنية الأولى بباستخدام التابع add كما في المثال التالي والأخرى عن طريق تمرير قائمة بالطبقات التي نريدها إلى باني الصف Sequential  كما سنرى:
#add باستخدام model.add(layers.Dense(64)) model.add(layers.Dense(32)) model.add(layers.Dense(1)) # Sequential طريقة أخرى حيث نمرر قائمة من الطبقات إلى باني الصف model =Sequential( [ layers.Dense(64), layers.Dense(32), layers.Dense(1), ] ) المثال1: هنا سأقوم بتعريف نموذج باستخدام هذه المعمارية وقمت بترجمته وتدريبه (التدريب وكل شيء قمت به هو عشوائي، غايتي هي فقط أن أبين لك شكل المعمارية كيف يتم الأمر).
# تحميل الدتا from keras.datasets import imdb (train_data, train_labels), (test_data, test_labels) = imdb.load_data( num_words=100) # تحضير الداتا import numpy as np def vectorize_sequences(sequences, dimension=100): results = np.zeros((len(sequences), dimension)) for i, sequence in enumerate(sequences): results[i, sequence] = 1. return results x_train = vectorize_sequences(train_data) x_test = vectorize_sequences(test_data) y_train = np.asarray(train_labels).astype('float32') y_test = np.asarray(test_labels).astype('float32') #----------------------------------------------------------------- # استيراد المكتبات from keras import layers # Sequential استيراد المعمارية from keras.models import Sequential # Sequential إنشاء كائن يمثل نموذج من النوع model = Sequential() # سنضيف الآن عدد من الطبقات بشكل عشوائي #إلى هذا النموذج Fully Conected قمنا بإضافة 3 طبقات من نوع model.add(layers.Dense(64, activation='relu', input_shape=(100,))) # features 100 والدخل لهذه الطبقة هو relu طبقة ب32 خلية وتابع تنشيط model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) # طبقة الخرج حددناها بمخرج واحد فقط #---------------------------------------------------------------- # ثم سنرسم شكل المعمارية باستخدام واجهة برمجة التطبيقات من كيراس لتتضح لك # واجهة برمجة تطبيقات Keras الوظيفية أن تفعل ذلك لنا. from tensorflow.keras.utils import plot_model # قم بتشغيل الكود لترى هيكل النموذج إذا أحببت # هيكل النموذج هو الصورة في الأسفل plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True) #----------------------------------------------------------------- # ثم نقوم بترجمة النموذج وتمرير المعلومات التي يحتاجها model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) # وأخيراً تدريب النموذج history = model.fit(x_train, y_train, epochs=4) #---------------------------------------------------------------- # لتقييم النموذج model.evaluate(x_test,y_test)
إذا هذا النموذج غير جيد في حال كان لديك أكثر من input أوأكثر من output في أي طبقة من طبقاتك، أو إذا كنت بحاجة إلى تشارك الطبقات أو إذا كنت لاتريد أن تكون طبولوجيا الشبكة خطية.
# Writen by: Ali_H_Ahmad
 

هذه الطريقة نادرة الاستخدام عموماً. وهي أحد طرق تقسيم الداتا مثل StratifiedKFold ولكن يختلف عنه بأنه يقوم بأخذ نسبه متساوية من كل صنف في كل مجموعة.. في  StratifiedKFold لو كان لدينا أربع عينات وكل منها يحمل 0و0و1و1 فمن الممكن أن يأخذ 0و0 والمجموعه الثانيه 1و1 وهذا تساوي أما Repeated Stratified KFold سوف يأخذ 0و1 في الأولى و1و0 في الثانية لكي تكون النسبة متساوية لكل صنف في كل مجموعة.
يتم استخدامه عبر الموديل sklearn.model_selection.
#استدعاء المكتبات from sklearn.model_selection import RepeatedStratifiedKFold قمنا باستدعاء المكتبة numpy لتشكيل الداتا
واستدعاء الوظيفه RepeatedStratifiedKFold  من الوحدة model_selection في مكتبة sklearn
#تشكيل الداتا الدخل والخرج X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) y = np.array([1, 0, 1, 0]) حيث X مصفوفة أبعادها 4 أسطر وعمودين وy عمود واحد بأربع أسطر
#RepeatedStratifiedKFold rskf = RepeatedStratifiedKFold(n_splits=5,n_repeats=10, random_state=None) الوسيط الأول n_splits عدد صحيح لتحديد عدد الأجزاء folds وهي افتراضية في sklearn من 3 إلى 5.
الوسيط الثاني n_repeats وهو نقطة الاختلاف عن StratifiedKFold هو عدد صحيح يمثل عدد KFolds.
الوسيط الثالث random_state للتحكم بآلية التقسيم.
نفس الأمر في StratifiedKFold مرور حلقة حيث يتم استخدام اثنين من الاندكسات في الحلقة للمرور على التدريب والاختبار  وتحوي rskf.split(X, y) هذه الاندكسات .
نقوم بطباعة الاندكس للتدريب والاختبار في كل محاولة وبعدها تخزين التدريب والاختبار
ومن ثم طباعة كل منها:
for train_index, test_index in rskf.split(X, y): print("TRAIN:", train_index, "TEST:", test_index) X_train, X_test = X[train_index], X[test_index] y_train, y_test = y[train_index], y[test_index] print('X_train:\n '+str(X_train),end='\n\n') print('X_test:\n '+str(X_train),end='\n\n') print('y_train:\n '+str(X_train),end='\n\n') print('y_test:\n '+str(X_train),end='\n\n')  

ماتزال هذه النسخة تجريبة حتى الآن "experimental" لذا لاستخدامه ، تحتاج إلى استيراد enable_iterative_imputer بشكل صريح لكي يتم استخدام الميزات التجريبية كالتالي:
from sklearn.experimental import enable_iterative_imputer from sklearn.impute import IterativeImputer  

هي أحد طرق تقسيم الداتا هي متل KFold ولكن يختلف عنه بأنه يقوم بأخذ مجموعات متساوية من حيث عدد الفئات في كل مجموعة في حال كانت البيانات بغرض التنصيف
يتم استخدامه عبر الموديل sklearn.model_selection.
#استدعاء المكتبات from sklearn.model_selection import StratifiedKFold قمنا باستدعاء المكتبة numpy لتشكيل الداتا.
واستدعاء الوظيفه StratifiedKFold  من الوحدة model_selection في مكتبة sklearn.
#تشكيل الداتا الدخل والخرج X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) y = np.array([1, 0, 1, 0]) حيث X مصفوفة أبعادها 4 أسطر وعمودين وy عمود واحد بأربع أسطر.
#StratifiedKFold Skf = StratifiedKFold(n_splits=5, *, shuffle=False, random_state=None) الوسيط الأول n_splits عدد صحيح لتحديد عدد الأجزاء folds وهي افتراضية في sklearn من 3 إلى 5.
الوسيط الثاني shuffle تأخذ قيمه بوليانية عند وضعها True تقوم بعمل خلط عشوائي للبيانات وfalse عكس ذلك.
الوسيط الثالث random_state للتحكم بآلية التقسيم.
نفس الأمر في Kfolds مرور حلقة حيث يتم استخدام اثنين من الاندكسات في الحلقة للمرور على التدريب والاختبار  وتحوي skf.split(X) هذه الاندكسات .
نقوم بطباعة الاندكس للتدريب والاختبار في كل محاوله وبعدها تخزين التدريب والاختبار.
ومن ثم طباعة كل منها.
#استدعاء المكتبات from sklearn.model_selection import StratifiedKFold #تشكيل الداتا الدخل والخرج X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) y = np.array([1, 0, 1, 0]) #StratifiedKFold skf = StratifiedKFold(n_splits=2, shuffle=False, random_state=None) for train_index, test_index in skf.split(X, y): print("TRAIN:", train_index, "TEST:", test_index) X_train, X_test = X[train_index], X[test_index] y_train, y_test = y[train_index], y[test_index] print('X_train:\n '+str(X_train),end='\n\n') print('X_test:\n '+str(X_train),end='\n\n') print('y_train:\n '+str(X_train),end='\n\n') print('y_test:\n '+str(X_train),end='\n\n')  

المشكلة في قيم معامل التنعيم C حيث أن القيم المسموح بها هي القيم الموجبة تماماً أي الأكبر تماماً من الصفر، وأنت تحاول تجريب القيمة C=0 وهذا سينتج عنه خطأ.
لحل المشكلة يمكنك إعطاء C قيمة متناهية في الصغر بحيث تكون مهملة (أي وكأنها صفر) :
from sklearn.svm import SVR from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.model_selection import GridSearchCV import pandas as pd BostonData = load_boston() X = BostonData.data y = BostonData.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0, shuffle =True) SelectedModel = SVR() Selected = {'kernel':('linear', 'rbf'),'C': [0.000001, 0.7, 8]} GridSearchModel = GridSearchCV(SelectedModel,Selected, cv = 2,return_train_score=True) GridSearchModel.fit(X_train, y_train)  

هو أداة تستخدم لتنظيف البيانات أو معالجة البيانات قبل عملية التدريب، يستخدم في عملية تحديد وجود قيم مفقودة في البيانات حيث يرد مصفوفة بوليانية كل عمود فيها يمثل عمود في البيانات وتحوي فقط الأعمدة التي تحوي قيم مفقودة أي في حال وجود عمود لا يحوي قيم مفقودة لا يقوم بإعطاء عمود له في المصفوفة أما عند وجود قيمة مفقودة في عمود ما يتم إضافة عمود إلى المصفوفة تكون كل قيمه True و مكان القيمة المفقودة false.
يتم استخدامه عبر الموديول:
sklearn.impute #استدعاء المكتبات: from sklearn.impute import MissingIndicator في البداية قمنا باستدعاء المكتبة التي يوجد فيها  MissingIndicator.
#الشكل العام MissingIndicator: MI=MissingIndicator(missing_values=nan, features='missing-only', sparse='auto') الوسيط الأول missing_values القيمة المفقودة أي القيمة التي سوف يتم البحث عنها في البيانات و في كثير من الأمثلة تكون القيمة المفقودة Nan أو 0.
الوسيط الثاني  features في حال كان هذا الوسيط يساوي missing-only بتالي سوف يتم طباعة المصفوفة البوليانة كما ذكرنا سابقا في تعريف MissingIndicator أما في حال all فسوف يتم طباعتها بالكامل مع كافة الأعمدة التي تحوي قيم مفقودة ولا تحوي قيم مفقودة.
الوسيط الثالث sparse يتحكم في طباعة المصفوفة إذا كان auto تكون المصفوفة مثل مصفوفة الدخل واذا كان false سوف تكون المصفوفة كاملة أيضا إذا كان true فسوف تكون المصفوفة بدون الميزات التي لا تحوي قيم مفقودة لذلك يتم وضعه auto لترك MissingIndicator يقرر المناسب.
طريقة استخدامه:
MI=MissingIndicator(missing_values=nan, features='missing-only',                      sparse='auto') MI.fit_transform(X) حيث الدالة fit_transform يوجد ضمنها جميع العمليات الداخلية لعملية حساب القيم و تطبيقها على البيانات.
لنأخذ مثال يوضح MissingIndicator.
#استدعاء المكتبات import numpy as np from sklearn.impute import MissingIndicator #تعين داتا دخل مزيفة X = np.array([[np.nan, 2, 3],                 [0, 1, np.nan],                 [8, 3, 0]]) #طباعة القيم الناتجه لمعرفة مكان القيم المفقوده  MI=MissingIndicator(missing_values=np.nan, features='missing-only',sparse=False) MI.fit_transform(X) #النتيجة array([[ True, False],        [False,  True],        [False, False]])  

هي أداة نستخدمها لتطبيق العديد من المعاملات العليا hyperparameters على نموذجنا، لتجريبها و اختيار الأفضل منها.
 يتم استخدامها عبر الموديول:
model_selection.GridSearchCV خطوات تنفيذها:
1.     استيراد المكتبة.
from sklearn.model_selection import GridSearchCV 2.     استيراد الموديل المطلوب فحصه وإنشاؤه.
3.     عمل قاموس بحيث يكون فيه المفتاح هو اسم الـ parameter  و القيمة هي القيم المطلوب تجريبها له.
4.     تنفيذ GridSearchCV  حيث نمرر له الموديل المطلوب تنفيذه و القاموس الذي يحوي مانريد نتجريبه.
5.     ثم إظهار النتائج عبر عدد من الـ attributes التي سنوردها في المثال (ستكون كل الأمور واضحة جداً) .
حيث يجرب GridSearchCV جميع مجموعات القيم التي تم تمريرها في القاموس ويقيم النموذج لكل مجموعة باستخدام طريقة Cross-Validation. ومن ثم، بعد استخدام هذه الوظيفة ، نحصل على الدقة / الخسارة لكل مجموعة من المعلمات العليا ويمكننا اختيار الأفضل أداءً.
الصيغة:
sklearn.model_selection.GridSearchCV(estimator, param_grid, scoring=None, n_jobs=None, cv=None, verbose=0, return_train_score=False) 1.estimator: النموذج الذي تريد التحقق من المعلمات العليا الخاصة به.
2.params_grid: كائن القاموس الذي يحتوي على المعلمات العليا التي تريد تجربتها.
3-scoring: مقياس التقييم الذي تريد استخدامه.
4.cv: عدد عمليات التحقق المتبادل التي يجب أن تجربها لكل مجموعة مختارة من المعلمات العليا.
5. overbose: يمكنك ضبطه على 1 للحصول على نسخة مطبوعة مفصلة أثناء ملائمة البيانات لـ GridSearchCV .
6.n_jobs: عدد العمليات التي ترغب في تشغيلها بالتوازي لهذه المهمة إذا كانت -1 ستستخدم جميع المعالجات المتاحة.
الوسيط الأخير إذا كان False، فلن تتضمن السمة cv_results_  ال score للتدريب.
مثال:
from sklearn.svm import SVR from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.model_selection import GridSearchCV import pandas as pd # تحميل البيانات BostonData = load_boston() X = BostonData.data y = BostonData.target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0, shuffle =True) #تطبيق GridSearchCV SelectedModel = SVR() ''' :نحدد الآن في القاموس التالي مايلي 1. المفاتيح التي تمثل المعاملات العليا المطلوب إجراء التجريب عليها 2.القيم المراد اختبارها من أجل كل مفتاح لاحظ أننا حددنا للكيرنل قيمتين ليتم تجريبهم وهم linear و rbf :وحددنا للإبسلون القيم التالية 0.1 0.2 0.3 ''' Selected = {'kernel':('linear', 'rbf'), 'epsilon':[0.1,0.2,0.3]} GridSearchModel = GridSearchCV(SelectedModel,Selected, cv = 2,return_train_score=True) # للبدأ بالتدريب GridSearchModel.fit(X_train, y_train) sorted(GridSearchModel.cv_results_.keys()) GridSearchResults = pd.DataFrame(GridSearchModel.cv_results_)[['mean_test_score', 'std_test_score', 'params' , 'rank_test_score' , 'mean_fit_time']] # عرض النتائج print('All Results :', GridSearchResults ) # عرض أفضل نتيجة print('Best Score is :', GridSearchModel.best_score_) # عرض أفضل المعاملات العليا print('Best Parameters :', GridSearchModel.best_params_) #Estimator عرض أفضل print('Best Estimator :', GridSearchModel.best_estimator_) # الخرج ''' All Results : mean_test_score std_test_score params \ 0 0.744228 0.009539 {'epsilon': 0.1, 'kernel': 'linear'} 1 0.234970 0.049682 {'epsilon': 0.1, 'kernel': 'rbf'} 2 0.743469 0.009218 {'epsilon': 0.2, 'kernel': 'linear'} 3 0.232345 0.049925 {'epsilon': 0.2, 'kernel': 'rbf'} 4 0.744154 0.009648 {'epsilon': 0.3, 'kernel': 'linear'} 5 0.231108 0.053474 {'epsilon': 0.3, 'kernel': 'rbf'} rank_test_score mean_fit_time 0 1 0.956472 1 4 0.001997 2 3 1.818950 3 5 0.002998 4 2 1.063380 5 6 0.002010 Best Score is : 0.7442279764447716 Best Parameters : {'epsilon': 0.1, 'kernel': 'linear'} Best Estimator : SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='scale', kernel='linear', max_iter=-1, shrinking=True, tol=0.001, verbose=False) ''' مثال آخر:
# استيراد المكتبات import sklearn from sklearn.svm import SVC from sklearn.model_selection import GridSearchCV from sklearn.model_selection import train_test_split from sklearn.datasets import load_breast_cancer from sklearn.metrics import classification_report, confusion_matrix from sklearn.datasets import load_breast_cancer # تحميل بياناتك dataset = load_breast_cancer() X=dataset.data Y=dataset.target # تقسيمها X_train, X_test, y_train, y_test = train_test_split(X,Y,test_size = 0.2, random_state = 1) # تحديد مانريد اختباره param_grid = {'C': [0.1, 0.7, 8], 'gamma': [1, 0.1, 0.01, 0.0001], 'gamma':['scale', 'auto'], 'kernel': ['linear','rbf']} #GridSearchCV إنشاء ال grid = GridSearchCV(SVC(), param_grid, refit = True,cv=2) # بدأ التدريب والتجريب grid.fit(X_train, y_train) # عرض أفضل المعاملات print(grid.best_params_) # توقع القيم grid_predictions = grid.predict(X_test) #classification_report عرض ال print(classification_report(y_test, grid_predictions)) ''' {'C': 0.1, 'gamma': 'scale', 'kernel': 'linear'} precision recall f1-score support 0 1.00 0.86 0.92 42 1 0.92 1.00 0.96 72 accuracy 0.95 114 macro avg 0.96 0.93 0.94 114 weighted avg 0.95 0.95 0.95 114 '''  

إليك لطرق المستخدمة:
import math import numpy x= np.array([0, 1, 2, 3, 4, 5]) g = lambda x: x ** 2 vg = numpy.vectorize(g) def array_for(v): return numpy.array([g(vi) for vi in v]) def array_map(v): return numpy.array(list(map(g, v))) def fromiter(v): return numpy.fromiter((g(vi) for vi in v), v.dtype) def vectorize(v): return numpy.vectorize(g)(v) def vectorize_without_init(v): return vg(v) والاختلاف في التعقيد "complexity" كما في الصورة المرفقة.
لاحظ أن التعقيد الزمني يصبح متساوي تقريباً (الفرق في التعقيد يصبح مهمل تقريباً) عندما يزداد طول x عن 2^10.

إضافة إلى الطرق التي قدمها الأستاذ وائل.
سأضيف لك طريقة هي الأسرع، حيث أنه يوجد العديد من الطرق لحسابها في بايثون و الفرق بينهم هو التعقيد الزمني.
حيث يتم استخدام الدالة (Einstein’s summation)einsum  كالتالي:
import numpy as np point1 = numpy.array((2, 1, 2)) point2 = numpy.array((2, 1, 2)) # التابع التالي سيحسب لك المسافة من أجل نقاط أحادية وثنائية وثلاثية الأبعاد def dist(p1, p2, metric='euclidean'): p1 = np.asarray(p1) p2 = np.atleast_2d(p2) p1_dim = p1.ndim p2_dim = p2.ndim if p1_dim == 1: p1 = p1.reshape(1, 1, p1.shape[0]) if p1_dim >= 2: p1 = p1.reshape(np.prod(p1.shape[:-1]), 1, p1.shape[-1]) if p2_dim > 2: p2 = p2.reshape(np.prod(p2.shape[:-1]), p2.shape[-1]) diff = p1 - p2 dist_arr = np.einsum('ijk,ijk->ij', diff, diff) if metric[:1] == 'e': dist_arr = np.sqrt(dist_arr) dist_arr = np.squeeze(dist_arr) return dist_arr dist(point1,point2) # array(0.) لاحظ التعقيد كيف يختلف من طريقة لأخرى.

يتم استخدامه عبر الموديول:
sklearn.impute #استدعاء المكتبات: from sklearn.impute import KNNImputer في البداية قمنا باستدعاء المكتبة التي يوجد فيها  KNNImputer.
#الشكل العام KNNImputer: imputerKNN=KNNImputer(missing_values=nan, n_neighbors=5,                       weights='uniform',metric='nan_euclidean', copy=True) الوسيط الأول missing_values القيمة المفقودة أي القيمه التي سنضع مكانها ما ينوب عنها وفي كثير من الأمثلة تكون القيمه المفقودة Nan أو 0.
الوسيط الثاني n_neighbors عدد الجيران الذي سيتم حساب القيمة المتوسطة لهم من أجل عينة تحوي قيمة مفقودة.
الوسيط الثالث  weights هذا الوسيط يحدد الأساس الذي سيسير عليه KNNImputer حيث يأخذ  قيمتين هي  ‘uniform’ حيث تعني أن الجار القريب أو البعيد لهم نفس التأثير أي لا يفرق أحدهما في عملية حساب القيمة المتوسطة  أما  ‘distance’ هنا يتم اعتماد المسافة كعامل تقييم أي الاقرب مسافة إلى المثال الذي يتم التنبؤ بقيمته بتالي سوف يكون تأثير الجار ذو المسافة الأقل أكبر من الجار ذو المسافة الأبعد  
الوسيط الرابع metric مقياس المسافة للبحث عن الجيران.
الوسيط الخامس copy عند وضع هذا الوسيط True يتم أخذ نسخه من البيانات false عكس ذلك أي يتم التطبيق على البيانات الاصلية.
مثال:
#استدعاء المكتبات import numpy as np from sklearn.impute import KNNImputer #تعين داتا دخل مزيفة X = [[3, 4, np.nan], [3, 4, 3], [np.nan, 1, 2], [8, 8, 7]] #طباعة القيم بعد عملية التنظيف imputerKNN= KNNImputer(n_neighbors=2) imputerKNN.fit_transform(X) #النتيجة array([[3. , 4. , 2.5],        [3. , 4. , 3. ],        [3. , 1. , 2. ],        [8. , 8. , 7. ]]) حيث الدالة fit_transform يوجد ضمنها جميع العمليات الداخلية لعملية حساب القيم و تطبيقها على البيانات.

QDA(Quadratic Discriminant Analysis)
هو طريقة تستخدم في تقليل الأبعاد وخاصة في مسائل التصنيف التابعة بالتعليم بإشراف فلو كان لدينا عملية تصنيف ما لأكثر من صنف هو نفس LDA الفرق الوحيد أن LDA عملية الفصل لديه خطية أما  QDA مربعة، ويمكن استخدامه كموديل للتنصيف.
يتم استخدامه عبر الموديول:
sklearn.discriminant_analysis استدعاء المكتبات:
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل.
الشكل العام للموديل:
QDA=QuadraticDiscriminantAnalysis(priors=None, reg_param=0.0,  tol=0.0001) الوسيط الأول  priors قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف.
الوسيط الثاني reg_param يمثل معامل التنعيم.
الوسيط الثالث tol مقدار التسامح في التقارب من القيم الدنيا.
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test, y_test  تسطيع كتابة الأتي لعملية التدريب.
#الشكل العام للموديل QDA=QuadraticDiscriminantAnalysis( priors=None, reg_param=0.0,tol=0.0001) QDA.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي:
#حساب القيم المتوقعة y_pred =َQDA.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل:
# حساب الكفاءه على الاختبار والتدريب print('QDA Train Score is : ' , QDA.score(X_train, y_train)) print('QDA Test Score is : ' , QDA.score(X_test, y_test)) لنأخذ مثال يوضح المصنف:
قمنا باستدعاء المكتبات وبناء عينة مزيفه وكان التصنيف ثنائي أما 1 أو 0.
ثم قمنا بتجريب الموديل على عينة معطاة.
# استدعاء المكتبات import numpy as np from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis #تعين داتا دخل مزيفة X = np.array([[1, 1], [3, 1], [-3, -2], [-1, -1], [-3, -1], [3, 2]]) y = np.array([1, 0, 0, 1, 1, 1]) #بناء الموديل QDA = QuadraticDiscriminantAnalysis() QDA.fit(X,y) #طباعة تصنيف العينه print(QDA.predict([[-1, -0.4]])) #النتيجة #[1]  

LDA(Linear Discriminant Analysis)
هي طريقة تستخدم في تقليل الأبعاد وخاصة في مسائل التصنيف التابعة بالتعليم بإشراف فلو كان لدينا عملية تصنيف ما لأكثر من صنف وكان تمثيل الداتا بالمستوى ثنائي الابعاد فالخط المستقيم يمكن أن يكون غير كافي في عملية الفصل لذلك يتم استخدام LDA ليقوم بتحويل المستوي ثنائي الابعاد إلى أحادي الأبعاد.
ويمكن استخدامه كموديل للتنصيف.
يتم استخداه عبر الموديول:
sklearn.discriminant_analysis استدعاء المكتبات:
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل.
# الصيغة المبسطة للموديل:
LDA=LinearDiscriminantAnalysis(solver='svd', shrinkage=None,                                 priors=None, n_components=None,                                tol=0.0001) الوسيط الأول solver يمثل طريقة الحل ويأخذ ثلاث قيم  {‘svd’, ‘lsqr’, ‘eigen’}
الوسيط الثاني shrinkage معامل تنعيم يستخدم لتحسين تقدير المصفوفات في حال كان عدد عينات التدريب صغير وعدد الميزات كبير
الوسيط الثالث priors قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف
الوسيط الرابع n_components هو عدد حقيقي أو صحيح يشير إلى عدد المكونات التي سيتم الإبقاء عليها المقصود بالمكونات أٌقل عدد أمثلة وعدد الفيتشرز وإذا أخذ None يتم الاحتفاظ بجميع المكونات
الوسيط الخامس tol مقدار التسامح في التقارب من القيم الدنيا
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جداً فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test, y_test  تسطيع كتابة الأتي لعملية التدريب
# الشكل العام للموديل:
LDA=LinearDiscriminantAnalysis(solver='svd', shrinkage=None,                                 priors=None, n_components=None,                                tol=0.0001 ) LDA.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي..
#حساب القيم المتوقعة:
y_pred =LDA.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل:
حساب الكفاءة على الاختبار والتدريب:
print('LDA Train Score is : ' , LDA.score(X_train, y_train)) print('LDA Test Score is : ' , LDA.score(X_test, y_test)) لنأخذ مثال يوضح المصنف..
قمنا باستدعاء المكتبات وبناء عينة مزيفة وكان التصنيف ثنائي أما 1 أو 0.
ثم قمنا بتجريب الموديل على عينة معطاة.
استدعاء المكتبات import numpy as np from sklearn.discriminant_analysis import LinearDiscriminantAnalysis #تعين داتا دخل مزيفة X = np.array([[1, 1], [3, 1], [-3, -2], [-1, -1], [-3, -1], [3, 2]]) y = np.array([0, 0, 1, 1, 0, 1]) #بناء الموديل LDA = LinearDiscriminantAnalysis() LDA.fit(X,y) #طباعة تصنيف العينه print(LDA.predict([[-1, -0.4]])) #النتيجة #[0]  

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

في النسخ الحديثة من Sklearn أصبحت هذه الكلاسات موجودة في الموديول model_selection لذا لإصلاح الأمر قم باستيرادها من مكانها الجديد كالتالي:
from sklearn.model_selection import learning_curve, GridSearchCV  

لانستخدم الترميز One-Hot مع توابع حساب كفاءة النموذج في Sklearn.
المشكلة في أن مصفوفة الCM لاتقبل أن تكون مدخلاتها من الشكل One-Hot، وإنما يجب أن تكون كالتالي:
y_true (n_samples,) y_predict(n_samples,) وبالتالي لحل مشكلتك يجب أن لاتستخدم التحويل One-Hot مع المصفوفة CM.
إذا أردت إرجاع بياناتك لشكلها الطبيعي (بدون ال One-Hot) يمكنك استخدام التابع  argmax على للبيانات التي حولتها إلى الترميز One-Hot كالتالي:
y=y.argmax(axis=1) ثم يمكنك حساب ال CM بدون مشاكل.
إليك مثال:
# هكذا تتوقع المصفوفة أن تكون مدخلاتها from sklearn.metrics import confusion_matrix y_true = [1, 1, 0, 2, 0, 1] y_pred = [1, 0, 2, 2, 0, 2] confusion_matrix(y_true, y_pred)  

قد يظهر هذا الخطأ في أي نموذج آخر في Sklearn بشكل مشابه تماماً.
المشكلة تظهر في التابع fit ، حيث أن التابع يتوقع أبعاد X بالشكل:
[n_samples,n_features] لكنك تعطيه مصفوفة من الشكل:
[n_samples,] لحل المشكلة قم بإعادة تعيين الأبعاد:
X=X.reshape(-1,1) lr.fit(X ,y)