Ali Haidar Ahmad

يمكنك ذلك باستخدام الموديول: 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).

يمكنك الاستفسار عن أي شيء من خلال الرابط: https://help.hsoub.com/

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. ]]

كما أشار @محمد أبو عواد و @Wael Aljamal. أولاً أنت تعرف القائمة bar على أنها class attributes أي وكأنها static أي تتشارك القيمة مع كل الكائنات المأخوذة من الصف. ثانياً في حالة استخادم += فهذا يقابل استدعاء الدالة __iadd__ التي تقوم بتعديل القيمة الأصلية لل bar. أي أنها تغير قيمة الكائن الذي تعمل عليه. أما + فهذا يقابل استدعاء الدالة __add__ التي تقوم بإنشاء كائن جديد، أي في حالتنا سوف تنشئ نسخة من bar أي أن التعديل لن يتأثر به المتغير bar الأصلي. ويمكنك التأكد بذلك عن طريق تجربة التالي: >>> f.bar = f.bar + [4] >>> print(f.bar) # [1, 2, 3, 4] >>> print(g.bar) # [1, 2, 3] >>> foo.bar # [1, 2, 3] مع ملاحظة أن التابع الخاص __iadd__ يحاول في البداية أن يعدل القيمة الأصلية للمتغير، وإذا لم ينجح (مثلاً قد يكون متحولاً ثابتاً أي لايمكن تعديل قيمته) فإنه يقوم بإنشاء نسخة جديدة منه، أي يسلك سلوك __add__.

أولاً يجب أن تحذر فهذا المعيار يستخدم مع مهام التصنيف 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'])

لقد قمت بحذف اسم الباكج الذي تعمل بداخله وبالتالي ظهر لك هذا الخطأ. لحل المشكلة يجب أن تضع في بداية الكود اسم البكج الذي تعمل بداخله لكي يتم التعرف على الكلاس. ويجب أن تكون أول تعليمة في برنامجك : package package_name

كنصيحة يفضل استخدامه عندما يكون هنالك بيانات منفصلة أي الميزات 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]

set-current-module تستخدم للانتقال إلى فرع آخر من البرنامج. تعليمة focus تقوم بنقل التنفيذ إلى فرع آخر أيضاً من البرنامج ويمكن أن تكتب ضمن action لقاعدة أو ضمن ال main. الفرق بين تعليمة focus و set current module أن focus تبدأ بتنفيذ القواعد الموجودة في WM أما set current module تقوم فقط بإضافة القواعد ولا تبدأ بالتنفيذ، وهذا هو الفرق الأساسي. افتراضياً focus و set-current-module يكونان على MAIN.