Python com ML Básico
Carregando, aguarde alguns segundos.

7 - Regressão

Os modelos de regressão são um conjunto de algoritmos que podem ser usados para prever valores contínuos usando uma função de regressão.

Na contexto da estatística, regressão é um conceito fundamental que se refere a uma técnica utilizada para modelar a relação entre uma variável dependente (também chamada de variável resposta) e uma ou mais variáveis independentes (também chamadas de preditoras ou explicativas). O objetivo da regressão é entender e quantificar como as mudanças nas variáveis independentes estão associadas a mudanças na variável dependente. Em $f(x) = y$, $x$ representa a variável independente e $y$ representa a variável dependente.

Em outras palavras, a regressão busca encontrar uma equação matemática que melhor representa a relação entre as variáveis envolvidas. Essa equação pode ser usada para fazer previsões ou para entender como uma variável está influenciando outra. Existem diferentes tipos de regressão, cada um com suas próprias características e aplicações.

Existem muitos tipos diferentes de modelos de regressão, cada um com seus próprios pontos fortes e fracos.

Alguns dos modelos de regressão mais comuns incluem:

  • Regressão Linear Simples: O modelo da regressão linear simples prevê valores contínuos usando uma linha reta, utilizando uma equação linear para mapear os valores de entrada para os valores de saída. Envolve apenas uma variável independente e uma variável dependente. A equação da regressão linear tenta encontrar a melhor linha reta que se ajusta aos dados para minimizar a soma dos quadrados das diferenças entre os valores observados e os valores previstos pela linha.
  • Regressão Linear Múltipla: Envolve mais de uma variável independente e uma variável dependente. Nesse caso, a equação de regressão tenta encontrar um hiperplano que melhor se ajusta aos dados.
  • Regressão Não-Linear: A regressão não-linear é um modelo que pode prever valores contínuos usando uma função não-linear, o que significa que não pode ser expresso como uma equação linear.
  • Regressão Logística: Usada quando a variável dependente é categórica (por exemplo, sim/não, sucesso/fracasso, 0/1). Ela modela a probabilidade de ocorrência de um evento em relação às variáveis independentes, transformando essa probabilidade usando a função logística. É um modelo mais complexo de regressão não-linear, que prevê valores de saída categóricos usando uma curva logística e confinados a um intervalo limitado, como 0 e 1.
  • Regressão Polinomial: Quando a relação entre as variáveis não é linear, a regressão polinomial é usada para ajustar um polinômio aos dados, permitindo um ajuste mais flexível. Este é um modelo de regressão que usa um polinômio para mapear os valores de entrada para os valores de saída.
  • Regressão de Séries Temporais: Usada para modelar dados que variam ao longo do tempo, como séries temporais econômicas, climáticas etc.
  • Regressão Ridge e Lasso: São técnicas de regularização usadas para evitar sobreajuste (overfitting) e subajuste (underfitting) em modelos de regressão, especialmente quando há muitas variáveis independentes.

Esses são apenas alguns exemplos dos tipos de regressão existentes. A escolha do tipo de regressão depende das características dos dados e do problema específico que se está tentando resolver.

Em resumo, a regressão é uma ferramenta poderosa na estatística que permite analisar e modelar as relações entre variáveis, fazer previsões e entender os padrões subjacentes nos dados.

No contexto de aprendizado de máquina, a regressão é um tipo de estratégia que envolve a construção de um modelo para prever um valor contínuo, sendo treinado com um conjunto de dados que contém valores de entrada e valores de saída. O modelo aprende a mapear e associar os valores de entrada para os valores de saída, para então usado em seguida para prever valores de saída para novos valores de entrada.

O tipo de modelo de regressão mais adequado para um determinado problema depende dos dados disponíveis, do objetivo do aprendizado de máquina e das restrições de recursos.

A regressão é uma ferramenta poderosa que pode ser usada para resolver uma ampla variedade de problemas. Pode ser usado para prever preços, prever vendas, prever probabilidade de sucesso e muito mais.

  • Preços: Previsão do preço futuro de bens e serviços, como imóveis e aluguéis.
  • Vendas: Previsão das vendas de produtos e a correlação entre eles, como itens de supermercado.
  • Risco: Previsão do risco de crédito ou do risco de ocorrência de eventos climáticos.
  • Probabilidade: Previsão da probabilidade de ocorrência de epidemias ou pandemias, como foi o caso da COVID.

As etapas para aplicar a regressão para o aprendizado de máquina são:

flowchart TD F((Início)) F --> |Passo 1|ETL[[ETL]] EXT[Extrair] -.-> ETL C[Coletar] -.-> EXT S[Selecionar] -.-> EXT L[Limpar] -.-> EXT TRA[Transformar] -.-> ETL N[Normalizar] --> TRA CAR[Carregar] -.-> ETL CAR -.-> |MySQL, Oracle, MSSQL|DB[(SQL-DB)] CAR -.-> |Xml, Css, Json|ARQ[(Arquivos)] ETL --> |Passo 2|D[[Dividir]] D --> |Passo 3|TR[[Treinar]] TR --> |Passo 4|TE[[Testar]] TE --> |Passo 5|A[Avaliar] A --> |Passo 6|E{Ajustou?} E -.-> |Não|D E --> |Passo 7 Sim|IMP[[Implantar]] MA[Manter] -.-> IMP ME[Melhorar] -.-> IMP

O passo 1 é coletar, selecionar, limpar e transformar (normalizar, reduzir) os dados que serão usados para treinar o modelo de regressão. Esses dados podem ser coletados de uma variedade de fontes, como pesquisas, formulários, sensores ou outros dispositivos, no ambiente privado de uma empresa ou na internet.

O passo 2 é dividir os dados em dois conjuntos: treinamento e teste. O conjunto de treinamento será usado para treinar o modelo de regressão, enquanto o conjunto de teste será usado para avaliar o desempenho do modelo.

O passo 3 é treinar o modelo de regressão para que aprenda a associar as características de entrada com a saída desejada.

O passo 4 é testar o modelo de regressão, avaliado-se o desempenho do modelo usando-se o conjunto de teste. Isso significa que o modelo será usado para fazer previsões para os dados do conjunto de teste e o desempenho das previsões será comparado aos valores reais.

O passo 5 é avaliar as métricas do modelo de regressão para determinar se os resultados são bons e atendem os requisitos necessários, ou necessitam de ajustes.

O passo 6 é ajustar o modelo de regressão, se necessário, usando-se o conjunto de treinamento e o conjunto de teste. Isso pode envolver o ajuste dos parâmetros do modelo ou a coleta de mais dados.

O passo 7 é implementar em produção o modelo de regressão ajustado, envolvendo o envio do modelo para um servidor ou o uso do modelo em um aplicativo.

7.1 - Regressão Linear Simples

No contexto da estatística, A regressão linear simples é um tipo básico de análise de regressão que envolve uma variável independente e uma variável dependente. O objetivo é encontrar a melhor linha reta que se ajusta aos dados, de modo a minimizar a soma dos quadrados das diferenças entre os valores observados e os valores previstos pela linha. Essa linha é chamada de "linha de regressão" ou "linha de melhor ajuste".

A equação geral da regressão linear simples é dada por: $y = β_0 + β_1 x + ε$, onde $y$ é a variável dependente (variável resposta), $x$ é a variável independente (variável preditora), $β_0$ é o intercepto da linha de regressão, ou seja, o valor de $y$ quando $x$ é igual a zero, $β_1$ é o coeficiente de regressão, que representa a inclinação da linha de regressão, e $ε$ é o termo de erro, que captura as diferenças entre os valores observados e os valores previstos pela linha de regressão. Esses erros são considerados aleatórios e não são explicados pelo modelo.

O objetivo é encontrar os valores de $β_0$ e $β_1$ que minimizem a soma dos quadrados dos resíduos, ou seja, as diferenças entre os valores observados de $y$ e os valores previstos pela equação da linha de regressão.

Existem vários métodos para estimar os coeficientes $β_0$ e $β_1$, sendo o método dos mínimos quadrados o mais comum. Esse método busca minimizar a soma dos quadrados dos resíduos, o que leva a estimativas "melhores" para os coeficientes.

Após estimar os coeficientes, é possível fazer previsões usando a equação da linha de regressão. Além disso, a análise dos coeficientes permite entender como a variável independente está relacionada à variável dependente. O coeficiente $β_0$ representa a mudança esperada na variável dependente para uma unidade de mudança na variável independente, mantendo todas as outras variáveis constantes.

É importante notar que a regressão linear simples pressupõe certas suposições, como a linearidade da relação entre as variáveis e a normalidade dos resíduos. Se essas suposições não forem atendidas, os resultados da regressão podem ser menos confiáveis.

Em resumo, a regressão linear simples é uma técnica estatística fundamental para modelar a relação entre duas variáveis e fazer previsões com base nessa relação linear.

A regressão linear é uma boa escolha para problemas em que a relação entre as variáveis de entrada e saída é linear.

Exemplo: Preço de Aluguéis de Imóveis

Este código cria e treina um modelo de regressão linear para prever o preço de uma casa com base na área e idade do interessado.

Importe as bibliotecas necessárias. 

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.datasets import load_boston

Carregue os dados do conjunto de dados Boston Housing. 

boston = load_boston()

Imprima os nomes das colunas do conjunto de dados. 

print(boston.feature_names)

Use a função np.set_printoptions() para imprimir os dados com 2 casas decimais e suprimir a notação científica com o numpy. 

np.set_printoptions(suppress=True, precision=2)

Também importe a biblioteca tabulate para imprimir os dados no formato de tabela com estilo. 

from tabulate import tabulate

Imprima as 10 primeiras linhas do conjunto de dados. 

print(tabulate(boston.data[0:10], tablefmt='pretty', headers=boston.feature_names, floatfmt='.2f'))

Imprima as 10 primeiras linhas de alvos do conjunto de dados. 

print(boston.target[0:10])

Use o método train_test_split() do sklearn.model_selection para dividir os dados em um conjunto de treino e um conjunto de teste. 

dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(boston.data, boston.target, test_size=0.2)

Imprima as 10 primeiras linhas do conjunto de dados de dados_treino: 

print(tabulate(dados_treino[0:10], tablefmt='pretty', headers=boston.feature_names, floatfmt='.2f'))

Imprima as 10 primeiras linhas do conjunto de dados de alvos_treino: 

print(alvos_treino[0:10])

Imprima as 10 primeiras linhas do conjunto de dados de dados_teste: 

print(tabulate(dados_teste[0:10], tablefmt='pretty', headers=boston.feature_names, floatfmt='.2f'))

Imprima as 10 primeiras linhas do conjunto de dados de alvos_teste: 

print(alvos_teste[0:10])

Crie um modelo de regressão linear. 

reglin = LinearRegression()

Treine o modelo no conjunto de treino. 

reglin.fit(dados_treino, alvos_treino)

Faça previsões no conjunto de teste. 

y_pred = reglin.predict(dados_teste)

Avalie o desempenho do modelo. 

escore = r2_score(alvos_teste, y_pred)

Imprima o desempenho. 

print(f"Escore R2: {escore:.4f}")

O modelo tem um Escore R2 de aproximadamente 0,71; ou seja, é capaz de identificar em torno de 71% da variação do preço das casas no conjunto de teste.

Agora, vamos usar o modelo para fazer uma previsão para uma casa com a média dos valores do conjunto de dados boston.data.

O argumento axis=0 do método mean() retorna a média de cada coluna do conjunto de dados.

Calcule e imprima os valores médios das colunas. 

media = [boston.data.mean(axis=0)]

Calcule e imprima a previsão. 

previsao = reglin.predict(media)
print(f"Primeira Previsão: {previsao[0]:.4f}")

7.2 - Regressão Linear Múltipla

A regressão linear múltipla é uma extensão da regressão linear simples, que permite modelar a relação entre uma variável dependente e duas ou mais variáveis independentes. É usada quando a relação entre a variável dependente e as variáveis independentes não pode ser adequadamente representada por uma única variável preditora.

A equação geral da regressão linear múltipla é semelhante à da regressão linear simples, mas agora envolve vários coeficientes de regressão para cada variável independente:

$y = β_0 + β_1 x_1 + β_2 x_2 + ... + β_n x_n + ε$, onde $y$ é a variável dependente (variável resposta), $x_1$, $x_2$,...,$x_n$ são as variáveis independentes (variáveis preditoras), $β_0$ é o intercepto da linha de regressão, $β_1$ é o coeficiente de regressão para $x_1$, $β_2$ é o coeficiente de regressão para $x_2$, e assim por diante, e $ε$ é o termo de erro.

O processo para realizar uma regressão linear múltipla é semelhante ao da regressão linear simples:

  • Coleta de Dados: Obtenha os dados para a variável dependente e as variáveis independentes.
  • Estimação dos Coeficientes: Use um método de estimação, como os mínimos quadrados, para encontrar os valores dos coeficientes que minimizam a soma dos quadrados dos resíduos.
  • Interpretação dos Coeficientes: Analise os coeficientes de regressão para entender como cada variável independente está relacionada à variável dependente. O coeficiente $β_j$ representa a mudança esperada em $y$ para uma unidade de mudança em $x_j$, mantendo todas as outras variáveis constantes.
  • Avaliação do Modelo: Avalie a qualidade do modelo usando medidas como o coeficiente de determinação ($\bar{R}^2$) e análise dos resíduos para verificar se as suposições do modelo estão sendo atendidas.
  • Previsões: Com o modelo ajustado, é possível fazer previsões para novos conjuntos de valores das variáveis independentes.

7.3 - Regressão Não-Linear

A regressão não-linear é um modelo que pode prever valores contínuos usando uma função não linear, é uma boa escolha para problemas em que a relação entre as variáveis de entrada e saída não é linear.

A equação para a regressão não linear é a seguinte: $y = f(x)$, onde $f(x)$ é uma função não linear, $x$ é a variável de entrada (independente) e $y$ é a variável de saída (dependente).

O tipo de modelo de regressão mais adequado para um determinado problema depende dos dados disponíveis, do objetivo do aprendizado de máquina e das restrições de recursos.

7.4 - Regressão Logística

A regressão logística é um modelo mais complexo que prevê valores categóricos usando uma curva logística.

A equação para a regressão logística é: $p(y = 1) = \frac{1}{1 + e^{-(ax + b)}}$, onde $p(y = 1)$ é a probabilidade de y ser igual a 1, $y$ é a variável de saída, $x$ é a variável de entrada, $a$ é a inclinação da linha e $b$ é o intercepto da linha.

A regressão logística é uma boa escolha para problemas em que a variável de saída é categórica, como "sim" ou "não".

Exemplo: Regressão Logística Médica Oncológica

Este código cria um modelo de regressão logística que pode ser usado para prever se um paciente tem câncer com base em seus resultados de exame.

Importe as bibliotecas necessárias. 

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer

Carregue os dados do conjunto de dados Breast Cancer. 

cancer_mama = load_breast_cancer()

Imprima as dimensoes dos dados e dos alvos classificadores do conjunto de dados. 

print("Dimensões do conjunto de dados: ", cancer_mama.data.shape)
print("Dimensões do conjunto de alvos: ", cancer_mama.target.shape)

Imprima os nomes das colunas do conjunto de dados cancer_mama.data. 

print(cancer_mama.feature_names)

Use a função np.set_printoptions() para imprimir os dados com 2 casas decimais e suprimir a notação científica. 

np.set_printoptions(suppress=True, precision=2)

Imprima os dados do conjunto de dados. 

print(cancer_mama.data)

Imprima os nomes das colunas do conjunto de alvos dos dados cancer_mama.target. 

print(cancer_mama.target_names)

Imprima os alvos do conjunto de dados. 

print(cancer_mama.target)

Separe os dados em um conjunto de treino e um conjunto de teste. 

dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(cancer_mama.data, cancer_mama.target, test_size=0.2)

Imprima dados_treino: 

print(dados_treino)

Imprima alvos_treino: 

print(alvos_treino)

Imprima dados_teste: 

print(dados_teste)

Imprima alvos_teste: 

print(alvos_teste)

Crie um modelo de regressão logística. 

logreg = LogisticRegression()

Treine o modelo no conjunto de treino. 

logreg.fit(dados_treino, alvos_treino)

Faça previsões no conjunto de teste. 

previsoes_teste = logreg.predict(dados_teste)

Imprima as previsões do modelo. 

print(previsoes_teste)

Avalie o desempenho do modelo. 

escore_acuracia = accuracy_score(alvos_teste, previsoes_teste)

Imprima o desempenho do modelo. 

print(f"Escore acurácia: {escore_acuracia:.4f}")

O modelo tem uma acurâcia de aproximadamente 0,93. Isso significa que ele pode prever com 93% de precisão se um paciente tem câncer.

Como você pode ver, o modelo é muito preciso. Isso ocorre porque o aprendizado de máquina pode ser usado para identificar padrões em dados que seriam difíceis ou impossíveis de identificar para humanos.

Traduções:

  • mean radius: raio médio
  • mean texture: textura média
  • mean perimeter: perímetro médio
  • mean area: área média
  • mean smoothness: significa suavidade
  • mean compactness: média compactação
  • mean concavity: média concavidade
  • mean concave points: pontos côncavos médios
  • mean symmetry: simetria média
  • mean fractal dimension: dimensão fractal média
  • radius error: erro de raio
  • texture error: erro de textura
  • perimeter error: erro de perímetro
  • area error: erro de área
  • smoothness error: erro de suavidade
  • compactness error: erro de compactação
  • concavity error: erro de concavidade
  • concave points error: erro de pontos côncavos
  • symmetry error: erro de simetria
  • fractal dimension error: erro de dimensão fractal
  • worst radius: pior raio
  • worst texture: pior textura
  • worst perimeter: pior perímetro
  • worst area: pior área
  • worst smoothness: pior suavidade
  • worst compactness: pior compactação
  • worst concavity: pior concavidade
  • worst concave points: pior pontos côncavos
  • worst symmetry: pior simetria
  • worst fractal dimension: pior dimensão fractal

Agora, vamos usar o modelo para fazer uma previsão para um paciente com os seguintes resultados de exame com a média das colunas: 

previsao = logreg.predict([cancer_mama.data.mean(axis=0)])
print(previsao)

Agora, use o modelo de regressão logística com um novo conjunto de dados usando apenas os 10 primeiros campos: raio médio, textura média, perímetro médio, area média, suavidade média, compactação média, concavidade média, pontos côncavos médios, simetria média e dimensão fractal média.

Vamos criar o novo conjunto de dados com as dez primeiras colunas. 

import pandas as pd
cancer_mama_novo = cancer_mama.data[:,:10]
dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(cancer_mama_novo.data, cancer_mama_novo.target, test_size=0.2)

Imprima os dados de treino: 

print(dados_treino)

Imprima os alvos treino: 

print(alvos_treino)

Imprima os dados de teste: 

print(dados_teste)

Imprima os alvos de teste: 

print(alvos_teste)

Crie um modelo de regressão logística. 

logreg = LogisticRegression()

Treine o modelo no conjunto de treino. 

logreg.fit(dados_treino, alvos_treino)

Faça previsões no conjunto de teste. 

previsoes_teste = logreg.predict(dados_teste)

Imprima as previsões de teste do modelo. 

print(previsoes_teste)

Avalie o desempenho do modelo. 

escore_acuracia = accuracy_score(alvos_teste, previsoes_teste)

Imprima o desempenho do modelo. 

print(f"Escore acurácia: {escore_acuracia:.4f}")

Agora, vamos usar o modelo para fazer uma previsão para um paciente com os seguintes resultados de exame com a média das colunas. 

previsao = logreg.predict([cancer_mama_novo.data.mean(axis=0)])

imprima a previsão. 

print(previsao)

A previsão é de que o paciente tenha câncer.

Faça agora a previsão para um paciente com os seguintes resultados de exame, em uma pesquisa com valores independentes.

  • Raio médio: 18.420
  • Textura média: 10.678
  • Perimetro medio: 122.800
  • Area média: 1051.100
  • Suavidade média: 148.500
  • Compactação média: 0,1184
  • Concavidade média: 0,2778
  • Pontos côncavos médios: 0,0714
  • Simetria média: 0,2449
  • Dimensão fractal média: 0,0797

Atribua os valores a variáveis, para melhorar a legibilidade e o entendimento. 

rm = 18.420
tm = 10.678
pm = 122.800
am = 1051.100
sm = 148.500
cpm = 0.1184
cnm = 0.2778
pcm = 0.0714
smm = 0.2449
dfm = 0.0797

Preveja o resultado com as variáveis nas ordens das colunas no conjunto de dados. 

previsao = logreg.predict([[rm, tm, pm, am, sm, cpm, cnm, pcm, smm, dfm]])
# previsao = logreg.predict([[18.420, 10.678, 122.800, 1051.100, 148.500, 0.1184, 0.2778, 0.0714, 0.2449, 0.0797]])
print(previsao)

A previsão é de que o paciente tenha câncer.

7.5 - Regressão Ridge

A regressão Ridge é uma técnica valiosa de aprendizado de máquina que lida com o problema de multicolinearidade, onde as variáveis independentes em um modelo de regressão estão altamente correlacionadas.

O cálculo do Erro Quadrático Médio (MSE) nos fornece uma medida da qualidade das previsões do modelo, enquanto a análise dos coeficientes estimados ajuda a entender quais variáveis independentes têm mais impacto nas previsões.

No exemplo a seguir, utilizamos a regressão Ridge para criar e ajustar um modelo com base em dados sintéticos.

O objetivo é prever uma variável dependente a partir de duas variáveis independentes.

Além disso, introduzimos um fator de regularização, o parâmetro alpha, que controla a força da penalização aplicada aos coeficientes do modelo.

Exemplo: Regressão Ridge com Dados Aleatórios

Vamos avaliar o desempenho do modelo e examinar os coeficientes estimados. 

import numpy as np
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error

# Criação de dados sintéticos
X, y = make_regression(n_samples=100, n_features=2, noise=0.5, random_state=42)

# Divisão dos dados em conjunto de treinamento e teste
X_treino, X_teste, Y_treino, Y_teste = train_test_split(X, y, test_size=0.2, random_state=42)

# Criação e ajuste do modelo de regressão Ridge
alpha = 1.0  # Fator de regularização (lambda)
regrid = Ridge(alpha=alpha)
regrid.fit(X_treino, Y_treino)

# Fazendo previsões no conjunto de teste
alvos_previstos = regrid.predict(X_teste)

# Avaliação do modelo
mse = mean_squared_error(Y_teste, alvos_previstos)
print(f'Erro Quadrático Médio: {mse}')

# Coeficientes estimados pelo modelo
print('Coeficientes:', regrid.coef_)
print('Interceptação:', regrid.intercept_)

A regressão Ridge é uma ferramenta poderosa para lidar com problemas de multicolinearidade em modelos de regressão.

Neste exemplo, demonstramos como aplicá-la a um conjunto de dados sintéticos, destacando a importância do fator de regularização (alpha) na busca por um equilíbrio entre ajuste excessivo e subajuste.

O Erro Quadrático Médio (MSE) é uma medida que quantifica o quão bem um modelo de regressão está fazendo suas previsões, calculando a média dos quadrados das diferenças entre os valores reais (Y_teste) e os valores previstos (y_pred) pelo modelo. Quanto menor o valor do MSE, melhor o desempenho do modelo, pois indica que as previsões estão mais próximas dos valores reais. No exemplo, o MSE de 2,229 significa que, em média, os quadrados das diferenças entre as previsões do modelo e os valores reais são iguais a 2,229. Isso sugere que o modelo tem um desempenho razoavelmente bom em fazer previsões para os dados de teste, embora a interpretação exata dependa do contexto do problema. Para um contexto específico, é importante comparar o MSE do modelo com o de outros modelos ou benchmarks para avaliar seu desempenho relativo.

Os coeficientes (ou pesos) são os valores associados a cada variável independente no modelo de regressão. Eles representam o impacto que cada variável tem nas previsões. No caso da regressão Ridge, esses coeficientes são penalizados pela adição de um termo de regularização (controlado pelo parâmetro alpha). Isso ajuda a evitar coeficientes excessivamente grandes, o que pode levar ao overfitting. No exemplo, os coeficientes estimados são 86.31 e 73.18 para as duas variáveis independentes. Isso significa que, para uma unidade de aumento em cada variável independente, o modelo prevê um aumento de 86.31 unidades na variável dependente, mantendo as outras variáveis constantes. Portanto, os coeficientes indicam a magnitude e a direção da influência de cada variável nas previsões.

A interceptação (ou termo de intercepção) é o valor da variável dependente quando todas as variáveis independentes são iguais a zero. Em alguns contextos, isso pode não ter um significado prático, mas é uma parte importante do modelo de regressão. No exemplo, a interceptação é aproximadamente -0,178. Isso significa que, quando todas as variáveis independentes são iguais a zero, o modelo prevê um valor próximo a -0,178 para a variável dependente. Em muitos casos, essa interpretação direta da interceptação pode não fazer sentido, mas ela contribui para o cálculo das previsões.

Lembre-se de que a interpretação específica dos coeficientes pode variar dependendo do contexto do problema e da escala das variáveis. Também é importante notar que a interpretação exata pode ser mais complexa em modelos de regressão múltipla com várias variáveis independentes, pois os coeficientes representam o efeito isolado de cada variável mantendo todas as outras constantes. Portanto, a interpretação precisa deve ser adaptada ao problema em questão.

A regressão Ridge é uma técnica valiosa em análise de dados e aprendizado de máquina, especialmente quando lidamos com conjuntos de dados complexos e altamente correlacionados.

7.6 - Exemplos

São apresentados quatro exemplos:

  • Regressão Logistica: Vinho com o Dataset Wine
  • Regressão Logistica: Flores com o Dataset Iris
  • Regressão Logística: Textos com o Dataset Digits
  • Regressão Logistica: Valores Aleatórios

São exemplos usando os modelos de regressão logistica e regressão logistica, para você familiarizar-se mais com os conceitos desses modelos de algoritmos.

7.6.1 - Regressão Logistica: Dataset Wine

A regressão logistica é uma técnica fundamental no campo da aprendizagem de máquina, frequentemente utilizada para modelar relacionamentos entre variáveis.

Neste exemplo, usamos a regressão logistica para prever a qualidade do vinho com base em atributos específicos.

Os dados do vinho, que incluem características como teor alcoólico, acidez e outros, são divididos em conjuntos de treinamento e teste.

O modelo é treinado no conjunto de treinamento e, em seguida, usado para fazer previsões sobre a qualidade do vinho no conjunto de teste.

Avaliamos o desempenho do modelo usando a métrica R2, que mede o quão bem as previsões se ajustam aos valores reais.

Este exemplo ilustra a aplicação simples, mas eficaz, da regressão logistica em um contexto do mundo real.

Importe as bibliotecas necessárias. 

import sklearn
from tabulate import tabulate
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn.datasets import load_wine

Carregue os dados do vinho 

vinho = load_wine()

Imprima as linhas e colunas dos dados e alvos do conjunto vinho. 

print("Dados:", vinho.data.shape)
print("Alvos:", vinho.target.shape)

Imprima os nomes das colunas do conjunto de dados. 

print(vinho.feature_names)

Use a função np.set_printoptions() para imprimir os dados com 2 casas decimais e suprimir a notação científica. 

np.set_printoptions(suppress=True, precision=2)

Imprima as 10 primeiras linhas do conjunto de dados. 

print(tabulate(vinho.data[0:10], tablefmt='fancy_grid', floatfmt=".2f"))

Imprima os nomes das colunas dos alvos do conjunto de dados. 

print(vinho.target_names)

Imprima os alvos do conjunto de dados. 

print(vinho.target)

Avalie e imprima os balanceamento dos dados a partir dos alvos. 

valores_unicos, contagens = np.unique(vinho.target, return_counts=True)

Agora, valores_unicos contém os valores únicos e contagens contém as contagens correspondentes

Imprima os valores únicos das classes e as contagens. 

for valor, contagem in zip(valores_unicos, contagens):
    print(f'Classe [{valor}]: {contagem} ocorrências')

Separe os dados em dois conjuntos: um conjunto de treino e um conjunto de teste. 

dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(vinho.data, vinho.target, test_size=0.2)

Imprima as dimensões dos conjuntos. 

print("Dados de treino:", dados_treino.shape)
print("Alvos de treino:", alvos_treino.shape)
print("Dados de teste:", dados_teste.shape)
print("Alvos de teste:", alvos_teste.shape)

Imprima as 10 primeiras linhas dos dados de treino. 

print(tabulate(dados_treino[0:10], tablefmt='fancy_grid', floatfmt=".2f"))

Imprima os alvos de treino. 

print(alvos_treino)

Imprima as 10 primeiras linhas dos dados de teste. 

print(tabulate(dados_teste[0:10], tablefmt='fancy_grid', floatfmt=".2f"))

Imprima os alvos de teste. 

print(alvos_teste)

Crie um modelo de regressão logistica. 

reglin = LogisticRegression()

Treine o modelo com os dados e alvos do conjunto de treino. 

reglin.fit(dados_treino, alvos_treino)

Faça as previsões com os dados do conjunto de teste. 

alvos_previstos = reglin.predict(dados_teste)

Imprima as previsões do modelo. 

print(alvos_previstos)

Avalie o desempenho do modelo 

escore = reglin.score(dados_teste, alvos_previstos)

Imprima o desempenho do modelo 

print('R2:', escore)

Aplicamos a técnica de regressão logistica para prever a qualidade do vinho com base em seus atributos.

A métrica R2 nos fornece uma medida do desempenho do modelo, permitindo-nos avaliar quão bem as previsões se aproximam dos valores reais.

À medida que avançamos no campo do aprendizado de máquina, é importante entender e apreciar as técnicas fundamentais, como a regressão logistica, que formam a base para algoritmos mais complexos e soluções de análise de dados.

Esse exemplo demonstra como a regressão logistica pode ser aplicada de forma eficaz para resolver problemas do mundo real, fornecendo uma base sólida para a exploração adicional de técnicas de aprendizado de máquina.

7.6.2 - Regressão Logística: Dataset Iris

Este código tenta prever se uma flor é uma rosa ou um girassol com base na quantidade de pétalas que ela tem.

Importe as bibliotecas necessárias. 

# Importe as bibliotecas necessárias.
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_iris

Carregue os dados do conjunto de dados Iris. 

iris = load_iris()

Separe os dados em um conjunto de treino e um conjunto de teste. 

dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(iris.data, iris.target, test_size=0.2)

Crie um modelo de regressão logística. 

logreg = LogisticRegression()

Treine o modelo no conjunto de treino. 

logreg.fit(dados_treino, alvos_treino)

Faça previsões no conjunto de teste. 

alvos_previstos = logreg.predict(dados_teste)

Avalie o desempenho do modelo. 

acuracia = accuracy_score(alvos_teste, alvos_previstos)
print(f"Acurácia: {acuracia:.4f}")

O modelo tem uma precisão de 0,9333. Isso significa que ele pode prever com 93,33% de precisão se uma flor é uma rosa ou um girassol.

Como você pode ver, o modelo não é muito preciso. Isso ocorre porque a quantidade de pétalas que uma flor tem não é um bom indicador de sua espécie.

Existem muitas outras características que são mais importantes, como a cor das pétalas, o formato das pétalas e o tamanho da flor.

7.6.3 - Regresão Logística: Dataset Digits

Este código usa a biblioteca Scikit-Learn para treinar um modelo de regressão logística visando prever a classificação de digitos, usando o conjunto de dados Digits.

Importe as bibliotecas necessárias. 

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_digits

Carregue os dados do conjunto de dados Digits. 

digitos = load_digits()

Separe os dados em um conjunto de treino e um conjunto de teste. 

dados_treino, dados_teste, alvos_treino, alvos_teste = train_test_split(digitos.data, digitos.target, test_size=0.2)

Crie um modelo de regressão logística. 

clf = LogisticRegression()

Treine o modelo no conjunto de treino. 

clf.fit(dados_treino, alvos_treino)

Faça previsões no conjunto de teste. 

alvos_previstos = clf.predict(dados_teste)

Avalie o desempenho do modelo. 

acuracia = accuracy_score(alvos_teste, alvos_previstos)

Imprima a acurácia do modelo. 

print(f"Acurácia: {acuracia:.4f}")

O modelo tem uma precisão de 0,97 em uma escala de 0 a 1, que significa que pode prever corretamente aproximadamente 97% dos digitos.

7.6.4 - Regressão Logística: Valores Aleatórios

Este código carrega um conjunto de dados de classificação de valores aleatórios e treina um modelo de regressão logística para prever se uma pesquisa de valores aleatórios é boa ou ruim. 

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

Cria um DataFrame com 1000 linhas e 10 colunas. 

df = pd.DataFrame(np.random.randn(1000, 10))

Adicione uma coluna de rótulos. 

df['rotulos'] = np.random.randint(0, 2, 1000)

Separe os dados em treino e teste. 

X_train, X_test, y_train, y_test = train_test_split(df.drop('rotulos', axis=1), df['rotulos'], test_size=0.2)

Treine o modelo. 

clf = LogisticRegression()

Treine o modelo com os dados de treino. 

clf.fit(X_train, y_train)

Faça previsões para os dados de teste 

y_pred = clf.predict(X_test)

Avalie o desempenho do modelo. 

escore = clf.score(X_test, y_test)
#escore = accuracy_score(y_test, y_pred)

Imprima a acurácia do modelo. 

print('Acurácia:', escore)

O modelo é então avaliado em um conjunto de dados de teste e obtém uma acurácia de 95%.

Este é apenas um exemplo simples de como o aprendizado de máquina pode ser usado para resolver problemas do mundo real.

O aprendizado de máquina pode ser usado para resolver uma ampla variedade de problemas, incluindo classificação, regressão e agrupamento.

À medida que o campo de aprendizado de máquina continua a evoluir, ele se tornará cada vez mais importante na solução dos problemas mais desafiadores do mundo.

7.7 - Projeto Avançado: Fraude Financeira

Este tutorial discutirá a detecção de fraude de cartão de crédito usando regressão logística em aprendizado de máquina usando Python.

Usaremos o módulo de aprendizado de máquina Scikit-Learn.

Este projeto informa sobre os dados fornecidos e se esta transação é uma transação verdadeira ou uma transação fraudulenta.

O conjunto de dados contém transações feitas por cartões de crédito em setembro de 2013 por titulares de cartões europeus.

Este conjunto de dados apresenta transações ocorridas em dois dias, onde temos 492 fraudes em 284.807 transações.

O conjunto de dados é altamente desbalanceado, a classe positiva (fraudes) responde por 0,172% de todas as transações.

Ele contém apenas variáveis ​​de entrada numéricas que são o resultado de uma transformação PCA.

Infelizmente, devido a questões de confidencialidade, não podemos fornecer os recursos originais e mais informações básicas sobre os dados.

As características V1, V2, … V28 são os principais componentes obtidos com PCA, as únicas características que não foram transformadas com PCA são 'Time' e 'Amount'.

O recurso 'Tempo' contém os segundos decorridos entre cada transação e a primeira transação no conjunto de dados.

O recurso 'Valor' é o valor da transação, esse recurso pode ser usado para aprendizado sensível ao custo dependente de exemplo.

A característica 'Classe' é a variável de resposta e assume valor 1 em caso de fraude e 0 caso contrário.

Dada a taxa de desequilíbrio de classe, recomendamos medir a precisão usando a Área sob a Curva de Rechamada de Precisão (AUPRC).

A precisão da matriz de confusão não é significativa para a classificação desbalanceada.

Você pode baixar o conjunto de dados aqui os dados de crédito.

Importar

Importe as bibliotecas Python necessárias: 

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

Dados

A primeira etapa é a de coleta de dados: 

dados_credito  =pd.read_csv("creditcard.csv").round(2)

Para checar se o conjunto de dados está carregado ou não imprima as primeiras cinco linhas usando o método head. 

print(dados_credito.head())

Agora imprimimos as últimas cinco linhas usando o método tail. 

print(dados_credito.tail())

Lembre-se sempre desse ponto sempre quando trabalhar em problemas de aprendizado de máquina que precisam explorar os dados.

Imprimimos as informações do conjunto de dados: 

print(dados_credito.info())

Todos os valores são numéricos e inteiros, então o computador pode ler facilmente o conjunto de dados.

Verificamos se há algum valor ausente no conjunto de dados: 

print(dados_credito.isnull().sum())

Não há valores ausentes no conjunto de dados, sendo desnecessário adicionarmos os valores da média e da mediana.

Verificamos quantos zeros e uns são presentes no conjunto de dados:

O valor 0 (zero) representa transações verdadeiras, e 1 (um) representa uma transação fraudulenta no conjunto de dados. 

print(dados_credito['Class'].value_counts())

Verificamos que somente 492 (um) e 284315 (zero) estão presentes no conjunto de dados.

Separamos os dados para análise: 

legitimo=dados_credito[dados_credito.Class==0]
fraude=dados_credito[dados_credito.Class==1]
print(legitimo.shape)
print(fraude.shape)

Balanceamento

O conjunto de dados é extremamente desbalanceado.

Se enviarmos o conjunto de dados diretamente para previsão, o desempenho será muito baixo.

Tratamos os dados desbalanceados. A partir do conjunto de dados retiramos 492 zeros e assim todos os valores ficam balanceados.

Imprimimos a estatísticas de dados: 

print(legitimo.Amount.describe().round(2))

Verifique a informação fraudulenta: 

print(fraude.Amount.describe().round(2))

Existem muita diferença entre os valores médios dos dois conjuntos de dados.

Comparação das médias

Comparamos os valores para ambas os transações: 

print(dados_credito.groupby('Class').mean().round(2))

Há uma diferença entre os dois conjuntos de dados e com isso determinamos se é uma transação fraudulenta ou uma transação verdadeira

Subamostragem

Criamos um conjunto de dados com uma distribuição similar entre transações verdadeiras e fraudulenta. 

amostra_legitima = legitimo.sample(n=len(fraude))

Concatenamos os dois conjuntos de dados. 

novo_dataset = pd.concat([amostra_legitima,fraude],axis=0)

Checamos se o novo conjunto de dados está carregado ou não imprimindo as primeiras cinco linhas usando o método head. 

print(novo_dataset.head())

Agora imprimimos as últimas cinco linhas usando o método tail. 

print(novo_dataset.tail())

Verificamos quantas classes estão presentes no conjunto de dados 

print(novo_dataset['Class'].value_counts())

Verifique a diferença média entre os dois conjuntos de dados 

print(novo_dataset.groupby('Class').mean().round(2))

Verificamos que a diferença média entre os dois conjuntos de dados é reduzida nos valores. A diferença média é como calculamos agora. 

# dividir os dados em recursos e destino
X=novo_dataset.drop(columns='Class',axis=1)
Y=novo_dataset['Class']
print(X)

Agora imprimimos os valores de Y. 

print(Y)

Separamos os dados de treino e teste. 

dados_treino, dados_teste, alvos_treino, alvos_teste=train_test_split(X,Y,test_size=0.2,stratify=Y,random_state=2)
print(X.shape,dados_treino.shape,dados_teste.shape)

Seleção do modelo

Treinamos o modelo. 

modelo = LogisticRegression()
print(modelo)

Treinamento do modelo

Treinamos o modelo de regressão logística com o conjunto de treino. 

modelo.fit(dados_treino,alvos_treino)

Predição

imprimimos a acurâcia do modelo de avaliação com o próprio conjunto de dados de treino. 

predicao_alvos_treino = modelo.predict(dados_treino)
acuracia_dados_treinamento = accuracy_score(predicao_alvos_treino,alvos_treino)
print(f"Acurâcia com o conjunto de treino: {acuracia_dados_treinamento:.2f}")

imprimimos a acurácia com o conjunto de teste. 

previsao_dados_teste = modelo.predict(dados_teste)
acuracia_dados_teste = accuracy_score(previsao_dados_teste,alvos_teste)
print(f"Acurâcia com o conjunto de teste: {acuracia_dados_teste:.2f}")

O valor de acuração para cada conjunto de treino e teste é superior a 90% então esse algoritmo é adequado para detecção de fraude de cartão de crédito.

Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python com ML Básico || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (Introdução ao ML) | Fundamentos (Programação, dados, modelos, algoritmos, tipos, treinamento, teste, avaliação e Métricas, generalização, engenharia de características, viés (bias) e interpretabilidade, tamanho do conjunto de dados, hiperparâmetros) | Python (Scikit-Learn, TensorFlow, Keras, PyTorch, XGBoost, LightGBM, Pandas, Numpy, Seaborn, Matplotlib) | Dados (Dados) | Modelos e Algoritmos (Modelos e Algoritmos) | Avaliação dos Modelos (Avaliação dos Modelos) | Regressão (Regressão) | Classificação (Classificação) | Tipos (Tipos) | Aprendizado Supervisionado (Aprendizado Supervisionado) | Aprendizado Não Supervisionado (Aprendizado Não Supervisionado) | Aprendizado por Reforço (Aprendizado por Reforço) | ML Profundo (Aprendizado profundo) |