Mtech PCA iris.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PCA Clustering For Iris Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing libraries from SKLEARN\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn import datasets\n",
    "from sklearn.decomposition import PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()\n",
    "\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "target_names = iris.target_names\n",
    "\n",
    "pca = PCA(n_components=3)\n",
    "X_r = pca.fit(X).transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PCA Cluster plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x26641600cc0>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEICAYAAABcVE8dAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO29eZwU1dX//z7TM8MMzLgbhk2JWxQB0YiJGyq4m6hjxCjG6GOUmIAxv0QRBGQbZESf/Mzm46N5ohnFqNGguMQYRUBQE0FBwSUaBEFAERVngBlmud8/btXQNN1V1ft23q/XvJruqq663TOcunXu53yOGGNQFEVRCp+SbA9AURRFyQwa8BVFUYoEDfiKoihFggZ8RVGUIkEDvqIoSpGgAV9RFKVI0ICv5AUicp+I1KXweHUi8pmIbEjVMX3Od5OI/CET51KUWGjAV2IiIqtEZJuINInIJyJyr4hUhW0/Q0QWiEijiGwUkfkicm7EMU4WESMiYzI4biMiB3ls7wP8EuhnjKnJxDmNMbcYY65K4Lju76BRRL4UkZdF5BoRCfR/V0T6OmMrjffccY4zI+dRkkMDvuLHd40xVcBRwGBgAoCIXAj8BWgAegPdgZuB70a8/3Lgc+cxV9gf2GSM+TTeNyYS0FIQBL9rjKnGjrseuBH4vySPqRQhGvCVQBhjPgb+BvQXEQF+BUwzxvzBGLPZGNNhjJlvjLnafY+IdAUuBEYBB4vI0bGO79wJrHVSH585M9tLPfa/WkQ+EJHPRWSOiPR0Xl/g7LLMuTP5fsT7TgX+AfR0tt/nvH6uiKxwZtHzROSwsPesEpEbReRNYItfABeRySLyqIg8ICJfAVc4rz3gbK9wtm1yzveaiHT3OiaA8z3PAb4PXC4i/Z3jnSMib4jIVyKyRkQmh73N/T6+dD7vsSJyoIjMdc7/mYjMEpE9wsZ/o4h87NxVvCciw5zXS0RkrIj8x3nvIyKyV6zz+H0eJfNowFcC4aRBzgbeAL4B9AEe9Xnb94Am7J3A34Ef+uxfA+wD9MLeEdwtIt+IMpahwAzgIqAHsBp4CMAYM8TZ7QhjTJUx5uHw9xpjngfOAtY5268QkUOAPwM/B/YFngGeFJHysLdeApwD7GGMafP5HADnYb+fPYBZEdsuB3bHfod7A9cA2wIc0/0M/wLWAic6L23Bfrd7OGP8iYic72xzv489nM/7CiDY768ncJgzjskAzvc9Ghjs3FWcAaxyjvEz4HzgJOe9XwC/9ziPkmNowFf8eFxEvgQWAvOBW7BBCmC9z3svBx42xrQDDwKXiEiZz3smGmNajDHzgaexQT2SS4E/GmNeN8a0AOOAY0Wkb5APFIXvA08bY/5hjGkFbgcqgePC9vmNMWaNMSZoYH7FGPO4c+cT+Z5W7Hd4kDGm3RizxBjzVZxjXgfsBWCMmWeMecs515vYi9dJsd5ojPnA+awtxpiN2Ls1d/92oAvQT0TKjDGrjDH/cbb9GBhvjFnrfO+TgQs1b58/aMBX/DjfGLOHMWZ/Y8xPneC1ydnWI9abnDuCU9gxu30CqMDOQGPxhTFmS9jz1diZZCQ9nW0AGGOanDH18vswMYg8XgewJuJ4a+I8ptf+92PveB4SkXUiMjPAhTCSXti1EUTkWyLyorNwvhl7x7BPrDeKyNdE5CEnbfMV8IC7vzHmA+ydzmTgU2c/93ewPzDbSUN9CbyDvUD4pqOU3EADvpII72ED2vc89rkM+/f1pFjp40pswPdK6+wpIt3Cnu+HnclGsg4bfABw3rM38HGg0fsfT7BpjvDjxWsrG3N/Y0yrMWaKMaYf9i7iO/inuzoRkcHYgL/QeelBYA7QxxizO3AXNm0TaxwznNcHGmN2A34Qtj/GmAeNMSdgvxMD3OpsWgOc5UwA3J8KZ31HbXfzAA34StwY66n9C2CiiPyXiOzmLOidICJ3O7v9EJgCDAr7+R5wjojsHfXAlikiUi4iJ2ID4V+i7PMg8F8iMkhEumDTTP80xqxytn8CHBDHR3rEGdcwZ6b9S6AFeDmOYwRGRE4RkQEiEgK+wqZ42gO8bzcR+Q52veIBY8xbzqZq4HNjTLOIHAOMCHvbRqCDnb+Pauzaypci0gu4Iewc3xCRoc732oxdW3DHdhcwXUT2d/bdV0TO8ziPkmNowFcSwhjzKDb3fSV2hvwJUAc8ISLfBvoCvzfGbAj7mQN8gF0AjcYG7ELgOmwq6BpjzLtRzv0CMBF4DLuOcCBwcdguk4E/OamHaGsAkcd7DzvL/S3wGVZa+l1jzHa/9yZIDXZB9ytsWmQ+Nq0SiydFpBE7wx6Pzbn/V9j2nwJTnX1uxl7AADDGbAWmA4uc7+Pb2AvxUcBm7DrJX8OO1QUr/fwM+/v4GnCTs+3X2DuJ55xzvQp8y+M8So4h2gBFyQVE5GTsrLV3tseiKIWKzvAVRVGKBA34iqIoRYKmdBRFUYoEneEriqIUCTlbIbfPPvuYvn37ZnsYiqIoecWSJUs+M8bsG21bzgb8vn37snjx4mwPQ1EUJa8QkdWxtmlKR1EUpUjQgK8oilIkaMBXFEUpEjTgK4qiFAka8BVFUYoEDfiKoihFggZ8RVGUIiFndfiKkls0ArOxjsE1QC3WVl5R8gcN+IriicHaw08DQtieIBXYLoITgbGENYtSlJxGA76ieFKP7esS3oe8yXmscx7HZXREipIomsNXlJg0Ymf2W2Ns34oN+k0xtitKbqEBX1FiMhubxvGixNlPUXIfDfiKEpMN2Jy9F83YtrqKkvukJOCLyB9F5FMRWR5j+8kisllEljo/N6fivIqSXmqwC7ReVAA9wp43Ag3ATOexMT1DU5QESNUM/z7gTJ99XjLGDHJ+pqbovIqSRmqBdp99Opz9DDAD6A6MAsY7j92d17WznJJ9UhLwjTELgM9TcSxFyR2qsdLLrjG2dwUmAFXsrOZpAtqcx23O6/XpHqyi+JLJHP6xIrJMRP4mIodH20FERorIYhFZvHHjxgwOTVFiMRYb1Cuxgb3Ueax0Xh+LqnmUfCFTOvzXgf2NMU0icjbwOHBw5E7GmLuBuwGOPvpovQdWcgDB6uxHY/9s12Nz9rXYwA/xqXkuS88wFSUAGQn4xpivwv79jIjcKSL7GGM+y8T5FSV5qokdrFXNo+QHGQn4IlIDfGKMMSJyDHa6sykT51YKkVzztXHVPF4pm0g1j6JknpQEfBH5M3AysI+IrAUmAWUAxpi7gAuBn4hIG3YV62JjjKZslDjJVV+bWmcMXrhqHiXfaGxpZPa7s9nQtIGaqhpqD62lukt+GudJrsbdo48+2ixevDjbw1ByihnYxc9oi6OuYiZbvja5PDYlEYwx1C+qZ9r8aYRKQjS3NVNRWkF7RzsTT5rI2OPHIpJ7xnkissQYc3S0bWqelm5aG2HNbGjeABU10KcWyvJzdpBdXCXMthjbXSXMtexYTE3luf1SSGOdx8i7j3Z2qHmUfKJ+UT11C+rY1rbjb65pu03b1S2wxnnjTsivi7jO8NOFMfB2PSyfBhKC9mYIVYBph/4Tod9YyMHZQe7SgC1k8sqTVwF3kjolTKwUUjuxU0iNxFbzKPlCY0sj3W/vvlOwj6RrWVc+uf4Tqspz6/erM/xs8HY9LK+D9rA/mDYnWC13bHUPz6/ZQXbJhhImEWtkLzWPki/Mfnc2oRJvqW2JlDD7ndlcdkT+/L7VPC0dtDbamX17jEKc9q026LdqIU5wgvjalAD/ITX+NVpMVcxsaNpAc5v3BKO5rZn1TfkltdWAnw7WzLZpHC+kBNaqrW5wgvjabAdmkRr/mnRZI6u5Wj5QU1VDRan3BKOitIIeVfkltdWAnw6aN9icvRftzbAtv2YH2cXP18ZlC6nxr0l1CknN1fKJ2kNrae/wnmB0mA5qD8svqa0G/HRQUWMXaL0IVUBlfs0Osk+kr40XyaZcErFG9kLN1fKJ6i7VTDxpIl3Lok8wupZ1ZcKQCTm3YOuHBvx00KfWqnG8MB3QO79mB9nH9bX5BBgBlPvsn0w3qniskf3Q9YB8ZOzxY5kwZAKVpZVUlVdRWlJKVXkVlaWVTBgygbHH55/UVlU66aCs2kovl9dFX7gNdYX+E6Asv2YHuUM1cCA24HqRjGrHTSH5FVMZbC7eS6Ov5mr5iIgw7oRxjB48msfffZz1TevpUdWD2sNq825m76IBP130c67+UXX4E3ZsVxIkE/41XsVU451t3fG3eVBztXymukt1XkkvvdCAny5ErM7+kNGw9nG7QFvZw6ZxdGafAjLhX+Nljfxbgmv01VxNyQ200jYR1C4hR8iWf00jdmYfuwrTnv8T7OJyvPsr+UouGK1ppW2qiGWX8No1apeQFbLlXxNvTj7oeoAG+3wlltHaNU9dk1NGaxrw40HtEnKMIN2o0kEiOXk1Vytk8sVoTVM6QWlthL923znYRxLqChd8ojn6gicZIzc1Vys0cs1ozSulozr8oKhdQgGQKluDZDT6rrnaGOdRg32+E4/RWrbRgB8UtUvIY1Jta+Bn86A5+WIin4zWNIcfFNcuoc3jNr6ki9ol5CRBbI5H49/kJLwRSk/gBuzdgubkixnXaM3N2UcjV4zWNIcflCA5fID+k2HAzarWyRmCSCLLsEG7lOhNTiB2I5QxwAHYi4Dm5IsRzeEXIq5dQsjHrfGdmVbNo+QIQSSUrdggHsvUzMv47DbgYzQnX7zkk9GaBvx46DcWDrvBex9tbpJjBJFQxmIrMBWYhBqfKV7ki9Ga5vDjQQSqDoDSbtC2xWM/R63z9cLw38hvgtgaeBHkYqHGZ8VOvhitacCPl+YN0N7ivY+qdXKIIJ47yaLGZ4ol143WNKUTL9rcJM8I2ikrGdT4TMkPNODHizY3yUNGAWdj1TgV2BvbKmznrFTc5CbryqkomSElAV9E/igin4rI8hjbRUR+IyIfiMibInJUKs6bFfzUOtrcJIdwC65qgGexgdmVIZ+FdaecSnKzfy2yUvKHVM3w7wPO9Nh+FnCw8zMS+J8UnTc79Btrg3qoEkqrQErtY6hSm5vkFJFyynagBSurfBr4Hbv2yS0FugQ8fhlaZKXkEykrvBKRvsBTxpj+Ubb9LzDPGPNn5/l7wMnGmJgrXTlXeBWN1kZtbpJWwitbY1W/er03Xs9619RsD+DnPu8tB1Y741KU3CEX/PB7AWvCnq91Xtsp4IvISOwdAPvtt1+GhpYEZdUqvUwLhuiVrdHaB8YiEc/68N/lJmL715cDQ4Hn2PkilMwFSlHST6YCfrT/nbvcWhhj7gbuBjvDT/eglFwliPeNn7f4Brxn6OAtp4zmX18CbHde/wewEHsRmoD9E0/mAqUo6SdTKp21QJ+w572BdRk6t5JXNGIDZzKVrQZ4DX8LYy85pdtc5ROsr/2pYdu2O8d27RVuxlbjRrNecO0ZFCX7ZCrgzwF+6Kh1vg1s9srfK8VMPKmYWNQDzwQ4Vws2KHv54lcD5wPz2TG7j6Qd68cTDbVeUHKHVMky/wy8AnxDRNaKyI9E5BoRcUscnwFWAh8A9wA/TcV5C4LWRljZAG/PtI+tiTblKBQSaR8Yjt8dQjjtwC/x98UPchHywu8CpSiZISU5fGPMJT7bDbb6RXHRhugxCOJ945WKiSc4dxBsbSDIeoAXar2g5AZaaZstwhuitzWBabOP7dvs60VrsZxM+0BI3B3TK/VSQ3JzI7VeUHIDDfjZoLXRzuzbY6QditpiOdn2ge4dQiLESr0EuQh5odYLSm6gAT8RWhvh/f+Fhd+3P+//b3y5d22I7kO06lfX+ya8sjVaU/JkgnOs1Iu7cJsIar2g5A5qjxwPxsCKenhrEpgwVcZHj8Di0TBgChw+zj/3rg3RfXAlkaPZUf0a3j7Q9ciJpXufwK46/iBEpl7CC6lOdcbS5nOMblj1j/a3VXIPDfjx8HaUYO9i2uw2ERv0vQjSEF0tltm1+tXFrzBrAnAithI2HtzUS6xKX8H+l4kW9Ltim5ofyK4XKCVXaGxpZPa7s9nQtIGaqhpqD62lukvxVENrE/OgBG1iXlIJ3/vU21MnyLFCXeGCT9SbZxeCeORUYoN2PIu3buplHPbuIZatQplz7AqiNzwvRmVV7mOMoX5RPdPmTyNUEqK5rZmK0graO9qZeNJExh4/FikQVVwueOnkP2tmW597Xzr82xu6FsvL66Iv3KrFsgdBZJeG2Jr6cELYi0N46sXV8ce6oLQ67/kV8AU6k88P6hfVU7egjm1tO36vTdvtXWHdAivJHXeCn11H/qOLtkFp3gAdsaopw+ho9c+9tzZCRU/42hAoKVeL5bgIIrvcTuzKV5cS4HSsbcKn2Jm9EOyCEsLO7MdgU04a7HOZxpZGps2fxtbW6Kq4ra1bqVtQ13kBKGR0hh+UihooKYMOn362JWWxc+/Riq1KutgeuTWnwv6XQJ8LdGbvSZDCrHLsDN/rd9UVuIRd1wiSrfRVco3Z784mVOJ9ES+REma/Mzun+9GmAp3hB6VPrZVK+lISu71htGKr9i12EfjTBbDtYw32vgSRXQr+ufRY2vga/BugaCFVPrGhaQPNbd4X8ea2ZtY3Ff5FXAN+UNy8u5TF3kdKYcDE6EFbi61SRJDCrIlYB8t4i7cM1vJpi88YtJAqn6ipqqGi1LsYr6K0gh5VhX8R14AfD/3GWq19tKAvpXZbrNy7FlulkCCFWUGLt8KpB27zObcWUuUbtYfW0t7hfVfYYTo49YBTaVjWwMxFM2lY1kBjS+EZGaosMxFaG2H1n2HDXPu8ZpjNv3ulY96eCcvG2zROLKQUjpgO/cakdrwFS3hbwlhqmSD7uPv5yT0BJmPvHgpDwlcszFg4g7oFdVEXbitLKzlxvxN56aOXCkKyqbLMVFNWDQeNtD9B0WKrNGHCHqNNXmIVb0USRJ3TDTgADfb5x9jj7R1dNB3+ifudyMI1C4tCsqkz/FTS2mhTN80bbIDvU2svDu42LbZKEV8BPwKewGYl20msACrcOmEJ8BjeC8KlwHSsHFPJRxpbGnn83cdZ37SeHlU9OPWAUznwNwfuFOwj6VrWlU+u/4Sq8vz4f6kz/HQTxNtei61SgGt5cDO72hvE0/M2mnVCiORaIir5QHWX6p2klw3LGopKsqmLtqkgqLd9v7E2qIcqtdgqIdwg7WVgFqSlYLgXj9uD1qe+AlB1TuFRbJJNneEnipu+2bLazuyjGarBDrnlIdfa2fvh4+CQ0bD2cVuRW9nD6vZ1Zu+Dn+VBOK6vfbQZWTzHCUfVOYWIK9n0qrItJMmmBvx4iUzftG3Fzvw8cOWWrr9OWbW3144ShQfx/Z478aqEDdoCsQs7rw2ozXEhUntoLdc8dY3nPh2mg9rDCuPOTlM68RKZvgkShIra2z5ZXO/7awmWdgHvXHsQ64RSbMOT6ezqtaMUEtVdqpl40kS6lkUv0uta1pUJQybkzYKtHzrDj4fOatk40wEqt0wCN98ewLiuE69ce9Am6ecQTM6pZItUedt7STYnDJnQuT2dY8gUKsuMh5UNsHiUt5Y+Giq3TJCgxVDhhPvaJ3rMrsAnaL4+N0mXt32kZLP2sNqYM/tc9tdXWWaqCNKaMBIpV7llwgTNt7uU4Z9rd714YjU40cXZXCdd3vaRks1sjCHdaA4/Htxq2XioGapyy4QJkm8H+2c8HNhE7Fx7eMPznth2hPH47Ci5QC542+fCGBJFA3489KkF41ecE0ZpFfQd4d/UXImBm2/3ogK4C3gEO3uPxF307Q6MAsZjm6PPxFbM/h5dnM0f4vG2L+QxJIoG/Hhwq2VDsWx3I2hvgV7np3dMBU0Q7/sSbCOTWEQrsmpynt8GfIx2rsofcqFQKhfGkCgpCfgicqaIvCciH4jILvfDInKFiGwUkaXOz1WpOG9W6DcWDrsh4M4G3v9dWodTOISnXBqc50G8773y7W6RVYweBIGqcpVM09jSGNOmOBe87XNhDImSdMAXkRD2vvgsoB9wiYj0i7Lrw8aYQc7PH5I9b9YQgaoDINTNf1/Tpk1NfImWchnlPJ8B3Ej8vvYuQRZ93apcJdsYY5ixcAbdb+/OqGdGMX7ueEY9M4rut3dnxsIZGGMCe9uns1AqyBi2t29n1eZVOeern4oZ/jHAB8aYlcaY7cBDwHkpOG7u0rzBv7eti19Tk9ZGK/d8e6Z9bM2dP47M4JVyqQNuxebVP8Hm2ePJt2t/2nwiXPnStL2Jto42mrY3sa1tG3UL6qhfVJ8ThVJ+Y3CZOn/qLhesbJMKWWYvYE3Y87XAt6Ls9z0RGQL8G/j/jDFrIncQkZHASID99tsvBUNLE0G87V1iVdkGcdgs+MVeP18bN+VyLcF97cMJWmSVe7fexYarfIllU+wqX6495tqkCqVSRbQxlFDC9o7tgJ3hQ+5JNZMuvBKR4cAZxpirnOeXAccYY64N22dvoMkY0yIi1wAXGWOGeh03JwuvXIJ427uUVEDv86Dn2Tv746+Y4W+VfHju6XhTSwM2feMVkKuwM/pEql61yCoTpKLatGFZA6OeGeUpZawqr+LOs+/s1MrHUyiVLtwxrPpyFXUv1XUG+mhkylc/3YVXa4E+Yc97A+vCdzDGbAp7eg/2Pj1/cdU6yybiqyLpaIaPHoV1T9vZe89zYPcB8PZ06IjxxxHpsFmwpDvlokVW6SRWtek1T10Td7VpIsqXeAql0oU7hoZlDZSHyj0Dfi746qcih/8acLCIfF1EyoGLgTnhO4hI+D3zucA7KThvdjl4lM3PB6J9hz/+mkdh+aTYwd6lKBqaB9XZJ5NySaSZuRKEIDn3oARSvoRyU/kC+SPVTHqGb4xpE5HRwN+xkog/GmNWiMhUYLExZg7wMxE5F7si9zlwRbLnzTprH4dQF2iLx9QrDorCYbMW8LamDd50JLxdYY3znmrsou44bLFVkGbmShDiybkbY3xTPkFsiptam/jPF//BGBOXT00mDM7yxVdfzdMS5e2ZsPQm/AuDEqS0CgbfWQS++TPwT7mMJnowh+jtCr3628a6MCjxEDTnftZBZ/HUv58KZDA2Y+EM6hbUxbQsgB0qnCCLn14GZ+cccg5H9ziaHtU9UnIBaGxppPvt3XOiN65XDl8DfqKsbIB/Xg3GJzWTKEXjsOkVsCdgg7VXMHdlnV4XjHE+54mn8bkCMHPRTMbPHU9bR+x2kyVSQkhCtHbsehfsBu7Rg0d3zr67d+vOu5+965sKcgOn352D3wVEELqVd0uZw6XX+eK5UCWLBvxkCW9nuHUNdO0DZbvB6z9Pz/mKRqUTTiO7plx+i3cwvwFbmeulwikHVgH3+RzLy1JZiSTIDN+PspIyQhKiNFTaOfve3r4d02FojdUylGB3Dk3bm3xn3OGkIiDnimWyBvxECdfKm3b/hdakCEFppT1P0ejwvQgiqSzHWiJv8TlWGXaG79X8XOWZ8RAkhZEugtw59KruFfcFKVUpl2zLRb0CvpqneRHezjCdwV7KYcAkm7O/4FM7sy/qYA/BvfBj53t30Ip3sAe1WIgPv2rTspIyJE0psg7TETXYw47F4tWbV/uqZiJJlcOlK9Ucc/wYLjvispxqj6gBPxad7QyDBBQPSirw/JpDXWHgZBgw0S7QFnzOPihBNPrbsTP3VKAWC/Ey9vixTBgygcrSSqrKqygtKaWqvIrK0krOO/Q8X+uBdFEiJazdvNZX5hlJLsgm0412vIrFqgfBBGhQ7kVJJRz9a2j5HD5fAh8/CSWlO2wUTLvN1WuDlCjUAF3wn5mnCrVYiBcRYdwJ4xg9ePQuKQxjDN1v756VcTW3NdN7t96+BmeR5IJsMt1owI/Ezdsvu5mkgo278HrQ1Ttea220+v1t621T8961OqOPigFW4p+bTyVB9f5KJLEqXieeNNFXZpkOKkor6LtH37jPn26XTS8y1QxdA34kbt4+0WAvISgpjz5zL6suAl19KqjHNifJFGqxEEkqApCXyVlreyttJj13b27g7lbWbafzb23dSkeMu/ZMuGxGI5X2FEFQlU448ZiixeJrp8BJc3TmnjBB1DlgNfPx/u2WYReCS1EdfnTSIS2Mplr57b9+m5bZf3monMknT95JXumef13jOpasX8KT7z25kxQ007LJcNKh3VdZZlBWNsDiUcFsj2PRbxwcMV1VNgkTxEEzEcKrdtViIRbpLh5y7xzWN65n8frFPP3vpzsvLF1CXdjSmlwa78yDzuSZEc94Bu5syybDx5GO6tx0u2UWDs0b7IJqMrz3a5u6OXzcjoKt5g3WQz/cHlmJQRB1TiKMYccsXtNq0YjHHyfeABnrzsEYw1kHncU3e3yTntU9WfnFSma+PDOhmX9VWRUj+o/wnaXngssmxNcMPVXj1YAfTjyNTWLRvhXemgbt2+GdW4u4uUk0gvjYBGlaEi/dgAPQlI03yQQgv5x/uLOmi1sU9fT7T9Nv334YDBWlFZx98Nk7zfyD5v07yN6iayJkw2FTA344fWptUE4W0w5v37JzsZZ7EVluO98Ul21CLB+ba7D581HYNMsGYHdSL8VsQTX2/iQSgIIsOjZtb/K9c5gyfwrdyrrR0t4Sdebvl/fP1qJrMmTDYVMDfjhuY5NYnaiCYrbHXk8smuYm4YT3rXVx/8hvBiZhNffhC6mlpC7wq8Y+CIkEIK+Zu9vWr1d1L987B6Azfx8+8z+yx5GddxO50NowlQSxhE61VLQwF22TyZ27Ovy3ptrCq3A3zJJyO3s3SVoiF431MQRX3UTi+t9UYC8EIexMPRHUJycI8S4iBt1/7PFjmbpgqqezZpDzhY8zFxZdU0GmVTqFNcNPRWNwEZtuOWS0LZJqWgXbPobKXlDZHV77GUl74BdFcxOXoJ44kbRiu1L9CvgC2AP4OfFfOFRjHxTXHydo2mT2u7N9/XJKpIQ1X62hJEEXl2hrBrmy6JoKMn3XUlgBP9zszCXR3Hm0Iqn3/zcx+XckoQpbaVsUJKO6CWFn+GOc55uIbXEcjTK0jWF8BA1AHR0d9sLQ5v27aG5r5sMvPmR7guaDhe5v42VPkY67lsIJ+J1mZzFmgMnkzt07hzcngYdPd2A6tts7h5UNRSDVTEZ1E8tKwlMAACAASURBVGlo5gZud/HX75ilwLWoOic4QQPQWbPO4v3P3/c9XkWogvmr5yc8nmLwt4HM3bUUTsBfM9umcbxwG4PHmzt37xxSEezB3iEsn1okUs0gfWtjEbnYGt6f9npsUxOvmWMIm1IqjNv/TBIZgBpbGmlY1sCGpg10CXXhuZXPBTrO9o7tlIfKY9oZ+5FNf5tCpHACfpCiqSC588gF35pTve8cEsFdCC4KqWY1VnoZTyrGJZahWTVwoLPdC7U8TpZossugKc2QhBjadyjPf/h8QufOR6llrlM4AT9I0ZRX7jzWgm97S/pn3gUv1YxMxbjyy2bsrD3a7K8rcDZwJ9GLtIKkilSOmSzRZJdBOXDPA7m4/8UsXLPQU+pZXlIOYn1w8l1qmesUjiwziPGZV2PwFTOS099LKSCJp32KQqoZ2bf2fOB37HohaMFOI7s4/45mchZE7qlyzGRIto3hj4/6Mbedflsg6eYH137A8yufLwipZbYpDlmmX9GU608fLdj7Lfj6IaVw5K+gvSnxi0ZRSDWr2TWf7ubk3QvBYuApbCB3ddvu7LAu7D1+qSKVYyZLEKsFL/bquhdV5VWBpJ49qnsUjNQylymcgA87/Ocj0zJ+naWCLPh6Ydpg6Rh7wTl8AqyIOH+HU3lrPBYYi0qqGYl7IfCbtW/FBvhrsYE8VqqoHZVjJk8QqwUv7nj1Dqq7VBdchWw+UzgpnXDi7Sz19kxYNt4G7mRw7yLcoi33/DWnwpwDE083FTThhmofAA/i3emqCpvXD58NRqaK1PI4FTQsa2DUM6M88+9+RFbmJqM1z1RXqHwn7X74InIm8GvsNOsPxpj6iO1dsEbn38RWz3zfGLPK65gZ9cMP4oMv5SAG/ORlsQK31xqBe6EoSJVOLKIZqpXgLbMEe1M6nR3FWEq6SDaHD1BVXsWdZ9+ZVLomHU1ZChmvgJ9YvfPOBw8BvwfOAvoBl4hIv4jdfgR8YYw5CPj/gVuTPW9K6VPr749TUgqDboeSLt77uVr/SA4eBT3Ptvn+ki5AyC7UhiqLtJF5uKFaEzZfH6QaU5U3mcK1Wuha1jXhY8RTKetq/WcumknDsgYaWxqBnZVCTdubaOtoo2l7E9vatlG3oI76RfU+R1ZcUpHDPwb4wBizEkBEHgLOA94O2+c8YLLz70eB34mImFzJJwVd8O1o9r8wRC6+Rso9XaQEep4Fx/wflBfbbWkjdmafyMxRm41nkqj591AFTa3B0jxBKmW9LJbHHD+GWxfeSnOMGptkmrIUI0nP8IFewJqw52ud16LuY4xpAzYDe0ceSERGishiEVm8cePGFAwtDvqNtUE9VGln3lK66wzc1fp7Ebn4Gu7v09Zk1wk6Wqx88+On4f3fpfdz5SSJGqqp8ibTuFYLn1z/CXeefSfTh07nznPuZNJJk+ha6j/zD1Ip6zWDn7FwRszG4y6uwZriTypm+NGSZ5Ez9yD7YIy5G7gbbA4/+aHFQaRLZrQF3yANUkyHfQ+k198nr9lAsNl9OXZGr8qbbBNptWCMoUtpFya9OCmmbUKQSlm/torb2/3TfIVusJZKUjHDXwv0CXveG1gXax8RKcW2Nfo8BedOPa5L5sE/semY9++0i7qtjTtSP6EYM5tIrX88/j5FRQ3+M/wy4L+wC7R3Ap9i9fe6OJcLuDP/z274jOH9hlNaUkqXUBdCEqKqvIrK0spAkstktf5QPAZrqSAVM/zXgINF5OvAx8DFwIiIfeYAlwOvABcCc3Mmfx+Jn6f+QT+Fz1+HtU/Y7aYtttY/Vf4+Bcep+C/QtmKXfWrSPholcXar2I1Hhj+SsOQyWa0/qMFaPCQd8I0xbSIyGvg7dtr2R2PMChGZCiw2xswB/g+4X0Q+wM7sL072vGnDy1P/zZutRXJJuaPZ77AXiO6nwrENuy6+JuvvU7A8j03XeAX9cuAfqNNlYmRas56ovW+QtorloXIgenpHDdbiozALrxIliB9PLGpOh1Oe3dloLVl/n4JlJjAe7561qrdPhCCa9abtTTlTwBS0TeINx93AzEUzVYcfgOLw0kkFqx60i66JsOE5W62726E799JN1N+noFGny3Th1VR82vxpzPtwHi999NIu8sdsBc6gbRXHnTCOXx77y4LpZZstdIYPYR2tbk6BvUI3K7t08/qHTwQMrKiL4u9TyI1PvFCny1Tipm9Wf7maaQumJdRsJNGG2alAK2lTS9qtFdJBRgN+stbIXsTy1/Hz9yl4ZuDvdJlI8An35onmo184RAbKra1bfTXrXoT73iRCsusGyXrtKBYN+F4kk7cPSlHm6f0I99Ipwc72S53XbwImEZ8EM5o3TzQf/cJhxsIZMVMhiZCo743O0HMLzeF7kaw1chAS7aVb0Ag2CLdgZ/ul2EXcSuyibhfiC9Lh3jwu0Xz0CwO/gqVECFLAFG0W/7vXfhdz3aBugf3uRw8enTMLxcWMBvwgWvlkKUqtfRDqgdvYWZ7pWiPHE6T9vHkiffTzn1QULEXiVcDk5XfT2t5KW4y1r62tW7n5xZuZNn8aJVLCtrZtlJaUctWcq7jpxJuYdNIknf1nEA34QbTyyVKUWns/Uhmkg3jzlDj7FcZdVioKliLxKmDyUv/40dbRRlvHjguCq6efMn8Kr6x5hWd/8GxOSUULGQ34QfxxkiXcX0dxSGWQ3oDN2XvRjG2QUhgEKViKB68CpnSkj1yeW/kcp91/Gi+veTlnpKKFTCq8dPIb1x+npDI9xy9arb0fqQzSrq7fi8LS9dceWkt7h49Vd0DKQ+WevjfpSB+F88KHL6jXfYbQgA9WC9/rnNQfV0qLtLlJEFIZpGuxahwvCstHPxXNScBaC0840ervY82k05E+CoLrdZ+quxhFA75FBPYebAN0qiipgMF3WstlvSWNQiqDdDVWehkr+BWmj/7Y48cyYcgEKksrqSqvokTi/+9cWVpJ3z36eu7jpo+ygXrdpxYN+C5BmpvEg5TA/pek7ngFRyqCdCO2VfJMoCdwA1bWWYVdnqpynhemj35kc5Jbht7C8H7DqQhVUFVeRWmJ/wSmpb3F12kySPqorKRsp/NWlVdREaoglKTkWb3uU4su2rqkcvFW8/YBcYNwtGIpryDtVWQ1BjgAu0bQA3uHUNi/h0inSrdiddWXq5gyfwrtHm05JUCdQ1C/m9GDR+9SKXv7y7czZf6UxD4Y6nWfaoq30ra10RZdhRud/ft3iVksSBlg1CMnYRqBx7ELtEGCdLpsGQqLhmUNjHpmlGcOPGh1baLVtMYYznzgTJ5b+VxCnyFZu4diRCttw/FqcHL4BPvz1iTbczYIoUr45q9h+xfqkZMw1QTXxxdfkVWiBFlsDZoycdNH0WbxXsFYRHj2B88yZf4UZiycAUB7RzuVpZW0m3ZO3O9EXvropaiST/W6Tz3FF/C9GpysmG5TMd/7DOaeCp+/5n+8Xt+Bg65Oz1iVKBRfkVWiBNHqV4Qq+M/n/2HmopmBCp4SaXQiIkw+eXJUe+NuZd1i3jkEaZGoxEdxpXTiaUjy/p2w9Ca8lSQCR8yAw29M7TgVD7R5SlCCNBcB6FbWjZb2lqwanqlTZurQlI5LPE3FK2qgtNLbcqG0G3TtmdoxKj5o85Sg+C22umxptf5FkYZnmfTGT7RFohIfxSXLjKepeJ9auwDrhVomZIHiK7JKhkitfmlJKVU+a0xa8FS4FFfAD6K1d43OXMuFUAyduEovs0RxFlklSqRWf/rQ6YwYMIJuZd0836cFT4VJcQX8eGft/cbaoB6qhNIqW4lbWmWfq2VCFhmLDerFU2SVLG7KZMzxYzhwrwNpaW/x3F8LngqT4srhu7P2oE3FRaw1grYnzDEEq7MfTXz6fQUCqne04KkgKS6VDsTW4WvBlFIkBFHvaMFT/uKl0imulA7smLVf8Akc9d/Q5wLoeQ4cdYedyWuwVwocP6dNLXgqXIorpeNijGOjEDbLX/c0vP5zneUrRYFb0BRPwVO0frbalSq/KLyUTjSPnLKIP8oVM/zz+IerF4ulEVu1ugGrga/FKmWUQiBIwVOiPjpKdvBK6SQV8EVkL+BhoC+wCrjIGPNFlP3agbecpx8ZY871O3bcAT9obj6eatuiXpj1cqSciFXC6H/yYmDGwhm+TpmZLNJSvElnDn8s8IIx5mDgBWLr4bYZYwY5P77BPiHCPXLamsC02cf2bfb1t51WafFU2xY19VgTsm3YqtY253Gb87q2nis0GlsaaVjWwMxFM2lY1kBjS2NnP9tYlbpapJVfJJvDPw842fn3n4B5QOaNZVob7cw+1qy9fasN+odcG1+1bdGijpTFRKyUzTVPXcM5h5zj28/WLdJSa4TcJ9kZfndjzHoA5/FrMfarEJHFIvKqiJwf62AiMtLZb/HGjRuDjyJejxy/alspgcb/2AtJURKPI6WSL6z7ah0jnxzJ2bPOZuSTI1n31ToA6hfVU7egLmoj8SfefYKt2737Q2iRVv7gO8MXkeexq3WRjI/jPPsZY9aJyAHAXBF5yxjzn8idjDF3A3eDzeEHPno8s/aDf+Lf2apjO6yaBavuL1LVzgZszt6LZmzBk5LrdHR0cNass3ZpQnLP6/cw7OvDWPTRIppj/P9p7fDvC6FFWvmDb8A3xpwaa5uIfCIiPYwx60WkB/BpjGOscx5Xisg84Ehgl4CfMO6s3cvZMtIjx6+zVbt1EGS5dQ4sLtWOOlLmG16SyWjB3uWFD19IqPl5OB2mw7cvrpIbJJvSmQNc7vz7cuCJyB1EZE8R6eL8ex/geODtJM+7M8l65Hjh5v9bi2lRSh0p8wVjDDMWzqD77d0Z9cwoxs8dz6hnRtH99u7MWDiDjzd/7NtesMN0eG4XhLKSsqjbtEgrv0g24NcDp4nI+8BpznNE5GgR+YOzz2HAYhFZBrwI1BtjUhvw43W2DK+23X8ElJR7H7/oVDvqSJkveOXf6xbUUftI8hflrmVdOf/Q83e2WC6vorK0UrtS5RlJqXSMMZuAYVFeXwxc5fz7ZWBAMucJhOtcGVWHH8PZsqwaqg+0s38vilK1435f0XT46kiZC7iSyVieOFtbt7Jk/ZKkz2Mw/PG8P2KM0a5UeU7hWCsk6mwZT/6/qFBHylxn9ruzfSWTIQn5pmzc/dqjpEUjUzYqvcxvCifgu5RVw9fj+KPsU+uv2inqzlbVFHsz8FxlQ9MGmtu81VRBgj3AmOPHcMerd2gj8QKn8AJ+vMTrka8oOUIQX/vKskr67t6X5RuXx9zn9ANO55ZhtzDuhHGasilwCs88LRHUIz9FqNFaJgnqa7/+F+sZ/pfhUdU6px9wOn+79G+0t7ezdu1ampv96i+UXKGiooLevXtTVrazgipt5mnpJKMB36W1UTtbJYQarWWLeIzN1n21jqnzp/LRVx+x3277MfmUydRU2ZrKDz/8kOrqavbee291vswDjDFs2rSJxsZGvv71r++0zSvga0onnHjz/4pDuNGai5tmcArXKKbCtcwRj699z916ctd374p6nObmZvr27avBPk8QEfbee2/isqBBA76SNGq0lk1EhHEnjGP04NFJ59812OcXify+NOArSRKP0ZrePaWL6i7VO0kmXavjtHWnCtJoSMk5iq+nrZJiNmBn8V5sRY3WMkM0q4WRT45k75l7M/wvw/mq+atkT2A7xv21OyweBcvG28e/drevJ7EmWFUV+47kuOOOS/i4ftxyyy1pO3auoQFfSZLdsb46XnQAe2ZgLEo0q4WW9hZaO1p59O1H2Xvm3sxYOIOExRpBGw2liPZ2Wwz28ssvp/S44WjAVxQl7/DrTgXQZtqYNn8a9YsSCMydjYZiHD9FRoPz5s3jlFNOYcSIEQwYYF1Z3Nn/+vXrGTJkCIMGDaJ///689NJLu7x/xYoVHHPMMQwaNIiBAwfy/vvvA/DAAw90vv7jH/+Y9vZ2xo4dy7Zt2xg0aBCXXnopAL/61a/o378//fv354477gBgy5YtnHPOORxxxBH079+fhx9+GICpU6cyePBg+vfvz8iRIxO/kGYIDfhKkmzGX3IpwC6tjpUUE8RqAeg0Vou7LWEG24P+61//Yvr06bz99s4+iw8++CBnnHEGS5cuZdmyZQwaNGiX9951111cd911LF26lMWLF9O7d2/eeecdHn74YRYtWsTSpUsJhULMmjWL+vp6KisrWbp0KbNmzWLJkiXce++9/POf/+TVV1/lnnvu4Y033uDZZ5+lZ8+eLFu2jOXLl3PmmWcCMHr0aF577TWWL1/Otm3beOqpp5L+7OlEA76SJDXEdtV06Yp656efIFYLLm5bwrjIYHvQY445Zhd9OcDgwYO59957mTx5Mm+99RbV1bsuFB977LHccsst3HrrraxevZrKykpeeOEFlixZwuDBgxk0aBAvvPACK1eu3OW9CxcupLa2lm7dulFVVcUFF1zASy+9xIABA3j++ee58cYbeemll9h9990BePHFF/nWt77FgAEDmDt3LitWrEj6s6cTDfhKktTin8M3qHd++nGtFoKQUFvCIO1BU2Q02K1bt6ivDxkyhAULFtCrVy8uu+wyGhoamD17NoMGDWLQoEEsXryYESNGMGfOHCorKznjjDOYO3cuxhguv/xyli5dytKlS3nvvfeYPHnyLsePlZI55JBDWLJkCQMGDGDcuHFMnTqV5uZmfvrTn/Loo4/y1ltvcfXVV+d8pbIGfCVJ1Ds/V6g9tJb2Dr/GNZaE2hLG22goDaxevZqvfe1rXH311fzoRz/i9ddfp7a2tjOQH3300axcuZIDDjiAn/3sZ5x77rm8+eabDBs2jEcffZRPP7VN+T7//HNWr14NQFlZGa2ttpXjkCFDePzxx9m6dStbtmxh9uzZnHjiiaxbt46uXbvygx/8gOuvv57XX3+9M7jvs88+NDU18eijj6btc6cK1eErKUC983OB6i7VTDxpInXz69ja5i2VTagtYQ4YDc6bN4/bbruNsrIyqqqqaGho2GWfhx9+mAceeICysjJqamq4+eab2Wuvvairq+P000+no6ODsrIyfv/737P//vszcuRIBg4cyFFHHcWsWbO44oorOOaYYwC46qqrOPLII/n73//ODTfcQElJCWVlZfzP//wPe+yxB1dffTUDBgygb9++DB48OG2fO1Wol46SQhpR7/zsYoyhflE9k16cFLMBeaTHDsA777zDYYcdFuQEajSYQ0T7val5mpKDqLNmOvmq+SuuevIqq9yREG0dbVSWVdLe0c7EkyYy9vixO5XmBw74Lmo0mBPEG/A1paNkmFjOmtegzpqpY7eK3Xhk+CM0tjSmx+NejQbzEg34SoZRZ81MEumxoxQ3GvAjUVOoNKLOmoqSTTTgu8RajHrtGl2MShnqrKko2UQDvku4KZRLm5NqWO6kGg7XVENybMDm7L1oRp018wFddM9HtPAKMmYKpdRgF2i9qEBtGHIZA8wAugOjgPHOY3fn9fyzRw7K2WefzZdffhn3+yZPnsztt9+ehhHFjwZ8yKgpVHFTiy3G8qIDtWHIZcIX3ZuANudxm/N6/tkjh9PW1hZz2zPPPMMee+yRkXFEw2tsQUkq4IvIcBFZISIdIhJV9+nsd6aIvCciH4hI7pVdZtAUqrhRG4b8xl10j1XF6y66Z9ce+Vvf+tZOJmYnn3wyS5YsYcuWLVx55ZUMHjyYI488kieeeAKA++67j+HDh/Pd736X008/PeY5+vbty2effQZAQ0MDAwcO5IgjjuCyy+x60+rVqxk2bBgDBw5k2LBhfPTRR7uMbenSpXz7299m4MCB1NbW8sUXX3SO0a07+uyzz+jbt2/UsSVLsjP85cAFwIJYO4hICPg9cBbQD7hERPoled7UkkFTKGUsNqhXYgN7qfNYidow5DrxLLonRzL2yBdffDGPPPIIYC8Q69at45vf/CbTp09n6NChvPbaa7z44ovccMMNbNmyBYBXXnmFP/3pT8ydO9f3HCtWrGD69OnMnTuXZcuW8etf/xqwVsk//OEPefPNN7n00kv52c9+tsvYfvjDH3Lrrbfy5ptvMmDAAKZMmeL7XYSPLVmSCvjGmHeMMe/57HYM8IExZqUxZjvwEHBeMudNOTlgClU8CFZn/wlwJzDdefzUeV2VULlL5hbdk7FHvuiii/jLX/4CwCOPPMLw4cMBeO6556ivr2fQoEGcfPLJNDc3d87CTzvtNPbaa69A55g7dy4XXngh++yzD0Dn+1555RVGjBgBwGWXXcbChQt3et/mzZv58ssvOemkkwC4/PLLWbAg5ly5k/CxJUsmcvi9gDVhz9c6r+UOrilUKEaqIQOmUMVHNVZ6OcZ51O8298nconsy9si9evVi77335s033+Thhx/m4osvBqzP0GOPPdbprPnRRx912hKEny/aOcIxxuxkSxGLIPu4lJaW0tFhbcYjLZZjfReJ4BvwReR5EVke5SfoLD3ap466lC8iI0VksYgs3rhxY8DDp4h+Y21QD1VCaRVIqX0MVdrX+2mqQSl2sr/oHsQeGWxaZ+bMmWzevLlzHeCMM87gt7/9bafn/RtvvBH4HOEMGzaMRx55hE2bNgHWahmskuihhx4CYNasWZxwwgk7vW/33Xdnzz337FwTuP/++ztn+3379mXJkiUAabVZ9tXhG2NOTfIca4E+Yc97A+tinOtu4G6w5mlJnjc+RKzO/pDRagqlKFFxF93riL5wm/5F9yD2yAAXXngh1113HRMnTux8beLEifz85z9n4MCBGGPo27dv1JaEfuc4/PDDGT9+PCeddBKhUIgjjzyS++67j9/85jdceeWV3Hbbbey7777ce++9uxz7T3/6E9dccw1bt27lgAMO6Nzn+uuv56KLLuL+++9n6NChyXxFnqTELVNE5gHXG2N2sbcUkVLg38Aw4GPgNWCEMcazF5i6ZSpK5gjulhnL/K4dNb/LPBl1yxSRWuC3wL7A0yKy1Bhzhoj0BP5gjDnbGNMmIqOBv2P/Qv7oF+wVRclV3EX30Wjvg/wjqYBvjJlNFA2WMWYdcHbY82eAZ5I5l6IouYS76K7kE1ppqyiKUiRowFcURSkSNOAriqIUCWqPrCgpprGlkdnvzmZD0wZqqmqoPbSW6i6FZR1cDJ+xENEZvqKkCGMMMxbOoPvt3Rn1zCjGzx3PqGdG0f327sxYOINUSKCzTTo/Y7rtkefMmUN9ffxunkHOfdVVV+3i+5OLpESHnw5Uh6/kGzMWzqBuQR1bW3ctSupa1pUJQyYw7oTcbKITVIefzs9YVVVFU9POTpvt7e2EQn6GbcnR1tZGaWl+Jjvi1eHrDF9RUkBjSyPT5k+LGggBtrZupW5BHU3b87eJTqY+Y7rske+77z5Gjx4NwBVXXMEvfvELTjnlFG688UY2btzIaaedxlFHHcWPf/xj9t9//04rZPfc8+bN4+STT+bCCy/k0EMP5dJLL+28owm3N3722Wc56qijOOKIIxg2bBhg3T+PO+44jjzySI477jjee8/PczI9aMBXlBQw+93ZhEq8Z6IlUsLsd/K3iU4mP2M67JEj+fe//83zzz/Pf//3fzNlyhSGDh3a6c0TzcserP/OHXfcwdtvv83KlStZtGjRTts3btzI1VdfzWOPPcayZcs6XTsPPfRQFixYwBtvvMHUqVO56aabEvpekiU/72MUJcfY0LSB5jZv6+DmtmbWN+VvE51MfkYve+Qrr7yS1tZWzj///KgB/6KLLuK0005jypQpO9kjRzJ8+PDOdNHChQuZPdteqM4880z23HPPmOPq3bs3AIMGDWLVqlU7maS9+uqrDBkypHPsrq3x5s2bufzyy3n//fcREVpbW4N+FSlFZ/iKkgJqqmqoKPW2Dq4oraBHVf420cnkZ0yHPbLXOYKuZXbp0qXz36FQaJe2g7GskydOnMgpp5zC8uXLefLJJ3exQM4UGvAVJQXUHlpLe4e3dXCH6aD2sPxtopMLnzEZe2QvTjjhhM400HPPPdfZejBejj32WObPn8+HH34I7LBO3rx5M7162TYg9913X0LHTgUa8BUlBVR3qWbiSRPpWha9iY6rYKkqz1+DsVz4jPPmzWPQoEEceeSRPPbYY1x33XVR97vwwgt56KGHuOiiiwIdd9KkSTz33HMcddRR/O1vf6NHjx5Ru2n5se+++3L33XdzwQUXcMQRR/D9738fgDFjxjBu3DiOP/74zsbs2UBlmYqSIowx1C+qZ9r8aYRKQjS3NVNRWkF7RzsTT5rI2OPHxtUFKZMElWXm82f0oqWlhVAoRGlpKa+88go/+clPWLp0abaH5UtG7ZEVRdmBiDDuhHGMHjyax999nPVN6+lR1YPaw2rzemYfTqF+xo8++oiLLrqIjo4OysvLueeee7I9pLSgAV9RUkx1l2ouO6KwrYML7TMefPDBMVseFhKaw1cUBQiuVFFyg0R+XxrwFUWhoqKCTZs2adDPE4wxbNq0iYoKb5lsJJrSURSF3r17s3btWjZu3JjtoSgBqaio6CwCC4oGfEVRKCsri1rZqhQWmtJRFEUpEjTgK4qiFAka8BVFUYqEnK20FZGNwOoMnGof4LMMnCcV6FjTg4419eTLOKHwxrq/MWbfaBtyNuBnChFZHKsMOdfQsaYHHWvqyZdxQnGNVVM6iqIoRYIGfEVRlCJBAz7cne0BxIGONT3oWFNPvowTimisRZ/DVxRFKRZ0hq8oilIkaMBXFEUpEjTgAyIyTUTeFJGlIvKciPTM9phiISK3ici7znhni8ge2R5TNERkuIisEJEOEclJyZuInCki74nIByIyNtvjiYWI/FFEPhWR5dkeix8i0kdEXhSRd5zff/QehDmAiFSIyL9EZJkz1inZHpMfIhISkTdE5KlE3q8B33KbMWagMWYQ8BRwc7YH5ME/gP7GmIHAv4FxWR5PLJYDFwALsj2Qnqz5MgAAAplJREFUaIhICPg9cBbQD7hERPpld1QxuQ84M9uDCEgb8EtjzGHAt4FROfy9tgBDjTFHAIOAM0Xk21kekx/XAe8k+mYN+IAx5quwp92AnF3JNsY8Z4xpc56+CsTnj5ohjDHvGGPey/Y4PDgG+MAYs9IYsx14CDgvy2OKijFmAfB5tscRBGPMemPM686/G7HBqVd2RxUdY2lynpY5Pzn7f19EegPnAH9I9Bga8B1EZLqIrAEuJbdn+OFcCfwt24PIU3oBa8KeryVHA1O+IiJ9gSOBf2Z3JLFxUiRLgU+BfxhjcnaswB3AGKAj0QMUTcAXkedFZHmUn/MAjDHjjTF9gFnA6Fweq7PPeOzt86xcHmcOI1Fey9nZXb4hIlXAY8DPI+6gcwpjTLuTyu0NHCMi/bM9pmiIyHeAT40xS5I5TtE0QDHGnBpw1weBp4FJaRyOJ35jFZHLge8Aw0wWCyni+E5zkbVAn7DnvYF1WRpLQSEiZdhgP8sY89dsjycIxpgvRWQedq0kFxfHjwfOFZGzgQpgNxF5wBjzg3gOUjQzfC9E5OCwp+cC72ZrLH6IyJnAjcC5xpit2R5PHvMacLCIfF1EyoGLgTlZHlPeIyIC/B/wjjHmV9kejxcisq+rchORSuBUcvT/vjFmnDGmtzGmL/ZvdW68wR404LvUO6mIN4HTsSvhucrvgGrgH46M9K5sDygaIlIrImuBY4GnReTv2R5TOM7C92jg79iFxUeMMSuyO6roiMifgVeAb4jIWhH5UbbH5MHxwGXAUOfvc6kzK81FegAvOv/vX8Pm8BOSO+YLaq2gKIpSJOgMX1EUpUjQgK8oilIkaMBXFEUpEjTgK4qiFAka8BVFUYoEDfiKoihFggZ8RVGUIuH/AeVhJsDoHOG3AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_r[y == 0, 0], X_r[y == 0, 1], s =80, c = 'orange', label = 'Iris-setosa')\n",
    "plt.scatter(X_r[y == 1, 1], X_r[y == 1, 0], s =80,  c = 'yellow', label = 'Iris-versicolour')\n",
    "plt.scatter(X_r[y == 2, 0], X_r[y == 2, 1], s =80,  c = 'green', label = 'Iris-virginica')\n",
    "plt.title('PCA plot for Iris Dataset')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import neighbors, datasets, preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = iris.data\n",
    "y = iris.target\n",
    "Xtrain, Xtest, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)\n",
    "scaler = preprocessing.StandardScaler().fit(Xtrain)\n",
    "Xtrain = scaler.transform(Xtrain)\n",
    "Xtest = scaler.transform(Xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 0, 0, 1, 2, 0, 1, 1, 1, 1, 2, 0, 1, 0, 0, 0, 0, 2, 0, 2, 2,\n",
       "       2, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 2, 1])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using knn model for accuracy\n",
    "\n",
    "knn = neighbors.KNeighborsClassifier(n_neighbors=5)\n",
    "knn.fit(Xtrain, y_train)\n",
    "y_pred = knn.predict(Xtest)\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 0.9210526315789473\n",
      "Confusion matrix \n",
      " [[14  0  0]\n",
      " [ 0 14  1]\n",
      " [ 0  2  7]]\n",
      "Classification \n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        14\n",
      "           1       0.88      0.93      0.90        15\n",
      "           2       0.88      0.78      0.82         9\n",
      "\n",
      "    accuracy                           0.92        38\n",
      "   macro avg       0.92      0.90      0.91        38\n",
      "weighted avg       0.92      0.92      0.92        38\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "print('Accuracy Score:', accuracy_score(y_test, y_pred))\n",
    "print('Confusion matrix \\n',  confusion_matrix(y_test, y_pred))\n",
    "print('Classification \\n', classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8782051282051282"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xtrain, Xtest, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression :\n",
      "Accuracy =  0.9666666666666667\n",
      "[[11  0  0]\n",
      " [ 0 12  1]\n",
      " [ 0  0  6]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Ayantika\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "C:\\Users\\Ayantika\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:469: FutureWarning: Default multi_class will be changed to 'auto' in 0.22. Specify the multi_class option to silence this warning.\n",
      "  \"this warning.\", FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "#Logistic Regression\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifier = LogisticRegression()\n",
    "classifier.fit(Xtrain,y_train)\n",
    "y_pred = classifier.predict(Xtest)\n",
    "cm = confusion_matrix(y_test,y_pred)\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"Logistic Regression :\")\n",
    "print(\"Accuracy = \", accuracy)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cohen Kappa Accuracy For LR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9483648881239243"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# K Nearest Neighbors Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K Nearest Neighbors :\n",
      "Accuracy =  0.9666666666666667\n",
      "[[11  0  0]\n",
      " [ 0 12  1]\n",
      " [ 0  0  6]]\n"
     ]
    }
   ],
   "source": [
    "#K Nearest Neighbors\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "classifier = KNeighborsClassifier(n_neighbors=5, p=2, metric='minkowski')\n",
    "classifier.fit(Xtrain,y_train)\n",
    "y_pred = classifier.predict(Xtest)\n",
    "cm = confusion_matrix(y_test,y_pred)\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"K Nearest Neighbors :\")\n",
    "print(\"Accuracy = \", accuracy)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cohen Kappa Accuracy For KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9483648881239243"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xtrain, Xtest, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Support Vector Machine Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Support Vector Machine:\n",
      "Accuracy =  0.9733333333333334\n",
      "[[21  0  0]\n",
      " [ 0 29  1]\n",
      " [ 0  1 23]]\n"
     ]
    }
   ],
   "source": [
    "#Support Vector Machine\n",
    "from sklearn.svm import SVC\n",
    "classifier = SVC(kernel='linear',random_state=123)\n",
    "classifier.fit(Xtrain,y_train)\n",
    "y_pred = classifier.predict(Xtest)\n",
    "cm = confusion_matrix(y_test,y_pred)\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"Support Vector Machine:\")\n",
    "print(\"Accuracy = \", accuracy)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cohen Kappa Accuracy For SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.959546925566343"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gaussian Naive Bayes Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gaussian Naive Bayes :\n",
      "Accuracy =  0.9466666666666667\n",
      "[[21  0  0]\n",
      " [ 0 30  0]\n",
      " [ 0  4 20]]\n"
     ]
    }
   ],
   "source": [
    "#Gaussian Naive Bayes\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "classifier = GaussianNB()\n",
    "classifier.fit(Xtrain,y_train)\n",
    "y_pred = classifier.predict(Xtest)\n",
    "cm = confusion_matrix(y_test,y_pred)\n",
    "accuracy = accuracy_score(y_test,y_pred)\n",
    "print(\"Gaussian Naive Bayes :\")\n",
    "print(\"Accuracy = \", accuracy)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cohen Kappa Accuracy For GNB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9185667752442996"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Tree Classifier Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision Tree Classifier :\n",
      "Accuracy =  0.9466666666666667\n",
      "[[21  0  0]\n",
      " [ 0 29  1]\n",
      " [ 0  2 22]]\n"
     ]
    }
   ],
   "source": [
    "#Decision Tree Classifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier as DT\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "classifier = DT(criterion='entropy',max_depth=3,  random_state=0)\n",
    "classifier.fit(Xtrain,y_train)\n",
    "y_pred = classifier.predict(Xtest)\n",
    "cm = confusion_matrix(y_test,y_pred)\n",
    "print(\"Decision Tree Classifier :\")\n",
    "print(\"Accuracy = \", accuracy)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cohen Kappa Accuracy For DTC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9392220421393841"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest Classifier Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Classifier :\n",
      "Accuracy =  0.9466666666666667\n",
      "[[21  0  0]\n",
      " [ 0 29  1]\n",
      " [ 0  7 17]]\n"
     ]
    }
   ],
   "source": [
    "#Random Forest Classifier\n",
    "from sklearn.ensemble import RandomForestClassifier as RF\n",
    "classifier = RF(n_estimators=10, criterion='entropy', random_state=0)\n",
    "classifier.fit(Xtrain,y_train)\n",
    "y_pred = classifier.predict(Xtest)\n",
    "cm = confusion_matrix(y_test,y_pred)\n",
    "print(\"Random Forest Classifier :\")\n",
    "print(\"Accuracy = \", accuracy)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cohen Kappa Accuracy For RFC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8366013071895425"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import cohen_kappa_score\n",
    "cluster = cohen_kappa_score(y_test, y_pred)\n",
    "cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}