Ali Haidar Ahmad

المشكلة في ترتيبك للمخرجات التي يردها التابع train_test_split.
الخطأ يظهر عندما تحاول القيام ب fitting على البيانات.
ec1 = ec1.fit(X_train, y_train) ولحل المشكلة يجب التقيد بترتيب مخرجات التابع  train_test_split وهي كالتالي:
X_train, y_train, X_test, y_test الكود بعد الإصلاح:
#استيراد المكتبات import numpy as np from sklearn.linear_model import LogisticRegression from sklearn.naive_bayes import GaussianNB from sklearn.ensemble import RandomForestClassifier, VotingClassifier from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split #تحميل البيانات data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) c1 = LogisticRegression(multi_class='multinomial', random_state=1) c2 = RandomForestClassifier(n_estimators=50, random_state=1) c3 = GaussianNB() ec1 = VotingClassifier(estimators=[ ('lr', c1), ('rf', c2), ('gnb', c3)], voting='hard') ec1 = ec1.fit(X_train, y_train) print(ec1.score(X_test,y_test))#0.9385964912280702  

هي طريقة أكثر ترتيباً وسهولة إذا كنت دقيقاً في التعامل معها لإنجاز مشاريعك.
فمثلاً في الكود التالي قمت ببناء نموذج بسيط واستخدمت فيه ال Pipeline. وهي أداة نمرر لها خطوات الخوارزمية ثم تقوم هي بتنفيذها.
يمكنك استخدامها عبر الموديول:
pipeline.Pipeline إليك المثال التالي:
from sklearn.linear_model import LogisticRegression from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.pipeline import Pipeline from sklearn.metrics import confusion_matrix,accuracy_score, classification_report from sklearn.model_selection import train_test_split from sklearn.datasets import load_boston from sklearn.ensemble import RandomForestRegressor from sklearn.preprocessing import PolynomialFeatures from sklearn.preprocessing import StandardScaler # تحميل الداتا 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) # الخطوات المراد تنفيذها نعرفها بالشكل التالي ضمن قاموس steps = [ ('step1', StandardScaler()), ('step2', PolynomialFeatures(degree=2)), ('model', RandomForestRegressor()) ] # pipeline نقوم بإنشاء pipe = Pipeline(steps) pipe.fit(X_test,y_test) # مرحلة التقييم prediction = pipe.predict(X_test) pipe.score(X_test,y_test) # 0.9637792975442071 أو بالشكل التالي باستخدام الكلاس make_pipeline من نفس الموديول pipeline كالتالي:
from sklearn.linear_model import LogisticRegression from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.pipeline import make_pipeline from sklearn.metrics import confusion_matrix,accuracy_score, classification_report from sklearn.model_selection import train_test_split import pandas as pd # نقوم بتحميل الداتا Data = pd.read_csv('D:/train.csv') Data['Tweet'] =Data['Tweet'].astype(str) Data['Class'].replace({"abusive":0,"hate":0,"normal":1},inplace=True) data = Data['Tweet'] label = Data["Class"] # تقسيم الداتا X_train, X_test, Y_train, Y_test = train_test_split(data, label, test_size = 0.2, random_state = 2021) # pipeline نقوم بإنشاء pipe = make_pipeline(TfidfVectorizer(),LogisticRegression()) # نضع داخله الخطوات التي نريدها بشكل متتالي pipe.fit(X_train,Y_train) # مرحلة التقييم prediction = pipe.predict(X_test) print(f"Accuracy score is {accuracy_score(prediction, Y_test):.2f}") print(classification_report(prediction, Y_test))  

الخطأ هو أنك تقوم بإعطاء الموديل الخرج كقيمة حقيقة وهذا لا يجوز في التصنيف الذي يعمل مع القيم المتقطعة يمكن حل المشكلة بتحويل y_train إلى عدد صحيح int أو استخدام labelEncoder  
طريقة1: #استدعاء المكتبات import numpy as np from sklearn.linear_model import LogisticRegression from sklearn import preprocessing #داتا التدريب والاختبار X_train = np.array([ [2.3, 4.3, 2.5], [1.3, 5.2, 5.2], [3.3, 2.9, 0.8], [3.1, 4.3, 4.0] ]) y_train = np.array( [3.4, 7.5, 4.5, 1.6] ) X_test = np.array([ [2.5, 2.4, 2.7], [2.7, 3.2, 1.2] ]) #LabelEncoder تطبيق enc = preprocessing.LabelEncoder() y_new = enc.fit_transform(y_train) LR = LogisticRegression() LR.fit(X_train,y_new) print(LR.predict(X_test)) #طريقة 2 #استدعاء المكتبات import numpy as np from sklearn.linear_model import LogisticRegression from sklearn import preprocessing #داتا التدريب والاختبار X_train = np.array([ [2.3, 4.3, 2.5], [1.3, 5.2, 5.2], [3.3, 2.9, 0.8], [3.1, 4.3, 4.0] ]) y_train = np.array( [3.4, 7.5, 4.5, 1.6] ) X_test = np.array([ [2.5, 2.4, 2.7], [2.7, 3.2, 1.2] ]) #تحويل الخرج إلى عدد صحيح y_train=y_train.astype("int64") LR = LogisticRegression() LR.fit(X_train,y_train) print(LR.predict(X_test))  

يمكن ذلك باستخدام مكتبة time وتحديداً الدالة  time فنقوم بحساب الوقت قبل تنفيذ الكود والوقت بعد تنفيذ الكود ونقوم بطرح القيمة الأولى من الثانية فنحصل على الجواب بالثانية:
#استدعاء المكتبة import time start= time.time() #حساب الوقت قبل التنفيذ # نها تضع الكود end=time.time() #حساب الوقت بعد التنفيذ #طرح قيمة البداية من قيمة النهايه print(end - start)  

يمكنك ذلك عبر الموديول:
externals.joblib للحفظ نستخدم التابع التالي:
dump(model_name, 'path') لإعادةالتحميل:
load('path') مثال:
#استيراد المكتبات import numpy as np from sklearn.linear_model import LogisticRegression from sklearn.naive_bayes import GaussianNB from sklearn.ensemble import RandomForestClassifier, VotingClassifier from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split #تحميل البيانات data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) c1 = LogisticRegression(multi_class='multinomial', random_state=1) c2 = RandomForestClassifier(n_estimators=50, random_state=1) c3 = GaussianNB() ec1 = VotingClassifier(estimators=[ ('lr', c1), ('rf', c2), ('gnb', c3)], voting='hard') ec1 = ec1.fit(X_train, y_train) print(ec1.score(X_test,y_test))#0.9385964912280702 # نستدعي الكلاس import sklearn.externals.joblib as savemodel savemodel.dump(ec1 , 'model.sav') # نستخدم التابع التالي لعملية الحفظ # لإعادة تحميله loading = savemodel.load('model.sav')  

نستخدم K Neighbors Classifier
هي طريقة تستخدم في التصنيف حيث يتم تصنيف القيم عن طريق أقرب الجيران لها فمثلا لو كان لدينا مثال للتصنيف الثنائي 0 أو 1 وكان هذا المثال قريب إليه 5 أمثله تصنيفها 1 و4 أمثله تصنيفها 0 فسيكون تصنيف المثال 1 لأن عدد الجيران التي تصنيفها 1 هي الأكثر طبعا يكون ذلك بعد عملية اختيار الجيران التسعه الاقرب مثلا
يتم استخدام عبر الموديول:
neighbors.KNeighborsClassifier #استدعاء المكتبات:
from sklearn.neighbors import KNeighborsClassifier في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل:
KNNC=KNeighborsClassifier(n_neighbors=5, weights='uniform',algorithm=’auto’,p=2,n_jobs=None) الوسيط الأول n_neighbors عدد الجيران المستخدم في عملية التصنيف أي يتم اختيار أقرب خمس جيران مثلا ثم يتم الحكم بينهم
الوسيط الثاني weights هذا الوسيط يحدد الأساس الذي سيسير عليه KNeighborsClassifier حيث يأخذ ثلاث قيم هي  ‘uniform’ حيث تعني أن الجار القريب أو البعيد لهم نفس التأثير أي لا يفرق أحدهما في عملية التصنيف  أما  ‘distance’ هنا يتم اعتماد المسافه كعامل تقييم أي الاقرب مسافه إلى المثال الذي يتم التنبؤ بقيمته بتالي سوف يكون تأثير الجار ذو المسافة الأقل أكبر من الجار ذو المسافة الأبعد  أما القيمه الثالثه فيمكن إعطاءه داله من بناء المبرمج لتدخل في عملية التقييم 
الوسيط الثالث algorithm نوع الخوارزميه الذي يستخدمها KNeighborsClassifier لحساب أقرب جار وهي ‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’ ولكن ينصح باعتماد auto لكي يتم اختيار أفضل خوارزميه
الوسيط الرابع p  الطاقة لمقياس مينكوفسكي حيث عندما تساوي 1 يكون حساب المسافه عن طريق قانون منهاتن للمسافات وعندما تساوي 2 يتم الحساب عن طريق المسافة الإقليديه وفي الحاله الافتراضيه يتم استخدام مينكوفسكي
الوسيط الخامس  n_jobs عدد المعالجات التي تعمل بالتوازي وبتالي كلما زاد العدد زاد التسريع ,يوضع -1 للدلاله على عمل كامل المعالجات
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test, y_test  تسطيع كتابة الأتي لعملية التدريب.
#الشكل العام للموديل:
KNNC=KNeighborsClassifier(n_neighbors=4, weights='uniform',algorithm=’auto’,p=2,n_jobs=None) KNNC.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب  
يوجد دالة أخرى تستخدم لغرض التنبؤ  بالتصنيف كالاتي
#حساب قيم التصنيف:
y_pred = KNNC.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل
#حساب الكفاءه على التدريب والاختبار:
print('Train Score is : ' , KNNC.score(X_train, y_train)) print('Test Score is : ' , KNNC.score(X_test, y_test)) مثال:
# استيراد المكتبات from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt #تحميل البيانات data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) # KNeighborsClassifier تطبيق KNNC = KNeighborsClassifier(n_neighbors= 10,weights ='uniform',algorithm='auto') KNNC.fit(X_train, y_train) # عرض النتائج print('Train Score is : ' , KNNC.score(X_train, y_train)) print('Test Score is : ' , KNNC.score(X_test, y_test)) Train Score is : 0.9428571428571428 Test Score is : 0.9210526315789473  

هي طريقة تستخدم في التوقع حيث يتم التنبؤ بالقيم عن طريق أقرب الجيران لها فمثلا لو كان لدينا مثال للتوقع وكان هذا المثال قريب للقيمة 1 أكثر من القيمة 2 فإن قيمة المثال سوف تكون 1 لأنها أقرب إليه.
يتم استخدام عبر الموديول:
neighbors.KNeighborsRegressor #استدعاء المكتبات:
from sklearn.neighbors import KNeighborsRegressor في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل:
KNeighborsRegressorModel=KNeighborsRegressor(n_neighbors=5, weights='uniform',algorithm=’auto’, p=2,n_jobs=None) الوسيط الأول n_neighbors عدد الجيران المستخدم في عملية التوقع أي يتم اختيار أقرب خمس جيران ثم يتم الحكم بينهم
الوسيط الثاني weights هذا الوسيط يحدد الأساس الذي سيسير عليه KNeighborsRegressor حيث يأخذ ثلاث قيم هي  ‘uniform’ حيث تعني أن الجار القريب أو البعيد لهم نفس التأثير أي لا يفرق أحدهما في عملية التوقع  أما  ‘distance’ هنا يتم اعتماد المسافه كعامل تقييم أي الاقرب مسافه إلى المثال الذي يتم التنبؤ بقيمته بتالي سوف يكون تأثير الجار ذو المسافة الأقل أكبر من الجار ذو المسافة الأبعد  أما القيمه الثالثه فيمكن إعطاءه داله من بناء المبرمج لتدخل في عملية التقييم 
الوسيط الثالث algorithm نوع الخوارزميه الذي يستخدمها KNeighborsRegressor لحساب أقرب جار وهي ‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’ ولكن ينصح باعتماد auto لكي يتم اختيار أفضل خوارزميه
الوسيط الرابع p  الطاقة لمقياس مينكوفسكي حيث عندما تساوي 1 يكون حساب المسافه عن طريق قانون منهاتن للمسافات وعندما تساوي 2 يتم الحساب عن طريق المسافة الإقليديه وفي الحاله الافتراضيه يتم استخدام مينكوفسكي
الوسيط الخامس  n_jobs عدد المعالجات التي تعمل بالتوازي وبتالي كلما زاد العدد زاد التسريع ,يوضع -1 للدلاله على عمل كامل المعالجات
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test, y_test  تسطيع كتابة الأتي لعملية التدريب
#الشكل العام للموديل.
KNeighborsRegressorModel=KNeighborsRegressor(n_neighbors=5, weights='uniform', algorithm=’auto’, p=2,n_jobs=-1) KNeighborsRegressorModel.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب  
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي
#حساب القيم المتوقعة:
y_pred = KNeighborsRegressorModel.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل
#حساب الكفاءة على التدريب والاختبار:
print('Train Score is : ' , KNeighborsRegressorModel.score(X_train, y_train)) print('Test Score is : ' , KNeighborsRegressorModel.score(X_test, y_test)) حيث قمنا بطباعة قيمتها لكي نرى كفاءة الموديل على بيانات الاختبار  والتدريب وهل هو يعاني من الضبط الزائد  overfit أو الضبط الناقص underfit.
مثال:
from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsRegressor # تحميل الداتا 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) # KNeighborsRegressor تطبيق KNeighborsRegressorModel = KNeighborsRegressor(n_neighbors = 8, weights='uniform',algorithm = 'auto') KNeighborsRegressorModel.fit(X_train, y_train) # عرض النتائج print('Train Score is : ' , KNeighborsRegressorModel.score(X_train, y_train)) print('Test Score is : ' , KNeighborsRegressorModel.score(X_test, y_test))  

PCA
هي طريقة تستخدم لتقليل الأبعاد أي تقليل عدد الفيتشرز بهدف تسريع عملية معالجة البيانات.
لا يقوم PCA بتقليل المساحه في الهارد وأنما يقلل المساحة في الذاكره العشوائية أثناء عملية التدريب.
وغالباً ماتستخدم مع التعليم بدون إشراف إلا أنه يتم استخدامها أحياناً مع التعليم بإشراف لكنها تؤثر على كفاءة النموذج بشكل سلبي فهي لاتأخذ قيم ال target بعين الاعتبار.
يتم استخدامه عبر الموديول sklearn.decomposition
#استدعاء المكتبات:
from sklearn.decomposition import PCA في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل:
PCAM=PCA(n_components=None, copy=True,svd_solver='auto', iterated_power='auto', random_state=None) الوسيط الأول n_components هو عدد حقيقي أو صحيح يشير إلى عدد المكونات التي سيتم الإبقاء عليها المقصود بالمكونات أقل عدد أمثلة وعدد الفيتشرز وإذا أخذ None يتم الاحتفاظ بجميع المكونات.
الوسيط الثاني copy قيمة بوليانية إذا كان false فإنه سوف يتم العمل على نسخة من البيانات الأصلية أي تعديل على البيانات سوف يكون دائم أما إذا كان True تؤخذ نسخة من البيانات.
الوسيط الثالث svd_solver  يمثل طريقة الحل  يأخذ  ‘auto’, ‘full’, ‘arpack’, ‘randomized’ وكل قيمة لها طريقتها في اختيار الأبعاد لذلك ينصح بوضع ‘auto’ لكي تكون عملية الاختيار تلقائية.
الوسيط الرابع iterated_power  عدد التكرارات المسموحة عندما يكون svd_solver=randomized.
ويمكن وضعها auto لكي يتم التحديد بشكل تلقائي.
الوسيط الخامس random_state للتحكم بآلية التقسيم.
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامة سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train,X_test  نستطيع كتابة الأتي لعملية التدريب.
#الشكل العام للموديل:
PCAM=PCA(n_components=None, copy=True, whiten=False,svd_solver='auto', tol=0.0001, iterated_power='auto', random_state=None) PCAM.fit(X_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب
نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score وحساب عدد المكونات  وفق الشكل
#حساب الكفاءة على التدريب والاختبار وعدد المكونات:
print('Train Score is : ' , PCAM.score(X_train)) print('Test Score is : ' , PCAM.score(X_test)) print('No. of components is : ' , PCAM.components_) الان للحصول على X الجديدة نستخدم transform
#الحصول على الدخل الجديد:
X =PCAM.transform(X) يوجد دالة تقوم بالعمليتن معا التدريب والتحويل fit_transform.
#استدعاء المكتبات from sklearn.decomposition import PCA #الشكل العام للموديل PCAM=PCA(n_components=None, copy=True, whiten=False,svd_solver='auto', tol=0.0001, iterated_power='auto', random_state=None) PCAM.fit(X_train) #حساب الكفاءه على التدريب والاختبار وعدد المكونات print('Train Score is : ' , PCAM.score(X_train)) print('Test Score is : ' , PCAM.score(X_test)) print('No. of components is : ' , PCAM.components_) #الحصول على القيم X_new =PCAM.transform(X_train)  

اعتقد أنك تقصد الفرق بينهما أليس كذلك؟! حسناً...
وظائفهما متشابهة لحد ما، لذا فغالباً ماتذكران معاً. لكن جذور التقنيتين مختلفة كثيراً.
LVM:  هي التقنية الستخدمة من قبل نظام لينوكس وهي اختصار ل Logical Volume Manager "مدير التخزين المنظقي"، تستخدم لعزل الحيز التخزيني المتاح لنظام الملفات (المنطقي) عن الحيز التخزيني الفيزيائي، بحيث تجعل إدارة البيانات أكثر مرونة واستقلالاً  عن السعة الحقيقية للأقراص عند تحميل تلك البيانات.
RAID: وهي تفنية مستخدمة في التخزين وهي اختصاراً ل "Redundant Array of Independent Disks" أي التخزين الفائض للبيانات على الأقراص بحيث تحمي البيانات من الفقدان الذي قد يحصل بسبب فشل الأقراص أو حدوث عطب ما في أحد الأقراص فهي تستخدم طريقة بأن تخزن الملف على أكثر من قرص (الأقراص تكون رخيصة الثمن ) وله أكثر من مستوى من RAID0 إلى 6 وكل مستوى له خصائصه.

ليس بالضرورة أن نجعل كل المستخدمين يصلون إلى كافة البيانات في قاعدة البيانات قد نحجب بعض الواصفات في علاقة ما عن المستخدمين  وذلك باستخدام مفهوم ليس بإنشاء جدول جديد وليس استعلام جديد. وإنما بإنشاء مايسمى "منظار" نستطيع من خلاله الوصول إلى جزء محدد من قاعدة البيانات.
إن المنظار هو علاقة لاتنتمي إلى النموذج المنطقي لقاعدة البيانات لكنها تعرض للمستخدم بشكل مرئي كعلاقة افتراضية Virtual relation.
CREATE VIEW view_name(c1,c2,...,cn) AS SELECT ...,...,... FROM ... WHERE ... c تشير لاسم العمود
## يمكننا استخدام اسم المنظار للوصول إلى العلاقة الافتراضية (الجدول الوهمي) الناتجة عن استعلام هذا المنظار المعرف مسبقاً.
## المنظار ليس جدول جديد يخزن في ال Database وإنما يتم تخزين الاستعلام الذي عرف المنظار من خلاله.
## يتم تنفيذ الاستعلام الموجود في المنظار في كل مرة يتم فيها ذكر هذا المنظار.
## عند الطلب يتم تنفيذ الاستعلام.
مثلاً سوف أقوم بإنشاء منظار لعلاقة ما ولتكن A بحيث أخفي فيها الواصفة c2 أما باقي الواصفات تكون مرئية:
CREATE VIEW myview AS SELECT c1,c3,cn # c2 لا نضع FROM A; # ثم يمكنك التعامل معه وكأنه علاقة موجودة في القاعدة لذا نسميها علاقة افتراضية  

يمكنك ذلك عن طريق الموديول:
ensemble.GradientBoostingClassifier الصيغة العامة:
sklearn.ensemble.GradientBoostingClassifier(loss='deviance', learning_rate=0.1, n_estimators=100, subsample=1.0, criterion='friedman_mse', min_samples_split=2, min_samples_leaf=1, max_depth=3, random_state=None, max_features=None, verbose=0, max_leaf_nodes=None, validation_fraction=0.1, n_iter_no_change=None, tol=0.0001, ccp_alpha=0.0) الوسطاء:
loss: معادلة التكلفة المستخدمة. {‘deviance’, ‘exponential’}, 'default=’deviance
n_estimators : عدد مراحل ال  boosting المستخدمة.  default=100
learning_rate: قيمة معامل التعلم افتراضياً 0.1.
criterion: الأسلوب الرياضي للمعالجة (قياس جودة الانقسام) وتكون {‘friedman_mse’, ‘mse’, ‘mae’}, 'default=’friedman_mse
max_depth  : عمق الأشجار.
min_samples_split:الحد الأدنى لعدد العينات المطلوبة لتقسيم عقدة داخلية. int , default=2.
min_samples_leaf:  الحد الأدنى لعدد العينات المطلوبة في العقدة التي تمثل الاوراق.  default=1.
random_state: يتحكم بعملية التقسيم افتراضياً يكون None.
verbose: لعرض التفاصيل التي تحدث في التدريب. افاراضياً 0 أي لايظهر شيء، أما وضع أي قيمة أكبر من الصفر سيعرض التفاصيل int.
max_features:العدد المناسب من الفيتشرز التي يتم احتسابها {“auto”, “sqrt”, “log2”}.
في حال auto:
max_features=sqrt(n_features).
sqrt:
ax_features=sqrt(n_features).
log2:
max_features=log2(n_features).
None:
max_features=n_features.
إذا وضعت قيمة float:
max_features=int(max_features * n_features)
قيمة int:
سيتم أخذ ال features  عند كل تقسيمة ك max_features.
validation_fraction: النسبة التي سيتم اقتطاعها من عينة التدريب للاستخدام كعينة تطوير. افتراضياً 0.1
n_iter_no_change: لتطبيق مفهوم التوقف المبكر "early stopping" (إيقاف التدريب عندما تتوقف عينة التطةير عن التحسن). افتراضياً None أي لن تطبق، إذا أسندت لها أي عدد صحيح سيتم تطبيقه.
tol: مقدار السماحية في التقاربم من القيم المثالية. افتراضياً 0.0001
ccp_alpha: معامل تعقيد  يستخدم لتقليل التكلفة الزمانية والمكانية. non-negative float, default=0.0
ال attributtes:
classes_: لعرض ال labels التي وجدها.
n_outputs_: عدد المخرجات الناتجة عن عملية ال fitting.
estimators_: عرض معلومات عن كل الخوارزميات التي تم تشكيلها.
feature_importances_: عرض أهم الفيتشرز المؤثرة في التوقع.
n_features_: عدد الفيتشرز.
التوابع:
fit(data): للقيام بعملية التدريب.
predict(data): لتوقع القيم.
score(data):  لتقييم كفاءة النموذج.
()get_params :لايجاد مقدار الدقة.
predict_proba(data) : لعمل التوقع أيضاً لكن هنا سيخرج الفيمة الاحتمالية(أي لن يتم القصر على  عتبة)
apply(data):  ياتي لك بقيمة الورقة المحسوبة.
مثال:
# استيراد المكتبات from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.ensemble import GradientBoostingClassifier from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt #تحميل البيانات data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) # RandomForestClassifier تطبيق GBCM = GradientBoostingClassifier(n_estimators=110,max_depth=1,random_state=44,n_iter_no_change=1) GBCM.fit(X_train, y_train) print('Train Score is : ' , GBCM.score(X_train, y_train)) # Train Score is : 0.9758241758241758 print('Test Score is : ' , GBCM.score(X_test, y_test)) # Test Score is : 0.9649122807017544 #print('No. of n_classes_ are : ' , GBCM.n_classes_) # No. of n_classes_ are : 2 #print('No. of features are :', GBCM.n_features_) # No. of features are : 30 # عرض معلومات عن كل الأشجار التي تم تشكيلها #print(GBCM.estimators_) # عرض أهم الفيتشرز #print( GBCM.feature_importances_)  

يمكنك استخدامها عبر الموديول:
ensemble.RandomForestClassifier الصيغة العامة:
sklearn.ensemble.RandomForestClassifier(n_estimators=100, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1, max_features='auto', max_leaf_nodes=None, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, ccp_alpha=0.0) n_estimators : عدد أشجار القرار المستخدمة.  default=100
criterion: الأسلوب الرياضي للمعالجة وتكون {“gini”, “entropy”}, 'default='gini
max_depth   :  عمق الأشجار.
min_samples_split:الحد الأدنى لعدد العينات المطلوبة لتقسيم عقدة داخلية. int , default=2.
min_samples_leaf:  الحد الأدنى لعدد العينات المطلوبة في العقدة التي تمثل الاوراق.  default=1.
max_features:العدد المناسب من الفيتشرز التي يتم احتسابها {“auto”, “sqrt”, “log2”}.
في حال auto:
max_features=sqrt(n_features).
sqrt:
ax_features=sqrt(n_features).
log2:
max_features=log2(n_features).
None:
max_features=n_features.
إذا وضعت قيمة float:
max_features=int(max_features * n_features)
قيمة int:
سيتم أخذ ال features  عند كل تقسيمة ك max_features.
bootstrap: لتحديد فيما إذا كان سيتم استخدام عينات ال bootstrap عند بناء الأشجار. في حال ضبطها على true سيتم استخدام كامل البيانات لبناء كل شجرة. افتراضياً تكون False.
oob_score: لتحديد فيما إذا كان سيتم استخدام عينات out-of-bag لتقدير قيمة التعميم "generalization score". ويجب أن تكون bootstrap مضبوطة على True لاستخدامها.
n_jobs: عدد المهام التي يتم تنفيذها بالتوازي. -1 للتنفيذ بأقصى سرعة ممكنة.
random_state: يتحكم بعملية التقسيم افتراضياً يكون None.
verbose: لعرض التفاصيل التي تحدث في التدريب. افاراضياً 0 أي لايظهر شيء، أما وضع أي قيمة أكبر من الصفر سيعرض التفاصيل int.
ccp_alpha: معامل تعقيد  يستخدم لتقليل التكلفة الزمانية والمكانية. non-negative float, default=0.0
التوابع:
fit(data): للقيام بعملية التدريب.
predict(data): لتوقع القيم.
score(data):  لتقييم كفاءة النموذج.
()get_params :لايجاد مقدار الدقة
predict_proba(data) : لعمل التوقع أيضاً لكن هنا سيخرج الفيمة الاحتمالية(أي لن يتم القصر على  عتبة)
apply(data):  ياتي لك بقيمة الورقة المحسوبة.
()get_n_leaves: يرد عدد الأوراق.
()get_depth: يرد عمق الشجرة.
ال attributtes:
classes_: لعرض ال labels التي وجدها.
n_outputs_: عدد المرخرجات الناتجة عن عملية ال fitting.
estimators_: عرض معلومات عن كل الأشجار التي تم تشكيلها.
base_estimator_:عرض معلومات الشجرة الأساسية
feature_importances_: عرض أهم الفيتشرز المؤثرة في التوقع.
n_features_: عدد الفيتشرز.
مثال:
# استيراد المكتبات from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt #تحميل البيانات data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) # RandomForestClassifier تطبيق RandomForestC = RandomForestClassifier(criterion = 'gini',n_estimators=100,max_depth=2,random_state=33) #criterion can be also : entropy RandomForestC.fit(X_train, y_train) print('Train Score is : ' , RandomForestC.score(X_train, y_train)) # 0.9538461538461539 print('Test Score is : ' , RandomForestC.score(X_test, y_test)) # Test Score is : 0.9298245614035088 #print('No. of classes are : ' , RandomForestC.n_classes_) # No. of features are : 2 #print('No. of features are : ' RandomForestC.n_features_) # No. of features are : 30 #print('No. of n_outputs are : ' , RandomForestC.n_outputs_) # No. of n_outputs are : # عرض معلومات عن كل الأشجار التي تم تشكيلها #print(RandomForestC.estimators_) # عرض معلومات الشجرة الأساسية #print( RandomForestC.base_estimator_) # عرض أهم الفيتشرز #print( RandomForestC.feature_importances_)  

يمكن ذلك بطريقتين :
الطريقه الأولى بعد تهيئة القاموس نقوم باستخدام التابع setdefault حيث يأخذ وسيطين الأول المفتاح والثاني نوع القيم ممكن أن تكون list وset وغيرها وبعد ذلك نستخدم append الخاص ب list لأضافة القيمة
#طريقة أولى:
dic={} # تعريف قاموس فارغ yourlist=[[88,66],[80,3]] # تعريف قائمة for j in range(len(yourlist)): dic.setdefault(j, list()).append(yourlist[j]) print(dic) # {0: [[88, 66]], 1: [[80, 3]]} الطريقة الثانية بدون التابع setdefault نقوم فقط بعملية إسناد تقليدية
#طريقة ثانية:
dic={} # تعريف قاموس فارغ yourlist=[[88,66],[80,3]] # تعريف قائمة for j in range(len(yourlist)): dic[j]=yourlist[j]  

ال multithreading ليست دوماً الحل الأفضل لتسريع البرنامج:
هناك عبء  overhead مرتبط بإدارة ال Threads، لذلك لايكون من الجيد استخدامها للمهام البسيطة (الغاية الأساسية هي السرعة في التنفيذ، لكن في هكذا حالات قد تكون النتائج سيئة أي قد يزداد زمن التنفيذ وهذا ما لانريده فنحن بالأساس نتجه لتحقيق الThreading لكي يقل زمن التنفيذ وليس العكس)
ال multithreading يزيد من تعقيد البرنامج ، مما يجعل تصحيح الأخطاء أكثر صعوبة.
ال multiprocessing:
هناك عبء مرتبط بها عندما يتعلق الأمر بعمليات الإخراج والإدخال.
لاتتم مشاركة الذاكرة بين ال subprocess حيث يكون لكل subprocess نسخة كاملة خاصة به من الذاكرة وهذا يشكل عبء Overhead بالنسبة للبرامج الأخرى.
إن الموديول multiprocessing يستخدم ال Processes أي أن التعليمة الثانية التي أشرت لها في كتابتك تقوم بإنشاء Processe  أما الموديول multithreading يستخدم ال Threads أي أن التعليمة الأولى التي أشرت لها تقوم بإنشاء Thread، والفرق الأساسي بينهم أن الأولى تستخدم ذاكرة منفصلة لكل subprocess (كما أشرت في الأعلى) بينما ال Threads تتشارك الذاكرة وبالتالي في ال multiprocessing لاخوف من حدوث حالات تلف البيانات أو التوقف التام deadlock بينما في ال multithreading فهذا وارد الحدوث.
متى نستخدم كل منها:
إذا كان البرنامج يحوي العديد من مهام الإدخال والإخراج أو استخدام الشبكة فيفضل استخدام ال threading لأنها سيترتب عليها overhead أقل من ال multiprocessing. أو إذا كان لديك GUI في برنامجك.
إذا كان برنامجك يحوي على  العديد من العمليات الحسابية "CPU bound" فيفضل التعامل مع ال multiprocessing.

هي طريقه تكافئ طريقة KMeans الفرق الوحيد هو أنه يتم تقسيم الداتا إلى أجزاء ومن ثم تطبيق KMeans لتسريع العملية.
يتم استخداه عبر الموديول  cluster.MiniBatchKMeans
#استدعاء المكتبات
from sklearn.cluster import MiniBatchKMeans في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل
MiniBatchKMeansModel=MiniBatchKMeans(n_clusters=8,init='k-means++',batch_size=100, compute_labels=True,random_state=None, max_no_improvement=10) البارمتر الأول n_clusters وهو عدد العناقيد المراد تكوينها 
البارمتر الثاني init مصفوفه ابعادها عدد الفيتشرز ضرب عدد العناقيد ولتهيئتها يوجد طريقتين الأولى random يتم اختيار مراكز العناقيد الأوليه بشكل عشوائي من الصفوف في الداتا 
و k-means++ يتم اختيار المراكز الأوليه بطريقه ذكيه لتسريع التقارب
البارمتر الثالثbatch_size وهو يمثل حجم كل جزء مقسم
البارمتر الرابع compute_labels عند إعطاءه القيمه True يقوم بحساب عدد العناقيد بمجرد أن يصل أحد الأجزاء إلى التقارب 
البارمتر الخامس  random_state للتحكم بآلية التقسيم
البارمتر السادس max_no_improvement تحديد العدد الأعظمى لعدد الأجزاء المتتاليه التي لا تحسن في التقارب عن طريق التوقف المبكر عند وضعها None تتعطل هذه المهمه
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train,X_test  تسطيع كتابة الأتي لعملية التدريب
#الشكل العام للموديل:
MiniBatchKMeansModel = MiniBatchKMeans(n_clusters=8, init='k-means++', batch_size=100,compute_labels=True, random_state=None,max_no_improvement=10) MiniBatchKMeansModel.fit(X_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب  
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي
#حساب القيم المتوقعة:
y_pred = MiniBatchKMeansModel.predict(X_test) حيث قمنا بحساب كل سطر من داتا الاختبار  لأي عنقود يتبع
نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل
#طباعة الكفاءه على التدريب والاختبار ومراكز العناقيد
print('Train Score is : ' , MiniBatchKMeansModel.score(X_train)) print('Test Score is : ' , MiniBatchKMeansModel.score(X_test)) print('centers are : ' , MiniBatchKMeansModel.cluster_centers_)  

لزيادة الفائدة أود إلقاء مراجعة صغيرة على هذه الخوارزمية قبل أن أعرض لك كيفية تطبيقها:
K-Means طريقة لعمل تقسيم للبيانات الغير معنونة أي unlabeled data يتم أولاً تحديد عدد المجموعات المطلوب Clusters تقوم الخوارزمية بتحديد عدد من النقاط العشوائية وسط النقاط تسمي cluster centroid ويكون عددها هو نفس عدد المجموعات المطلوب ثم يقوم بتقسيم نقاط العينة عبر المراكز  يقوم بعمل تغيير في اماكن المراكز , و يعيد الخطوة , حتي يصل للشكل الأمثل وهو يستخدم في التعلم بلا إشراف.
في Sklearn يتم استخدامها عبر الموديول cluster.KMeans.
#استدعاء المكتبة
from sklearn.cluster import KMeans في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل
sklearn.cluster.KMeans(n_clusters=8, init='k-means++', n_init=10, random_state=None, copy_x=True, n_jobs=None, algorithm='auto’) البارمتر الأول n_clusters وهو عدد العناقيد المراد تكوينها 
البارمتر الثاني init مصفوفه ابعادها عدد الفيتشرز ضرب عدد العناقيد ولتهيئتها يوجد طريقتين الأولى random يتم اختيار مراكز العناقيد الأوليه بشكل عشوائي من الصفوف في الداتا 
و k-means++ يتم اختيار المراكز الأوليه بطريقه ذكيه لتسريع التقارب
البامتر الثالث n_init عدد المرات التي ستعمل فيها الخوارزميه مع مراكز عناقيد مختلفه
البارمتر الرابع random_state للتحكم بآلية التقسيم
البارمتر الخامس  copy_x في حال ضبطه على True سوف يأخذ نسخة من البيانات ولن يتم التعديل عليها أي أن البيانات تعود كما أخذت أما في حال false سوف يتم التعديل على البيانات الاصليه
البارمتر السادس n_jobs عدد المعالجات التي تعمل بالتوازي وبتالي كلما زاد العدد زاد التسريع ,يوضع -1 للدلاله على عمل كامل المعالجات
البارمتر السابع algorithm الخوارزميه التي تستخدمها kmean ويفضل وضع auto لترك kmeans تقرر المناسب لها
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train,X_test  تسطيع كتابة الأتي لعملية التدريب
#الشكل العام للموديل
KMeansM=KMeans(n_clusters=8, init='k-means++', n_init=10, random_state=None, copy_x=True, n_jobs=None, algorithm='auto’) KMeansM.fit(X_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب  
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي
#حساب القيم المتوقعة
y_pred = KMeansModel.predict(X_test) حيث قمنا بحساب كل سطر من داتا الاختبار  لأي عنقود يتبع
نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل
#طباعة الكفاءه على التدريب والاختبار ومراكز العناقيد
print('Train Score is : ' , KMeansM.score(X_train)) print('Test Score is : ' , KMeansM.score(X_test)) print('centers are : ' , KMeansM.cluster_centers_) #استدعاء المكتبات from sklearn.cluster import KMeans #الشكل العام للموديل KMeansM=sklearn.cluster.KMeans(n_clusters=8, init='k-means++', n_init=10, random_state=None, copy_x=True, n_jobs=None, algorithm='auto’) KMeansM.fit(X_train) #طباعة الكفاءه على التدريب والاختبار ومراكز العناقيد print('Train Score is : ' , KMeansM.score(X_train)) print('Test Score is : ' , KMeansM.score(X_test)) print('centers are : ' , KMeansM.cluster_centers_) #حساب القيم المتوقعه y_pred = KMeansModel.predict(X_test)  

يمكنك استخدامها عبر الموديول
ensemble.RandomForestRegressor الصيغة العامة:
sklearn.ensemble.RandomForestRegressor(n_estimators=100, criterion='mse', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto', bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0 ccp_alpha=0.0, max_samples=None) n_estimators : عدد أشجار القرار المستخدمة.
max_depth   :  عمق الأشجار.
min_samples_split: الحد الادني من التقسيمات المسموح بها.
n_jobs: عدد المهام التي يتم تنفيذها بالتوازي. -1 للتنفيذ بأقصى سرعة ممكنة.
random_state: يتحكم بعملية التقسيم افتراضياً يكون None.
ccp_alpha: معامل تعقيد  يستخدم لتقليل التكلفة الزمانية والمكانية. non-negative float, default=0.0
criterion: الأسلوب الرياضي للمعالجة وتكون {“mse”, “friedman_mse”, “mae”, “poisson”}, "default=”mse
min_samples_split:الحد الأدنى لعدد العينات المطلوبة لتقسيم عقدة داخلية. int , default=2.
min_samples_leaf:  الحد الأدنى لعدد العينات المطلوبة في العقدة التي تمثل الاوراق.  default=1.
verbose: لعرض التفاصيل التي تحدث في التدريب. افاراضياً 0 أي لايظهر شيء، أما وضع أي قيمة أكبر من الصفر سيعرض التفاصيل int.
bootstrap: لتحديد فيما إذا كان سيتم استخدام عينات ال bootstrap عند بناء الأشجار. في حال ضبطها على true سيتم استخدام كامل البيانات لبناء كل شجرة. افتراضياً تكون False.
oob_score: لتحديد فيما إذا كان سيتم استخدام عينات out-of-bag لتقدير قيمة التعميم "generalization score". ويجب أن تكون bootstrap مضبوطة على True لاستخدامها.
max_features:العدد المناسب من الفيتشرز التي يتم احتسابها {“auto”, “sqrt”, “log2”}.
في حال auto:
max_features=sqrt(n_features).
sqrt:
ax_features=sqrt(n_features).
log2:
max_features=log2(n_features).
None:
max_features=n_features.
إذا وضعت قيمة float:
max_features=int(max_features * n_features)
قيمة int:
سيتم أخذ ال features  عند كل تقسيمة ك max_features.
التوابع:
fit(data): للقيام بعملية التدريب.
predict(data): لتوقع القيم.
score(data):  لتقييم كفاءة النموذج.
()get_params :لايجاد مقدار الدقة
predict_proba(data) : لعمل التوقع أيضاً لكن هنا سيخرج الفيمة الاحتمالية(أي لن يتم القصر على  عتبة)
apply(data):  ياتي لك بقيمة الورقة المحسوبة.
()get_n_leaves: يرد عدد الأوراق.
()get_depth: يرد عمق الشجرة.
ال attributtes:
classes_: لعرض ال labels التي وجدها.
feature_importances_: عرض أهم الفيتشرز المؤثرة في التوقع.
مثال:
from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestRegressor # تحميل الداتا 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) # DecisionTreeRegressor تطبيق RandomForestR = RandomForestRegressor(n_estimators=100, random_state=44) RandomForestR.fit(X_train, y_train) #Calculating Details print('Train Score is : ' , RandomForestR.score(X_train, y_train)) print('Test Score is : ' , RandomForestR.score(X_test, y_test)) # 0.7831947504479144 print('No. of features are : ' , RandomForestR.n_features_)  

يمكنك القيام بذلك عن طريق الموديول tree أن تستدعي الكلاس DecisionTreeRegressor:
sklearn.tree.DecisionTreeRegressor الصيغة العامة:
sklearn.tree.DecisionTreeRegressor( criterion='mse', splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, ccp_alpha=0.0) الوسطاء نفسها في حالة التصنيف مع بعض الاختلافات في القيم:
criterion: الأسلوب الرياضي للمعالجة وتكون {“mse”, “friedman_mse”, “mae”, “poisson”}, "default=”mse
splitter: الاستراتيجية المستخدمة لاختيار الانقسام عند كل عقدة. {“best”, “random”}, "default=”best
random ليكون التقسيم عشوائي و best لاختيار أفضل تقسيم.
min_samples_split:الحد الأدنى لعدد العينات المطلوبة لتقسيم عقدة داخلية. int , default=2.
min_samples_leaf:  الحد الأدنى لعدد العينات المطلوبة في العقدة التي تمثل الاوراق.  default=1
n_jobs: عدد المهام التي يتم تنفيذها بالتوازي نضع -1 للتنفيذ على ال GPU.
max_depth: عمق شجرة القرار. default=None
min_samples_split:الحد الادني من التقسيمات المسموح بها
tol: (مقدار السماحية) عدد يمثل نقطة إيقاف التعلم  بحال تجاوز هذه القيمه فيتوقف ال optimizer .
max_features:العدد المناسب من الفيتشرز التي يتم احتسابها {“auto”, “sqrt”, “log2”}.
في حال auto:
max_features=sqrt(n_features).
sqrt:
ax_features=sqrt(n_features).
log2:
max_features=log2(n_features).
None:
max_features=n_features.
إذا وضعت قيمة float:
max_features=int(max_features * n_features)
قيمة int:
سيتم أخذ ال features  عند كل تقسيمة ك max_features.
random_state: يتحكم بعملية التقسيم افتراضياً يكون None.
ccp_alpha: معامل تعقيد  يستخدم لتقليل التكلفة الزمانية والمكانية. non-negative float, default=0.0
التوابع:
fit(data): للقيام بعملية التدريب.
predict(data): لتوقع القيم.
score(data):  لتقييم كفاءة النموذج.
()get_params :لايجاد مقدار الدقة
predict_proba(data) : لعمل التوقع أيضاً لكن هنا سيخرج الفيمة الاحتمالية(أي لن يتم القصر على  عتبة)
apply(data):  ياتي لك بقيمة الورقة المحسوبة.
()get_n_leaves: يرد عدد الأوراق.
()get_depth: يرد عمق الشجرة.
ال attributtes:
classes_: لعرض ال labels التي وجدها.
feature_importances_: عرض أهم الفيتشرز المؤثرة في التوقع.
مثال:
# بيانات أسعار المنازل في مدينة بوسطن from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeRegressor # تحميل الداتا 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) # DecisionTreeRegressor تطبيق DecisionTreeR = DecisionTreeRegressor(random_state=20) DecisionTreeR.fit(X_train, y_train) #حساب الدقة print('Train Score is : ' , DecisionTreeR.score(X_train, y_train)) print('Test Score is : ' , DecisionTreeR.score(X_test, y_test)) #حعرض التوقعات y_pred = DecisionTreeR.predict(X_test) print(y_pred)  

يمكنك القيام بذلك عن طريق الموديول tree أن تستدعي الكلاس DecisionTreeClassifier:
tree.DecisionTreeClassifier الصيغة العامة:
sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, ccp_alpha=0.0
الوسطاء:
splitter: الاستراتيجية المستخدمة لاختيار الانقسام عند كل عقدة. {“best”, “random”}, "default=”best
random ليكون التقسيم عشوائي و best لاختيار أفضل تقسيم.
min_samples_split:الحد الأدنى لعدد العينات المطلوبة لتقسيم عقدة داخلية. int , default=2.
min_samples_leaf:  الحد الأدنى لعدد العينات المطلوبة في العقدة التي تمثل الاوراق.  default=1
n_jobs: عدد المهام التي يتم تنفيذها بالتوازي نضع -1 للتنفيذ على ال GPU.
max_depth: عمق شجرة القرار. default=None
min_samples_split:الحد الادني من التقسيمات المسموح بها
tol: (مقدار السماحية) عدد يمثل نقطة إيقاف التعلم  بحال تجاوز هذه القيمه فيتوقف ال optimizer .
max_features:العدد المناسب من الفيتشرز التي يتم احتسابها {“auto”, “sqrt”, “log2”}.
في حال auto:
max_features=sqrt(n_features).
sqrt:
ax_features=sqrt(n_features).
log2:
max_features=log2(n_features).
None:
max_features=n_features.
إذا وضعت قيمة float:
max_features=int(max_features * n_features)
قيمة int:
سيتم أخذ ال features  عند كل تقسيمة ك max_features.
random_state: يتحكم بعملية التقسيم افتراضياً يكون None.
ccp_alpha: معامل تعقيد  يستخدم لتقليل التكلفة الزمانية والمكانية. non-negative float, default=0.0
criterion: الأسلوب الرياضي للمعالجة وتكون  gini , entropy
min_impurity_split: عتبة التوقف المبكر لنمو الشجرة.float, default=0
التوابع:
fit(data): للقيام بعملية التدريب.
predict(data): لتوقع القيم.
score(data):  لتقييم كفاءة النموذج.
()get_params :لايجاد مقدار الدقة
predict_proba(data) : لعمل التوقع أيضاً لكن هنا سيخرج الفيمة الاحتمالية(أي لن يتم القصر على  عتبة)
apply(data):  ياتي لك بقيمة الورقة المحسوبة.
ال attributtes:
classes_: لعرض ال labels التي وجدها.
feature_importances_: عرض أهم الفيتشرز المؤثرة في التوقع.
# استيراد المكتبات from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt #تحميل البيانات data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) DecisionTreeC = DecisionTreeClassifier(criterion='gini',max_depth=3,random_state=2021) DecisionTreeC.fit(X_train, y_train) # حساب التوقع print('Train Score is : ' , DecisionTreeC.score(X_train, y_train)) print('Test Score is : ' , DecisionTreeC.score(X_test, y_test)) # 0.9473684210526315 # عرض الفئات الموجودة print('Classes are : ' , DecisionTreeC.classes_) # Classes are : [0 1] #عرض أهم الفيتشرز التي تؤثر في عملية التوقع print('feature importances are : ' , DecisionTreeC.feature_importances_) #حساب التوقع y_pred = DecisionTreeC.predict(X_test) # حساب التوقع كقيماحتمالية y_pred_prob = DecisionTreeC.predict_proba(X_test)  

يمكنك القيام بذلك عن طريق الكلاس SVC  من الموديول SVM. أي يمكنك استخدامها عبر الموديول svm.SVC
C-Support Vector Classification
الصيغة العامة:
class sklearn.svm.SVC(C=1.0, kernel='rbf', degree=3, coef0=0.0, shrinking=True, probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=- 1, decision_function_shape='ovr', gamma='scale', break_ties=False, random_state=None) الوسطاء:
يوجد عدة أنواع ‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’ ننصح دوما باستخدام rbf لأنها الأفضل.
degree: وهو في حال أردنا جعل ال regressor غير خطي أي Polynomial نضبطه بالدرجة التي نريدها(default=3).
بحال استخدام الkernel=poly فيجب تحديد درجة كثير الحدود.
 tol: عدد يمثل نقطة إيقاف التعلم  بحال تجاوز هذه القيمه فيتوقف svr.
kernel: النواة أو المعادلة المستخدمة تكافئ فكرة تابع التنشيط في الشبكات العصبونية.
C: معامل التنعيم أفضل القيم للتجريب 0.1,0.001,10,1
max_iter: العدد الأقصى للتكرارت إذا وضعت -1 فأنه يأخذ الحد الأعلى ويفضل ذلك
epsilon: ضمن هذا المقدار لن يتم تطبيق أي penalty على تابع التكلفة. أي هي هامش للسماحية بدون تطبيق penalty. افتراضياً default=0.1.
cache_size: تحديد حجم ال kernel cache وافتراضياً 200 MB.
gamma: معمل النواة وهي إما {‘scale’, ‘auto’}أو float وتكون افتراضياً 'default=’scale.
coef0: مصطلح مستقل يتعلق بدالة النواة ويعمل فقط في حالة كانت الدالة هي sigmoid و poly.
shrinking: لتحديد فيما إذا كنت تريد استخدام shrinking heuristic أو لا.
decision_function_shape: إما ova أو ovo وافتراضياً 'default='ovr  وهي تمثل شكل تابع القرار الذي سيتم إرجاعه one-vs-rest أو one-vs-one.
ال attributes:
intercept_ : التقاطع مع المحور الاحداثي أي الثوابت في معادلة الفرضية.
coef_: أوزان التدريب.
التوابع:
(data,labels)fit: للقيام بعملية التدريب.
(y-true,y_pred)score: لتقييم دقة النموذج.
(data)predict: للتوقع.
مثال على بيانات breast cancer وهي بيانات لأمراض سرطان الثدي.
from sklearn.metrics import confusion_matrix import seaborn import matplotlib from sklearn.datasets import load_breast_cancer from sklearn.model_selection import train_test_split from sklearn.svm import SVC # تحميل الداتا data = load_breast_cancer().data labels = load_breast_cancer().target # تقسيم البيانات X_train, X_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=2021, shuffle =True) # SVC تطبيق ال SVCM = SVC(kernel= 'rbf', max_iter=100, C=1.0, gamma='auto') SVCM.fit(X_train, y_train) # عرض الدقة print('Train Score is : ' , SVCM.score(X_train, y_train)) print('Test Score is : ' , SVCM.score(X_test, y_test)) # 0.8859649122807017 # لعرض القيم المتوقعة y_pred = SVCM.predict(X_test) # حساب مصفوفة التشتت c = confusion_matrix(y_test, y_pred) print('Confusion Matrix is : \n', c) # الرسم seaborn.heatmap(c, center = True) matplotlib.pyplot.show()  

classmethod@ تجعل التابع تابع صنف أي"class method" وبالتالي تمكننا من الوصول إلى الصنف الذي تم فيه تعريف التابع.
التابع الذي يتم تعريفه على أنه تابع صف، يستقبل كمعامل أول الصف الخاص به ويعبر عن ذلك ب cls، أي بشكل مشابه لما كنا نفعله في التوابع العادية حينما كنا نمرر للتابع العادي نسخة instance أي (self).
إذن هي توابع مرتبطة بالصف وليس بال object.
التوابع المعرفة بهذه الطريقة يكون لديها سماحية "access to the state of the class" أي النفاذ إلى حالة الصف (نحن مررنا لها cls أي أنها تشير إلى الصف نفسه وليس نسخة منه) ويمكنها التعديل عليها أيضاً وهذا التعديل ينتقل إلى كل ال object.
 Static Method@: وهي مشابهة لتلك الموجودة في Java أو C‎+‎+‎.
الدالة  التي نعرفها على أنها ساكة يمكننا الوصول لها من الكلاس نفسه (أي يمكن الوصول لها مباشرة من خلال اسم الكلاس). أو من خلال ال object المأخوذة من الكلاس.
عندما يتم إستدعاء التوابع الساكنة من كائن من هذا الكلاس, فإنه لا تتم معاملته  بشكل خاص بالنسبة للكائن بل سيبقى كأنك تستدعيها بشكل مباشر من الكلاس. وهذا هو السبب في كونها لاتقبل الوسيط self.
التوابع من هذا النوع لاتملك السماحية "access to the state of the class" أي لايمكنها التعديل على حالة الصف. أي أنها لاتعرف شيئ عن حالة الصف class state ولاتستطيع تعديلها أما classmethod يمكنها ذلك.
بشكل عام تستخدم class method كنوع من ال factory method (دوال تعيد object (بشكل مشابه لل constructor ) من أجل استخدام معين أنت تريده) أما ال static فتستخدم كأداة للقيام بعمليات معينة.
إذا لم يكن لديك معرفة عن factory method يمكنك أن تجدها في هذا المقال:  https://wiki.hsoub.com/Design_Patterns/factory_method
from datetime import date class Person: def __init__(self, name, age): self.name = name self.age = age # دالة ساكنة لاختبار فيما إذا كان مسناً أم لا @staticmethod def old(age): print("old") return age > 55 #person كلاس ميثود لإنشاء كائن من الصف @classmethod def create(cls, name, year): return cls(name, date.today().year - year) print (Person.old(22)) # True obj=Person.create('km',24) print(obj) # <__main__.Person object at 0x000001C7DC405708> obj.age # 1997  

يمكنك ذلك بعدة طرق أسهلها استخدام الدالة join كالتالي:
def convert(lst): return (" ".join(lst)) # اختبار التابع l = ['Hsoub', 'Mostaql'] print(convert(l)) # Output: Hsoub Mostaql حيث " " هي التي ستفصل بين الكلمات ويمكنك تغييرها. 
#تعديل: طريقة أخرى إذا أحببت بدون توابع جاهزة:
# تابع التحويل def convert(lst): string=lst[0] # نضع أول كلمة من القائمة في السلسة for word in lst[1:]: # نضيف باقي الكلمات إلى السلسلة string +=' '+ word return string # اختبار التابع l = ['Hsoub', 'Mostaql'] print(convert(l))  

الحل هو أن داتا التدريب من النمط سترنغ ويجب أن تحولها للصيغة العددية :
['-214' '-153' '-58' ..., '36' '191' '-37'] قم بتحويلها إلى النمط العددي، يمكنك استخدام الطريقة التالية:
import numpy as np np.array(['1','2','3']).astype(np.float) هذا الخطأ شائع، لأنه غالباً مايتم تخزين الأعداد على شكل String من أجل فعالية التخزين والحجم.

توفر Sklearn القيام بالتوقع الخطي مع التنعيم عن طريق استخدام  الكلاس Lasso.
يتم استخدامها عبر الموديول linear_model.Lasso كالتالي:
sklearn.linear_model.Lasso(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
positive:عندما يأخذ True تكون المعلاملات كلها موجبه
أهم ال 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 Lasso # تحميل الداتا 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) # تطبيق التابع LassoRegression =Lasso(alpha=0.5,random_state=20,solver='auto') LassoRegression.fit(X_train, y_train) #حساب الكفاءه على التدريب والاختبار print('Train Score is : ' , LassoRegression.score(X_train, y_train)) print('Test Score is : ' , LassoRegression.score(X_test, y_test)) #print('Coef is : ' , LassoRegression.coef_) print(LassoRegression.predict(X_test))  

SVR هو جزء من موديل support vector machine ويستخدم في مهام التوقع 
يمكنك استخدامها عبر الموديول sklearn.svm
مثل أي نموذج في التعلم الآلي يوجد لديه العديد من المعاملات التي تلعب دوراً أساسيا في عملية تعلم الموديل عبر داتا التدريب لنقوم بالمرور على أهم المعاملات التي يأخذها هذا النموذج.
#استدعاء المكتبة:
from sklearn.svm import SVR في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
#الشكل العام للموديل:
SVRModel = SVR(kernel=’rbf’, degree=3, tol=0.001,C=1.0,max_iter=-1,epsilon=0.1,cache_size=200وgamma='auto') أهم البارمتر المستخدمة:
البارمتر الأول kernel نوع النواة أو المعادلة المستخدمة تكافئ فكرة تابع التنشيط في الشبكات العصبونية
يوجد عدة أنواع ‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’ ننصح دوما باستخدام rbf لأنها الأفضل.
البارمتر الثاني degree وهو في حال أردنا جعل ال regressor غير خطي أي Polynomial نضبطه بالدرجة التي نريدها(default=3).
بحال استخدام الkernel=poly فيجب تحديد درجة كثير الحدود.
البارمتر الثالث tol عدد يمثل نقطة إيقاف التعلم  بحال تجاوز هذه القيمه فيتوقف svr.
البارمتر الرابع C معامل التنعيم أفضل القيم للتجريب 0.1,0.001,10,1
البارمتر الخامس  max_iter العدد الأقصى للتكرارت إذا وضعت -1 فأنه يأخذ الحد الأعلى ويفضل ذلك
epsilon: ضمن هذا المقدار لن يتم تطبيق أي penalty على تابع التكلفة. أي هي هامش للسماحية بدون تطبيق penalty. افتراضياً default=0.1.
cache_size: تحديد حجم ال kernel cache وافتراضياً 200 MB.
gamma: معمل النواة وهي إما {‘scale’, ‘auto’}أو float وتكون افتراضياً 'default=’scale.
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جداً فقط بعد أن تقوم بتقسيم الداتا إلى X_train, y_train,X_test,. y_test  تسطيع كتابة الأتي لعملية التدريب:
SVRM = SVR(kernel=’rbf’, degree=3, tol=0.001,C=1.0,max_iter=-1) SVRM.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب  
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي.
#حساب القيم المتوقعة:
y_pred = SVRM.predict(X_test) حيث قمنا بالتنبؤ بقيم التصنيف لداتا الاختبار
نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل
#حساب الكفاءه على التدريب والاختبار:
print('Train Score is : ' , SVRM.score(X_train, y_train)) print('Test Score is : ' , SVRM.score(X_test, y_test)) مثال:
from sklearn.datasets import load_boston from sklearn.model_selection import train_test_split from sklearn.svm import SVR # تحميل الداتا 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=44) # تطبيق التابع SVRM = SVR(C = 1.0 ,epsilon=0.1,kernel = 'rbf') SVRM.fit(X_train, y_train) # عرض النتائج print('SVRM Train Score is : ' , SVRM.score(X_train, y_train)) print('SVRM Test Score is : ' , SVRM.score(X_test, y_test))