Data-Science-from-Scratch_Chapter4_Linear-Algebra_Joel-Grus.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bd32b3b0",
   "metadata": {},
   "source": [
    "# Linear Algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c926795",
   "metadata": {},
   "source": [
    "## Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a70968cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial, reduce\n",
    "\n",
    "height_weight_age = [70,   # inches\n",
    "                    170,   # kilos\n",
    "                    40]    # years\n",
    "\n",
    "grades = [95,   # test1\n",
    "         80,    # test2\n",
    "         75,    # test3\n",
    "         62]    # test4\n",
    "\n",
    "def vector_add(v, w):\n",
    "    \"\"\"sum of corresponding elements\"\"\"\n",
    "    return [v_i + w_i for v_i, w_i in zip(v, w)]\n",
    "\n",
    "def vector_subtract(v, w):\n",
    "    \"\"\"subtract of corresponding elements\"\"\"\n",
    "    return [v_i - w_i for v_i, w_i in zip(v, w)]\n",
    "\n",
    "# Sum of a list o vectors, which the first element of the new vector is the sum of all first elements, \n",
    "# the second element is the sum of all second elements, and so on. The best way to do this is adding \n",
    "# one vector of a time\n",
    "\n",
    "def vector_sum(vectors):\n",
    "    \"\"\"sum of all corresponding elements\"\"\"\n",
    "    result = vectors[0]                             # starts with the first vector\n",
    "    for vector in vectors[1:]:                      # then pass through all other vectors\n",
    "        result = vector_add(result, vector)         # and add them to the result\n",
    "    \n",
    "    return result\n",
    "\n",
    "# We are just 'reducing' the list of vectors using vector_add, what means we can rewrite the function above in a \n",
    "# reduced form using high order functions\n",
    "\n",
    "def vector_sum(vectors):\n",
    "    return reduce(vector_add, vectors)\n",
    "\n",
    "# or even\n",
    "vector_sum = partial(reduce, vector_add)\n",
    "\n",
    "#####\n",
    "\n",
    "# Multiplying by a scalar\n",
    "def scalar_multiply(c, v):\n",
    "    \"\"\" c is a number, v is a vector\"\"\"\n",
    "    return [c * v_i for v_i in v]\n",
    "\n",
    "# The multiplication by a scalar allows us to compute the mean of a list of vectors (of same size)\n",
    "def vector_mean(vectors):\n",
    "    \"\"\"compute the vector which n^th element be the mean of the n^ths elements of the included vectors\"\"\"\n",
    "    n = len(vectors)\n",
    "    return scalar_multiply(1/n, vector_sum(vectors))\n",
    "\n",
    "# Scalar product (dot product). It is the sum of the vector's products element by element.\n",
    "def dot(v, w):\n",
    "    \"\"\"v_1 * w_1 + ... + v_n * w_n\"\"\"\n",
    "    return sum(v_i * w_i for v_i, w_i in zip(v, w))\n",
    "\n",
    "# The scalar product measures the distance which the vector 'v' extends towards 'w'. In other words, it's \n",
    "# the size of the vector if you project 'v' in 'w'\n",
    "\n",
    "# Sum of squares of a vector\n",
    "def sum_of_squares(v):\n",
    "    \"\"\"v_1 * v_1 + ... + v_n * v_n\"\"\"\n",
    "    return dot(v, v)\n",
    "\n",
    "# We can use the functiona above to compute the magnitude (or size) of a vector\n",
    "import math\n",
    "\n",
    "def magnitude(v):\n",
    "    return math.sqrt(sum_of_squares(v))\n",
    "\n",
    "# Computing the distance between two vectors\n",
    "def squared_distance(v, w):\n",
    "    \"\"\"(v_1 - w_1) ** 2 + ... + (v_n - w_n) ** 2\"\"\"\n",
    "    return sum_of_squares(vector_subtract(v, w))\n",
    "\n",
    "def distance(v, w):\n",
    "    return math.sqrt(squared_distance(v, w))\n",
    "\n",
    "# We can resume the distance between two vectors with the following function\n",
    "def distance(v, w):\n",
    "    return magnitude(vector_subtract(v, w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9392cc9b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a25563b8",
   "metadata": {},
   "source": [
    "## Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3a59218b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A matrix is a bidimensional collection of numbers. We can represent it as a list of lists, with each inner \n",
    "# list having the same size and representing a line of the matrix. Usually capital letters are used to \n",
    "# represent matrices\n",
    "A = [[1, 2, 3], # A has 2 rows and 3 columns\n",
    "     [4, 5, 6]]\n",
    "\n",
    "B = [[1, 2],   # B has 3 lines and 2 columns\n",
    "     [3, 4],\n",
    "     [5, 6]]\n",
    "\n",
    "def shape(A):\n",
    "    num_rows = len(A)\n",
    "    num_cols = len(A[0]) if A else 0 # number of elements on the 1st line\n",
    "    return num_rows, num_cols\n",
    "\n",
    "# We can think that each line of a matrix 'n x k' as a vector of size 'k', and each column as a vector of size n\n",
    "def get_row(A, i):\n",
    "    return A[i]\n",
    "\n",
    "def get_column(A, j):\n",
    "    return [A_i[j]          # j_th element of line A_i\n",
    "            for A_i in A]   # for each line A_i\n",
    "\n",
    "# Create a matrix given its form and a function to create its elements.\n",
    "def make_matrix(num_rows, num_cols, entry_fn):\n",
    "    \"\"\"returns the matrix num_rows x num_cols\n",
    "    which (i, j)th entry is the entry_fn(i, j)\"\"\"\n",
    "    return [[entry_fn(i, j)               # given 'i', creates a list\n",
    "            for j in range(num_cols)]     # [entry_fn(i, 0), ...]\n",
    "           for i in range(num_rows)]      # creates a list for each i\n",
    "\n",
    "# Given that function, we can create a '5x5' identity matrix\n",
    "def is_diagonal(i, j):\n",
    "    \"\"\"1s on the diagonal, 0 everywhere else\"\"\"\n",
    "    return 1 if i == j else 0\n",
    "\n",
    "# Matrices can be used to represent binary relationships.\n",
    "\n",
    "friendships = [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (3, 4),\n",
    "               (4, 5), (5, 6), (5, 7), (6, 8), (7, 8), (8, 9)]\n",
    "\n",
    "# Can be represented:\n",
    "\n",
    "\n",
    "friendships = [[0, 1, 1, 0, 0, 0, 0, 0, 0, 0],    # user 0\n",
    "               [1, 0, 1, 1, 0, 0, 0, 0, 0, 0],    # user 1\n",
    "               [1, 1, 0, 1, 0, 0, 0, 0, 0, 0],    # user 2\n",
    "               [0, 1, 1, 0, 1, 0, 0, 0, 0, 0],    # user 3\n",
    "               [0, 0, 0, 1, 0, 1, 0, 0, 0, 0],    # user 4\n",
    "               [0, 0, 0, 0, 1, 0, 1, 1, 0, 0],    # user 5\n",
    "               [0, 0, 0, 0, 0, 1, 0, 0, 1, 0],    # user 6\n",
    "               [0, 0, 0, 0, 0, 1, 0, 0, 1, 0],    # user 7\n",
    "               [0, 0, 0, 0, 0, 0, 1, 1, 0, 1],    # user 8\n",
    "               [0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]    # user 9\n",
    "\n",
    "friends_of_five = [i                                                 # we just\n",
    "                   for i, is_friend in enumerate(friendships[5])     # need to look\n",
    "                   if is_friend]                                     # at one row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73b57edf",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}