Os algoritmos de aprendizado de máquina ganharam enorme popularidade na última década. Hoje, esses algoritmos são usados ​​em vários campos de trabalho para todos os tipos de manipulação de dados e previsões.

Neste tutorial, iremos implementar o algoritmo de aprendizado de máquina mais básico chamado “ Regressão Linear ”. Se tivéssemos que descrever a regressão linear em uma única linha, seria algo como:

“Ajustando uma linha reta através de seus pontos de dados ”

Este é um algoritmo de aprendizado de máquina supervisionado. Se você deseja aprender sobre algoritmos não supervisionados, clique aqui .

Este tutorial consistirá em 3 partes principais :

· Compreender e implementar o algoritmo passo a passo.

· Aplicando o algoritmo construído em dados bidimensionais (para melhor visualização).

· Aplicação do algoritmo em dados n-dimensionais.

** Todo o código usado neste tutorial pode ser encontrado no seguinte repositório GitHub **.

Vamos começar.

Implementação passo a passo

Compreensão básica

Como discutimos antes, a regressão linear é tão simples quanto encaixar uma linha reta em nossos dados; portanto, para um entendimento básico, precisamos revisitar algumas matemáticas básicas e procurar uma linha reta na equação.

Na equação acima, X e Y são pontos de dados e m e c são a inclinação e a interceptação y, respectivamente. Precisamos dos valores apropriados para ' m ' e ' c ' para criar uma linha reta apropriada.

Digamos que temos vários valores de ' X ' contra os quais temos um único ' Y ', então podemos alterar a equação acima para criar uma mais geral da seguinte maneira:

Agora, em vez de 'm' e 'c', agora precisamos encontrar 'c' e todos os coeficientes de X de a_0 a a_n e esse é o conceito completo de regressão linear multivariável.

Implementação

Precisaremos das seguintes bibliotecas para funcionalidade matemática básica e visualização.

Primeiro, definimos uma função que nos retornaria os valores previstos de y (convencionalmente chamados de Y-hat ) a partir de alguns valores dados de ce a.

Em seguida, precisamos calcular a que distância estávamos dos valores originais de Y. Em termos de aprendizado de máquina, isso é chamado de cálculo do custo . Existem várias funções de custo diferentes definidas, mas para o nosso caso, usaremos o bom e velho “ erro médio quadrático” . A função para MSE é,

Vamos codificar isso:

Nosso objetivo é minimizar o custo calculado pela função acima, a fim de nos aproximar ao máximo dos valores originais.

Para isso, precisamos ver como cada um dos nossos parâmetros afeta o custo geral. Isso pode ser feito calculando a taxa de mudança, também conhecida como gradiente, em relação a cada parâmetro. As equações seriam:

Para minimizar o custo, precisamos realizar um processo denominado “Gradiente Descendente” . O gráfico abaixo representa o custo em relação a um parâmetro específico plotado em relação ao valor do parâmetro. Para atingir o custo mínimo, devemos alterar o valor do nosso parâmetro e é aí que nossas equações de atualização são utilizadas.

As equações finais para atualizar os valores dos nossos parâmetros são as seguintes,

O alfa na equação acima é chamado de taxa de aprendizado. Seu valor precisa ser definido de forma otimizada, um valor muito pequeno atualizará os parâmetros muito lentamente e um valor muito grande pode fazer com que os parâmetros atualizados ultrapassem o limbo e nunca convirjam para os mínimos globais.

Vamos codificar essas equações de atualização de maneira geral, de forma que o número n de parâmetros possa ser atualizado.

Com todas as funções implementadas, só precisamos criar uma rotina de treinamento que chamaria essas funções para minimizar o custo e encontrar os parâmetros adequados.

Testando

Agora é hora de testar nosso algoritmo. Vamos primeiro testar em um conjunto de dados mais simples. O conjunto de dados pode ser baixado gratuitamente aqui . As etapas de filtragem e visualização dos dados são realizadas a seguir.

Vamos normalizar os dados usando a técnica de escala mín-máx . Vamos definir uma função para escalonamento mín-máx. (Existem várias bibliotecas que podem fazer isso para você, mas é muito mais divertido codificar)

data_scaled = min_max_scaler(data_train)

X_train = data_scaled["x"].values.reshape(-1,1)
y_train = data_scaled["y"].values.reshape(-1,1)
coeff, intercept, preds = fit(X_train, y_train, iterr = 3000)

      

       Final cost
      

Podemos ver que nosso modelo se ajusta com bastante precisão no conjunto de treinamento e razoavelmente bem no conjunto de teste. Os resultados podem melhorar se o modelo for treinado para mais iterações. (A experimentação é com você 😀)

Outra boa medida para testar o nosso modelo é o “Valor R ao quadrado”, também conhecido como “ Qualidade de ajuste”. Para este propósito, usaremos a biblioteca sklearn (porque às vezes você se cansa de programar😅).

from sklearn.metrics import r2_score  
print("R_square Score:",r2_score(data_test["y"],y_pred))

      

Teste em dados n-dimensionais

Agora, para verificar se nosso algoritmo realmente funciona com dados n-dimensionais. Para tanto, utilizamos o conjunto de dados de preços de habitação . (O conjunto de dados original tem muitos recursos, mas selecionamos apenas alguns deles para o propósito deste teste)

Como a maioria dos recursos eram tipos de string , nós os convertemos em rótulos numéricos.

Normalizamos o conjunto de dados como antes e o configuramos para treinar por 2.000 épocas.

weights, biases, y_predicted = fit(X_train,y_train, iterr = 2000)

      

       The final cost for the housing data
      

from sklearn.metrics import r2_score
print(r2_score(y_test,predicted))

      

       A 27.9% goodness of fit
      

Conclusão

Implementamos com sucesso o algoritmo de regressão linear usando Python e alcançamos um ajuste razoavelmente bom em nosso conjunto de dados inicial. Não obtivemos uma pontuação muito boa em nosso segundo conjunto de dados (multivariáveis) porque é muito difícil para um conjunto de dados tão complexo seguir uma tendência linear. Para conjuntos de dados como esses, existem algoritmos como “ Regressão polinomial ” ou SVM . Esses algoritmos são um pouco mais complexos, mas alcançam pontuações muito melhores.