From 0a55071e36ac5354a0065ae684006a60807d8398 Mon Sep 17 00:00:00 2001 From: Joao Carrasco Soares Date: Wed, 15 Mar 2023 23:15:50 +0000 Subject: [PATCH] done --- your-code/lab_imbalance.ipynb | 664 +++++++++++++++++++++++++++++++++- 1 file changed, 647 insertions(+), 17 deletions(-) diff --git a/your-code/lab_imbalance.ipynb b/your-code/lab_imbalance.ipynb index a3a5359..ca50618 100644 --- a/your-code/lab_imbalance.ipynb +++ b/your-code/lab_imbalance.ipynb @@ -28,11 +28,359 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "# Your code here" + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
steptypeamountnameOrigoldbalanceOrgnewbalanceOrignameDestoldbalanceDestnewbalanceDestisFraudisFlaggedFraud
4322754308CASH_IN300104.98C186002225849610.00349714.98C5003120840.000.0000
2014520180PAYMENT2279.49C48951396745070.0042790.51M1000763670.000.0000
1464593140CASH_OUT207500.36C7666694400.000.00C20231765553377272.263567270.5500
1195060132TRANSFER561898.95C1047514788540585.000.00C212930538378744.41640643.3600
2181325185PAYMENT1825.79C953842295148853.03147027.24M17941738880.000.0000
\n", + "
" + ], + "text/plain": [ + " step type amount nameOrig oldbalanceOrg \\\n", + "4322754 308 CASH_IN 300104.98 C1860022258 49610.00 \n", + "2014520 180 PAYMENT 2279.49 C489513967 45070.00 \n", + "1464593 140 CASH_OUT 207500.36 C766669440 0.00 \n", + "1195060 132 TRANSFER 561898.95 C1047514788 540585.00 \n", + "2181325 185 PAYMENT 1825.79 C953842295 148853.03 \n", + "\n", + " newbalanceOrig nameDest oldbalanceDest newbalanceDest isFraud \\\n", + "4322754 349714.98 C500312084 0.00 0.00 0 \n", + "2014520 42790.51 M100076367 0.00 0.00 0 \n", + "1464593 0.00 C2023176555 3377272.26 3567270.55 0 \n", + "1195060 0.00 C2129305383 78744.41 640643.36 0 \n", + "2181325 147027.24 M1794173888 0.00 0.00 0 \n", + "\n", + " isFlaggedFraud \n", + "4322754 0 \n", + "2014520 0 \n", + "1464593 0 \n", + "1195060 0 \n", + "2181325 0 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here\n", + "df = pd.read_csv(\"PS_20174392719_1491204439457_log.csv\").sample(1000000)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "step int64\n", + "type object\n", + "amount float64\n", + "nameOrig object\n", + "oldbalanceOrg float64\n", + "newbalanceOrig float64\n", + "nameDest object\n", + "oldbalanceDest float64\n", + "newbalanceDest float64\n", + "isFraud int64\n", + "isFlaggedFraud int64\n", + "dtype: object" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.dtypes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\jmpcs\\AppData\\Local\\Temp\\ipykernel_21428\\1134722465.py:1: FutureWarning: The default value of numeric_only in DataFrame.corr is deprecated. In a future version, it will default to False. Select only valid columns or specify the value of numeric_only to silence this warning.\n", + " df.corr()\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stepamountoldbalanceOrgnewbalanceOrigoldbalanceDestnewbalanceDestisFraudisFlaggedFraud
step1.0000000.022195-0.010006-0.0103030.0288830.0270780.0325510.001617
amount0.0221951.000000-0.002772-0.0078990.2925670.4555280.0790090.016886
oldbalanceOrg-0.010006-0.0027721.0000000.9988090.0666700.0427370.0096610.005578
newbalanceOrig-0.010303-0.0078990.9988091.0000000.0681560.042505-0.0086950.005499
oldbalanceDest0.0288830.2925670.0666700.0681561.0000000.977110-0.005703-0.000455
newbalanceDest0.0270780.4555280.0427370.0425050.9771101.0000000.000739-0.000470
isFraud0.0325510.0790090.009661-0.008695-0.0057030.0007391.0000000.039674
isFlaggedFraud0.0016170.0168860.0055780.005499-0.000455-0.0004700.0396741.000000
\n", + "
" + ], + "text/plain": [ + " step amount oldbalanceOrg newbalanceOrig \\\n", + "step 1.000000 0.022195 -0.010006 -0.010303 \n", + "amount 0.022195 1.000000 -0.002772 -0.007899 \n", + "oldbalanceOrg -0.010006 -0.002772 1.000000 0.998809 \n", + "newbalanceOrig -0.010303 -0.007899 0.998809 1.000000 \n", + "oldbalanceDest 0.028883 0.292567 0.066670 0.068156 \n", + "newbalanceDest 0.027078 0.455528 0.042737 0.042505 \n", + "isFraud 0.032551 0.079009 0.009661 -0.008695 \n", + "isFlaggedFraud 0.001617 0.016886 0.005578 0.005499 \n", + "\n", + " oldbalanceDest newbalanceDest isFraud isFlaggedFraud \n", + "step 0.028883 0.027078 0.032551 0.001617 \n", + "amount 0.292567 0.455528 0.079009 0.016886 \n", + "oldbalanceOrg 0.066670 0.042737 0.009661 0.005578 \n", + "newbalanceOrig 0.068156 0.042505 -0.008695 0.005499 \n", + "oldbalanceDest 1.000000 0.977110 -0.005703 -0.000455 \n", + "newbalanceDest 0.977110 1.000000 0.000739 -0.000470 \n", + "isFraud -0.005703 0.000739 1.000000 0.039674 \n", + "isFlaggedFraud -0.000455 -0.000470 0.039674 1.000000 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.corr()" ] }, { @@ -44,11 +392,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGnCAYAAABl41fiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAaQUlEQVR4nO3db2yd5X3/8Y9jiNOO2kBd7CTzZspGoQKS1AFjKO3QvKYsyhZN3SK6NVlaqKgyxLDQmhRIlrXFdCJpVBEWNSPNeMDIqFbUNSiFWUNdh6UMZ+kfiT+jGU0Es5Moqg1mc6jt3wM0I//ihJyQ5MLO6yWdB1y+r3O+RyLxO/c59zlVo6OjowEAKGRa6QEAgDObGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIqaVDHygx/8IIsWLcqsWbNSVVWVxx57rOL7GB0dzX333ZeLL744NTU1mT17dr761a+e/GEBgONyVukBKjE4OJg5c+bks5/9bP7gD/7ghO7jtttuyxNPPJH77rsvl19+eQ4dOpRDhw6d5EkBgONVNVm/KK+qqirf+c53snjx4rG1oaGh3Hnnnfn7v//7/OIXv8hll12Wr33ta/mt3/qtJMmzzz6bK664Ij/96U/zoQ99qMzgAMA4k+plmrfzZ3/2Z+nu7s4jjzySH//4x/nDP/zDfPKTn8x//ud/Jkn+6Z/+KR/84Afzve99LxdeeGGam5tz0003OTMCAAVNmRjZu3dvvvWtb+XRRx/Nddddl4suuih33HFHPvrRj+Zb3/pWkmTPnj35+c9/nkcffTQPPfRQtm7dmp6ennzqU58qPD0AnLkm1XtGjuUnP/lJhoeHc/HFF49bHxoayvvf//4kycjISIaGhvLQQw+NHffggw+mpaUlzz//vJduAKCAKRMjr732Wqqrq9PT05Pq6upxPzvnnHOSJDNnzsxZZ501LlguvfTSJG+eWREjAHD6TZkYmTdvXoaHh7N///5cd911Ex5z7bXX5pe//GV+9rOf5aKLLkqSvPDCC0mSX//1Xz9tswIAb5lUV9O89tprefHFF5O8GR/r16/P9ddfn/PPPz+/9mu/lj/5kz/Jv/3bv2XdunWZN29eDhw4kK6urlxxxRVZuHBhRkZGcuWVV+acc87Jhg0bMjIykhUrVqS2tjZPPPFE4WcHAGemSRUjTz31VK6//voj1pctW5atW7fmjTfeyFe+8pU89NBDefnll1NfX5+rr746a9euzeWXX54keeWVV3LrrbfmiSeeyK/8yq/khhtuyLp163L++eef7qcDAGSSxQgAMPVMmUt7AYDJSYwAAEVNiqtpRkZG8sorr+R973tfqqqqSo8DAByH0dHRvPrqq5k1a1amTTv6+Y9JESOvvPJKmpqaSo8BAJyAffv25Vd/9VeP+vNJESPve9/7krz5ZGprawtPAwAcj4GBgTQ1NY39Hj+aSREj//fSTG1trRgBgEnm7d5i4Q2sAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEACiq4hj5wQ9+kEWLFmXWrFmpqqrKY4899rZ7nnrqqXzkIx9JTU1NfuM3fiNbt249gVEBgKmo4hgZHBzMnDlzsnHjxuM6/r/+67+ycOHCXH/99dm9e3f+/M//PDfddFO+//3vVzwsADD1VPxFeTfccENuuOGG4z5+06ZNufDCC7Nu3bokyaWXXpof/vCH+frXv54FCxZU+vAAwBRzyt8z0t3dnfb29nFrCxYsSHd391H3DA0NZWBgYNwNAJiaKj4zUqne3t40NDSMW2toaMjAwED+53/+J+95z3uO2NPZ2Zm1a9ee6tEmheaV20uPwGn00r0LS48AcNq9K6+mWbVqVfr7+8du+/btKz0SAHCKnPIzI42Njenr6xu31tfXl9ra2gnPiiRJTU1NampqTvVoAMC7wCk/M9LW1paurq5xa08++WTa2tpO9UMDAJNAxTHy2muvZffu3dm9e3eSNy/d3b17d/bu3ZvkzZdYli5dOnb8Lbfckj179uQv/uIv8txzz+WBBx7IP/zDP+T2228/Oc8AAJjUKo6RZ555JvPmzcu8efOSJB0dHZk3b15Wr16dJPnv//7vsTBJkgsvvDDbt2/Pk08+mTlz5mTdunX527/9W5f1AgBJkqrR0dHR0kO8nYGBgdTV1aW/vz+1tbWlxzmtXE1zZnE1DTCVHO/v73fl1TQAwJlDjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgqBOKkY0bN6a5uTkzZsxIa2trdu7ceczjN2zYkA996EN5z3vek6amptx+++353//93xMaGACYWiqOkW3btqWjoyNr1qzJrl27MmfOnCxYsCD79++f8PiHH344K1euzJo1a/Lss8/mwQcfzLZt2/KlL33pHQ8PAEx+FcfI+vXrc/PNN2f58uX58Ic/nE2bNuW9731vtmzZMuHxTz/9dK699tp8+tOfTnNzcz7xiU/kxhtvfNuzKQDAmaGiGDl8+HB6enrS3t7+1h1Mm5b29vZ0d3dPuOeaa65JT0/PWHzs2bMnjz/+eH73d3/3qI8zNDSUgYGBcTcAYGo6q5KDDx48mOHh4TQ0NIxbb2hoyHPPPTfhnk9/+tM5ePBgPvrRj2Z0dDS//OUvc8sttxzzZZrOzs6sXbu2ktEAgEnqlF9N89RTT+Wee+7JAw88kF27duUf//Efs3379nz5y18+6p5Vq1alv79/7LZv375TPSYAUEhFZ0bq6+tTXV2dvr6+cet9fX1pbGyccM/dd9+dz3zmM7npppuSJJdffnkGBwfz+c9/PnfeeWemTTuyh2pqalJTU1PJaADAJFXRmZHp06enpaUlXV1dY2sjIyPp6upKW1vbhHtef/31I4Kjuro6STI6OlrpvADAFFPRmZEk6ejoyLJlyzJ//vxcddVV2bBhQwYHB7N8+fIkydKlSzN79ux0dnYmSRYtWpT169dn3rx5aW1tzYsvvpi77747ixYtGosSAODMVXGMLFmyJAcOHMjq1avT29ubuXPnZseOHWNvat27d++4MyF33XVXqqqqctddd+Xll1/OBz7wgSxatChf/epXT96zAAAmrarRSfBaycDAQOrq6tLf35/a2trS45xWzSu3lx6B0+ilexeWHgHgpDne39++mwYAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFHVCMbJx48Y0NzdnxowZaW1tzc6dO495/C9+8YusWLEiM2fOTE1NTS6++OI8/vjjJzQwADC1nFXphm3btqWjoyObNm1Ka2trNmzYkAULFuT555/PBRdccMTxhw8fzu/8zu/kggsuyLe//e3Mnj07P//5z3PuueeejPkBgEmu4hhZv359br755ixfvjxJsmnTpmzfvj1btmzJypUrjzh+y5YtOXToUJ5++umcffbZSZLm5uZ3NjUAMGVU9DLN4cOH09PTk/b29rfuYNq0tLe3p7u7e8I93/3ud9PW1pYVK1akoaEhl112We65554MDw8f9XGGhoYyMDAw7gYATE0VxcjBgwczPDychoaGcesNDQ3p7e2dcM+ePXvy7W9/O8PDw3n88cdz9913Z926dfnKV75y1Mfp7OxMXV3d2K2pqamSMQGASeSUX00zMjKSCy64IN/85jfT0tKSJUuW5M4778ymTZuOumfVqlXp7+8fu+3bt+9UjwkAFFLRe0bq6+tTXV2dvr6+cet9fX1pbGyccM/MmTNz9tlnp7q6emzt0ksvTW9vbw4fPpzp06cfsaempiY1NTWVjAYATFIVnRmZPn16Wlpa0tXVNbY2MjKSrq6utLW1Tbjn2muvzYsvvpiRkZGxtRdeeCEzZ86cMEQAgDNLxS/TdHR0ZPPmzfm7v/u7PPvss/nCF76QwcHBsatrli5dmlWrVo0d/4UvfCGHDh3KbbfdlhdeeCHbt2/PPffckxUrVpy8ZwEATFoVX9q7ZMmSHDhwIKtXr05vb2/mzp2bHTt2jL2pde/evZk27a3GaWpqyve///3cfvvtueKKKzJ79uzcdttt+eIXv3jyngUAMGlVjY6OjpYe4u0MDAykrq4u/f39qa2tLT3OadW8cnvpETiNXrp3YekRAE6a4/397btpAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAijqhGNm4cWOam5szY8aMtLa2ZufOnce175FHHklVVVUWL158Ig8LAExBFcfItm3b0tHRkTVr1mTXrl2ZM2dOFixYkP379x9z30svvZQ77rgj11133QkPCwBMPRXHyPr163PzzTdn+fLl+fCHP5xNmzblve99b7Zs2XLUPcPDw/njP/7jrF27Nh/84Aff0cAAwNRSUYwcPnw4PT09aW9vf+sOpk1Le3t7uru7j7rvr/7qr3LBBRfkc5/73HE9ztDQUAYGBsbdAICpqaIYOXjwYIaHh9PQ0DBuvaGhIb29vRPu+eEPf5gHH3wwmzdvPu7H6ezsTF1d3ditqampkjEBgEnklF5N8+qrr+Yzn/lMNm/enPr6+uPet2rVqvT394/d9u3bdwqnBABKOquSg+vr61NdXZ2+vr5x6319fWlsbDzi+J/97Gd56aWXsmjRorG1kZGRNx/4rLPy/PPP56KLLjpiX01NTWpqaioZDQCYpCo6MzJ9+vS0tLSkq6trbG1kZCRdXV1pa2s74vhLLrkkP/nJT7J79+6x2+/93u/l+uuvz+7du738AgBUdmYkSTo6OrJs2bLMnz8/V111VTZs2JDBwcEsX748SbJ06dLMnj07nZ2dmTFjRi677LJx+88999wkOWIdADgzVRwjS5YsyYEDB7J69er09vZm7ty52bFjx9ibWvfu3Ztp03ywKwBwfKpGR0dHSw/xdgYGBlJXV5f+/v7U1taWHue0al65vfQInEYv3buw9AgAJ83x/v52CgMAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFHVCMbJx48Y0NzdnxowZaW1tzc6dO4967ObNm3PdddflvPPOy3nnnZf29vZjHg8AnFkqjpFt27alo6Mja9asya5duzJnzpwsWLAg+/fvn/D4p556KjfeeGP+5V/+Jd3d3WlqasonPvGJvPzyy+94eABg8qsaHR0drWRDa2trrrzyytx///1JkpGRkTQ1NeXWW2/NypUr33b/8PBwzjvvvNx///1ZunTpcT3mwMBA6urq0t/fn9ra2krGnfSaV24vPQKn0Uv3Liw9AsBJc7y/vys6M3L48OH09PSkvb39rTuYNi3t7e3p7u4+rvt4/fXX88Ybb+T8888/6jFDQ0MZGBgYdwMApqaKYuTgwYMZHh5OQ0PDuPWGhob09vYe13188YtfzKxZs8YFzf+vs7MzdXV1Y7empqZKxgQAJpHTejXNvffem0ceeSTf+c53MmPGjKMet2rVqvT394/d9u3bdxqnBABOp7MqObi+vj7V1dXp6+sbt97X15fGxsZj7r3vvvty77335p//+Z9zxRVXHPPYmpqa1NTUVDIaADBJVXRmZPr06WlpaUlXV9fY2sjISLq6utLW1nbUfX/913+dL3/5y9mxY0fmz59/4tMCAFNORWdGkqSjoyPLli3L/Pnzc9VVV2XDhg0ZHBzM8uXLkyRLly7N7Nmz09nZmST52te+ltWrV+fhhx9Oc3Pz2HtLzjnnnJxzzjkn8akAAJNRxTGyZMmSHDhwIKtXr05vb2/mzp2bHTt2jL2pde/evZk27a0TLn/zN3+Tw4cP51Of+tS4+1mzZk3+8i//8p1NDwBMehV/zkgJPmeEM4XPGQGmklPyOSMAACebGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCKEiMAQFFiBAAoSowAAEWJEQCgKDECABQlRgCAosQIAFCUGAEAihIjAEBRYgQAKEqMAABFiREAoCgxAgAUJUYAgKLECABQlBgBAIoSIwBAUScUIxs3bkxzc3NmzJiR1tbW7Ny585jHP/roo7nkkksyY8aMXH755Xn88cdPaFgAYOqpOEa2bduWjo6OrFmzJrt27cqcOXOyYMGC7N+/f8Ljn3766dx444353Oc+l//4j//I4sWLs3jx4vz0pz99x8MDAJNf1ejo6GglG1pbW3PllVfm/vvvT5KMjIykqakpt956a1auXHnE8UuWLMng4GC+973vja1dffXVmTt3bjZt2nRcjzkwMJC6urr09/entra2knEnveaV20uPwGn00r0LS48AcNIc7+/vsyq508OHD6enpyerVq0aW5s2bVra29vT3d094Z7u7u50dHSMW1uwYEEee+yxoz7O0NBQhoaGxv67v78/yZtP6kwzMvR66RE4jc7E/8eBqev//k57u/MeFcXIwYMHMzw8nIaGhnHrDQ0Nee655ybc09vbO+Hxvb29R32czs7OrF279oj1pqamSsaFSaduQ+kJAE6+V199NXV1dUf9eUUxcrqsWrVq3NmUkZGRHDp0KO9///tTVVVVcDJOh4GBgTQ1NWXfvn1n3MtyMNX5831mGR0dzauvvppZs2Yd87iKYqS+vj7V1dXp6+sbt97X15fGxsYJ9zQ2NlZ0fJLU1NSkpqZm3Nq5555byahMAbW1tf6yginKn+8zx7HOiPyfiq6mmT59elpaWtLV1TW2NjIykq6urrS1tU24p62tbdzxSfLkk08e9XgA4MxS8cs0HR0dWbZsWebPn5+rrroqGzZsyODgYJYvX54kWbp0aWbPnp3Ozs4kyW233ZaPf/zjWbduXRYuXJhHHnkkzzzzTL75zW+e3GcCAExKFcfIkiVLcuDAgaxevTq9vb2ZO3duduzYMfYm1b1792batLdOuFxzzTV5+OGHc9ddd+VLX/pSfvM3fzOPPfZYLrvsspP3LJhSampqsmbNmiNeqgMmP3++mUjFnzMCAHAy+W4aAKAoMQIAFCVGAICixAgAUJQYAQCKeld+HDxnloMHD2bLli3p7u4e+86ixsbGXHPNNfnTP/3TfOADHyg8IQCnkjMjFPXv//7vufjii/ONb3wjdXV1+djHPpaPfexjqauryze+8Y1ccskleeaZZ0qPCZwC+/bty2c/+9nSY/Au4HNGKOrqq6/OnDlzsmnTpiO+BHF0dDS33HJLfvzjH6e7u7vQhMCp8qMf/Sgf+chHMjw8XHoUCvMyDUX96Ec/ytatWyf8NuaqqqrcfvvtmTdvXoHJgHfqu9/97jF/vmfPntM0Ce92YoSiGhsbs3PnzlxyySUT/nznzp1jXzUATC6LFy9OVVVVjnUCfqJ/iHDmESMUdccdd+Tzn/98enp68tu//dtj4dHX15eurq5s3rw59913X+EpgRMxc+bMPPDAA/n93//9CX++e/futLS0nOapeDcSIxS1YsWK1NfX5+tf/3oeeOCBsdeOq6ur09LSkq1bt+aP/uiPCk8JnIiWlpb09PQcNUbe7qwJZw5vYOVd44033sjBgweTJPX19Tn77LMLTwS8E//6r/+awcHBfPKTn5zw54ODg3nmmWfy8Y9//DRPxruNGAEAivI5IwBAUWIEAChKjAAARYkRAKAoMQIAFCVGAICixAgAUJQYAQCK+n/CtoRxFL8OBAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Your response here" + "# Your response here\n", + "pd.value_counts(df['isFraud']).plot(kind = 'bar')" ] }, { @@ -60,11 +430,193 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHaCAYAAADseiazAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDDUlEQVR4nO3df1zV9d3/8ScHBX+eQ2qCJP6aTSV/JSaxfiyTJMUuXbipuSI1nQ69Eq4SbYZlWzp3Veq03C5FdEkzm7UpiTFMXIGaOFJZOmsa7tKDlMoxElA43z/68rk8SioVHDzvx/12O7db57xf58OL80l48vm8P++Pn9vtdgsAAMBANm83AAAA4C0EIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsZp4u4HGrLq6WsePH1fr1q3l5+fn7XYAAMA1cLvdOnv2rEJDQ2WzXfmYD0HoCo4fP66wsDBvtwEAAL6BY8eOqWPHjlesIQhdQevWrSV99UHa7XYvdwMAAK6Fy+VSWFiY9Xv8SghCV1BzOsxutxOEAAC4zlzLtBYmSwMAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgrDoFoVdeeUV9+/a1bkIaFRWlLVu2WOP33HOP/Pz8PB5Tp0712EZRUZFiY2PVokULtW/fXk8++aQuXLjgUbN9+3YNGDBAgYGB6t69u9LS0i7rZfny5erSpYuaNWumyMhI7d6922O8vLxcCQkJatu2rVq1aqW4uDgVFxfX5dsFAAA+rk5BqGPHjlq4cKHy8/O1Z88e3XvvvRo5cqQKCwutmsmTJ+vEiRPWY9GiRdZYVVWVYmNjVVlZqdzcXK1Zs0ZpaWlKSUmxao4cOaLY2FgNHjxYBQUFmjlzph577DFt3brVqlm/fr2SkpI0b9487d27V/369VNMTIxOnjxp1SQmJmrTpk3asGGDcnJydPz4cT344IPf6EMCAAC+yc/tdru/zQbatGmj3/zmN5o0aZLuuece9e/fX4sXL661dsuWLRoxYoSOHz+u4OBgSdKKFSuUnJyskpISBQQEKDk5WRkZGTpw4ID1vrFjx+rMmTPKzMyUJEVGRuq2227TsmXLJEnV1dUKCwvTjBkzNHv2bJWWlurGG29Uenq6Ro8eLUk6ePCgevXqpby8PN1+++3X9L25XC45HA6VlpbKbrd/04/oqrrMzqi3bTekowtjvd0CAAB1+v39jecIVVVV6Y9//KPKysoUFRVlvb5u3Tq1a9dOvXv31pw5c/Tll19aY3l5eerTp48VgiQpJiZGLpfLOqqUl5en6Ohoj68VExOjvLw8SVJlZaXy8/M9amw2m6Kjo62a/Px8nT9/3qOmZ8+e6tSpk1VTm4qKCrlcLo8HAADwXU3q+ob9+/crKipK5eXlatWqld58802Fh4dLkh566CF17txZoaGh2rdvn5KTk3Xo0CFt3LhRkuR0Oj1CkCTrudPpvGKNy+XSuXPndPr0aVVVVdVac/DgQWsbAQEBCgoKuqym5uvUZsGCBXr22Wfr+IkAAIDrVZ2DUI8ePVRQUKDS0lK98cYbio+PV05OjsLDwzVlyhSrrk+fPurQoYOGDBmiTz75RN/73ve+08brw5w5c5SUlGQ9d7lcCgsL82JHAACgPtX51FhAQIC6d++uiIgILViwQP369dOSJUtqrY2MjJQkffzxx5KkkJCQy67cqnkeEhJyxRq73a7mzZurXbt28vf3r7Xm4m1UVlbqzJkzX1tTm8DAQOuKuJoHAADwXd96HaHq6mpVVFTUOlZQUCBJ6tChgyQpKipK+/fv97i6KysrS3a73Tq9FhUVpezsbI/tZGVlWfOQAgICFBER4VFTXV2t7OxsqyYiIkJNmzb1qDl06JCKioo85jMBAACz1enU2Jw5czRs2DB16tRJZ8+eVXp6urZv366tW7fqk08+UXp6uoYPH662bdtq3759SkxM1N13362+fftKkoYOHarw8HA9/PDDWrRokZxOp+bOnauEhAQFBgZKkqZOnaply5Zp1qxZmjhxorZt26bXX39dGRn/d2VVUlKS4uPjNXDgQA0aNEiLFy9WWVmZJkyYIElyOByaNGmSkpKS1KZNG9ntds2YMUNRUVHXfMUYAADwfXUKQidPntQjjzyiEydOyOFwqG/fvtq6davuu+8+HTt2TH/961+tUBIWFqa4uDjNnTvXer+/v782b96sadOmKSoqSi1btlR8fLzmz59v1XTt2lUZGRlKTEzUkiVL1LFjR61cuVIxMTFWzZgxY1RSUqKUlBQ5nU71799fmZmZHhOoX3rpJdlsNsXFxamiokIxMTF6+eWXv81nBQAAfMy3XkfIl7GOUN2wjhAAoDFokHWEAAAArncEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjFXnW2wAvowr+ADALBwRAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGqlMQeuWVV9S3b1/Z7XbZ7XZFRUVpy5Yt1nh5ebkSEhLUtm1btWrVSnFxcSouLvbYRlFRkWJjY9WiRQu1b99eTz75pC5cuOBRs337dg0YMECBgYHq3r270tLSLutl+fLl6tKli5o1a6bIyEjt3r3bY/xaegEAAGarUxDq2LGjFi5cqPz8fO3Zs0f33nuvRo4cqcLCQklSYmKiNm3apA0bNignJ0fHjx/Xgw8+aL2/qqpKsbGxqqysVG5urtasWaO0tDSlpKRYNUeOHFFsbKwGDx6sgoICzZw5U4899pi2bt1q1axfv15JSUmaN2+e9u7dq379+ikmJkYnT560aq7WCwAAgJ/b7XZ/mw20adNGv/nNbzR69GjdeOONSk9P1+jRoyVJBw8eVK9evZSXl6fbb79dW7Zs0YgRI3T8+HEFBwdLklasWKHk5GSVlJQoICBAycnJysjI0IEDB6yvMXbsWJ05c0aZmZmSpMjISN12221atmyZJKm6ulphYWGaMWOGZs+erdLS0qv2ci1cLpccDodKS0tlt9u/zcd0RV1mZ9TbthvS0YWx3m7hW2NfAMD1ry6/v7/xHKGqqir98Y9/VFlZmaKiopSfn6/z588rOjraqunZs6c6deqkvLw8SVJeXp769OljhSBJiomJkcvlso4q5eXleWyjpqZmG5WVlcrPz/eosdlsio6OtmqupZfaVFRUyOVyeTwAAIDvqnMQ2r9/v1q1aqXAwEBNnTpVb775psLDw+V0OhUQEKCgoCCP+uDgYDmdTkmS0+n0CEE14zVjV6pxuVw6d+6cPvvsM1VVVdVac/E2rtZLbRYsWCCHw2E9wsLCru1DAQAA16U6B6EePXqooKBAu3bt0rRp0xQfH69//OMf9dFbg5szZ45KS0utx7Fjx7zdEgAAqEdN6vqGgIAAde/eXZIUERGhDz74QEuWLNGYMWNUWVmpM2fOeByJKS4uVkhIiCQpJCTksqu7aq7kurjm0qu7iouLZbfb1bx5c/n7+8vf37/Wmou3cbVeahMYGKjAwMA6fBoAAOB69q3XEaqurlZFRYUiIiLUtGlTZWdnW2OHDh1SUVGRoqKiJElRUVHav3+/x9VdWVlZstvtCg8Pt2ou3kZNTc02AgICFBER4VFTXV2t7Oxsq+ZaegEAAKjTEaE5c+Zo2LBh6tSpk86ePav09HRt375dW7dulcPh0KRJk5SUlKQ2bdrIbrdrxowZioqKsq7SGjp0qMLDw/Xwww9r0aJFcjqdmjt3rhISEqwjMVOnTtWyZcs0a9YsTZw4Udu2bdPrr7+ujIz/u5onKSlJ8fHxGjhwoAYNGqTFixerrKxMEyZMkKRr6gUAAKBOQejkyZN65JFHdOLECTkcDvXt21dbt27VfffdJ0l66aWXZLPZFBcXp4qKCsXExOjll1+23u/v76/Nmzdr2rRpioqKUsuWLRUfH6/58+dbNV27dlVGRoYSExO1ZMkSdezYUStXrlRMTIxVM2bMGJWUlCglJUVOp1P9+/dXZmamxwTqq/UCAADwrdcR8mWsI1Q3vrB2DfsCAK5/DbKOEAAAwPWOIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgrDoFoQULFui2225T69at1b59e40aNUqHDh3yqLnnnnvk5+fn8Zg6dapHTVFRkWJjY9WiRQu1b99eTz75pC5cuOBRs337dg0YMECBgYHq3r270tLSLutn+fLl6tKli5o1a6bIyEjt3r3bY7y8vFwJCQlq27atWrVqpbi4OBUXF9flWwYAAD6sTkEoJydHCQkJ2rlzp7KysnT+/HkNHTpUZWVlHnWTJ0/WiRMnrMeiRYussaqqKsXGxqqyslK5ublas2aN0tLSlJKSYtUcOXJEsbGxGjx4sAoKCjRz5kw99thj2rp1q1Wzfv16JSUlad68edq7d6/69eunmJgYnTx50qpJTEzUpk2btGHDBuXk5Oj48eN68MEH6/whAQAA3+Tndrvd3/TNJSUlat++vXJycnT33XdL+uqIUP/+/bV48eJa37NlyxaNGDFCx48fV3BwsCRpxYoVSk5OVklJiQICApScnKyMjAwdOHDAet/YsWN15swZZWZmSpIiIyN12223admyZZKk6upqhYWFacaMGZo9e7ZKS0t14403Kj09XaNHj5YkHTx4UL169VJeXp5uv/32q35/LpdLDodDpaWlstvt3/RjuqouszPqbdsN6ejCWG+38K2xLwDg+leX39/fao5QaWmpJKlNmzYer69bt07t2rVT7969NWfOHH355ZfWWF5envr06WOFIEmKiYmRy+VSYWGhVRMdHe2xzZiYGOXl5UmSKisrlZ+f71Fjs9kUHR1t1eTn5+v8+fMeNT179lSnTp2smktVVFTI5XJ5PAAAgO9q8k3fWF1drZkzZ+qOO+5Q7969rdcfeughde7cWaGhodq3b5+Sk5N16NAhbdy4UZLkdDo9QpAk67nT6bxijcvl0rlz53T69GlVVVXVWnPw4EFrGwEBAQoKCrqspubrXGrBggV69tln6/hJAACA69U3DkIJCQk6cOCA3nvvPY/Xp0yZYv13nz591KFDBw0ZMkSffPKJvve9733zThvAnDlzlJSUZD13uVwKCwvzYkcAAKA+faNTY9OnT9fmzZv17rvvqmPHjlesjYyMlCR9/PHHkqSQkJDLrtyqeR4SEnLFGrvdrubNm6tdu3by9/evtebibVRWVurMmTNfW3OpwMBA2e12jwcAAPBddQpCbrdb06dP15tvvqlt27apa9euV31PQUGBJKlDhw6SpKioKO3fv9/j6q6srCzZ7XaFh4dbNdnZ2R7bycrKUlRUlCQpICBAERERHjXV1dXKzs62aiIiItS0aVOPmkOHDqmoqMiqAQAAZqvTqbGEhASlp6frz3/+s1q3bm3NtXE4HGrevLk++eQTpaena/jw4Wrbtq327dunxMRE3X333erbt68kaejQoQoPD9fDDz+sRYsWyel0au7cuUpISFBgYKAkaerUqVq2bJlmzZqliRMnatu2bXr99deVkfF/V/QkJSUpPj5eAwcO1KBBg7R48WKVlZVpwoQJVk+TJk1SUlKS2rRpI7vdrhkzZigqKuqarhgDAAC+r05B6JVXXpH01SXyF1u9erUeffRRBQQE6K9//asVSsLCwhQXF6e5c+datf7+/tq8ebOmTZumqKgotWzZUvHx8Zo/f75V07VrV2VkZCgxMVFLlixRx44dtXLlSsXExFg1Y8aMUUlJiVJSUuR0OtW/f39lZmZ6TKB+6aWXZLPZFBcXp4qKCsXExOjll1+u0wcEAAB817daR8jXsY5Q3fjC2jXsCwC4/jXYOkIAAADXM4IQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsZp4uwEA+DpdZmd4u4Vv7ejCWG+3AOAKOCIEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMFadgtCCBQt02223qXXr1mrfvr1GjRqlQ4cOedSUl5crISFBbdu2VatWrRQXF6fi4mKPmqKiIsXGxqpFixZq3769nnzySV24cMGjZvv27RowYIACAwPVvXt3paWlXdbP8uXL1aVLFzVr1kyRkZHavXt3nXsBAADmqlMQysnJUUJCgnbu3KmsrCydP39eQ4cOVVlZmVWTmJioTZs2acOGDcrJydHx48f14IMPWuNVVVWKjY1VZWWlcnNztWbNGqWlpSklJcWqOXLkiGJjYzV48GAVFBRo5syZeuyxx7R161arZv369UpKStK8efO0d+9e9evXTzExMTp58uQ19wIAAMzm53a73d/0zSUlJWrfvr1ycnJ09913q7S0VDfeeKPS09M1evRoSdLBgwfVq1cv5eXl6fbbb9eWLVs0YsQIHT9+XMHBwZKkFStWKDk5WSUlJQoICFBycrIyMjJ04MAB62uNHTtWZ86cUWZmpiQpMjJSt912m5YtWyZJqq6uVlhYmGbMmKHZs2dfUy9X43K55HA4VFpaKrvd/k0/pqvqMjuj3rbdkI4ujPV2C98a+6Jx8YX94Sv7Arie1OX397eaI1RaWipJatOmjSQpPz9f58+fV3R0tFXTs2dPderUSXl5eZKkvLw89enTxwpBkhQTEyOXy6XCwkKr5uJt1NTUbKOyslL5+fkeNTabTdHR0VbNtfRyqYqKCrlcLo8HAADwXd84CFVXV2vmzJm644471Lt3b0mS0+lUQECAgoKCPGqDg4PldDqtmotDUM14zdiValwul86dO6fPPvtMVVVVtdZcvI2r9XKpBQsWyOFwWI+wsLBr/DQAAMD16BsHoYSEBB04cEB//OMfv8t+vGrOnDkqLS21HseOHfN2SwAAoB41+SZvmj59ujZv3qwdO3aoY8eO1ushISGqrKzUmTNnPI7EFBcXKyQkxKq59Oqumiu5Lq659Oqu4uJi2e12NW/eXP7+/vL396+15uJtXK2XSwUGBiowMLAOnwQAALie1emIkNvt1vTp0/Xmm29q27Zt6tq1q8d4RESEmjZtquzsbOu1Q4cOqaioSFFRUZKkqKgo7d+/3+PqrqysLNntdoWHh1s1F2+jpqZmGwEBAYqIiPCoqa6uVnZ2tlVzLb0AAACz1emIUEJCgtLT0/XnP/9ZrVu3tubaOBwONW/eXA6HQ5MmTVJSUpLatGkju92uGTNmKCoqyrpKa+jQoQoPD9fDDz+sRYsWyel0au7cuUpISLCOxkydOlXLli3TrFmzNHHiRG3btk2vv/66MjL+7wqSpKQkxcfHa+DAgRo0aJAWL16ssrIyTZgwwerpar0AAACz1SkIvfLKK5Kke+65x+P11atX69FHH5UkvfTSS7LZbIqLi1NFRYViYmL08ssvW7X+/v7avHmzpk2bpqioKLVs2VLx8fGaP3++VdO1a1dlZGQoMTFRS5YsUceOHbVy5UrFxMRYNWPGjFFJSYlSUlLkdDrVv39/ZWZmekygvlovAADAbN9qHSFfxzpCdeML66WwLxoXX9gfvrIvgOtJg60jBAAAcD0jCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYq85BaMeOHXrggQcUGhoqPz8/vfXWWx7jjz76qPz8/Dwe999/v0fNqVOnNH78eNntdgUFBWnSpEn64osvPGr27dunu+66S82aNVNYWJgWLVp0WS8bNmxQz5491axZM/Xp00dvv/22x7jb7VZKSoo6dOig5s2bKzo6WocPH67rtwwAAHxUnYNQWVmZ+vXrp+XLl39tzf33368TJ05Yj9dee81jfPz48SosLFRWVpY2b96sHTt2aMqUKda4y+XS0KFD1blzZ+Xn5+s3v/mNnnnmGf3+97+3anJzczVu3DhNmjRJf//73zVq1CiNGjVKBw4csGoWLVqkpUuXasWKFdq1a5datmypmJgYlZeX1/XbBgAAPqhJXd8wbNgwDRs27Io1gYGBCgkJqXXso48+UmZmpj744AMNHDhQkvTb3/5Ww4cP13//938rNDRU69atU2VlpVJTUxUQEKBbbrlFBQUFevHFF63AtGTJEt1///168sknJUnPPfecsrKytGzZMq1YsUJut1uLFy/W3LlzNXLkSEnS2rVrFRwcrLfeektjx46t67cOAAB8TL3MEdq+fbvat2+vHj16aNq0afr888+tsby8PAUFBVkhSJKio6Nls9m0a9cuq+buu+9WQECAVRMTE6NDhw7p9OnTVk10dLTH142JiVFeXp4k6ciRI3I6nR41DodDkZGRVs2lKioq5HK5PB4AAMB3fedB6P7779fatWuVnZ2tX//618rJydGwYcNUVVUlSXI6nWrfvr3He5o0aaI2bdrI6XRaNcHBwR41Nc+vVnPx+MXvq63mUgsWLJDD4bAeYWFhdf7+AQDA9aPOp8au5uJTTn369FHfvn31ve99T9u3b9eQIUO+6y/3nZozZ46SkpKs5y6XizAEAIAPq/fL57t166Z27drp448/liSFhITo5MmTHjUXLlzQqVOnrHlFISEhKi4u9qipeX61movHL35fbTWXCgwMlN1u93gAAADfVe9B6N///rc+//xzdejQQZIUFRWlM2fOKD8/36rZtm2bqqurFRkZadXs2LFD58+ft2qysrLUo0cP3XDDDVZNdna2x9fKyspSVFSUJKlr164KCQnxqHG5XNq1a5dVAwAAzFbnIPTFF1+ooKBABQUFkr6alFxQUKCioiJ98cUXevLJJ7Vz504dPXpU2dnZGjlypLp3766YmBhJUq9evXT//fdr8uTJ2r17t95//31Nnz5dY8eOVWhoqCTpoYceUkBAgCZNmqTCwkKtX79eS5Ys8Tht9fjjjyszM1MvvPCCDh48qGeeeUZ79uzR9OnTJUl+fn6aOXOmfvnLX+ovf/mL9u/fr0ceeUShoaEaNWrUt/zYAACAL6jzHKE9e/Zo8ODB1vOacBIfH69XXnlF+/bt05o1a3TmzBmFhoZq6NCheu655xQYGGi9Z926dZo+fbqGDBkim82muLg4LV261Bp3OBx65513lJCQoIiICLVr104pKSkeaw394Ac/UHp6uubOnaunnnpKN998s9566y317t3bqpk1a5bKyso0ZcoUnTlzRnfeeacyMzPVrFmzun7bAADAB/m53W63t5torFwulxwOh0pLS+t1vlCX2Rn1tu2GdHRhrLdb+NbYF42LL+wPX9kXwPWkLr+/udcYAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFh1DkI7duzQAw88oNDQUPn5+emtt97yGHe73UpJSVGHDh3UvHlzRUdH6/Dhwx41p06d0vjx42W32xUUFKRJkybpiy++8KjZt2+f7rrrLjVr1kxhYWFatGjRZb1s2LBBPXv2VLNmzdSnTx+9/fbbde4FAACYq85BqKysTP369dPy5ctrHV+0aJGWLl2qFStWaNeuXWrZsqViYmJUXl5u1YwfP16FhYXKysrS5s2btWPHDk2ZMsUad7lcGjp0qDp37qz8/Hz95je/0TPPPKPf//73Vk1ubq7GjRunSZMm6e9//7tGjRqlUaNG6cCBA3XqBQAAmMvP7Xa7v/Gb/fz05ptvatSoUZK+OgITGhqq//qv/9ITTzwhSSotLVVwcLDS0tI0duxYffTRRwoPD9cHH3yggQMHSpIyMzM1fPhw/fvf/1ZoaKheeeUV/eIXv5DT6VRAQIAkafbs2Xrrrbd08OBBSdKYMWNUVlamzZs3W/3cfvvt6t+/v1asWHFNvVyNy+WSw+FQaWmp7Hb7N/2YrqrL7Ix623ZDOrow1tstfGvsi8bFF/aHr+wL4HpSl9/f3+kcoSNHjsjpdCo6Otp6zeFwKDIyUnl5eZKkvLw8BQUFWSFIkqKjo2Wz2bRr1y6r5u6777ZCkCTFxMTo0KFDOn36tFVz8depqan5OtfSy6UqKirkcrk8HgAAwHd9p0HI6XRKkoKDgz1eDw4OtsacTqfat2/vMd6kSRO1adPGo6a2bVz8Nb6u5uLxq/VyqQULFsjhcFiPsLCwa/iuAQDA9Yqrxi4yZ84clZaWWo9jx455uyUAAFCPvtMgFBISIkkqLi72eL24uNgaCwkJ0cmTJz3GL1y4oFOnTnnU1LaNi7/G19VcPH61Xi4VGBgou93u8QAAAL7rOw1CXbt2VUhIiLKzs63XXC6Xdu3apaioKElSVFSUzpw5o/z8fKtm27Ztqq6uVmRkpFWzY8cOnT9/3qrJyspSjx49dMMNN1g1F3+dmpqar3MtvQAAALPVOQh98cUXKigoUEFBgaSvJiUXFBSoqKhIfn5+mjlzpn75y1/qL3/5i/bv369HHnlEoaGh1pVlvXr10v3336/Jkydr9+7dev/99zV9+nSNHTtWoaGhkqSHHnpIAQEBmjRpkgoLC7V+/XotWbJESUlJVh+PP/64MjMz9cILL+jgwYN65plntGfPHk2fPl2SrqkXAABgtiZ1fcOePXs0ePBg63lNOImPj1daWppmzZqlsrIyTZkyRWfOnNGdd96pzMxMNWvWzHrPunXrNH36dA0ZMkQ2m01xcXFaunSpNe5wOPTOO+8oISFBERERateunVJSUjzWGvrBD36g9PR0zZ07V0899ZRuvvlmvfXWW+rdu7dVcy29AAAAc32rdYR8HesI1Y0vrJfCvmhcfGF/+Mq+AK4nXltHCAAA4HpCEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxqrzvcYAAObhdifwVRwRAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWN95EHrmmWfk5+fn8ejZs6c1Xl5eroSEBLVt21atWrVSXFyciouLPbZRVFSk2NhYtWjRQu3bt9eTTz6pCxcueNRs375dAwYMUGBgoLp37660tLTLelm+fLm6dOmiZs2aKTIyUrt37/6uv10AAHAdq5cjQrfccotOnDhhPd577z1rLDExUZs2bdKGDRuUk5Oj48eP68EHH7TGq6qqFBsbq8rKSuXm5mrNmjVKS0tTSkqKVXPkyBHFxsZq8ODBKigo0MyZM/XYY49p69atVs369euVlJSkefPmae/everXr59iYmJ08uTJ+viWAQDAdaheglCTJk0UEhJiPdq1aydJKi0t1apVq/Tiiy/q3nvvVUREhFavXq3c3Fzt3LlTkvTOO+/oH//4h1599VX1799fw4YN03PPPafly5ersrJSkrRixQp17dpVL7zwgnr16qXp06dr9OjReumll6weXnzxRU2ePFkTJkxQeHi4VqxYoRYtWig1NbU+vmUAAHAdqpcgdPjwYYWGhqpbt24aP368ioqKJEn5+fk6f/68oqOjrdqePXuqU6dOysvLkyTl5eWpT58+Cg4OtmpiYmLkcrlUWFho1Vy8jZqamm1UVlYqPz/fo8Zmsyk6OtqqqU1FRYVcLpfHAwAA+K7vPAhFRkYqLS1NmZmZeuWVV3TkyBHdddddOnv2rJxOpwICAhQUFOTxnuDgYDmdTkmS0+n0CEE14zVjV6pxuVw6d+6cPvvsM1VVVdVaU7ON2ixYsEAOh8N6hIWFfaPPAAAAXB+afNcbHDZsmPXfffv2VWRkpDp37qzXX39dzZs3/66/3Hdqzpw5SkpKsp67XC7CEAAAPqzeL58PCgrS97//fX388ccKCQlRZWWlzpw541FTXFyskJAQSVJISMhlV5HVPL9ajd1uV/PmzdWuXTv5+/vXWlOzjdoEBgbKbrd7PAAAgO+q9yD0xRdf6JNPPlGHDh0UERGhpk2bKjs72xo/dOiQioqKFBUVJUmKiorS/v37Pa7uysrKkt1uV3h4uFVz8TZqamq2ERAQoIiICI+a6upqZWdnWzUAAADfeRB64oknlJOTo6NHjyo3N1c/+tGP5O/vr3HjxsnhcGjSpElKSkrSu+++q/z8fE2YMEFRUVG6/fbbJUlDhw5VeHi4Hn74YX344YfaunWr5s6dq4SEBAUGBkqSpk6dqn/961+aNWuWDh48qJdfflmvv/66EhMTrT6SkpL0P//zP1qzZo0++ugjTZs2TWVlZZowYcJ3/S0DAIDr1Hc+R+jf//63xo0bp88//1w33nij7rzzTu3cuVM33nijJOmll16SzWZTXFycKioqFBMTo5dfftl6v7+/vzZv3qxp06YpKipKLVu2VHx8vObPn2/VdO3aVRkZGUpMTNSSJUvUsWNHrVy5UjExMVbNmDFjVFJSopSUFDmdTvXv31+ZmZmXTaAGAADm8nO73W5vN9FYuVwuORwOlZaW1ut8oS6zM+pt2w3p6MJYb7fwrbEvGhdf2B/si8bDV/YFrq4uv7+51xgAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsQhCAADAWAQhAABgLIIQAAAwFkEIAAAYiyAEAACMRRACAADGIggBAABjEYQAAICxCEIAAMBYBCEAAGAsghAAADAWQQgAABiLIAQAAIxFEAIAAMYiCAEAAGMRhAAAgLEIQgAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYzXxdgMAAODadZmd4e0WvhNHF8Z6uwVJHBECAAAGMyIILV++XF26dFGzZs0UGRmp3bt3e7slAADQCPh8EFq/fr2SkpI0b9487d27V/369VNMTIxOnjzp7dYAAICX+XwQevHFFzV58mRNmDBB4eHhWrFihVq0aKHU1FRvtwYAALzMpydLV1ZWKj8/X3PmzLFes9lsio6OVl5e3mX1FRUVqqiosJ6XlpZKklwuV732WV3xZb1uv6HU9+fUENgXjYsv7A/2RePBvmhc6nN/1Gzb7XZftdang9Bnn32mqqoqBQcHe7weHBysgwcPXla/YMECPfvss5e9HhYWVm89+hLHYm93gBrsi8aDfdF4sC8al4bYH2fPnpXD4bhijU8HobqaM2eOkpKSrOfV1dU6deqU2rZtKz8/Py929u24XC6FhYXp2LFjstvt3m7HaOyLxoN90biwPxoPX9gXbrdbZ8+eVWho6FVrfToItWvXTv7+/iouLvZ4vbi4WCEhIZfVBwYGKjAw0OO1oKCg+myxQdnt9uv2f2pfw75oPNgXjQv7o/G43vfF1Y4E1fDpydIBAQGKiIhQdna29Vp1dbWys7MVFRXlxc4AAEBj4NNHhCQpKSlJ8fHxGjhwoAYNGqTFixerrKxMEyZM8HZrAADAy3w+CI0ZM0YlJSVKSUmR0+lU//79lZmZedkEal8WGBioefPmXXbaDw2PfdF4sC8aF/ZH42HavvBzX8u1ZQAAAD7Ip+cIAQAAXAlBCAAAGIsgBAAAjEUQAgAAxiIIAQAalXPnznm7BRiEIORjunXrps8//9zbbQBAnVVUVOiFF15Q165dvd0KDOLz6wiZ5ujRo6qqqvJ2G/j/unXrpg8++EBt27b1ditGW7t27TXVPfLII/XcCSoqKvTMM88oKytLAQEBmjVrlkaNGqXVq1frF7/4hfz9/ZWYmOjtNo0xceJELVmyRK1bt/Z2K17DOkI+xmazyel0qn379t5uBWJ/NBY33HDD1475+fmprKxMFy5c4I+IBpCcnKzf/e53io6OVm5urkpKSjRhwgTt3LlTTz31lH784x/L39/f220aw9/fXydOnDD6ZxRHhHzQ1q1br3qzuf/4j/9ooG4A7zt9+nStr584cULPPvusUlNTdd999zVwV2basGGD1q5dq//4j//QgQMH1LdvX124cEEffvih/Pz8vN2ecTgWwhEhn2OzXX3al5+fH3/5NhCbzaY1a9YQTBuZs2fP6te//rWWLFmiW265RQsWLNDgwYO93ZYRAgICdOTIEd10002SpObNm2v37t3q06ePlzszk81m0+HDh3XjjTdese56vgv91XBEyAdxKqZxiY+Pv+I4wbThnD9/Xr/97W/1/PPPq23btlq9erVGjx7t7baMUlVVpYCAAOt5kyZN1KpVKy92hO9///tfO+Z2u33+ZxRByMdwaLnxIZh6n9vt1tq1a5WSkqILFy7o+eef16RJk5iL4gVut1uPPvqodUPP8vJyTZ06VS1btvSo27hxozfaM9Ibb7yhNm3aeLsNryEI+RjOdDYuBNPGoW/fvvrXv/6lGTNmaObMmWrRooXKysouq/Plw/+NxaVHSH/60596qRPUuOOOO4z+Y405Qj5mwoQJWrp0qdGXQjYmXDXWOFw8d662cGrC4X+gNvyM4oiQz0lMTNSRI0cue93hcKhTp04coWhg8fHxat68ubfbMN67777r7RZQBydPnjT6F3ND6ty5s/GniDki5GNsNpv8/PwuO0Xm5+enZs2aaebMmZo/f77x/+MD8I4WLVro008/ta5Sio2N1cqVK9WhQwdJUnFxsUJDQzk6hwbDESEfU9vRIEk6c+aM8vPz9fTTT+uGG27QE0880cCdmakmmF6Jn5+fLly40EAdmcnlcl1THXOE6l95ebnHH2o7duy47N5i/H3ecAYMGHBNdXv37q3nTryHIORjOnfu/LWv9+vXT3a7Xc8++yxBqIFs3Ljxa4NQXl6eli5dqurq6gbuyjxBQUFXDKTMEWpcOIXfcEaOHOntFryOIGSYiIiIrz1qhO/eqFGjLnvt0KFDmj17tjZt2qTx48dr/vz5Dd+YYZgjBNRu3rx53m7B6whChnE6nVddQRT14/jx45o3b57WrFmjmJgYFRQUqHfv3t5uywg//OEP61S/cOFCTZ06VUFBQfXTkMH8/Pw8jvhc+hyNQ2VlpSorK41Y7PLq92OAzygpKdHTTz/NrQQaWGlpqZKTk9W9e3cVFhYqOztbmzZtIgQ1Ys8//7xOnTrl7TZ8ktvt1ve//321adNGbdq00RdffKFbb73Vet6zZ09vt2ic1atXa8aMGVq3bp0kac6cOWrdurUcDofuu+8+ff75517usH5xRMjH3HrrrbX+dVVaWqp///vf6tGjh1599VUvdGamRYsW6de//rVCQkL02muvcT7+OsFk3fqzevVqb7eAi/zqV7/Sr371K91xxx1KT0/Xe++9p7feekvz58+XzWbT0qVLNXfuXL3yyivebrXecPm8j3n22Wdrfd1ut6tHjx6KiYnh0vkGZLPZ1Lx5c0VHR1/xc+d2Ao1L69at9eGHH6pbt27ebgWoVzfffLPmz5+vcePGac+ePYqMjNTrr7+uuLg4SdKWLVs0depUffrpp17utP5wRMjHMPGtcXnkkUeY/wBcJDU1VePHj7fuNQbvKioq0p133ilJGjhwoJo0aeJx2r5v3746ceKEt9prEAQhH3Xu3DllZWXpn//8pySpR48eio6OZpXjBpaWlubtFoBGZfLkyRoxYoS1cnRoaKhyc3PVpUsX7zZmqPPnz3uE0oCAADVt2tR63qRJE59fVoIg5IP+8pe/6LHHHtNnn33m8Xq7du20atUqPfDAA17qDLXhdgIwyaWzMc6ePctaWl72j3/8Q06nU9JX++fgwYP64osvJOmy3yO+iKvGfExubq5Gjx6tu+++W++//75OnTqlU6dO6b333tNdd92l0aNHa+fOnd5u0xgtWrRQSUmJ9Tw2NtbjMHNxcbF1awE0HnfddRdHT2GMIUOGqH///urfv7++/PJLjRgxQv3799ett96q6Ohob7dX75gs7WOGDx+usLAw/e53v6t1/Gc/+5mOHTumt99+u4E7M9Old3a+dBJuTRDiL+L6xS02Gg9/f3+P9czsdrs+/PBDde3a1cudmelaJ0F/3V0LfAGnxnzMzp079etf//prxxMSEuq8uBzqF5Op6x+32Gg8atYRqtkfNesI2WyeJyhYx6lh+HLAuVYEIR9z7ty5K/5V63A4VF5e3oAdAd538S023G63hg8frpUrV+qmm27yYldmYh2hxmXRokWaMWOGdSr4/fff18CBA60J1GfPnlVycrJefvllb7ZZrzg15mP69u2rxMRETZgwodbx1NRULV68WPv27Wvgzsx0tdMAxcXFCg0N5UhEA2OdIOAr/v7+OnHihHX63m63q6CgwOP0va//jOKIkI+ZMGGCnnjiCQUHB2v48OEeYxkZGZo1a5aeeuopL3VnnqudBuDvEEAqLy/X+vXrVVZWpvvuu08333yzt1syxqU/g0z8mUQQ8jGPP/64cnNzNWLECPXo0UO9evWS2+3WRx99pMOHD2vUqFGaOXOmt9s0BqcBAE9JSUk6f/68fvvb30r66uaeUVFRKiwsVIsWLTRr1ixlZWUpKirKy53CFAQhH2Oz2bRhwwatX79er732mg4ePChJ6tmzp5555hmNHTvWyx2aJT4+3tst4GswSd073nnnHT3//PPW83Xr1unTTz/V4cOH1alTJ02cOFG//OUvlZGR4cUuYRKCkI8aM2aMxowZc9W6hQsXaurUqQoKCqr/pgAvefDBBz2el5eXa+rUqWrZsqXH69zzrf4VFRUpPDzcev7OO+9o9OjR1tVLjz/++GWn9VG/Vq5cqVatWkmSLly4oLS0NLVr107SV5OlfR2TpQ136cQ4fLeu9XP917/+Vc+dmO3rLh64FKcy619QUJA++OADax5Q165d9fTTT2vixImSpKNHj6pXr146d+6cN9s0RpcuXa7p6OiRI0caoBvv4IiQ4cjB9evo0aPq3LmzHnroIW6j4UUEnMajV69e2rRpk5KSklRYWKiioiINHjzYGv/0008VHBzsxQ7NcvToUW+34HUEIaAerV+/XqmpqXrxxRc1bNgwTZw4UcOHD79s8Th4x6effqqysjL17NmTfdJAZs2apbFjxyojI0OFhYUaPny4x6rSb7/9tgYNGuTFDs1TXV2ttLQ0bdy4UUePHpWfn5+6deumuLg4Pfzwwz4/n45/+UA9+vGPf6wtW7bo448/VkREhBITExUWFqbZs2fr8OHD3m7PGDVh9GJTpkxRt27d1KdPH/Xu3VvHjh3zUndm+dGPfqS3337bWvNs/fr1HuMtWrTQz3/+cy91Zx63260HHnhAjz32mP73f/9Xffr00S233KKjR4/q0Ucf1Y9+9CNvt1j/3DBaq1at3J988om32zDK9u3b3ffcc4/bZrO5T5065e12jBAZGelOTU21nm/ZssXdpEkT96uvvurOz893R0VFuSdNmuTFDgHvSE1Ndbdu3dq9bdu2y8ays7PdrVu3dq9Zs8YLnTUcTo0BDaS8vFxvvPGGUlNTtWvXLv34xz9WixYtvN2WEQ4fPqyBAwdaz//85z9r5MiRGj9+vCTp+eefv+YJ1fh2ioqKrqmuU6dO9dwJJOm1117TU0895TFPq8a9996r2bNna926dXrkkUe80F3DIAgZ7q677rLuMYP6sWvXLq1atUqvv/66unXrpokTJ+pPf/qTbrjhBm+3ZoxL78GXm5urSZMmWc+7desmp9PpjdaM83VXKbn//41vpa/WeLpw4UJDt2akffv2adGiRV87PmzYMC1durQBO2p4BCEf43K5rqmu5pfC22+/XZ/tGO+WW27RyZMn9dBDDyknJ0f9+vXzdktG6ty5s/Lz89W5c2d99tlnKiws1B133GGNO51OORwOL3Zojr///e+1vu52u/XHP/5RS5cutda0Qf07derUFa/SCw4O1unTpxuwo4ZHEPIxQUFBV5zhX/NXly/fQK8x+eijj9SyZUutXbtWf/jDH7627tSpUw3YlXni4+OVkJCgwsJCbdu2TT179lRERIQ1npubq969e3uxQ3PU9sfAX//6V82ePVv//Oc/NWvWLP3Xf/2XFzozU1VVlZo0+foo4O/v7/NH5whCPubdd9+1/tvtdmv48OFauXKlbrrpJi92ZS7Wr2kcZs2apS+//FIbN25USEiINmzY4DH+/vvvc/sZL9i7d6+Sk5P1t7/9TY899pjefvtt1ttqYG63W48++qgCAwNrHa+oqGjgjhoeK0v7uNatW+vDDz9k5WgvKSsru+w2Dmicqqqq5O/v7+02jPDJJ5/oqaee0p/+9Cf95Cc/0S9/+Ut+RnkJq65zRAioV3379tWaNWt05513ersVfI1//vOfWrVqldauXasTJ054ux2f9/Of/1yrVq3S4MGDtWfPHvXv39/bLRnNlwPOtSIIAfUoLi5O9957rx5//HH96le/UkBAgLdbgqQvv/zSWvU7Ly9PAwcOVFJSkrfbMsKKFSvUrFkznTx50rq/WG327t3bgF3BZAQhA/j68uiN2aJFi/Tggw9q4sSJ2rJli/7whz/o1ltv9XZbxtq5c6dWrlypDRs2qFOnTvroo4/07rvv6q677vJ2a8aYN2+et1sAPDBHyMc8+OCDHs83bdqke++997J5Khs3bmzItoxXUVGhuXPnatmyZbrvvvsuu0qD/VG/XnjhBaWmpqq0tFTjxo3TT3/6U/Xr109NmzbVhx9+qPDwcG+3CMBLOCLkYy5dC+WnP/2plzrBxSoqKnTy5En5+fnJ4XBc8XJVfPeSk5OVnJys+fPnMyG6EXO5XFq3bp1WrVqlPXv2eLsdGIKfxj6GiW+NT1ZWliZOnKgOHTooPz9fvXr18nZLxnnuuee0evVq/eEPf9C4ceP08MMPs25QI/Luu+8qNTVVGzdulMPhMONGn2g0ODVmiE8//VRlZWXq2bOnbDabt9sxxs9+9jOtWbNGTz31lH7xi19wNMLLcnJylJqaqjfeeEPdu3dXYWGhcnJyPFaZRsP43//9X6WlpWn16tU6c+aMTp8+rfT0dP3kJz9hXiMaFL8RfUxqaqpefPFFj9emTJmibt26qU+fPurdu7eOHTvmpe7M8/777ys3N1cpKSmXhSC3260tW7Zo9OjRXurOPD/84Q+1Zs0aOZ1O/fznP1dERIR++MMf6gc/+MFl/25QP/70pz9p+PDh6tGjhwoKCvTCCy/o+PHjstls6tOnDyEIDY4g5GN+//vfe9zMMzMzU6tXr9batWv1wQcfKCgoSM8++6wXOzTL3r17NWDAAI/Xjhw5oqefflqdOnXSj370I5WXl3upO3O1bt1aP/vZz7Rr1y4VFBQoMjJSCxcu9HZbRhgzZoxuvfVWnThxQhs2bNDIkSNZVgJeRRDyMYcPH9bAgQOt53/+8581cuRIjR8/XgMGDNDzzz+v7OxsL3Zolpof8BUVFVq3bp3uvfde9ejRQ88//7ySkpJ08uRJbd682ctd+r5t27YpPDy81psSh4WFaevWrUpPT/dCZ+aZNGmSli9frvvvv18rVqzw+Rt6ovEjCPmYc+fOWXeWl766meTdd99tPe/WrZucTqc3WjNSfn6+fv7znyskJESLFy/WqFGjdOzYMdlsNsXExHjsK9SfxYsXa/LkybV+3g6HQ1OnTtXy5cu90Jl5fve73+nEiROaMmWKXnvtNXXo0EEjR46U2+1WdXW1t9uDgQhCPqZz587Kz8+XJH322WcqLCz0mAjqdDovu8Qe9ScyMlKBgYHauXOnPvjgA/3nf/6ngoODvd2WcT788EPdf//9Xzs+dOhQ698N6l/z5s0VHx+vnJwc7d+/X7fccouCg4N1xx136KGHHmJdLTQogpCPiY+PV0JCgp577jn9+Mc/Vs+ePRUREWGN5+bmctlwAxoyZIhWrVql+fPnKzMzU1yk6R3FxcVq2rTp1443adJEJSUlDdgRatx88816/vnndezYMb366qv68ssvNW7cOG+3BYOwjpCPmTVrlr788ktt3LhRISEh2rBhg8f4+++/r7Fjx3qpO/Ns3bpVx44dU2pqqqZNm6Zz585pzJgxkrj1SUO66aabdODAAXXv3r3W8X379qlDhw4N3BUuZrPZ9MADDyg6OlrLli3zdjswCOsIGaiqqor1bLzkr3/9q1JTU/Xmm28qLCxMo0eP1ujRoy+7sgzfrRkzZmj79u364IMP1KxZM4+xc+fOadCgQRo8eLCWLl3qpQ7NUlJSol27dikgIEBDhgyRv7+/zp8/r5dfflkLFy7U+fPn9dlnn3m7TRiCIGSQf/7zn1q1apXWrl2rEydOeLsdI1RVVem///u/9Ze//EWVlZUaMmSI5s2bp/Lycr366qtKTU3Vvn37VFVV5e1WfVpxcbEGDBggf39/TZ8+XT169JAkHTx4UMuXL1dVVZX27t3L/K0G8N5772nEiBFyuVzy8/PTwIEDtXr1ao0aNUpNmjTRf/7nfyo+Pl7Nmzf3dqswhRs+rayszJ2amuq+88473f7+/u7IyEj3okWLvN2WMebPn++22WzuoUOHukeOHOlu1qyZe8KECR41+fn5XurOLEePHnUPGzbMbbPZ3H5+fm4/Pz+3zWZzDxs2zP2vf/3L2+0Z44c//KF73Lhx7v3797ufeOIJt5+fn/v73/++e8OGDd5uDYbiiJCP2rlzp1auXKkNGzaoU6dO+uijj/Tuu+/qrrvu8nZrRrn55pv1xBNP6Gc/+5mkr06NxcbG6ty5c9zqxEtOnz6tjz/+WG63WzfffLPHAqSof23bttXf/vY3hYeH69y5c2rVqpU2btyokSNHers1GIqfxD7mhRde0C233KLRo0frhhtu0I4dO7R//375+fmpbdu23m7POEVFRRo+fLj1PDo6Wn5+fjp+/LgXuzLbDTfcoNtuu02DBg0iBHnB6dOn1a5dO0lfXUbfokULrmSFV3HVmI9JTk5WcnKy5s+fz4ToRuDChQuXTc5t2rSpzp8/76WOAO/7xz/+YS3s6na7dejQIZWVlXnU9O3b1xutwUCcGvMxCxYs0OrVq1VeXq5x48bp4YcfVu/evdW0aVN9+OGHCg8P93aLRrHZbBo2bJgCAwOt1zZt2qR7771XLVu2tF5jATmYwmazyc/Pr9Y1tWpe9/Pz4wICNBiCkI/KyclRamqq3njjDXXv3l2FhYXKycnxWGUa9W/ChAnXVLd69ep67gRoHD799NNrquvcuXM9dwJ8hSDk486ePav09HSlpqYqPz9fgwYN0ujRo5WUlOTt1gAYaP78+XriiSfUokULb7cCSCIIGeXAgQNatWqV1q1bp5MnT3q7HQAG8vf314kTJ9S+fXtvtwJI4qoxn7Nt2zaFh4fL5XJdNhYWFqatW7cqPT3dC50BgLjfHhodgpCPWbx4sSZPniy73X7ZmMPh0NSpU7V8+XIvdAYAX+E+e2hMODXmYzp37qzMzEz16tWr1vGDBw9q6NChKioqauDOAOCrq8YcDsdVw9CpU6caqCOYjnWEfExxcbGaNm36teNNmjRRSUlJA3YEAJ6effZZORwOb7cBSCII+ZybbrpJBw4cUPfu3Wsd37dvnzp06NDAXQHA/xk7diyTpdFoMEfIxwwfPlxPP/20ysvLLxs7d+6c5s2bpxEjRnihMwBgfhAaH+YI+Zji4mINGDBA/v7+mj59unr06CHpq7lBy5cvV1VVlfbu3avg4GAvdwrARDabTU6nkyNCaDQIQj7o008/1bRp07R161brUlU/Pz/FxMRo+fLl6tq1q5c7BACgcSAI+bDTp0/r448/ltvt1s0338ydtgEAuARBCAAAGIvJ0gAAwFgEIQAAYCyCEAAAMBZBCAAAGIsgBAAAjEUQAgAAxiIIAQAAYxGEAACAsf4frlpOsr80gJwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Your code here\n", + "pd.value_counts(df['type']).plot(kind = 'bar')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
stepamountoldbalanceOrgnewbalanceOrigoldbalanceDestnewbalanceDestisFraudisFlaggedFraudtype_CASH_INtype_CASH_OUTtype_DEBITtype_PAYMENTtype_TRANSFER
4322754308300104.9849610.00349714.980.000.000010000
20145201802279.4945070.0042790.510.000.000000010
1464593140207500.360.000.003377272.263567270.550001000
1195060132561898.95540585.000.0078744.41640643.360000001
21813251851825.79148853.03147027.240.000.000000010
\n", + "
" + ], + "text/plain": [ + " step amount oldbalanceOrg newbalanceOrig oldbalanceDest \\\n", + "4322754 308 300104.98 49610.00 349714.98 0.00 \n", + "2014520 180 2279.49 45070.00 42790.51 0.00 \n", + "1464593 140 207500.36 0.00 0.00 3377272.26 \n", + "1195060 132 561898.95 540585.00 0.00 78744.41 \n", + "2181325 185 1825.79 148853.03 147027.24 0.00 \n", + "\n", + " newbalanceDest isFraud isFlaggedFraud type_CASH_IN type_CASH_OUT \\\n", + "4322754 0.00 0 0 1 0 \n", + "2014520 0.00 0 0 0 0 \n", + "1464593 3567270.55 0 0 0 1 \n", + "1195060 640643.36 0 0 0 0 \n", + "2181325 0.00 0 0 0 0 \n", + "\n", + " type_DEBIT type_PAYMENT type_TRANSFER \n", + "4322754 0 0 0 \n", + "2014520 0 1 0 \n", + "1464593 0 0 0 \n", + "1195060 0 0 1 \n", + "2181325 0 1 0 " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Your code here\n" + "df = pd.get_dummies(df, columns=['type'])\n", + "df.drop(['nameOrig','nameDest'], axis = 1, inplace=True)\n", + "df.head()" ] }, { @@ -76,11 +628,59 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.99852" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Your code here" + "# Your code here\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import classification_report, confusion_matrix\n", + "\n", + "data = df.drop(labels='isFraud', axis=1)\n", + "target = df['isFraud']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(data, target, test_size= 0.2)\n", + "\n", + "LR = LogisticRegression()\n", + "LR.fit(X_train,y_train)\n", + "LR.score(X_test,y_test)\n", + "pred = LR.predict(X_test)\n", + "\n", + "LR.score(X_train,y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[199578, 175],\n", + " [ 149, 98]], dtype=int64)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pred = LR.predict(X_test)\n", + "confusion_matrix(y_test, pred)" ] }, { @@ -92,11 +692,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\jmpcs\\Desktop\\Ironhack\\Labs\\lab-imbalance\\your-code\\lab_imbalance.ipynb Cell 17\u001b[0m in \u001b[0;36m7\n\u001b[0;32m 1\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msklearn\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mensemble\u001b[39;00m \u001b[39mimport\u001b[39;00m GradientBoostingClassifier\n\u001b[0;32m 2\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msklearn\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmetrics\u001b[39;00m \u001b[39mimport\u001b[39;00m accuracy_score\n\u001b[0;32m 4\u001b[0m clf \u001b[39m=\u001b[39m GradientBoostingClassifier(n_estimators \u001b[39m=\u001b[39m \u001b[39m1000\u001b[39m\n\u001b[0;32m 5\u001b[0m ,learning_rate \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m 6\u001b[0m ,max_depth \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m----> 7\u001b[0m ,random_state \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m)\u001b[39m.\u001b[39mfit(X_train, y_train)\n\u001b[0;32m 9\u001b[0m display(clf\u001b[39m.\u001b[39mscore(X_train,y_train))\n\u001b[0;32m 11\u001b[0m display(accuracy_score(y_train, clf\u001b[39m.\u001b[39mpredict(X_train)))\n", + "File \u001b[1;32mc:\\Users\\jmpcs\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\ensemble\\_gb.py:668\u001b[0m, in \u001b[0;36mBaseGradientBoosting.fit\u001b[1;34m(self, X, y, sample_weight, monitor)\u001b[0m\n\u001b[0;32m 665\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_resize_state()\n\u001b[0;32m 667\u001b[0m \u001b[39m# fit the boosting stages\u001b[39;00m\n\u001b[1;32m--> 668\u001b[0m n_stages \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit_stages(\n\u001b[0;32m 669\u001b[0m X,\n\u001b[0;32m 670\u001b[0m y,\n\u001b[0;32m 671\u001b[0m raw_predictions,\n\u001b[0;32m 672\u001b[0m sample_weight,\n\u001b[0;32m 673\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_rng,\n\u001b[0;32m 674\u001b[0m X_val,\n\u001b[0;32m 675\u001b[0m y_val,\n\u001b[0;32m 676\u001b[0m sample_weight_val,\n\u001b[0;32m 677\u001b[0m begin_at_stage,\n\u001b[0;32m 678\u001b[0m monitor,\n\u001b[0;32m 679\u001b[0m )\n\u001b[0;32m 681\u001b[0m \u001b[39m# change shape of arrays after fit (early-stopping or additional ests)\u001b[39;00m\n\u001b[0;32m 682\u001b[0m \u001b[39mif\u001b[39;00m n_stages \u001b[39m!=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mestimators_\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m]:\n", + "File \u001b[1;32mc:\\Users\\jmpcs\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\ensemble\\_gb.py:745\u001b[0m, in \u001b[0;36mBaseGradientBoosting._fit_stages\u001b[1;34m(self, X, y, raw_predictions, sample_weight, random_state, X_val, y_val, sample_weight_val, begin_at_stage, monitor)\u001b[0m\n\u001b[0;32m 738\u001b[0m old_oob_score \u001b[39m=\u001b[39m loss_(\n\u001b[0;32m 739\u001b[0m y[\u001b[39m~\u001b[39msample_mask],\n\u001b[0;32m 740\u001b[0m raw_predictions[\u001b[39m~\u001b[39msample_mask],\n\u001b[0;32m 741\u001b[0m sample_weight[\u001b[39m~\u001b[39msample_mask],\n\u001b[0;32m 742\u001b[0m )\n\u001b[0;32m 744\u001b[0m \u001b[39m# fit next stage of trees\u001b[39;00m\n\u001b[1;32m--> 745\u001b[0m raw_predictions \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit_stage(\n\u001b[0;32m 746\u001b[0m i,\n\u001b[0;32m 747\u001b[0m X,\n\u001b[0;32m 748\u001b[0m y,\n\u001b[0;32m 749\u001b[0m raw_predictions,\n\u001b[0;32m 750\u001b[0m sample_weight,\n\u001b[0;32m 751\u001b[0m sample_mask,\n\u001b[0;32m 752\u001b[0m random_state,\n\u001b[0;32m 753\u001b[0m X_csc,\n\u001b[0;32m 754\u001b[0m X_csr,\n\u001b[0;32m 755\u001b[0m )\n\u001b[0;32m 757\u001b[0m \u001b[39m# track deviance (= loss)\u001b[39;00m\n\u001b[0;32m 758\u001b[0m \u001b[39mif\u001b[39;00m do_oob:\n", + "File \u001b[1;32mc:\\Users\\jmpcs\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\ensemble\\_gb.py:247\u001b[0m, in \u001b[0;36mBaseGradientBoosting._fit_stage\u001b[1;34m(self, i, X, y, raw_predictions, sample_weight, sample_mask, random_state, X_csc, X_csr)\u001b[0m\n\u001b[0;32m 244\u001b[0m sample_weight \u001b[39m=\u001b[39m sample_weight \u001b[39m*\u001b[39m sample_mask\u001b[39m.\u001b[39mastype(np\u001b[39m.\u001b[39mfloat64)\n\u001b[0;32m 246\u001b[0m X \u001b[39m=\u001b[39m X_csr \u001b[39mif\u001b[39;00m X_csr \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m X\n\u001b[1;32m--> 247\u001b[0m tree\u001b[39m.\u001b[39;49mfit(X, residual, sample_weight\u001b[39m=\u001b[39;49msample_weight, check_input\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n\u001b[0;32m 249\u001b[0m \u001b[39m# update tree leaves\u001b[39;00m\n\u001b[0;32m 250\u001b[0m loss\u001b[39m.\u001b[39mupdate_terminal_regions(\n\u001b[0;32m 251\u001b[0m tree\u001b[39m.\u001b[39mtree_,\n\u001b[0;32m 252\u001b[0m X,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 259\u001b[0m k\u001b[39m=\u001b[39mk,\n\u001b[0;32m 260\u001b[0m )\n", + "File \u001b[1;32mc:\\Users\\jmpcs\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\tree\\_classes.py:1342\u001b[0m, in \u001b[0;36mDecisionTreeRegressor.fit\u001b[1;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[0;32m 1313\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfit\u001b[39m(\u001b[39mself\u001b[39m, X, y, sample_weight\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, check_input\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[0;32m 1314\u001b[0m \u001b[39m\"\"\"Build a decision tree regressor from the training set (X, y).\u001b[39;00m\n\u001b[0;32m 1315\u001b[0m \n\u001b[0;32m 1316\u001b[0m \u001b[39m Parameters\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 1339\u001b[0m \u001b[39m Fitted estimator.\u001b[39;00m\n\u001b[0;32m 1340\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[1;32m-> 1342\u001b[0m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49mfit(\n\u001b[0;32m 1343\u001b[0m X,\n\u001b[0;32m 1344\u001b[0m y,\n\u001b[0;32m 1345\u001b[0m sample_weight\u001b[39m=\u001b[39;49msample_weight,\n\u001b[0;32m 1346\u001b[0m check_input\u001b[39m=\u001b[39;49mcheck_input,\n\u001b[0;32m 1347\u001b[0m )\n\u001b[0;32m 1348\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n", + "File \u001b[1;32mc:\\Users\\jmpcs\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\tree\\_classes.py:458\u001b[0m, in \u001b[0;36mBaseDecisionTree.fit\u001b[1;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[0;32m 447\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 448\u001b[0m builder \u001b[39m=\u001b[39m BestFirstTreeBuilder(\n\u001b[0;32m 449\u001b[0m splitter,\n\u001b[0;32m 450\u001b[0m min_samples_split,\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 455\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmin_impurity_decrease,\n\u001b[0;32m 456\u001b[0m )\n\u001b[1;32m--> 458\u001b[0m builder\u001b[39m.\u001b[39;49mbuild(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtree_, X, y, sample_weight)\n\u001b[0;32m 460\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_outputs_ \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m \u001b[39mand\u001b[39;00m is_classifier(\u001b[39mself\u001b[39m):\n\u001b[0;32m 461\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_classes_ \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_classes_[\u001b[39m0\u001b[39m]\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ - "# Your code here" + "from sklearn.ensemble import GradientBoostingClassifier\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "clf = GradientBoostingClassifier(n_estimators = 1000\n", + " ,learning_rate = 1\n", + " ,max_depth = 1\n", + " ,random_state = 0).fit(X_train, y_train)\n", + "\n", + "display(clf.score(X_train,y_train))\n", + "\n", + "display(accuracy_score(y_train, clf.predict(X_train)))\n", + "display(accuracy_score(y_test, clf.predict(X_test)))\n", + "\n", + "display(confusion_matrix(y_test, clf.predict(X_test)))" ] }, { @@ -108,11 +738,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Your response here" + "#Regression Model worked better, LogisticRegression" ] }, { @@ -139,7 +769,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.10.7" } }, "nbformat": 4,