matemagica-para-devs/algebra linear.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui vamos rever os seguintes conceitos sobre álgebra linear\n",
    "\n",
    "* O que são vetores?\n",
    "* O que são matrizes?\n",
    "* Multiplicação matriz x vetor, vetor x vetor e matriz x matriz\n",
    "* Tamanho de um vetor (norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Material auxiliar\n",
    "\n",
    "Essence of Linear Algebra por 3Blue1Brown no YouTube https://www.youtube.com/watch?v=kjBOesZCoqc&list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab&index=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O que é um vetor?\n",
    "\n",
    "De forma bem simplificada, é um conjunto de números com uma direção e tamanho.\n",
    "\n",
    "É importante notar que a notação normal é definir o vetor como coluna e não como linha.\n",
    "\n",
    "$$\\mathbf{v} = \\begin{bmatrix} 4 \\\\ 1 \\\\ 10 \\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4]\n",
      " [ 1]\n",
      " [10]]\n"
     ]
    }
   ],
   "source": [
    "# um vetor no numpy\n",
    "v = np.array([\n",
    "    [4], \n",
    "    [1], \n",
    "    [10]\n",
    "])\n",
    "\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem duas operações fundamentais com vetores: soma e multiplicação por escalar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A soma de vetores é definida como\n",
    "\n",
    "$$\n",
    "\\mathbf{x} = \\begin{bmatrix} 4 \\\\ 1 \\\\ 10 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf{y} = \\begin{bmatrix} 5 \\\\ 8 \\\\ -1 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf{x} + \\mathbf{y} \n",
    "= \n",
    "\\begin{bmatrix} 4 + 5 \\\\ 1 + 8 \\\\ 10 + (-1) \\end{bmatrix}\n",
    "= \n",
    "\\begin{bmatrix} 9 \\\\ 9 \\\\ 9 \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9]\n",
      " [9]\n",
      " [9]]\n"
     ]
    }
   ],
   "source": [
    "# com numpy\n",
    "x = np.array([\n",
    "    [4],\n",
    "    [1],\n",
    "    [10]\n",
    "])\n",
    "\n",
    "y = np.array([\n",
    "    [5],\n",
    "    [8],\n",
    "    [-1]\n",
    "])\n",
    "\n",
    "v = x + y\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A multiplicação por escalar é definida como\n",
    "\n",
    "$$\n",
    "\\mathbf{x} = \\begin{bmatrix} 4 \\\\ 1 \\\\ 10 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "7\\mathbf{x}\n",
    "= \n",
    "\\begin{bmatrix} 7 \\cdot 4 \\\\ 7 \\cdot 1 \\\\ 7 \\cdot 10 \\end{bmatrix}\n",
    "= \n",
    "\\begin{bmatrix} 28 \\\\ 7 \\\\ 7 0 \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[28]\n",
      " [ 7]\n",
      " [70]]\n"
     ]
    }
   ],
   "source": [
    "# com numpy\n",
    "x = np.array([\n",
    "    [4],\n",
    "    [1],\n",
    "    [10]\n",
    "])\n",
    "\n",
    "v = 7 * x\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra operação comum é a transposição, que é basicamente trocar as linhas pelas colunas.\n",
    "\n",
    "$$\n",
    "\\mathbf{x} = \\begin{bmatrix} a \\\\ b \\\\ c \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf{x}^T = \\begin{bmatrix} a & b & c \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  1 10]]\n"
     ]
    }
   ],
   "source": [
    "# com numpy\n",
    "x = np.array([\n",
    "    [4],\n",
    "    [1],\n",
    "    [10]\n",
    "])\n",
    "\n",
    "print(x.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O que são matrizes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma simples, uma matriz é um conjunto de números que representa uma transformação linear.\n",
    "\n",
    "As mesmas operação de adição, multiplicação e trasposição dos vetores se aplicam as matrizes.\n",
    "\n",
    "Detalhe para a transposta conforme\n",
    "\n",
    "$$\n",
    "\\mathbf{x} \n",
    "= \n",
    "\\begin{bmatrix} \n",
    "a & b & c \\\\\n",
    "d & e & f\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\mathbf{x}^T \n",
    "= \n",
    "\\begin{bmatrix} \n",
    "a & d \\\\\n",
    "b & e \\\\\n",
    "c & f\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "soma\n",
      "[[ 8 10]\n",
      " [12 14]\n",
      " [16 18]]\n",
      "multiplicação\n",
      "[[ 7 14]\n",
      " [21 28]\n",
      " [35 42]]\n",
      "transposta\n",
      "[[1 3 5]\n",
      " [2 4 6]]\n",
      "[[ 7  9 11]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "# com numpy\n",
    "\n",
    "A = np.array([\n",
    "    [1, 2],\n",
    "    [3, 4],\n",
    "    [5, 6]\n",
    "])\n",
    "\n",
    "B = np.array([\n",
    "    [7, 8],\n",
    "    [9, 10],\n",
    "    [11, 12]\n",
    "])\n",
    "\n",
    "R = A + B\n",
    "print('soma')\n",
    "print(R)\n",
    "\n",
    "R = 7 * A\n",
    "print('multiplicação')\n",
    "print(R)\n",
    "\n",
    "print('transposta')\n",
    "print(A.T)\n",
    "print(B.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplicação matriz x vetor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A multiplicação de uma matriz por um vetor resulta em uma transformação linear do vetor.\n",
    "\n",
    "A matriz representa a transformação e o vetor representa as coordenadas iniciais.\n",
    "\n",
    "A multiplicação de uma matriz por um vetor tem a forma\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "a & b \\\\\n",
    "c & d\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix} e \\\\ f \\end{bmatrix}\n",
    "=\n",
    "e\n",
    "\\begin{bmatrix} a \\\\ c \\end{bmatrix}\n",
    "+\n",
    "f\n",
    "\\begin{bmatrix} b \\\\ d \\end{bmatrix}\n",
    "=\n",
    "\\begin{bmatrix}\n",
    "ae + bf \\\\\n",
    "ce + df\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3.]\n",
      " [ 2.]]\n",
      "[[3]\n",
      " [2]]\n",
      "[[3]\n",
      " [2]]\n"
     ]
    }
   ],
   "source": [
    "# em código\n",
    "\n",
    "matriz = np.array([\n",
    "    [0, 1],\n",
    "    [1, 0]\n",
    "])\n",
    "\n",
    "vetor = np.array([\n",
    "    [2],\n",
    "    [3]\n",
    "])\n",
    "\n",
    "resultado = np.zeros(vetor.shape)\n",
    "for i in range(vetor.shape[0]):\n",
    "    resultado[:, 0] += vetor[i, 0] * matriz[:, i]\n",
    "print(resultado)\n",
    "\n",
    "# usando numpy\n",
    "resultado = np.dot(matriz, vetor)\n",
    "print(resultado)\n",
    "\n",
    "# usando operador\n",
    "resultado = matriz @ vetor\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A matriz não precisa ser quadrada como no exemplo acima. Por exemplo:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix}\n",
    "a & b & c \\\\\n",
    "d & e & f\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix} x \\\\ y \\\\ z \\end{bmatrix}\n",
    "=\n",
    "x\n",
    "\\begin{bmatrix} a \\\\ d \\end{bmatrix}\n",
    "+\n",
    "y\n",
    "\\begin{bmatrix} b \\\\ e \\end{bmatrix}\n",
    "+\n",
    "z\n",
    "\\begin{bmatrix} c \\\\ f \\end{bmatrix}\n",
    "=\n",
    "\\begin{bmatrix}\n",
    "ax + by + cz \\\\\n",
    "dx + ey + fz\n",
    "\\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 7.25]\n",
      " [ 4.81]]\n"
     ]
    }
   ],
   "source": [
    "matriz = np.array([\n",
    "    [0.25, 1.0, 5.06],\n",
    "    [1.31, 0.5, 2.33]\n",
    "])\n",
    "\n",
    "vetor = np.array([\n",
    "    [1],\n",
    "    [7],\n",
    "    [0]\n",
    "])\n",
    "\n",
    "resultado = matriz @ vetor\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplicação vetor x vetor (produto cruzado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A multiplicação entre vetores é o produto cruzado. O resultado é o mesmo que multiplicar\n",
    "a transposição do primeiro vetor pelo segundo.\n",
    "\n",
    "Portanto, $\\mathbf{x} \\times \\mathbf{y} = \\mathbf{x}^T \\mathbf{y}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10]]\n"
     ]
    }
   ],
   "source": [
    "# em código\n",
    "x = np.array([\n",
    "    [1],\n",
    "    [2],\n",
    "    [3]\n",
    "])\n",
    "\n",
    "y = np.array([\n",
    "    [3],\n",
    "    [2],\n",
    "    [1]\n",
    "])\n",
    "\n",
    "resultado = np.dot(x.T, y)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplicação matriz x matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para a multiplicação matriz x matriz vamos utilizar um exemplo mais prático.\n",
    "\n",
    "Dado uma matriz de vendas ($\\mathbf{V}$) com a quantidade de cada item em cada venda.\n",
    "\n",
    "Dado uma matriz com o custo de frete ($\\mathbf{F}$) de cada unidade de cada item.\n",
    "\n",
    "A matriz $\\mathbf{V}$ tem $M$ vendas por $N$ produtos.\n",
    "\n",
    "A matriz $\\mathbf{F}$ tem $N$ produtos por $Q$ transportadoras.\n",
    "\n",
    "Ao calcular $\\mathbf{C} = \\mathbf{V}\\mathbf{F}$, temos uma matriz de $M$ vendas por $Q$ transportadoras.\n",
    "\n",
    "Cada item dessa matriz representa o custo de transporte de uma determinada venda.\n",
    "\n",
    "Por exemplo, $\\mathbf{C}_{12}$ possui o custo de transporte da primeira venda pela segunda transportadora.\n",
    "\n",
    "Dessa forma, é possível descobrir com uma operação qual seria a melhor opção de frete para venda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.23   0.15   0.39]\n",
      " [ 10.64   9.82  11.64]\n",
      " [  6.23   6.31   7.25]\n",
      " [  1.69   1.5    2.19]\n",
      " [  3.37   3.07   3.03]\n",
      " [  5.96   5.75   6.84]]\n"
     ]
    }
   ],
   "source": [
    "V = np.array([\n",
    "    [0, 0, 0, 1, 0],\n",
    "    [0, 3, 0, 0, 2],\n",
    "    [0, 2, 2, 1, 0],\n",
    "    [1, 0, 0, 3, 0],\n",
    "    [0, 0, 0, 1, 2],\n",
    "    [3, 1, 0, 2, 0],\n",
    "])\n",
    "\n",
    "F = np.array([\n",
    "    [1.00, 1.05, 1.02],\n",
    "    [2.50, 2.30, 3.00],\n",
    "    [0.50, 0.78, 0.43],\n",
    "    [0.23, 0.15, 0.39],\n",
    "    [1.57, 1.46, 1.32],\n",
    "])\n",
    "\n",
    "C = V @ F\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medindo o tamanho de vetores e matrizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O tamanho de um vetor é medido pela *p-norm*. Quando $p=1$ temos a distância Manhattan e a distância euclidiana quando $p=2$.\n",
    "\n",
    "A *p-norm* de um vetor $\\mathbf{x}$ é calculada como \n",
    "$\\lvert \\mathbf{x} \\rvert_p = (\\sum_{i=1}^{n}\\lvert \\mathbf{x}_i \\rvert^p)^{\\frac{1}{p}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.07106781187\n",
      "7.07106781187\n"
     ]
    }
   ],
   "source": [
    "# em código\n",
    "vetor = np.array([\n",
    "    [1],\n",
    "    [7],\n",
    "    [0]\n",
    "])\n",
    "\n",
    "p = 2\n",
    "norm = 0\n",
    "for i in range(vetor.shape[0]):\n",
    "    norm += np.abs(vetor[i, 0]) ** p\n",
    "norm = norm ** (1.0 / p)\n",
    "print(norm)\n",
    "\n",
    "# com numpy\n",
    "norm = np.linalg.norm(vetor, 2)\n",
    "print(norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para matrizes, existe um operador similar conhecido como *Frobenius norm*.\n",
    "\n",
    "A *Frobenius norm* de uma matriz $\\mathbf{A}$ é calculada como \n",
    "$\\lvert \\lvert \\mathbf{A} \\rvert \\rvert_F = (\\sum_{i=1}^{m}\\sum_{j=1}^{n}\\lvert \\mathbf{A}_{ij} \\rvert^2)^{\\frac{1}{2}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.2882057274\n",
      "12.2882057274\n",
      "12.2882057274\n"
     ]
    }
   ],
   "source": [
    "# em código\n",
    "matriz = np.array([\n",
    "    [1, 2],\n",
    "    [7, 4],\n",
    "    [0, 9]\n",
    "])\n",
    "\n",
    "norm = 0\n",
    "for i in range(matriz.shape[0]):\n",
    "    for j in range(matriz.shape[1]):\n",
    "        norm += np.abs(matriz[i, j]) ** 2\n",
    "norm = norm ** (1.0 / 2)\n",
    "print(norm)\n",
    "\n",
    "# outra opção\n",
    "norm = np.sqrt(np.square(np.abs(matriz)).sum())\n",
    "print(norm)\n",
    "\n",
    "# com numpy\n",
    "norm = np.linalg.norm(matriz, 'fro')\n",
    "print(norm)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}