Improved_parameter_tuning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9e5d0f00",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import csv, re\n",
    "import string\n",
    "import codecs\n",
    "import nltk\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import sklearn.metrics as metrics\n",
    "import matplotlib.pyplot as plt\n",
    "import jsonlines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1a72516b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data into a pandas dataframe\n",
    "\n",
    "data = pd.read_csv('data/wcpr_mypersonality.csv',encoding='mac-roman')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d15dc622",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['#AUTHID', 'STATUS', 'sEXT', 'sNEU', 'sAGR', 'sCON', 'sOPN', 'cEXT',\n",
       "       'cNEU', 'cAGR', 'cCON', 'cOPN', 'DATE', 'NETWORKSIZE', 'BETWEENNESS',\n",
       "       'NBETWEENNESS', 'DENSITY', 'BROKERAGE', 'NBROKERAGE', 'TRANSITIVITY'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac0769aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = data['STATUS']\n",
    "y = data['cNEU']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bbb5d254",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Split data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, shuffle=True, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "95035de3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract features using vectorizer\n",
    "#the training and testing data were vectorized by CountVectorizer and TfidfVectorizer objects. \n",
    "#This transformation is needed, because the ML algorithms work only with numerical data. \n",
    "#CountVectorizer creates a dictionary containing the occurrence number of tokens, \n",
    "#while TfidfVectorizer generates a dictionary with the tf-idf values of tokens.\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "# Initialize count vectorizer\n",
    "count_vectorizer = CountVectorizer(analyzer='word', stop_words='english')\n",
    "\n",
    "# create count train and test variables\n",
    "count_train = count_vectorizer.fit_transform(X_train, y_train)\n",
    "count_test = count_vectorizer.transform(X_test)\n",
    "\n",
    "# Initialize TfidfVectorizer\n",
    "count_vectorizer = TfidfVectorizer(analyzer='word', stop_words='english')\n",
    "\n",
    "# create count train and test variables\n",
    "tdidf_train = count_vectorizer.fit_transform(X_train, y_train)\n",
    "tdidf_test = count_vectorizer.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "26e74681",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best hyperparameters:  {'C': 0.1, 'penalty': 'l2'}\n",
      "Test accuracy:  0.6370967741935484\n"
     ]
    }
   ],
   "source": [
    "# Define the hyperparameters to search over\n",
    "param_grid = {'C': [0.01, 0.1, 1, 10], 'penalty': ['l1', 'l2']}\n",
    "\n",
    "# Create a grid search object\n",
    "grid_search = GridSearchCV(LogisticRegression(solver='liblinear'), param_grid, cv=5)\n",
    "\n",
    "# Fit the grid search object to the training data\n",
    "grid_search.fit(count_train, y_train)\n",
    "\n",
    "# Print the best hyperparameters found by the grid search\n",
    "print(\"Best hyperparameters: \", grid_search.best_params_)\n",
    "\n",
    "# Create a new logistic regression object with the best hyperparameters and fit it to the entire training data\n",
    "best_logreg = LogisticRegression(**grid_search.best_params_, solver='liblinear')\n",
    "best_logreg.fit(count_train, y_train)\n",
    "\n",
    "# Evaluate the performance of the final model on the test data\n",
    "test_accuracy = best_logreg.score(count_test, y_test)\n",
    "print(\"Test accuracy: \", test_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7f794625",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifying test data...\n",
      "Logistic Regression Accuracy  = 0.6370967741935484\n"
     ]
    }
   ],
   "source": [
    "# Classify the test data and see how well the vectorizers perform\n",
    "\n",
    "print(\"Classifying test data...\")\n",
    "# Run predict on count test data\n",
    "predicted_labels_count = best_logreg.predict(count_test)\n",
    "print('Logistic Regression Accuracy  = {}'.format(metrics.accuracy_score(predicted_labels_count,  y_test)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "104242f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification report after parameter tuning:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           n       0.96      0.64      0.77      1856\n",
      "           y       0.10      0.59      0.17       128\n",
      "\n",
      "    accuracy                           0.64      1984\n",
      "   macro avg       0.53      0.62      0.47      1984\n",
      "weighted avg       0.90      0.64      0.73      1984\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Report for both vectorizers\n",
    "report_count = classification_report(predicted_labels_count, y_test)\n",
    "print(f\"Classification report after parameter tuning:\\n{report_count}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aeab22c8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}