Ali Haidar Ahmad

توفر Sklearn القيام بالتوقع الخطي مع التنعيم عن طريق استخدام  الكلاس Ridge.
يتم استخدامها عبر الموديول linear_model.Ridge كالتالي:
sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True, normalize=False, copy_X=True, max_iter=None, tol=0.001, solver='auto', random_state=None) الوسطاء:
fit_intercept: لجعل المستقيم يتقاطع مع أفضل نقطة على المحور العيني y.
copy_X: وسيط بولياني، في حال ضبطه على True سوف يأخذ نسخة من البيانات ، وبالتالي لاتتأثر البيانات الأصلية بالتعديل، ويفيدنا في حالة قمنا بعمل Normalize للبيانات.
normalize: وسيط بولياني، في حال ضبطه على True سوف يقوم بتوحيد البيانات (تقييسها) اعتماداً على المقياس
n_jobs: لتحديد عدد العمليات التي ستتم بالتوازي (Threads) أي لزيادة سرعة التنفيذ، افتراضياُ تكون قيمته None أي بدون تسريع، وبالتالي لزيادة التسريع نضع عدد صحيح وكلما زاد العدد كلما زاد التسريع (التسريع يتناسب مع قدرات جهازك)، وفي حال كان لديك GPU وأردت التدريب عليها فقم بضبطه على -1.
random_state: للتحكم بآلية التقسيم.
max_iter: العدد الأقصى للتكرارات.
tol: مقدار التسماح في التقارب من القيم الدنيا. float, default=1e-3
solver: ال Optimezer المستخدم. 
solver{‘auto’, ‘svd’, ‘cholesky’, ‘lsqr’, ‘sparse_cg’, ‘sag’, ‘saga’}, default=’auto’
alpha: هو معامل التنعيم ويأخذ قيم من الصفر إلى n، و كلما زادت القيمة زاد تأثير التنعيم. default=1.0.
أهم ال attributes:
_coef: الأوزان التي حصلنا عليها بعد انتهاء التدريب وهي مصفوفة بأبعاد (,عدد الfeatures).
intercept: التقاطع مع المحور y.
أهم التوابع:
fit(data, truevalue): للقيام بعملية التدريب.
predict(data): دالة التوقع ونمرر لها البيانات وتعطيك التوقع لها.
score(data, truevalue): لمعرفة مدي كفاءة النموذج ونمرر لها بيانات الاختبار والقيم الحقيقية لها فيقوم بعمل predict للداتا الممررة ثم يقارنها بالقيم الحقيقية ويرد الناتج حسي معيار R Squaerd.
يمكن تطبيقه كما يلي:
from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.linear_model import Ridge # تحميل الداتا BostonData = load_boston() data = BostonData.data labels = BostonData.target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, shuffle =True, random_state=2021) # تطبيق التابع RidgeRegression = Ridge(alpha=0.5,random_state=20,solver='auto') RidgeRegression.fit(X_train, y_train) #Calculating Details print('Train Score is : ' , RidgeRegression.score(X_train, y_train)) print('Test Score is : ' , RidgeRegression.score(X_test, y_test)) #print('Coef is : ' , RidgeRegression.coef_) print(RidgeRegression.predict(X_test))  

هي نموذج للتصنيف باستخدام الشبكات العصبونية
يتم استخدامها عبر الموديول neural_network.MLPClassifier
مثل أي نموذج في التعلم الألي يوجد لديه العديد من المعاملات التي تلعب دورا أساسيا في عملية تعلم الموديل عبر داتا التدريب لنقوم بالمرور على أهم المعاملات التي يأخذها هذا النموذج 
#استدعاء المكتبة
from sklearn.neural_network import MLPClassifier في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل
MLPClassifierModel = MLPClassifier(activation='tanh', solver='adam', learning_rate='constant', early_stopping= False, alpha=0.0001 ,hidden_layer_sizes=(100, 3)) البارمتر الأول activation مثلما نعرف يوجد في الشبكات العصبونية عدة أنواع لتوابع التنشيط أو activation ومن أهمها تابع sigmoid , relu,tanh لن أدخل في تفاصيل كل منها فأي دورة تعلم الآلة أو تعلم عميق تحوي هذه المفاهيم ولكن كنصيحه نقوم بجعل relu لجميع الطبقات ماعدا الأخيره أما الطبقة الأخيره نستخدم sigmod
البارمتر الثاني  solver هو طريقة الحل أو طريقة الوصول إلى أفضل قيم w,b الأوزران الخاصه بالشبكه العصبونية يوجد أكثر من طريقه مثل sgd ,adam ولكن  ننصح باستخدام adam دوما
البارمتر الثالث learning_rate هو معامل التعلم وهو يمثل مقدار الخطوه للوصول إلى الأوزران ويمكن تركه costant أي خطوات ثابتة أو  adaptive متغيره أما ان تكون طويله أو قصيرة 
البارمتر الرابع early_stopping التوقف المبكر وهو يأخذ True بحال أردنا أيقاف معامل التعلم عند نقطه بحيث لا يدخل الموديل في مرحلة overfit أي الضبط الزائد وfalse عكس ذلك
البارمتر الخامس alpha يمثل معامل التنعيم حيث التنعيم هو طريقة لكي يتخلص الموديل من الضبط الزائد overfit ويلعب alpha دورا مهما في ذلك
البارمتر السادس hidden_layer_sizes وهو يمثل عدد الطبقات ماعدا طبقة الدخل والخرج لأنهما لا تعتبرا طبقات مخفيه وعدد الخلايا في كل طبقه حيث الأرقام تدل على عدد الخلايا في الطبقه أما موقع الرقم يدل على الطبقه وعدد المواقع يدل على عدد الطبقات المخفيه فمثلا (10,200,30,4) يوجد أربعة طبقات لأنه يوجد أربع أرقام وكل رقم منها يدل على عدد الخلايا في طبقته مثلا الطبقة الأولى تحوي 10 خلايا
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test, y_test  تسطيع كتابة الأتي لعملية التدريب 
 
MLPClassifierModel = MLPClassifier(activation='tanh', solver='adam', learning_rate='constant', early_stopping= False, alpha=0.0001 ,hidden_layer_sizes=(100, 3)) MLPClassifierModel.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لتدريب الشبكه العصبية 
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي:
y_pred = MLPClassifierModel.predict(X_test) حيث قمنا بالتنبؤ بقيم التصنيف لداتا الاختبار
نستطيع أيضا حساب دقة الموديل أو كفاءته عن طريق التابع score ويكون وفق الشكل:
print('MLPClassifierModel Test Score is : ' , MLPClassifierModel.score(X_test, y_test)) حيث قمنا بطباعة قيمتها لكي نرى كفاءة الموديل على بيانات الاختبار وهل هو يعاني من الضبط الزائد  overfit أو الضبط الناقص underfit.

في مكتبة sklearn يتطلب الأبعاد (رقم الصف,رقم العمود) ومن المؤكد أن شكل الأبعاد لديك هي (999,) وبالتالي فلن تعمل لأنه يفقد رقم العمود يكون الحل باستخدام الوظيفه reshape من المكتبة numpy لجعلها (999,1)
الكود:
data=data.reshape((999,1))  

في الإصدارات الحديثة من تنسرفلو تم حذف هذه الدالة  وأصبح بإمكانك استخدام ال generators مع الدالة Model.fit لذا لديك حلين إما أن  تقوم بتثبيت إحدى الإصدارات السابقة مثل 1.15 من تنسرفلو كالتالي:
pip install tensorflow==1.15  أو أن تقوم باستخدام الدالة Model.fit :
# generetors الشكل العام للتابع في حالة كانت بياناتك ليست fit( x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False, **kwargs ) # generetors في حالة كانت بياناتك fit( data_generetors, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False, **kwargs ) لكن في الحالة الثانية لن تكون قادراً على استخدام الخاصية validation_data أو validation_split والخواص الأخرى المتعلقة بهم لذا قد يكون الحل الأفضل استخدام إصدار سابق لحل مشكلتك في حال كنت تعتمد validation_generator

الخطأ هو عدم وجود  sklearn في نظامك، ولحل المشكلة يجب تثبيت مكتبة sklearn ويمكنك ذلك عن طريق:
أما فتح موجه الأوامر cmd وكتابة التعليمة التالية:
pip install -U scikit-learn أو من خلال الكتابة على موجه الأوامر في anconda إن كنت تستخدمها:
conda install scikit-learn أو من خلال الكتابة في jupyter notebook:
pip install scikit-learn  

Stochastic Gradient Descent (SGD) Classifier
تقوم بعمل  Logistic Regression لكن باستخدام خوارزمية التحسين ال Stochastic Gradient Descent.
يمكنك استخدامها عبر الموديول: linear_model.SGDClassifier
sklearn.linear_model.SGDClassifier(loss='hinge', *, penalty='l2', alpha=0.0001, fit_intercept=True, max_iter=1000, tol=0.001, shuffle=True, verbose=0, epsilon=0.1, n_jobs=None, random_state=None, learning_rate='optimal', early_stopping=False) الوسطاء:
loss: هي دالة التكلفة المستخدمة، وكون المهمة هي مهمة تصنيف نستخدم الدالة  الافتراضية دوماً. أي hinge.
penalty: وهو نوع التنعيم المستخدم.
learning_rate: وهو معامل التعلم (مقدار الخطوة).
max_iter: العدد الأقصى للمحاولات.
early_stopping: في حال ضبطه على True سيتم تطبيق خاصية التوقف المبكر (لمنع ال Overfitting عندما تنهار الدقة على عينة التطوير مقابل عينة الاختبار).
shuffle: لخلط البيانات.
verbose: ضبطه على أي قيمة غير الصفر سيعطيك التفاصيل أثناء التدريب.
random_state: تتحكم بنظام العشوائية.
ال attributes:
coef_: الأوزان.
intercept_: التقاطع مع المحور y، ضبطه على False يجبر الكلاسيفير على المرور من المبدأ 0،0 لذا يفضل ضبطه على True لإعطاء الحرية للكلاسيفير.
n_iter_: عدد المحاولات التي تم تنفيضها خلال التدريب حتى الوصول لمرحلة التقارب من القيم الدنيا.
الدوال:
fit(X, y): لبدء التدريب على بياناتك.
predict(X): لتوقع قيم الدخل اعتماداً على قيم الأوزان.
score(X, y): لتقدير مدى كفاءة النموذج.
مثال على مجموعة بيانات Iris Data :
from sklearn.model_selection import train_test_split from sklearn.linear_model import SGDClassifier from sklearn.metrics import confusion_matrix from sklearn.datasets import load_breast_cancer import seaborn as sns import matplotlib.pyplot as plt # تحميل البيانات Data = load_breast_cancer() X = Data.data y = Data.target # تقسيم البيانات إلى عينات تدريب واختبار X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=44, shuffle =True) # SGDClassifier تطبيق SGDC = SGDClassifier(penalty='l1',loss='hinge',learning_rate='optimal',random_state=44) SGDC.fit(X_train, y_train) print('SGDC Train Score is : ' , SGDC.score(X_train, y_train)) print('SGDC Test Score is : ' , SGDC.score(X_test, y_test)) # SGDC Test Score is : 0.9414893617021277 print('SGDC loss function is : ' , SGDC.loss_function_) print('SGDC No. of iteratios is : ' , SGDC.n_iter_) # عرض مصفوفة التشتت c = confusion_matrix(y_test, SGDC.predict(X_test)) print('Confusion Matrix is : \n', c) #لرسم المصفوفة sns.heatmap(c, center = True) plt.show()  

يمكنك استخدامه عبر الموديول:  preprocessing.PolynomialFeatures
وهو يستخدم مع التوقع الخطي لإعطاء البيانات الصفة اللاخطية، فكما تعلم أن الفرضية المستخدمة مع التوقع الخطي هي معادلة خط مستقيم من الشكل : y=wx+b وبالتالي معادلة مستقيم، وبالتالي في حال البيانات التي لها الشكل التالي لن تكون قادرة على ملاءمتها:


 
حيث سيكون شكل ال Regressor بعد التدريب كالتالي:

وبالتالي لملاءمة هكذا نوع من البيانات يجب أن تضيف لبياناتك الصفة اللاخطية وبالتالي تكون معادلة ال Regressor قادراة على ملائمة البيانات بالشكل المطلوب كالتالي:

أي يجب أن تكون معادلة ال Regressor كالتالي:
y=b+x1+x1^2+,,,,+x1^n
للقيام بذلك باستخدام Sklearn:
sklearn.preprocessing.PolynomialFeatures(degree=2, include_bias=True) degree: درجة كثير الحدود المطلوبة.
include_bias: لتضمين الانحراف bias في العملية.
مثال:
import numpy as np from sklearn.preprocessing import PolynomialFeatures X = np.arange(4).reshape(2, 2) # تشكيل مصفوفة بقيم عشوائية print(X) ''' array([[0, 1], [2, 3]]) ''' poly = PolynomialFeatures(2) print(poly.fit_transform(X)) # للقيام بعملية التحويل نستدعي هذ التابع ''' array([[1. 0. 1. 0. 0. 1.] [1. 2. 3. 4. 6. 9.]]) '''  

يمكن ذلك باستخدام مكتبة pands في البداية نقوم باستيراد المكتبة:
import pandas as pd بعد ذلك نقوم بقراءة الملف وفق الرابط url:
xls = pd.ExcelFile(url) بعد ذلك نقوم بحساب عدد ال sheet في الملف من خلال تطبيق len على قائمة الأسماء sheet_names، حيث أن xls.sheet_names قائمه تحوي أسماء ال sheet في الملف:
namesheet=xls.sheet_names تعريف قائمة فارغة لوضع ال sheet فيها:
frames=[] مرور حلقة على عدد ال sheet وقراءة كل شيت باستخدام read_excel من pandas وإضافتها للقائمه frames:
for i in range(numsheet): df1 = pd.read_excel(xls,namesheet[i]) frames.append(df1) بعد ذلك نقوم بدمج جميع ال sheet الموجودة في frames باستخدام concat:
df = pd.concat(frames) أي شيئ آخر؟

إذا كانت المهمة مهمة توقع كما أشرت، فإنه يتم استخدام MLPRegressor و هو نموذج للتوقع باستخدام الشبكات العصبونية
يتم استخدامه عبر الموديول:
neural_network.MLPRegressor مثل أي نموذج في التعلم الآلي يوجد لديه العديد من المعاملات التي تلعب دورا أساسيا في عملية تعلم الموديل عبر داتا التدريب لنقوم بالمرور على أهم المعاملات التي يأخذها هذا النموذج 
#استدعاء المكتبة:
from sklearn.neural_network import MLPRegressor في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل:
MLPRegressorModel = MLPRegressor(activation='tanh', solver='adam', learning_rate='constant', early_stopping= False, alpha=0.0001 ,hidden_layer_sizes=(100, 3))  البارمتر الأول activation مثلما نعرف يوجد في الشبكات العصبونية عدة أنواع لتوابع التنشيط أو activation ومن أهمها تابع sigmoid , relu,tanh لن أدخل في تفاصيل كل منها فأي دورة تعلم الآلة أو تعلم عميق تحوي هذه المفاهيم ولكن كنصيحه نقوم بجعل relu لجميع الطبقات ماعدا الأخيره أما الطبقة الأخيره نستخدم sigmod
البارمتر الثاني  solver هو طريقة الحل أو طريقة الوصول إلى أفضل قيم w,b الأوزران الخاصه بالشبكه العصبونية يوجد أكثر من طريقه مثل sgd ,adam ولكن  ننصح باستخدام adam دوما
البارمتر الثالث learning_rate هو معامل التعلم وهو يمثل مقدار الخطوه للوصول إلى الأوزران ويمكن تركه costant أي خطوات ثابتة أو  adaptive متغيره أما ان تكون طويله أو قصيرة 
البارمتر الرابع early_stopping التوقف المبكر وهو يأخذ True بحال أردنا أيقاف معامل التعلم عند نقطه بحيث لا يدخل الموديل في مرحلة overfit أي الضبط الزائد وfalse عكس ذلك
البارمتر الخامس alpha يمثل معامل التنعيم حيث التنعيم هو طريقة لكي يتخلص الموديل من الضبط الزائد overfit ويلعب alpha دورا مهما في ذلك
البارمتر السادس hidden_layer_sizes وهو يمثل عدد الطبقات ماعدا طبقة الدخل والخرج لأنهما لا تعتبرا طبقات مخفيه وعدد الخلايا في كل طبقه حيث الأرقام تدل على عدد الخلايا في الطبقه أما موقع الرقم يدل على الطبقه وعدد المواقع يدل على عدد الطبقات المخفيه فمثلا (10,200,30,4) يوجد أربعة طبقات لأنه يوجد أربع أرقام وكل رقم منها يدل على عدد الخلايا في طبقته مثلا الطبقة الأولى تحوي 10 خلايا
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test, y_test  تسطيع كتابة الأتي لعملية التدريب.
MLPRegressorModel = MLPRegressor(activation='tanh', solver='adam', learning_rate='constant', early_stopping= False, alpha=0.0001 ,hidden_layer_sizes=(100, 3)) MLPRegressorModel.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لتدريب الشبكه العصبية 
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي:
y_pred = MLPRegressorModel.predict(X_test) حيث قمنا بالتنبؤ بالقيم المتوقعه لداتا الاختبار
نستطيع أيضا حساب دقة الموديل أو كفاءته عن طريق التابع score ويكون وفق الشكل:
print('MLPRegressorModel Test Score is : ' , MLPRegressorModel.score(X_test, y_test)) حيث قمنا بطباعة قيمتها لكي نرى كفاءة الموديل على بيانات الاختبار وهل هو يعاني من الضبط الزائد  overfit أو الضبط الناقص underfit
 
#استدعاء المكتبة from sklearn.neural_network import MLPRegressor #الشكل العام للموديل MLPRegressorModel = MLPRegressor(activation='tanh', solver='adam', learning_rate='constant', early_stopping= False, alpha=0.0001 ,hidden_layer_sizes=(100, 3)) #تدريب الموديل MLPRegressorModel.fit(X_train, y_train) #حساب الدقة على الاختبار print('MLPRegressorModel Test Score is : ' , MLPRegressorModel.score(X_test, y_test)) #حساب القيم المتوقعه y_pred = MLPRegressorModel.predict(X_test)  

ربما لأنك تستخدمين المعامل ==. وهو معامل نستخدمه مع ال primitive data types أي مع أنواع البيانات البدائية مثل int و float و double .. إلخ. لكنها لاتصلح للاستخدام مع البيانات من نوع object أي مع الكائنات لأنها في هذه الحالة ستقوم بمقارنة (المرجع) وليس القيمة التي يحملها.
يجب استخدام التابع equal.مثلاً:
import java.math.BigInteger; public class JavaApplication19 { public static void main(String[] args) { BigInteger x = new BigInteger("15"); // object متغير من النمط BigInteger y = new BigInteger("15"); // object متغير من النمط System.out.println(x.equals(y)); // true System.out.println(x==y); // false } }  

يمكنك فلترة هذا التنبيه، ولن يظهر مرة أخرى باستخدام التعليمات التالية:
import warnings warnings.filterwarnings("ignore", message="numpy.ufunc size changed") warnings.filterwarnings("ignore", message="numpy.dtype size changed")  
 

Time Series Split هي طريقة لتقسيم الداتا تعتمد على فكرة عنصر تدريب وعنصر اختبار ثم عنصرين تدريب وعنصر اختبار ثم ثلاث عناصر تدريب وعنصر اختبار وهكذا.
 لنأخذ مثال  يوضح Time Series Split بشكل أفضل. في البداية نقوم باستدعاء المكتبات 
#استدعاء المكتبات
import numpy as np from sklearn.model_selection import TimeSeriesSplit قمنا باستدعاء المكتبة numpy لتشكيل الداتا
واستدعاء الوظيفه TimeSeriesSplit من الوحدة model_selection في مكتبة sklearn
#تشكيل الدخل والخرج:
X = np.array([[1, 2], [1, 4], [5, 2], [9, 4], [6, 2], [0, 4]]) y = np.array([1, 2, 3, 4, 5, 6]) حيث X مصفوفة أرقام من 6 أسطر وعمودين و y مصفوفة من 6 اسطر وعمود واحد
#TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5,max_train_size=None) البارمتر الأول n_splits عدد صحيح لتحديد عدد الأجزاء folds وهي افتراضية في sklearn من 3 إلى 5
البارمتر الثاني   max_train_size الحجم الأكبر لمجموعة تدريب واحدة
 
for train_index, test_index in tscv.split(X): 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' , X_train) print('X_test \n' , X_test) print('y_train \n' ,y_train) print('y_test \n' , y_test) print('*********************') بعد ذلك يتم المرور بحلقة حيث يتم استخدام اثنين من الاندكسات في الحلقة للمرور على التدريب والاختبار  وتحوي tscv.split(X) 
بعد ذلك في كل مرور على الحلقة  يتم طباعة الاندكسات الخاص بالتدريب والاختبار 
وبعد ذلك تم تخزين بيانات التدريب والاختبار وبعدها طباعة كل منها في كل محاولة
الكود كامل:
#استدعاء المكتبات import numpy as np from sklearn.model_selection import TimeSeriesSplit #تشكيل الدخل والخرج X = np.array([[1, 2], [1, 4], [5, 2], [9, 4], [6, 2], [0, 4]]) y = np.array([1, 2, 3, 4, 5, 6]) #TimeSeriesSplit tscv = TimeSeriesSplit(n_splits=5,max_train_size=None) for train_index, test_index in tscv.split(X): 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' , X_train) print('X_test \n' , X_test) print('y_train \n' ,y_train) print('y_test \n' , y_test) print('*********************')  # Machine Learning is everywhere
 # Written by Ali Ahmed

يمكنك استخدام التابع sort الذي له الشكل التالي:
list.sort(key = len,reverse=False) key و reverse وسيطان اختياريان.
key  يمثل تابع لتنفيذ الفرز على أساسه وفي حالتنا سنمرر له التابع len وبالتالي سيتم الفرز على أساس طول كل كلمة.
في حال ضبط reverse على True سيكون الترتيب تنازلي.
Hsoub = ['ali', 'ml', 'python'] Hsoub.sort(key = len,reverse=True) print(Hsoub) # output: ['python', 'ali', 'ml'] كما يمكنك استخدام هذا التابع لفرز العناصر داخل ال list مهما كان نوعها.
 

يمكنك استخدامها عبر الموديول linear_model.LogisticRegression:
sklearn.linear_model.LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, n_jobs=None) الوسطاء (غالباً نتركهم على الحالة الافتراضية لكن أنصح باستخدام  newton-cg optimizer مع solver ):
penalty: لتحديد ال norm المستخدمة في عملية ال penalization (يقصد فيهما نوع عملية التنعيم المستخدمة). ويأخذ القيم التالية:
{‘l1’, ‘l2’(default), ‘elasticnet’, ‘none’}
ملاحظة: sag و lbfgs و newton-cg يدعمون فقط النوع الثاني l2.
elasticnet يدعم فقط saga.
tol: مقدار السماحية المسموح بها في الخطأ، أي لكي تخبر النموذج متى يمكنه التوقف عند البحث عن القيمة صغرى بمجرد الوصول إلى هذه القيمة.
C: معكوس التنعيم، وكلما كانت أصغر كلما زاد التنعيم.
random_state: تتحكم بعملية تقسيم البيانات.
max_iter: العدد الأعظمي للتكرارات الممكنة.
n_jobs: لتحديد السرعة، ويقبل عدد صحيح:
-1: أي أنك تريد التنفيذ على GPU
[1,n]: كلما قمت بزيادة الرقم كلما زاد التسريع (يعتمد على قدرات جهازك).
Solver: لتحديد خوارزمية التقارب convergence وتكون قيمتها :
{‘newton-cg’, ‘lbfgs’ (default), ‘liblinear’, ‘sag’, ‘saga’}
sag أو saga في حالة البيانات الكبيرة.
liblinear في حالة البيانات الصغيرة.
dual: يفضل وضعه على False عندما تكون عدد العينات أكبر من عدد ال features.
verbose: لعرض كل التفاصيل أثناء التدريب نضع أي عدد صحيح أكبر من الصفر وإلا نضع 0.
ال attributes:
coef_: لعرض أوزان التدريب.
intercept_: التقاطع مع المحور y وهو قيمة بوليانية، في حال ضبطه على true يتم إخذ أفضل تقاطع مع المحور y.
classes_: أسماء الفئات المستخدمة، مثلاً مريض أو غير مريض أي 0 و 1.
n_iter_: عدد المحاولات التي قامت بها الخوارزمية.
الدوال:
score(data, label): لعرض مدى كفاءة المودل.
predict(data): لإخراج القيم المتوقعة لدخل معطى.
fit(data,label): للقيام بعملية التدريب.

مثال على بيانات أمراض سرطان الثدي (مريض|سليم) :
# استيراد المكتبات اللازمة from sklearn.datasets import load_breast_cancer # استيراد الداتا from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression # تحميل الدات BreastData = load_breast_cancer() data = BreastData.data labels = BreastData.target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=4, shuffle =True) LogisticR = LogisticRegression(max_iter=110,solver="newton-cg") # حددنا عدد التكرارات ب 110 كحد أقصى LogisticR.fit(X_train, y_train) # بدء التدريب print('train Score is : ' , LogisticR.score(X_train, y_train)) #96% # عرض الدقة على بيانات التدريب print('Test Score is : ' , LogisticR.score(X_test, y_test)) # 91% # عرض الدقة على بيانات الاختبار print('LogisticR Classes are : ' , LogisticR.classes_) # عرض الفئات الموجودة لدينا وهي 0 و 1 أي مريض وسليم print('LogisticR No. of iteratios is : ' , LogisticR.n_iter_) # عرض عدد المحاولات أوالتكرارات print('----------------------------------------------------') # حساب التوقع y_pred = LogisticR.predict(X_test) y_pred_prob = LogisticR.predict_proba(X_test) print('Predicted Value : ' , y_pred[:4]) # عرض القيم المتوقعة بعد قصرها print('Prediction Probabilities Value : ' , y_pred_prob[:4]) # عرض القيم المتوقعة كقيم احتمالية  

هي أحد طرق تقسيم الداتا هي متل KFold ولكن تختلف عنها بأنها مجموعه من Kfold، ولكن بتنويعات أكبر، ويتم استخدامها في حالة كانت البيانات قليلة جداً وأردنا أن يكون تقييم النموذج دقيق جداً (أشار لذلك فرانسوا كوليت)، لننتقل إلى الكود البرمجي لسهولة الفهم في التطبيق
#استدعاء المكتبات:
import numpy as np from sklearn.model_selection import RepeatedKFold قمنا باستدعاء المكتبة numpy لتشكيل الداتا، واستدعاء الوظيفه RepeatedKFold من الوحدة model_selection في مكتبة sklearn
#تشكيل الداتا الدخل والخرج:
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) y = np.array([11, 22, 33, 44]) حيث X مصفوفة أبعادها 4 أسطر وعمودين وy عمود واحد بأربع أسطر.
#RepeatedKFold rkf = RepeatedKFold(n_splits=4, n_repeats=4) البارمتر الأول n_splits عدد صحيح لتحديد عدد الأجزاء folds وهي افتراضية في sklearn من 3 إلى 5.
البارمتر الثاني n_repeats وهو نقطة الاختلاف عن KFolds هو عدد صحيح يمثل عدد KFolds.
نفس الأمر في Kfolds مرور حلقة حيث يتم استخدام اثنين من الاندكسات في الحلقة للمرور على التدريب والاختبار  وتحوي kf.split(X) هذه الاندكسات وهنا عدد المحاولات سوف يكون في مثالنا:
n_splits*n_repeats=4*4=16 أي 4 Kfolds وكل kfold يحوي 4 تقسيمات مختلفه في كل مره.
نقوم بطباعة الاندكس للتدريب والاختبار في كل محاوله وبعدها تخزين التدريب والاختبار
ومن ثم طباعة كل منها:
for train_index, test_index in rkf.split(X): 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' , X_train) print('X_test \n' , X_test) print('y_train \n' ,y_train) print('y_test \n' , y_test) print('*********************') الكود كامل:
#استدعاء المكتبات import numpy as np from sklearn.model_selection import RepeatedKFold #تشكيل الداتاالدخل والخرج X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) y = np.array([11, 22, 33, 44]) #RepeatedKFold rkf = RepeatedKFold(n_splits=2, n_repeats=4, random_state=44) for train_index, test_index in rkf.split(X): 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' , X_train) print('X_test \n' , X_test) print('y_train \n' ,y_train) print('y_test \n' , y_test) print('*********************')  

يمكنك ذلك بالطريقة التالية باستخدام مكتبة Json:
import json with open('data.json') as file: data = json.load(file) type(data) # Output: dict data.keys() # Output: dict_keys(['key1', 'key2', 'key3', 'key4', 'keyn']) أو باستخدام مكتبة pandas وهنا سيقرأها ك DataFrame:
import pandas as pd df = pd.read_json(‘data.json’) print(df)  

هو أحد الطرق لتقسيم البيانات بدلا من استخدام train_test_split ويستخدم في حالة كانت البيانات قليلة.
import numpy as np from sklearn.model_selection import KFold قمنا باستدعاء المكتبة numpy لتشكيل داتا مزيفه
واستدعاء الوظيفه KFold من الوحدة model_selection في مكتبة sklearn
#تكوين داتا مزيفة مكونة من أرقام عشوائية:
X = np.random.random((1,15)).reshape((5, 3)) y = np.random.random((5,1)) في السطرين السابقين تم تشكيل X ,y كداتا مزيفه (أرقام عشوائيه )حيث X أبعادها 5 أسطر مع ثلاث أعمده وتحوي أرقام عشوائيه أما y عمود واحد بخمس أسطر وتحوي أرقام عشوائية
#تقسيم الداتا المزيفه إلى أجزاء :
لكن بداية سنعرض الصيغة العامة للتابع:
sklearn.model_selection.KFold(n_splits=5, shuffle=False, random_state=None) الوظيفة KFold تأخذ البارمترات التالية:
البارمتر الأول n_splits عدد صحيح لتحديد عدد الأجزاء folds وهي افتراضية في sklearn من 3 إلى 5.
البارمتر الثاني shuffle متحول بولياني يأخذ True لكي يتم خلط الداتا قبل عملية التقسيم أي جعلها عشوائية ويأخذ False عندما لا نريد خلط الداتا.
randomstate: للتحكم بعملية الخلط. وقد تحدثت عنه في هذا الرابط:

الأن في مثالنا  تم تقسيم الداتا إلى 5 أجزاء مع خلط الداتا قبل عملية التقسيم.
وللوصول إلى كل جزء وما يحوية لديك الأسطر التالية حيث يتم استخدام اثنين من الاندكسات في الحلقة للمرور على التدريب والاختبار  وتحوي kf.split(X) هذه الاندكسات لكل محاولة من المحاولات يقصد بالمحاولات اي عملية التقسيم المختلفة التي ذكرناها سابقاً
بعد ذلك في كل مرور على الحلقة  يتم طباعة الاندكس الخاص بالتدريب والاختبار 
وبعد ذلك تم تخزين بيانات التدريب والاختبار وبعدها طباعة الابعاد لكل منها في كل محاولة.
# المثال:
 
#استدعاء المكتبات import numpy as np from sklearn.model_selection import KFold #تكوين داتا مزيفة مكونة من أرقام عشوائية X = np.random.random((1,15)).reshape((5, 3)) y = np.random.random((5,1)) #تقسيم الداتا المزيفه إلى أجزاء kf = KFold(n_splits=2, random_state=44, shuffle =True) #KFold Data for train_index, test_index in kf.split(X): print('Train Data is : \n', train_index) print('Test Data is : \n', test_index) print('-------------------------------') X_train, X_test = X[train_index], X[test_index] y_train, y_test = y[train_index], y[test_index] print('X_train Shape is ' , X_train.shape) print('X_test Shape is ' , X_test.shape) print('y_train Shape is ' ,y_train.shape) print('y_test Shape is ' , y_test.shape) print('========================================')  

هو معيار لقياس كفاءة نماذج التصنيف Classification.
يعتمد على حساب عدد مرات اللاتطابق بين القيم الحقيقية والقيم المتوقعة.
يمكن تطبيقه باستخدام مكتبة Sklearn كالتالي:
 
sklearn.metrics.zero_one_loss(y_true, y_pred, normalize=True) الوسيط الأول والثاني يمثلان القيم الحقيقية والمتوقعة على التوالي.
الوسيط الأخير في حال ضبطه على True سيعيد عدد مرات اللاتطابق كقيمة عشرية.
في حال ضبطه على False يعيد عدد مرات اللاتطابق.
المثال يوضح:
 
from sklearn.metrics import zero_one_loss y_pred = [1, 0, 2, 1] y_true = [1, 0, 3, 1] z1=zero_one_loss(y_true, y_pred,normalize=True) print(z1) # 0.25 z2=zero_one_loss(y_true, y_pred, normalize=False) # print(z2) # 1  # Machine Learning is everywhere
 # Written by Ali Ahmed

يحاول الانحدار الخطي LinearRegression   نمذجة العلاقة بين متغيرين X وY من خلال ملاءمة معادلة خطية (خط مستقيم) للبيانات التي يتم التدريب عليها وهو من الشكل Y=WX+b. ويستخدم في مهام التنبؤ Regression (مثل توقع أسعار المنازل مثلاُ أو توقع عدد الإصابات بمرض معين).
ندعو X  بال features و b بال bias (وهي تكافئ الإزاحة) بينما w تمثل أوزان النموذج (وهي تكافئ ميل المستقيم).
نميز نوعين للتوقع الخطي:
Univariate Linear Regression : أي التوقع الخطي الذي يعتمد فيه الخرج Y على One feature أي تكون X عبارة عن متغير واحد.
Multiple linear regression : أي التوقع الخطي الذي يعتمد فيه الخرج Y على أكتر من feature أي تكون X عبارة عن x1,x2,...,xn.
يمكن تطبيق التوقع الخطي عن طريق مكتبة Sklearn.
يتم استخدامها عبر الموديول .linear_model.LinearRegression
sklearn.linear_model.LinearRegression(fit_intercept=True, normalize=False, copy_X=True, n_jobs=None) الوسطاء:
fit_intercept: لجعل المستقيم يتقاطع مع أفضل نقطة على المحور العيني y.
copy_X: وسيط بولياني، في حال ضبطه على True سوف يأخذ نسخة من البيانات ، وبالتالي لاتتأثر البيانات الأصلية بالتعديل، ويفيدنا في حالة قمنا بعمل Normalize للبيانات.
normalize: وسيط بولياني، في حال ضبطه على True سوف يقوم بتوحيد البيانات (تقييسها) اعتماداً على المقياس L2norm. وقد سبق وتحدثت عن هذا الموضوع في هذا الرابط:
n_jobs: لتحديد عدد العمليات التي ستتم بالتوازي (Threads) أي لزيادة سرعة التنفيذ، افتراضياُ تكون قيمته None أي بدون تسريع، وبالتالي لزيادة التسريع نضع عدد صحيح وكلما زاد العدد كلما زاد التسريع (التسريع يتناسب مع قدرات جهازك)، وفي حال كان لديك GPU وأردت التدريب عليها فقم بضبطه على -1.

أهم ال attributes:
_coef: الأوزان التي حصلنا عليها بعد انتهاء التدريب وهي مصفوفة بأبعاد (,عدد الfeatures).
أهم التوابع:
fit(data, truevalue): للقيام بعملية التدريب.
predict(data): دالة التوقع ونمرر لها البيانات وتعطيك التوقع لها.
score(data, truevalue): لمعرفة مدي كفاءة النموذج ونمرر لها بيانات الاختبار والقيم الحقيقية لها فيقوم بعمل predict للداتا الممررة ثم يقارنها بالقيم الحقيقية ويرد الناتج حسي معيار R Squaerd .
إليك التطبيق العملي:
الداتاسيت هي مواصفات منازلX مع أسعارها Y في مدينة بوسطن.
from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression # تحميل الداتاسيت 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=33, shuffle =True) #تعريف LinearRegressionModel LR = LinearRegression(fit_intercept=True,copy_X=True,n_jobs=-1) LR.fit(X_train, y_train) print('Train Score is : ' ,LR.score(X_train, y_train)) # R Squaerd on trainset print('Test Score is : ' , LR.score(X_test, y_test)) # R Squaerd on testset print('Coef is : \n' , LR.coef_) # Coefficent # حساب القيم المتوقعة y_pred = LR.predict(X_test) print(y_pred[0:10]) # عرض القيم الحقيقية print(y_test[0:10]) # Machine Learning is everywhere

هي دوال تتألف من سطر واحد تستخدم الكلمة المفتاحية lambda على عكس التوابع الأخرى في بايثون التي تستخدم def ككلمة مفتاحية وهي تقوم بإرجاع قيمة عند استدعاءها لها الشكل التالي:
lambda [arg1 [,arg2,.....argn]]:expression الكلمة المفتاحية lambda
أسماء متحولات الدخل ويوجد فاصلة بين كل متحول وأخر [arg1 [,arg2,.....argn]]
ب expression تتم العمليات على المتحولات 
مثال بسيط لجمع عددين باستخدام Anonymous Function:
 
T=lambda x,y:x+y على عكس التوابع الأخرى التي تستدعى بالاسم فإن Anonymous Function يتم إسنادها لمتغير ومن ثم يكون المتغير هو الاسم لهذا التابع أي يكون الاستدعاء كالتالي:
 
T(2,3) #output:5  

ROC&AUC Score
ROC (Receiver Operating Characteristics)curve
AUC (Area Under The Curve)
ROC&AUC Score: هو معيار لقياس كفاءة نماذج التصنيف.
للفهم جيداً يجب أن يكون لديك معرفة حول Recall(Sensitivity) و Precision(Specificity) وقد أشرت لهما سابقاً في هذا الرابط:
https://academy.hsoub.com/questions/15466-حساب-ال-precision-و- recall-باستخدام-مكتبة-scikit-learn/
في الصورة المرفقة رسم بياني يعبر عن ROC&AUC ، بحيث :
أولاً:
<<TPR (True Positive Rate) or Recall or Sensitivity>>
يمثل المحور العمودي، ويساوي إلى TP/(TP+FN) ويعبر عن ال Recall أي ال Sensitivity.
ثانياً:
<<FPR(False Positive Rate)>>
 ويساوي إلى FP/(FP+TN) أي أنه متمم ال Specificity أي : FPR=1-Specificity.
ثالثاً:
ROC: يمثل المنحنى الاحتمالي الذي يعبر عن العلاقة بين المحورين.
رابعاً:
AUC هو المساحة تحت المنحنى ويعبر عن درجة قدرة النموذج على الفصل بين الفئات Classes. ستلاحظ في الأكواد التالية أن زيادة المساحة تحت المنحني تشير إلى أداء أقوى للنموذج.

مناقشة القيم أو قراءة القيم:
كلما كانت درجة  AUC أكبر كلما كان النموذج أفضل علماً أن أعلى قيمة لها 1 وأقل قيمة 0.
في حال كانت قيمة AUC=1 فهذا يعني أن النموذج قادر على الفصل بين الClasses بنسبة 100%.  الكود رقم 1 يعبر عن هذه الحالة.
AUC=0.5 فهذا يعني أن النموذج غير قادر على الفصل بين ال Classes اطلاقاً وهي حالة سيئة، وفيه يكون النموذج غير قادر على إعطاء قرار، أي مثلا في مهمة تصنيف صور القطط والكلاب تشير قيمة 0.5 لل AUC إلى أن النموذج سيقف حائراً أمام أي صورة أي كأن يقول أن هذه الصورة هي 50% كلب و 50% قط. الكود رقم 2 يعبر عن هذه الحالة.
AUC=0 فهذا يعني أن النموذج يتنبأ بشكل عكسي بالقيم أي يتموقع أن الأصناف الإيجابية سلبية والعكس بالعكس أي يقول عن القط كلب والكلب قط وبكل ثقة. الكود رقم 3 يعبر عن هذه الحالة.
الشكل العام للتابع الذي يقوم بحساب ROC في Sklearn:
sklearn.metrics.roc_curve(y_true, y_score) الوسيطين الأول والثاني يعبران عن القيم الحقيقية والمتوقعة على التوالي.
يرد التابع 3 قيم fpr و tpr والعتبة وسنستخدم هذه القيم لحساب درجة AUC.
الشكل العام للتابع الذي يقوم بحساب AUC في Sklearn:
sklearn.metrics.auc(fpr, tpr) قم بتجريب الأكواد التالية لتحصل على الخرج وترى الفروقات:
# الكود 1
############################# Case 1 ######################################## # استيراد المكتبات اللازمة from sklearn.metrics import roc_curve from sklearn.metrics import auc import matplotlib.pyplot as plt import numpy as np # بفرض لدي القيم الحقيقية والمتوقعة التالية y = np.array([1 , 1 , 0 , 1, 1]) y_pred = np.array([0.99 ,0.02 ,0.01, 0.99,0.999]) #لاحظ نسبة التطابق fpr, tpr, threshold = roc_curve(y,y_pred) print('TPR'+str(tpr)+'\n'+'FPR'+str(fpr)+'\n'+'threshold'+str(threshold)) # طباعة قيم الخرج # لرسم المنحنى plt.plot(fpr, tpr) plt.title('ROC curve') plt.xlabel('False Positive Rate (1 - Specificity)') plt.ylabel('True Positive Rate (Sensitivity)') plt.grid(True) AUC = auc(fpr, tpr) # حساب قيمة AUC print('AUC Value : ', AUC) # طباعة القيمة
#الكود 2
############################# Case 2 ######################################## # استيراد المكتبات اللازمة from sklearn.metrics import roc_curve from sklearn.metrics import auc import matplotlib.pyplot as plt import numpy as np # بفرض لدي القيم الحقيقية والمتوقعة التالية y = np.array([0 ,1 ,0 ,1,0]) y_pred = np.array([0.5 ,0.5 ,0.5, 0.5, 0.5]) # لاحظ أننا غيرنا القيم fpr, tpr, threshold = roc_curve(y,y_pred) print('TPR'+str(tpr)+'\n'+'FPR'+str(fpr)+'\n'+'threshold'+str(threshold)) plt.plot(fpr, tpr) plt.title('ROC curve') plt.xlabel('False Positive Rate (1 - Specificity)') plt.ylabel('True Positive Rate (Sensitivity)') plt.grid(True) AUC = auc(fpr, tpr) print('AUC Value : ', AUC) # الكود 3
############################# Case 3 ######################################## # استيراد المكتبات اللازمة from sklearn.metrics import roc_curve from sklearn.metrics import auc import matplotlib.pyplot as plt import numpy as np # بفرض لدي القيم الحقيقية والمتوقعة التالية y = np.array([0 ,1 ,0 ,0,0]) y_pred = np.array([0.9 ,0.1 ,0.9, 0.9, 0.9]) fpr, tpr, threshold = roc_curve(y,y_pred) print('TPR'+str(tpr)+'\n'+'FPR'+str(fpr)+'\n'+'threshold'+str(threshold)) plt.plot(fpr, tpr) plt.title('ROC curve') plt.xlabel('False Positive Rate (1 - Specificity)') plt.ylabel('True Positive Rate (Sensitivity)') plt.grid(True) AUC = auc(fpr, tpr) print('AUC Value : ', AUC)  

هما معياران لقياس كفاءة نماذج التصنيف Classifications.
أولاً: Precision
هو نسبة (المتوقع) الإيجابي الصحيح على نسبة (((المتوقع))) الإيجابي الكلي ويعبر عنه بالعلاقة التالية:
Precision = TP/(TP+FP)
لاحظ أن البسط يعبر عن كل العينات التي قال عنها نموذجنا أنها P وهي بالغعل P.
لاحظ أن المقام  (TP+FP) يشير إلى كل العينات التي اعتبرها نموذجنا P سواءاً أكان التوقع صحيح أم لا.
ويمكن أن نعبر عنه بالصيغة؟ كم هي عدد العينات التي توقع النموذج أنها + وكانت بالفعل + من بين كل التوقعات التي توقع أنها +.
لتطبيقه باستخددام scikit-learn نستخدم الصيغة التالية:
sklearn.metrics.precision_score(y_true, y_pred) مثال:
from sklearn.metrics import precision_score y_pred = [0, 1, 0, 1,0,1] # بفرض أن القيم المتوقعة كانت y_true = [0, 1, 0, 1,1,1] # بفرض أن القيم الحقيقية كانت # يكون الناتج precision=precision_score(y_true, y_pred) # لطباعة الناتج كنسبة مئوية print(str(precision*100)+'%',sep='') ثانياً: Recall 
هي كل (التوقعات) الإيجابية الصحيحة مقسومة على العدد الكلي للحالات الإيجابية.
Recall = TP/(TP+FN)
البسط لم يتغير.
المقام تم استبدال FP ب FN ليصبح (TP+FN) ويشير إلى عدد العينات الإيجابية كلها التي اكتشفها النموذج والتي  لم يكتشفها أصلاً.
sklearn.metrics.recall_score(y_true, y_pred) مثال:
from sklearn.metrics import recall_score y_pred = [0, 1, 0, 1,0,1] # بفرض أن القيم المتوقعة كانت y_true = [0, 1, 0, 1,1,1] # بفرض أن القيم الحقيقية كانت # يكون الناتج recall=recall_score(y_true, y_pred) # لطباعة الناتج كنسبة مئوية print(str(recall*100)+'%',sep='') # 75.0% # للتنويه: الرابط التالي يحوي شرح لمفاهيم TPو TN والبقية:
 

يعتبر من أهم معايير قياس دقة نماذج التصنيف Classification. 
وهو نسبة ماتوقعناه بشكل صحيح إلى مجموع التوقعات الكلية ويستخدم بكثرة، ويمكن التعبير عنه بالصيغة التالية:
Accuracy = (TP+TN)/(TP+FP+FN+TN)
الصيغة العامة للتابع الذي يقوم بحساب الدقة في مكتبة scikit-learn:
sklearn.metrics.accuracy_score(y_true, y_pred, normalize=True) حيث أن أول وثاني وسيط يمثلان القيم الحقيقية والمتوقعة على التوالي.
الوسيط normalize في حال تم ضبطه على true يعيد قيمة عشرية تمثل الدقة (الحالة الافتراضية)، وفي حال ضبطه على False سيقوم بحساب
TP+TN أي عدد التوقعات الصحيحة للنموذج.
مثال:
 
from sklearn.metrics import accuracy_score y_pred = [0, 1, 0, 1,0,1] # بفرض أن القيم المتوقعة كانت y_true = [0, 1, 0, 1,1,1] # بفرض أن القيم الحقيقية كانت # يكون الناتج print(accuracy_score(y_true, y_pred, normalize=True)) # 0.8333333333333334 # لطباعة الناتج كنسبة مئوية print(accuracy_score(y_true, y_pred)*100,'%',sep='') # 83.33333333333334%  
# تنويه: تجد شرح المفاهيم TP,TN,FP,FN في الرابط التالي بالتفصيل.
 

يتم ذلك باستخدام التابع التالي:
sklearn.model_selection.train_test_split(data,label, test_size=None, train_size=None, random_state=None, shuffle=True)
يقوم التابع train_test_split بتقسيم البيانات إلى عينات تدريب وعينات اختبار.
data: تمثل مجموعة البيانات.
label: تمثل الفئات (classes).
test_size: لتحديد النسبة المئوية التي سيتم اقتطاعها من البيانات لاستخدامها كعينة اختبار. لو وضعنا 0.2، سيتم تخصيص 20% من البيانات للاستخدام كعينة اختبار.
train_size: لتحديد النسبة المئوية التي سيتم اقتطاعها من البيانات لاستخدامها كعينة تدريب.
random_state:  هذا الوسيط غامض لدى الكثيرين. إنه يتحكم بطريقة الخلط المطبقة على البيانات أي لتحديد نظام العشوائية ويأخذ قيمة من النمط  integer ويمكنك وضع أي قيمة تريدها، هذا الرقم يفهمه المترجم بطريقة معينة على أنه نمط معين للتقسيم.
لنفهم فائدة هذا الوسيط سأعطيك المثال التالي:
لنفرض أننا نعمل في فريق على مهمة تعلم آلة معينة.
في حال لم نستخدم random_state سوف يتم تقسيم البيانات على جهاز كل عضو من الفريق بطريقة مختلفة، أما إذا اخترنا جميعاً قيمة ثابتة ولتكن 44 فهذا يعني أن البيانات ستقسم بنفس الطريقة على جهاز كل عضو، ولو أعدنا التقسيم 1000 مرة سيكون نفسه.
وطريقة قسم البيانات مهمة فمثلاً إذا كانت عناصر مجموعة الاختبار a تختلف عن عناصر مجموعة الاختبار b، هذا سيؤدي إلى اختلاف ال score بين المجموعتين.
shuffle: لعمل خلط للبيانات قبل تقسيمها (أي بعثرة أو إعادة ترتيب العينات بشكل عشوائي). في حال وضعنا False لن تتم البعثرة (يفضل وضعها True دوماً).
الكود التالي يوضح العملية:
# سنقوم بتحميل الداتاسيت الخاصة بأسعار المنازل في مدينة يوسطن ونقوم بتقسيمها import numpy as np from sklearn.model_selection import train_test_split from sklearn.datasets import load_boston # تحميل الداتاسيت BostonData = load_boston() data = BostonData.data label = BostonData.target # عرض حجم الداتا print('The shape of data:',data.shape,'\n') # The shape of data: (506, 13) أي لدينا 506 عينات # تقسيم الداتا X_train, X_test, y_train, y_test = train_test_split(data, label, test_size=0.2, random_state=44, shuffle =True) # لاحظ أننا حددنا 20 بالمئة كعينة اختبار وبالتالي سيتم اعتبار الباقي عينة تدريب تلقائياً # عرض حجم البيانات بعد التقسيم print('The shape of X_train:',X_train.shape) # The shape of X_train: (354, 13) print('The shape of X_test:',X_test.shape) # The shape of X_test: (152, 13) print('The shape of y_train:',y_train.shape) # The shape of y_train: (354,) print('The shape of y_test:',y_test.shape) # The shape of y_test: (152,)  

error matrix أو confusion_matrix: هي مصفوفة تستخدم لتقييم أداء نماذج التصنيف، أي نستخدمها عندما تكون المهمة هي مهمة تصنيف Classification.
هذه المصفوفة تقوم بحساب TP و FP و FN و TN وترد مصفوفة تعبر عنهم بأبعاد  (n_classes, n_classes).
سأعطي مثال لشرحهم:
تجري إحدى الكليات فحصاً لمرض كورونا باستخدام التعلم الآلي على جميع طلابها.
الناتج إما مصاب بكورونا + أو سليم -.
وبالتالي سيكون هناك 4 حالات من أجل طالب x.
إذا كانت تبدأ بـ  True، فإن التنبؤ كان صحيحاً سواء كان مصاباً بمرض كورونا أم لا.
 إذا كانت تبدأ بـ  False، فإن التنبؤ كان غير صحيح.
P تدل على الفئة الإيجابية و N السلبية، وهما خرج برنامجنا.
True positive (TP): النموذج يتوقع أن الطالب x حالته + والطالب x هو فعلاً مصاب (وهذا جيد).  أي توقع أن الشخص مصاب وهو مصاب فعلاً.
True negative (TN): النموذج يتوقع أن الطالب x حالته - والطالب سليم (وهذا جيد). أي شخص سليم و تنبأ أنه سليم بشكل صحيح.
False positive (FP): النموذج يتوقع أن الطالب x حالته + والطالب غير مصاب (وهذا سيئ). أي شخص سليم وتوقع أنه مصاب.
False negative (FN): النموذج يتوقع أن الطالب x حالته - والطالب مصاب (وهذا الأسوأ). أي شخص مصاب وتوقع أنه سليم.
 
لتطبيقها باستخدام مكتبة Sklearn نستدعي التابع confusion_matrix  من الموديول metrics والمثال التالي يبين كل شيء:
sklearn.metrics.confusion_matrix(y_true, y_pred, normalize=None) أول وسيطين يمثلان القيم الحقيقية والقيم المتوقعة، على التوالي. أما الوسيط الأخير فهو  اختياري  ويستعمل لعمل normalize للقيم وهو يأخذ 3 قيم:
all: بالتالي يقسم كل قيم المصفوفة على  مجموع كل التوقعات (جرب بنفسك).
true: يقسم كل القيم في عمود j على مجموع القيم فيه.
pred: يقسم كل القيم في سطر i على مجموع القيم فيه.
لاستخراج قيم tp و tn و fp و fn من المصفوفة نستخدم التابع ()ravel مع ملاحظة أنه لايمكنك استخدام هذا التابع إلى في حالة أن التصنيف ثنائي.
from sklearn.metrics import confusion_matrix y_true = ["cat", "dog", "cat", "cat", "dog", "dog","cat","cat"] y_pred = ["dog", "dog", "cat", "cat", "dog", "cat","cat","cat"] # حساب المصفوفة cm=confusion_matrix(y_true, y_pred,normalize=None') # عرض نتيجة المصفوفة print(cm) # لاستخراج القيم tp,fp,fn,tn=cm.ravel() #يمكنك التعبير عن هذه القيم بالرسم import matplotlib.pyplot as plt import seaborn as sea sea.heatmap(cm, center = True) plt.show()