All_classifiers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic Tasks for building Machine Learning models\n",
    "========================================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# various classifiers/regressors models\n",
    "from sklearn.naive_bayes import MultinomialNB, GaussianNB, BernoulliNB\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC \n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor\n",
    "from sklearn.linear_model import LinearRegression, LogisticRegression \n",
    "from sklearn.datasets import make_regression\n",
    "\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "#make non numeric feature to numeric\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate artificial data\n",
    "=================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import make_regression, make_classification\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)\n",
    "\n",
    "poly = PolynomialFeatures(degree=2)\n",
    "X_ = poly.fit_transform(X)\n",
    "linear_reg=LinearRegression()\n",
    "linear_reg.fit(X_,y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Process data\n",
    "==========="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import svm, datasets\n",
    "from sklearn.preprocessing import Normalizer\n",
    "iris = datasets.load_iris()\n",
    "normalizer=Normalizer(norm=\"l2\")\n",
    "X_train,X_test,Y_train,Y_test=train_test_split(iris.data,iris.target,test_size=0.2, random_state=42)\n",
    "X_train=normalizer.transform(X_train)\n",
    "X_test=normalizer.transform(X_test)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Grid Search to find best parameter\n",
    "============================"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0.001\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "parameters = {'kernel':('linear', 'rbf'), 'C':[1, 10],\"gamma\":[0.001,1,1.00]}\n",
    "svc = svm.SVC()\n",
    "clf = GridSearchCV(svc, parameters)\n",
    "clf.fit(iris.data, iris.target)\n",
    "print(clf.best_params_['C'],clf.best_params_['gamma'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train with best parameter\n",
    "===================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6333333333333333\n"
     ]
    }
   ],
   "source": [
    "model = svm.SVC(C=clf.best_params_['C'],kernel=\"linear\")\n",
    "model.fit(X_train,Y_train)\n",
    "y_pred=model.predict(X_test)\n",
    "print(accuracy_score(y_pred,Y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "plot metrices\n",
    "==========="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x7f7506056978>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plot_confusion_matrix(model, X_test, Y_test,cmap=plt.cm.Blues,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feature Importance/ Selections\n",
    "========================="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.73678\n",
      "Feature: 1, Score: 2.71775\n",
      "Feature: 2, Score: -4.17779\n",
      "Feature: 3, Score: -1.85155\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "importance=model.coef_[0]\n",
    "#importance = model.feature_importances_\n",
    "for i,v in enumerate(importance):\n",
    "\tprint('Feature: %0d, Score: %.5f' % (i,v))\n",
    "# plot feature importance\n",
    "plt.bar([x for x in range(len(importance))], importance)\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 90.30\n"
     ]
    }
   ],
   "source": [
    "# evaluation of a model using 5 features chosen with random forest importance\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# feature selection\n",
    "def select_features(X_train, y_train, X_test):\n",
    "\t# configure to select a subset of features\n",
    "\tfs = SelectFromModel(RandomForestClassifier(n_estimators=1000), max_features=5)\n",
    "\t# learn relationship from training data\n",
    "\tfs.fit(X_train, y_train)\n",
    "\t# transform train input data\n",
    "\tX_train_fs = fs.transform(X_train)\n",
    "\t# transform test input data\n",
    "\tX_test_fs = fs.transform(X_test)\n",
    "\treturn X_train_fs, X_test_fs, fs\n",
    "\n",
    "# define the dataset\n",
    "X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)\n",
    "# split into train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=1)\n",
    "# feature selection\n",
    "X_train_fs, X_test_fs, fs = select_features(X_train, y_train, X_test)\n",
    "# fit the model\n",
    "model = RandomForestClassifier()\n",
    "model.fit(X_train_fs, y_train)\n",
    "# evaluate the model\n",
    "yhat = model.predict(X_test_fs)\n",
    "# evaluate predictions\n",
    "accuracy = accuracy_score(y_test, yhat)\n",
    "print('Accuracy: %.2f' % (accuracy*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Feature Importance')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "feat_importances = pd.Series(model.feature_importances_, index=[0,1,2,3,4])\n",
    "feat_importances.nlargest(5).sort_values(ascending = True).plot(kind='barh')\n",
    "plt.xlabel('importance')\n",
    "plt.title('Feature Importance')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}