Fundamentos de machine learning - as normas

Introdução

Álgebra linear é uma das bases matemáticas essenciais para quem trabalha com ciência de dados. Entender esses conceitos aumenta sua compreensão de vários algoritmos. É, de fato, uma excelente base para seguir um caminho em data science e machine learning.

O objetivo deste tutorial é entrar na matemática para ciência de dados programando com Python/Numpy. Acredito que tutoriais práticos sobre tópicos teóricos, como álgebra linear, são úteis porque escrever e ler código é uma ótima forma de entender de verdade os conceitos matemáticos. E, acima de tudo, pode ser muito divertido!

Não há pré-requisitos específicos, mas, se você não tem certeza do que é uma matriz ou como fazer o produto escalar, os primeiros posts (1 a 4) da minha série sobre o livro de deep learning do Ian Goodfellow são um bom começo.

Neste tutorial, vamos abordar um conceito importante para machine learning e deep learning: a norma. A norma é muito usada, por exemplo, para avaliar a qualidade de um modelo. Ao final, você deve ter uma intuição melhor desse conceito e por que ele é tão valioso em machine learning. Também veremos como a derivada da norma é usada para treinar um algoritmo de machine learning.

Configuração básica

Antes de tudo, vamos configurar as bibliotecas que vamos usar:

import numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n

E adicionar alguns atalhos em LaTeX para os comandos bs (símbolos em negrito) e norm (símbolo da norma):

$$\n\\newcommand\\bs[1]{\\boldsymbol{#1}}\n\\newcommand\\norm[1]{\\left\\lVert#1\\right\\rVert}\n$$\n

$$ \\newcommand\\bs[1]{\\boldsymbol{#1}} \\newcommand\\norm[1]{\\left\\lVert#1\\right\\rVert} $$

A última coisa é ajustar a aparência dos gráficos que vamos criar:

# Parâmetros do gráfico\nsns.set()\n%pylab inline\npylab.rcParams['figure.figsize'] = (4, 4)\nplt.rcParams['xtick.major.size'] = 0\nplt.rcParams['ytick.major.size'] = 0\n

Populating the interactive namespace from numpy and matplotlib\n

Um exemplo prático

Vamos começar com um exemplo simples. Imagine que você tem um conjunto de músicas com diferentes atributos. Agora, digamos que você quer construir um modelo que prevê a duração de uma música com base em outras características, como o gênero, a instrumentação etc. Você treinou um modelo e agora quer avaliar a capacidade dele de prever a duração de uma nova música. Uma forma de fazer isso é pegar dados novos e prever as durações com o seu modelo. Como você conhece a duração real de cada música nessas observações, pode comparar a duração real e a prevista para cada uma. Você obteve os seguintes resultados, em segundos, para 7 observações:

errorModel1 = [22, -4, 2, 7, 6, -3, 12]\n

Essas diferenças podem ser vistas como o erro do modelo. Um modelo perfeito teria apenas 0, enquanto um modelo muito ruim teria valores positivos ou negativos enormes.

Agora imagine que você testa outro modelo e termina com as seguintes diferenças entre as durações previstas e reais:

errorModel2 = [14, 9, -13, 19, 8, -21, 4]\n

O que fazer para escolher o melhor modelo? Uma forma natural é somar os valores absolutos desses erros. Usamos o valor absoluto porque um erro negativo (duração real menor que a prevista) também é erro. Quanto menor o erro total, melhor o modelo:

totalErrorModel1 = np.sum(np.abs(errorModel1))\ntotalErrorModel1\n

56\n

totalErrorModel2 = np.sum(np.abs(errorModel2))\ntotalErrorModel2\n

88\n

Parece que o modelo 1 é bem melhor que o modelo 2.

Parabéns! Você acabou de calcular a norma do vetor de erros de cada modelo!

Intuição

Você pode pensar na norma como o comprimento do vetor. Para ter uma ideia da representação gráfica, vamos retomar o exemplo anterior. Os vetores de erro são multidimensionais: há uma dimensão por observação. No último exemplo, 7 observações geravam 7 dimensões. Ainda é difícil representar 7 dimensões, então vamos simplificar e manter apenas 2 observações:

errorModel1 = [22, -4]\nerrorModel2 = [14, 9]\n

Agora podemos representar esses vetores considerando que o primeiro elemento do array é a coordenada x e o segundo é a coordenada y. Vamos começar escrevendo uma função para plotar os vetores com facilidade e visualizar suas representações.

Como plotar vetores com Python e Matplotlib

Queremos uma função que nos ajude a plotar os vetores. Vamos começar pelo jeito como gostaríamos de usá-la. Queremos passar uma lista de arrays correspondentes às coordenadas dos vetores e obter um gráfico desses vetores. Digamos também que podemos passar um array de cores para diferenciar os vetores no gráfico. Resumindo, gostaríamos de chamar a função assim:

plotVectors([vector1, vector2], ['red', 'blue'])\n

Vamos escrever essa função:

def plotVectors(vecs, cols, alpha=1):\n    \"\"\"\n    Plotar um conjunto de vetores.\n\n    Parâmetros\n    ----------\n    vecs : array-like\n        Coordenadas dos vetores a serem plotados. Cada vetor está em um array. Por\n        exemplo: [[1, 3], [2, 2]] plota 2 vetores.\n    cols : array-like\n        Cores dos vetores. Por exemplo: ['red', 'blue'] mostra o\n        primeiro vetor em vermelho e o segundo em azul.\n    alpha : float\n        Opacidade dos vetores\n\n    Retorna:\n\n    fig : instância de matplotlib.figure.Figure\n        A figura com os vetores\n    \"\"\"\n    plt.axvline(x=0, color='#A9A9A9', zorder=0)\n    plt.axhline(y=0, color='#A9A9A9', zorder=0)\n\n    for i in range(len(vecs)):\n        if (isinstance(alpha, list)):\n            alpha_i = alpha[i]\n        else:\n            alpha_i = alpha\n        if (len(vecs[i])==2):\n            x = np.concatenate([[0,0],vecs[i]])\n        elif (len(vecs[i])==4):\n            x = vecs[i]\n        plt.quiver([x[0]],\n                   [x[1]],\n                   [x[2]],\n                   [x[3]],\n                   angles='xy', scale_units='xy', scale=1, color=cols[i],\n                  alpha=alpha_i)\n

Ela recebe um array de vetores a serem plotados (vecs) e suas cores (cols) como entrada. Se apenas 2 dimensões forem especificadas no vetor, ele começa em (0, 0). Por baixo dos panos, iteramos nesse array de vetores e usamos plt.quiver() para plotá-los.

Vamos usar nossa nova função para plotar os erros dos modelos 1 e 2:

plotVectors([errorModel1, errorModel2], [sns.color_palette()[0], sns.color_palette()[1]])\n\nplt.xlim(-1, 25)\nplt.ylim(-5, 10)\nplt.show()\n

Observação: não incluímos plt.show() na função para podermos adicionar configurações ao gráfico, como os limites neste exemplo.

Observação 2: usamos as cores do seaborn manualmente com sns.color_palette()

Temos, então, um vetor de erro para cada modelo. O melhor modelo é simplesmente o que corresponde ao vetor menor. Uma forma de calcular o comprimento dos vetores é usar o teorema de Pitágoras: $\\sqrt{x^2+y^2}$. Podemos calcular o comprimento dos dois vetores:

# Comprimento do vetor errorModel1\nnp.sqrt(errorModel1[0]**2+errorModel1[1]**2)\n

22.360679774997898\n

# Comprimento do vetor errorModel2\nnp.sqrt(errorModel2[0]**2+errorModel2[1]**2)\n

16.643316977093239\n

Parabéns! Você acabou de calcular outra norma dos vetores de erro. O comprimento do vetor de erro do primeiro modelo é $22,36$ e o do segundo é cerca de $16,64$. Neste caso, o segundo modelo é melhor — lembrando que usamos apenas os dois primeiros valores.

Primeiro calculamos a soma dos erros, mas também podemos usar o teorema de Pitágoras para obter a norma de um vetor. São duas normas diferentes, o que mostra que há várias maneiras de calcular normas.

Funções norma: definições

A norma de um vetor pode ser qualquer função que mapeia um vetor para um valor positivo. Diferentes funções podem ser usadas, e veremos alguns exemplos. Essas funções podem ser chamadas de normas se forem caracterizadas pelas seguintes propriedades:

\n
• \n

  Normas são não negativas. Pensando na norma como comprimento, fica claro por que não pode ser negativa.

  \n
\n
• \n

  Normas são $0$ se, e somente se, o vetor é o vetor nulo.

  \n
\n
• \n

  Normas obedecem à desigualdade triangular. Veja abaixo.

  \n
\n
• \n

  $\\norm{k\\cdot \\bs{u}}=\\norm{k}\\cdot\\norm{\\bs{u}}$. Aqui, $k$ é um escalar e $\\bs{u}$ um vetor. A norma de um vetor multiplicado por um escalar é igual ao valor absoluto desse escalar multiplicado pela norma do vetor.

  \n
\n

Geralmente é escrita com duas barras verticais: $\\norm{\\bs{x}}$

A desigualdade triangular

Vimos acima que uma condição para uma função ser norma é respeitar a desigualdade triangular. Isso significa que a norma da soma de alguns vetores é menor ou igual à soma das normas desses vetores:

Exemplo 1.

Para ilustrar, vamos pegar dois vetores, cada um com dois elementos (novamente úteis para serem representados como coordenadas x e y). Nossos vetores são:

u = np.array([1, 6])\nu\n

array([1, 6])\n

e

v = np.array([4, 2])\nv\n

array([4, 2])\n

Vamos comparar:

e:

Veremos depois diferentes tipos de norma, mas, por ora, usaremos uma clássica: a norma euclidiana ($L^2$). A norma $L^2$ pode ser calculada com a função do Numpy np.linalg.norm() (veja mais detalhes na documentação).

Mais adiante veremos em detalhes o que são as normas $L^1$ e $L^2$.

np.linalg.norm(u+v)\n

9.4339811320566032\n

e

np.linalg.norm(u)+np.linalg.norm(v)\n

10.554898485297798\n

Vemos que a desigualdade triangular é respeitada, pois:

Explicação gráfica

A representação gráfica desse teorema o torna quase trivial. Vamos plotar os vetores $\\bs{u}$, $\\bs{v}$ e $\\bs{u}+\\bs{v}$ usando nossa função plotVectors e adicionando alguns textos para identificá-los:

u = np.array([0,0,1,6])\nv = np.array([0,0,4,2])\nw = u+v\n\nu_bis = [u[2], u[3], v[2], v[3]]\n\nplotVectors([u, u_bis, w],\n            [sns.color_palette()[0],\n            sns.color_palette()[1],\n            sns.color_palette()[2]])\n\nplt.xlim(-2, 6)\nplt.ylim(-2, 9)\n\nplt.text(-1, 3.5, r'$||\\vec{u}||$', color=sns.color_palette()[0], size=20)\nplt.text(2.5, 7.5, r'$||\\vec{v}||$', color=sns.color_palette()[1], size=20)\nplt.text(2, 2, r'$||\\vec{u}+\\vec{v}||$', color=sns.color_palette()[2], size=20)\n\nplt.show()\nplt.close()\n

O comprimento de $\\bs{u}$ mais o comprimento de $\\bs{v}$ é maior que o comprimento do vetor $\\bs{u}+\\bs{v}$. Geometricamente, isso simplesmente significa que o caminho mais curto entre dois pontos é uma linha!

P-normas: regras gerais

Vimos as condições para uma função ser chamada de norma. Isso significa que há várias funções que podem ser usadas como normas. Veremos depois prós e contras de diferentes normas. Chamamos de $p$-norma a seguinte categoria de funções que dependem de $p$:

Vamos destrinchar essa equação passo a passo. Há uma soma de elementos, então podemos pensá-la como uma iteração sobre os elementos $i$:

\n
1. $\\vert\\bs{x}_i\\vert$ Calcule o valor absoluto do $i$-ésimo elemento
\n
2. $\\vert\\bs{x}_i\\vert^p$ Eleve à potência $p$
\n
3. $\\sum_i\\vert\\bs{x}_i\\vert^p$ Some todos esses valores absolutos elevados
\n
4. $(\\sum_i\\vert\\bs{x}_i\\vert^p)^{1/p}$ Eleve o resultado à potência $\\frac{1}{p}$
\n

Isso fica claro com exemplos usando essas $p$-normas muito utilizadas.

A norma $L^0$

Se $p=0$, a fórmula se torna:

Vamos ver o que isso significa. Elevar ao expoente $0$ com valores absolutos resulta em $1$ para todo valor diferente de $0$ e em $0$ para o próprio $0$.

Portanto, essa “norma” corresponde ao número de elementos não nulos no vetor. Ela não é exatamente uma norma, porque, se você multiplicar o vetor por $\\alpha$, essa contagem permanece a mesma (regra 4 acima).

A norma $L^1$

Se $p=1$, temos simplesmente a soma dos valores absolutos. Foi o que usamos intuitivamente no começo do tutorial:

A norma $L^2$ (norma euclidiana)

A norma euclidiana é a $p$-norma com $p=2$. Talvez seja a mais usada, junto com sua versão ao quadrado (veja abaixo).

Note que o valor absoluto não é mais necessário, já que $x$ está ao quadrado. Foi o que usamos ao calcular o comprimento dos nossos vetores com o teorema de Pitágoras.

Vamos ver outro exemplo dessa norma:

Exemplo 2.

Graficamente, a norma euclidiana corresponde ao comprimento do vetor da origem até o ponto obtido pela combinação linear (teorema de Pitágoras). Veremos um exemplo em 2 dimensões: o vetor $\\bs{u}$ tem dois valores correspondentes às coordenadas $x$ e $y$. Se você plota o ponto com essas coordenadas e desenha um vetor da origem até esse ponto, a norma $L^2$ será o comprimento desse vetor.

Por exemplo:

Vamos começar calculando a norma pela fórmula:

A norma $L^2$ é $5$.

Lembrando: a norma $L^2$ pode ser calculada com a função linalg.norm() do Numpy:

np.linalg.norm([3, 4])\n

5.0\n

Aqui está a representação gráfica do vetor:

u = np.array([3, 4])\n\nplt.ylim(-1, 5)\nplt.xlim(-1, 5)\nplotVectors([u], [sns.color_palette()[0]])\n

Vemos que o vetor vai da origem (0, 0) até (3, 4) e que seu comprimento é 5.

Neste caso, o vetor está em um espaço 2D, mas isso vale para mais dimensões.

A norma euclidiana ao quadrado (norma $L^2$ ao quadrado)

A norma $L^2$ ao quadrado é conveniente porque remove a raiz quadrada e ficamos com a simples soma de cada valor do vetor elevado ao quadrado.

A norma euclidiana ao quadrado é muito usada em machine learning, em parte porque pode ser calculada com a operação vetorial $\\bs{x}^\\text{T}\\bs{x}$. Pode haver ganhos de desempenho por otimização. Veja aqui e aqui para mais detalhes.

Exemplo 3.

Veremos neste exemplo que a norma euclidiana ao quadrado pode ser calculada com operações vetorizadas. Vamos começar com um vetor $\\bs{x}$:

Como de costume, vamos usar código para checar o processo. Primeiro, vamos criar nosso vetor Numpy $\\bs{x}$:

x = np.array([[2], [5], [3], [3]])\nx\n

array([[2],\n       [5],\n       [3],\n       [3]])\n

Agora vamos tomar a transposta desse vetor. Isso apenas converte o vetor coluna inicial em um vetor linha:

Podemos calcular a transposta de $\\bs{x}$ com o atributo T dos objetos Numpy:

x.T\n

array([[2, 5, 3, 3]])\n

O produto escalar de $\\bs{x}$ e $\\bs{x}^\\text{T}$ (veja aqui se precisar relembrar o produto escalar) corresponde, na prática, à multiplicação de cada elemento por ele mesmo:

Isso é exatamente a definição da norma euclidiana ao quadrado!

Vamos conferir com o Numpy. Lembre-se (e teste para se convencer) de que a ordem dos vetores no produto escalar importa:

euclideanNorm = x.T.dot(x)\neuclideanNorm\n

array([[47]])\n

Deve ser a nossa norma euclidiana ao quadrado! Vamos calculá-la a partir da norma $L^2$ e elevar ao quadrado para checar:

np.linalg.norm(x)**2\n

47.0\n

Funcionou! A possibilidade de usar uma operação vetorizada é uma grande vantagem sobre outras normas.

Derivada da norma $L^2$ ao quadrado

Vimos que as normas podem ser usadas para avaliar a qualidade de um modelo ao resumir os vetores de erro.

Agora queremos ir além e entender como mudar os parâmetros do modelo para reduzir o erro total. Para isso, usamos uma função de custo que associa o erro do modelo em função dos valores dos parâmetros. O algoritmo de gradiente descendente pode ser usado para encontrar o mínimo dessa função. O gradiente descendente é feito calculando as derivadas em relação a cada parâmetro (derivadas parciais = gradientes). Por isso é crucial conseguir calcular a derivada de forma eficiente.

De fato, uma grande vantagem da norma $L^2$ ao quadrado é que sua derivada parcial é facilmente computada. Considere o vetor:

Vimos que sua norma $L^2$ ao quadrado é calculada por:

Para calcular as derivadas parciais, consideramos todas as outras variáveis constantes. Por exemplo, a derivada parcial em relação a $u_1$ é a derivada de $u_1^2+a$ ($a$ sendo a constante correspondente às demais variáveis). Por isso, temos as seguintes derivadas parciais:

O ótimo nos gradientes da norma $L^2$ ao quadrado é que as derivadas não dependem das outras variáveis. Veremos que isso não acontece com a norma $L^2$.

Derivada da norma $L^2$

No caso da norma $L^2$, a derivada é mais complicada e leva em conta todos os elementos do vetor. Vamos usar o último vetor $\\bs{u}$ como exemplo. A norma $L^2$ é:

Vamos calcular a derivada em relação a $u_1$:

Percebemos que a derivada parcial de $u_1$ ainda contém $u_2...u_n$. As outras derivadas seguem a mesma estrutura:

Outras considerações

A norma $L^2$ ao quadrado é ótima, mas um problema é que ela discrimina pouco entre 0 e valores pequenos, pois a função cresce devagar nesse trecho.

Podemos ver isso comparando graficamente a norma $L^2$ com sua versão ao quadrado. O eixo $z$ corresponde ao valor da norma e os eixos $x$ e $y$ correspondem a dois parâmetros. O mesmo vale para mais de 2 dimensões, mas seria difícil de visualizar.

Norma $L^2$:

Norma $L^2$ ao quadrado:

Para comparação, aqui está a norma $L^1$:

Esses gráficos foram feitos com a ajuda deste site. Acesse e plote essas normas se quiser girá-las para entender melhor o formato.

A norma máximo

É a norma $L^\\infty$ e corresponde ao valor absoluto do maior elemento do vetor.

Normas de matrizes: a norma de Frobenius

Isso é equivalente a aplicar a norma $L^2$ na matriz após achatá-la.

A mesma função do Numpy pode ser usada:

A = np.array([[1, 2], [6, 4], [3, 2]])\nA\n

array([[1, 2],\n       [6, 4],\n       [3, 2]])\n

np.linalg.norm(A)\n

8.3666002653407556\n

Produto escalar expresso com normas

O produto escalar entre os vetores $\\bs{x}$ e $\\bs{y}$ pode ser obtido com as normas $L^2$ desses vetores. $\\theta$ é o ângulo entre eles.

Exemplo 4.

Vamos pegar dois vetores em 2 dimensões:

e

O gráfico a seguir mostra a representação deles:

x = [0,0,0,2]\ny = [0,0,2,2]\n\nplotVectors([x, y], [sns.color_palette()[0], sns.color_palette()[1]])\n\nplt.xlim(-1, 3)\nplt.ylim(-1, 3)\n\nplt.text(-0.5, 1, r'$\\vec{x}$', size=18, color=sns.color_palette()[0])\nplt.text(1.5, 0.5, r'$\\vec{y}$', size=18, color=sns.color_palette()[1])\n

<matplotlib.text.Text at 0x10a33b950>\n

Escolhemos este exemplo pela simplicidade. Como podemos ver, o ângulo $\\theta$ é igual a 45°.

Primeiro, vamos calcular o produto escalar dos vetores:

x = np.array([0, 2])\ny = np.array([2, 2])\n\nx.dot(y)\n

4\n

Agora vamos calcular as normas:

e

Então, pela fórmula acima, temos:

É o mesmo resultado do produto escalar. Aqui estão as operações usando numpy. Note que usamos a função deg2rad do Numpy porque np.cos recebe o ângulo em radianos, então precisamos converter.

# Observação: np.cos recebe o ângulo em radianos\nnp.cos(np.deg2rad(45))*2*np.sqrt(8)\n

4.0000000000000009\n

Conclusão

A norma $L^2$ (ou a norma de Frobenius no caso de matrizes) e a norma $L^2$ ao quadrado são amplamente usadas em machine learning, deep learning e ciência de dados em geral. Por exemplo, normas podem ser usadas como funções de custo. Suponha que você queira ajustar uma reta a um conjunto de pontos. Uma forma de encontrar a melhor reta é começar com parâmetros aleatórios e iterar minimizando a função de custo. A função de custo representa o erro do seu modelo, então você quer que esse erro seja o menor possível. As normas são úteis aqui porque oferecem uma forma de medir esse erro. A norma mapeia o vetor com todos os seus erros para um escalar, e a função de custo é esse escalar para um determinado conjunto de valores dos seus parâmetros.

Vimos que normas não são mais que um array reduzido a um escalar. Também percebemos que há variações conforme a função usada para calculá-la. Escolher qual norma usar depende muito do problema a ser resolvido, já que há prós e contras em aplicar uma ou outra. Por exemplo, a norma $L^1$ é mais robusta que a $L^2$. Isso significa que a $L^2$ é mais sensível a outliers, pois erros grandes geram valores quadráticos muito altos.

Este tutorial é baseado neste artigo da minha série sobre o capítulo de álgebra linear do Deep Learning Book, de Goodfellow et al.

Referências

https://www.quora.com/Why-is-L1-regularization-better-than-L2-regularization-provided-that-all-Norms-are-equivalent

http://www.deeplearningbook.org/contents/linear_algebra.html

https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.linalg.norm.html

https://hadrienj.github.io/deep-learning-book-series-home/

http://christopher5106.github.io/deep/learning/2016/09/16/about-loss-functions-multinomial-logistic-logarithm-cross-entropy-square-errors-euclidian-absolute-frobenius-hinge.html

https://datascience.stackexchange.com/questions/10188/why-do-cost-functions-use-the-square-error