Gender Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "raising-landscape",
   "metadata": {},
   "source": [
    "# Gender Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dental-cincinnati",
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing required libraries\n",
    "import pandas as pd\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "pharmaceutical-community",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Favorite Color Favorite Music Genre Favorite Beverage Favorite Soft Drink  \\\n",
      "0           Cool                 Rock             Vodka          7UP/Sprite   \n",
      "1        Neutral              Hip hop             Vodka     Coca Cola/Pepsi   \n",
      "2           Warm                 Rock              Wine     Coca Cola/Pepsi   \n",
      "3           Warm     Folk/Traditional           Whiskey               Fanta   \n",
      "4           Cool                 Rock             Vodka     Coca Cola/Pepsi   \n",
      "\n",
      "  Gender  \n",
      "0      F  \n",
      "1      F  \n",
      "2      F  \n",
      "3      F  \n",
      "4      F  \n"
     ]
    }
   ],
   "source": [
    "# Importing Data set\n",
    "data = pd.read_csv(\"Transformed Data Set - Sheet1.csv\")\n",
    "print(data.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proprietary-ribbon",
   "metadata": {},
   "source": [
    "## Analyzing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "indoor-battlefield",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "C = \n",
      " Cool       37\n",
      "Warm       22\n",
      "Neutral     7\n",
      "Name: Favorite Color, dtype: int64\n",
      "\n",
      "Color = \n",
      " Index(['Cool', 'Warm', 'Neutral'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "c = data['Favorite Color'].value_counts()\n",
    "color = c.index\n",
    "print(\"\\nC = \\n\", c)\n",
    "print(\"\\nColor = \\n\", color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "approved-stone",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "mg = \n",
      " Rock                19\n",
      "Pop                 17\n",
      "Electronic           8\n",
      "Hip hop              8\n",
      "R&B and soul         6\n",
      "Jazz/Blues           4\n",
      "Folk/Traditional     4\n",
      "Name: Favorite Music Genre, dtype: int64\n",
      "\n",
      "Genre = \n",
      " Index(['Rock', 'Pop', 'Electronic', 'Hip hop', 'R&B and soul', 'Jazz/Blues',\n",
      "       'Folk/Traditional'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "mg = data['Favorite Music Genre'].value_counts()\n",
    "genre = mg.index\n",
    "print(\"\\nmg = \\n\", mg)\n",
    "print(\"\\nGenre = \\n\", genre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "tight-training",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "b = \n",
      " Doesn't drink    14\n",
      "Beer             13\n",
      "Other            11\n",
      "Wine             10\n",
      "Whiskey           9\n",
      "Vodka             9\n",
      "Name: Favorite Beverage, dtype: int64\n",
      "\n",
      "Beverage = \n",
      " Index(['Doesn't drink', 'Beer', 'Other', 'Wine', 'Whiskey', 'Vodka'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "b = data['Favorite Beverage'].value_counts()\n",
    "beverage = b.index\n",
    "print(\"\\nb = \\n\", b)\n",
    "print(\"\\nBeverage = \\n\", beverage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "congressional-command",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "s = \n",
      " Coca Cola/Pepsi    32\n",
      "Fanta              14\n",
      "7UP/Sprite         13\n",
      "Other               7\n",
      "Name: Favorite Soft Drink, dtype: int64\n",
      "\n",
      "Soft = \n",
      " Index(['Coca Cola/Pepsi', 'Fanta', '7UP/Sprite', 'Other'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "s = data['Favorite Soft Drink'].value_counts()\n",
    "soft = s.index\n",
    "print(\"\\ns = \\n\", s)\n",
    "print(\"\\nSoft = \\n\", soft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "advisory-lebanon",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "g = \n",
      " F    33\n",
      "M    33\n",
      "Name: Gender, dtype: int64\n",
      "\n",
      "gender = \n",
      " Index(['F', 'M'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "g = data['Gender'].value_counts()\n",
    "gender = g.index\n",
    "print(\"\\ng = \\n\", g)\n",
    "print(\"\\ngender = \\n\", gender)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hindu-friendly",
   "metadata": {},
   "source": [
    "## Manual Encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "social-surrey",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Head(3)  = \n",
      "    Favorite Color  Favorite Music Genre  Favorite Beverage  \\\n",
      "0               0                     0                  5   \n",
      "1               2                     3                  5   \n",
      "2               1                     0                  3   \n",
      "\n",
      "   Favorite Soft Drink  Gender  \n",
      "0                    2       0  \n",
      "1                    0       0  \n",
      "2                    0       0  \n",
      "\n",
      "Tail(3) = \n",
      "     Favorite Color  Favorite Music Genre  Favorite Beverage  \\\n",
      "63               2                     3                  0   \n",
      "64               0                     0                  3   \n",
      "65               0                     2                  1   \n",
      "\n",
      "    Favorite Soft Drink  Gender  \n",
      "63                    1       1  \n",
      "64                    0       1  \n",
      "65                    0       1  \n"
     ]
    }
   ],
   "source": [
    "for i in range(len(color)):\n",
    "    data['Favorite Color'].replace(color[i], i, inplace=True)\n",
    "\n",
    "for i in range(len(genre)):\n",
    "    data['Favorite Music Genre'].replace(genre[i], i, inplace=True)\n",
    "\n",
    "for i in range(len(beverage)):\n",
    "    data['Favorite Beverage'].replace(beverage[i], i, inplace=True)\n",
    "\n",
    "for i in range(len(soft)):\n",
    "    data['Favorite Soft Drink'].replace(soft[i], i, inplace=True)\n",
    "\n",
    "for i in range(len(gender)):\n",
    "    data['Gender'].replace(gender[i], i, inplace=True)\n",
    "\n",
    "print(\"\\nHead(3)  = \\n\", data.head(3))\n",
    "print(\"\\nTail(3) = \\n\", data.tail(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advisory-senegal",
   "metadata": {},
   "source": [
    "## Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "beneficial-stanley",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "X shape =  (66, 4)\n",
      "\n",
      "Y shape =  (66,)\n"
     ]
    }
   ],
   "source": [
    "# Loading data\n",
    "y = data['Gender']\n",
    "X = data.drop('Gender', 1)\n",
    "\n",
    "print(\"\\nX shape = \", X.shape)\n",
    "print(\"\\nY shape = \", y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "pending-matter",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Logistic Regression classification report = \n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.57      0.61      0.59        33\n",
      "           1       0.58      0.55      0.56        33\n",
      "\n",
      "    accuracy                           0.58        66\n",
      "   macro avg       0.58      0.58      0.58        66\n",
      "weighted avg       0.58      0.58      0.58        66\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Using Logistic Regression classifier\n",
    "log_model = LogisticRegression()\n",
    "log_model.fit(X, y)\n",
    "# print(\"\\n Accuracy of Logistic Regression = \", log_model.score(X, y).round(3))\n",
    "log_pred = log_model.predict(X)\n",
    "print(\"\\nLogistic Regression classification report = \\n\", classification_report(y, log_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "marked-garbage",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "KNN classification report = \n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      0.79      0.72        33\n",
      "           1       0.74      0.61      0.67        33\n",
      "\n",
      "    accuracy                           0.70        66\n",
      "   macro avg       0.70      0.70      0.69        66\n",
      "weighted avg       0.70      0.70      0.69        66\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# K-Nearest Neighbors\n",
    "knn_model = KNeighborsClassifier()\n",
    "knn_model.fit(X, y)\n",
    "# print(\"K-Nearest Neighbors:\", knn_model.score(X, y).round(3))\n",
    "knn_pred = knn_model.predict(X)\n",
    "print(\"\\nKNN classification report = \\n\", classification_report(y, knn_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fantastic-retrieval",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CRT classification report = \n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.92      1.00      0.96        33\n",
      "           1       1.00      0.91      0.95        33\n",
      "\n",
      "    accuracy                           0.95        66\n",
      "   macro avg       0.96      0.95      0.95        66\n",
      "weighted avg       0.96      0.95      0.95        66\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Classification and Regression Trees\n",
    "cart_model = DecisionTreeClassifier()\n",
    "cart_model.fit(X, y)\n",
    "# print(\"Classification and Regression Trees:\", cart_model.score(X, y).round(3))\n",
    "cart_pred = cart_model.predict(X)\n",
    "print(\"\\nCRT classification report = \\n\", classification_report(y, cart_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "extended-integration",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RFC classification report = \n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.91      0.95        33\n",
      "           1       0.92      1.00      0.96        33\n",
      "\n",
      "    accuracy                           0.95        66\n",
      "   macro avg       0.96      0.95      0.95        66\n",
      "weighted avg       0.96      0.95      0.95        66\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classifier\n",
    "rfc_model = RandomForestClassifier()\n",
    "rfc_model.fit(X, y)\n",
    "# print(\"Random Forest Classifier:\", rfc_model.score(X, y).round(3))\n",
    "rfc_pred = rfc_model.predict(X)\n",
    "print(\"\\nRFC classification report = \\n\", classification_report(y, rfc_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "entertaining-inclusion",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "SVM classification report = \n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.79      0.82      0.81        33\n",
      "           1       0.81      0.79      0.80        33\n",
      "\n",
      "    accuracy                           0.80        66\n",
      "   macro avg       0.80      0.80      0.80        66\n",
      "weighted avg       0.80      0.80      0.80        66\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Support Vector Machines\n",
    "svm_model = SVC(gamma='auto')\n",
    "svm_model.fit(X, y)\n",
    "# print(\"Support Vector Machines:\", svm_model.score(X, y).round(3))\n",
    "svm_pred = svm_model.predict(X)\n",
    "print(\"\\nSVM classification report = \\n\", classification_report(y, svm_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "genetic-hammer",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "encouraging-prize",
   "metadata": {},
   "source": [
    "We received highest accuracy from Decision Tree and Random Forest Classifier.\n",
    "\n",
    "Classifiers in decreasing order of their accuracy:\n",
    "CRT = RFC < SVM < KNN < Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "happy-division",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}