1.4_week4_pt2_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises 04 - NumPy for array manipulation\n",
    "\n",
    "This week we will work with the `numpy` library for numerical manipulations.\n",
    "The reference guide for numpy can be found here: https://numpy.org/doc/stable/reference/generated/numpy.ones.html. It is\n",
    "quite huge, but the sections of main interests for us are in the \"routines\" (a synonym for \"functions\") section,\n",
    "in particular:\n",
    "    - Array creation routines\n",
    "    - Array manipulation routines\n",
    "    - Input and output\n",
    "    - Statistics\n",
    "\n",
    "Some exercises have been modified from https://www.machinelearningplus.com/python/101-numpy-exercises-python/. You can try more exercises there, if you like!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the NumPy library, using `np` as an alias\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Create a 1D array of numbers from 99 to 110 \n",
    "\n",
    "Desired output: ```#> array([99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110])```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your solution here\n",
    "np.arange(99,111)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Create a 3x3 numpy array of all False values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your solution here\n",
    "np.zeros((3,3),dtype=bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Replace all odd numbers in ```arr``` with -1\n",
    "\n",
    "Sample input: ```np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])```\n",
    "\n",
    "Desired output: ```#>  array([ 0, -1,  2, -1,  4, -1,  6, -1,  8, -1])```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, -1,  2, -1,  4, -1,  6, -1,  8, -1])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sample input\n",
    "arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "\n",
    "#getting the remainder of each num when divided by 2\n",
    "#arr % 2 #Output: array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])\n",
    "\n",
    "#converting the array into a boolean\n",
    "#arr % 2 == 1 #Output: array([False,  True, False,  True, False,  True, False,  True, False, True])\n",
    "\n",
    "# Write your solution here:\n",
    "arr[arr % 2 == 1] = -1\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4 Stack two arrays vertically\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider these two numpy arrays as input:\n",
    "\n",
    "```\n",
    "a = np.arange(10).reshape(2,-1)\n",
    "b = np.repeat(1, 10).reshape(2,-1)\n",
    "```\n",
    "\n",
    "```\n",
    "a = [[0 1 2 3 4]\n",
    " [5 6 7 8 9]]\n",
    " \n",
    "b = [[1 1 1 1 1]\n",
    " [1 1 1 1 1]]\n",
    "```\n",
    "\n",
    "Desired output:\n",
    "```\n",
    "c = [[0, 1, 2, 3, 4],\n",
    "     [5, 6, 7, 8, 9],\n",
    "     [1, 1, 1, 1, 1],\n",
    "     [1, 1, 1, 1, 1]])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10).reshape(2,-1)\n",
    "b = np.repeat(1, 10).reshape(2,-1)\n",
    "\n",
    "# Write your solution here\n",
    "np.vstack((a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises of data manipulation on the \"500_Person_Gender_Height_Weight_Index\" dataset.\n",
    "\n",
    "We will use a \"500_Person_Gender_Height_Weight_Index\" dataset containing information about height (in cm) and weights (in kg) for 500 subjects, classified by Gender. You can have a look at the dataset here in Kaggle: https://www.kaggle.com/yersever/500-person-gender-height-weight-bodymassindex\n",
    "You do not have to download it though. The CSV (comma separated values) file \n",
    "can be found in the \"datasets\" directory: \n",
    "\n",
    "We are not going to use the Body Mass Index (BMI) information provided in the dataset. \n",
    "We will compute the BMI later on using Numpy.\n",
    "\n",
    "Let's import the \"500_Person_Gender_Height_Weight_Index\" dataset. You can import the dataset keeping the text column intact, passing `dtype`='object' as argument. In this case, though all the numeric values will be stored as bytes. We will have to set the `names` argument to `True` as the first line of the file (the \"header\") contains the column names. \n",
    "\n",
    "Read more details about the textual data importing functions of Numpy here: \n",
    "- `np.loadtxt()`: https://docs.scipy.org/doc/numpy-1.16.1/reference/generated/numpy.loadtxt.html#numpy.loadtxt\n",
    "- `np.genfromtxt()`: https://docs.scipy.org/doc/numpy-1.16.1/reference/generated/numpy.genfromtxt.html#numpy.genfromtxt\n",
    "\n",
    "You can see all the arguments you can supply to the functions. All the arguments that have a default value are\n",
    "optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pip install kagglehub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\hussainsarfraz\\anaconda3\\envs\\oxford_course\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import kagglehub, os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Installing the 500 person height data using the kaggle API. [link to dataset](https://www.kaggle.com/datasets/yersever/500-person-gender-height-weight-bodymassindex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: Looks like you're using an outdated `kagglehub` version, please consider updating (latest version: 0.3.3)\n"
     ]
    }
   ],
   "source": [
    "# Download latest version\n",
    "path = kagglehub.dataset_download(\"yersever/500-person-gender-height-weight-bodymassindex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\hussainsarfraz\\\\.cache\\\\kagglehub\\\\datasets\\\\yersever\\\\500-person-gender-height-weight-bodymassindex\\\\versions\\\\2'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([(b'Male', b'174', b'96', b'4'), (b'Male', b'189', b'87', b'2'),\n",
       "       (b'Female', b'185', b'110', b'4'),\n",
       "       (b'Female', b'195', b'104', b'3'), (b'Male', b'149', b'61', b'3'),\n",
       "       (b'Male', b'189', b'104', b'3'), (b'Male', b'147', b'92', b'5'),\n",
       "       (b'Male', b'154', b'111', b'5'), (b'Male', b'174', b'90', b'3'),\n",
       "       (b'Female', b'169', b'103', b'4'), (b'Male', b'195', b'81', b'2'),\n",
       "       (b'Female', b'159', b'80', b'4'),\n",
       "       (b'Female', b'192', b'101', b'3'), (b'Male', b'155', b'51', b'2'),\n",
       "       (b'Male', b'191', b'79', b'2'), (b'Female', b'153', b'107', b'5'),\n",
       "       (b'Female', b'157', b'110', b'5'), (b'Male', b'140', b'129', b'5'),\n",
       "       (b'Male', b'144', b'145', b'5'), (b'Male', b'172', b'139', b'5')],\n",
       "      dtype=[('Gender', 'O'), ('Height', 'O'), ('Weight', 'O'), ('Index', 'O')])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import `height-weight` keeping the text column intact.\n",
    "localfilepath = os.path.join(path, \"500_Person_Gender_Height_Weight_Index.csv\" )\n",
    "hw_dataset = np.genfromtxt(localfilepath, delimiter=',', names=True, dtype='object')\n",
    "hw_dataset[:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. How to convert a 1d array of tuples to a 2d numpy array\n",
    "\n",
    "Convert the `hw_dataset` to a numeric-only 2D array `hw_data` by omitting the \"Gender\" text column and the \"Index\" numeric field. Create a `hw_label` 1D array containing only the \"Gender\" text field. Keep the same indexing/order as in the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Male' 'Male' 'Female' 'Female' 'Male'] \n",
      " [[174.  96.]\n",
      " [189.  87.]\n",
      " [185. 110.]\n",
      " [195. 104.]\n",
      " [149.  61.]]\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here\n",
    "\n",
    "#each item, in the dataset, is a void type, not tuple\n",
    "type(hw_dataset[0]) #Output: numpy.void\n",
    "type(tuple(hw_dataset[0])) #Output: tuple\n",
    "\n",
    "#converting each item to a list & specifying datatype\n",
    "hw_dataset = [list(row) for row in hw_dataset]\n",
    "\n",
    "hw_label = np.array([row[0] for row in hw_dataset], dtype=str)\n",
    "hw_data = np.array([row[1:3] for row in hw_dataset], dtype=float)\n",
    "\n",
    "print(hw_label[0:5], '\\n', hw_data[0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Split the datasets in two groups\n",
    "\n",
    "Split the dataset in `hw_data` according to the labels in `hw_labels`. Hint: You can create a dictionary with the two different labels (\"Male\" and \"Female\") as keys, and the two split datasets as values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dictionary Keys:  dict_keys([np.str_('Female'), np.str_('Male')])\n",
      "First 5 rows of values in female key:  [[185. 110.]\n",
      " [195. 104.]\n",
      " [169. 103.]\n",
      " [159.  80.]\n",
      " [192. 101.]]\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here\n",
    "\n",
    "hw_by_label = {\n",
    "    label: hw_data[hw_label == label] for label in set(hw_label)\n",
    "}\n",
    "\n",
    "print('Dictionary Keys: ',hw_by_label.keys())\n",
    "print('First 5 rows of values in female key: ', hw_by_label['Female'][0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Compute the monovariate statistics for each group\n",
    "\n",
    "For each label compute the key statistics for both weight and height. \n",
    "- mean\n",
    "- median\n",
    "- standard deviation\n",
    "- variance\n",
    "- interquartile range\n",
    "\n",
    "Read carefully the numpy documentation for the statistics routines.\n",
    "Answer to the following questions:\n",
    "\n",
    "1) Which is the gender with the highest mean value for `height`?\n",
    "\n",
    "2) Which is the gender with the smallest median value for `weight`?\n",
    "\n",
    "3) Which is the gender with the shortest interquartile range for `weight`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---Summary Statistics--- \n",
      " {np.str_('Female'): {'mean': array([170.22745098, 105.69803922]), 'median': array([170., 106.]), 'quantiles': array([[157.,  79.],\n",
      "       [170., 106.],\n",
      "       [184., 135.]]), 'std': array([15.68098734, 32.89732983]), 'var': array([ 245.89336409, 1082.23430988])}, np.str_('Male'): {'mean': array([169.64897959, 106.31428571]), 'median': array([171., 105.]), 'quantiles': array([[154.,  80.],\n",
      "       [171., 105.],\n",
      "       [183., 137.]]), 'std': array([17.0308019 , 31.76770276]), 'var': array([ 290.04821324, 1009.18693878])}} \n",
      "\n",
      "---Male Interquartile Range--- \n",
      " [[154.  80.]\n",
      " [171. 105.]\n",
      " [183. 137.]] \n",
      " ------ \n",
      " [183. 137.] \n",
      " ---The highest value of the interquartile range--- \n",
      " 137.0 \n",
      "\n",
      "Male IQR for weight: 57.0\n",
      "Female IQR for weight: 56.0\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here\n",
    "summary_statistics ={}\n",
    "\n",
    "for gender, dataset in hw_by_label.items():\n",
    "    \n",
    "    summary_statistics[gender] = {\n",
    "        'mean': np.mean(dataset, axis=0),\n",
    "        'median': np.median(dataset, axis=0),\n",
    "        'quantiles': np.quantile(dataset, [0.25, 0.5, 0.75], axis=0),\n",
    "        'std': np.std(dataset, axis=0),\n",
    "        'var': np.var(dataset, axis=0)\n",
    "   }\n",
    "    \n",
    "print('---Summary Statistics---','\\n', summary_statistics,'\\n')\n",
    "\n",
    "# male interquartile range for weight\n",
    "print('---Male Interquartile Range---','\\n',summary_statistics['Male']['quantiles'],'\\n','------', '\\n',\n",
    "      summary_statistics['Male']['quantiles'][2],'\\n','---The highest value of the interquartile range---', '\\n',\n",
    "      summary_statistics['Male']['quantiles'][2][1],'\\n')\n",
    "\n",
    "#calculating the interquartile range\n",
    "male_iqr_w = summary_statistics['Male']['quantiles'][2][1] - summary_statistics['Male']['quantiles'][0][1]\n",
    "female_iqr_w = summary_statistics['Female']['quantiles'][2][1] - summary_statistics['Female']['quantiles'][0][1]\n",
    "print(\"Male IQR for weight: {}\".format(male_iqr_w))\n",
    "print(\"Female IQR for weight: {}\".format(female_iqr_w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Compute the covarance and correlation matrix for each group\n",
    "\n",
    "1) Compute the `height`-`weight` covariance matrix for each gender. Are the values on the diagonal matching the values computed with the variance functions in the previous step? If not, can you understand why, and how you can obtain coherent values?\n",
    "\n",
    "2) Compute the `height`-`weight` correlation matrix for each gender."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{np.str_('Female'): {'cov': array([[ 245.89336409,   14.22162245],\n",
      "       [  14.22162245, 1082.23430988]])}, np.str_('Male'): {'cov': array([[ 290.04821324,  -14.13865889],\n",
      "       [ -14.13865889, 1009.18693878]])}}\n"
     ]
    }
   ],
   "source": [
    "# Compute the covariance matrix here:\n",
    "# Delta Degrees of Freedom (DDOF) is by default == 0 in np.var while it is == 1 for np.cov\n",
    "cov_mat = {\n",
    "    label: dict(cov=np.cov(dataset.T, ddof=0)) for label, dataset in hw_by_label.items()\n",
    "}\n",
    "print(cov_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{np.str_('Female'): {'cov': array([[1.        , 0.02756862],\n",
      "       [0.02756862, 1.        ]])}, np.str_('Male'): {'cov': array([[ 1.        , -0.02613288],\n",
      "       [-0.02613288,  1.        ]])}}\n"
     ]
    }
   ],
   "source": [
    "# Compute the correlation matrix here\n",
    "\n",
    "# Compute the correlation matrix here\n",
    "cor_mat = {\n",
    "    label: dict(cov=np.corrcoef(dataset.T)) for label, dataset in hw_by_label.items()\n",
    "}\n",
    "print(cor_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. How to create a new column from existing columns of a numpy array\n",
    "\n",
    "Create a new column for \"Mass-body Index\" (\"MBI\")  in `hw_data`, where MBI is:\n",
    "\n",
    "$$MBI =  \\frac{weight [kg]}{(height [m])^2}$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[174.        ,  96.        ,  31.70828379],\n",
       "       [189.        ,  87.        ,  24.35542118],\n",
       "       [185.        , 110.        ,  32.14024836],\n",
       "       ...,\n",
       "       [141.        , 136.        ,  68.40702178],\n",
       "       [150.        ,  95.        ,  42.22222222],\n",
       "       [173.        , 131.        ,  43.77025627]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute MBI here:\n",
    "\n",
    "# (remeber to convert the weights in kg!!)\n",
    "mbi = hw_data[:, 1] / (hw_data[:, 0]/100)**2\n",
    "\n",
    "# Introduce new dimension to match hw_data 2-dimensions\n",
    "mbi = mbi[:,np.newaxis]\n",
    "hw_data = np.hstack((hw_data, mbi))\n",
    "hw_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Convert a quantitative variable to a categorical one\n",
    "\n",
    "Now create an array `hw_mbi_labels` where you assign each record in `hw_data` to one of these categories: \n",
    "    - 'UNDERWEIGHT': MBI < 18.5\n",
    "    - 'NORMAL': 18.5 =< MBI < 25 \n",
    "    - 'OVERWEIGHT': 25 =< MBI < 30\n",
    "    - 'OBESE': MBI >= 30\n",
    "    \n",
    "Then, count the number of occurrences of each category per gender."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['NORMAL' 'OBESE' 'OVERWEIGHT' 'UNDERWEIGHT'] [ 38 167  37  13]\n",
      "['NORMAL' 'OBESE' 'OVERWEIGHT' 'UNDERWEIGHT'] [ 28 165  31  21]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{np.str_('Female'): {np.str_('NORMAL'): np.int64(38),\n",
       "  np.str_('OBESE'): np.int64(167),\n",
       "  np.str_('OVERWEIGHT'): np.int64(37),\n",
       "  np.str_('UNDERWEIGHT'): np.int64(13)},\n",
       " np.str_('Male'): {np.str_('NORMAL'): np.int64(28),\n",
       "  np.str_('OBESE'): np.int64(165),\n",
       "  np.str_('OVERWEIGHT'): np.int64(31),\n",
       "  np.str_('UNDERWEIGHT'): np.int64(21)}}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Label the record here\n",
    "# Hint: write a function to assign labels to the record then use the numpy appropriate function \n",
    "# to apply the function to each row\n",
    "\n",
    "def assign_label(row):\n",
    "    bmi = row[-1]\n",
    "    if bmi < 18.5:\n",
    "        return 'UNDERWEIGHT'\n",
    "    if bmi >= 18.5 and bmi < 25.0:\n",
    "        return 'NORMAL'\n",
    "    if bmi >= 25.0 and bmi < 30.0:\n",
    "        return 'OVERWEIGHT'\n",
    "    if bmi >= 30.0:\n",
    "        return 'OBESE'\n",
    "\n",
    "#creating a array of categorized weights based on bmi/mbi\n",
    "hw_bmi_labels = np.array([assign_label(row) for row in hw_data])\n",
    "#print(hw_bmi_labels[0:5])\n",
    "\n",
    "#creating a dictionary which categorizes the bmi by gender\n",
    "mbi_labels_by_gender = {\n",
    "    gender: hw_bmi_labels[hw_label == gender] for gender in set(hw_label)\n",
    "}\n",
    "#print(mbi_labels_by_gender)\n",
    "\n",
    "#creating the count dictionary that keeps count of the occurances for each category\n",
    "cts = {}\n",
    "for gender in set(hw_label):\n",
    "    unique, counts = np.unique(mbi_labels_by_gender[gender], return_counts=True)\n",
    "    print(unique, counts)\n",
    "    cts[gender] = dict(zip(unique, counts))\n",
    "cts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. Compute the frequencies of each category within genders\n",
    "\n",
    "Compute the percentages of the four categories ('UNDERWEIGHT', 'NORMAL', 'OVERWEIGHT', 'OBESE'), and anwer these questions:\n",
    "\n",
    "- Which gender has the highest percentage of 'OBESE' subjects\n",
    "- Which gender has the highest petcentahe of 'subjects that are neither 'OVERWEIGHT' nor 'OBESE'?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total count for Gender Female is 255\n",
      "Total count for Gender Male is 245\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{np.str_('Female'): {np.str_('NORMAL'): np.float64(14.901960784313726),\n",
       "  np.str_('OBESE'): np.float64(65.49019607843137),\n",
       "  np.str_('OVERWEIGHT'): np.float64(14.50980392156863),\n",
       "  np.str_('UNDERWEIGHT'): np.float64(5.098039215686274)},\n",
       " np.str_('Male'): {np.str_('NORMAL'): np.float64(11.428571428571429),\n",
       "  np.str_('OBESE'): np.float64(67.3469387755102),\n",
       "  np.str_('OVERWEIGHT'): np.float64(12.653061224489795),\n",
       "  np.str_('UNDERWEIGHT'): np.float64(8.571428571428571)}}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute the percentages here:\n",
    "\n",
    "prc_cts = {}\n",
    "for gender, counts in cts.items():\n",
    "    total_count = sum(cts[gender].values())\n",
    "    print('Total count for Gender {} is {}'.format(gender, total_count))\n",
    "    prc_cts[gender] = {\n",
    "        label: (count/total_count)*100 for label, count in cts[gender].items() \n",
    "    }\n",
    "prc_cts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. Normalize an array so the values range exactly between 0 and 1\n",
    "\n",
    "Normalization is an important pre-processing step before feeding a dataset to a data science (e.g a machine learning) algorithm.\n",
    "Create a normalized form of `hw_data`'s \"height\" and \"weight\" whose values range exactly between 0 and 1 so that the minimum has value 0 and maximum has value 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max weight: 160.0 - Min weight: 50.0 - Max height: 199.0 - Min height: 140.0\n",
      "[0.57627119 0.83050847 0.76271186 0.93220339 0.15254237]\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here \n",
    "\n",
    "h_min, h_max = hw_data[:, 0].min(), hw_data[:, 0].max()\n",
    "w_min, w_max = hw_data[:, 1].min(), hw_data[:, 1].max()\n",
    "\n",
    "print('Max weight: {} - Min weight: {} - Max height: {} - Min height: {}'.format(\n",
    "   w_max, w_min, h_max, h_min\n",
    "))\n",
    "\n",
    "normalized_h = (hw_data[:, 0] - h_min)/(h_max - h_min)\n",
    "normalized_w = (hw_data[:, 1] - w_min)/(w_max - w_min)\n",
    "print(normalized_h[0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will be able to find more exercises on numpy here: https://www.machinelearningplus.com/python/101-numpy-exercises-python/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}