تقسيم البيانات باستخدام LeavePOut في مكتبة Sklearn

يمكنك تقسيم البيانات كالآتي

# استيراد دالة 
# LeavePOut
from sklearn.model_selection import LeavePOut
# استيراد numpy
import numpy as np
X = np.array([[1, 2], [3, 4], [5, 6], [7, 8],[9,10]])
y = np.array([0,1,1,0,0])
# تحديد عدد العينات الى 2
lpo = LeavePOut(2)
# طباعة عدد التقسيمات
print(lpo.get_n_splits(X))

print(lpo)
LeavePOut(p=2)
# تقسيم البيانات
for train_index, test_index in lpo.split(X):
    for x in range(0,len(test_index)):
      for z in range(1,len(test_index)):
        if(y[test_index[x]] != y[test_index[z]]):
          # طباعة البيانات المُقسمة
          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]

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

• قم بتشغيل الكود لترى الخرج مباشرة.

import numpy as np
from sklearn.model_selection import LeavePOut
X = np.array([[1,4],[2,1],[3,4],[7,8]])
y = np.array([2,1,3,9])
#3 هنا حددنا عدد العينات 
lpo = LeavePOut(3)
# لمعرفة عدد التقسيمات الممكنة
print(lpo.get_n_splits(X))
# تقسيم البيانات
for train_index, test_index in lpo.split(X):
    # للتقسيمة index  عرض ال 
    print("TRAIN:"+str(train_index)+'\n'+"TEST:"+str(test_index),end='\n\n')
    # تقسيم البيانات
    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_test),end='\n\n')
    print('y_train:\n '+str(y_train),end='\n\n')
    print('y_test:\n' +str(y_test),end='\n\n')

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

from sklearn.model_selection import LeavePOut
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.datasets import make_blobs
# إنشاء داتاسيت مزيفة ب10 عينات و3 فئات
X, y = make_blobs(n_samples=10, random_state=2021) # y=array([1, 1, 2, 0, 1, 2, 0, 2, 0, 0])
# LeavePOut إنشاء كائن من الكلاس
# تحديد عدد العينات التي نريدها للاختبار في كل مرة
pout=2
cv = LeavePOut(p=pout)
# لتخزين النتائج من كل تقسيمة 
y_true, y_pred = list(), list()
# عملية التقسيم
for train_ix, test_ix in cv.split(X):
    # تقسيم البيانات
    X_train, X_test = X[train_ix, :], X[test_ix, :]
    y_train, y_test = y[train_ix], y[test_ix]
    # تدريب النموذج
    model = RandomForestClassifier(random_state=44)
    model.fit(X_train, y_train)
    # تقييم النموذج
    yhat = model.predict(X_test)
    # تخزين النتيجة
    for i in range(0,pout):
        y_true.append(y_test[i])
        y_pred.append(yhat[i])
# حساب الدقة
acc = accuracy_score(y_true, y_pred)
print('Accuracy: %.3f' % acc)# Accuracy: 1.000

لاحظ كيف أنه في كل مرة أقوم بأخذ عدة عينات (حددها بشكل اختياري)  للاختبار والباقي للتدريب ثم أدرب النموذج عليها وأقوم بحساب القيمة المتوقعة على عينات الاختبار وأضعها في  y_pred  وأضع القيم الحقيقية المقابلة لها في y_true, وهكذا بالنسبة لبقية التقسيمات حتى ننتهي وبعدها أقوم بحساب دقة النموذج. 

LeavePOut هي إحدى إستراتيجيات ال Cross validation و التي تهتم بالتحقق من دقة النموذج و ذلك بتقسيم جزء محدد من بيانات التدريب و معاملتها كبيانات للإختبار و مقارنة نتائجها مع القيم الحقيقة لإماكنية تعديل Hyperparameters للنموذج. بالإعتماد على فرضية أن بعض البيانات تكون Independent and Identically Distributed (i.i.d.) أن البيانات تولد بنفس الطريقة، بذلك للقيام بعملية التحقق من دقة النموذج لابد من وجود طرق تساعد على تدريب النموذج للتعرف أغلب البيانات و توزيعها و خصائصها. من هذه الطرق LeavePOut وهي مشابهة جداً ل LeaveOneOut و من الأسم لابد أنك لاحظت انها تعتمد على ترك قيمة وحيدة للتحقق و تدرب النموذج ببقية البيانات، وفي حالة وجود n عينة، يتدرب النموذج على n-1 عينة فبالتالي يوجد تباين عالي في بيانات الإختبار لاحقاً.

\documentclass{article}
\usepackage{amsmath}
\begin{document}  
$\binom nk= \binom 4 1= \frac{4!}{1!(4-1)!} = \frac{4*3!}{1(3!)!} = 4$ 
\end{document}

دعنا نلقى نظرة على مثال مبسط لتطبيق LeaveOneOut و الذي سيرينا الفرق بينه و بين LeavePOut:

from sklearn.model_selection import LeaveOneOut

X = [1, 2, 3, 4]
loo = LeaveOneOut()
for train, test in loo.split(X):
    print("%s %s" % (train, test))

بعد إستدعاء الدالة LeaveOneOut قمنا بتعريف قائمة تحتوي على أربع قيم، و من ثم عرفنا الدالة و بإستخدام حلقة for التكرارية قمنا بتخزين ناتج إستدعاء دالة التقسيم split والتي ترجع مؤشرات البيانات المقسمة إلى تدريب و إختبار (في هذه حالة تدريب النموذج على بيانات حقيقية سترمز بيانات الإختبار إلى بيانات التحقق و ستكون هنالك بيانات منفصلة للإختبار).

لاحظ ناتج عملية التقسيم:

[1 2 3] [0]
[0 2 3] [1]
[0 1 3] [2]
[0 1 2] [3]

القوائم التي تحتوي على ثلاث قيم و هي تشير لمؤشرات بيانات التدريب train كما موضح في البرنامج و القيمة الأخيرة تشير لمؤشرات بيانات الإختبار.

والان لنلقى نظرة على LeavePOut وهي مشابهة لLeaveOneOut و تنشئ كافة بيانات التدريب و التحقق بترك P عينة من مجموعة البيانات بدلاً من ترك عينة واحدة في كل مرة كما في LeaveOneOut. وبذلك يجب أن تكون قيمة ال P أكبر من 1 (وإلا فإنها ستكون مساوية لLeaveOneOut) و أقل من n.

from sklearn.model_selection import LeavePOut

X = [1, 2, 3, 4]
lpo = LeavePOut(p=2)
for train, test in lpo.split(X):
    print("%s %s" % (train, test)) 

لنحاول حساب مجموعات المؤشرات المتوقع إنشاؤها بتحديد P=2 في المثال السابق:

\documentclass{article}
\usepackage{amsmath}
\begin{document}  
$\binom np= \binom 4 2= \frac{4!}{2!(4-2)!} = \frac{4*3*2!}{2*1(2!)!} = 6$ 
\end{document}

بالتالي رياضياً حسب التعريف نتوقع الحصول على 6 مجموعات، والان فلنراجع ناتج التنفيذ:

[2 3] [0 1]
[1 3] [0 2]
[1 2] [0 3]
[0 3] [1 2]
[0 2] [1 3]
[0 1] [2 3]

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