Aprendizado de Máquina

Prof. Ronaldo Cristiano Prati
ronaldo.prati@ufabc.edu.br

Bloco A, Sala 513-2

Tópicos da Aula

• Implementações do algoritmo da descida do gradiente para regressão linear
  • Direta
  • Vetorizada (numpy)
  • Algebra Linear
• Regressão linear multivariada

Função de custo

• Vamos definir a função de custo (em python). As variáveis x e y são listas de tamanho $m$, e theta é uma lista de tamanho 2.

def costFunction(x,y,theta):
    error = 0
    m = len(x)
    for i in range(m):
        error += ((theta[0] + theta[1]*x[i]) - y[i])**2
    return error / (2*m)

Descida do Gradiente (1 passo)

• Calcula o gradiente em cada ponto e calcula o novo valor de $\theta$.

def step_gradient(x,y,theta,alpha):

    new_theta = [0,0]
    m = len(x)

    theta_0_grad = []
    theta_1_grad = []

    for i in range(m):
        theta_0_grad.append((theta[0] + theta[1]*x[i]) - y[i])
        theta_1_grad.append(((theta[0] + theta[1]*x[i]) - y[i])* x[i])

    new_theta[0] = theta[0] - (alpha * sum(theta_0_grad)/m)
    new_theta[1] = theta[1] - (alpha * sum(theta_1_grad)/m)
    return(new_theta)

Descida do Gradiente (iterando)

• Chama o método step_gradient iterativamente para atualizar o valor de $\theta$. Armazena os valores intermediários para plotar

theta = [0,0]
theta_logs = [theta] # para plotar
cost_logs = [costFunction(x,y,theta)] # para plotar
n_iter=200
alpha = 0.001
for i in range(n_iter):
    theta = step_gradient(x,y,theta,alpha)
    theta_logs.append(theta) # para plotar
    cost_logs.append(costFunction(x,y,theta)) # para plotar

Alpha = 0.03

Alpha = 0.02

Alpha = 0.01

Alpha = 0.001

Alpha = 0.0001

Vetorização

• Algumas linguagens (como matlab e R) permite o uso de técnicas de vetorização. Nessas linguagens, algumas operacoes são transparentemente aplicadas a vetores ou matrizes.

• Em python, a biblioteca numpy provê várias funcionalidades para explorar vetorização

Função de custo - vetorizada

• Uma versão da função de custo vetorizada é mostrada a seguir. Observe que não é utilizado o laço.

• As variáveis x, y e theta devem ser numpy.array

import numpy as np

def costFunction(x,y,theta):
    error = np.sum(((theta[0] + theta[1]*x) - y)**2)
    return error / (2*m)  

Descida do Gradiente (1 passo)

def step_gradient(x,y,theta,alpha):

    theta_gradient = np.zeros(2)
    theta_gradient[0] = np.mean((theta[0] + theta[1]*x) - y)
    theta_gradient[1] = np.mean(((theta[0] + theta[1]*x) - y)*x)

    new_theta = theta - (alpha * theta_gradient)

    return(new_theta)

Algebra linear

• Suponha que nosso modelo seja

$h_\theta(x) = -40 + 0.25x$

• Queremos aplicá-la em uma base de dados com 4 casas

Algebra linear

• Podemos calcular o valor predito pelo modelo acrescentando uma coluna de 1's ao conjunto de dados, e multiplicando pela "matriz" de coeficientes.

$\begin{bmatrix} 1 & 2104 \\ 1 & 1416 \\ 1 & 1534 \\ 1 & 852 \\\end{bmatrix} \times \begin{bmatrix} -40 \\ 0.25\end{bmatrix} =\begin{bmatrix} 486.0 \\ 314.0 \\ 343.5 \\ 173.0 \end{bmatrix}$

• Isso pode ser muito mais eficiente computacionalmente que usar laços, e também facilita a codificação (se tivermos uma biblioteca de algegra linear)

Gradiente descendente - AlgLin

• Podemos reescrever a função de custo como:
  $J_\theta(x) = \frac{1}{2m} \sum\left(x {\theta} - {y} \right)^2$
• e o seu gradiente como:
  $\begin{aligned} \frac{\partial}{\partial_\theta}J_\theta(x) & = \frac{1}{m} \left((x{\theta} - {y})^\intercal x \right)^\intercal \\ & = \frac{1}{m} \left(x^\intercal \times (x{\theta} - {y})\right) \end{aligned}$
• Para derivação do gradiente, veja aqui

Gradiente descendente - AlgLin

def costFunction(X, y, theta):
    error = np.dot(X, theta) - y
    return np.mean(error) / 2

def step_gradient(x,y,theta,alpha):
    m = len(x)
    theta = theta - (alpha/m) * np.dot(x.T, np.dot(x, theta) - y)
    return(theta)

x = np.column_stack((np.ones(len(x)),x))
theta = [0,0]
n_iter=200
alpha = 0.001
for i in range(n_iter):
    theta = step_gradient(x,y,theta,alpha)

Regressão linear multivariada

• Múltiplas variáveis = múltiplos atributos
• No problema anterior, tinhamos
  • $x$ = tamanho da casa (em $ft^2$)
  • $y$ = preço da casa
• Mas podemos adicionar novas variáveis, tais como
  • $x_1, x_2, x_3, x4$ são quatro atributos:
    $x_1$ = tamanho ($ft^2$)
    $x_2$ = número de quartos
    $x_3$ = number de andares
    $x_4$ = idade da casa (anos)
    $y$ = preço das casas

Mais notação

• $n$ = número de atributos $(n = 4)$
• $m$ = número de exemplos
• $x^i$ = vetor de entrada para um exemplo. $i$ é o índice do conjunto de treinamento, então $x^3$ é, por exemplo a $3^{a}$ casa. $x$ é um vetor $n$-dimensional
• $x_j^i$ é o valor do atributo $j$ do $i$-ésimo exemplo de treino. Por exemplo, $x_2^3$ é o número de quartos da terceira casa.

Forma da hipótese

• Anteriormente nossa hipótese era da forma:
  $h_\theta(x) = \theta_0 + \theta_1 x$

• Agora que temos multiplos atributos:
  $h_\theta(x) = \theta_0 + \theta_1 x + \theta_2 x + \theta_3 x + \theta_4 x$

• Se adicionarmos uma feature adicional $x_0 = 1$, em notação vetorial temos:

$h_\theta(x) = \overrightarrow{\theta}x$

Descida do Gradiente

• Os parâmetros ainda podem ser determinados pela função de custo

• Atualizamos cada parâmetro $\theta_j$ fazendo
  $\theta_j := \theta_j - \alpha \frac{\partial}{\partial\theta_j} J(\theta)$

• em que
  $\frac{\partial}{\partial\theta_j} J(\theta) = \frac{1}{m} \sum_i^m (h_\theta(x^i) - y^i) x^i_j$

• A forma vetorial se ajusta ao número de variáveis

Criação de atributos

• Suponha que tenhamos os atributos:
  • $x_1$ = Largura da frente to terreno
  • $x_2$ = Profundidade do terreno
• Podemos criar um novo atributo $x_3$ = Área fazendo
  $x_3 = x_1 * x_2$
• Em muitos casos, a definição de novos atributos pode gerar modelos melhores!