diff --git "a/src/classifier.ipynb" "b/src/classifier.ipynb" --- "a/src/classifier.ipynb" +++ "b/src/classifier.ipynb" @@ -12,16 +12,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mehdi/miniconda3/envs/adc/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import pickle\n", "\n", @@ -29,15 +20,12 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", - "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.model_selection import RandomizedSearchCV\n", - "from sklearn.preprocessing import LabelEncoder\n", "import torch\n", "from transformers import AutoModel, AutoTokenizer\n", "import xgboost as xgb\n", "\n", - "from utils import evaluate_predictions" + "from utils import evaluate_predictions, plot_confusion_matrix" ] }, { @@ -599,206 +587,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can try different models. \n", - "\n", - "For the ensemble models, we can do a randomized or grid search to tune the hyperparameters. We will use a 5-fold cross validation strategy, and optimize for the macro averaged f1 score (because we want to give an equal importance to each class, regardless of how many observations each one has)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.3.1 Logistic Regression " - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
LogisticRegression(class_weight='balanced', max_iter=1000,\n",
-       "                   multi_class='multinomial', random_state=2024)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "LogisticRegression(class_weight='balanced', max_iter=1000,\n", - " multi_class='multinomial', random_state=2024)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "lr_model = LogisticRegression(multi_class='multinomial', \n", - " class_weight=\"balanced\", \n", - " max_iter=1000, \n", - " random_state=2024)\n", - "lr_model.fit(X_train, y_train)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.3.2 Random Forest" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
RandomizedSearchCV(cv=5,\n",
-       "                   estimator=RandomForestClassifier(class_weight='balanced',\n",
-       "                                                    random_state=2024),\n",
-       "                   n_iter=20,\n",
-       "                   param_distributions={'max_depth': [3, 4, 5, 6, 7, 8],\n",
-       "                                        'n_estimators': [100, 150, 200, 250,\n",
-       "                                                         300, 400, 500]},\n",
-       "                   scoring='f1_macro')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "RandomizedSearchCV(cv=5,\n", - " estimator=RandomForestClassifier(class_weight='balanced',\n", - " random_state=2024),\n", - " n_iter=20,\n", - " param_distributions={'max_depth': [3, 4, 5, 6, 7, 8],\n", - " 'n_estimators': [100, 150, 200, 250,\n", - " 300, 400, 500]},\n", - " scoring='f1_macro')" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rf_model = RandomForestClassifier(class_weight=\"balanced\", random_state=2024)\n", - "parameters = {\n", - " \"n_estimators\": [100, 150, 200, 250, 300, 400, 500],\n", - " \"max_depth\": [3, 4, 5, 6, 7, 8]\n", - "}\n", - "rf_search = RandomizedSearchCV(estimator=rf_model, param_distributions=parameters, \n", - " scoring=\"f1_macro\", cv=5, n_iter=20)\n", - "rf_search.fit(X_train, y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best Parameters: {'n_estimators': 400, 'max_depth': 8}\n", - "Best Score: 0.15591886021384346\n" - ] - } - ], - "source": [ - "print(\"Best Parameters:\", rf_search.best_params_)\n", - "print(\"Best Score:\", rf_search.best_score_)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.3.3 XGBoost" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For XGBoost, we first need to encode the target variable." + "We will start simple, and use a logistic regression to see what we can achieve with those embeddings." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], - "source": [ - "label_encoder = LabelEncoder()\n", - "y_train_encoded = label_encoder.fit_transform(y_train)\n", - "y_test_encoded = label_encoder.transform(y_test)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "xgb_model = xgb.XGBClassifier(device=\"cuda\", seed=2024)\n", - "parameters = {\n", - " \"n_estimators\" : [100, 150, 200, 300, 400, 450, 500],\n", - " \"max_depth\" : [3, 4, 5, 6, 7, 8],\n", - " \"learning_rate\": [0.1, 0.05, 0.01, 0.005, 0.001]\n", - "}\n", - "xgb_search = RandomizedSearchCV(estimator=xgb_model, param_distributions=parameters,\n", - " scoring=\"f1_macro\", cv=5, n_iter=20)\n", - "xgb_search.fit(X_train, y_train_encoded)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\"Best Parameters:\", xgb_search.best_params_)\n", - "print(\"Best Score (Macro Average F1):\", xgb_search.best_score_)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The best parameters and best score obtained are the following: \n", - "```\n", - "Best Parameters: {'n_estimators': 450, 'max_depth': 7, 'learning_rate': 0.1} \n", - "Best Score (Macro Average F1): 0.17356889596239114\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Evaluating the Performance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, let's retrain the models with the best parameters we obtained." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, "outputs": [ { "data": { @@ -812,7 +607,7 @@ " multi_class='multinomial', random_state=2024)" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -826,91 +621,10 @@ ] }, { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
RandomForestClassifier(class_weight='balanced', max_depth=8, n_estimators=400,\n",
-       "                       random_state=2024)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "RandomForestClassifier(class_weight='balanced', max_depth=8, n_estimators=400,\n", - " random_state=2024)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rf_model = RandomForestClassifier(class_weight=\"balanced\", \n", - " random_state=2024,\n", - " n_estimators=400,\n", - " max_depth=8)\n", - "rf_model.fit(X_train, y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
-       "              colsample_bylevel=None, colsample_bynode=None,\n",
-       "              colsample_bytree=None, device='cuda', early_stopping_rounds=None,\n",
-       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
-       "              gamma=None, grow_policy=None, importance_type=None,\n",
-       "              interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
-       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
-       "              max_delta_step=None, max_depth=7, max_leaves=None,\n",
-       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
-       "              multi_strategy=None, n_estimators=450, n_jobs=None,\n",
-       "              num_parallel_tree=None, objective='multi:softprob', ...)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "XGBClassifier(base_score=None, booster=None, callbacks=None,\n", - " colsample_bylevel=None, colsample_bynode=None,\n", - " colsample_bytree=None, device='cuda', early_stopping_rounds=None,\n", - " enable_categorical=False, eval_metric=None, feature_types=None,\n", - " gamma=None, grow_policy=None, importance_type=None,\n", - " interaction_constraints=None, learning_rate=0.1, max_bin=None,\n", - " max_cat_threshold=None, max_cat_to_onehot=None,\n", - " max_delta_step=None, max_depth=7, max_leaves=None,\n", - " min_child_weight=None, missing=nan, monotone_constraints=None,\n", - " multi_strategy=None, n_estimators=450, n_jobs=None,\n", - " num_parallel_tree=None, objective='multi:softprob', ...)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "xgb_model = xgb.XGBClassifier(device=\"cuda\", \n", - " seed=2024,\n", - " n_estimators=450,\n", - " max_depth=7,\n", - " learning_rate=0.1)\n", - "xgb_model.fit(X_train, y_train_encoded)" + "## 3. Evaluating the Performance" ] }, { @@ -922,7 +636,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -953,81 +667,37 @@ ] }, { - "cell_type": "code", - "execution_count": 15, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Random Forest\n", - "\n", - "Train set:\n", - "Accuracy: 0.5817619047619048\n", - "F1 macro average: 0.6302920544396868\n", - "F1 weighted average: 0.5817320656440126\n", - "--------------------------------------------------\n", - "Test set:\n", - "Accuracy: 0.2188\n", - "F1 macro average: 0.11020842424166737\n", - "F1 weighted average: 0.2054551695522176\n" - ] - } - ], "source": [ - "rf_train_preds = rf_model.predict(X_train)\n", - "rf_test_preds = rf_model.predict(X_test)\n", - "\n", - "evaluate_predictions(model=\"Random Forest\", \n", - " train_preds= rf_train_preds, y_train=y_train,\n", - " test_preds=rf_test_preds, y_test=y_test)" + "We see that the model is struggling to correctly classify the different dialects, (which makes sense because everything is in arabic at the end of the day). Let's have a look at the confusion matrix." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 6, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/mehdi/miniconda3/envs/adc/lib/python3.10/site-packages/xgboost/core.py:160: UserWarning: [12:38:31] WARNING: /home/conda/feedstock_root/build_artifacts/xgboost-split_1705650282415/work/src/common/error_msg.cc:58: Falling back to prediction using DMatrix due to mismatched devices. This might lead to higher memory usage and slower performance. XGBoost is running on: cuda:0, while the input data is on: cpu.\n", - "Potential solutions:\n", - "- Use a data structure that matches the device ordinal in the booster.\n", - "- Set the device for booster before call to inplace_predict.\n", - "\n", - "This warning will only be shown once.\n", - "\n", - " warnings.warn(smsg, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "XgBoost\n", - "\n", - "Train set:\n", - "Accuracy: 0.9998571428571429\n", - "F1 macro average: 0.9998485323510583\n", - "F1 weighted average: 0.9998571499183782\n", - "--------------------------------------------------\n", - "Test set:\n", - "Accuracy: 0.3552\n", - "F1 macro average: 0.13665190979200587\n", - "F1 weighted average: 0.288613804297705\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "xgb_train_preds = xgb_model.predict(X_train)\n", - "xgb_test_preds = xgb_model.predict(X_test)\n", - "\n", - "evaluate_predictions(model=\"XgBoost\", \n", - " train_preds= xgb_train_preds, y_train=y_train_encoded,\n", - " test_preds=xgb_test_preds, y_test=y_test_encoded)" + "plot_confusion_matrix(y_test, lr_test_preds)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the confusion matrix, we see that the model is only really able to detect Egyptian arabic, and to a lesser extent Iraqi and Algerian." ] } ],