supervised.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **SENTIMENT ANALYSIS - SUPERVISED**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inicialització"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inicialitzem els imports necessaris, així com les lectures dels diferents documents i el preprocessament dels texts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "import numpy as np\n",
    "import json\n",
    "from sklearn.metrics import accuracy_score\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk import pos_tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load datasets\n",
    "with open('./data/original_data/X_train.json', 'r') as file:\n",
    "    X_train_data = json.load(file)\n",
    "    \n",
    "with open('./data/original_data/X_test.json', 'r') as file:\n",
    "    X_test_data = json.load(file)\n",
    "\n",
    "with open('./data/original_data/X_train_no_val.json', 'r') as file:\n",
    "    X_train_val_data = json.load(file)\n",
    "\n",
    "with open('./data/original_data/X_val.json', 'r') as file:\n",
    "    X_val_data = json.load(file)\n",
    "    \n",
    "with open('./data/original_data//y_train.json', 'r') as file:\n",
    "    y_train = json.load(file)\n",
    "    \n",
    "with open('./data/original_data/y_test.json', 'r') as file:\n",
    "    y_test = json.load(file)\n",
    "\n",
    "with open('./data/original_data/y_train_no_val.json', 'r') as file:\n",
    "    y_train_val = json.load(file)\n",
    "\n",
    "with open('./data/original_data/y_val.json', 'r') as file:\n",
    "    y_val = json.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "vectorizer = CountVectorizer(min_df=0.0, stop_words='english', strip_accents='ascii')\n",
    "\n",
    "# Vectorizer alternatiu per comparar resultats amb l'altre\n",
    "vectorizer_alternate = CountVectorizer(min_df=0.0, binary=True, stop_words='english', strip_accents='ascii')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nEn cas de voler Stemmatitzar:\\nfrom nltk.stem import PorterStemmer\\nstemmer = PorterStemmer()\\nX_train_stem = [\" \".join([stemmer.stem(i) for i in word_tokenize(sent)]) for sent in X_train_data]\\nX_test_stem = [\" \".join([stemmer.stem(i) for i in word_tokenize(sent)]) for sent in X_test_data]\\n'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "# Realitzem el preprocessament esmentat: lemmatitzar, treure signes de puntuació i stopwords\n",
    "wnl = WordNetLemmatizer()\n",
    "X_train_lem = [\" \".join([wnl.lemmatize(i,j[0].lower()) if j[0].lower() in ['a','n','v'] else wnl.lemmatize(i) for i,j in pos_tag(word_tokenize(sent))]) for sent in X_train_data]\n",
    "X_test_lem = [\" \".join([wnl.lemmatize(i,j[0].lower()) if j[0].lower() in ['a','n','v'] else wnl.lemmatize(i) for i,j in pos_tag(word_tokenize(sent))]) for sent in X_test_data]\n",
    "\n",
    "stop_words = set(nltk.corpus.stopwords.words('english'))\n",
    "X_train_pre = []\n",
    "for sent in X_train_lem:\n",
    "    sentence = []\n",
    "    for token in word_tokenize(sent):\n",
    "        if token not in string.punctuation and token not in stop_words and token != \"``\":\n",
    "            sentence.append(token)\n",
    "    X_train_pre.append(\" \".join(e for e in sentence))\n",
    "\n",
    "X_test_pre = []\n",
    "for sent in X_test_lem:\n",
    "    sentence = []\n",
    "    for token in word_tokenize(sent):\n",
    "        if token not in string.punctuation and token not in stop_words and token not in [\"``\", \"--\"]:\n",
    "            sentence.append(token)\n",
    "    X_test_pre.append(\" \".join(e for e in sentence))\n",
    "\n",
    "\"\"\"\n",
    "En cas de voler Stemmatitzar:\n",
    "from nltk.stem import PorterStemmer\n",
    "stemmer = PorterStemmer()\n",
    "X_train_stem = [\" \".join([stemmer.stem(i) for i in word_tokenize(sent)]) for sent in X_train_data]\n",
    "X_test_stem = [\" \".join([stemmer.stem(i) for i in word_tokenize(sent)]) for sent in X_test_data]\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Realitzem els fits i els transforms tant per les dades que usarem d'entrada (\"validació\") com per les després usades en train i test. Tenir en compte que aquesta primera validació és tan sols per escollir alguns models que més o menys funcionin, i que la validació real es farà utilitzant Cross-Validation més endavant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nX_train_stem = vectorizer.fit_transform(X_train_stem)\\nX_test_stem = vectorizer.transform(X_test_stem)\\n'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dades sense processar, vectorizer normal, de validació\n",
    "X_train_val = vectorizer.fit_transform(X_train_val_data)\n",
    "X_val = vectorizer.transform(X_val_data)\n",
    "\n",
    "# Dades sense processar, vectorizer normal, de train test\n",
    "X_train = vectorizer.fit_transform(X_train_data)\n",
    "X_test = vectorizer.transform(X_test_data)\n",
    "\n",
    "# Dades sense processar, vectorizer alternatiu, de validació\n",
    "X_train_val_alt = vectorizer_alternate.fit_transform(X_train_val_data)\n",
    "X_val_alt = vectorizer_alternate.transform(X_val_data)\n",
    "\n",
    "# Dades sense processar, vectorizer alternatiu, de train test\n",
    "X_train_alt = vectorizer_alternate.fit_transform(X_train_data)\n",
    "X_test_alt = vectorizer_alternate.transform(X_test_data)\n",
    "\n",
    "# Dades lemmatitzades, vectorizer normal, de train test\n",
    "X_train_lem = vectorizer.fit_transform(X_train_lem)\n",
    "X_test_lem = vectorizer.transform(X_test_lem)\n",
    "\n",
    "# Dades amb el preprocessament, vectorizer normal, de train test\n",
    "X_train_pre = vectorizer.fit_transform(X_train_pre)\n",
    "X_test_pre = vectorizer.transform(X_test_pre)\n",
    "\n",
    "\"\"\"\n",
    "X_train_stem = vectorizer.fit_transform(X_train_stem)\n",
    "X_test_stem = vectorizer.transform(X_test_stem)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7786666666666666"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.5, max_depth=3, random_state=0).fit(X_train_val, y_train_val)\n",
    "clf.score(X_val, y_val)\n",
    "\n",
    "# 0.7787"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.808"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "clf = AdaBoostClassifier(n_estimators=100, algorithm=\"SAMME\", random_state=0)\n",
    "clf.fit(X_train_val, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val), y_val)\n",
    "\n",
    "# 0.808"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6906666666666667"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "clf = GaussianNB()\n",
    "clf.fit(X_train_val.toarray(), y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val.toarray()), y_val)\n",
    "\n",
    "# 0.69"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8693333333333333"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "clf = RandomForestClassifier(n_estimators=800, max_depth=12, random_state=0)\n",
    "clf.fit(X_train_val, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val), y_val)\n",
    "\n",
    "# 0.8693"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8213333333333334"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "clf = LogisticRegression(random_state=0)\n",
    "clf.fit(X_train_val, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val), y_val)\n",
    "\n",
    "# 0.8213"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7813333333333333"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "clf = SVC(C=1, kernel='rbf', degree=3)\n",
    "clf.fit(X_train_val, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val), y_val)\n",
    "\n",
    "# 0.7813"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5413333333333333"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "clf = KNeighborsClassifier(n_neighbors=1)\n",
    "clf.fit(X_train_val, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val), y_val)\n",
    "\n",
    "# 0.5413"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.832"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "clf = MLPClassifier(solver='lbfgs', alpha=1e-3, hidden_layer_sizes=(20, 10), random_state=42)\n",
    "clf.fit(X_train_val, y_train_val)\n",
    "accuracy_score(clf.predict(X_val), y_val)\n",
    "\n",
    "# 0.832"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observem també, com canvia per exemple el Random Forest i el Logistic Regression amb l'altre vectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.856"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "clf = RandomForestClassifier(n_estimators=800, max_depth=12, random_state=0)\n",
    "clf.fit(X_train_val_alt, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val_alt), y_val)\n",
    "\n",
    "# 0.8666\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "clf = LogisticRegression(random_state=0)\n",
    "clf.fit(X_train_val_alt, y_train_val)\n",
    "\n",
    "accuracy_score(clf.predict(X_val_alt), y_val)\n",
    "\n",
    "# 0.856"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cross-validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En aquest apartat, realitzarem una cross-validation per cada model (per escollir els seus millors paràmetres), i després agafarem el millor de tots els models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GradientBoostingClassifier: Best params = {'learning_rate': 0.25, 'max_depth': 6, 'random_state': 0} (Accuracy = 0.7947)\n",
      "AdaBoostClassifier: Best params = {'algorithm': 'SAMME', 'learning_rate': 1, 'n_estimators': 200, 'random_state': 0} (Accuracy = 0.7907)\n",
      "RandomForestClassifier: Best params = {'max_depth': 14, 'n_estimators': 1500, 'random_state': 0} (Accuracy = 0.8613)\n",
      "LogisticRegression: Best params = {'max_iter': 1000, 'random_state': 0} (Accuracy = 0.8513)\n",
      "SVC: Best params = {'C': 1, 'degree': 1, 'kernel': 'poly', 'random_state': 0} (Accuracy = 0.8520)\n",
      "MLPClassifier: Best params = {'alpha': 0.001, 'hidden_layer_sizes': (20, 10), 'learning_rate': 'constant', 'random_state': 0, 'solver': 'lbfgs'} (Accuracy = 0.8593)\n",
      "BEST MODEL: RandomForestClassifier with params = {'max_depth': 14, 'n_estimators': 1500, 'random_state': 0} (Accuracy = 0.8613)\n"
     ]
    }
   ],
   "source": [
    "# Cross-validation\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "# List of models and their hyperparameters\n",
    "random_state = 0\n",
    "models_params = [\n",
    "    (GradientBoostingClassifier(), {'learning_rate': [0.1, 0.25, 0.5], 'max_depth': [3, 6], 'random_state': [random_state]}),\n",
    "    (AdaBoostClassifier(), {'n_estimators': [50, 100, 200], 'algorithm': [\"SAMME\", \"SAMME.R\"], 'learning_rate': [0.5, 1], 'random_state': [random_state]}),\n",
    "    (RandomForestClassifier(), {'n_estimators': [100, 500, 1000, 1500], 'max_depth': [2, 5, 10, 12, 13, 14, None], 'random_state': [random_state]}),\n",
    "    (LogisticRegression(), {'max_iter': [1000] , 'random_state': [random_state]}),\n",
    "    (SVC(), {'C': [0.5, 1, 5], 'kernel': ['linear', 'rbf', 'poly'], 'degree': [1, 2, 3], 'random_state': [random_state]}),\n",
    "    (MLPClassifier(), {'solver': ['lbfgs', 'adam'], 'learning_rate': ['constant', 'adaptive', 'invscaling'], 'hidden_layer_sizes': [(5, 2), (10, 5), (20, 10)], 'alpha': [1e-2, 1e-3, 1e-5], 'random_state': [random_state]})\n",
    "]\n",
    "results = []\n",
    "\n",
    "def run_grid_search(model, params):\n",
    "    \"\"\"\n",
    "    Runs a grid search for the given model and parameters.\n",
    "    \"\"\"\n",
    "    grid_search = GridSearchCV(model, params, scoring='accuracy', cv=5)\n",
    "    grid_search.fit(X_train_alt, y_train)\n",
    "    \n",
    "    return grid_search.best_params_, grid_search.best_score_\n",
    "\n",
    "# Run grid search for each model\n",
    "iter = 1\n",
    "for model, params in models_params:\n",
    "    print(f\"Running grid search on model: {iter}/{len(models_params)}\\r\", end=\"\")\n",
    "    best_params, best_score = run_grid_search(model, params)\n",
    "    results.append((model.__class__.__name__, best_params, best_score))\n",
    "    iter += 1\n",
    "\n",
    "# Show results\n",
    "for model_name, best_params, best_score in results:\n",
    "    print(f\"{model_name}: Best params = {best_params} (Accuracy = {best_score:.4f})\")\n",
    "\n",
    "best_model = max(results, key=lambda x: x[2])\n",
    "print(f\"BEST MODEL: {best_model[0]} with params = {best_model[1]} (Accuracy = {best_model[2]:.4f})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un cop executat el validation, executem el test amb el millor model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.854"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run the best model on the test set\n",
    "best_clf = RandomForestClassifier(max_depth=14, n_estimators=1500, random_state=42)\n",
    "best_clf.fit(X_train_alt, y_train)\n",
    "accuracy_score(best_clf.predict(X_test_alt), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create confusion matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "y_pred = best_clf.predict(X_test_alt)\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "y_scores = best_clf.predict_proba(X_test_alt)[:, 1]  # Probability estimates\n",
    "\n",
    "# Calculate ROC curve\n",
    "fpr, tpr, thresholds = roc_curve(y_test, y_scores)\n",
    "\n",
    "# Calculate the area under the ROC curve (AUC)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "\n",
    "# Plot ROC curve\n",
    "plt.figure()\n",
    "plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC)')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podem observar en quines valoracions d'equivoca:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the american action film has been slowly drowning to death in a sea of asian wire - fu copycats . it ' s not a pretty death , and it ' s leaving the likes of schwartznager , stallone , and van damme wearing cement galoshes at the bottom of a kung fu sea . sometimes , the mix results in a mind - blowing spectacle unlike any other . quality action with amazing and exciting stunt work , as in 1999 ' s the matrix , can be a real gem . but too often hollywood gets it wrong , even when they pay off chinese directors . flying ninjas and floating karate masters have been replaced by soaring bronx detectives and slow motion kicking scientists . mostly it ' s laughable . in hollywood ' s rush to emulate the success of the matrix , trademark asian stunt choreography has become more of a joke than an art form . but iron monkey , the latest asian import , shows us how to get it right . iron monkey ( actually a reissue of a 1993 film ) is the story of a 19th chinese vigilante ( rongguang yu ) , fighting with his own unique style of shaolin kung fu for the rights of the oppressed and the bellies of the hungry . but it is also a piece of the narrative of legendary chinese film hero wong fei - hong , most recently seen in one of the most overlooked , and possibly best films of 2000 , drunken master 2 ( released in the u . s . as the legend of drunken master ) . unlike drunken master 2 , which stars jackie chan as an adult fei - hong , iron monkey finds a much younger fei - hong ( sze - man tsang ) and his father wong kei - ying ( yen chi dan ) thrust into the middle of iron monkey ' s fight against oppression . iron monkey succeeds as no kung fu film since drunken master 2 . at times , fighting styles , especially that of monkey himself , do devolve into the ridiculous twinkle - toed floating of films like crouching tiger , hidden dragon , director yuen wo ping eventually remembers to bring his action scenes back to earth . iron monkey is at its heart a hardcore , kung fu action film rather than any kind of drama a la crouching tiger . however , there are brief moments of profoundness shared between characters , such as those that pass between our outlaw hero and his good - hearted but misguided enemy , chief fox . in those moments , and in others , iron monkey manages to transcend its mindless kung fu nature to touch the hearts and minds of its audience . while in no way the equal of a masterpiece like drunken master 2 , iron monkey dances quite nicely to the invading kung fu tune . aka siunin wong fei - hung tsi titmalau .\n"
     ]
    }
   ],
   "source": [
    "false_negatives = []\n",
    "false_positives = []\n",
    "\n",
    "for i in range(len(y_test)):\n",
    "    if y_test[i] != y_pred[i]:\n",
    "        if y_test[i] == 0:  # False Negative\n",
    "            false_negatives.append(i)\n",
    "        else:  # False Positive\n",
    "            false_positives.append(i)\n",
    "\n",
    "print(X_train_data[false_negatives[0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "També podem veure com rendeixen alguns dels models que haviem \"descartat\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.856"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf = MLPClassifier(random_state=42)\n",
    "clf.fit(X_train_alt, y_train)\n",
    "accuracy_score(clf.predict(X_test_alt), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.848"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_clf = RandomForestClassifier(max_depth=12, n_estimators=1500, random_state=42)\n",
    "best_clf.fit(X_train, y_train)\n",
    "accuracy_score(best_clf.predict(X_test), y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAIjCAYAAAAk+FJEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAqtUlEQVR4nO3de/zX8/3/8fun1Kd0FipGSZOMybGFSl/ENhv6Os1M5TQbZpLjZiqHNiFnMafmsGGmbWxfM80cv84RM18h8yVJiA6Kev/+8Ovz3UfF55Pq88T1erl0uez9fL8Oj/f7clluvT6v9/tTValUKgEAgAI1augBAABgacQqAADFEqsAABRLrAIAUCyxCgBAscQqAADFEqsAABRLrAIAUCyxCgBAscQqwBI899xzGTBgQNq0aZOqqqqMHz9+uR5/ypQpqaqqytVXX71cj/tZtv3222f77bdv6DGAwohVoFjPP/98vv/976dr165p1qxZWrdunW233TbnnXde5s6du0LPPWjQoEyaNCmnn356rrnmmmy55ZYr9Hwr0+DBg1NVVZXWrVsv8X187rnnUlVVlaqqqpx11ln1Pv6rr76a4cOHZ+LEicthWuCLbpWGHgBgSW677bbstddeqa6uzgEHHJCNN9448+fPz7333ptjjz02Tz/9dC677LIVcu65c+fmgQceyE9+8pMcccQRK+QcnTt3zty5c9OkSZMVcvxPssoqq2TOnDn54x//mL333rvWc9ddd12aNWuW9957b5mO/eqrr2bEiBHp0qVLevbsWef9/vKXvyzT+YDPN7EKFOfFF1/Mvvvum86dO2fChAnp1KlTzXOHH354Jk+enNtuu22FnX/69OlJkrZt266wc1RVVaVZs2Yr7PifpLq6Ottuu21+/etfLxar119/fb75zW/m5ptvXimzzJkzJ6uuumqaNm26Us4HfLa4DQAozplnnplZs2bliiuuqBWqi3Tr1i1HHXVUzeMPPvggp556atZff/1UV1enS5cuOemkkzJv3rxa+3Xp0iW77rpr7r333my99dZp1qxZunbtml/96lc12wwfPjydO3dOkhx77LGpqqpKly5dknz44/NF//vfDR8+PFVVVbXW7rjjjmy33XZp27ZtWrZsme7du+ekk06qeX5p96xOmDAhffr0SYsWLdK2bdvstttueeaZZ5Z4vsmTJ2fw4MFp27Zt2rRpkyFDhmTOnDlLf2M/Yr/99suf//znvP322zVrDz/8cJ577rnst99+i23/5ptvZtiwYdlkk03SsmXLtG7dOl//+tfzxBNP1Gxz1113ZauttkqSDBkypOZ2gkWvc/vtt8/GG2+cRx99NH379s2qq65a87589J7VQYMGpVmzZou9/p133jnt2rXLq6++WufXCnx2iVWgOH/84x/TtWvXbLPNNnXa/uCDD87PfvazbL755hkzZkz69euXUaNGZd99911s28mTJ2fPPffMTjvtlLPPPjvt2rXL4MGD8/TTTydJBg4cmDFjxiRJvvOd7+Saa67JueeeW6/5n3766ey6666ZN29eRo4cmbPPPjvf/va3c999933sfn/961+z88475/XXX8/w4cMzdOjQ3H///dl2220zZcqUxbbfe++98+6772bUqFHZe++9c/XVV2fEiBF1nnPgwIGpqqrK7373u5q166+/PhtuuGE233zzxbZ/4YUXMn78+Oy6664555xzcuyxx2bSpEnp169fTTj26NEjI0eOTJIceuihueaaa3LNNdekb9++NceZMWNGvv71r6dnz54599xz079//yXOd95552WNNdbIoEGDsmDBgiTJpZdemr/85S+54IILstZaa9X5tQKfYRWAgsycObOSpLLbbrvVafuJEydWklQOPvjgWuvDhg2rJKlMmDChZq1z586VJJW77767Zu3111+vVFdXV4455piatRdffLGSpDJ69Ohaxxw0aFClc+fOi81wyimnVP79r9MxY8ZUklSmT5++1LkXneOqq66qWevZs2dlzTXXrMyYMaNm7Yknnqg0atSocsABByx2vgMPPLDWMffYY49K+/btl3rOf38dLVq0qFQqlcqee+5Z2WGHHSqVSqWyYMGCSseOHSsjRoxY4nvw3nvvVRYsWLDY66iurq6MHDmyZu3hhx9e7LUt0q9fv0qSytixY5f4XL9+/Wqt3X777ZUkldNOO63ywgsvVFq2bFnZfffdP/E1Ap8frqwCRXnnnXeSJK1atarT9n/605+SJEOHDq21fswxxyTJYve2brTRRunTp0/N4zXWWCPdu3fPCy+8sMwzf9Sie11///vfZ+HChXXaZ+rUqZk4cWIGDx6c1VZbrWb9q1/9anbaaaea1/nvDjvssFqP+/TpkxkzZtS8h3Wx33775a677sprr72WCRMm5LXXXlviLQDJh/e5Nmr04X82FixYkBkzZtTc4vDYY4/V+ZzV1dUZMmRInbYdMGBAvv/972fkyJEZOHBgmjVrlksvvbTO5wI++8QqUJTWrVsnSd599906bf/SSy+lUaNG6datW631jh07pm3btnnppZdqra+77rqLHaNdu3Z56623lnHixe2zzz7Zdtttc/DBB6dDhw7Zd999c+ONN35suC6as3v37os916NHj7zxxhuZPXt2rfWPvpZ27dolSb1eyze+8Y20atUqN9xwQ6677rpstdVWi72XiyxcuDBjxozJl7/85VRXV2f11VfPGmuskSeffDIzZ86s8znXXnvten2Y6qyzzspqq62WiRMn5vzzz8+aa65Z532Bzz6xChSldevWWWuttfLUU0/Va7+PfsBpaRo3brzE9UqlssznWHQ/5SLNmzfP3Xffnb/+9a/53ve+lyeffDL77LNPdtppp8W2/TQ+zWtZpLq6OgMHDsy4ceNyyy23LPWqapKcccYZGTp0aPr27Ztrr702t99+e+6444585StfqfMV5OTD96c+Hn/88bz++utJkkmTJtVrX+CzT6wCxdl1113z/PPP54EHHvjEbTt37pyFCxfmueeeq7U+bdq0vP322zWf7F8e2rVrV+uT84t89OptkjRq1Cg77LBDzjnnnPzjH//I6aefngkTJuRvf/vbEo+9aM5nn312sef++c9/ZvXVV0+LFi0+3QtYiv322y+PP/543n333SV+KG2R3/72t+nfv3+uuOKK7LvvvhkwYEB23HHHxd6Tuv7DoS5mz56dIUOGZKONNsqhhx6aM888Mw8//PByOz5QPrEKFOe4445LixYtcvDBB2fatGmLPf/888/nvPPOS/Lhj7GTLPaJ/XPOOSdJ8s1vfnO5zbX++utn5syZefLJJ2vWpk6dmltuuaXWdm+++eZi+y76cvyPfp3WIp06dUrPnj0zbty4WvH31FNP5S9/+UvN61wR+vfvn1NPPTUXXnhhOnbsuNTtGjduvNhV25tuuimvvPJKrbVFUb2ksK+v448/Pv/6178ybty4nHPOOenSpUsGDRq01PcR+PzxSwGA4qy//vq5/vrrs88++6RHjx61foPV/fffn5tuuimDBw9Okmy66aYZNGhQLrvssrz99tvp169fHnrooYwbNy677777Ur8WaVnsu+++Of7447PHHnvkRz/6UebMmZNLLrkkG2ywQa0PGI0cOTJ33313vvnNb6Zz5855/fXXc/HFF+dLX/pStttuu6Uef/To0fn617+e3r1756CDDsrcuXNzwQUXpE2bNhk+fPhyex0f1ahRo/z0pz/9xO123XXXjBw5MkOGDMk222yTSZMm5brrrkvXrl1rbbf++uunbdu2GTt2bFq1apUWLVqkV69eWW+99eo114QJE3LxxRfnlFNOqfkqrauuuirbb799Tj755Jx55pn1Oh7w2eTKKlCkb3/723nyySez55575ve//30OP/zwnHDCCZkyZUrOPvvsnH/++TXbXn755RkxYkQefvjh/PjHP86ECRNy4okn5je/+c1ynal9+/a55ZZbsuqqq+a4447LuHHjMmrUqHzrW99abPZ11103V155ZQ4//PBcdNFF6du3byZMmJA2bdos9fg77rhj/uu//ivt27fPz372s5x11ln52te+lvvuu6/eobcinHTSSTnmmGNy++2356ijjspjjz2W2267Leuss06t7Zo0aZJx48alcePGOeyww/Kd73wnf//73+t1rnfffTcHHnhgNttss/zkJz+pWe/Tp0+OOuqonH322fnv//7v5fK6gLJVVepzJz4AAKxErqwCAFAssQoAQLHEKgAAxRKrAAAUS6wCAFAssQoAQLHEKgAAxfpc/gar5lsPa+gRAJar6feMbugRAJarltVVddrOlVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVuHfDBv0H7n36qPy+t9Oy0v/NTw3jh6cL6+7Rq1tDty9V26/5AeZNuG0zH3orLRp2Wyx47Rr3TxXjdwv0yaclql3nppLfrpXWjRvurJeBkCdXXXFZdniqxvmrF+cUbM2b968/Pz0kfmPPr2yXa/Nc+zRR2bGjDcacEq+yMQq/Js+m3fN2JvuS7+DLsiuR16aVRo3zq0XHJpVm/1faK7arGnueOCfGX31nUs9zlUjv5seXTtk1yMvy38OvSLb9eyai07ac2W8BIA6e/qpSfndTTfkyxt0r7V+9pmjcvff/5afn3VefnnVrzJ9+us59ugjG2hKvujEKvyb3Y66PNfe9kieeWFaJj03NYeO/E3W7dQum/X4Us02F/7mnpz1q7/lwaf+tcRjdO+yZnbeZsP88PSb8vDT/8r9T0zJ0LPGZ6+deqbT6q1X1ksB+Fhz5szOT08clp8OPzWtW//f303vvvtufn/LzRk67Phs3etr6bHRxjnl1FF5YuLjmfTExIYbmC+sBo3VN954I2eeeWb22GOP9O7dO717984ee+yR0aNHZ/r06Q05GiRJWv//H/G/NXNOnffptUnnvPXOnDz2zP/WrE14+LksXFjJVhuvu9xnBFgWPz99ZLbrs316fW2bWuvP/OPpfPDB+7XW11uvazp2WitPPjlxJU8JySoNdeKHH344O++8c1ZdddXsuOOO2WCDDZIk06ZNy/nnn5+f//znuf3227Plllt+7HHmzZuXefPm1VqrLPwgVY0a7KXxOVFVVZXRQ3fL/RNfzD9eeK3O+3Vo3yrT35pVa23BgoV585256dC+1fIeE6Debv/zbfnnM//INb/+7WLPzXhjepo0aZJWrWv/JKh9+/aZ8Yb7Vln5GqzojjzyyOy1114ZO3Zsqqqqaj1XqVRy2GGH5cgjj8wDDzzwsccZNWpURowYUWut8Vq902TtbZayB9TNucftka907ZgdDr2ooUcBWG5ee21qzvrFGbn4sitTXV3d0OPAJ2qw2wCeeOKJHH300YuFavLhFa2jjz46EydO/MTjnHjiiZk5c2atP6t02noFTMwXyZhhe+Qb222UnX84Nq+8PrNe+06b8W7WaNey1lrjxo2yWuvmmTbj3eU5JkC9PfOPp/PmmzPy3X0GZuvNvpKtN/tKHn3k4fzm+muy9WZfSfv2q+f999/Pu++8U2u/GTNmpP3qqzfQ1HyRNdiV1Y4dO+ahhx7KhhtuuMTnH3rooXTo0OETj1NdXb3YvwzdAsCnMWbYHvn29htnwA8uyUuvvlnv/R+c9FLatV41m224dh7/5ytJku237JZGjary8FI+lAWwsmzd62u54eY/1Fob8bOT0mW9rhk05OB06Ngpq6zSJA89+EB22GnnJMmUF1/Ia1NfzVe/2rMBJuaLrsGqbtiwYTn00EPz6KOPZocddqgJ02nTpuXOO+/ML3/5y5x11lkNNR5fUOceNzD77LxZ9hp2VWbNmVdzj+nMWXPz3rwPknx4T2qH1Vpl/XXaJ0k27tYp786el5envZW33pmbZ6e8ntvv/2cuOmmv/OjnN6fJKo0z5tg9ctMdEzP1jXeWem6AlaFFi5bp9uUNaq01b948bdq0rVnfbY//zDln/SKt27RJy5Ytc+ao0/LVTXtmk017NsDEfNFVVSqVSkOd/IYbbsiYMWPy6KOPZsGCBUmSxo0bZ4sttsjQoUOz9957L9Nxm289bHmOyRfI3IeW/A+kQ0b8Jtfe9kiS5CeHDMhPDxnwsdu0a908Y4798FaChZVKxk+YlGPOHp/Zc+evuOH5XJt+z+iGHoHPsUMP/F426N4jw44/KcmHH14ec9Yvcvufb8v8+fPTe9vtcsJPfpbVV1/jE44EddeyevFbQZekQWN1kffffz9v/P9PGK6++upp0qTJpzqeWAU+b8Qq8HlT11gt4ubOJk2apFOnTg09BgAAhfEbrAAAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIolVgEAKJZYBQCgWGIVAIBiiVUAAIq1TLF6zz33ZP/990/v3r3zyiuvJEmuueaa3Hvvvct1OAAAvtjqHas333xzdt555zRv3jyPP/545s2blySZOXNmzjjjjOU+IAAAX1z1jtXTTjstY8eOzS9/+cs0adKkZn3bbbfNY489tlyHAwDgi63esfrss8+mb9++i623adMmb7/99vKYCQAAkixDrHbs2DGTJ09ebP3ee+9N165dl8tQAACQLEOsHnLIITnqqKPy4IMPpqqqKq+++mquu+66DBs2LD/4wQ9WxIwAAHxBrVLfHU444YQsXLgwO+ywQ+bMmZO+ffumuro6w4YNy5FHHrkiZgQA4AuqqlKpVJZlx/nz52fy5MmZNWtWNtpoo7Rs2XJ5z7bMmm89rKFHAFiupt8zuqFHAFiuWlZX1Wm7el9ZXaRp06bZaKONlnV3AAD4RPWO1f79+6eqauklPGHChE81EAAALFLvWO3Zs2etx++//34mTpyYp556KoMGDVpecwEAQP1jdcyYMUtcHz58eGbNmvWpBwIAgEXq/dVVS7P//vvnyiuvXF6HAwCAZf+A1Uc98MADadas2fI63Kfy1v1nNfQIAMtVu62OaOgRAJaruY9fWKft6h2rAwcOrPW4Uqlk6tSpeeSRR3LyySfX93AAALBU9Y7VNm3a1HrcqFGjdO/ePSNHjsyAAQOW22AAAFCvWF2wYEGGDBmSTTbZJO3atVtRMwEAQJJ6fsCqcePGGTBgQN5+++0VNA4AAPyfen8bwMYbb5wXXnhhRcwCAAC11DtWTzvttAwbNiy33nprpk6dmnfeeafWHwAAWF6qKpVKpS4bjhw5Msccc0xatWr1fzv/269drVQqqaqqyoIFC5b/lPX03gcNPQHA8uWrq4DPm7p+dVWdY7Vx48aZOnVqnnnmmY/drl+/fnU68YokVoHPG7EKfN4s9+9ZXdS0JcQoAABfDPW6Z/Xff+wPAAArWr2+Z3WDDTb4xGB98803P9VAAACwSL1idcSIEYv9BisAAFhR6hWr++67b9Zcc80VNQsAANRS53tW3a8KAMDKVudYreM3XAEAwHJT59sAFi5cuCLnAACAxdT7160CAMDKIlYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKtUpDDwClu/E31+fGG36dV195JUmyfrcv5/s/+GG269OvZpsnJj6eC84bk0mTnkzjRo3SfcMeueSyK9KsWbOGGhsgSTLswAHZ/T82zQZdOmTuvPfz4BMv5Cfn/T7PvfR6zTYHDtw2+3x9y/Tc8Etp3bJ5OvY5NjNnzV3i8Zo2WSV3XzMsm3b/UnrtMypP/s8rK+ul8AXlyip8gjU7dMxRRw/Lr2/6Xa6/8eZs3etrOeqIwzN58nNJPgzVH37/4PTeZrtc95ubcv0Nv82++303jRr5vxfQ8Pps3i1jb7g7/Q44K7v+4MKsskrj3HrJEVm1WdOabVZt1iR33P+PjL7yL594vDN+vFumTp+5IkeGWlxZhU+wff//qPX4yKOOzo2/+XWefGJiunX7ckb/YlS+893v5aBDDq3Zpst6XVf2mABLtNsRF9d6fOgp1+blCT/PZhutk/seez5JcuH1dyVJ+mzx5Y891oBtN8oOX+uR7xx7eXbZ7isrZF74KJd+oB4WLFiQP//ptsydOyebbrpZZsyYkUlPPpHV2rfPAd/dN/37bpMDB+2fxx59pKFHBVii1i0/vD3prZlz6rXfmqu1ysUnfycHnfyrzJk7f0WMBktUdKy+/PLLOfDAAz92m3nz5uWdd96p9WfevHkraUK+KJ77n2fztS03y1abbZLTR56SMedflPW7dcsr//tykmTsRRdm4J575eJLL0+PHhvl0IMG56WXpjTs0AAfUVVVldHD9sz9jz+ffzw/tV77XjZy//zyt/fmsX/8awVNB0tWdKy++eabGTdu3MduM2rUqLRp06bWn9G/GLWSJuSLokuX9XLjzeNz7a9vzF77fCcnn3R8np88OQsXLkyS7Ln3Ptl9j/9Mjx4b5dgTTkqX9dbL+N/d3MBTA9R27ol75yvdOuWAE66q134//E6/tFq1WZ3uaYXlrUHvWf3DH/7wsc+/8MILn3iME088MUOHDq21Vmlc/anmgo9q0rRp1u3cOUmy0Vc2ztNPTcp11/4qBx58SJKk6/rr19p+va7r57Wpr670OQGWZszxe+UbfTbOjgedm1def7te+26/1Qbp9dX1MvPBc2ut33fdcfnNnx/JIT+7ZvkNCh/RoLG6++67p6qqKpVKZanbVFVVfewxqqurU11dO07f+2C5jAdLtXDhwrw/f37WXvtLWWPNNTPlxRdrPf/SlCnZrk/fBpoOoLYxx++Vb//HphlwyHl56dUZ9d7/mDN/m+EX3VrzuNMabXLrJUfkeydclYcnTVmOk8LiGjRWO3XqlIsvvji77bbbEp+fOHFitthii5U8FdR23pizs12fvunYqVPmzJ6dP912ax55+KFcctkVqaqqyuAhB+WSiy5I9+4bpvuGPfKH39+SKS++kLPHnN/QowPk3BP3zj5f3zJ7HX1ZZs1+Lx3at0qSzJz1Xt6b936SpEP7VunQvnXWX3f1JMnGX14r785+Ly+/9lbeemdOXn7trVrHnDXnw8+GvPDy9HpfpYX6atBY3WKLLfLoo48uNVY/6aorrAxvvjkjPz3x+Eyf/npatmqVDTbonksuuyK9t9k2SbL/AYMzb978jD5zVGbOnJnu3TfM2F9emXXWXbeBJwdIvr/3hz/luePyH9daP+Rn1+TaPz6YJDl4zz756WHfqHnur1cevdg20FCqKg1Yg/fcc09mz56dXXbZZYnPz549O4888kj69eu3xOeXxm0AwOdNu62OaOgRAJaruY9fWKftGjRWVxSxCnzeiFXg86ausVr0V1cBAPDFJlYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKJVYBACiWWAUAoFhiFQCAYolVAACKVVWpVCoNPQR8Fs2bNy+jRo3KiSeemOrq6oYeB+BT8/caJRKrsIzeeeedtGnTJjNnzkzr1q0behyAT83fa5TIbQAAABRLrAIAUCyxCgBAscQqLKPq6uqccsopPoQAfG74e40S+YAVAADFcmUVAIBiiVUAAIolVgEAKJZYBQCgWGIVltFFF12ULl26pFmzZunVq1ceeuihhh4JYJncfffd+da3vpW11lorVVVVGT9+fEOPBDXEKiyDG264IUOHDs0pp5ySxx57LJtuuml23nnnvP766w09GkC9zZ49O5tuumkuuuiihh4FFuOrq2AZ9OrVK1tttVUuvPDCJMnChQuzzjrr5Mgjj8wJJ5zQwNMBLLuqqqrccsst2X333Rt6FEjiyirU2/z58/Poo49mxx13rFlr1KhRdtxxxzzwwAMNOBkAfP6IVainN954IwsWLEiHDh1qrXfo0CGvvfZaA00FAJ9PYhUAgGKJVain1VdfPY0bN860adNqrU+bNi0dO3ZsoKkA4PNJrEI9NW3aNFtssUXuvPPOmrWFCxfmzjvvTO/evRtwMgD4/FmloQeAz6KhQ4dm0KBB2XLLLbP11lvn3HPPzezZszNkyJCGHg2g3mbNmpXJkyfXPH7xxRczceLErLbaall33XUbcDLw1VWwzC688MKMHj06r732Wnr27Jnzzz8/vXr1auixAOrtrrvuSv/+/RdbHzRoUK6++uqVPxD8G7EKAECx3LMKAECxxCoAAMUSqwAAFEusAgBQLLEKAECxxCoAAMUSqwAAFEusAgBQLLEKUJjBgwdn9913r3m8/fbb58c//vFKn+Ouu+5KVVVV3n777ZV+boBFxCpAHQ0ePDhVVVWpqqpK06ZN061bt4wcOTIffPDBCj3v7373u5x66ql12lZgAp83qzT0AACfJbvsskuuuuqqzJs3L3/6059y+OGHp0mTJjnxxBNrbTd//vw0bdp0uZxztdVWWy7HAfgscmUVoB6qq6vTsWPHdO7cOT/4wQ+y44475g9/+EPNj+5PP/30rLXWWunevXuS5OWXX87ee++dtm3bZrXVVstuu+2WKVOm1BxvwYIFGTp0aNq2bZv27dvnuOOOS6VSqXXOj94GMG/evBx//PFZZ511Ul1dnW7duuWKK67IlClT0r9//yRJu3btUlVVlcGDBydJFi5cmFGjRmW99dZL8+bNs+mmm+a3v/1trfP86U9/ygYbbJDmzZunf//+teYEaChiFeBTaN68eebPn58kufPOO/Pss8/mjjvuyK233pr3338/O++8c1q1apV77rkn9913X1q2bJlddtmlZp+zzz47V199da688srce++9efPNN3PLLbd87DkPOOCA/PrXv87555+fZ555JpdeemlatmyZddZZJzfffHOS5Nlnn83UqVNz3nnnJUlGjRqVX/3qVxk7dmyefvrpHH300dl///3z97//PcmHUT1w4MB861vfysSJE3PwwQfnhBNOWFFvG0CduQ0AYBlUKpXceeeduf3223PkkUdm+vTpadGiRS6//PKaH/9fe+21WbhwYS6//PJUVVUlSa666qq0bds2d911VwYMGJBzzz03J554YgYOHJgkGTt2bG6//falnvd//ud/cuONN+aOO+7IjjvumCTp2rVrzfOLbhlYc80107Zt2yQfXok944wz8te//jW9e/eu2efee+/NpZdemn79+uWSSy7J+uuvn7PPPjtJ0r1790yaNCm/+MUvluO7BlB/YhWgHm699da0bNky77//fhYuXJj99tsvw4cPz+GHH55NNtmk1n2qTzzxRCZPnpxWrVrVOsZ7772X559/PjNnzszUqVPTq1evmudWWWWVbLnllovdCrDIxIkT07hx4/Tr16/OM0+ePDlz5szJTjvtVGt9/vz52WyzzZIkzzzzTK05ktSELUBDEqsA9dC/f/9ccskladq0adZaa62sssr//TXaokWLWtvOmjUrW2yxRa677rrFjrPGGmss0/mbN29e731mzZqVJLntttuy9tpr13quurp6meYAWFnEKkA9tGjRIt26davTtptvvnluuOGGrLnmmmnduvUSt+nUqVMefPDB9O3bN0nywQcf5NFHH83mm2++xO032WSTLFy4MH//+99rbgP4d4uu7C5YsKBmbaONNkp1dXX+9a9/LfWKbI8ePfKHP/yh1tp///d/f/KLBFjBfMAKYAX57ne/m9VXXz277bZb7rnnnrz44ou566678qMf/Sj/+7//myQ56qij8vOf/zzjx4/PP//5z/zwhz/82O9I7dKlSwYNGpQDDzww48ePrznmjTfemCTp3Llzqqqqcuutt2b69OmZNWtWWrVqlWHDhuXoo4/OuHHj8vzzz+exxx7LBRdckHHjxiVJDjvssDz33HM59thj8+yzz+b666/P1VdfvaLfIoBPJFYBVpBVV101d999d9Zdd90MHDgwPXr0yEEHHZT33nuv5krrMccck+9973sZNGhQevfunVatWmWPPfb42ONecskl2XPPPfPDH/4wG264YQ455JDMnj07SbL22mtnxIgROeGEE9KhQ4ccccQRSZJTTz01J598ckaNGpUePXpkl112yW233Zb11lsvSbLuuuvm5ptvzvjx47Pppptm7NixOeOMM1bguwNQN1WVpd3FDwAADcyVVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBYYhUAgGKJVQAAiiVWAQAollgFAKBY/w/2G/DuKBc0ZAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "y_pred = best_clf.predict(X_test)\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}