From 25acc1724cfde292906649e571d2b2ac3621161a Mon Sep 17 00:00:00 2001 From: Lovely028 Date: Thu, 31 Jul 2025 17:09:26 +0200 Subject: [PATCH] first commit lab-svm --- lab-svm.ipynb | 1156 ++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 1107 insertions(+), 49 deletions(-) diff --git a/lab-svm.ipynb b/lab-svm.ipynb index bbbfd6b..6531274 100644 --- a/lab-svm.ipynb +++ b/lab-svm.ipynb @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -57,17 +57,17 @@ "metadata": {}, "outputs": [], "source": [ - "import piplite\n", - "await piplite.install(['pandas'])\n", - "await piplite.install(['matplotlib'])\n", - "await piplite.install(['numpy'])\n", - "await piplite.install(['scikit-learn'])\n", - "await piplite.install(['scipy'])\n" + "#import piplite\n", + "#await piplite.install(['pandas'])\n", + "#await piplite.install(['matplotlib'])\n", + "#await piplite.install(['numpy'])\n", + "#await piplite.install(['scikit-learn'])\n", + "#await piplite.install(['scipy'])\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -85,15 +85,27 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'pyodide'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[4], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpyodide\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mhttp\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m pyfetch\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdownload\u001b[39m(url, filename):\n\u001b[0;32m 4\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m pyfetch(url)\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'pyodide'" + ] + } + ], "source": [ - "from pyodide.http import pyfetch\n", + "#from pyodide.http import pyfetch\n", "\n", - "async def download(url, filename):\n", - " response = await pyfetch(url)\n", - " if response.status == 200:\n", - " with open(filename, \"wb\") as f:\n", - " f.write(await response.bytes())\n" + "#async def download(url, filename):\n", + " # response = await pyfetch(url)\n", + " # if response.status == 200:\n", + " # with open(filename, \"wb\") as f:\n", + " # f.write(await response.bytes())\n" ] }, { @@ -131,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "button": false, "new_sheet": false, @@ -164,12 +176,12 @@ "metadata": {}, "outputs": [], "source": [ - "await download(path, \"cell_samples.csv\")" + "#await download(path, \"cell_samples.csv\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "button": false, "new_sheet": false, @@ -177,9 +189,280 @@ "read_only": false } }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "int64", + "type": "integer" + }, + { + "name": "ID", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Clump", + "rawType": "int64", + "type": "integer" + }, + { + "name": "UnifSize", + "rawType": "int64", + "type": "integer" + }, + { + "name": "UnifShape", + "rawType": "int64", + "type": "integer" + }, + { + "name": "MargAdh", + "rawType": "int64", + "type": "integer" + }, + { + "name": "SingEpiSize", + "rawType": "int64", + "type": "integer" + }, + { + "name": "BareNuc", + "rawType": "object", + "type": "string" + }, + { + "name": "BlandChrom", + "rawType": "int64", + "type": "integer" + }, + { + "name": "NormNucl", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Mit", + "rawType": "int64", + "type": "integer" + }, + { + "name": "Class", + "rawType": "int64", + "type": "integer" + } + ], + "ref": "25e0d456-cb4c-4558-a985-ee4f9fc60276", + "rows": [ + [ + "0", + "1000025", + "5", + "1", + "1", + "1", + "2", + "1", + "3", + "1", + "1", + "2" + ], + [ + "1", + "1002945", + "5", + "4", + "4", + "5", + "7", + "10", + "3", + "2", + "1", + "2" + ], + [ + "2", + "1015425", + "3", + "1", + "1", + "1", + "2", + "2", + "3", + "1", + "1", + "2" + ], + [ + "3", + "1016277", + "6", + "8", + "8", + "1", + "3", + "4", + "3", + "7", + "1", + "2" + ], + [ + "4", + "1017023", + "4", + "1", + "1", + "3", + "2", + "1", + "3", + "1", + "1", + "2" + ] + ], + "shape": { + "columns": 11, + "rows": 5 + } + }, + "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", + "
IDClumpUnifSizeUnifShapeMargAdhSingEpiSizeBareNucBlandChromNormNuclMitClass
010000255111213112
1100294554457103212
210154253111223112
310162776881343712
410170234113213112
\n", + "
" + ], + "text/plain": [ + " ID Clump UnifSize UnifShape MargAdh SingEpiSize BareNuc \\\n", + "0 1000025 5 1 1 1 2 1 \n", + "1 1002945 5 4 4 5 7 10 \n", + "2 1015425 3 1 1 1 2 2 \n", + "3 1016277 6 8 8 1 3 4 \n", + "4 1017023 4 1 1 3 2 1 \n", + "\n", + " BlandChrom NormNucl Mit Class \n", + "0 3 1 1 2 \n", + "1 3 2 1 2 \n", + "2 3 1 1 2 \n", + "3 3 7 1 2 \n", + "4 3 1 1 2 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "cell_df = pd.read_csv(\"cell_samples.csv\")\n", + "cell_df = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/cell_samples.csv')\n", "cell_df.head()" ] }, @@ -196,9 +479,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOHhJREFUeJzt3Xl4VOXh/v97GJawZCOyRQKJJBEFERRMAxahBMJH4XIp2hKsov1oK0tB6oZaqyCkWlFcWizqV6hIbKto/YgwJggBESFs4s8tC0lMBRpNQsIuJPP7I2QkJGSdzJnn5P26rrku5jmTmftwZjJ3nnPOjMPtdrsFAABgqDZWBwAAAGgOygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNHaWh2gpVVUVGjfvn0KDAyUw+GwOg4AAGgAt9utQ4cOKTw8XG3a1D33Yvsys2/fPkVERFgdAwAANEFBQYF69+5d521sX2YCAwMlVf5nBAUFWZwGAAA0RFlZmSIiIjzv43WxfZmp2rUUFBREmQEAwDANOUSEA4ABAIDRKDMAAMBolBkAAGA02x8z01Dl5eU6efKk1THgRe3bt6/3dD4AgPlafZlxu906cOCADh48aHUUeFmbNm0UFRWl9u3bWx0FANCCWn2ZqSoy3bt3V6dOnfhgPZuo+rDE/fv3q0+fPmxXALCxVl1mysvLPUUmLCzM6jjwsm7dumnfvn06deqU2rVrZ3UcAEALadUHFFQdI9OpUyeLk6AlVO1eKi8vtzgJAKAlteoyU4VdEPbEdgWA1oEyAwAAjGZpmdm4caMmTpyo8PBwORwOvfPOO9WWu91uPfroowoPD1fHjh01atQoff7559aEBdAomZnFWrNmr7KySqyO0iwuV67mzftYqal5VkeB7LM97PL6WLBgi372s3/oT3/6xNIclh4AfOTIEV166aW67bbb9POf/7zG8ieffFJPP/20li1bptjYWD3++OMaO3asvv766wZ98RQaZ+rUqTp48KCnVI4aNUqDBw/W4sWLLc0FsxQXH1NS0mq5XHmescTESKWkTFBoaIB1wRopJ6dEcXGvq6jouGcsLCxAGRk3KyoqxLpgrZRdtoddXh8ffpivhIR/ye2uvL5+fYEefPAjbdhwk0aO7OPzPJbOzPzP//yPHn/8cd1www01lrndbi1evFgPPfSQbrjhBg0cOFDLly/X0aNHtXLlSgvStj6rVq3S/PnzrY5Rq8jISEqWn0pKWq20tPxqY2lp+Zo8+T2LEjXN2W+cklRUdFzDhq2wKFHrZpftYZfXx5lFporbLY0a9U9L8vjtMTO5ubk6cOCAxo0b5xnr0KGDrrrqKn388cfn/LkTJ06orKys2sUX7DJleKauXbsyA4ZGycwslsuVp/Ly6r/lysvdcrnyjHl9uFy5Nd44qxQVHTd+F4dp7LI97PL6WLBgS40iU8XtliW7nPy2zBw4cECS1KNHj2rjPXr08CyrTXJysoKDgz2XiIiIFs1ZXHxM48e/qQsv/H+6+upVio19RePHv6mSktpfeN4yatQozZw5U7Nnz1ZoaKh69OihpUuX6siRI7rtttsUGBiofv36ac2aNZIqT0/+9a9/raioKHXs2FEXXnihnn322XofY/bs2Z7r+/fv1zXXXKOOHTsqKipKK1eurDFD4nA49PLLL+v6669Xp06dFBMTo3fffdezvCE5pk6dquuuu05PPfWUevXqpbCwME2fPt1zKv2oUaOUn5+vu+++Ww6Hg7OW/EhOzsE6l2dnm/HLeuvW/XUu37Jln4+SQLLP9rDL62Pdum/qXP7BB/l1Lm8Jfltmqpz9RuV2u+t885o7d65KS0s9l4KCghbNZ+WU4fLly3Xeeedp27Ztmjlzpu666y7deOONGj58uHbu3KnExET96le/0tGjR1VRUaHevXvrn//8p7744gs98sgjevDBB/XPfzZ8SvCWW27Rvn37tGHDBr311ltaunSpCgsLa9zuscce00033aQ9e/bo6quv1pQpU1RcXCxJDc6xfv165eTkaP369Vq+fLmWLVumZcuWSarc/dW7d2/NmzdP+/fv1/79df+ig+/06xdS5/Lo6FDfBGmmuLhedS6Pjw/3URJI9tkednl9jBlT9zEx48b19VGSH/ltmenZs6ck1ZiFKSwsrDFbc6YOHTooKCio2qWlWD1leOmll+rhhx9WTEyM5s6dq44dO+q8887THXfcoZiYGD3yyCMqKirSnj171K5dOz322GMaNmyYoqKiNGXKFE2dOrXBZearr75SWlqaXnrpJcXFxemyyy7Tyy+/rGPHjtW47dSpUzV58mRFR0dr4cKFOnLkiLZt2yZJDc4RGhqqF154Qf3799eECRN0zTXXaN26dZIqd385nU4FBgaqZ8+enucKrBcb21WJiZFyOqv/weF0OpSYGKmYGDN+WScmRiksrPaDMcPCAjR2bKRvA7Vydtkednl9PPRQvM41p+BwSA888BPfBpIfl5moqCj17NlTqampnrEffvhB6enpGj58uIXJfmT1lOGgQYM8/3Y6nQoLC9Mll1ziGasqfVWzJy+++KKGDh2qbt26qUuXLnrppZf0zTd1TxdW+frrr9W2bVtddtllnrHo6GiFhtZ88Z2Zq3PnzgoMDKw2g9OQHAMGDJDT6fRc79WrV62zQPA/KSkTlJBQ/S+zhIS+SkmZYFGipsnIuLnGG2jV2TPwPbtsD7u8PjZsuKlGoXE4KsetYOmp2YcPH1Z2drbnem5urnbv3q2uXbuqT58+mj17thYuXKiYmBjFxMRo4cKF6tSpk5KSkixM/SOrpwzP/r4hh8NRbaxqd1xFRYX++c9/6u6779aiRYsUHx+vwMBA/fnPf9bWrVsb9FjucxztVdt4bbkqKiokqcE56roP+LfQ0ACtXTtJWVklys4uUXR0qDF/cZ4pKipE338/Q6mpedqyZZ/i48ONmQGwI7tsD7u8PkaO7KOKinv0pz99og8+yNe4cX0tmZGpYmmZ2b59u0aPHu25PmfOHEnSrbfeqmXLlum+++7TsWPHNG3aNJWUlCguLk4ffPCB35xhUzVlmJaWX21Xk9PpUEJCX796gm7atEnDhw/XtGnTPGM5OTkN/vn+/fvr1KlT2rVrly6//HJJUnZ2tg4ePOjTHFXat2/Pdy75uZgYM39Jn23s2Egj3zTtyi7bwy6vjwce+ImlJaaKpbuZRo0aJbfbXeNSdaCnw+HQo48+qv379+v48eNKT0/XwIEDrYxcgylThtHR0dq+fbtcLpcyMzP1hz/8QRkZGQ3++f79+yshIUF33nmntm3bpl27dunOO+9Ux44dG3U2UXNzVImMjNTGjRv17bff6vvvv2/0zwMA7MNvj5kxRdWUYWbmr/X++zcoM/PXWrt2kt99kuNvf/tb3XDDDfrFL36huLg4FRUVVZsdaYi///3v6tGjh0aOHKnrr79ed9xxhwIDAxUQ0PB19UYOSZo3b57y8vLUr18/devWrdE/DwCwD4f7XAdD2ERZWZmCg4NVWlpa48ym48ePKzc3V1FRUY16Q0al//znP4qIiFBaWprGjBljdZwa2L4AYK663r/PZukxMzDLhx9+qMOHD+uSSy7R/v37dd999ykyMlIjR460OhoAoBWjzKDBTp48qQcffFB79+5VYGCghg8frtdff73GmUcAAPgSZQYNlpiYqMTERKtjAABQDQcAAwAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmXGUKNGjdLs2bNb9DGmTp2q6667rkUfAwCA5uLUbJzTs88+e85vywYAwF9QZnBOwcHBVkcAAKBe7GbymkxJayRl+ewRT506pRkzZigkJERhYWF6+OGHPTMpP/zwg+677z6df/756ty5s+Li4rRhwwbPzy5btkwhISFyuVy66KKL1KVLF40fP1779+/33Obs3UyHDh3SlClT1LlzZ/Xq1UvPPPNMjd1dkZGRWrhwoW6//XYFBgaqT58+Wrp0aUv/VwAAWjHKTLMVSxov6UJJV0uKPX29pMUfefny5Wrbtq22bt2q5557Ts8884xefvllSdJtt92mzZs364033tCePXt04403avz48crK+rFsHT16VE899ZRee+01bdy4Ud98843uueeecz7enDlztHnzZr377rtKTU3Vpk2btHPnzhq3W7RokYYOHapdu3Zp2rRpuuuuu/TVV195/z8AAACxm8kLkiSlnTWWJmmypLUt+sgRERF65pln5HA4dOGFF+qzzz7TM888o5/97GdKSUnRf/7zH4WHh0uS7rnnHq1du1avvvqqFi5cKKnyu5ZefPFF9evXT5I0Y8YMzZs3r9bHOnTokJYvX66VK1d6viH71Vdf9dz/ma6++mpNmzZNknT//ffrmWee0YYNG9S/f3+v/x8AAECZaZZMSa5axstPj2dJimmxR//JT34ih8PhuR4fH69FixZp+/btcrvdio2NrXb7EydOKCwszHO9U6dOniIjSb169VJhYWGtj7V3716dPHlSV1xxhWcsODhYF154YY3bDho0yPNvh8Ohnj17nvN+AQBoLspMs+TUszxbLVlm6uJ0OrVjxw45nc5q4126dPH8++xvu3Y4HOc8e6lq/MzydOb4mWq734qKioaHBwCgESgzzdKvnuXRLfron3zySY3rMTExGjJkiMrLy1VYWKif/vSnXnmsfv36qV27dtq2bZsiIiIkSWVlZcrKytJVV13llccAAKApOAC4WWIlJUpynjXuPD3esrMyBQUFmjNnjr7++mulpKTo+eef16xZsxQbG6spU6bolltu0apVq5Sbm6uMjAw98cQTev/995v0WIGBgbr11lt17733av369fr88891++23q02bNjVmawAA8CVmZpotRZUH+5557EzC6fGWdcstt+jYsWO64oor5HQ6NXPmTN15552SKg/Offzxx/X73/9e3377rcLCwhQfH6+rr766yY/39NNP67e//a0mTJigoKAg3XfffSooKFBAQIC3VgkAgEZzuG3+Ea9lZWUKDg5WaWmpgoKCqi07fvy4cnNzFRUV5YU35CxVHiMTLauOk/G1I0eO6Pzzz9eiRYv061//2uo4NXh3+wIAfKmu9++zMTPjNTGye4nZtWuXvvrqK11xxRUqLS31nMZ97bXXWpwMANCaUWbQKE899ZS+/vprtW/fXpdffrk2bdqk8847z+pYAIBWjDKDBhsyZIh27NhhdQwAAKrhbCYAAGA0yoxq/+A3mI/tCgCtQ6suM1WfVHv06FGLk6Al/PDDD5JU41OQAQD20qqPmXE6nQoJCfF8b1CnTp34ADibqKio0HfffadOnTqpbdtW/TQHANtr9b/le/bsKUl8EaINtWnTRn369KGgAoDNtfoy43A41KtXL3Xv3l0nT560Og68qH379mrTplXvSQWAVqHVl5kqTqeTYysAADAQf7YCAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEbz6zJz6tQpPfzww4qKilLHjh11wQUXaN68eaqoqLA6GoBWI1PSGklZVgdplszMYq1Zs1dZWSVWRwG8rq3VAeryxBNP6MUXX9Ty5cs1YMAAbd++XbfddpuCg4M1a9Ysq+MBsLViSUmSXGeMJUpKkRRqSaKmKC4+pqSk1XK58jxjiYmRSkmZoNDQAOuCAV7k1zMzW7Zs0bXXXqtrrrlGkZGRmjRpksaNG6ft27dbHQ2A7SVJSjtrLE3SZAuyNF1S0mqlpeVXG0tLy9fkye9ZlAjwPr8uM1deeaXWrVunzMxMSdKnn36qjz76SFdfffU5f+bEiRMqKyurdgGAxslU5YxM+Vnj5afHzdjllJlZLJcrT+Xl7mrj5eVuuVx57HKCbfj1bqb7779fpaWl6t+/v5xOp8rLy7VgwQJNnnzuv4ySk5P12GOP+TAlAPvJqWd5tqQYXwRplpycg3Uuz84uUUyMObvMgHPx65mZf/zjH1qxYoVWrlypnTt3avny5Xrqqae0fPnyc/7M3LlzVVpa6rkUFBT4MDEAe+hXz/Jon6Rorn79QupcHh1NkYE9+PXMzL333qsHHnhAv/zlLyVJl1xyifLz85WcnKxbb7211p/p0KGDOnTo4MuYAGwnVpUH+6ap+q4mp6QEmTArI0mxsV2VmBiptLT8aruanE6HEhL6MisD2/DrmZmjR4+qTZvqEZ1OJ6dmA/CBFFUWlzMlnB43R0rKBCUk9K02lpDQVykpEyxKBHifX8/MTJw4UQsWLFCfPn00YMAA7dq1S08//bRuv/12q6MBsL1QSWtVebBvtip3LZkxI3Om0NAArV07SVlZJcrOLlF0dCgzMrAdh9vtdtd/M2scOnRIf/jDH/T222+rsLBQ4eHhmjx5sh555BG1b9++QfdRVlam4OBglZaWKigoqIUTAwAAb2jM+7dflxlvoMwAAGCexrx/+/UxMwAAAPWhzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKO1tToA4C2ZmcXKyTmo6OhQxcSEWh0HQAvgde5fXK5cbd26X/Hx4Ro7NtKyHJQZGK+4+JiSklbL5crzjCUmRiolZYJCQwOsCwbAa3id+5ecnBLFxb2uoqLjnrGwsABlZNysqKgQn+dhNxOMl5S0Wmlp+dXG0tLyNXnyexYlAuBtvM79y9lFRpKKio5r2LAVluShzMBomZnFcrnyVF7urjZeXu6Wy5WnrKwSi5IB8BZe5/7F5cqtUWSqFBUdV2pqnm8DiTIDw+XkHKxzeXY2v+QA0/E69y9bt+6vc/mWLft8lORHlBkYrV+/kDqXR0dzgCBgOl7n/iUurledy+Pjw32U5EeUGRgtNrarEhMj5XQ6qo07nQ4lJkZytgNgA7zO/UtiYpTCwmo/6DosLMCSs5ooMzBeSsoEJST0rTaWkNBXKSkTLEoEwNt4nfuXjIybaxSaqrOZrOBwu93u+m9mrrKyMgUHB6u0tFRBQUFWx0ELysoqUXZ2CZ8/AdgYr3P/kpqapy1b9rXI58w05v2bMgMAAPxOY96/2c0EAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGa3KZycnJ0cMPP6zJkyersLBQkrR27Vp9/vnnXgsHAABQnyaVmfT0dF1yySXaunWrVq1apcOHD0uS9uzZoz/+8Y9eDQg0VGZmsdas2ausrBKro0B22h6ZktZIyrI6CGzELq8PlytX8+Z9rNTUPEtztG3KDz3wwAN6/PHHNWfOHAUGBnrGR48erWeffdZr4STp22+/1f333681a9bo2LFjio2N1SuvvKLLL7/cq48DcxUXH1NS0mq5XHmescTESKWkTFBoaIB1wVop+2yPYklJklxnjCVKSpEUakkimM8ur4+cnBLFxb2uoqLjnrGwsABlZNysqKgQn+dp0szMZ599puuvv77GeLdu3VRUVNTsUFVKSko0YsQItWvXTmvWrNEXX3yhRYsWKSQkxGuPAfMlJa1WWlp+tbG0tHxNnvyeRYlaN/tsjyRJaWeNpUmabEEW2IVdXh9nFxlJKio6rmHDVliSp0kzMyEhIdq/f7+ioqKqje/atUvnn3++V4JJ0hNPPKGIiAi9+uqrnrHIyMg6f+bEiRM6ceKE53pZWZnX8sD/ZGYWV/sLp0p5uVsuV56yskoUE8Nf0b5in+2RqeozMlXKT49nSYrxaSKYzy6vD5crt0aRqVJUdFypqXkaOzbSp5maNDOTlJSk+++/XwcOHJDD4VBFRYU2b96se+65R7fccovXwr377rsaOnSobrzxRnXv3l1DhgzRSy+9VOfPJCcnKzg42HOJiIjwWh74n5ycg3Uuz842e3+0aeyzPXLqWZ7tkxSwF7u8PrZu3V/n8i1b9vkoyY+aVGYWLFigPn366Pzzz9fhw4d18cUXa+TIkRo+fLgefvhhr4Xbu3evlixZopiYGLlcLv32t7/V7373O/39738/58/MnTtXpaWlnktBQYHX8sD/9OsXUufy6Gj//yvHTuyzPfrVszzaJylgL3Z5fcTF9apzeXx8uI+S/MjhdrvdTf3hnJwc7dq1SxUVFRoyZIhiYrw77dq+fXsNHTpUH3/8sWfsd7/7nTIyMrRly5YG3UdZWZmCg4NVWlqqoKAgr+aDfxg//k2lpeWrvPzHp7LT6VBCQl+tXTvJwmStk322x3hVHiNTfsaYU1KCpLWWJIL57PL6OO+8F2rd1RQWFqDvv5/hlcdozPt3k2ZmNm7cqMLCQvXr10+TJk3STTfdpJiYGJ08eVIbN25sUuja9OrVSxdffHG1sYsuukjffPON1x4D5ktJmaCEhL7VxhIS+iolZYJFiVo3+2yPFFUWlzMlnB4HmsYur4+MjJsVFlb97Kuqs5ms0KSZmTZt2qhHjx5atWqV4uPjPeP//e9/FR4ervLy8jp+uuGSkpJUUFCgTZs2ecbuvvtubd26tdpsTV2YmWk9srJKlJ1doujoUCMOorM7+2yPLFUeIxMtDvqFt9jl9ZGamqctW/YpPj7c6wf9Nub9u8llZtasWfrb3/6mv/71r5o6daqkyjLTq1cvVVRUNCn42TIyMjR8+HA99thjuummm7Rt2zbdcccdWrp0qaZMmdKg+6DMAABgnhbfzeRwODR37lytWLFCM2fO1Jw5c1TViRwOR1PuslbDhg3T22+/rZSUFA0cOFDz58/X4sWLG1xkAACA/TV5ZubAgQPq3r27du3apWuvvVYXX3yxnn32WV188cVe283kDczMAABgnhafmTnTkCFDtG3bNh08eFBjxoxp7t0BAAA0SpPKzK233qqOHTt6rvfs2VPp6ekaM2aM+vTp47VwAAAA9WnW58yYgN1MAACYpzHv3w3+bqY9e/Zo4MCBatOmjfbs2VPnbQcNGtTQuwUAAGiWBpeZwYMHew76HTx4sBwOh86c1Km67nA4/OoAYAAAYG8NLjO5ubnq1q2b598AAAD+oMFlpm/fvrX+GwAAwEqNOpspOztbO3bsqDa2bt06jR49WldccYUWLlzo1XAAAAD1aVSZuffee/XOO+94rufm5mrixIlq37694uPjlZycrMWLF3s5IgAAwLk1eDeTJG3fvl333Xef5/rrr7+u2NhYuVwuSZVnMT3//POaPXu2V0MCAACcS6NmZr7//nv17t3bc339+vWaOHGi5/qoUaOUl5fntXAAAAD1aVSZ6dq1q/bv3y9Jqqio0Pbt2xUXF+dZ/sMPP8jmn8EHAAD8TKPKzFVXXaX58+eroKBAixcvVkVFhUaPHu1Z/sUXXygyMtLbGQEAAM6pUcfMLFiwQGPHjlXfvn3ldDr13HPPqXPnzp7lr732mn72s595PSQAAMC5NLjMlJWVKSoqSl9++aW++OILdevWTeHh4dVu89hjj1U7pgYAAKClNXg3U2hoqAoLC9WuXTvdfffd6tSpU43bXHrppQoLC/NqQAAAgLo0uMx06dJFRUVFkqQNGzbo5MmTLRYKAACgoRq8mykhIUGjR4/WRRddJEm6/vrr1b59+1pv++GHH3onHQAAQD0aXGZWrFih5cuXKycnR+np6RowYECtu5oAAAB8yeFuwgfDjB49Wm+//bZCQkJaIJJ3lZWVKTg4WKWlpQoKCrI6DgAAaIDGvH836tTsKuvXr29SMAAAAG9rcJmZM2eO5s+fr86dO2vOnDl13vbpp59udjAAAICGaHCZ2bVrl+cMpl27dp3zdg6Ho/mpAAAAGqhJx8yYhGNmAAAwT2Pevxv13UwAAAD+pkkHAB85ckR/+tOftG7dOhUWFqqioqLa8r1793olHAAAQH2aVGb+93//V+np6frVr36lXr16cZyM4TIzi5WTc1DR0aGKiQm1Ok6T2WU97ILt4V/YHv7F5crV1q37FR8frrFjI62O02T+sh5NKjNr1qzR6tWrNWLECG/ngQ8VFx9TUtJquVx5nrHExEilpExQaGiAdcEayS7rYRdsD//C9vAvOTkliot7XUVFxz1jYWEBysi4WVFRIdYFayR/W48mHTMTGhqqrl27ejsLfCwpabXS0vKrjaWl5Wvy5PcsStQ0dlkPu2B7+Be2h385uwBIUlHRcQ0btsKiRE3jb+vRpDIzf/58PfLIIzp69Ki388BHMjOL5XLlqby8+sls5eVuuVx5ysoqsShZ49hlPeyC7eFf2B7+xeXKrVEAqhQVHVdqap5vAzWRP65Hk8rMokWL5HK51KNHD11yySW67LLLql3g/3JyDta5PDvbjF9ydlkPu2B7+Be2h3/ZunV/ncu3bNnnoyTN44/r0aRjZq699loO+jVcv34hdS6PjjbjAEG7rIddsD38C9vDv8TF9apzeXx8uI+SNI8/rkeTysyjjz7q5RjwtdjYrkpMjFRaWn61KWin06GEhL7GnO1gl/WwC7aHf2F7+JfExCiFhQXUuosmLCzAmLOa/HE9GrWbqU2bNnI6nTUuoaGh+slPfqJVq1a1VE60gJSUCUpI6FttLCGhr1JSJliUqGnssh52wfbwL2wP/5KRcbPCwqqfRVZ1FpBJ/G09GvV1Bv/+979rHT948KC2bdumV199VcuXL9eNN97otYDNxdcZ1C8rq0TZ2SXGf/6EXdbDLtge/oXt4V9SU/O0Zcs+yz+fpblacj0a8/7t1e9m+stf/qK///3v2rp1q7fustkoMwAAmMey72YaN26cMjMzvXmXAAAAdfJqmTl27JgCAvhESQAA4DteLTMvvfSShgwZ4s27BAAAqFOjTs2eM2dOreOlpaXavn27cnJytGnTJq8EAwAAaIhGlZldu3bVOh4UFKTx48dr2rRp6tu3b623AQAAaAmNKjPr169vqRwAAABN4tVjZgAAAHyNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRjCozycnJcjgcmj17ttVRANQjN3ebMjL+n/LytlsdBZIyM4u1Zs1eZWWVWB2lWVgP/+Jy5WrevI+VmppnaY62lj56I2RkZGjp0qUaNGiQ1VEA1KGk5Fvl5FyjoUM/VVRU5dj27ZcqOnqNQkJ6WRuuFSouPqakpNVyufI8Y4mJkUpJmaDQ0ADrgjUS6+FfcnJKFBf3uoqKjnvGwsIClJFxs6KiQnyex4iZmcOHD2vKlCl66aWXFBoaanUcAHXIyblGgwfvqTY2ePAeZWf/j0WJWrekpNVKS8uvNpaWlq/Jk9+zKFHTsB7+5ewiI0lFRcc1bNgKS/IYUWamT5+ua665RgkJCfXe9sSJEyorK6t2AeAbubnbNHTop2rb1l1tvG1bt4YO/ZRdTj6WmVkslytP5eXVt0d5uVsuV54xuzhYD//icuXWKDJVioqOW7LLye/LzBtvvKGdO3cqOTm5QbdPTk5WcHCw5xIREdHCCQFU+f77/6/O5d99t6fO5fCunJyDdS7PzjbjzZP18C9bt+6vc/mWLft8lORHfl1mCgoKNGvWLK1YsUIBAQ3blzh37lyVlpZ6LgUFBS2cEkCV884bWOfybt045s2X+vULqXN5dLQZu+1ZD/8SF1f3sW/x8eE+SvIjvy4zO3bsUGFhoS6//HK1bdtWbdu2VXp6up577jm1bdtW5eXlNX6mQ4cOCgoKqnYB4BtRUVdo+/ZLdeqUo9r4qVMObd9+qSIjh1qUrHWKje2qxMRIOZ3Vt4fT6VBiYqRiYsx482Q9/EtiYpTCwmqfYAgLC9DYsZG+DSQ/LzNjxozRZ599pt27d3suQ4cO1ZQpU7R79245nU6rIwI4S3T0Gu3eXX0GZvfuQYqOXmNRotYtJWWCEhL6VhtLSOirlJQJFiVqGtbDv2Rk3Fyj0FSdzWQFh9vtdtd/M/8xatQoDR48WIsXL27Q7cvKyhQcHKzS0lJmaQAfysvbru++26Nu3QYxI+MHsrJKlJ1doujoUGNmAGrDeviX1NQ8bdmyT/Hx4V6fkWnM+zdlBgAA+J3GvH8b86F5VTZs2GB1BAAA4Ef8+pgZAACA+lBmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0dpaHcBsmZJyJEVLirE4S9NlZhYrJ+egoqNDFRMTanWcJrPLetjFkiX/UH7+LkVFXa7f/OZGq+M0mV2eVy5XrrZu3a/4+HCNHRtpdZwms8v2sAt/eV5RZpqkWFKSJNcZY4mSUiSZ8+IqLj6mpKTVcrnyPGOJiZFKSZmg0NAA64I1kl3Wwy42bvxUR4/epLvuyvSMrV0bq6CgNzV8+CUWJmscuzyvcnJKFBf3uoqKjnvGwsIClJFxs6KiQqwL1kh22R524W/PK3YzNUmSpLSzxtIkTbYgS9MlJa1WWlp+tbG0tHxNnvyeRYmaxi7rYRdHj96khISsamMJCVkqK5tkUaKmscvz6uw3HEkqKjquYcNWWJSoaeyyPezC355XlJlGy1TljEz5WePlp8ezavyEP8rMLJbLlafycne18fJyt1yuPGVllViUrHHssh52sWTJPzR+fKbatq2+Pdq2dWv8+Ez97W//sihZ49jleeVy5dZ4w6lSVHRcqal5vg3URHbZHnbhj88rykyj5dSzPNsnKZorJ+dgncuzs8345WCX9bCL/PxddS7Pzd3hoyTNY5fn1dat++tcvmXLPh8laR67bA+78MfnFWWm0frVszzaJymaq1+/kDqXR0ebceyPXdbDLvr2HVLn8qioy32UpHns8ryKi+tV5/L4+HAfJWkeu2wPu/DH5xVlptFiVXmwr/OscefpcTPOaoqN7arExEg5nY5q406nQ4mJkcacJWCX9bCLu+76hdaujdWpU9W3x6lTDq1dG2vMWU12eV4lJkYpLKz2g2PDwgKMOavJLtvDLvzxeUWZaZIUSQlnjSWcHjdHSsoEJST0rTaWkNBXKSkTLErUNHZZD7sICnpTaWnVS31aWoyCgt60KFHT2OV5lZFxc403nqqzTkxil+1hF/72vHK43W53/TczV1lZmYKDg1VaWqqgoCAv33uWKo+RMftzZrKySpSdXWL85zbYZT3s4m9/+5dyc3cY/zkzdnlepabmacuWfZZ/Hkhz2WV72EVLPq8a8/5NmQEAAH6nMe/f7GYCAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBofl1mkpOTNWzYMAUGBqp79+667rrr9PXXX1sdy4YyJa2RlGV1kGZiPfzJpk3rtHLlIm3evN7qKM1kj+1hFy5XrubN+1ipqXlWR4EfaWt1gLqkp6dr+vTpGjZsmE6dOqWHHnpI48aN0xdffKHOnTtbHc8GiiUlSXKdMZYoKUVSqCWJmob18Ce5uXu1d+8EjRnzpWds3bqLFB39vvr2jbQuWKPZY3vYRU5OieLiXldR0XHPWFhYgDIyblZUVIh1weAXHG632211iIb67rvv1L17d6Wnp2vkyJEN+pmysjIFBwertLRUQUFBLZzQNOMlpUkqP2PMKSlB0lpLEjUN6+FP1q27WFdd9ZXatv3xV8upUw6lp/fXmDFfWJisseyxPezivPNeqFZkqoSFBej772dYkAgtrTHv3369m+lspaWlkqSuXbue8zYnTpxQWVlZtQtqk6nKvzjLzxovPz1uypQ66+FPNm1apzFjvqxWZCSpbVu3xoz50qBdTvbYHnbhcuXWWmQkqajoOLucYE6ZcbvdmjNnjq688koNHDjwnLdLTk5WcHCw5xIREeHDlCbJqWd5tk9SNB/r4U8KCnbXuTw/f6dvgjSbPbaHXWzdur/O5Vu27PNREvgrY8rMjBkztGfPHqWkpNR5u7lz56q0tNRzKSgo8FFC0/SrZ3m0T1I0H+vhTyIiBte5vG/fy3wTpNnssT3sIi6uV53L4+PDfZQE/sqIMjNz5ky9++67Wr9+vXr37l3nbTt06KCgoKBqF9QmVpUHMzrPGneeHo/xeaKmYT38yU9/Okbr1l2kU6cc1cZPnXJo3bqLNGLEaIuSNZY9toddJCZGKSwsoNZlYWEBGjs20reB4Hf8usy43W7NmDFDq1at0ocffqioqCirI9lMiioPZjxTwulxk7Ae/iQ6+n2lp/evNpae3l/R0e9blKip7LE97CIj4+YahabqbCbAr89mmjZtmlauXKl///vfuvDCCz3jwcHB6tixY4Pug7OZGiJLlccARMvsvzhZD3+yefN65efvVN++lxk0I1Mbe2wPu0hNzdOWLfsUHx/OjIzNNeb926/LjMPhqHX81Vdf1dSpUxt0H5QZAADM05j3b7/+0Dw/7lkAAMBP+PUxMwAAAPWhzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMBplBgAAGI0yAwAAjEaZAQAARqPMAAAAo1FmAACA0SgzAADAaJQZAABgNMoMAAAwGmUGAAAYjTIDAACMRpkBAABGo8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZpolQpX/hX2sDtJMwyV1lnSl1UGa6XpJPSRNsjpIM9llPV6R9CtJyyzO0VyZktZIyrI6CIBzoMw0ya2SHJL+I8ktqeD09TutDNUE81SZe4uko5I2n77+JytDNcESVeZ+R1KhpLdOX3/FwkxNYZf12CGpvaT/lbRC0m2nr++2MFNTFEsaL+lCSVdLij19vcTKUABq4XC73W6rQ7SksrIyBQcHq7S0VEFBQV66V0cdy0z672Q9/Itd1qO9pJO1jLeT9IOPszTHeElpksrPGHNKSpC01pJEQGvSmPdvZmYaLaKe5abschpez3JTdjldX89yU3bV2GU9XlHtRUanx5f5LkqzZEpyqXqR0enrLrHLCfAvlJlG+7ae5f/xSYrm+7Se5bt8kqL5Pq5n+SafpGg+u6zHhnqWr/NFCC/IqWd5tk9SAGgYykyjnV/P8t4+SdF8l9azfIhPUjRffTNMP/VJiuazy3qMqmf5GF+E8IJ+9SyP9kkKAA3DMTNNYpdjG1gP/2KX9eCYGQDNxzEzLe6ORo77q+RGjvurlxs57q/ssh7bVFlcztTu9LhJUlRZXM6UcHocgD9hZqZZ+qjyGJnekr7x8n370pWqPEZmiKSPLM7SHJNUeWzJTyW9aXGW5rDLeixT5TEyYyRNtTRJ82Sp8hiZaEkxFmcBWo/GvH9TZgAAgN9hNxMAAGg1KDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGhtrQ7Q0qq+raGsrMziJAAAoKGq3rcb8q1Lti8zhw4dkiRFRERYnAQAADTWoUOHFBwcXOdtbP9FkxUVFdq3b58CAwPlcDisjuOXysrKFBERoYKCAr6M0w+wPfwL28O/sD38S0tuD7fbrUOHDik8PFxt2tR9VIztZ2batGmj3r17Wx3DCEFBQfxy8CNsD//C9vAvbA//0lLbo74ZmSocAAwAAIxGmQEAAEajzEAdOnTQH//4R3Xo0MHqKBDbw9+wPfwL28O/+Mv2sP0BwAAAwN6YmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUmVYqOTlZw4YNU2BgoLp3767rrrtOX3/9tdWxcFpycrIcDodmz55tdZRW7dtvv9XNN9+ssLAwderUSYMHD9aOHTusjtUqnTp1Sg8//LCioqLUsWNHXXDBBZo3b54qKiqsjtYqbNy4URMnTlR4eLgcDofeeeedasvdbrceffRRhYeHq2PHjho1apQ+//xzn+WjzLRS6enpmj59uj755BOlpqbq1KlTGjdunI4cOWJ1tFYvIyNDS5cu1aBBg6yO0qqVlJRoxIgRateundasWaMvvvhCixYtUkhIiNXRWqUnnnhCL774ol544QV9+eWXevLJJ/XnP/9Zzz//vNXRWoUjR47o0ksv1QsvvFDr8ieffFJPP/20XnjhBWVkZKhnz54aO3as5/sRWxqnZkOS9N1336l79+5KT0/XyJEjrY7Tah0+fFiXXXaZ/vrXv+rxxx/X4MGDtXjxYqtjtUoPPPCANm/erE2bNlkdBZImTJigHj166JVXXvGM/fznP1enTp302muvWZis9XE4HHr77bd13XXXSaqclQkPD9fs2bN1//33S5JOnDihHj166IknntBvfvObFs/EzAwkSaWlpZKkrl27WpykdZs+fbquueYaJSQkWB2l1Xv33Xc1dOhQ3XjjjerevbuGDBmil156yepYrdaVV16pdevWKTMzU5L06aef6qOPPtLVV19tcTLk5ubqwIEDGjdunGesQ4cOuuqqq/Txxx/7JIPtv2gS9XO73ZozZ46uvPJKDRw40Oo4rdYbb7yhnTt3KiMjw+ookLR3714tWbJEc+bM0YMPPqht27bpd7/7nTp06KBbbrnF6nitzv3336/S0lL1799fTqdT5eXlWrBggSZPnmx1tFbvwIEDkqQePXpUG+/Ro4fy8/N9koEyA82YMUN79uzRRx99ZHWUVqugoECzZs3SBx98oICAAKvjQFJFRYWGDh2qhQsXSpKGDBmizz//XEuWLKHMWOAf//iHVqxYoZUrV2rAgAHavXu3Zs+erfDwcN16661Wx4Mqdz+dye121xhrKZSZVm7mzJl69913tXHjRvXu3dvqOK3Wjh07VFhYqMsvv9wzVl5ero0bN+qFF17QiRMn5HQ6LUzY+vTq1UsXX3xxtbGLLrpIb731lkWJWrd7771XDzzwgH75y19Kki655BLl5+crOTmZMmOxnj17SqqcoenVq5dnvLCwsMZsTUvhmJlWyu12a8aMGVq1apU+/PBDRUVFWR2pVRszZow+++wz7d6923MZOnSopkyZot27d1NkLDBixIgaH1eQmZmpvn37WpSodTt69KjatKn+luV0Ojk12w9ERUWpZ8+eSk1N9Yz98MMPSk9P1/Dhw32SgZmZVmr69OlauXKl/v3vfyswMNCzzzM4OFgdO3a0OF3rExgYWON4pc6dOyssLIzjmCxy9913a/jw4Vq4cKFuuukmbdu2TUuXLtXSpUutjtYqTZw4UQsWLFCfPn00YMAA7dq1S08//bRuv/12q6O1CocPH1Z2drbnem5urnbv3q2uXbuqT58+mj17thYuXKiYmBjFxMRo4cKF6tSpk5KSknwT0I1WSVKtl1dffdXqaDjtqquucs+aNcvqGK3a//3f/7kHDhzo7tChg7t///7upUuXWh2p1SorK3PPmjXL3adPH3dAQID7ggsucD/00EPuEydOWB2tVVi/fn2t7xm33nqr2+12uysqKtx//OMf3T179nR36NDBPXLkSPdnn33ms3x8zgwAADAax8wAAACjUWYAAIDRKDMAAMBolBkAAGA0ygwAADAaZQYAABiNMgMAAIxGmQEAAEajzADwKw6HQ++8847VMQAYhDIDwKcOHDigmTNn6oILLlCHDh0UERGhiRMnat26dVZHA2AovmgSgM/k5eVpxIgRCgkJ0ZNPPqlBgwbp5MmTcrlcmj59ur766iurIwIwEDMzAHxm2rRpcjgc2rZtmyZNmqTY2FgNGDBAc+bM0SeffFLj9hs2bJDD4dDBgwc9Y7t375bD4VBeXp4kadmyZQoJCdF7772nCy+8UJ06ddKkSZN05MgRLV++XJGRkQoNDdXMmTNVXl7uuZ/IyEjNnz9fSUlJ6tKli8LDw/X888+39H8BgBZAmQHgE8XFxVq7dq2mT5+uzp0711geEhLS5Ps+evSonnvuOb3xxhtau3atNmzYoBtuuEHvv/++3n//fb322mtaunSp3nzzzWo/9+c//1mDBg3Szp07NXfuXN19991KTU1tcg4A1mA3EwCfyM7OltvtVv/+/b1+3ydPntSSJUvUr18/SdKkSZP02muv6b///a+6dOmiiy++WKNHj9b69ev1i1/8wvNzI0aM0AMPPCBJio2N1ebNm/XMM89o7NixXs8IoOUwMwPAJ9xut6TKs5W8rVOnTp4iI0k9evRQZGSkunTpUm2ssLCw2s/Fx8fXuP7ll196PR+AlkWZAeATMTExcjgcjSoLbdpU/oqqKkJS5SzM2dq1a1ftusPhqHWsoqKi3sdsibIFoGVRZgD4RNeuXZWYmKi//OUvOnLkSI3lZx7kW6Vbt26SpP3793vGdu/e7bVMZx90/Mknn7TIbjAALYsyA8Bn/vrXv6q8vFxXXHGF3nrrLWVlZenLL7/Uc889V2OXjyRFR0crIiJCjz76qDIzM7V69WotWrTIa3k2b96sJ598UpmZmfrLX/6if/3rX5o1a5bX7h+Ab1BmAPhMVFSUdu7cqdGjR+v3v/+9Bg4cqLFjx2rdunVasmRJjdu3a9dOKSkp+uqrr3TppZfqiSee0OOPP+61PL///e+1Y8cODRkyRPPnz9eiRYuUmJjotfsH4BsO95k7owGglYiMjNTs2bM1e/Zsq6MAaCZmZgAAgNEoMwAAwGjsZgIAAEZjZgYAABiNMgMAAIxGmQEAAEajzAAAAKNRZgAAgNEoMwAAwGiUGQAAYDTKDAAAMNr/D3uEuv/22qOUAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax = cell_df[cell_df['Class'] == 4][0:50].plot(kind='scatter', x='Clump', y='UnifSize', color='DarkBlue', label='malignant');\n", "cell_df[cell_df['Class'] == 2][0:50].plot(kind='scatter', x='Clump', y='UnifSize', color='Yellow', label='benign', ax=ax);\n", @@ -221,9 +515,96 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "object", + "type": "string" + }, + { + "name": "0", + "rawType": "object", + "type": "unknown" + } + ], + "ref": "281746c7-4a81-46e0-a499-c8419eb9c3ed", + "rows": [ + [ + "ID", + "int64" + ], + [ + "Clump", + "int64" + ], + [ + "UnifSize", + "int64" + ], + [ + "UnifShape", + "int64" + ], + [ + "MargAdh", + "int64" + ], + [ + "SingEpiSize", + "int64" + ], + [ + "BareNuc", + "object" + ], + [ + "BlandChrom", + "int64" + ], + [ + "NormNucl", + "int64" + ], + [ + "Mit", + "int64" + ], + [ + "Class", + "int64" + ] + ], + "shape": { + "columns": 1, + "rows": 11 + } + }, + "text/plain": [ + "ID int64\n", + "Clump int64\n", + "UnifSize int64\n", + "UnifShape int64\n", + "MargAdh int64\n", + "SingEpiSize int64\n", + "BareNuc object\n", + "BlandChrom int64\n", + "NormNucl int64\n", + "Mit int64\n", + "Class int64\n", + "dtype: object" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cell_df.dtypes" ] @@ -237,9 +618,96 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.microsoft.datawrangler.viewer.v0+json": { + "columns": [ + { + "name": "index", + "rawType": "object", + "type": "string" + }, + { + "name": "0", + "rawType": "object", + "type": "unknown" + } + ], + "ref": "5458eb75-be4b-46ba-8678-f58d95ffcc6f", + "rows": [ + [ + "ID", + "int64" + ], + [ + "Clump", + "int64" + ], + [ + "UnifSize", + "int64" + ], + [ + "UnifShape", + "int64" + ], + [ + "MargAdh", + "int64" + ], + [ + "SingEpiSize", + "int64" + ], + [ + "BareNuc", + "int64" + ], + [ + "BlandChrom", + "int64" + ], + [ + "NormNucl", + "int64" + ], + [ + "Mit", + "int64" + ], + [ + "Class", + "int64" + ] + ], + "shape": { + "columns": 1, + "rows": 11 + } + }, + "text/plain": [ + "ID int64\n", + "Clump int64\n", + "UnifSize int64\n", + "UnifShape int64\n", + "MargAdh int64\n", + "SingEpiSize int64\n", + "BareNuc int64\n", + "BlandChrom int64\n", + "NormNucl int64\n", + "Mit int64\n", + "Class int64\n", + "dtype: object" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cell_df = cell_df[pd.to_numeric(cell_df['BareNuc'], errors='coerce').notnull()]\n", "cell_df['BareNuc'] = cell_df['BareNuc'].astype('int')\n", @@ -248,9 +716,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 5, 1, 1, 1, 2, 1, 3, 1, 1],\n", + " [ 5, 4, 4, 5, 7, 10, 3, 2, 1],\n", + " [ 3, 1, 1, 1, 2, 2, 3, 1, 1],\n", + " [ 6, 8, 8, 1, 3, 4, 3, 7, 1],\n", + " [ 4, 1, 1, 3, 2, 1, 3, 1, 1]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "feature_df = cell_df[['Clump', 'UnifSize', 'UnifShape', 'MargAdh', 'SingEpiSize', 'BareNuc', 'BlandChrom', 'NormNucl', 'Mit']]\n", "X = np.asarray(feature_df)\n", @@ -266,9 +749,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 2, 2, 2, 2])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cell_df['Class'] = cell_df['Class'].astype('int')\n", "y = np.asarray(cell_df['Class'])\n", @@ -291,9 +785,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train set: (546, 9) (546,)\n", + "Test set: (137, 9) (137,)\n" + ] + } + ], "source": [ "X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=4)\n", "print ('Train set:', X_train.shape, y_train.shape)\n", @@ -325,9 +828,438 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
SVC()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "SVC()" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from sklearn import svm\n", "clf = svm.SVC(kernel='rbf')\n", @@ -343,9 +1275,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 4, 2, 4, 2])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "yhat = clf.predict(X_test)\n", "yhat [0:5]" @@ -360,7 +1303,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +1313,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -411,9 +1354,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " 2 1.00 0.94 0.97 90\n", + " 4 0.90 1.00 0.95 47\n", + "\n", + " accuracy 0.96 137\n", + " macro avg 0.95 0.97 0.96 137\n", + "weighted avg 0.97 0.96 0.96 137\n", + "\n", + "Confusion matrix, without normalization\n", + "[[85 5]\n", + " [ 0 47]]\n" + ] + } + ], "source": [ "# Compute confusion matrix\n", "cnf_matrix = confusion_matrix(y_test, yhat, labels=[2,4])\n", @@ -435,9 +1397,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.9639038982104676" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from sklearn.metrics import f1_score\n", "f1_score(y_test, yhat, average='weighted') " @@ -452,9 +1425,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(0.9444444444444444)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from sklearn.metrics import jaccard_score\n", "jaccard_score(y_test, yhat,pos_label=2)" @@ -470,11 +1454,85 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear Kernel Accuracy: 0.9708\n", + "RBF Kernel Accuracy: 0.9635\n" + ] + } + ], "source": [ - "# write your code here\n" + "import pandas as pd\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.svm import SVC\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "# Step 1: Load dataset\n", + "url = \"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/cell_samples.csv\"\n", + "df = pd.read_csv(url)\n", + "\n", + "# Step 2: Clean data - remove rows where 'BareNuc' is non-numeric\n", + "df = df[pd.to_numeric(df[\"BareNuc\"], errors='coerce').notnull()]\n", + "df[\"BareNuc\"] = df[\"BareNuc\"].astype(int)\n", + "\n", + "# Step 3: Define features and target\n", + "features = ['Clump', 'UnifSize', 'UnifShape', 'MargAdh', 'SingEpiSize',\n", + " 'BareNuc', 'BlandChrom', 'NormNucl', 'Mit']\n", + "X = df[features].values\n", + "y = df['Class'].values # 2 = benign, 4 = malignant\n", + "\n", + "# Step 4: Split dataset into training and testing\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", + "\n", + "# Step 5: Scale features\n", + "scaler = StandardScaler()\n", + "X_train = scaler.fit_transform(X_train)\n", + "X_test = scaler.transform(X_test)\n", + "\n", + "# Step 6: Train SVM with linear kernel\n", + "svm_linear = SVC(kernel='linear', random_state=42)\n", + "svm_linear.fit(X_train, y_train)\n", + "y_pred_linear = svm_linear.predict(X_test)\n", + "accuracy_linear = accuracy_score(y_test, y_pred_linear)\n", + "\n", + "# Step 7: Train SVM with RBF kernel (default)\n", + "svm_rbf = SVC(kernel='rbf', random_state=42)\n", + "svm_rbf.fit(X_train, y_train)\n", + "y_pred_rbf = svm_rbf.predict(X_test)\n", + "accuracy_rbf = accuracy_score(y_test, y_pred_rbf)\n", + "\n", + "# Step 8: Print accuracies\n", + "print(f\"Linear Kernel Accuracy: {accuracy_linear:.4f}\")\n", + "print(f\"RBF Kernel Accuracy: {accuracy_rbf:.4f}\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg F1-score: 0.9707\n", + "Jaccard score: 0.9512\n" + ] + } + ], + "source": [ + "clf2 = svm.SVC(kernel='linear')\n", + "clf2.fit(X_train, y_train) \n", + "yhat2 = clf2.predict(X_test)\n", + "print(\"Avg F1-score: %.4f\" % f1_score(y_test, yhat2, average='weighted'))\n", + "print(\"Jaccard score: %.4f\" % jaccard_score(y_test, yhat2,pos_label=2))" ] }, { @@ -505,7 +1563,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "base", "language": "python", "name": "python3" }, @@ -519,7 +1577,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.13.5" } }, "nbformat": 4,