5.1.Dep_parsing_classifier.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# ***Setup***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [],
            "source": [
                "import matplotlib.pyplot as plt\n",
                "\n",
                "import numpy as np\n",
                "\n",
                "import pandas as pd\n",
                "\n",
                "import pickle\n",
                "\n",
                "from sklearn.feature_selection import SelectKBest, chi2\n",
                "from sklearn.feature_extraction.text import TfidfVectorizer\n",
                "from sklearn.naive_bayes import MultinomialNB\n",
                "from sklearn.model_selection import train_test_split\n",
                "from sklearn.metrics import accuracy_score, classification_report\n",
                "\n",
                "from tabulate import tabulate"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "import sys\n",
                "import os\n",
                "parent_dir = os.path.abspath('..')\n",
                "sys.path.append(parent_dir)\n",
                "from constants import CONSTANTS\n",
                "%load_ext autoreload\n",
                "%autoreload 2"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## ***Load dataset***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [],
            "source": [
                "train_df = pd.read_csv(CONSTANTS.AUGMENTED_TRAIN_SET_PATH)\n",
                "test_df = pd.read_csv(CONSTANTS.AUGMENTED_TEST_SET_PATH)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## ***Load dep. parsing results***\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [
                {
                    "name": "stderr",
                    "output_type": "stream",
                    "text": [
                        "C:\\Users\\TOSHIBA\\AppData\\Roaming\\Python\\Python39\\site-packages\\networkx\\utils\\backends.py:135: RuntimeWarning: networkx backend defined more than once: nx-loopback\n",
                        "  backends.update(_get_backends(\"networkx.backends\"))\n"
                    ]
                }
            ],
            "source": [
                "with open(CONSTANTS.DEP_PARSED_TEXTS_OBJECT_PATH, 'rb') as f:\n",
                "    loaded_data = pickle.load(f)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## ***Helper functions***"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Get processed text by row id***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Each sentence in the dataset has an id, and a document contain its stanza processing\n",
                "def get_doc_by_id(target_id):\n",
                "    for obj in loaded_data:\n",
                "        if obj[\"id\"] == target_id:\n",
                "            return obj[\"processed_text\"]\n",
                "    return None  # Return None if not found"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Features extraction***\n",
                "**Dependency Relation Tuples:**  \n",
                "`(head_word, dependent_word, dependency_relation)`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "def extract_dependency_features(row_id):\n",
                "    doc = get_doc_by_id(row_id)\n",
                "    feature_tuples = []\n",
                "    for sentence in doc.sentences:\n",
                "        for word in sentence.words:\n",
                "            # Dependency relation tuples\n",
                "            if word.head > 0:  # If not root\n",
                "                head = sentence.words[word.head - 1]  # Adjust head index\n",
                "                feature_tuples.append((head.lemma, word.lemma, word.deprel))\n",
                "    return feature_tuples\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "- **Dependency Relation Tuples:**  \n",
                "`(head_word, dependent_word, dependency_relation)`  \n",
                "- **POS Tag Tuples:**  \n",
                "`(head_pos, dependent_pos, dependency_relation)`\n",
                "- **Root Word Relation Tuple**  \n",
                "`(root_word, \"ROOT\")`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [],
            "source": [
                "def extract_full_features(row_id):\n",
                "    doc = get_doc_by_id(row_id)\n",
                "    feature_tuples = []\n",
                "    for sentence in doc.sentences:\n",
                "        for word in sentence.words:\n",
                "            # Dependency relation tuples\n",
                "            if word.head > 0:  # If not root\n",
                "                head = sentence.words[word.head - 1]  # Adjust head index\n",
                "                feature_tuples.append((head.lemma, word.lemma, word.deprel))                \n",
                "                \n",
                "                # POS tag tuples\n",
                "                feature_tuples.append((head.upos, word.upos, word.deprel))\n",
                "            \n",
                "            # Root word tuple\n",
                "            if word.deprel == \"root\":\n",
                "                feature_tuples.append((word.lemma, \"ROOT\"))\n",
                "    \n",
                "    return feature_tuples"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Features extraction***\n",
                "**Dependency Relation Tuples:**  \n",
                "- `(head_word, dependent_word, dependency_relation)`\n",
                "- `n1 -> n2 grams`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [],
            "source": [
                "def extract_dependency_features_with_n_grams(row_id, n1=1, n2=2):\n",
                "    doc = get_doc_by_id(row_id)\n",
                "    feature_tuples = set()  # Use a set to avoid duplicates\n",
                "    \n",
                "    # Extract dependency relations\n",
                "    for sentence in doc.sentences:\n",
                "        for word in sentence.words:\n",
                "            # Dependency relation tuples\n",
                "            if word.head > 0:  # If not root\n",
                "                head = sentence.words[word.head - 1]  # Adjust head index\n",
                "                feature_tuples.add((head.lemma, word.lemma, word.deprel))\n",
                "    \n",
                "    # Extract n-grams from n1 to n2\n",
                "    for sentence in doc.sentences:\n",
                "        words = [word.lemma for word in sentence.words]\n",
                "        \n",
                "        for n in range(n1, n2 + 1):  # Loop from n1 to n2 inclusive\n",
                "            for i in range(len(words) - n + 1):\n",
                "                n_gram = tuple(words[i:i+n])  # Create a tuple for the n-gram\n",
                "                feature_tuples.add(n_gram)\n",
                "    \n",
                "    return feature_tuples"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### ***Usage example***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "The skin on my palms and soles is thickened and has deep cracks. These cracks are painful and bleed easily.\n"
                    ]
                }
            ],
            "source": [
                "print(train_df[train_df[\"Id\"] == 5][\"text\"].to_list()[0])"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "[('skin', 'the', 'det'),\n",
                            " ('thicken', 'skin', 'nsubj'),\n",
                            " ('palm', 'on', 'case'),\n",
                            " ('palm', 'my', 'nmod:poss'),\n",
                            " ('skin', 'palm', 'nmod'),\n",
                            " ('sole', 'and', 'cc'),\n",
                            " ('palm', 'sole', 'conj'),\n",
                            " ('thicken', 'be', 'cop'),\n",
                            " ('have', 'and', 'cc'),\n",
                            " ('thicken', 'have', 'conj'),\n",
                            " ('crack', 'deep', 'amod'),\n",
                            " ('have', 'crack', 'obj'),\n",
                            " ('thicken', '.', 'punct'),\n",
                            " ('crack', 'this', 'det'),\n",
                            " ('painful', 'crack', 'nsubj'),\n",
                            " ('painful', 'be', 'cop'),\n",
                            " ('bleed', 'and', 'cc'),\n",
                            " ('painful', 'bleed', 'conj'),\n",
                            " ('bleed', 'easily', 'advmod'),\n",
                            " ('painful', '.', 'punct')]"
                        ]
                    },
                    "execution_count": 10,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "extract_dependency_features(5)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Flatten tuples into strings***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Flatten tuples into strings\n",
                "def flatten_tuples(features):\n",
                "    return ['_'.join(map(str, t)) for t in features]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Features selection***\n",
                "- Using `SelectKBest`"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [],
            "source": [
                "def select_features(X_train, X_test, y_train, scorer, k_value):\n",
                "\n",
                "    # Apply features selection\n",
                "    selector = SelectKBest(score_func=scorer, k=k_value)\n",
                "    X_train_selected = selector.fit_transform(X_train, y_train)\n",
                "    X_test_selected = selector.transform(X_test)\n",
                "    return X_train_selected, X_test_selected    \n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Plot train, and test accuracies vs number_of_features***\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "metadata": {},
            "outputs": [],
            "source": [
                "def plot_accuracies(X_train, X_test, y_train, y_test, model):\n",
                "    train_accuracies = []\n",
                "    test_accuracies = []\n",
                "    features_counts = []\n",
                "    for i in range(500, 26501, 500):\n",
                "        X_train_selected, X_test_selected = select_features(X_train, X_test, y_train, chi2, i)\n",
                "        model.fit(X_train_selected, y_train)\n",
                "        \n",
                "        # Training set acc\n",
                "        y_train_pred = model.predict(X_train_selected)\n",
                "        train_accuracy = accuracy_score(y_train, y_train_pred)\n",
                "        train_accuracies.append(train_accuracy)\n",
                "\n",
                "        # Testing set acc\n",
                "        y_pred = model.predict(X_test_selected)\n",
                "        test_accuracy = accuracy_score(y_test, y_pred)\n",
                "        test_accuracies.append(test_accuracy)\n",
                "\n",
                "        features_counts.append(i)\n",
                "\n",
                "    # Plotting the accuracies\n",
                "    plt.figure(figsize=(10, 6))\n",
                "    plt.plot(features_counts, train_accuracies, label='Train Accuracy', marker='.')\n",
                "    plt.plot(features_counts, test_accuracies, label='Test Accuracy', marker='.')\n",
                "    plt.title('Train and Test Accuracy vs Number of Features')\n",
                "    plt.xlabel('Number of Features Selected')\n",
                "    plt.ylabel('Accuracy')\n",
                "    plt.legend()\n",
                "    plt.grid()\n",
                "\n",
                "    # Finding closest points (3)\n",
                "    differences = np.abs(np.array(train_accuracies) - np.array(test_accuracies))\n",
                "    closest_indices = np.argsort(differences)[:3]  # indices of the three smallest differences\n",
                "    colors = ['darkgreen', 'mediumseagreen', 'lightgreen']\n",
                "\n",
                "    # Draw a rect\n",
                "    for i, idx in enumerate(closest_indices):\n",
                "        x = features_counts[idx] - 5\n",
                "        y_bottom = min(train_accuracies[idx], test_accuracies[idx])\n",
                "        y_top = max(train_accuracies[idx], test_accuracies[idx])\n",
                "        height = y_top - y_bottom\n",
                "\n",
                "        plt.gca().add_patch(plt.Rectangle(\n",
                "            (x, y_bottom), 10, height,\n",
                "            color=colors[i], alpha=0.5\n",
                "        ))\n",
                "        \n",
                "        # Print the number of selected features for each closest point\n",
                "        print(f\"Closest Point {i+1}: Number of Features = {features_counts[idx]}, Train Accuracy = {train_accuracies[idx]}, Test Accuracy = {test_accuracies[idx]}\")\n",
                "\n",
                "\n",
                "    plt.show()    "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Evaluate model***\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {},
            "outputs": [],
            "source": [
                "def print_clf_report_as_table(report):\n",
                "    data = []\n",
                "    for key, value in report.items():\n",
                "        if key != 'accuracy' and key != 'macro avg' and key != 'weighted avg':\n",
                "            data.append([key, value['precision'], value['recall'], value['f1-score'], value['support']])\n",
                "\n",
                "    data.append(['accuracy', '', '', report['accuracy'], ''])\n",
                "\n",
                "    data.append(['macro avg', report['macro avg']['precision'], report['macro avg']['recall'], report['macro avg']['f1-score'], ''])\n",
                "\n",
                "    data.append(['weighted avg', report['weighted avg']['precision'], report['weighted avg']['recall'], report['weighted avg']['f1-score'], ''])\n",
                "\n",
                "    print(tabulate(data, headers=['Class', 'Precision', 'Recall', 'F1-score', 'Support'], tablefmt='psql'))"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 15,
            "metadata": {},
            "outputs": [],
            "source": [
                "def evaluate_model(X_train, X_test, y_train, y_test, scorer, k_value, model):\n",
                "    X_train_selected, X_test_selected = select_features(X_train, X_test, y_train, scorer, k_value)\n",
                "    model.fit(X_train_selected, y_train)\n",
                "        \n",
                "    # Training set acc\n",
                "    y_train_pred = model.predict(X_train_selected)\n",
                "    train_accuracy = accuracy_score(y_train, y_train_pred)\n",
                "\n",
                "    # Testing set acc\n",
                "    y_pred = model.predict(X_test_selected)\n",
                "    test_accuracy = accuracy_score(y_test, y_pred)\n",
                "\n",
                "    print(f'Train Accuracy: {train_accuracy}')\n",
                "    print(f'Test Accuracy: {test_accuracy}')\n",
                "    print(f'Difference: {train_accuracy-test_accuracy}')    \n",
                "    # Print classification report\n",
                "    report = classification_report(y_test, y_pred, output_dict=True)\n",
                "    print_clf_report_as_table(report)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# ***Use Dependency Relation Features***"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## ***Apply features extraction on the dataset***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 16,
            "metadata": {},
            "outputs": [],
            "source": [
                "train_df[\"features\"] = train_df[\"Id\"].apply(extract_dependency_features)\n",
                "test_df[\"features\"] = test_df[\"Id\"].apply(extract_dependency_features)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Flatten and Vectorize Tuples***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 17,
            "metadata": {},
            "outputs": [],
            "source": [
                "all_features_train = train_df['features'].apply(flatten_tuples)\n",
                "all_features_flat_train = [' '.join(features) for features in all_features_train]\n",
                "\n",
                "all_features_test = test_df['features'].apply(flatten_tuples)\n",
                "all_features_flat_test = [' '.join(features) for features in all_features_test]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "#### ***Vectorize the features***\n",
                "- **This will be done using `TF-IDF`**"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 18,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Train set shape after features extraction: (4320, 26869)\n",
                        "Test set shape after features extraction: (480, 26869)\n"
                    ]
                }
            ],
            "source": [
                "vectorizer = TfidfVectorizer()\n",
                "X_train = vectorizer.fit_transform(all_features_flat_train)\n",
                "X_test = vectorizer.transform(all_features_flat_test)\n",
                "print(f\"Train set shape after features extraction: {X_train.shape}\")\n",
                "print(f\"Test set shape after features extraction: {X_test.shape}\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 19,
            "metadata": {},
            "outputs": [],
            "source": [
                "y_train = train_df[\"label\"]\n",
                "y_test = test_df[\"label\"]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## ***Select best number of features***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 20,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Closest Point 1: Number of Features = 500, Train Accuracy = 0.7800925925925926, Test Accuracy = 0.7166666666666667\n",
                        "Closest Point 2: Number of Features = 1000, Train Accuracy = 0.8694444444444445, Test Accuracy = 0.79375\n",
                        "Closest Point 3: Number of Features = 20000, Train Accuracy = 0.9944444444444445, Test Accuracy = 0.8979166666666667\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1000x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "model = MultinomialNB()\n",
                "plot_accuracies(X_train, X_test, y_train, y_test, model)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### ***Tune model's hyperparameters to reduce OF***\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 21,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Closest Point 1: Number of Features = 17500, Train Accuracy = 1.0, Test Accuracy = 0.9604166666666667\n",
                        "Closest Point 2: Number of Features = 18000, Train Accuracy = 1.0, Test Accuracy = 0.9604166666666667\n",
                        "Closest Point 3: Number of Features = 20500, Train Accuracy = 0.9997685185185186, Test Accuracy = 0.9583333333333334\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1000x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "model = MultinomialNB(alpha=0.01)\n",
                "plot_accuracies(X_train, X_test, y_train, y_test, model)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## ***Evaluate best model***"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 22,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Train Accuracy: 0.999537037037037\n",
                        "Test Accuracy: 0.9520833333333333\n",
                        "Difference: 0.04745370370370372\n",
                        "+---------------------------------+--------------------+--------------------+------------+-----------+\n",
                        "| Class                           | Precision          | Recall             |   F1-score | Support   |\n",
                        "|---------------------------------+--------------------+--------------------+------------+-----------|\n",
                        "| Acne                            | 1.0                | 1.0                |   1        | 21.0      |\n",
                        "| Arthritis                       | 1.0                | 1.0                |   1        | 20.0      |\n",
                        "| Bronchial Asthma                | 0.9444444444444444 | 0.8947368421052632 |   0.918919 | 19.0      |\n",
                        "| Cervical spondylosis            | 0.875              | 1.0                |   0.933333 | 21.0      |\n",
                        "| Chicken pox                     | 0.7142857142857143 | 1.0                |   0.833333 | 15.0      |\n",
                        "| Common Cold                     | 1.0                | 1.0                |   1        | 21.0      |\n",
                        "| Dengue                          | 0.8823529411764706 | 0.6818181818181818 |   0.769231 | 22.0      |\n",
                        "| Dimorphic Hemorrhoids           | 1.0                | 1.0                |   1        | 19.0      |\n",
                        "| Fungal infection                | 1.0                | 1.0                |   1        | 26.0      |\n",
                        "| Hypertension                    | 0.9444444444444444 | 0.9444444444444444 |   0.944444 | 18.0      |\n",
                        "| Impetigo                        | 0.9583333333333334 | 1.0                |   0.978723 | 23.0      |\n",
                        "| Jaundice                        | 1.0                | 1.0                |   1        | 22.0      |\n",
                        "| Malaria                         | 1.0                | 1.0                |   1        | 17.0      |\n",
                        "| Migraine                        | 1.0                | 0.9583333333333334 |   0.978723 | 24.0      |\n",
                        "| Pneumonia                       | 0.9565217391304348 | 1.0                |   0.977778 | 22.0      |\n",
                        "| Psoriasis                       | 0.9375             | 0.8823529411764706 |   0.909091 | 17.0      |\n",
                        "| Typhoid                         | 0.9                | 1.0                |   0.947368 | 18.0      |\n",
                        "| Varicose Veins                  | 1.0                | 0.96               |   0.979592 | 25.0      |\n",
                        "| allergy                         | 0.875              | 0.9333333333333333 |   0.903226 | 15.0      |\n",
                        "| diabetes                        | 0.9333333333333333 | 0.8235294117647058 |   0.875    | 17.0      |\n",
                        "| drug reaction                   | 1.0                | 0.875              |   0.933333 | 16.0      |\n",
                        "| gastroesophageal reflux disease | 0.9523809523809523 | 0.9523809523809523 |   0.952381 | 21.0      |\n",
                        "| peptic ulcer disease            | 1.0                | 0.9444444444444444 |   0.971429 | 18.0      |\n",
                        "| urinary tract infection         | 0.9565217391304348 | 0.9565217391304348 |   0.956522 | 23.0      |\n",
                        "| accuracy                        |                    |                    |   0.952083 |           |\n",
                        "| macro avg                       | 0.9512549434024818 | 0.9502873176638152 |   0.948434 |           |\n",
                        "| weighted avg                    | 0.9555412634558654 | 0.9520833333333333 |   0.951736 |           |\n",
                        "+---------------------------------+--------------------+--------------------+------------+-----------+\n"
                    ]
                }
            ],
            "source": [
                "model = MultinomialNB(alpha=0.01)\n",
                "evaluate_model(X_train, X_test, y_train, y_test, chi2, 8000, model)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# ***Use More features***\n",
                "- **Dependency relations**\n",
                "- **POS tags with relations**\n",
                "- **Head words**\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 23,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Train set shape after features extraction: (4320, 27622)\n",
                        "Test set shape after features extraction: (480, 27622)\n"
                    ]
                }
            ],
            "source": [
                "train_df[\"features\"] = train_df[\"Id\"].apply(extract_full_features)\n",
                "test_df[\"features\"] = test_df[\"Id\"].apply(extract_full_features)\n",
                "\n",
                "all_features_train = train_df['features'].apply(flatten_tuples)\n",
                "all_features_flat_train = [' '.join(features) for features in all_features_train]\n",
                "all_features_test = test_df['features'].apply(flatten_tuples)\n",
                "all_features_flat_test = [' '.join(features) for features in all_features_test]\n",
                "\n",
                "vectorizer = TfidfVectorizer()\n",
                "X_train = vectorizer.fit_transform(all_features_flat_train)\n",
                "X_test = vectorizer.transform(all_features_flat_test)\n",
                "print(f\"Train set shape after features extraction: {X_train.shape}\")\n",
                "print(f\"Test set shape after features extraction: {X_test.shape}\")\n",
                "\n",
                "y_train = train_df[\"label\"]\n",
                "y_test = test_df[\"label\"]"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 24,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Closest Point 1: Number of Features = 25500, Train Accuracy = 1.0, Test Accuracy = 0.95625\n",
                        "Closest Point 2: Number of Features = 23500, Train Accuracy = 0.9997685185185186, Test Accuracy = 0.9541666666666667\n",
                        "Closest Point 3: Number of Features = 23000, Train Accuracy = 0.9997685185185186, Test Accuracy = 0.9541666666666667\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1000x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "model = MultinomialNB(alpha=0.01)\n",
                "plot_accuracies(X_train, X_test, y_train, y_test, model)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 25,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Train Accuracy: 0.9986111111111111\n",
                        "Test Accuracy: 0.9479166666666666\n",
                        "Difference: 0.050694444444444486\n",
                        "+---------------------------------+--------------------+--------------------+------------+-----------+\n",
                        "| Class                           | Precision          | Recall             |   F1-score | Support   |\n",
                        "|---------------------------------+--------------------+--------------------+------------+-----------|\n",
                        "| Acne                            | 1.0                | 1.0                |   1        | 21.0      |\n",
                        "| Arthritis                       | 1.0                | 1.0                |   1        | 20.0      |\n",
                        "| Bronchial Asthma                | 1.0                | 0.8947368421052632 |   0.944444 | 19.0      |\n",
                        "| Cervical spondylosis            | 0.875              | 1.0                |   0.933333 | 21.0      |\n",
                        "| Chicken pox                     | 0.6818181818181818 | 1.0                |   0.810811 | 15.0      |\n",
                        "| Common Cold                     | 0.875              | 1.0                |   0.933333 | 21.0      |\n",
                        "| Dengue                          | 0.9333333333333333 | 0.6363636363636364 |   0.756757 | 22.0      |\n",
                        "| Dimorphic Hemorrhoids           | 1.0                | 1.0                |   1        | 19.0      |\n",
                        "| Fungal infection                | 1.0                | 1.0                |   1        | 26.0      |\n",
                        "| Hypertension                    | 1.0                | 0.8333333333333334 |   0.909091 | 18.0      |\n",
                        "| Impetigo                        | 0.9583333333333334 | 1.0                |   0.978723 | 23.0      |\n",
                        "| Jaundice                        | 1.0                | 1.0                |   1        | 22.0      |\n",
                        "| Malaria                         | 1.0                | 1.0                |   1        | 17.0      |\n",
                        "| Migraine                        | 1.0                | 0.9166666666666666 |   0.956522 | 24.0      |\n",
                        "| Pneumonia                       | 1.0                | 1.0                |   1        | 22.0      |\n",
                        "| Psoriasis                       | 0.9411764705882353 | 0.9411764705882353 |   0.941176 | 17.0      |\n",
                        "| Typhoid                         | 0.9                | 1.0                |   0.947368 | 18.0      |\n",
                        "| Varicose Veins                  | 1.0                | 0.96               |   0.979592 | 25.0      |\n",
                        "| allergy                         | 0.8666666666666667 | 0.8666666666666667 |   0.866667 | 15.0      |\n",
                        "| diabetes                        | 0.8823529411764706 | 0.8823529411764706 |   0.882353 | 17.0      |\n",
                        "| drug reaction                   | 0.9375             | 0.9375             |   0.9375   | 16.0      |\n",
                        "| gastroesophageal reflux disease | 1.0                | 0.9047619047619048 |   0.95     | 21.0      |\n",
                        "| peptic ulcer disease            | 0.9473684210526315 | 1.0                |   0.972973 | 18.0      |\n",
                        "| urinary tract infection         | 0.9565217391304348 | 0.9565217391304348 |   0.956522 | 23.0      |\n",
                        "| accuracy                        |                    |                    |   0.947917 |           |\n",
                        "| macro avg                       | 0.9481279619624704 | 0.9470866750330255 |   0.944049 |           |\n",
                        "| weighted avg                    | 0.9537602173046252 | 0.9479166666666666 |   0.947483 |           |\n",
                        "+---------------------------------+--------------------+--------------------+------------+-----------+\n"
                    ]
                }
            ],
            "source": [
                "model = MultinomialNB(alpha=0.01)\n",
                "evaluate_model(X_train, X_test, y_train, y_test, chi2, 7500, model)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# ***Use Dependecy features with N-Grams***\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 26,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Train set shape after features extraction: (4320, 84052)\n",
                        "Test set shape after features extraction: (480, 84052)\n"
                    ]
                }
            ],
            "source": [
                "n1 = 1\n",
                "n2 = 3\n",
                "def extractor(row_id):\n",
                "    return extract_dependency_features_with_n_grams(row_id, n1, n2)\n",
                "\n",
                "\n",
                "train_df[\"features\"] = train_df[\"Id\"].apply(extractor)\n",
                "test_df[\"features\"] = test_df[\"Id\"].apply(extractor)\n",
                "\n",
                "all_features_train = train_df['features'].apply(flatten_tuples)\n",
                "all_features_flat_train = [' '.join(features) for features in all_features_train]\n",
                "all_features_test = test_df['features'].apply(flatten_tuples)\n",
                "all_features_flat_test = [' '.join(features) for features in all_features_test]\n",
                "\n",
                "vectorizer = TfidfVectorizer()\n",
                "X_train = vectorizer.fit_transform(all_features_flat_train)\n",
                "X_test = vectorizer.transform(all_features_flat_test)\n",
                "print(f\"Train set shape after features extraction: {X_train.shape}\")\n",
                "print(f\"Test set shape after features extraction: {X_test.shape}\")\n",
                "\n",
                "y_train = train_df[\"label\"]\n",
                "y_test = test_df[\"label\"]"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 27,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Closest Point 1: Number of Features = 66000, Train Accuracy = 1.0, Test Accuracy = 0.975\n",
                        "Closest Point 2: Number of Features = 68000, Train Accuracy = 1.0, Test Accuracy = 0.975\n",
                        "Closest Point 3: Number of Features = 67000, Train Accuracy = 1.0, Test Accuracy = 0.975\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1000x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Make sure to update step in plotting before running this cell\n",
                "model = MultinomialNB(alpha = 0.01)\n",
                "plot_accuracies(X_train, X_test, y_train, y_test, model)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 28,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Train Accuracy: 1.0\n",
                        "Test Accuracy: 0.975\n",
                        "Difference: 0.025000000000000022\n",
                        "+---------------------------------+--------------------+--------------------+------------+-----------+\n",
                        "| Class                           | Precision          | Recall             |   F1-score | Support   |\n",
                        "|---------------------------------+--------------------+--------------------+------------+-----------|\n",
                        "| Acne                            | 1.0                | 1.0                |   1        | 21.0      |\n",
                        "| Arthritis                       | 1.0                | 1.0                |   1        | 20.0      |\n",
                        "| Bronchial Asthma                | 1.0                | 0.9473684210526315 |   0.972973 | 19.0      |\n",
                        "| Cervical spondylosis            | 0.9130434782608695 | 1.0                |   0.954545 | 21.0      |\n",
                        "| Chicken pox                     | 0.75               | 1.0                |   0.857143 | 15.0      |\n",
                        "| Common Cold                     | 1.0                | 1.0                |   1        | 21.0      |\n",
                        "| Dengue                          | 1.0                | 0.7727272727272727 |   0.871795 | 22.0      |\n",
                        "| Dimorphic Hemorrhoids           | 1.0                | 1.0                |   1        | 19.0      |\n",
                        "| Fungal infection                | 1.0                | 1.0                |   1        | 26.0      |\n",
                        "| Hypertension                    | 1.0                | 0.9444444444444444 |   0.971429 | 18.0      |\n",
                        "| Impetigo                        | 0.9583333333333334 | 1.0                |   0.978723 | 23.0      |\n",
                        "| Jaundice                        | 1.0                | 1.0                |   1        | 22.0      |\n",
                        "| Malaria                         | 1.0                | 1.0                |   1        | 17.0      |\n",
                        "| Migraine                        | 1.0                | 1.0                |   1        | 24.0      |\n",
                        "| Pneumonia                       | 1.0                | 1.0                |   1        | 22.0      |\n",
                        "| Psoriasis                       | 1.0                | 0.8823529411764706 |   0.9375   | 17.0      |\n",
                        "| Typhoid                         | 0.9473684210526315 | 1.0                |   0.972973 | 18.0      |\n",
                        "| Varicose Veins                  | 1.0                | 0.96               |   0.979592 | 25.0      |\n",
                        "| allergy                         | 0.9375             | 1.0                |   0.967742 | 15.0      |\n",
                        "| diabetes                        | 1.0                | 0.9411764705882353 |   0.969697 | 17.0      |\n",
                        "| drug reaction                   | 1.0                | 1.0                |   1        | 16.0      |\n",
                        "| gastroesophageal reflux disease | 0.9545454545454546 | 1.0                |   0.976744 | 21.0      |\n",
                        "| peptic ulcer disease            | 1.0                | 0.9444444444444444 |   0.971429 | 18.0      |\n",
                        "| urinary tract infection         | 0.9583333333333334 | 1.0                |   0.978723 | 23.0      |\n",
                        "| accuracy                        |                    |                    |   0.975    |           |\n",
                        "| macro avg                       | 0.9757968341885676 | 0.9746880831013959 |   0.973375 |           |\n",
                        "| weighted avg                    | 0.9784746510441948 | 0.975              |   0.975031 |           |\n",
                        "+---------------------------------+--------------------+--------------------+------------+-----------+\n"
                    ]
                }
            ],
            "source": [
                "model = MultinomialNB(alpha=0.01)\n",
                "evaluate_model(X_train, X_test, y_train, y_test, chi2, 66000, model)"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "NLP",
            "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.9.20"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}