Ali Haidar Ahmad

هذا خطأ عام، وقد يظهر لك عند استخدامك لأي خوارزمية أخرى أوشبكة عصبية ويحدث عند محاولتك قياس كفاءة نموذج باستخدام معيار f1-score  مع مسائل التصنيف المتعدد.
الخطأ في السطر التالي:
f1_score(y_test,t.predict(x_test)) إن مجموعة البيانات الشهيرة MINST تشكل مسألة تصنيف متعدد، لذا لايمكن استخدام معيار f1-score معها كما في الشكل الذي أرفقته.
الشكل العام للتابع:
f1_score(y_true, y_pred,average='binary') أي افتراضياً يكون ال average تم تعيينه على binary (أي يقيس الكفاءة لمسألة تصنيف ثنائي)، لكن مسألتك هي مسألة تصنيف متعدد وبالتالي لايصلح استخدامه هنا.
لحل المشكلة نستخدم أحد المعاملات ['None, 'micro', 'macro', 'weighted].
طبعاً يمكنك استخدام أي منها ولا يعطونك نتائج متفاوتة (غالباً تكون الفروقات بقيم مهملة)  وبشكل عام فإن  [None, 'micro', 'macro', 'weighted'] يمكنك استخدامها في حالة التصنيف المتعدد والثنائي.
الحل:
import numpy as np from tensorflow.keras.datasets import mnist from sklearn.linear_model import LogisticRegression from sklearn.pipeline import Pipeline from tensorflow.keras.utils import to_categorical from sklearn.metrics import f1_score,precision_score,recall_score,accuracy_score,log_loss (x_train, y_train),(x_test, y_test) = mnist.load_data() x_train.shape image_size = x_train.shape[1] input_size = image_size * image_size x_train = np.reshape(x_train, [-1, input_size])/ 255 x_test = np.reshape(x_test, [-1, input_size]) / 255 t =LogisticRegression() t.fit(x_train, y_train) f1_score(y_test,t.predict(x_test),average='micro') #0.9258 # أو #f1_score(y_test,t.predict(x_test),average='macro') #0.9247 # أو #f1_score(y_test,t.predict(x_test),average=None) weighted: استخدمها إذا أردت أن تكون قيمة f1 معتمدة على عدد عينات كل صنف أيضاً .
macro: تأخذ متوسطات ال f1 لكل كلاس.
micro: نفس مبدأ accuracy.
None: تعطيك ال f1 لكل فئة .

نستخدم الدالة open التي تعيد لنا كائن من النوع  file أي file object ثم في حالة القراءة لانمرر أي شيء للدالة open أما إذا أردنا التعديل (الإضافة في نهاية الملف) نمرر لها "a" وإذا أردنا الكتابة فوق الملف الموجود نمرر "w" ثم نستدعي الدالة write ونمرر لها مانريد أن يتم إضافته كالتالي:
# الإضافة على الملف file = open("D:/r.txt", "a") file.write(" add line ") file.close() # نعيد فتح الملف لنتأكد من الإضافة file = open("D:/r.txt", "r") print(file.read()) # w نجرب الآن ال file = open("D:/r.txt", "w") file.write("say hi") file.close() # نعيد فتح الملف لنتأكد من الإضافة file = open("D:/r.txt", "r") print(file.read()) ولاننسى إغلاق الملف بعد الانتهاء باستخدام الدالة close.
 

هذا الخطأ قد يظهر لك في أي خوارزمية أخرى قد تستخدمها.
المشكلة في أنك تقوم بترميز قيم ال labels باستخدام ال One-Hot Encoding (التابع to_categorical) فتحدث المشكلة في التابع fit أي عندما يبدأ التدريب.
صحيح أننا نستخدم عادةً التابع to_categorical لترميز ال labels في مسائل التصنيف المتعدد لكن في الخوارزميات المعرفة في مكتبة Sklearn لانستخدمه لأن الخوارزميات فيها لاتتعامل مع هذا الشكل من البيانات.
إن شكل التابع fit في مكتبة Sklearn كالتالي:
fit(X, Y) بحيث أن y هي مصفوفة من الشكل (,n_sampels) أي مصفوفة أحادية الأبعاد (1D-array).
وعند استخدامك لترميز to_categorical سوف يتحول شكل البيانات إلى (n_sampels,voc) بحيث voc هي عدد ال labels الموجودة.
وهذا الشكل لايتطابق مع شكل البيانات الذي تتعامل معه fit.
لذا يجب أن لانقوم باستخدام هذا الترميز وأن نجعل ال labels ضمن مصفوفة 1D: 
حل المشكلة:
import numpy as np from sklearn.naive_bayes import MultinomialNB from tensorflow.keras.utils import to_categorical from tensorflow.keras.datasets import mnist from sklearn.metrics import accuracy_score (X, Y),(Xtest, Ytest) = mnist.load_data() Y=Y.reshape(-1,) Ytest=Ytest.reshape(-1,) X = np.reshape(X, [-1, X.shape[1]*X.shape[1]]) Xtest = np.reshape(Xtest, [-1, input_size]) M =MultinomialNB() M.fit(X, Y) accuracy_score(Ytest,M.predict(Xtest)) # 0.83  

خوارزمية تعتمد على التصويت بين عدة خوارزميات، بحيث تحدد لها عدة خوارزميات توقع وكل خوارزمية ستقوم بعمل fitting على البيانات ثم إجراء مايسمى  "Voting" لانتخاب النتيجة الأفضل اعتماداً على الخوارزميات المستخدمة. (تشبه VotingClassifier لكن هنا لمهمة توقع).
يمكنك استخادمها عبر الموديول:
sklearn.ensemble.VotingRegressor(estimators, weights=None, n_jobs=None) الوسيط الأول نحدد فيه خوارزميات التوقع التي نريد استخدامها وتقبل list من ال tuble بحيث كل tuble عبارة عن قيمة أولى str تمثل اسم اختياري للخوارزمية وقيمة ثانية تمثل الكلاس (الخوارزمية) "موضحة في المثال".
الوسيط weights: تحديد ماهي الأوزان في التصويت لكل خوارزمية. ويأخذ مصفوفة من الأوزان (,n_classifier,) قد تكون القيم int أو float لامشكلة.
n_jobs: عدد المهام التي يتم تنفيذها على التوازي. نضع -1 لأقصى قدر ممكن(زيادة سرعة التنفيذ).
ال attributes:
estimators_ : معلومات عن الخوارزميات المستخدمة.
التوابع:
fit(data)   للقيام بعملية التدريب.
predict(data)  للقيام بعملية توقع قيمة عينة.
score(data)     لإيجاد كفاءة النموذج.
مثال: قمنا هنا باستخدام خوارزميتي توقع RandomForest+LinearRegression
import numpy as np from sklearn.ensemble import RandomForestRegressor from sklearn.linear_model import LinearRegression from sklearn.ensemble import VotingRegressor reg1 = LinearRegression() reg2 = RandomForestRegressor(n_estimators=7, random_state=2021) # تشكيل بيانات بقيم عشوائية X = np.array([[3, 1], [32, 45], [53, 2], [5, 6]]) y = np.array([2, 6, 12, 20]) #VotingRegressor تعريف reg = VotingRegressor([('reg1', reg1), ('reg2', reg2)]) print(reg.fit(X, y).predict(X)) # [ 9.68531265 8.55106081 11.01620204 15.17599594] print(reg.score(X, y)) # 0.5118977425789101  

يمكنك ذلك باستخدام الموديول:
sklearn.datasets.make_classification(n_samples=100, n_features=20, n_classes=2, shuffle=True, random_state=None) الوسيط الأول يحدد عدد العينات التي تريدها. افتراضياً 100
الوسيط الثاني يحدد عدد الميزات features التي تريدها. افتراضياً 20
الوسيط الثالث يحدد عدد الفئئات (Classes) التي تريدها (عدد ال labels). افاراضياً 2
الوسيط الرابع لخلط البيانات بعد إنشائها.
الوسيط الأخير هو وسيط التحكم بنظام العشوائية في التقسيم.
مثال:
from sklearn.datasets import make_classification X, y = make_classification(n_samples=1000, n_features=4, random_state=0, shuffle=False) print(X.shape) #(1000, 4) print(y.shape,end='\n\n') # (1000,) print(X) ''' [[-1.66853167 -1.29901346 0.2746472 -0.60362044] [-2.9728827 -1.08878294 0.70885958 0.42281857] [-0.59614125 -1.37007001 -3.11685659 0.64445203] ... [ 0.91711204 1.10596645 0.86766522 -2.25625012] [ 0.10027664 1.45875846 -0.44360274 -0.67002328] [ 1.0415229 -0.01987143 0.15216419 -1.9405334 ]] '''  

يمكنك استخدامها عبر الموديول:
sklearn.ensemble.AdaBoostClassifier(base_estimator=None, n_estimators=50, learning_rate=1.0, algorithm='SAMME.R', random_state=None) base_estimator: ال estimator الأساسي الذي تبنى منه باقي المجموعة المعززة (boosted ensemble). افتراضياً None. ويفضل تركه none ليعطي أفضل النتائج في حال لم تكن لديك خبرة.
n_estimators : عدد الخوارزميات أو ال estimator  المستخدمة.  default=50.
learning_rate: مقدار معامل التعلم (حجم الخطوة)، ويأخذ فيمة من النمط float.
algorithm: لتحديد الخوارزمية التي تريد تنفيذها لكي تحصل على التقارب converge وهناك خوارزميتين فقط {‘SAMME’, ‘SAMME.R’}. و SAMME.R تعتبر أسرع في الوصول للتقارب وتعطي نتيجة أفضل حقيقة (عن تجربة). افتراضياً SAMME.R.
random_state: يتحكم بعملية التقسيم افتراضياً يكون None.
التوابع:
fit(data): للقيام بعملية التدريب.
predict(data): لتوقع القيم.
score(data):  لتقييم كفاءة النموذج.
()get_params :لايجاد مقدار الدقة
predict_proba(data) : لعمل التوقع أيضاً لكن هنا سيخرج الفيمة الاحتمالية(أي لن يتم القصر على  عتبة)
ال attributtes:
classes_: لعرض ال labels التي وجدها.
n_classes_: عدد ال labels.
estimator_weights_: أوزان كل estimator تم تطبيقه.
estimators_: عرض معلومات عن ال estimator التي تم تشكيلها.
base_estimator_:عرض معلومات ال estimator الأساسية
feature_importances_: عرض أهم الفيتشرز المؤثرة في التصنيف.
مثال:
from sklearn.model_selection import train_test_split from sklearn.ensemble import AdaBoostClassifier 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.2, random_state=44, shuffle =True) # AdaBoostClassifier تطبيق clf = AdaBoostClassifier(n_estimators=150, random_state=444) clf.fit(X_train, y_train) # النتائج print('AdaBoostClassifier Train Score is : ' , clf.score(X_train, y_train)) # AdaBoostClassifier Train Score is : 1.0 print('AdaBoostClassifier Test Score is : ' , clf.score(X_test, y_test)) # AdaBoostClassifier Test Score is : 0.9824561403508771 # عرض مصفوفة التشتت c = confusion_matrix(y_test, clf.predict(X_test)) print('Confusion Matrix is : \n', c) #لرسم المصفوفة sns.heatmap(c, center = True) plt.show()  

غالباً ماتكون البيانات المخزنة في ملفات csv من النوع object لذا عند تطبيقك ل TfidfVectorizer سيعطيك هذا الخطأ عند استدعاء التابع fit_transform.
فهو يتعامل مع unicode string وليس Object، لذا لحل المشكلة نقوم بتحويل نوع البيانات dtype  في ملف ال DataFrame إلى النمط unicode وذلك يتم كالتالي:
enc = tfidf.fit_transform(data['tweets'].values.astype('U')) # أو enc = tfidf.fit_transform(data['tweets'].values.astype(str))  

إنها أداة رائعة توفرها مكتبة scikit-Learn في Python. يتم استخدامها لتحويل نص معين إلى متجه على أساس تكرار (عدد) كل كلمة تحدث في النص بأكمله.
للاستيراد الكلاس:
sklearn.feature_extraction.text.CountVectorizer fit_transform(data) التابع هذا يقوم بعمل ال fitting (إنشاء الترميز) ثم يقوم بعملية ال transform (أي التحويل إلى الترميز الجديد ويكون على أساس الترميز الذي تم من المرحلة fitting)
نستخدم التابع toarray لعرض الداتا بعد الترميز كما في المثال الشامل التالي:
from sklearn.feature_extraction.text import CountVectorizer data = [ 'Argentena vs Urguaey.', 'Argentena vs Chile.', 'Argentena vs Brazil.', 'Brazil vs Chile', ] # نقوم بتشكيل غرض من هذا الكلاس vec = CountVectorizer() # نقوم بعملية التحويل X = vec.fit_transform(data) # التابع التالي يرد الكلمات التي وجدها print(vec.get_feature_names()) # ['argentena', 'brazil', 'chile', 'urguaey', 'vs'] # لطباعة النص بع الترميز print(X.toarray()) ''' output: [[1 0 0 1 1] [1 0 1 0 1] [1 1 0 0 1] [0 1 1 0 1]] '''  

هي عبارة عن واجهة مجردة abstract interface بين العتاد hardware  وبين أقل مستوى برمجي  lowest level software الذي يشمل كل المعلومات الضرورية لكتابة برنامج بلغة الآلة machine language program الذي سيعمل بشكل صحيح  متضمنة (نقصد ال ISA ) التعليمات Instructions والمسجلات register والوصول إلى الذاكرة memory access ووحدات الخل والخرج..
وبشكل أكثر وضوحاً يمكن أن نقول أن مجموعة التعليمات أو الأوامر ISA هي قائمة بجميع الأوامر المتاحة بمختلف أشكالها التي يمكن لمعالج ما أن يقوم بتنفيذها. تتضمن هذه التعليمات:
تعليمات حسابية:مثل الجمع والطرح، تعليمات منطقية: كتعليمات الضرب المنطقي AND والجمع المنطقي OR والنفي المنطقي NOT وو..
وهي عبارة هن نموذج مجرد Abstract model، تصبح ال ISA ملموسة (لها وجود فعلي) فقط عندما نضع لها تحقيقاً implementation بحيث أنه من أجل ISA واحدة يكون لدينا أكثر من تحقيق، حيث أن كل تحقيق يختلف في أدائه عن الآخر بحسب عدة عوامل.
خدمات هذه ال ISA هي الواجهة بين البرمجيات software والعتاد hardware بحيث أن كل برنامج قد كتب من أجل ISA واحدة يمكنه أن يعمل على التحقيقات  المختلفة لهذه ال ISA دون أي مشكلة لكن مع اختلاف في الأداء.

هي طريقة لعمل تقسيم للبيانات الغير معنونة unlabeled data ويستخدم في التعلم بلا إشراف..
يقوم AffinityPropagation بإنشاء المجموعات عن طريق إرسال الرسائل بين أزواج العينات حتى تصل إلى مرحلة التقارب يتم بعد ذلك وصف الداتا بعدد صغير من النماذج والتي تم اعتبارها الأكثر تمثيلاً للعينات الأخرى (مثلا لدينا 5 تفاحات حمراء  نعتبر أن تفاحة حمراء واحدة ممثلة عن ال5 تفاحات  ولكن يجب أن تكون في هذه التفاحة الصفات الأقرب للمثالية) تعتبر الرسائل المرسلة بين الأزواج مدى تماثل عينة واحدة لتكون ممثلاً للعينات الأخرى، يتم تحديث النتائج من الأزواج الأخرى بشكل متكرر حتى نصل إلى مرحلة التقارب واعتماد الأزواج النهائية.
يتم استخدامها عبر الموديول sklearn.cluster.
استدعاء المكتبات:
from sklearn.cluster import AffinityPropagation في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل.
#الشكل العام للموديل:
AP = AffinityPropagation(damping=0.5, max_iter=200,copy=True,preference=None,affinity='euclidean',verbose=0) الوسيط  الأول damping يأخذ قيمة بين 0.5 و 1 يمثل مدى الحفاظ على القيمة الحالية بالنسبة للقيم الواردة من الرسائل وذلك لتجنب التفاوت في القيم العددية عند تحديث هذه القيم.
الوسيط الثاني  max_iter أكبر عدد للتكرارات.
الوسيط الثالث copy قيمة بوليانية إذا كان false فإنه سوف يتم العمل على نسخة من البيانات الأصلية أي تعديل على البيانات سوف يكون دائم أما إذا كان True تؤخذ نسخة من البيانات.
الوسيط الرابع  preference مصفوفة تمثل وزن العينة حيث يتم اختيار  العينات ذات الوزن الأكبر كنماذج أو ممثل عن العينات المماثلة الأخرى وإذا لم يتم تمرير شيئ يتم اعتبار المتوسط هو الوزن لكل قيمة.
الوسيط الخامس affinity قيمة التقارب يتم استخدام المسافة الأقليدية لحساب التقارب ’euclidean’ أو المسافة المحسوبة سابقا  ‘precomputed’
الوسيط السادس verbose  قيمة بوليانية إذا كان false  وكان هناك خرج فلا يظهر أما True يظهر الخرج.
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, X_test  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
AP = AffinityPropagation(damping=0.5, max_iter=200,copy=True,preference=None,affinity='euclidean',verbose=0) AP.fit(X_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي:
نستطيع فيها حساب قيم التقسيم على التدريب والاختبار عن طريق التابع predict  ويكون وفق الشكل:
طباعة الخرج على الاختبار والتدريب..
y_pred_train = AP.predict(X_train) y_pred_test = AP.predict(X_test) print('AP Train data are : ' ,y_pred_train) print('AP Test data are : ' ,y_pred_test) لنأخذ مثال يوضح الموديل 
استدعاء المكتبات:
from sklearn.cluster import AffinityPropagation import numpy as np تعين داتا دخل مزيفة X = np.array([[0, 4], [3, 5], [1, 1],[2, 3], [5, 5], [4, 2]]) بناء الموديل:
AP = AffinityPropagation(damping=0.5, max_iter=200) AP.fit(X) طباعة تصنيف العينة:
AP.predict([[0, 0], [4, 4]]) النتيجة:
array([1, 0], dtype=int64)  

هي طريقة لعمل تقسيم للبيانات الغير معنونة، unlabeled data ويستخدم في التعلم بلا إشراف يحل مشكلة K-Means في تشكل العناقيد في البيانات التي فيها كثافات متفاوتة حيث تعتمد على إنشاء دوائر حول كل عينة من البيانات ويتم بعدها تصنيف العينات على أنها عينات أساسية أو حدية أو ضوضاء.
حيث تعتبر العينة التي تحتوى على عدد  min_samples  أو أكثر من العينات بعينة أساسية وتعتبر العينة حدية إذا كان min_samples أقل في حين أن العينات التي لا تحوي دوائرها عينات تعتبر ضوضاء.
يتم استخدامه عبر الموديول sklearn.cluster.
استدعاء المكتبات:
 from sklearn.cluster import DBSCAN في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل.
الشكل العام للموديل:
DB=DBSCAN(eps=0.5, min_samples=5, algorithm='auto', p=None, n_jobs=None) الوسيط  الأول eps هو اختصار ل epsilon  أكبر مسافة بين عينتين من البيانات.
الوسيط الثاني min_samples أقل عدد من العينات لتحديد فيما إذا كانت العينات أساسية أو حدية أو ضوضاء.
الوسيط الثالث algorithm نوع الخوارزمية الذي يستخدمها NearestNeighbors لحساب أقرب جار وحساب المسافات بين العينات  وهي ‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’ ولكن ينصح باعتماد auto لكي يتم اختيار أفضل خوارزمية. 
الوسيط الرابع  p  الطاقة لمقياس مينكوفسكي حيث عندما تساوي 1 يكون حساب المسافة عن طريق قانون منهاتن للمسافات وعندما تساوي 2 يتم الحساب عن طريق المسافة الإقليدية وفي الحالة الافتراضية يتم استخدام مينكوفسكي.
الوسيط الخامس  n_jobs عدد المعالجات التي تعمل بالتوازي وبتالي كلما زاد العدد زاد التسريع ,يوضع -1 للدلاله على عمل كامل المعالجات
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train,X_test  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
DB=DBSCAN(eps=0.5, min_samples=5,algorithm='auto', p=None, n_jobs=None) DB.fit(X_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب  .
يوجد دالة أخرى تستخدم لغرض التنبؤ كالآتي:
نستطيع فيها حساب قيم التقسيم على التدريب والاختبار عن طريق التابع fit_predict  ويكون وفق الشكل:
y_pred_train = DB.fit_predict(X_train) y_pred_test = DB.fit_predict(X_test) print('DB Train data are : ' ,y_pred_train) print('DB Test data are : ' ,y_pred_test) لنأخذ مثال يوضح الموديل:
# استدعاء المكتبات from sklearn.cluster import DBSCAN  import numpy as np # تعين داتا دخل مزيفة X = np.array([[50, 3], [4, 5], [25, 30],               [4, 1], [2, 7], [2, 8]]) # بناء الموديل DB= DBSCAN(eps=3, min_samples=2) # طباعة تصنيف العينه DB.fit_predict([[1,2]])  

هذا الخطأ قد يظهر لك في أي خوارزمية أخرى في مكتبة Sklearn  وليس فقط MultinomialNB، أي ممكن أن يظهر خلال استخدامك خوارزميات أخرى مثل LogisticRegression  أو RandomForest.
السبب هو أن التابع fit يقبل مصفوفة 2D وأنت تحاول تمرير مصفوفة 3D فيعطيك هذا الخطأ.
البيانات التي تتعامل معها هي MINST Dataset وهي بيانات تمثل صور وحجم هذه الداتا  28*28*60000 أي 60 ألف عينة وكل عينة هي صورة بأبعاد 28*28.
لذا لحل مشكلتك يجب أن تقوم بعمل reshape للداتاسيت حيث نقوم بجعلها 2D كما يلي:
import numpy as np from tensorflow.keras.datasets import mnist from sklearn.naive_bayes import MultinomialNB from sklearn.pipeline import Pipeline from tensorflow.keras.utils import to_categorical from sklearn.metrics import f1_score,precision_score,recall_score,accuracy_score,log_loss (x_train, y_train),(x_test, y_test) = mnist.load_data() x_train.shape image_size = x_train.shape[1] input_size = image_size * image_size input_size # نقوم بعمل إعادة تعيين للأبعاد x_train = np.reshape(x_train, [-1, input_size]) x_train = x_train.astype('float32') / 255 x_test = np.reshape(x_test, [-1, input_size]) x_test = x_test.astype('float32') / 255 # تعريف pipline t = Pipeline([('clf',MultinomialNB())]) t = text_clf.fit(x_train, y_train) accuracy_score(y_test,t.predict(x_test)) # 0.8357 ملاحظة: قمت بتقسيم كل قيمة من الداتا على 255 (أي على أكبر قيمة ممكنة للبكسل) وبالتالي تكون كل قيم البكسلات بين 0 و 1 (وهذا أمر ضروري ونسميه توحيد البيانات (Standardaization).

TfidfVectorizer هو مقياس إحصائي يُقال إنه أصلح المشكلات مع CountVectorizer بطريقة ما.
يتكون من جزأين، TF (تردد المدى) مضروبًا في IDF (تردد المستند العكسي).
يقيس TF (تكرار المصطلح) عدد مرات ظهور مصطلح أو كلمة في مستند معين.
يقيس IDF (تكرار  المستند العكسي) أهمية المصطلح عبر مجموعة.
درجة TF-IDF هي نتاج هذين المصطلحين. وبالتالي ، درجة TF-IDF  = TF * IDF
يمكن تطبيق هذا الترميز بسهولة في مكتبة Sklearn، حيث يتم استخدام هذا الكلاس كالتالي:
fit_transform(data) نستخدمه للقيام بعملية ال fitting (الترميز) و ال transform  (تطبيق الترميز -تحويل البيانات من شكلها الحالي إلى الشكل الجديد اعتماداً على الترميز الذي تم إنشاؤه في مرحلة ال fitting-) على البيانات.
إذا أردت استعراض النص بعد الترميز استخدم التابع toarray كما فعلت في المثال:
# استيراد الكلاس from sklearn.feature_extraction.text import TfidfVectorizer # إنشاء مجموعة بيانات data = [ 'This is a Hsoub website.', 'Where is the company headquarters?', 'Is this the first example?', 'Is this the first document?', ] # أخذ غرض من الكلاس vectorizer = TfidfVectorizer() #والتحويل fitting تطبيق ال X = vectorizer.fit_transform(data) # عرض أسماء الميزات print(vectorizer.get_feature_names()) # طباعة النصوص المرمزة بهذا الترميز print(X.toarray()) ##################################### Output ############################################# ['company', 'document', 'example', 'first', 'headquarters', 'hsoub', 'is', 'the', 'this', 'website', 'where'] [[0. 0. 0. 0. 0. 0.61087812 0.31878155 0. 0.38991559 0.61087812 0. ] [0.52130524 0. 0. 0. 0.52130524 0. 0.2720387 0.33274238 0. 0. 0.52130524] [0. 0. 0.60759891 0.47903796 0. 0. 0.31707032 0.38782252 0.38782252 0. 0. ] [0. 0.60759891 0. 0.47903796 0. 0. 0.31707032 0.38782252 0.38782252 0. 0. ]]  

أولاً يجب أن تحذر فهذا المعيار يستخدم مع مهام التصنيف Classification.
وهو يجمع بين المعيارين precision و recall ويحقق توازن بين قيمتهما.

إن f1score هي قيمة تساوي:
f1score = 2 * (precision * recall) / (precision + recall) قيمة f1 تكون بين ال 0 و 1 وكلما زادت القيمة كلما كان أداء النموذج أدق.
يتم استخدامها عبر الموديول:
sklearn.metrics.f1_score ويمكنك تطبيقها بالشكل التالي:
from sklearn.metrics import f1_score # f1_score(y_true, y_pred,average='micro') F1Score = f1_score(y_test, y_pred, average='micro') print('F1 Score is : ', F1Score)  

هذه الخوارزمية تستخدم في التصنيف الثنائي ويعتمد على نظرية بايز ويفضل استخدامه عندما يكون هنالك بيانات الميزات فيها  منفصلة
يتم استخدامه عبر الموديول sklearn.naive_bayes.
استدعاء المكتبات:
from sklearn.naive_bayes import CategoricalNB في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
الشكل العام للموديل:
CaNB = CategoricalNB(alpha=1.0, fit_prior=True, class_prior=None,min_categories=None) الوسيط الأول alpha هي الهدف من هذا الوسيط هو عند حساب الاحتمالات احد هذه الاحتمالات من الممكن أن يكون صفر وتجنبا لذلك يتم وضع قيمة تسمى قيمة تنعيم  أو تجانس لابلاس لكي لا يكون هناك قيم صفرية..
الوسيط الثاني  fit_prior تأخذ True فقط لكي تعلم الصفوف الاحتمالات السابقة false عكس ذلك .
الوسيط الثالث class_prior قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف. 
الوسيط الرابع  min_categorie يأخذ ثلاث قيم ..قيمه صحيحه تمثل الحد الأدنى لعدد الفئات لكل ميزة.
...مصفوفة من الأعداد الصحيحه تمثل كل قيمة فيها الحد الأدني لعدد الفئات لكل ميزه مقابلة
..عندما تأخذ None يحدد عدد الفئات تلقائيا من بيانات التدريب.
طبعاً قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جداً فقط بعد أن تقوم بتقسيم الداتا إلى X_train, X_test,  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
CaNB = CategoricalNB(alpha=1.0, fit_prior=True, class_prior=None,min_categories=None) CaNB.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.  
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي.
حساب القيم المتوقعة
y_pred = CaNB.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل.
حساب الكفاءة على الاختبار والتدريب:
print('CaNB Train Score is : ' , CaNB.score(X_train, y_train)) print('CaNB Test Score is : ' , CaNB.score(X_test, y_test)) لنأخذ مثال يوضح المصنف.
قمنا باستدعاء المكتبات وبناء عينة مزيفة وكان التصنيف lمتعدد أما 1 أو 2 أو 0 بعد ذلك استخدمنا CategoricalNB
ثم قمنا بتجريب الموديل على عينة معطاة.
#استدعاء المكتبات import numpy as np from sklearn.naive_bayes import CategoricalNB #تعين داتا دخل مزيفة X = np.random.random((6, 100)) y = np.array([1, 1, 0, 2, 0, 2]) #بناء الموديل CaNB =CategoricalNB () CaNB.fit(X, y) #تصنيف عينة print(CaNB.predict(X[4:5])) #النتيجة [0]  

هذه الخوارزمية تستخدم في التصنيف الثنائي ويعتمد على نظرية بايز ويفضل استخدامه عندما يكون هنالك بيانات غير متوازنة أي يكون أحد الفئات له أمثلة أكثر من الفئات الأخرى كمثال أن يكون مثلا لدينا 10000 مثال يكون الخرج فيها 1 و100 مثال يكون فيها الخرج 0 و50 مثال يكون الخرج فيها 2 لذلك MultinomialNB لن يكون فعالا مثل ComplementNB في هذا الوضع.
يتم استخدامه عبر الموديول sklearn.naive_bayes.
استدعاء المكتبات:
from sklearn.naive_bayes import ComplementNB في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
الشكل العام للموديل:
CNB = ComplementNB(alpha=1.0, fit_prior=True, class_prior=None,norm=True) الوسيط الأول alpha هي الهدف من هذا الوسيط هو عند حساب الاحتمالات أحد هذه الاحتمالات من الممكن أن يكون صفر وتجنباً لذلك يتم وضع قيمة تسمى قيمة تنعيم  أو تجانس لابلاس لكي لا يكون هناك قيم صفرية.
الوسيط الثاني fit_prior تأخذ True فقط لكي تعلم الصفوف الاحتمالات السابقة false عكس ذلك.
الوسيط الثالث class_prior قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف.
الوسيط الرابع  norm يكون True إذا أردنا بتطبيق التسوية على الأوزان وfalse عكس ذلك.
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جداً فقط بعد أن تقوم بتقسيم الداتا إلى X_train, X_test,  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
CNB = ComplementNB(alpha=1.0, fit_prior=True, class_prior=None,norm=True) CNB.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.
يوجد دالة أخرى تستخدم لغرض التنبؤ كالاتي
حساب القيم المتوقعة:
y_pred = CNB.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل
حساب الكفاءة على الاختبار والتدريب:
print('CNB Train Score is : ' , CNB.score(X_train, y_train)) print('CNB Test Score is : ' , CNB.score(X_test, y_test)) لنأخذ مثال يوضح المصنف.
قمنا باستدعاء المكتبات وبناء عينة مزيفة وكان التصنيف lامتعدد أما 1 أو 2 أو 3 بعد ذلك استخدمنا ComplementNB
ثم قمنا بتجريب الموديل على عينة معطاة.
# استدعاء المكتبات import numpy as np from sklearn.naive_bayes import ComplementNB # تعين داتا دخل مزيفة X = np.random.random((6, 100)) y = np.array([1, 1, 3, 3, 2, 2]) # بناء الموديل CNB =ComplementNB () CNB.fit(X, y) #تصنيف عينة print(CNB.predict(X[4:5])) # النتيجة [2]  

يمكننا القيام بذلك باستخدام الكلاس OneHotEncoder الموجود في الموديول preprocessing.
المثال التالي يوضح لك كل العملية:
حيث أن التابع fit_transform نمرر له الداتا وهو يقوم بعملية ال fitting (الترميز هنا) ثم transform (تطبيق الترميز على البيانات-التحويل-).
طبعاً يتم تمثيل كل كلمة بشعاع طوله بعدد المفردات الفريدة التي وجدها
import numpy as np from sklearn.preprocessing import OneHotEncoder # تعريف بيانات data = np.asarray([['first'], ['second'], ['third'],['second']]) print(data) ''' [['first'] ['second'] ['third'] ['second']] ''' # OneHotEncoder تعريف كائن من الكلاس enc = OneHotEncoder(sparse=False) #One-Hot-Encoding تحويل الداتا إلى ترميز OneHotEncoding = enc.fit_transform(data) print(OneHotEncoding) ''' [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.] [0. 1. 0.]] '''  

التوابع في مكتبة Sklearn تتعامل مع المصفوفات (numpy arrays) لذا يجب أن تقوم دوماً بتحويل بياناتك إلى numpy arrays قبل أن تدخلها في توابع وكلاسات مكتبة Sklearn.
للتحويل نستخدم التابع ()to_numpy كالتالي:
X=df['size'].to_numpy() Y=df['class'].to_numpy() # ثم قد يتطلب منك الأمر إعادة تعيين أبعادها X=X.reshape(-1,n)# يحيث أن الوسيط الثاني سوف يمثل عدد الميزات  

يمكن كتابة أكثر من كود يحقق المطلوب والفرق بينها يكون من ناحية درجة التعقيد (التعقيد الزماني تحديداً).
سوف اكتب لك حل جيد لذلك بدرجة تعقيد أعتقد أنها الأفضل (n)sqrt، لكن يفترض ان يكون لديك معرفة أساسيات "نظرية الأعداد":
في البداية نتأكد أن العدد ليس 0 أو 1 ويرجع بذلك false أي أنهما ليسا أوليان.
بعد ذلك نأخذ حلقة من 2 إلى جذر العدد ونبدأ بالتحقق من الأرقام إذا كان أحدها هو قاسم للعدد فإذا كان أحدها يقسم العدد بالتالي العدد غير أولي وبتالي يكون false وغير ذلك عند عدم وجود أي قاسم يرجع true فيكون هذا العدد أولي.
#include<iostream> using namespace std; bool prime(int g) { if(g<2) return 0; for(int i=2; i*i<=g; ++i) if(g%i==0)return 0; return 1; } int main(){ int a; cin>>a; if(prime(a)) cout<<"prime"; else cout<<"not prime"; return 0; }  

هذا الكلاس يستخدم في التصنيف الثنائي ويعتمد على نظرية بايز وأنصحك باستخدامه عندما يكون هنالك بيانات منفصله أي الميزات تكون مستقله لا يتعلق حدوث الميزة الأولى بالأخرى مثل عمر الشخص و درجته  في مادة الرياضيات على سبيل المثال.
الفرق بينه وبين MultinomialNB هو أنه مخصص للتصنيف الثنائي. ويتم استخدامه عبر الموديول sklearn.naive_bayes.
استدعاء المكتبات: from sklearn.naive_bayes import BernoulliNB في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل.
الشكل العام للموديل: BNB = BernoulliNB(alpha=1.0,binarize=0.0, fit_prior=True, class_prior=None) الوسيط الأول alpha هي الهدف من هذا الوسيط هو عند حساب الاحتمالات احد هذه الاحتمالات من الممكن أن يكون صفر وتجنبا لذلك يتم وضع قيمة تسمى قيمة تنعيم  أو تجانس لابلاس لكي لا يكون هناك قيم صفرية.
الوسيط الثاني binarize قيمة حقيقة وهي قيمة العتبه فمثلاً إذا كان الاحتمال أكبر من قيمة عتبه 0.5 فيأخذ واحد وإذا كان أقل من قيمة عتبه 0.5 فيأخذ 0.
الوسيط الثالث  fit_prior تأخذ True فقط لكي تعلم الصفوف الاحتمالات السابقه false عكس ذلك. 
الوسيط الرابع class_prior قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف.
 
طبعاً قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, X_test,  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
BNB = BernoulliNB(alpha=1.0, binarize=0.0,fit_prior=True, class_prior=None) BNB.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.
يوجد دالة أخرى تستخدم لغرض التنبؤ كالآتي، حساب القيم المتوقعة:
y_pred = BNB.predict(X_test)  
نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل:
print('BNB Train Score is : ' , BNB.score(X_train, y_train)) print('BNB Test Score is : ' , BNB.score(X_test, y_test))  
لنأخذ مثال يوضح المصنف:
قمنا باستدعاء المكتبات وبناء عينة مزيفه وكان التصنيف ثنائي أما 1 أو 0 بعد ذلك استخدمنا BernoulliNB
ثم قمنا بتجريب الموديل على عينة معطاة:
#استدعاء المكتبات import numpy as np from sklearn.naive_bayes import BernoulliNB #تعين داتا دخل مزيفة X = np.random.random((6, 100)) y = np.array([1, 0, 1, 0, 1, 0]) #بناء الموديل BNB =BernoulliNB () BNB.fit(X, y) #تصنيف عينة print(BNB.predict(X[3:4])) #النتيجة #[0]  

بشكل عام الخطأ ValueError: Only one class present in y_true. ROC AUC score is not defined in that case. يظهر عندما تكون قيم y_true واحدة (مثلاً كلها أصفار أو كلها واحدات..) في هذه الحالة فإن المعيار  ROC AUC غير معرف ولايمكن تطبيقه.
معالجة هذا ال Error تختلف باختلاف المسألة وتكون عادة بالتقاط هذا الخطأ (عن طريق رمي استثناء).
لكن دعنا نعالج مشكلتك:
أولاً أنت تستخدم مجموعة البيانات iris dataset وهذه الداتاسيت قيم ال target لها مرتبة أي إذا جربت استعراضها ستجد التالي:
dataset.target[0:50] # result array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) dataset.target[50:100] array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) dataset.target[100:150] array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
لاحظ أن أول 50 قيمة كلها 0 ثاني 50 قيمة هي 1..إلخ.
حسناً هنا صحيح لدينا أكثر من فئة (لدينا 0 و 1) وقد تقول لايجب أن يظهر الخطأ، وهذا الكلام صحيح تماماً إلا في حالة استخدامك لل cross_val_score فهنا تقوم بتقسيم البيانات إلى عدة أقسام (في حالتك قمت بقسمها إلى 4 أقسام وبالتالي من المرجح جداً أن تكون إحدى هذه الأقسام لاتحوي إلى على قيمة واحدة (تذكر البيانات مرتبة هنا) ).
لذا لحل هذا المشكلة قم بخلط البيانات قبل عملية ال cross_val_score وهذا سيضمن لك عدم حدوث ذلك (ستكون جعلت البيانات غير مرتبة).
from sklearn.utils import shuffle X_new, y_new = shuffle(Xdata,ydata) cross_val_score(model, X_new, y_new, cv=4, scoring="roc_auc") #النتيجة بعد إضافة الكود array([0.82692308, 0.85704023, 0.84974359, 0.79734848])  

يمكنك القيام بذلك عن طريق الكلاس OrdinalEncoder المعرف ضمن الموديول preprocessing قي مكتبة sklearn.
sklearn.preprocessing.OrdinalEncoder نستخدم التابع fit_transform(data) لكي يقوم بعملية ال fitting (الترميز) ثم التحويل transform بناءان على الترميز الذي تم في مرحلة ال fitting.
# ordinal encoding مثال عن ال # استيراد المكتبات from numpy import asarray from sklearn import preprocessing # تعريف بيانات ourdata = asarray([['first'], ['second'], ['third']]) print(ourdata) # output: [['first']['second']['third']] # تعريف غرض من الكلاس encoder = preprocessing.OrdinalEncoder() # القيام بعملية الترميز والتحويل dataencoded = encoder.fit_transform(data) print(dataencoded) #output: [[0.][1.][2.]]  

يمكننا القيام بذلك عن طريق مكتبة Sklearn باستخدام الصف LabelEncoder  عبر الموديول التالي:
preprocessing.LabelEncoder  classes_: هي attribute لعرض الفئات التي وجدها.
(data)fit : للقيام بعملية fitting على البيانات أي لكي يرمزها.
(data)transform: لتحويل البيانات data من  شكلها الحالي إلى الشكل الجديد (الترميز الجديد).
مثال:
# استيراد المكتبات from sklearn.preprocessing import LabelEncoder import pandas as pd # إنشاءداتا data = {'size': [100, 30, 50, 200, 2], 'rooms': [12, 2, 3, 30, 2], 'score': ['big', 'small', 'medium', 'verybig', 'verysmall']} df = pd.DataFrame(data) df.head() # تعريف غرض من الصف المطلوب le = LabelEncoder() # على البيانات المطلوبة fitting القيام بعملية ال le.fit(df['class']) # fitting عرض الفئات المختلفة التي وجدها بعد أن انتهى من ال print('classed found : ' , list(le.classes_)) # classed found : ['big', 'medium', 'small', 'verybig', 'verysmall'] # للقيام بعملية التحويل فقط ، حيث اننا هنا فقط استعرضنا النتيجة print('equivilant numbers are : ' ,le.transform(df['class']) ) # equivilant numbers are : [0 2 1 3 4] # للقيام يعملية التحويل واستبدال القيم الناتجة بالقيم الأصلية في البيانات df['class'] = le.transform(df['class'])  

كنصيحة يفضل استخدامه عندما يكون هنالك بيانات منفصلة أي الميزات features تكون مستقلة لا يتعلق حدوث الميزة الأولى بالاخرى مثل عمر الشخص و درجته  في مادة الرياضيات على سبيل المثال.
يتم استخدامه عبر الموديول:
sklearn.naive_bayes استدعاء المكتبات:
from sklearn.naive_bayes import MultinomialNB في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل.
الشكل العام للموديل:
MNB = MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None) الوسيط الأول alpha هي الهدف من هذا الوسيط هو عند حساب الاحتمالات احد هذه الاحتمالات من الممكن أن يكون صفر وتجنبا لذلك يتم وضع قيمة تسمى قيمة تنعيم  أو تجانس لابلاس لكي لا يكون هناك قيم صفرية.
الوسيط الثاني  fit_prior تأخذ True فقط لكي تعلم الصفوف الاحتمالات السابقه false عكس ذلك. 
الوسيط الثالث class_prior قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف 
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, X_test,  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
MNB = MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None) MNB.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب.
حساب القيم المتوقعة:
y_pred = MNB.predict(X_test) حساب الكفاءه على الاختبار والتدريب:
print('MNB Train Score is : ' , MNB.score(X_train, y_train)) print('MNB Test Score is : ' , MNB.score(X_test, y_test)) لنأخذ مثال يوضح المصنف.
قمنا باستدعاء المكتبات وبناء عينة مزيفة وكان التصنيف ثنائي أما 1 أو 0.
ثم قمنا بتجريب الموديل على عينة معطاة.
#استدعاء المكتبات import numpy as np from sklearn.naive_bayes import MultinomialNB #تعين داتا دخل مزيفة X = np.random.random((6, 100)) y = np.array([1, 0, 1, 0, 1, 0]) #بناء الموديل MNB =MultinomialNB () MNB.fit(X, Y) #تصنيف عينة print(MNB.predict(X[3:4])) #النتيجة #[1]  

بداية كنصيحة للحصول على نتائج أفضل: يفضل استخدام هذه الخوارزمية عندما تكون الداتا متوزعة توزعاً طبيعياً، وهذه الخوارزمية تعتمد على نظرية بايز في الاحتمالات.
يتم استخدامه عبر الموديول
sklearn.naive_bayes.GaussianNB استدعاء المكتبات: from sklearn.naive_bayes import GaussianNB        في البداية قمنا باستدعاء المكتبة التي يوجد فيها هذا الموديل
الشكل العام للموديل: GNB = GaussianNB(priors=None, var_smoothing=1e-09) الوسيط الأول priors قيم الاحتمالات للصفوف أي تساوي عدد الصفوف يمكن تمريرها كمصفوفة تحوي الاحتمال لكل صف 
الوسيط الثاني var_smoothing  عندما يعمل GaussianNB كمرشح تمرير منخفض فأنه يقوم بأخذ القيم القريبه من وسط المنحني الغاوصي لذلك هذا الوسيط يؤدي إى توسيع المنحني وبتالي نستطيع أخذ  القيم البعيده 
طبعا قمت بشرح الشكل العام للموديل ولكن عن طريقة استخدامه سهل جدا فقط بعد أن تقوم بتقسيم الداتا إلى X_train, X_test,  تسطيع كتابة الأتي لعملية التدريب.
الشكل العام للموديل:
GNB = GaussianNB(priors=None, var_smoothing=1e-09) GNB.fit(X_train, y_train) حيث الدالة fit يوجد ضمنها جميع العمليات الداخلية لعملية التدريب . 
حساب القيم المتوقعة: y_pred = GNB.predict(X_test) نستطيع حساب دقة الموديل أو كفاءته  على التدريب والاختبار عن طريق التابع score ويكون وفق الشكل: print('GNB Train Score is : ' , GNB.score(X_train, y_train)) print('GNB Test Score is : ' , GNB.score(X_test, y_test)) لنأخذ مثال يوضح المصنف.قمنا باستدعاء المكتبات وبناء عينة مزيفة وكان التصنيف ثنائي أما 1 أو 0 بعد ذلك استخدمنا GaussianNB
ثم قمنا بتجريب الموديل على عينة معطاة:
#استدعاء المكتبات import numpy as np from sklearn.naive_bayes import GaussianNB #تعين داتا دخل مزيفة X = np.array([[1, 1], [2, 1], [3, -2], [-1, -1], [4, 1], [-5, 2]]) Y = np.array([0, 1, 0, 1, 0, 1]) #يناء الموديل GNB = GaussianNB() GNB.fit(X, Y) #تصنيف عينة print(GNB.predict([[-0.8, -1]])) #النتيجة #[1]