notebooks/numpy_006.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "20ac73e2-9bfc-483b-94c5-ddf43c9d9260",
   "metadata": {},
   "source": [
    "# 6. Reduction Operations in NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33c5005b-5a2e-4a1d-9852-1f2dec3d171c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a88c2901-5893-45a2-9d6b-90c2365cec7d",
   "metadata": {},
   "source": [
    "For this part, we create a dummy dataset consisting of $200$ rows and $5$ columns by sampling from the uniform distribution  $\\mathcal{U}(-10, 10)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25a9b1cf-076d-4804-b567-b916fdcf16b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = np.random.uniform(-10, 10, (200, 5))\n",
    "print(dataset[:10]) # Print the first 10 rows of our dataset"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "78b2bbd0-b751-44d9-8558-ed6daf575c17",
   "metadata": {},
   "source": [
    "To compute the mean value, we can use the array method `arr.mean()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e399e38-dc34-40c7-829d-36fdc5a6e57c",
   "metadata": {},
   "outputs": [],
   "source": [
    "mean = np.mean(dataset) # or dataset.mean()\n",
    "print(mean)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2d64a7d1-98f8-44ce-8dd9-af9f787fe74a",
   "metadata": {},
   "source": [
    "Sometimes, we want to compute the mean for each column or row. We can do this by specifying which dimension we wish to compute the mean along."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0581e7eb-2d3f-4b9f-9f62-624e625781fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the mean along axis 1. This will take the mean over all columns for each row\n",
    "# resulting in an array of shape (200,)\n",
    "row_means = np.mean(dataset, axis=1) # or dataset.mean(axis=1)\n",
    "print(row_means.shape) # The mean for each row \n",
    "print(row_means[:10])  # Print the mean for the first 10 rows\n",
    "\n",
    "# Similarly, for computing the mean over all rows\n",
    "col_means = np.mean(dataset, axis=0) # or dataset.mean(axis=0)\n",
    "print(col_means.shape)\n",
    "print(col_means)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "35ec4943-d6bb-44e7-97a3-6169cecc06f0",
   "metadata": {},
   "source": [
    "There are similar functions for computing the sum, minimum, maximum and standard deviation of an array. We can also here specify over which axes we want to compute along."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "190b08ff-93f1-493a-8750-de855248fed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.sum(dataset, axis=0))      # The sum of each column (compute along row-dimension, axis 0)\n",
    "print(np.max(dataset))              # The largest value in the entire dataset\n",
    "print(np.min(dataset, axis=1)[:10]) # The smallest values for the 10 first rows (along the column dimension)\n",
    "print(np.std(dataset, axis=0))      # Standard deviation for each column"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5a635073-32c3-4ca7-820f-d30009057195",
   "metadata": {},
   "source": [
    "If we want to find the index of the smallest or largest value, we can use `np.argmin()` and `np.argmax()`, respectively. See the following example where we find the index (and value) of the smallest and largest value in the first column of `dataset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1981a4c2-8cd9-43af-8b23-89a94dd2009e",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_column = dataset[:, 0]      # Select only the first column\n",
    "\n",
    "min_idx = np.argmin(first_column) # Find the index of the smallest value\n",
    "min_val = first_column[min_idx]   # Get the value at index min_idx\n",
    "\n",
    "print(f\"The smallest value in the first column is {min_val:.4f} at index {min_idx}\")\n",
    "\n",
    "# Do the same with argmax\n",
    "max_idx = np.argmax(first_column) # Find the index of the smallest value\n",
    "max_val = first_column[max_idx]   # Get the value at index min_idx\n",
    "\n",
    "print(f\"The largest value in the first column is {max_val:.4f} at index {max_idx}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5d6ba52f-744b-4f10-be8a-46e08ef60182",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "### 1. Computing the Mean, Sum and Maximum\n",
    "\n",
    "You are given an array `A` in the code cell below. \n",
    "\n",
    "Compute\n",
    "1. The mean of all elements in `A` using `np.mean()`,\n",
    "2. The sum of each row, using `np.sum()`, and\n",
    "3. The largest value in each column using `np.max()`.\n",
    "\n",
    "Print the result to verify that it works as you intended. \n",
    "\n",
    "You need to use the `axis=` argument for 2. and 3.\n",
    "\n",
    "The output should be\n",
    "```\n",
    "5.0\n",
    "[ 6 15 24]\n",
    "[7 8 9]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edde4fe0-f032-47da-90f8-9bcd1fca755b",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 2, 3], \n",
    "              [4, 5, 6], \n",
    "              [7, 8, 9]])\n",
    "\n",
    "# Your code here\n",
    "total_mean = ...\n",
    "row_sums = ...\n",
    "column_maxes = ..."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ba141b57-92c5-4027-8ba7-984168cc481f",
   "metadata": {},
   "source": [
    "### 2. Standardize Each Column of a Dataset\n",
    "\n",
    "You are given a dataset of shape `(200, 5)` stored in the variable `X`. Think of this as 200 observations of 5 different measurements/variables.\n",
    "\n",
    "We now want to [standardize](https://en.wikipedia.org/wiki/Standard_score#Calculation) each column $X_i$ by applying the transform $\\hat{X}_i = \\frac{X_i - \\hat{\\mu}_i}{\\hat{\\sigma}_i}$ where $\\hat{\\mu}_i$ and $\\hat{\\sigma}_i$ are the empirical mean and standard deviation of column $i$, respectively.\n",
    "\n",
    "Compute the means and standard deviations for each column and standardize `X`. Store the standardized version of `X` in a new variable `X_hat`.\n",
    "\n",
    "Verify that the mean and standard deviation of each column of `X_hat` is close to 0 and 1, respectively.\n",
    "\n",
    "**Hints:**\n",
    "\n",
    "1. Compute the mean and standard deviations for each column by using `np.mean()` and `np.std()` with the argument `axis=0`.\n",
    "2. Taking advantage of broadcasting, all columns can be standardized simultaneously by simply writing `X_hat = (dataset - mean) / std`.\n",
    "3. Use `np.mean(X_hat, axis=0)` and `np.std(X_hat, axis=0)` to verify that each column now has mean $\\approx 0$ and standard deviation $\\approx 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d715a71-29a5-45a7-9acc-ae89f07d160c",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.random.uniform(-10, 10, (200, 5))\n",
    "\n",
    "# Your code here\n",
    "mean = ...\n",
    "std = ...\n",
    "X_hat = ..."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f5fdbc93-24eb-4d09-89a9-c5113e0cb3a4",
   "metadata": {},
   "source": [
    "### 3. Different Ways\n",
    "\n",
    "Below are three cases where two different expressions give the same result.\n",
    "\n",
    "Try to understand why they give (approximately) the same answers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7903db76-3025-41e4-b62a-2ab90a16cc2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.random.uniform(-10, 10, (200, 5))\n",
    "\n",
    "# Case 1\n",
    "print(X.sum(axis=0) / X.shape[0])\n",
    "print(X.mean(axis=0))\n",
    "\n",
    "# Case 2\n",
    "print(X.std())\n",
    "print(np.mean((X - X.mean())**2) ** 0.5)\n",
    "\n",
    "# Case 3\n",
    "print(X.sum())\n",
    "print((X.mean(0) * len(X)).sum())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b09f1161-30d7-47c6-8c55-86d2727fa20c",
   "metadata": {},
   "source": [
    "### 4. Count With Boolean Arrays\n",
    "\n",
    "You are given an array `X` with 100000 integers between 0 and 100 in the code cell below.\n",
    "\n",
    "1. Create a boolean array `ge_50_mask` with the expression `(X > 50)`. This will create an array of the same shape as `X` with `True` or `False` depending on the value in `X` is greater than 50 or not.\n",
    "2. Print the sum and mean of `ge_50_mask`.\n",
    "\n",
    "What does the sum and mean of `ge_50_mask` tell us? And why are they approximately, 50000 and 0.5, respectively?\n",
    "\n",
    "**Note:** When you do `np.sum()` or `arr.sum()` on a boolean array, NumPy will treat `False` as 0 and `True` as 1 and sum these. The same is true for mean and standard deviation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2607d68-b8cf-4bf1-baf3-970d7f8532c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.random.randint(0, 100, 100000)\n",
    "\n",
    "# Your code here\n",
    "ge_50_mask = ..."
   ]
  }
 ],
 "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}