Executando verificação de segurança...
5
Leodeymison
7 min de leitura ·

REGRESSÃO LINEAR SIMPLES - Como implementar em qualquer linguagem

graph-linear-regressão-linear

A regressão linear simples é uma espécie de modelo na estatística cujo objetivo é indicar qual será o comportamento de uma variável dependente, quando colocado uma variável independente.

Nesse caso, utilizaremos apenas uma variável independente e uma dependente. Se tivermos mais que uma variável independente utilizaremos a regressão linear múltipla, que veremos em próximos posts.

Ou seja, a regressão linear simples é uma forma de verificar uma possível relação linear entre duas variáveis, como, por exemplo:

Obs: Quanto mais dados você tiver na sua base de dados, mais assertiva será a previsão.


Fórmulas e cálculos (Teoria)

Usaremos uma base de dados fictícia de quantas bactérias foram mortas ao adicionar uma certa quantidade de veneno. Para simplificar nossa compreensão usaremos uma base de dados com apenas 5 linhas.

banco de dados regressão linear


Conceitos:
- Bo = Ponto de encontro com o eixo Y.
- B1 = Inclinação da reta.
- Ŷ = Estimativa de Y.
- Ym = Média de Y.
- Xm = Média de X.
- Σ = Somatório

Fórmula:

Ŷ = Bo + B1 * Xi


Primeiro vamos fazer alguns cálculos com nossa base de dados que vamos precisar.

  • 1. A média da coluna Xi no banco de dados (Xm). Todos os valores dividido pela quantidade de dados. media da coluna x - regressão linear simples

  • 2. A média da coluna Yi no banco de dados (Ym). Todos os valores dividido pela quantidade de dados. media da coluna y - regressão linear simnples

  • 3. A média de (Xi - Xm) * (Yi - Ym). Vamos pensar linha por linha para fazermos esse cálculo. (Xi - Xm) = Pegamos o primeiro valor da coluna Xi e subtraímos pela média de todos os valores da coluna Xi. (Yi - Ym) = Pegamos o primeiro valor da Yi e subtraímos pela média de todos os valores da coluna Yi. logo em seguida multiplicamos os dois resultados. multiplica media - regressão linear simples na tabnews
    Aí fazemos esse mesmo cálculo em todas as outras linhas.Mudando apenas o Xi e Yi em cada linha.
    media-Xim-EYim - Regressão linear simples na tabnews

  • 4. A média de (Xi - Xm)². Como já tiramos esse valor no campo anterior na 3° coluna após o a coluna Yi. Vamos apenas pegar o resultado e elevar ao quadrado. Soma Calculo Final regressão linear simples na tabnews


Vamos dividir a fórmula Ŷ = Bo + B1 * Xi em três parte.

Primeira parte - B1:

formul B1 regressão linear simples na tabnews

Como já temos esses valores nas tabelas acima, vamos apenas substituir pelos os resultados.

formula B1 result - regressão linear simples na tabnews

# B1 = 2,6


Segunda parte - Bo:

B0 = Ym - B1 * Xm

B0 = 8 - 2,6 * 3 (obs: Primeiro multiplica)

Bo = 8 - 7,8

# Bo = 0,2


Agora vamos para o cálculo final: Ŷ = Bo + B1 * Xi

Ŷ = 0,2 + 2,6 * Xi (Esse Xi é a entrada (input) do dado que você quer ver o resultado, vamos colocar um exemplo de “2”)

Ŷ = 0,2 + 2,6 * 2 (Primeiro multiplica)

Ŷ = 0,2 + 5,2

# Ŷ = 5,4


Implementando no JavaScript ( Prática )

Repositório de exemplo: https://github.com/leodeymison/regressao-linear-simples
Obs: Esse exemplo não foi implementado nenhuma arquitetura como Design patterns ou algo tipo, o objetivo é ficar o mais simples possível de entender.

banco de dados test:

const data = [
    { x: 1, y: 3 },
    { x: 2, y: 7 },
    { x: 3, y: 5 },
    { x: 4, y: 11 },
    { x: 5, y: 14 }
]


Primeiro vamos criar uma função com o nome “regressaoLinearSimples” que chamará todas as outras funções e será a função principal. Ele verificará sem o campo de input do html será vazio e chamará nossa primeira função que é a soma de todos os valores da coluna Xi e Yi. 

function RegressionLinearSimples(){
    var valueStart = document.getElementById('valueStart')
    if(valueStart.value == ''){
        return
    }

var somaXY = somaXandY()




}


}


Logo em seguida criaremos a função somaXandY, ela faz um loop pegando valor por valor de X e Y e somando em uma variável somaX e somaY, logo em seguida retorna as duas variáveis: 

function somaXandY(){
    var somaX = 0
    var somaY = 0
    data.forEach(element => {
        somaX += element.x
        somaY += element.y
    });
    return {
        somaX,
        somaY
    }
}


Agora chamaremos a função mediaXY, que fará a media das duas colunas no banco de dados. Essa função recebe dois parâmetros: “Soma da coluna X” e “Soma da coluna Y”, calculada na função anterior. 

function RegressionLinearSimples(){
    var valueStart = document.getElementById('valueStart')
    if(valueStart.value == ''){
        return
    }

var somaXY = somaXandY()
var mediaXY =  mediaXandY(somaXY.somaX, somaXY.somaY)




}


}


Nessa função pegamos a quantidade de linhas de temos no banco de dados e dividiremos pela soma, e logo em seguida retornamos o resultado de mediaX e mediaY 

function mediaXandY(somaX, somaY){
    var quant = data.length
    var mediaX = somaX / quant
    var mediaY = somaY / quant
    return {
        mediaX, mediaY
    }
}


Nessa próxima chamada, chamaremos duas funções passando a média de cada coluna no parâmetro: x_Somatoria = (Xi - Xm) e y_somatoria = (Yi - Ym), o resultado dessas duas funções será os parâmetro da função XXmuiltYs, que é (Xi - Xm) * (Yi - Ym) 

function RegressionLinearSimples(){
    var valueStart = document.getElementById('valueStart')
    if(valueStart.value == ''){
        return
    }

var somaXY = somaXandY()
var mediaXY =  mediaXandY(somaXY.somaX, somaXY.somaY)
var x_Somatoria = x_SomatoriaFunc(mediaXY.mediaX)
var y_Somatoria = y_SomatoriaFunc(mediaXY.mediaY)
var XSmultiYS = XSmultiYSFunc(x_Somatoria, y_Somatoria)




}


}


Nessas duas funções criamos um Array de números fazendo os cálculos linha por linha no banco de dados. (Xi = element.x - Xm = valorMedia) & (Yi = element.y - Xm = valorMedia), logo em seguida retornamos o valor. 

function x_SomatoriaFunc(valorMedia){
    var X_XSOMA = []
    data.forEach(element => {
        X_XSOMA.push(element.x-valorMedia)
    });
    return X_XSOMA
}
function y_SomatoriaFunc(valorMedia){
    var X_XSOMA = []
    data.forEach(element => {
        X_XSOMA.push(element.y-valorMedia)
    });
    return X_XSOMA
}


Nessa função faz um loop (Xi - Xm) multiplicando por (Yi - Ym) e logo em seguida outro loop que soma todos esses resultados, retornamos o resultado das multiplicações que é um Array e a soma desse Array. 

function XSmultiYSFunc(SX, SY){
    var result = []
    for(let i = 0; i < SX.length; i++){
        result.push(SX[i]*SY[i])
    }
    var soma = 0
    result.forEach(element => {
        soma += element
    });
    return {
        values: result,
        soma
    }
}


Vamos chamar a última função RaizXS que tem como parâmetro x_somatoria: a soma de todos os resultados de (Xi - Xm)². 

function RegressionLinearSimples(){
    var valueStart = document.getElementById('valueStart')
    if(valueStart.value == ''){
        return
    }

var somaXY = somaXandY()
var mediaXY =  mediaXandY(somaXY.somaX, somaXY.somaY)
var x_Somatoria = x_SomatoriaFunc(mediaXY.mediaX)
var y_Somatoria = y_SomatoriaFunc(mediaXY.mediaY)
var XSmultiYS = XSmultiYSFunc(x_Somatoria, y_Somatoria)
var VaizXS = VaizXSFunc(x_Somatoria)




}


}


Nessa função faz um loop (Xi - Xm) ² em cada linha e logo depois outro loop fazendo o somatório desses valores, retorna os Array de (Xi - Xm) ² e o valor do Somatório. 

function VaizXSFunc(SX){
    var result = []
    SX.forEach(element => {
        result.push(element*element)
    })
    var soma = 0
    result.forEach(element => {
        soma += element
    });
    return {
        values: result,
        soma
    }
}


Em seguida fazemos os cálculos de B0, B1 e Ŷ, formatamos o Ŷ para ter no máximo 2 número depois da vírgula e imprimimos o valor de Ŷ na página.
Obs: Como os cálculos de B1, Bo e Ŷ são pequenos eu não vi a necessidade de criar uma função para calculá-los, mas se você achar melhor, fique a vontade para criar. 

function RegressionLinearSimples(){
    var valueStart = document.getElementById('valueStart')
    if(valueStart.value == ''){
        return
    }

var somaXY = somaXandY()
var mediaXY =  mediaXandY(somaXY.somaX, somaXY.somaY)
var x_Somatoria = x_SomatoriaFunc(mediaXY.mediaX)
var y_Somatoria = y_SomatoriaFunc(mediaXY.mediaY)
var XSmultiYS = XSmultiYSFunc(x_Somatoria, y_Somatoria)
var VaizXS = VaizXSFunc(x_Somatoria)

var b1 = XSmultiYS.soma/VaizXS.soma
var b0 = mediaXY.mediaY-b1*mediaXY.mediaX

var result = b0 + b1 * parseFloat(valueStart.value)
result = result.toFixed(2)
document.getElementById('preview').innerHTML = `
    ${result} bactérias
`




}


}


O meu objetivo com esse post é fazer com que sua mente se abra para o conhecimento profundo na área de Machine Learning e Big Data, deixando de lado apenas aprender uma biblioteca que já te entrega tudo pronto e aprender a Raiz, para você conseguir criar novas formas revolucionárias de inteligência artificial. Bons estudos! :)


GitHub: https://github.com/leodeymison

Carregando publicação patrocinada...
13
Biridhin

Implementando em Python

Temos uma função do tipo y = a.x + b e como vimos no artigo acima, podemos calcular os coeficientes a e b utilizando um pouco de matemática.

Eu utilizei a função mean do módulo numpy pois me poupou umas 3 linhas a cada vez que precisei calcular a média. Você pode importá-la da seguinte forma:

from numpy import mean

Conforme os dados fictícios do artigo acima.

x = [1, 2, 3, 4, 5]
y = [3, 7, 5, 11, 14]

Podemos em um primeiro momento nos preocupar com o cálculo do coeficiente a. A função descrita abaixo tem esse papel; calculando o somatório da diferença entre o xi e a média através de um laço for.

def calculate_a(x, y):
    x_mean = mean(x)
    y_mean = mean(y)
    
    numerador = denominador = 0
    
    for xi, yi in zip(x, y):
        numerador += (xi - x_mean) * (yi - y_mean)
    for xi in x:
        denominador += (xi - x_mean)**2

    a = numerador / denominador
    
    return a

De maneira similar, podemos calcular o b implementando a fórmula descrita no artigo acima.

def calculate_b(x, y):
    x_mean = mean(x)
    y_mean = mean(y)
    
    a = calculate_a(x, y)
    
    b = y_mean - a * x_mean
    
    return b

A seguir, o código completo, com um input para um X qualquer e um print que escreve na tela a previsão conforme o ajuste linear.

# y = ax + b
from numpy import mean

def calculate_a(x, y):
    x_mean = mean(x)
    y_mean = mean(y)
    
    numerador = denominador = 0
    
    for xi, yi in zip(x, y):
        numerador += (xi - x_mean) * (yi - y_mean)
    for xi in x:
        denominador += (xi - x_mean)**2

    a = numerador / denominador
    
    return a

def calculate_b(x, y):
    x_mean = mean(x)
    y_mean = mean(y)
    
    a = calculate_a(x, y)
    
    b = y_mean - a * x_mean
    
    return b
    
 
x = [1, 2, 3, 4, 5]
y = [3, 7, 5, 11, 14]

a = calculate_a(x, y)
b = calculate_b(x, y)

X = float(input("Quantidade de veneno: "))

result = a * X + b

print(f'Essa quantidade matou {round(result)} bactérias.')

Considerações finais

Muito obrigado pelo conteúdo, Leodeymison. Mal posso esperar pelo próximo artigo sobre regressão linear múltipla.

Peço que você, leitor, implemente em uma liguagem diferente para que possamos ver como fica.

2
2
1
Leodeymison
Autor
Autor

Fico muito inpirado com a ideia de uma plataforma que tem um foco em publicar conteúdos de altíssimo valor, com certeza dedicarei meu tempo para contribuir com artigos melhores que esse para agregar na comunidade.

Obrigado Filipe por investir tanto na transformação de pessoas ;)