From bae346a69c6e4b61dfd2608ae92e584842ec57fd Mon Sep 17 00:00:00 2001 From: Ridhi Bandaru <77619512+bendemonium@users.noreply.github.com> Date: Thu, 30 Jan 2025 21:47:16 -0500 Subject: [PATCH] Add files via upload --- DMMidTerm_TeamID_02.ipynb | 1432 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1432 insertions(+) create mode 100644 DMMidTerm_TeamID_02.ipynb diff --git a/DMMidTerm_TeamID_02.ipynb b/DMMidTerm_TeamID_02.ipynb new file mode 100644 index 0000000..02b19b3 --- /dev/null +++ b/DMMidTerm_TeamID_02.ipynb @@ -0,0 +1,1432 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "UeVUDmw_Xuyl" + }, + "source": [ + "# NFHS Data Mining: Menstrual Products and Birth-Related Issues\n", + "\n", + "Group 2 Presents an evaluation of how the usage of different menstrual products could result in birth-related issues or pregnancy complications by studying the NFHS data set, IABR, specifically the attributes, giving insight into menstrual products used, complications in abortion (or month when pregnancy ended), size of child at birth and smoking-related habits. We tried to understand this in relation to relevant literature surrounding the \n", + "\n", + "\n", + "*Problem Statement*: finding the degree of impact of menstrual products on birth and complications related to birth\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "q1Kcaq9kRJLY" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import math\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2V6wimCAZhXT" + }, + "outputs": [], + "source": [ + "data2015 = pd.read_csv('/content/IABR2015-16.csv', low_memory=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n6iF1CiRWik0" + }, + "source": [ + "# Data Cleaning and Preprocessing\n", + "\n", + "Firstly, features related to period products used, smoking habits, birth weight, birth size, urban/rural setting, first period age, pregnancy termination, and complication in pregnancy are extracted.\n", + "\n", + "Then, this data is cleaned by eliminating the samples where the person smokes, and empty cells are either filled or removed depending on how many missing values there are.\n", + "\n", + "The preprocessing techniques employed are: **data cleaning and smoothing, feature subset selection, aggregation,** and **entropy-based discretization**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "F-JiZpNdaHj5" + }, + "outputs": [], + "source": [ + "# feature subset selection\n", + "data = data2015[['S257A','S257B','S257C','S257D','S257E','S257X','V229','S240','M18','M19','V025','V024','V026','S256','V463A','V463B','V463C','V463D','V463E','V463F','V463G']]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "x0KezWGTVwQ3" + }, + "outputs": [], + "source": [ + "# removing rows where data related to menstrual products is not available\n", + "data['S257A'].replace(' ', np.nan, inplace=True) \n", + "data.dropna(subset = ['S257A'] , inplace = True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WlObjWQ2aHG_" + }, + "source": [ + "Below, we are aggregating the features of drug consumption as it is a known fact that they affect birth, and depending on what the new 'SMOKE' feature value is, we remove the entire sample is smoking corresponds to a positive value." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "SDUrqsdvPM-q" + }, + "outputs": [], + "source": [ + "# converting smoke features to numeric data\n", + "data['V463A'] = pd.to_numeric(data['V463A'])\n", + "data['V463B'] = pd.to_numeric(data['V463B'])\n", + "data['V463C'] = pd.to_numeric(data['V463C'])\n", + "data['V463D'] = pd.to_numeric(data['V463D'])\n", + "data['V463E'] = pd.to_numeric(data['V463E'])\n", + "data['V463F'] = pd.to_numeric(data['V463F'])\n", + "data['V463G'] = pd.to_numeric(data['V463G'])\n", + "\n", + "# aggregation of smoke features, removing the smoke positive data\n", + "data['SMOKE']=data['V463A']+data['V463B']+data['V463C']+data['V463D']+data['V463E']+data['V463F']+data['V463G']\n", + "data = data[data['SMOKE'] == 0]\n", + "data = data.drop(['SMOKE','V463A','V463B','V463C','V463D','V463E','V463F','V463G','V026'],axis=1)\n", + "\n", + "# dataframe saved as a CSV file for further processing\n", + "data.to_csv('remove_smoke.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oss_mUgQahaJ" + }, + "source": [ + "Now, we are smoothing out the data by filling in the missing values with the median." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "R1T7Xn3tgrYx" + }, + "outputs": [], + "source": [ + "# filling missing values in the birth weights with the global median\n", + "data['M19'].replace([' ','9996','9998','9999'], np.nan, inplace=True)\n", + "data['M19'] = pd.to_numeric(data['M19'])\n", + "data['M19'] = data['M19'].fillna(data['M19'].median())\n", + "\n", + "# filling missing values in the birth sizes with the global median\n", + "data['M18'].replace([' ',8,9], np.nan, inplace=True)\n", + "data['M18'] = pd.to_numeric(data['M18'])\n", + "data['M18'] = data['M18'].fillna(data['M18'].median())\n", + "\n", + "# filling missing values in the age at first period with the global median\n", + "data['S256'].replace(' ', np.nan, inplace=True)\n", + "data['S256'] = pd.to_numeric(data['S256'])\n", + "data['S256'] = data['S256'].fillna(data['S256'].median())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "z7Hz7aFszwSm" + }, + "outputs": [], + "source": [ + "# cleaning pregnancy termination data\n", + "data['V229'].replace(' ', np.nan, inplace=True)\n", + "data.dropna(subset = ['V229'] , inplace = True)\n", + "data['V229'] = pd.to_numeric(data['V229'])\n", + "data.to_csv('terminated_preg.csv') # saved as a CSV for data exploration\n", + "\n", + "# cleaning abortion complication data\n", + "data['S240'].replace(' ', np.nan, inplace=True)\n", + "data.dropna(subset = ['S240'] , inplace = True)\n", + "data['S240'] = pd.to_numeric(data['S240'])\n", + "data.to_csv('abortion_complication.csv') # saved as a CSV for data exploration" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "93ZddlUScg2s" + }, + "source": [ + "### Entropy-based Discretization\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "nb2VApv8L9G7" + }, + "outputs": [], + "source": [ + "def entropy(pos,neg):\n", + " total = pos + neg\n", + " pos_part = pos/total\n", + " neg_part = neg/total\n", + " if (pos == 0 or neg ==0):\n", + " return 0\n", + " else:\n", + " a = math.prod([pos_part,math.log2(pos_part)])\n", + " b = math.prod([neg_part,math.log2(neg_part)])\n", + " return (-1*(a+b))" + ] + }, + { + "cell_type": "code", + "source": [ + "data = pd.read_csv('/content/abortion_complication.csv')" + ], + "metadata": { + "id": "p5slmQdTBPc_" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We make different bins with combinations of birth size, and whether or not there was a complication in the abortion of the later pregnancy." + ], + "metadata": { + "id": "-HKyhYtUBblY" + } + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "H7DZw6W8bfT9", + "outputId": "05ebbea7-6bda-4a8d-cf21-27c756a23abe" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Split 1 BIN TABLE:\n", + "13 0 13\n", + "31 2 33\n", + "86 11 97\n", + "Total Entropy: 0.42212551957759814\n" + ] + } + ], + "source": [ + "# Split 1: {1,5},{2,4},{3}\n", + "\n", + "# making bin 1\n", + "bin1_1_0= data.apply(lambda x : True if ((x['M18']==1 or x['M18']==5) and x['S240']==0) else False, axis = 1)\n", + "bin1_1_0_total = len(bin1_1_0[bin1_1_0 == True].index)\n", + "bin1_1_1= data.apply(lambda x : True if ((x['M18']==1 or x['M18']==5) and x['S240']==1) else False, axis = 1)\n", + "bin1_1_1_total = len(bin1_1_1[bin1_1_1 == True].index)\n", + "bin1_1total = bin1_1_0_total + bin1_1_1_total\n", + "# calculating entropy of bin 1\n", + "entropy1_1 = entropy(bin1_1_0_total,bin1_1_1_total)\n", + "\n", + "# making bin 2\n", + "bin1_2_0= data.apply(lambda x : True if ((x['M18'] == 2 or x['M18']==4) and x['S240']==0) else False, axis = 1)\n", + "bin1_2_0_total = len(bin1_2_0[bin1_2_0 == True].index)\n", + "bin1_2_1= data.apply(lambda x : True if ((x['M18'] == 2 or x['M18']==4) and x['S240']==1) else False, axis = 1)\n", + "bin1_2_1_total = len(bin1_2_1[bin1_2_1 == True].index)\n", + "bin1_2total = bin1_2_0_total + bin1_2_1_total\n", + "# calculating entropy of bin 2\n", + "entropy1_2 = entropy(bin1_2_0_total,bin1_2_1_total)\n", + "\n", + "# making bin 3\n", + "bin1_3_0= data.apply(lambda x : True if (x['M18'] == 3 and x['S240']==0) else False, axis = 1)\n", + "bin1_3_0_total = len(bin1_3_0[bin1_3_0 == True].index)\n", + "bin1_3_1= data.apply(lambda x : True if (x['M18'] == 3 and x['S240']==1) else False, axis = 1)\n", + "bin1_3_1_total = len(bin1_3_1[bin1_3_1 == True].index)\n", + "bin1_3total = bin1_3_0_total + bin1_3_1_total\n", + "# calculating entropy of bin 3\n", + "entropy1_3 = entropy(bin1_3_0_total,bin1_3_1_total)\n", + "\n", + "# calculating total entropy of split 1\n", + "total = bin1_1total + bin1_2total + bin1_3total\n", + "total_entropy1 = (bin1_1total*entropy1_1 + bin1_2total*entropy1_2 + bin1_3total*entropy1_3)/total\n", + "\n", + "print('Split 1 BIN TABLE:')\n", + "print(bin1_1_0_total, bin1_1_1_total, bin1_1total)\n", + "print(bin1_2_0_total, bin1_2_1_total, bin1_2total)\n", + "print(bin1_3_0_total, bin1_3_1_total, bin1_3total)\n", + "print('Total Entropy:',total_entropy1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NvtXltfRZxk_", + "outputId": "d5fb0599-84c2-4b8b-aa2c-be11f7c3bc4a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Split 2 BIN TABLE:\n", + "25 2 27\n", + "31 2 33\n", + "86 11 97\n", + "Total Entropy: 0.47603328656035293\n" + ] + } + ], + "source": [ + "# Split 2: {1,2},{4,5},{3}\n", + "\n", + "# making bin 1\n", + "bin2_1_0= data.apply(lambda x : True if ((x['M18']==1 or x['M18']==2) and x['S240']==0) else False, axis = 1)\n", + "bin2_1_0_total = len(bin2_1_0[bin2_1_0 == True].index)\n", + "bin2_1_1= data.apply(lambda x : True if ((x['M18']==1 or x['M18']==2) and x['S240']==1) else False, axis = 1)\n", + "bin2_1_1_total = len(bin2_1_1[bin2_1_1 == True].index)\n", + "bin2_1total = bin2_1_0_total + bin2_1_1_total\n", + "# calculating entropy of bin 1\n", + "entropy2_1 = entropy(bin2_1_0_total,bin2_1_1_total)\n", + "\n", + "# making bin 2\n", + "bin2_2_0= data.apply(lambda x : True if ((x['M18'] == 4 or x['M18']==5) and x['S240']==0) else False, axis = 1)\n", + "bin2_2_0_total = len(bin2_2_0[bin2_2_0 == True].index)\n", + "bin2_2_1= data.apply(lambda x : True if ((x['M18'] == 2 or x['M18']==4) and x['S240']==1) else False, axis = 1)\n", + "bin2_2_1_total = len(bin2_2_1[bin1_2_1 == True].index)\n", + "bin2_2total = bin1_2_0_total + bin1_2_1_total\n", + "# calculating entropy of bin 2\n", + "entropy2_2 = entropy(bin2_2_0_total,bin2_2_1_total)\n", + "\n", + "# making bin 3\n", + "bin2_3_0= data.apply(lambda x : True if (x['M18'] == 3 and x['S240']==0) else False, axis = 1)\n", + "bin2_3_0_total = len(bin2_3_0[bin2_3_0 == True].index)\n", + "bin2_3_1= data.apply(lambda x : True if (x['M18'] == 3 and x['S240']==1) else False, axis = 1)\n", + "bin2_3_1_total = len(bin1_3_1[bin1_3_1 == True].index)\n", + "bin2_3total = bin2_3_0_total + bin2_3_1_total\n", + "# calculating entropy of bin 3\n", + "entropy2_3 = entropy(bin2_3_0_total,bin2_3_1_total)\n", + "\n", + "# calculating total entropy of split 2\n", + "total = bin2_1total + bin2_2total + bin2_3total\n", + "total_entropy2 = (bin2_1total*entropy2_1 + bin2_2total*entropy2_2 + bin2_3total*entropy2_3)/total\n", + "\n", + "print('Split 2 BIN TABLE:')\n", + "print(bin2_1_0_total, bin2_1_1_total, bin2_1total)\n", + "print(bin1_2_0_total, bin2_2_1_total, bin1_2total)\n", + "print(bin2_3_0_total, bin2_3_1_total, bin2_3total)\n", + "print('Total Entropy:',total_entropy2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kzg4GjWnaMri" + }, + "source": [ + "From the above Shannon Information analysis, it is evident that Split 1 contains more meaningful information." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WSE-3EVFcjT2" + }, + "source": [ + "# Data Visualization" + ] + }, + { + "cell_type": "markdown", + "source": [ + "The menstrual products used are represnted by the following numbers:\n", + "\n", + "1. Cloth\n", + "2. Local prep\n", + "3. Sanitary napkin\n", + "4. Tampon\n", + "5. Nothing\n", + "6. Other\n" + ], + "metadata": { + "id": "2xdKWrQpEj5P" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Birth Weights and Sizes" + ], + "metadata": { + "id": "LZPt-AcLE9SH" + } + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "wYoSobNudLit" + }, + "outputs": [], + "source": [ + "plotdata = pd.read_csv('/content/remove_smoke.csv')\n", + "plotdata = plotdata.reset_index(drop=True)\n", + "\n", + "# using data without smoke for birth weight and birh size versus the period product used" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Plot of the product used and the corresponding birth weights in the data" + ], + "metadata": { + "id": "H1byR1BrDCix" + } + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "DE21OHihebSx", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "outputId": "22983f81-ef56-40d2-aaab-ed0ed2647509" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 19 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD4CAYAAAAAczaOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2G0lEQVR4nO2de3hV9ZnvP+/OhSQk3MKdgFArSo0GSA7qOONUevF6hraPQ23PqPTxGTuVdnDUWvQcpo7MqHW0FTvqqHVa6NTbofXYRy3Wqj3tcLSYIAgtXlAuAbmZAAYDhCTv+WOvney9si9rJ2vt6/t5njzZ67d+67d+i8u7f+t939/3FVXFMAzDKA5C2Z6AYRiGkTnM6BuGYRQRZvQNwzCKCDP6hmEYRYQZfcMwjCKiNNsTSMbYsWN1+vTp2Z6GYRhGXtHS0vKhqo6Ldy6njf706dNpbm7O9jQMwzDyChHZkeicuXcMwzCKCDP6hmEYRYQZfcMwjCLCjL5hGEYRYUbfMAyjiPBk9EXkH0TkjyKyWUQeF5EKEZkhIn8Qka0i8qSIlDt9hznHW53z06PGudlpf1tELgjomQzDMIwEpDT6IjIF+HugSVXrgRLgcuB7wA9U9ZPAQeBq55KrgYNO+w+cfojIp5zrTgcuBB4QkRJ/Hyd77GzrZOFDr/LJW55n4UOvsrOtM9tTMgzDGIBX904pUCkipUAVsAeYD6x2zq8EvuB8XuAc45z/jIiI0/6Eqh5X1W3AVmDekJ8gR7hx9UbWbWunu1dZt62dG1dvzPaUDMMwBpDS6KvqbuBuYCdhY38YaAEOqWq3020XMMX5PAVoda7tdvrXRrfHuaYPEblGRJpFpPnAgQODeaassH7HwaTHhmEYuYAX985owqv0GcBkYDhh90wgqOrDqtqkqk3jxsXdRZyTzD1pdNJjwzCMXMCLe+ezwDZVPaCqJ4BfAOcCoxx3D0AdsNv5vBuYCuCcHwm0RbfHuSbvufuyBubNGENpSJg3Ywx3X9aQ7SkZhmEMwIv2zk7gbBGpAo4CnwGagVeAy4AngKuAZ5z+v3SOX3XOv6yqKiK/BB4Tke8TfmM4BVjn47NklWm1VTz19XOyPQ3DMIykpDT6qvoHEVkNrAe6gTeAh4HngCdE5J+dtkedSx4FfioiW4F2whk7qOofReQp4E/OOItVtcfn5zEMwzCSILlcGL2pqUlNZdMwDCM9RKRFVZvinbMduYZhGEWEGX3DMIwiwoy+YRhGEWFG3zAMo4gwo28YhlFEmNE3DMMoIszoG4ZhFBFm9A3DMIoIM/qGYRhFhBl9wzCMIsKMvmEYRhFhRt8wDKOIMKNvGIZRRJjRNwzDKCLM6BuGYRQRZvQNwzCKCDP6hmEYRURKoy8ip4rIhqifj0TkOhEZIyIvisi7zu/RTn8RkftEZKuIvCkic6PGusrp/66IXBXkgxmGYRgDSWn0VfVtVZ2tqrOBRqATeBpYCrykqqcALznHABcRLnp+CnAN8CCAiIwBvgucBcwDvhv5ojAMwzAyQ7runc8A76nqDmABsNJpXwl8wfm8AFilYV4DRonIJOAC4EVVbVfVg8CLwIVDfQDDGAytHa0sWrOIOavmsGjNIlo7WrM9JcPICOka/cuBx53PE1R1j/N5LzDB+TwFiP4ftMtpS9RuGBln2dpltOxroVu7adnXwrK1y7I9JcPICJ6NvoiUA38F/G/3OVVVQP2YkIhcIyLNItJ84MABP4Y0jAFs3L8x6bFhFCrprPQvAtar6j7neJ/jtsH5vd9p3w1MjbquzmlL1B6Dqj6sqk2q2jRu3Lg0pmcY3mkY35D02DAKlXSM/lfod+0A/BKIZOBcBTwT1X6lk8VzNnDYcQO9AHxeREY7AdzPO22GkXGWn7ucxgmNlEopjRMaWX7u8mxPyTAyQqmXTiIyHPgc8PWo5juBp0TkamAHsNBpfx64GNhKONPnawCq2i4iy4HXnX63qWr7kJ/AMAbB1Jqp/OTCn2R7GoaRcSTsjs9NmpqatLm5OdvTMAzDyCtEpEVVm+Kdsx25hmEYRYQZfcMwjCLCjL5hGEYRYUbfMAyjiDCjbxiGUUSY0TcMwygizOgbhmEUEWb0DcMwiggz+oZhGEWEGX3DMIwiwoy+YRhGEWFG3zAMo4gwo28YhlFEmNE3DMMoIszoG4ZhFBFm9A3DMIoIM/qGYRhFhBl9wzCMIsKT0ReRUSKyWkTeEpEtInKOiIwRkRdF5F3n92inr4jIfSKyVUTeFJG5UeNc5fR/V0SuSnxHwzAMIwi8rvRXAGtU9TSgAdgCLAVeUtVTgJecY4CLgFOcn2uABwFEZAzwXeAsYB7w3cgXhWEYhpEZUhp9ERkJnAc8CqCqXap6CFgArHS6rQS+4HxeAKzSMK8Bo0RkEnAB8KKqtqvqQeBF4EIfn8UwDMNIgZeV/gzgAPBjEXlDRH4kIsOBCaq6x+mzF5jgfJ4CtEZdv8tpS9Qeg4hcIyLNItJ84MCB9J7GMAzDSIoXo18KzAUeVNU5wMf0u3IAUFUF1I8JqerDqtqkqk3jxo3zY0jDMAzDwYvR3wXsUtU/OMerCX8J7HPcNji/9zvndwNTo66vc9oStRuGYRgZIqXRV9W9QKuInOo0fQb4E/BLIJKBcxXwjPP5l8CVThbP2cBhxw30AvB5ERntBHA/77QZhmEYGaLUY79vAT8TkXLgfeBrhL8wnhKRq4EdwEKn7/PAxcBWoNPpi6q2i8hy4HWn322q2u7LUxiGYRiekLA7PjdpamrS5ubmbE/DMAwjrxCRFlVtinfOduQahmEUEWb0DcMwiggz+oZhGEWEGX3DMIwiwoy+YRhGEeE1ZTOv2dnWyY2rN7J+x0HmnjSauy9rYFptVbanZRiGkXGKYqV/4+qNrNvWTnevsm5bOzeu3pjtKRmGYWSFojD663ccTHpsGIZRLBSF0Z970uikx4ZhGMVCURj9uy9rYN6MMZSGhHkzxnD3ZQ3ZnpJhGEZWKIpA7rTaKp76+jnZnoZhGEbWKYqVvmEYhhHGjL5hGEYRYUbfMAyjiDCjbxiGUUSY0TcMwygizOgbhmEUEZ6MvohsF5FNIrJBRJqdtjEi8qKIvOv8Hu20i4jcJyJbReRNEZkbNc5VTv93ReSqRPczDMMwgiGdlf75qjo7qgTXUuAlVT0FeMk5BrgIOMX5uQZ4EMJfEsB3gbOAecB3I18UQbOzrZOFD73KJ295noUPvcpr77XFHO9s68zENPylfRv8+GK4rTb8u31btmc0JFo7Wlm0ZhFzVs1h0ZpFtHa0pt3HyxiGUex4qpErItuBJlX9MKrtbeDTqrpHRCYBv1XVU0XkIefz49H9Ij+q+nWnPaZfPPyqkbvwoVdZt62/BntNRSkdx7r7jufNGJN/m7d+fDHsWNt/fNK58LXnszefIbJozSJa9rX0HTdOaOQnF/4krT5exjCMYsCPGrkK/FpEWkTkGqdtgqrucT7vBSY4n6cA0UusXU5bonb3ZK8RkWYRaT5w4IDH6SXHLbAWbfDjnc8LWv+Q/DjP2Lh/Y9JjL328jGEYxY5Xo//nqjqXsOtmsYicF31Sw68LqV8ZPKCqD6tqk6o2jRs3zo8hBwis1VSUJj2fF0w9K/lxntEwviHpMcBpY05LeuxlDMModjwZfVXd7fzeDzxN2Ce/z3Hr4Pze73TfDUyNurzOaUvUHjhuwbVHrmjKfwG2BfeHXTqh0vDvBfdne0ZDYvm5y2mc0EiplNI4oZHl5y4f2EmSH3sawzCKnJQ+fREZDoRUtcP5/CJwG/AZoE1V7xSRpcAYVb1JRC4BvglcTDhoe5+qznMCuS1AJJtnPdCoqu3ue0bwy6dvFAZzVs2hW/tdc6VSyhtXvpHFGRlGbpLMp+9FZXMC8LSIRPo/pqprROR14CkRuRrYASx0+j9P2OBvBTqBrwGoaruILAded/rdlszgD4agyyJa2cXs0jC+ISZQm677prWjlWVrl7Fx/0Yaxjew/NzlTK2ZmvpCwyggPGXvZIt0V/ruLB2/s3KCHt9IzlCNtmX3GMXCUFf6ecNgyiKms3q3sovZZWrN1CEZacvuMYwCk2EYTFnEdIqmW9nF/MayewyjwIz+YMoiprN6t7KL+Y1l9xhGgfn0B4P56Q3DKDT82JFbsNjq3TCMYqKgArnRQdnTJ49AgT/uPkxFWQkfd/X09assC3H0RC8Aw8tLOHqiBwHWbWvnohW/Y9qYKt7e10Fv1EtQSMJ7gXo0vKP3kSuamDyqMjdTONu3wTOLw9IMU88Kb9waMyPbs0pIJCtnw/4NVJZWcvTEUWaNnQUKb7W/Fd55K/BW21t8YtQnaP2olaM9RwGYOXom955/b18WjzvD59rZ1/LAhgdiMn4AbvrdTWz+cHPfHOpr67nrL++yFM4Mc/jAUV5etYW97x1m4skjmX/lLEaOq8z2tAqagnLvuF01QVJTUcqsSSNy0zWUZ2Js7lTKdIlOvXSPVV1WzZETR2L6AnHvZymcmefpe9bzwbuH+o4nnzKKL94wN/EFhieKNmUzSDqOdeduCmeeibENNXUy+nr3WNEGP9W9LIUz8+x973DSY8N/Csqnn8kUypqK0txN4cwzMbahpk5GX+8eq7qsekDfRPezFM7MM/HkkUmPDf8pKKMfHZRtqBvJmXUjKZGw3z6ayrL+xx5eXkJIoET6j2dNrCHkEvOK7hPx6edsEDjPxNgiqZQlUkJIBv6TrK+tp35sPaVSyszRM6ks6ff5zhw9Myb10p2WuWL+igFpmsvPXU792PoB97AUzswz/8pZTD5lFKGQMPmUUcy/cla2p1TwFJRP38h/TFTNMIZO0fj0I6SSVtjZ1sm3Hl/Pxl39/sOGupH88CtzcyP7pog5rfa0mKya8pJy5qyaYwJphuETBeXeiZBKWuHG1RtjDD7Axl2Hk0owGBnC9eLZ2d1Jt3bTsq+FZWuXZWdOhlFAFORK351F07LjIAsferVv5d+SIMumZXtm0j0DJ8/y9KN5q/2thOcGk12zbu86lry8hCMnjlBdVs2K+SuYN3HeUKZoGHlNQa703Vk0VeUlMSv/Kldgt6/fsAL5DnxmcThPv7c7/PuZxdmekWeSZdAMJrsmYvAhnL655OUlg56bYRQCBWn03Vk1ncdjC6F3Hu+moW5galhn1K7dvCbP8vSjic6+ic7aGaxAmjtP331sGMVGgSxtY5lWWxWzM9a9U7dxenjn7ID2XMmzHypTz4rdkZvjefrRJNPMb+1oZdGaRWkVUXHvyA1JyALDRlFTkCt9N4ny6XM2z36o5FmevleWrV1Gy76WtAK7K+av6NugFZIQvdprgWGjqPGcpy8iJUAzsFtVLxWRGcATQC3hgudXqGqXiAwDVgGNQBvwZVXd7oxxM3A10AP8vaq+kOyelqdvRDPUHH7bA2AUC37l6S8BtgAjnOPvAT9Q1SdE5N8JG/MHnd8HVfWTInK50+/LIvIp4HLgdGAy8BsRmamqQ3akv/ZeG1f9+A8c7078BXbqxBpCwJa9HX1tJ48dzt6PjsUocCYjJMQob7oJPNc/UVZOpH3na1A+HLo+hrJK6HLcGpMb4exvwHPXw/GPoLwaRk+HA2/BROftZs+G8LUnOvvb9m4MPPuntaOV6165jncOvpO0X2VJZYzBBujWbs5YeQYAgqBo3+8IgjB3wlyunX0t5SXldHd3x1y/aM0i5o6fyyObHulr/3bTt7ny9Cv9eLys0tXayp6bb6FzwwaqZs9m0h23Uz7V3FnFjqeVvojUASuBfwGuB/47cACYqKrdInIOcKuqXiAiLzifXxWRUmAvMA5YCqCqdzhj9vVLdF+vK/0zbn2BjmPdKftlgkCVNhOpZ7rb4yElMNjv1wBVOoeqsOkVt28/FZuu2hTgbDLDjr+5gs6o/z9VTU2c9J8/zeKMjEzhRxGVe4GbgF7nuBY4pNq39NoFTHE+TwFaAZzzh53+fe1xrome7DUi0iwizQcOHPA0uVwx+BCw0mairBwv2TlDeaHasTb8xdK+bfBjJCBTypbFmLXTuWFD0mOjOElp9EXkUmC/qga/HANU9WFVbVLVpnHjxnm6pqYid5KQAlXaTKSemYnsnIDy/TOlbOlW2ywGqmbPTnpsFCdeVvrnAn8lItsJB27nAyuAUY77BqAO2O183g1MBXDOjyQc0O1rj3PNkHjkiiaGlUrqjgHTUDcy2AygRFk5qbJzJjeG3TtuQqXhc5Hzw0bEtrkJIN8/aGVLQfrUNutr+5U1q0oTx12+3fTtQOeUKSbdcTtVTU1QWkpVUxOT7rg921MycoC0VDZF5NPAjU72zv8Gfh4VyH1TVR8QkcXAGar6d04g90uqulBETgceA+YRDuS+BJySLJCbTvZORGTt9W3tbvmWQZEqaOvuF5FbPvvkWh/uPggS+fWHjQgHZ0sr+gO7ESJfHO4gbfs2WH01fBDn5S7RNYOktaOVS5++lF7tjWlP1wcfTVVpFbNqZ/HGvjdAoFd7qSqtYnzVeLZ/tB0ISyl39XbFBJDrx9bz+CWPD/pZDCNXCKow+neA60VkK2Gf/aNO+6NArdN+Pf0B3D8CTwF/AtYAi/3I3IkQEVlLZqcry+LLL8TDi8GP7tdxrJurV77ueXzfibwFRK/Yh40IZ+v0dg80+BDrsmnfFv7iuK0WHjovvsF3X+MDy9YuG2DwASYPn8zM0TP7jmeOnsn0EdM9jTm+ajwt+1ropbdv7M7uzj6DD7C5bfPAjKHcVRk3DN9Iyxmuqr8Ffut8fp/wqt3d5xjw1wmu/xfCGUC+4yWAevREsDILXlM/A2HMjIEZNrd5eOuIuGwiej0Q/qLwco0PJArkvnPoHRonNMZk0ZzzmLesqGjjng7JxN4Mo1AoiB25O9s6qUwgolY0RK/UI5k2XgK8kZz8dAy5j4HjZIHcln0tzFk1h0VrFtHa0Rp4Bk63dnPOY+ewbu+6QO9jGNmkIIz+jas3Diltc9oYfzZTRZdhzDjxlDWjA7+JgrMRvBpyKfFV1iFVIDdaMiFeKcVEVJdVEyKU1jVgSpxG4VMQRn+oufE3fG5m6k4eOHqil4UPvcrOtk5fxosh3ko+mng5/BGXzzeboawivMPWTaQt8gWRChFfd+d6FTxr2dcS1/efiCMnjvDsl57l2S8+m/acijGnP1scPnCUp+9Zz4PXvsLT96zn8IGj2Z5SwVMQRt9LbnxJkozO65/a4Ntc4lXq8gX3Sv6h82INf6Icfve1biL9Il8QbsM/bET8/j4SVA79srXLBiWqVow5/dni5VVb+ODdQ/T2Kh+8e4iXV23J9pQKnoIw+hG1zETUVJTy/YWz42rohwR6fM7aCGRXrnslf/yj2CyaZMqaA/z1kliB0z3O5Y8Frti5Yv6KIY9RwsCYzsb9G9Pe8RuprmVkhr3vHU56bPhP7mxlHQJPNe+M0cV303GsmyVPboh7zmtqZjr0qPLae23+5exv+z30xskM2rEWbh34RcaOtXDf7CQDajhvv/FrA/Pxy6rCef2RcZ69Hg639r9hPPhn8NWnYMZfDOWJ+rhv/X0xYmeDpYeBfz5ugTYvHDlxhF9v/3VGSyrGE0YDhiyW9vG6dey6djG9R44Qqq6m7oH7GT4vt0pFTjx5JB+8eyjmOB6HDxzl5VVb2PveYSaePJL5V85i5LjKDM3SPw7t28sLD97LB+9sYfLMWVzwjesYNWHioPsNhrQ2Z2Uar5uzpi99LgOzSY+ailI23XqBP4PdMTV1GuVgGKwI27ARcHNr6n4eiKhk5hqZFFyLJ4wGDFks7e2m/0bvkagCMtXVnNqcxb0kcfBqzJ++Z33Ml8PkU0bxxRvmZnCm/vDkrUvZtWVz33HdrHq+fOudg+6XCL+klY008FUELgiDD4MXYQtqPkWKF2G0wYilRRv8eMdBkO6KfOS4Sk/G2+32+eDdQxw+cDTvVvsfvBMbs9i1ZTNP3rp0wEre3c99PBQKwqefi/gqAucOpmabXJtPnhNPGM0PsbRQdXXS4yAIKjAbz+2Tj0HfyTNnDWjbtWUzLzx4b9J+8a4bLAVh9L95/snZnsIAHrki7pvV4Lj8sbCvPROkuk9ZVXg+PiFkXygv28QTRvNDLK3ugfv7DH3Epx80QQVm51850OjlY9D3gm9cR92s+gHt7pV8pF+opIS6WfVc8I3rfJtDQbh3FjZN48drt2dXBsHFvo+O+TfYjL+A/7knebGUSKGTh+cP1M0pr47V3nEfRzN5Dpw4llhszediKqePPZ3NH25O3TGDhAjR2tGasaLp5VOnxvXXD7XgSdmkSVScdhqdGzZQcdpplE2aNKTxvOA1MJsuI8dVMvmUUYGMnQncgdmJJ89k73v92k/ulfyoCRPT8uGnQ0Gs9G9cvTGnDD74m/vfR6INVOXVyVMp3Qa+60j4mnhEvlQiaZrDRoQDvkEVWM/BPIJeeguiaPqem28JB4O7u+lsbmbPzbcEfs/5V85i8imjCIWEyaeMirtCz8Wxg+aFB+9l15bN9Pb09AVog1rJp6IgVvqBVqsaJH7n/gP9G6huq43daNV9rH+XbLxdt/HoOtK/cnePt3cj/GObf/NOQq6KnGWqoleQZKNyltfAbK6NHTRu983+7e/xD489k5W55P1KP1fF1kJBuarbtw30u/d2h/P1b58Sf9dtIna+Fv490SV65j5OJQExBE4bc5pvY/lJJip6dbW2suNvrmBL/Rns+Jsr6GpNngabbn+rnJVdDu3by5O3LuUHX11A6bBhMef8DMymS94b/aGKrQXFjNrhwQz8zOLEKZNuN06qSljlHucYT8zNL3IwjltVWhV4RS+A3dffEON+2X39DUn7p+uuscpZ2SXapdPV2Ul5VVVW3Dlu8t69k4uuHYAd7QGJriUK5LqRkoEbqNxunK6Pwyt3d9B2z4bwvZ5ZHJZwcL89+Kin/1Zb7rl3unq6fA3iRu+4rZgVXuEd27IFumP/XI9tTh7QTtddkyhAbAyOdHfJul063cePZ82lE03er/QDLUQ+BAKZVzor7HireLdYWvnw+F8i5cOTi7T5mD6aqcLo6eD3nKJX6Mc2beLYpk0DDD4AKXbHm7smu7iDse7cejdB5toPhZRGX0QqRGSdiGwUkT+KyD857TNE5A8islVEnhSRcqd9mHO81Tk/PWqsm532t0XEF42CQAuRDwHf59W+DXb8P+/9T8R503CLqcXrE7k22Wq+62Pv80hBJtwo6dA4odH3OXkNoFackVySwtw12SXdXbJB5toPhZTaOyIiwHBVPSIiZcB/AUsI17/9RVRh9I2q+qCIXAucGVUY/Yuq+mUR+RTwOP2F0X8DzBxqYfSdbZ2c96+veH7gTFE7vIyWZZ8f+kDt2+DHl0DH7qGP5SdXPeuL6NrCXy5ky8Hc21n5/Jee983Fs+2vF4ZX98kIhRj/nZs48uJv6HzjDWTYMLTT9aUsEv9tIBSiau5cRl3+Zfbe+k/0HjmCVFVRNnEiXe+/H9O1/NRTmfpvP0xbvC0Ru94+yHP3b6S7K36tg5Iy6DkxsL3vUYSEabslZULPif6TZcNKONHVQ2lZKOH9Rk2o4tJvNvguz3Bo315+uvTv6Yr6O5FQCO3tpbS8HCRE9/FjlFdV8ZmrF7PpN79K6AY6tG8vz624qy9Pv3TYMLqPHwdg7LQZ9HR3cfCD/v/vY6fNYMGN/zMtwbUhFUbXMJEIYZnzo8B8YLXTvhL4gvN5gXOMc/4zzhfHAuAJVT2uqtuArcSpsZsugWjX+0Dbx3H+pQ+GZxbnnsEHeOKrvgyTiwYfyHyefm8v+793V9gN1NMz0OBDYvdPby+dzc18cNN3+vR1tLNzgMEH6Hr7bV/z9X/1728mNMAQ3+BD1KMkWXNGG3yAE8d7QEl6v0P7OgORZ3jhwXtjDD6A9obn0d3VRffx8GbMrs5O1tx/T1I30AsP3huzMSti8AE+3LktxuBH2lK5ktLBk09fREpEZAOwH3gReA84pNqnXbsLmOJ8ngK0AjjnDwO10e1xrom+1zUi0iwizQcOHEg5t1wN5PqGj0FTXylw0TU/8/SPbfFohHq9VwYbyvV+5ut3Hc2tTZEQjDxDOoJn6vp78EM8LeOCa6rao6qzgTrCq/PAkqtV9WFVbVLVpnHjxqXsn6uBXN8IoFKVLxS46JqfwdyMBVxD3vIy/JxPeWXu7ZEJQp7BHYSVJH/W7nN+BHSzJrimqoeAV4BzgFEiEkn5rAMi7yS7gakAzvmRQFt0e5xrBk2uBnJrh5f5M9CC+6Gk3J+xfEN8E12bNTo3Mhrc+BnM7QvAhkJJDXPZjBnhfiUlSFWcDClJsKkhFKKqqYnJd32vT2BNqqoo/8QnBnQtP/VUXwPAF/3dmZSWJ36mkgT/DfoeJck+jZKy2JNlw0pASHq/UROqApFncAdlL1x8A+XO31FpeTmlwyoAKK+q4sLFNyQN4F7wjeuYeHJ/Xe7ojVtjp81g9ORYB8jYaTN8DQJ7CeSOA06o6iERqQR+DXwPuAr4eVQg901VfUBEFgNnRAVyv6SqC0XkdOAx+gO5LwGnDDWQC7lZRGX7nZf4N5g7v95NqDT8RrDg/n45Bvc1odKwtEKy/PtIv4kNA3P3I9cHwJxVcwZV5SooSqSEDVduCPw+8Spm+RVgzXUKpRKWmyArXqXDkAK5wCTgFRF5E3gdeFFVnwW+A1wvIlsJ++wfdfo/CtQ67dcDSwFU9Y/AU8CfgDXA4mQG34gilYsn3k7ZRIXSk+XfR8aKp7AZoJsp13L1K0szY3wim6dmbd7ESf/506Ix+FC4BdHTzeXPBl6yd95U1Tmqeqaq1qvqbU77+6o6T1U/qap/rarHnfZjzvEnnfPvR431L6p6sqqeqqq/Cu6xCoxE6ppuooO+iQqlxyuSLqn8shKMwqZDruXqf3zCv30IRnwKtSB6kBWv/CLvd+TmIiV+68mMmRE2uu7gqdtYR1bj0S6ciNsHwpIL7hX+SX8Gk2Ynv/9Jf9bvNgqIipKKQMfPZ9IVWss0hw8c5el71vPgta/w9D3rOXzgaMp+pcNiTU8+aeMnI1d34UZTEEa/3HcrOzS+v3C2/4O6hdbcRc2Hjeg37vEE0iJt/QP0vwHEc+dE3yfAVT6Ec+KP9fhYdGaIaI6J/GdDFz8dvLpqovt1He2hvLIkL7Xxk5Gru3CjyXvBNYCuQMTrB8+COQO2Hwwdt1vGHQ450dm/Gnf3jZfrHyqJqoKVZFuk9gS+yi8E7fogyYYufjp4ddW427uP9/KNB84PbF7ZIMiKV35RECv94Tmmp//MGwHsoHUHUt2unujz8YK47rbebrhjKtw6OnEqIIQrbAWkpR8hm4HceDV6Z46eGaenvyRy2cRrz3WhNbdrJpGrxms/I1gKwuhPG5OhouEeCbRUYiQwe/lj8QO18fouuD9+MPj4R0AvaIKdnMNGwKjpwWnpOyw/d3nWfPpuV07jhEbuPf/ewO+byGUTrz3Xhda8ljHM53KHhUTKPP1sks+Ca8sumcXVfzFwc8ygaN8Gq69O7ntPhIQSG/XB4pPYGsBz7z/H0t8v9WUsv6gpq+HJ//6k74XR+/Ly33gDelzuudJSZm3exJb6M2Jll0tKqPjUpwYItlWccQZTvn/PgDTPrtZWdl9/Q7i/CBX19XH7BUWq/Hu/8/PzLd8/U3n8Q83Tz2lyVXBt+XM+pmo9s3hwBh/8N/jgm9gawC3/lVtBSYCOEx2BCK71reLdBp9+l43bdROqrIyr0Hls06a4Ad09N9/S3181Yb+gSBXU9Ts/P9/y/XMhjz/vjX7BC65B7omu+Si21hvEl5IPBBFcThaAjbhs3K6c3qPx0x8Tjee1LShSBXX9zs/Pt3z/XMjjz3ujX/CCa5B7oms+iq2FJDf/CQYRXE4UgK1qaupzv7h36VbNmZPWeF7bgiJVsDbesdc8/8HcLxNEF0B/8talHNq3N2HfXMjjz83/cWlw92UN1FTkXuaprzsHFtwfv7C5p4n48FccLUtQXu2b2BrA7X+eW0HJCEHsEu5bxZeUhIXRSkpSBmYn3XF73IpaFWecEfe6mP4iCfsFRapgbbzzQ3HR5EJwOB2XTS7k8ed9IBdyM5g7b8YYnvr6Odm5ebwdualy7X98cezmrUjWT7rjDJLWjlYu/sXFgYw9GPysnJWIIAXX8knM7cFrX6G3t98OhUKSV/n7P/jqAnqj4jQSKmHKqbOyKrpW0IFcyL1g7rwZY7Ir+RxvR24qotM8h42Ana/BQ+cFnq4ZIeOVqlKQifkEudM213fxRpMLLpqh4HbRlFUMy3qwNhkFYfRzKZh76sQa7r6sgWm1Wdw74GVHrpsxM8I7dKeeFQ7Uas/AgO2OtYFt0ApyV268DVipyMQu4SB32ub6Lt5ocsFFMxTcLpsTx2IlRXJNdK0gjH4uBXPf3tvBJT/8PTvb4tQ4zRSJZJW9kOoLIqAVf7qBUy8B4JmjZ1JdVo2iVJdV8+gFj3r+AsjELmG/dtrm4y7eaEaOq+SLN8zlGw+czxdvmJvTefbxiEgv/MNjz/DlW+9kyqmfijmfa6JrBWH0c616Vsex7uy6nBLJKnvB/QURT3Y5gBTS5ecup3GCt2B1dVl1SuM9pXoKWw9u5ciJcKHwIyeOsOTlJZR7qEJWP7Y+I3LPfu20zcddvIVMLgRrk1EQgVyAM259gY5juVN9qTQkbL09dwKTnnEHgeNV2Drp3CixNn9ZtGYRLfvib0QrlVLeuPINT/0axjckPJ+IxgmN/OTCn6R1TS4wYBevs7vXKF4KPpAL8MgVTX2pm5VlJYQCVluuLEv+R5czLqf2bekJpkV8+//YFv490fUWVV7tu9Rya0cri9YsYs6qORzvOc7MUfEFz3q1l9krZ/OVZ79CR1dHwvG6tTuuwa8qraKqNHGsJV/VPnPRlTOU3HsjWFIafRGZKiKviMifROSPIrLEaR8jIi+KyLvO79FOu4jIfSKyVUTeFJG5UWNd5fR/V0Su8vNBzj65lk23XsD2Oy9hy/IL+e2N59NQl14WwGkTawbk/MeT6p81sYZQHGXK4eUllIQk+9k70QwmkycZY0/1PW1z2dpltOxroVu72fzhZmqG1cR19fTSSw89bG7bzDsH3+lrT2bIo6mrqaOuui7h+Vwr2+iVXHTl5Js8QjHhpTD6JGCSqq4XkRqgBfgCsAhoV9U7RWQpMFpVvyMiFwPfAi4GzgJWqOpZIjIGaAaaCIu3twCNqpow9car4Nr/+NFrtB7MnZWEAPd+eba/uvoRt8vO16CsErqODG6cUClc8X/g8ctjxyirgpF18OE7CS/tu97nAukNKxvoJTfkGCpKKrj/s/czb+K8wO+VT7n06ZJu7r1bOO2/XTqDV5/eyv7t4Te68dNr+PzV9YwcV5l3ImvZYEjuHVXdo6rrnc8dwBZgCrAAWOl0W0n4iwCnfZWGeQ0Y5XxxXEC4qHq7Y+hfBC4c/GOFuXH1xpwy+BD+RvNdXjmyYteewRt8CPvpn/jqwDFOdKY2+JHr/SaHCp8d6znGkpeXZORe+ZRLny7p5t673wx+9e9v9hl8gP3bO/reFuwtYmik5dMXkenAHOAPwARV3eOc2gtMcD5PAaKLeO5y2hK1u+9xjYg0i0jzgQMHUs4pl3L0o/G9mJcvGTNOgfOhCKYFUDox10TXIhk/QZNPufTpkm7uvVsorevoQCXSSJ98E1nLNTwbfRGpBn4OXKeqMVZDwz4iX8ycqj6sqk2q2jRu3LiU/XMmYOrC97K9fqywJ88N++MHK5h20rmByDBUl1X7PuZQyNR8cjEA6xfp5t673wTKKwemCkf65PsO3mzjyeiLSBlhg/8zVf2F07zPcdtE/P77nfbdQLRjss5pS9Q+JO6+rIGpo3PLnycEUBw9knsvJeEMmqFw+WMDxyirgrFJygRObgysQPqK+StyxvBXlFSwYv6KjNwrFwOw2cL9ZnDR353J+Ok1fefHT6/pe1vI9x282cZLIFcI++zbVfW6qPZ/BdqiArljVPUmEbkE+Cb9gdz7VHWeE8htASLZPOsJB3LbE907nTx9Iw631cbm2AcQhPWbOavm0K2J91tE5+onuiZeH8MoJoaap38ucAUwX0Q2OD8XA3cCnxORd4HPOscAzwPvA1uBR4BrARzjvhx43fm5LZnBT5edbZ1cdO/vmL70OaYvfY7T/3ENr72X2wYubdLNuR+KHEOWcKdNut8AKkormLNqDovWLKK1ozXuNZHj6Pz/6P6Gf1g+fv5RMDtyFz70Kuu2xX6H1FSUsunWC2LaXnuvjb/9aTMdx7qpqSjlkSuaOPvk2kHNz8+xPBFP/jjZztjBSCxnmdaOVpatXcaG/RuoLK2k80QnVWVVHO0+SmVpZUyQtbqsmmPdx/jEyE+w68guOrs7qS6rZsX8FcybOG/Art183XGbyzx9z3o+ePdQ3/HkU0bxxRvmJr7AyAhFsSM3XhZPx7FuPnnL8yx86NU+AbSIkY6c/9uf9n+p7GzrZOFDrw64JlF7srECIV31TPfu2hw3+ABTa6bykwt/wuzxszly4gi99HLkxBFmj5/Nse5Y9cIjJ47Qrd28c+gdOrs7+9oe2PAAMHCHbb7uuM1lLJMm/ygYo58oi6e7V1m3rb1PAM2tzxN9fOPqjazb1j7gmkTtycYKhLKq5McFRDyD7XXHbOTaRG4fwz8skyb/KBijf/dlDcyaWJPwfORNwC2zEH3sfluIHCdqTzZWIHR9nPy4gIhnsCNKnKVSmjTbJ3JtdP/GCY0ZUc4sNiyTJv8oGKM/rbaKX113HtvvvITtd17CvBljYs5H3gSihdkifnh3H/dxovZ/XlDfl49fIuHjQJl2dvLjAiKewY64fn75xV8yfcT0vr4zR8+kfmy9GfcskO9a+MVIwQRy3exs6+TG1RtZv+Mgc08a7amaVaJrErW7g8eB18XNw8BsEHgN0Fog1yhWkgVyC9boZ4JP3vI83VGiUnmroZ9neM3Lt/x9o1hJZvQDdkJnhp1tnXzz8fW8uSt55oAAZ9aN5OaLZnHL05t4/8OwTzwkMKN2ODvaO+Ou8Ft2HKSqvGRAoNatrpx1SYjoN4GyqrDPf9rZ/W8Eyd4U3Oc+fTP89o6MvFWs27uOb730rb4MnOkjpoPC9o7tfX1mjp7Jveffy9SaqQMKpETn5S9bu6wv6Du1ZirbPurfy9Ct3Zyx8gzqa+u56y/vYs/He1jy8hKOnDhCSEIIwuzxs/tcSYZRiBTESj9ejn4yaipKk2baRNw0XsYtERARzy6kQHHn8UeI5PMny/N3nxs2IlaYLcBqWec8do4nkbOIe8Zt3CNG2u3OEQRNIAnVOKGRt9vfjntfcwMZ+U7Br/TTVdpMlVqZKGsnHj0K2+/IEZdOorz9SHuyPH/3ObcSZwB1cSN4VbWMpGJGArqJzkdIZPAjfRPJPVg+v1HIFET2TrpulVSplYmydgYzVkZJJLMQaU8my+A+51biDFDCwavYWqo8e/f5kCT+590wviHhfS2f3yhkCsLo331ZA2d6KI0oQEPdSB65oolPjB3e1x4SOHnscEpdpQ7vvqyBeTPGUBKSuMa9oiwUk/KZdSJKnKHSsNGWkvBxRB0z+nx0e7xzlz+WuK/PrJi/Iqbk4fQR05leMz2mz8zRM1OmYrrTPG//89v7DHso6p96fW09y89dHqPuGZIQJVJiKZ9GwVMQPv14ZCqdMjqIHAkU//Arc7Pr289jEvnrk/U7rfY0UNjStoXKskqOdh+1gKxR1BRlymY6efrJ+rrPXf/ZmXz/N+/0HR870TMgayjwfP0CZrA5+PGwgKxRrBR8IDdCX4rl9naqhpXS2dVDo4esmoi2DtCnrRMx2u5z0SJriTJ7WnK0hGM+4FUkzUuwNVEf99vEtbOv5YEND6R8u8gGhVw83cgOBeHTjxAx0D0aztDpcQmkJSKRtk68cwNy9eOMV1U+sNSb4Q2vImlegq2J+ixbu4yWfS10azct+1pY8vKSmONla5elP/GAKOTi6UZ2KCijnyjFMlXqZSJtnXjn3AHdeAHkzuMBq20WMF5F0qL71Y+tp762nhJKqC6rThmQdb8BuFNGcylls5CLpxvZoaDcO3NPGh3X5ZIq9fLuyxpigrHHT/Sws62TabVV3H1ZQ1KffuR89H0bp49JfDMjIV6DuJA4V98L7h291WXVMYY/l1I2q2bPDq/0o44NYygUVCB3sD59GFq2z2DE3YyBZEogzXz6RqEzpOwdEfkP4FJgv6rWO21jgCeB6cB2YKGqHnSKqK8gXBS9E1ikquuda64C/pcz7D+r6spUEw9KcC2ekZ5/z29NPC3LBCWQls4bhGEUAkM1+ucBR4BVUUb/LqBdVe8UkaXAaFX9jlMw/VuEjf5ZwApVPcv5kmgGmgAFWoBGVU3qbPdq9BMJrlWWhbjzS2fy4P99j7f2dgAwvLyE8SMq2PZhfwGSM+tGUlFWErPSDwlEvgPOrBvJvzm59/G+MIDMrPS9SiunI6yWQ/LMqVb6gzXeX3nuK2z+cPOA9pmjZoLAOwffAaB+bD13nXeXfSEYec+Q8/RFZDrwbJTRfxv4tKruEZFJwG9V9VQRecj5/Hh0v8iPqn7daY/plwg/BNdKJKyPk4rffft8Lvnh7xPq8iQSYYsUa8mIrr7XwujpCKsFKKSWLqmM+mDdP2esPMPzHCy33ygEgsjTn6Cqe5zPe4EJzucpQGtUv11OW6L2eJO9BrgGYNq0aZ4m07I9sRKmF4MvhCtvHe3qSdgnVenEVG2+4LUwejrCagEKqaWDl1V8Jgqd51LmjmEEwZBTNjX8quBbNFhVH1bVJlVtGjdunKdrqoYl/u4qiZdI7yKSdpksyydZ6cRkKZ++kkwwzWs/r2NkGHfufLxc+cEWOq+v9V7GMpcydwwjCAZr9Pc5bh2c3/ud9t1A9PKszmlL1O4LnQlW6JVlIb6/cDanJSmYLsAPvzIXiBVYGx61werMupEDRNiixdnitQVCMsE0r/28jpFhvKziB1vo/K6/vIvGCY1xz80cPbPvc/3YehNbMwqewfr0/xVoiwrkjlHVm0TkEuCb9Ady71PVeU4gtwWY6wy5nnAgN2mFksH69JP51DNe19bwRCbSNa1mrlEsJPPpp1zpi8jjwKvAqSKyS0SuBu4EPici7wKfdY4BngfeB7YCjwDXAjjGfTnwuvNzWyqDnw7prLQztio30mKwq/hcu4dh5DoFtTnLMAzDGOJK3zAMwygczOgbhmEUEWb0DcMwiggz+oZhGEWEGX3DMIwioqD09CPsbOvkW44AmxIrmJbqulTCaa+919ZXMrGmopRHrmji7JNrA3wawzAM/yjIlf6Nqzey0TH4AG/uOpyyZGLkunXb2ulOUmYxukZux7Fu/vanllJqGEb+UJBGf7AiaF7E1NwqnIlUOQ3DMHKRgjT68QTPvIigeRFOc9fIdR8bhmHkMgVp9O++rIGGupFEBDajBdNSXZdKouGRK5r6DH3Ep28YhpEvmAyDYRhGgWEyDIZhGAZgRt8wDKOoMKNvGIZRRJjRNwzDKCLM6BuGYRQRZvQNwzCKiJxO2RSRA8CODN5yLPBhBu+Xaez58ptCfr5CfjbI/POdpKrj4p3IaaOfaUSkOVFuayFgz5ffFPLzFfKzQW49n7l3DMMwiggz+oZhGEWEGf1YHs72BALGni+/KeTnK+Rngxx6PvPpG4ZhFBG20jcMwygizOgbhmEUEWb0ARH5DxHZLyKbsz2XIBCRqSLyioj8SUT+KCJLsj0nvxCRChFZJyIbnWf7p2zPKQhEpERE3hCRZ7M9F78Rke0isklENohIwWmpi8goEVktIm+JyBYROSer8zGfPojIecARYJWq1md7Pn4jIpOASaq6XkRqgBbgC6r6pyxPbciIiADDVfWIiJQB/wUsUdXXsjw1XxGR64EmYISqXprt+fiJiGwHmlS1IDdnichK4Peq+iMRKQeqVPVQtuZjK31AVX8HtGd7HkGhqntUdb3zuQPYAkzJ7qz8QcMccQ7LnJ+CWsmISB1wCfCjbM/FSA8RGQmcBzwKoKpd2TT4YEa/6BCR6cAc4A9ZnopvOK6PDcB+4EVVLZhnc7gXuAnozfI8gkKBX4tIi4hck+3J+MwM4ADwY8c99yMRGZ7NCZnRLyJEpBr4OXCdqn6U7fn4har2qOpsoA6YJyIF46ITkUuB/araku25BMifq+pc4CJgseNuLRRKgbnAg6o6B/gYWJrNCZnRLxIcf/fPgZ+p6i+yPZ8gcF6bXwEuzPJU/ORc4K8cv/cTwHwR+c/sTslfVHW383s/8DQwL7sz8pVdwK6ot8/VhL8EsoYZ/SLACXY+CmxR1e9nez5+IiLjRGSU87kS+BzwVlYn5SOqerOq1qnqdOBy4GVV/ZssT8s3RGS4k1yA4/b4PFAwWXSquhdoFZFTnabPAFlNoCjN5s1zBRF5HPg0MFZEdgHfVdVHszsrXzkXuALY5Pi+AW5R1eezNyXfmASsFJESwouYp1S14NIaC5gJwNPhdQmlwGOquia7U/KdbwE/czJ33ge+ls3JWMqmYRhGEWHuHcMwjCLCjL5hGEYRYUbfMAyjiDCjbxiGUUSY0TcMwygizOgbhmEUEWb0DcMwioj/DyC+i/M+N3PJAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "data1 = plotdata\n", + "df1 = pd.DataFrame(data1)\n", + "\n", + "## creating a values array which will store either 0 or the weight of the child, if the value of S257A is 1\n", + "y_values = []\n", + "for i in range(len(df1['S257A'])):\n", + " y_values.append(df1['S257A'][i] * df1['M19'][i])\n", + "## creating another array of same size\n", + "x_values = range(len(y_values))\n", + "## store all the non zero values in y, because for these non zero values S257A will have value 1\n", + "y_nonzero = [y for y in y_values if y != 0]\n", + "## store 1 in x for all these values \n", + "x_nonzero = [1 for i in range(len(y_values)) if y_values[i] != 0]\n", + "## plot the curve \n", + "sns.stripplot(x=x_nonzero, y=y_nonzero, jitter=0.3)\n", + "\n", + "## same for others\n", + "\n", + "\n", + "\n", + "y_values1 = []\n", + "\n", + "for i in range(len(df1['S257B'])):\n", + " y_values1.append(df1['S257B'][i] * df1['M19'][i])\n", + "x_values1 = range(len(y_values1))\n", + "y_nonzero1 = [y for y in y_values1 if y != 0]\n", + "x_nonzero1 = [2 for i in range(len(y_values1)) if y_values1[i] != 0]\n", + "sns.stripplot(x=x_nonzero1, y=y_nonzero1, jitter=0.3)\n", + "\n", + "\n", + "y_values2 = []\n", + "\n", + "for i in range(len(df1['S257C'])):\n", + " y_values2.append(df1['S257C'][i] * df1['M19'][i])\n", + "x_values2 = range(len(y_values2))\n", + "y_nonzero2 = [y for y in y_values2 if y != 0]\n", + "x_nonzero2 = [3 for i in range(len(y_values2)) if y_values2[i] != 0]\n", + "sns.stripplot(x=x_nonzero2, y=y_nonzero2, jitter=0.3)\n", + "\n", + "\n", + "y_values3 = []\n", + "\n", + "for i in range(len(df1['S257D'])):\n", + " y_values3.append(df1['S257D'][i] * df1['M19'][i])\n", + "x_values3 = range(len(y_values3))\n", + "y_nonzero3 = [y for y in y_values3 if y != 0]\n", + "x_nonzero3 = [4 for i in range(len(y_values3)) if y_values3[i] != 0]\n", + "sns.stripplot(x=x_nonzero3, y=y_nonzero3, jitter=0.3)\n", + "\n", + "\n", + "y_values4 = []\n", + "\n", + "for i in range(len(df1['S257E'])):\n", + " y_values4.append(df1['S257E'][i] * df1['M19'][i])\n", + "x_values4 = range(len(y_values4))\n", + "y_nonzero4 = [y for y in y_values4 if y != 0]\n", + "x_nonzero4 = [5 for i in range(len(y_values4)) if y_values4[i] != 0]\n", + "sns.stripplot(x=x_nonzero4, y=y_nonzero4, jitter=0.3)\n", + "\n", + "\n", + "y_values5 = []\n", + "\n", + "for i in range(len(df1['S257X'])):\n", + " y_values5.append(df1['S257X'][i] * df1['M19'][i])\n", + "x_values5 = range(len(y_values5))\n", + "y_nonzero5 = [y for y in y_values5 if y != 0]\n", + "x_nonzero5 = [6 for i in range(len(y_values5)) if y_values5[i] != 0]\n", + "sns.stripplot(x=x_nonzero5, y=y_nonzero5, jitter=0.3)\n", + "\n", + "\n", + "\n", + "\n", + "## product and weight" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Plot of the product used and the corresponding birth size in the data" + ], + "metadata": { + "id": "xScufuL9DKk2" + } + }, + { + "cell_type": "code", + "source": [ + "data = plotdata\n", + "df1 = pd.DataFrame(data)\n", + "\n", + "arr =[]\n", + "\n", + "## overall we have 5 possible values for M18 1,2,3,4,5. So first store the count of occurence of each of them\n", + "\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257A'])):\n", + " y_values.append(df1['S257A'][i] * df1['M18'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + "\n", + "## Store the count for S257A in arr\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "\n", + "## Upto this point, arr will store the frequency of 1,2,3,4,5 in S257A\n", + "\n", + "\n", + "## similarly we will store the frequency for all the columns.\n", + "\n", + "#2nd \n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257B'])):\n", + " y_values.append(df1['S257B'][i] * df1['M18'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "\n", + "#3rd\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257C'])):\n", + " y_values.append(df1['S257C'][i] * df1['M18'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257D'])):\n", + " y_values.append(df1['S257D'][i] * df1['M18'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257E'])):\n", + " y_values.append(df1['S257E'][i] * df1['M18'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257X'])):\n", + " y_values.append(df1['S257X'][i] * df1['M18'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "\n", + "## In the end we will have an array of size 30 thats storing the count of 1,2,3,4,5 in all the columns \n", + "\n", + "\n", + "## after that its standard procedure to create a bar chart\n", + "arr_t =[]\n", + "arr_s=[]\n", + "for i in range(1,7):\n", + " for j in range(1,6):\n", + " arr_t.append(str(i))\n", + "\n", + "for i in range(1,7):\n", + " for j in range(1,6):\n", + " arr_s.append(str(j))\n", + "\n", + "# arr_s\n", + "data = pd.DataFrame({'type':arr_t,'size':arr_s,'count':arr\n", + " })\n", + "# calculate percentages\n", + "data['percent'] = data['count'] / data.groupby('type')['count'].transform('sum') * 100\n", + "\n", + "# create stacked bar chart\n", + "sns.set_style('whitegrid')\n", + "sns.barplot(x='type', y='percent', hue='size', data=data, palette='magma')\n", + "plt.title('Distribution of size by product used')\n", + "plt.xlabel('Type')\n", + "plt.ylabel('Percentage')\n", + "plt.show()\n", + "\n", + "#size and product" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "mvfmc3PYmZbv", + "outputId": "0a2abcd5-cca7-4536-d44b-353edb28147a" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Boxplot of the distribution of birth size and product used:" + ], + "metadata": { + "id": "KznONAAeDVQg" + } + }, + { + "cell_type": "code", + "source": [ + "data = plotdata\n", + "df = pd.DataFrame(data)\n", + "\n", + "y_values = []\n", + "for i in range(len(df['S257A'])):\n", + " if df['S257A'][i]==1:\n", + " y_values.append(df['M19'][i])\n", + "\n", + "y_values1 = []\n", + "for i in range(len(df['S257B'])):\n", + " if df['S257B'][i]==1:\n", + " y_values1.append(df['M19'][i])\n", + "\n", + "y_values2 = []\n", + "for i in range(len(df['S257C'])):\n", + " if df['S257C'][i]==1:\n", + " y_values2.append(df['M19'][i])\n", + "\n", + "y_values3 = []\n", + "for i in range(len(df['S257D'])):\n", + " if df['S257D'][i]==1:\n", + " y_values3.append(df['M19'][i])\n", + "\n", + "y_values4 = []\n", + "for i in range(len(df['S257E'])):\n", + " if df['S257E'][i]==1:\n", + " y_values4.append(df['M19'][i])\n", + "\n", + "y_values5 = []\n", + "for i in range(len(df['S257X'])):\n", + " if df['S257X'][i]==1:\n", + " y_values5.append(df['M19'][i]) \n", + "\n", + "NA = [73, 49, 53, 20, 20, 20, 20, 20, 20, 20, 20, 20]\n", + "HG = [73, 30, 60]\n", + "\n", + "df = pd.Series(y_values, name=\"1\").to_frame().join(pd.Series(y_values1, name=\"2\").to_frame().join(pd.Series(y_values2, name=\"3\").to_frame().join(pd.Series(y_values3, name=\"4\").to_frame().join(pd.Series(y_values4, name=\"5\").to_frame().join(pd.Series(y_values5, name=\"6\"))))))\n", + "sns.boxplot(data=df, width = 0.2) \n", + "\n", + "#size and product box plot\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 282 + }, + "id": "ukF-H146mgWm", + "outputId": "d9fd41ea-049d-4662-9671-18943ff17db3" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 22 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Termination in Pregancy and Complication in Abortion" + ], + "metadata": { + "id": "zXtWgXTuD4l_" + } + }, + { + "cell_type": "code", + "source": [ + "df1 = pd.read_csv('/content/terminated_preg.csv', low_memory=False)\n", + "# using abortion data for the next set of graphs" + ], + "metadata": { + "id": "x6Nx263uneoV" + }, + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Plot of the product used and the percentage distrubution of which month the pregnancy terminated was:" + ], + "metadata": { + "id": "9GO17yC1DnEJ" + } + }, + { + "cell_type": "code", + "source": [ + "data = df1\n", + "df1 = pd.DataFrame(data)\n", + "\n", + "## Similar to the approach used in the bar chart above\n", + "\n", + "arr =[]\n", + "\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "cnt6=0\n", + "cnt7=0\n", + "cnt8=0\n", + "cnt9=0\n", + "cnt10=0\n", + "cnt11=0\n", + "cnt12=0\n", + "\n", + "for i in range(len(df1['S257A'])):\n", + " y_values.append(df1['S257A'][i] * df1['V229'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + " if(y_values[i]==6):\n", + " cnt6+=1\n", + " if(y_values[i]==7):\n", + " cnt7+=1\n", + " if(y_values[i]==8):\n", + " cnt8+=1\n", + " if(y_values[i]==9):\n", + " cnt9+=1\n", + " if(y_values[i]==10):\n", + " cnt10+=1\n", + " if(y_values[i]==11):\n", + " cnt11+=1\n", + " if(y_values[i]==12):\n", + " cnt12+=1\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "arr.append(cnt6);\n", + "arr.append(cnt7);\n", + "arr.append(cnt8);\n", + "arr.append(cnt9);\n", + "arr.append(cnt10);\n", + "arr.append(cnt11);\n", + "arr.append(cnt12);\n", + "#2nd \n", + "\n", + "for i in range(len(df1['S257B'])):\n", + " y_values.append(df1['S257B'][i] * df1['V229'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + " if(y_values[i]==6):\n", + " cnt6+=1\n", + " if(y_values[i]==7):\n", + " cnt7+=1\n", + " if(y_values[i]==8):\n", + " cnt8+=1\n", + " if(y_values[i]==9):\n", + " cnt9+=1\n", + " if(y_values[i]==10):\n", + " cnt10+=1\n", + " if(y_values[i]==11):\n", + " cnt11+=1\n", + " if(y_values[i]==12):\n", + " cnt12+=1\n", + "\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "arr.append(cnt6);\n", + "arr.append(cnt7);\n", + "arr.append(cnt8);\n", + "arr.append(cnt9);\n", + "arr.append(cnt10);\n", + "arr.append(cnt11);\n", + "arr.append(cnt12);\n", + "\n", + "#3rd\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257C'])):\n", + " y_values.append(df1['S257C'][i] * df1['V229'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + " if(y_values[i]==6):\n", + " cnt6+=1\n", + " if(y_values[i]==7):\n", + " cnt7+=1\n", + " if(y_values[i]==8):\n", + " cnt8+=1\n", + " if(y_values[i]==9):\n", + " cnt9+=1\n", + " if(y_values[i]==10):\n", + " cnt10+=1\n", + " if(y_values[i]==11):\n", + " cnt11+=1\n", + " if(y_values[i]==12):\n", + " cnt12+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "arr.append(cnt6);\n", + "arr.append(cnt7);\n", + "arr.append(cnt8);\n", + "arr.append(cnt9);\n", + "arr.append(cnt10);\n", + "arr.append(cnt11);\n", + "arr.append(cnt12);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257D'])):\n", + " y_values.append(df1['S257D'][i] * df1['V229'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + " if(y_values[i]==6):\n", + " cnt6+=1\n", + " if(y_values[i]==7):\n", + " cnt7+=1\n", + " if(y_values[i]==8):\n", + " cnt8+=1\n", + " if(y_values[i]==9):\n", + " cnt9+=1\n", + " if(y_values[i]==10):\n", + " cnt10+=1\n", + " if(y_values[i]==11):\n", + " cnt11+=1\n", + " if(y_values[i]==12):\n", + " cnt12+=1\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "arr.append(cnt6);\n", + "arr.append(cnt7);\n", + "arr.append(cnt8);\n", + "arr.append(cnt9);\n", + "arr.append(cnt10);\n", + "arr.append(cnt11);\n", + "arr.append(cnt12);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257E'])):\n", + " y_values.append(df1['S257E'][i] * df1['V229'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + " if(y_values[i]==6):\n", + " cnt6+=1\n", + " if(y_values[i]==7):\n", + " cnt7+=1\n", + " if(y_values[i]==8):\n", + " cnt8+=1\n", + " if(y_values[i]==9):\n", + " cnt9+=1\n", + " if(y_values[i]==10):\n", + " cnt10+=1\n", + " if(y_values[i]==11):\n", + " cnt11+=1\n", + " if(y_values[i]==12):\n", + " cnt12+=1\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "arr.append(cnt6);\n", + "arr.append(cnt7);\n", + "arr.append(cnt8);\n", + "arr.append(cnt9);\n", + "arr.append(cnt10);\n", + "arr.append(cnt11);\n", + "arr.append(cnt12);\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257X'])):\n", + " y_values.append(df1['S257X'][i] * df1['V229'][i])\n", + "\n", + "for i in range(len(y_values)):\n", + " if(y_values[i]==1):\n", + " cnt1+=1\n", + " if(y_values[i]==2):\n", + " cnt2+=1\n", + " if(y_values[i]==3):\n", + " cnt3+=1\n", + " if(y_values[i]==4):\n", + " cnt4+=1\n", + " if(y_values[i]==5):\n", + " cnt5+=1\n", + " if(y_values[i]==6):\n", + " cnt6+=1\n", + " if(y_values[i]==7):\n", + " cnt7+=1\n", + " if(y_values[i]==8):\n", + " cnt8+=1\n", + " if(y_values[i]==9):\n", + " cnt9+=1\n", + " if(y_values[i]==10):\n", + " cnt10+=1\n", + " if(y_values[i]==11):\n", + " cnt11+=1\n", + " if(y_values[i]==12):\n", + " cnt12+=1\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "arr.append(cnt3);\n", + "arr.append(cnt4);\n", + "arr.append(cnt5);\n", + "arr.append(cnt6);\n", + "arr.append(cnt7);\n", + "arr.append(cnt8);\n", + "arr.append(cnt9);\n", + "arr.append(cnt10);\n", + "arr.append(cnt11);\n", + "arr.append(cnt12);\n", + "\n", + "\n", + "arr_t =[]\n", + "arr_s=[]\n", + "for i in range(1,7):\n", + " for j in range(1,13):\n", + " arr_t.append(str(i))\n", + "\n", + "for i in range(1,7):\n", + " for j in range(1,13):\n", + " arr_s.append(str(j))\n", + "\n", + "# len(arr)\n", + "# arr\n", + "\n", + "data = pd.DataFrame({'type':arr_t,'month':arr_s,'count':arr\n", + " })\n", + "# calculate percentages\n", + "data['percent'] = data['count'] / data.groupby('type')['count'].transform('sum') * 100\n", + "\n", + "# create stacked bar chart\n", + "sns.set_style('whitegrid')\n", + "sns.barplot(x='type', y='percent', hue='month', data=data, palette='magma')\n", + "plt.title('Distribution of month by product used')\n", + "plt.xlabel('Type')\n", + "plt.ylabel('Percentage')\n", + "plt.show()\n", + "\n", + "#prod and preg terminated\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "xUTij5MTqjno", + "outputId": "81c7a021-4c71-4fa2-fcb0-ad17bb604761" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "df2 = pd.read_csv('/content/abortion_complication.csv')\n", + "# using abortion data for the next set of graphs" + ], + "metadata": { + "id": "mUSriF3btVmk" + }, + "execution_count": 26, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Plot of the product used and distribution of whether or not there was a complication in pregnancy:" + ], + "metadata": { + "id": "nLzxkaV8EP3K" + } + }, + { + "cell_type": "code", + "source": [ + "data = df2\n", + "df1 = pd.DataFrame(data)\n", + "\n", + "## another stacked bar chart \n", + "\n", + "arr =[]\n", + "\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "\n", + "for i in range(len(df1['S257A'])):\n", + " if df1['S257A'][i]==1:\n", + " if df1['S240'][i]==1:\n", + " cnt1+=1\n", + " else:\n", + " cnt2+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "\n", + "#2nd \n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257B'])):\n", + " if df1['S257B'][i]==1:\n", + " if df1['S240'][i]==1:\n", + " cnt1+=1\n", + " else:\n", + " cnt2+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "\n", + "#3rd\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257C'])):\n", + " if df1['S257C'][i]==1:\n", + " if df1['S240'][i]==1:\n", + " cnt1+=1\n", + " else:\n", + " cnt2+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257D'])):\n", + " if df1['S257D'][i]==1:\n", + " if df1['S240'][i]==1:\n", + " cnt1+=1\n", + " else:\n", + " cnt2+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257E'])):\n", + " if df1['S257E'][i]==1:\n", + " if df1['S240'][i]==1:\n", + " cnt1+=1\n", + " else:\n", + " cnt2+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "#\n", + "y_values = []\n", + "cnt1=0\n", + "cnt2=0\n", + "cnt3=0\n", + "cnt4=0\n", + "cnt5=0\n", + "for i in range(len(df1['S257X'])):\n", + " if df1['S257X'][i]==1:\n", + " if df1['S240'][i]==1:\n", + " cnt1+=1\n", + " else:\n", + " cnt2+=1\n", + "\n", + "arr.append(cnt1);\n", + "arr.append(cnt2);\n", + "\n", + "\n", + "\n", + "arr_t =[]\n", + "arr_s=[]\n", + "for i in range(1,7):\n", + " for j in range(1,3):\n", + " arr_t.append(str(i))\n", + "\n", + "for i in range(1,7):\n", + " for j in range(1,3):\n", + " arr_s.append(str(j))\n", + "\n", + "# arr_s\n", + "data = pd.DataFrame({'type':arr_t,'comp':arr_s,'count':arr\n", + " })\n", + "# calculate percentages\n", + "data['percent'] = data['count'] / data.groupby('type')['count'].transform('sum') * 100\n", + "\n", + "# create stacked bar chart\n", + "sns.set_style('whitegrid')\n", + "sns.barplot(x='type', y='percent', hue='comp', data=data, palette='magma')\n", + "plt.title('Distribution of abortion comoplication by product used')\n", + "plt.xlabel('Type')\n", + "plt.ylabel('Percentage')\n", + "plt.show()\n", + "\n", + "#product and complication" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "bFKpewNrtoyZ", + "outputId": "13643235-37ad-4e56-8760-52640c4a982e" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file