machine_learning/SportsClassifierML2.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 23,
      "id": "d7557d2a",
      "metadata": {
        "id": "d7557d2a"
      },
      "outputs": [],
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import train_test_split, cross_val_score, validation_curve, StratifiedKFold\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.svm import LinearSVC, SVC\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import classification_report\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "id": "5eb03fd6",
      "metadata": {
        "id": "5eb03fd6"
      },
      "outputs": [],
      "source": [
        "enc = LabelEncoder()\n",
        "\n",
        "sports_tweets = pd.read_csv(\"CleanedSportsTweets2.csv\")\n",
        "\n",
        "# Encode the Sport feature using a new column labeled \"Sport_Cat\"\n",
        "sports_tweets[\"Sport_Cat\"] = enc.fit_transform(sports_tweets[\"Sport\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "id": "8ae97678",
      "metadata": {
        "id": "8ae97678"
      },
      "outputs": [],
      "source": [
        "X = sports_tweets[\"Tweet\"]\n",
        "y = sports_tweets[\"Sport_Cat\"]\n",
        "\n",
        "# Create the Vectorizer that uses both unigrams and bigrams with tuple (1, 2)\n",
        "tfidf = TfidfVectorizer(max_features=1000, ngram_range=(1, 2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "id": "908c40bc",
      "metadata": {
        "id": "908c40bc"
      },
      "outputs": [],
      "source": [
        "# Create x_fit which holds the fitted x to include those unigrams and bigrams\n",
        "X_fit = tfidf.fit_transform(X)\n",
        "\n",
        "# Use Stratified K Fold with 10 folds to use for cross validation\n",
        "skfold = StratifiedKFold(n_splits = 10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "id": "ac4a02bc",
      "metadata": {
        "id": "ac4a02bc"
      },
      "outputs": [],
      "source": [
        "# Create the classifiers\n",
        "lin_svc = LinearSVC()\n",
        "rbf_svc = SVC()\n",
        "knn = KNeighborsClassifier()\n",
        "log_reg = LogisticRegression()\n",
        "rfc = RandomForestClassifier(n_estimators=50)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "id": "66aec321",
      "metadata": {
        "id": "66aec321"
      },
      "outputs": [],
      "source": [
        "def average(arr) -> float:\n",
        "    # Returns the average of the array, arr, as a float\n",
        "    return sum(arr) / len(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "id": "a27e4c35",
      "metadata": {
        "id": "a27e4c35"
      },
      "outputs": [],
      "source": [
        "# Split the data with an 80-20% split for training and testing where the model exclusively uses the 80% training data\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X_fit, y, test_size=0.2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "id": "9dceb86b",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9dceb86b",
        "outputId": "7570d1fd-e7de-4f8c-c629-e1b6a40cbc37"
      },
      "outputs": [],
      "source": [
        "# Test each classifier with cross validation using Stratified K Fold with the 80% training data\n",
        "lin_svc_scores = cross_val_score(lin_svc, X_train, y_train, cv=skfold)\n",
        "rbf_svc_scores = cross_val_score(rbf_svc, X_train, y_train, cv=skfold)\n",
        "knn_scores = cross_val_score(knn, X_train, y_train, cv=skfold)\n",
        "log_reg_scores = cross_val_score(log_reg, X_train, y_train, cv=skfold)\n",
        "rfc_scores = cross_val_score(rfc, X_train, y_train, cv=skfold)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "id": "06838a33",
      "metadata": {
        "id": "06838a33"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'Random Forest Classifier'"
            ]
          },
          "execution_count": 31,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create functions to choose the highest performing model\n",
        "def choose_classifier(lin_svc, rbf_svc, knn, log_reg, rfc):\n",
        "    empty_dict = {}\n",
        "    empty_dict[\"lin_svc\"] = average(lin_svc_scores)\n",
        "    empty_dict[\"rbf_svc\"] = average(rbf_svc_scores)\n",
        "    empty_dict[\"knn\"] = average(knn_scores)\n",
        "    empty_dict[\"log\"] = average(log_reg_scores)\n",
        "    empty_dict[\"rfc\"] = average(rfc_scores)\n",
        "\n",
        "    return string_to_classifier(max(empty_dict, key=empty_dict.get))\n",
        "\n",
        "def string_to_classifier(string):\n",
        "    if string == \"lin_svc\":\n",
        "        return \"Linear SVC Classifier\"\n",
        "    elif string == \"rbf_svc\":\n",
        "        return \"RBF Kernel SVM Classifier\"\n",
        "    elif string == \"knn\":\n",
        "        return \"K-Nearest Neighbors Classifier\"\n",
        "    elif string == \"log\":\n",
        "        return \"Logarithmic Regression Classifier\"\n",
        "    elif string == \"rfc\":\n",
        "        return \"Random Forest Classifier\"\n",
        "# Choose correct classifier with the highest average score\n",
        "classifier_str = choose_classifier(lin_svc, rbf_svc, knn, log_reg, rfc)\n",
        "classifier_str"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "id": "da74fafd",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Since the Random Forest Classifier was the highest performing model\n",
        "# We need to tune the hyperparameters for it to return the highest accuracy with 3 folds\n",
        "# Specifically the n_estimaters paramater will be used to find the correct one\n",
        "\n",
        "n_estimators = [10, 30, 50, 75, 100, 200, 300, 400, 500]\n",
        "\n",
        "train_scores_n_estimators, test_scores_n_estimators = validation_curve(\n",
        "                                RandomForestClassifier(),\n",
        "                                X = X_train, y = y_train, \n",
        "                                param_name = 'n_estimators', \n",
        "                                param_range = n_estimators, cv = 3)\n",
        "\n",
        "# Create a list of hyperparamaters to use\n",
        "chosen_hyperparameters = []\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "id": "01a3925c",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Create a graph plotting these scores\n",
        "train_scores_mean_n_estimators = np.mean(train_scores_n_estimators, axis=1)\n",
        "train_scores_std_n_estimators = np.std(train_scores_n_estimators, axis=1)\n",
        "test_scores_mean_n_estimators = np.mean(test_scores_n_estimators, axis=1)\n",
        "test_scores_std_n_estimators = np.std(test_scores_n_estimators, axis=1)\n",
        "\n",
        "\n",
        "plt.title(\"Validation Curve with Random Forest N_Estimators\")\n",
        "plt.xlabel(r\"$\\gamma$\")\n",
        "plt.ylabel(\"Score\")\n",
        "plt.ylim(0.79, 1.0)\n",
        "lw = 2\n",
        "plt.semilogx(\n",
        "    n_estimators, train_scores_mean_n_estimators, label=\"Training score\", color=\"darkorange\", lw=lw\n",
        ")\n",
        "plt.fill_between(\n",
        "    n_estimators,\n",
        "    train_scores_mean_n_estimators - train_scores_std_n_estimators,\n",
        "    train_scores_mean_n_estimators + train_scores_std_n_estimators,\n",
        "    alpha=0.2,\n",
        "    color=\"darkorange\",\n",
        "    lw=lw,\n",
        ")\n",
        "plt.semilogx(\n",
        "    n_estimators, test_scores_mean_n_estimators, label=\"Cross-validation score\", color=\"navy\", lw=lw\n",
        ")\n",
        "plt.fill_between(\n",
        "    n_estimators,\n",
        "    test_scores_mean_n_estimators - test_scores_std_n_estimators,\n",
        "    test_scores_mean_n_estimators + test_scores_std_n_estimators,\n",
        "    alpha=0.2,\n",
        "    color=\"navy\",\n",
        "    lw=lw,\n",
        ")\n",
        "plt.legend(loc=\"best\")\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "id": "48a8f2ca",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "400"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Within the graph above we can see that the score stabilizes after the n_estimators count reaches around 100\n",
        "# So any n_estimators after 100 will sufifce but we will grab the highest score just to be safe\n",
        "# Gets the index of the highest n_estimator\n",
        "list_test_score_mean_n_estimators = test_scores_mean_n_estimators.tolist()\n",
        "max_index = list_test_score_mean_n_estimators.index(max(list_test_score_mean_n_estimators))\n",
        "\n",
        "# Assign chosen_n_estimator to be equal to the highest performing n_estimator\n",
        "chosen_n_estimator = n_estimators[max_index]\n",
        "\n",
        "chosen_hyperparameters.append(chosen_n_estimator)\n",
        "\n",
        "chosen_n_estimator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "id": "7e96d282",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Performing similar actions for max_depth hyperparameter\n",
        "max_depths = [25, 30, 40, 45, 50, 60, 65, 75, 80, 90, 100]\n",
        "\n",
        "train_scores_depth, test_scores_depth = validation_curve(\n",
        "                                RandomForestClassifier(),\n",
        "                                X = X_train, y = y_train, \n",
        "                                param_name = 'max_depth', \n",
        "                                param_range = max_depths, cv = 5)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "id": "6783761f",
      "metadata": {},
      "outputs": [],
      "source": [
        "test_scores_mean_depth = np.mean(test_scores_depth, axis=1)\n",
        "\n",
        "list_test_score_mean_depth = test_scores_mean_depth.tolist()\n",
        "max_index = list_test_score_mean_depth.index(max(list_test_score_mean_depth))\n",
        "\n",
        "chosen_hyperparameters.append(max_depths[max_index])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "id": "2f5cfc54",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Performing similar actions for min_samples_split hyperparameter\n",
        "min_sample_splits = [1, 2, 3, 5, 10, 15, 20, 25, 30]\n",
        "\n",
        "train_scores_split, test_scores_split = validation_curve(\n",
        "                                RandomForestClassifier(),\n",
        "                                X = X_train, y = y_train, \n",
        "                                param_name = 'min_samples_split', \n",
        "                                param_range = min_sample_splits, cv = 5)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "90852b7f",
      "metadata": {},
      "outputs": [],
      "source": [
        "test_scores_mean_split = np.mean(test_scores_split, axis=1)\n",
        "\n",
        "list_test_score_mean_split = test_scores_mean_split.tolist()\n",
        "max_index = list_test_score_mean_split.index(max(list_test_score_mean_split))\n",
        "\n",
        "chosen_hyperparameters.append(min_sample_splits[max_index])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "id": "b411f127",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Performing similar actions for min_samples_leaf hyperparameter\n",
        "min_sample_leafs = [1, 2, 3, 4, 5, 6, 7, 8, 10, 15]\n",
        "\n",
        "train_scores_leafs, test_scores_leafs = validation_curve(\n",
        "                                RandomForestClassifier(),\n",
        "                                X = X_train, y = y_train, \n",
        "                                param_name = 'min_samples_leaf', \n",
        "                                param_range = min_sample_leafs, cv = 5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "id": "bfc3083a",
      "metadata": {},
      "outputs": [],
      "source": [
        "train_score_mean_leafs = np.mean(train_scores_leafs, axis=1)\n",
        "test_scores_mean_leafs = np.mean(test_scores_leafs, axis=1)\n",
        "\n",
        "list_test_score_mean_leafs = test_scores_mean_leafs.tolist()\n",
        "max_index = list_test_score_mean_leafs.index(max(list_test_score_mean_leafs))\n",
        "\n",
        "chosen_hyperparameters.append(min_sample_leafs[max_index])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "id": "95d2b433",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create the Random Forest Classifier with the selected n_estimator hyperparameter\n",
        "classifier = RandomForestClassifier(n_estimators=chosen_hyperparameters[0], max_depth=chosen_hyperparameters[1], min_samples_split=chosen_hyperparameters[2], min_samples_leaf=chosen_hyperparameters[3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "id": "25dbae7c",
      "metadata": {
        "id": "25dbae7c"
      },
      "outputs": [],
      "source": [
        "# Use the training data to fit the chosen classifier model \n",
        "X = classifier.fit(X_train, y_train)\n",
        "X.score(X_test, y_test)\n",
        "\n",
        "# Use the model to predict the testing data\n",
        "y_pred = classifier.predict(X_test)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "id": "dab30a1f",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dab30a1f",
        "outputId": "079fc331-755b-4846-c8b0-fc27e5d3fb1f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.84      0.66      0.74       191\n",
            "           1       0.96      0.73      0.83        71\n",
            "           2       0.78      0.98      0.87       461\n",
            "           3       0.98      0.70      0.81        82\n",
            "           4       0.89      0.67      0.77       163\n",
            "\n",
            "    accuracy                           0.83       968\n",
            "   macro avg       0.89      0.75      0.81       968\n",
            "weighted avg       0.84      0.83      0.82       968\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Compare the predictions to the actual output/label\n",
        "print(classification_report(y_test, y_pred))"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "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.1"
    },
    "vscode": {
      "interpreter": {
        "hash": "5238573367df39f7286bb46f9ff5f08f63a01a80960060ce41e3c79b190280fa"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}