Ciência de Dados Inteligência Artificial Programação Tutorial , , , , ,

Aprendizado Supervisionado: Regressão Linear Simples e Múltipla

Na área de machine learning, as técnicas de aprendizado supervisionado são aquelas que buscam prever ou representar relações entre uma ou mais variáveis de entrada ( X ) e uma variável de saída ( y ). De acordo com Belcic e Stryker (2026, online), o “aprendizado supervisionado é uma técnica (…) que usa conjuntos de dados rotulados para treinar modelos de inteligência artificial (IA) para identificar os padrões e as relações subjacentes”.

Para ler mais sobre aprendizado supervisionado, leia o artigo clicando aqui.

Nessa subcategoria da área de machine learning, existem inúmeras opções de técnicas e algoritmos. Dentre elas há uma chamada Regressão Linear, que é o foco deste artigo.

O que é a Regressão Linear?

A Regressão Linear é uma técnica estatística e de aprendizado supervisionado usada para modelar a relação entre uma variável de saída, chamada variável dependente, e uma ou mais variáveis de entrada, chamadas variáveis independentes ou explicativas.

Em outras palavras, a regressão linear procura responder a perguntas do tipo: “dado o tamanho de uma casa, qual seria seu preço esperado?” ou “dadas as horas de estudo, qual nota um estudante tende a obter?”. A ideia da técnica de regressão é ajustar um modelo que represente da melhor forma possível a relação entre entrada e saída.

Segundo Montgomery, Peck e Vining (2012), a regressão linear é uma das técnicas mais importantes da estatística aplicada porque permite investigar, explicar e prever fenômenos quantitativos. Em aprendizado de máquina, Hastie, Tibshirani e Friedman (2009) destacam que a regressão linear continua sendo uma referência válida por sua simplicidade, interpretabilidade e base conceitual para modelos mais complexos.

Tipos de regressão linear

Exsitem dois tipos de regressão linear: a simples e a múltipla. A diferença entre elas está na quantidade de variáveis independentes (ou explicativas).

Regressão Linear Simples

Na regressão linear simples, há apenas uma variável explicativa (X) que serve como entrada no algoritmo. Neste caso, o modelo para tentar obter a saída (ou seja, a variável dependente y) pode ser escrito como a equação de uma reta no plano:

y=β0+β1x+ϵ y = \beta_{0} + \beta_{1}x + \epsilon

onde:

  • yy é o valor que se deseja prever
  • xx é a variável de entrada
  • β0\beta_{0}​ é o intercepto (o valor de yy quando XX é 0)
  • β1\beta_{1}​ é o coeficiente angular da reta (o quanto yy muda para cada unidade de aumento em XX).
  • ϵ\epsilon representa o erro aleatório, que é uma parte da realidade que o modelo não conseguiu explicar (ou seja, é o erro que sabemos e aceitamos que existe).

Como a regressão linear simples trabalha com apenas duas variáveis (a entrada e a saída), o modelo resultante é uma reta plotada (desenhada) em um plano 2D.

Essa técnica pode ser utilizada em vários tipos de contextos como a área de vendas e marketing, ao tentar-se estimar o lucro futuro ( y ) com base apenas no valor investido em publicidade ( X ), ou a área de saúde e esportes, quando se busca avaliar o impacto da dosagem de um medicamento ( X ) na pressão arterial ( y ).

Regressão Linear Múltipla

O outro tipo é a regressão linear múltipla, que envolve duas ou mais variáveis independentes (X). Nestes casos, o modelo tenta explicar a variável dependente (y) utilizando múltiplos fatores. Por exemplo, podemos tentar prever o preço de uma casa usando o tamanho dela, a localização e a idade do imóvel.

Como existem mais fatores de influência, a função para obter o modelo de regressão linear muda para incluir estes fatores. Ela fica da seguinte forma:

y=β0+β1x1+β2x2+β3x3+⋯+βnxn+ϵy = \beta_{0} + \beta_{1}x_{1} + \beta_{2}x_{2} + \beta_{3}x_{3} + \cdots + \beta_{n}x_{n} + \epsilon

onde:

  • yy é o valor que se deseja prever
  • x1,...,xnx_{1}, … \; , x_{n} são as variáveis de entrada
  • β0\beta_{0}​ é o intercepto (o valor de yy quando o conjunto [x1,...,xn][x_{1}, … \; , x_{n}] é 0)
  • β1,...,βn\beta_{1}, … \; , \beta_{n}​ são os coeficientes angulares da reta (o quanto yy muda à medida que [x1,...,xn][x_{1}, … \; , x_{n}] aumenta).
  • ϵ\epsilon representa o erro aleatório, que é uma parte da realidade que o modelo não conseguiu explicar (ou seja, é o erro que sabemos e aceitamos que existe).

Devemos observar que à medida que o número de variáveis preditoras aumenta, as constantes β\beta também aumentam de forma correspondente. Assim, a regressão linear múltipla acaba modelando o grau de impacto das diversas variáveis em formato de plano no hiperplano.

Exemplo didático

Imagine um conjunto de imóveis e, para cada imóvel, temos sua área em metros quadrados ( X ) e seu preço ( y ). A regressão linear simples tentaria encontrar uma reta como esta:

preco=β0+β1⋅areapreco = \beta_{0} + \beta_{1} \cdot area

Se o modelo encontrar, por exemplo:

preco=50000+3000⋅areapreco = 50000 + 3000 \cdot area

isso significa que o modelo estima um valor inicial de R$ 50.000 e acrescenta R$ 3.000 para cada metro quadrado adicional. Naturalmente, esse é um modelo simplificado, pois o preço real de um imóvel depende também de localização, número de quartos, idade do imóvel, infraestrutura e outros fatores. Portanto, como vamos usar mais de uma variável explicativa, precisamos da Regressão Linear Múltipla.

Nesse caso, cada coeficiente βi\beta_{i} mede a contribuição esperada de uma variável, mantendo as demais constantes. Logo, o modelo que tentamos obter poderia ser descrito assim:

preco=β0+β1⋅area+β2⋅quartos+β3⋅idadepreco = \beta_{0} + \beta_{1} \cdot area + \beta_{2} \cdot quartos + \beta_{3} \cdot idade

Métricas de avaliação

Depois de treinarmos um modelo de regressão linear, precisamos avaliar sua qualidade. Para isso, comparamos os valores reais com os valores previstos pelo modelo. Supondo que yiy_{i}​ representa o valor real e yi^\hat{y_{i}} representa o valor previsto, podemos dizer que o erro individual é dado pela equação:

erroi​=yi​−y^​i​erro_{i}​=y_{i}​−\hat{y}_{​i​}

A partir desses erros individuais, podemos construir algumas métricas de avaliação.

Erro Médio Absoluto (Mean Absolute Error – MAE)

A primeira métrica importante é o Erro Médio Absoluto, conhecido como MAE (do inglês, Mean Absolute Error). Essa métrica é obtida pela equação:

MAE=1n∑i=1n​∣yi​−y^​i​∣MAE=\frac{1}{n} \sum_{i=1}^{n} ​∣y_{i}​−\hat{y}_{​i​}∣

A partir da construção matemática, podemos observar que o MAE calcula a média dos erros em valor absoluto. Ela é normalmente a métrica mais fácil de explicar, pois está na mesma unidade da variável prevista. Se estamos prevendo preço, o MAE está em reais. Se estamos prevendo tempo de entrega, o MAE está em minutos, horas ou dias. Assim, o MAE é bom quando o erro médio é pequeno o suficiente para a decisão que será tomada com base no modelo.

Em uma loja virtual, por exemplo, errar o tempo de entrega em 30 minutos pode ser irrelevante se o prazo prometido é de cinco dias. Mas errar 30 minutos pode ser inaceitável em um sistema de transporte de emergência. Logo, a qualidade do MAE depende do impacto prático do erro.

Erro Quadrático Médio (Mean Squared Error – MSE)

Outra métrica bastante usada é o Erro Quadrático Médio, conhecido como MSE (do inglês, Mean Squared Error). Para encontrarmos essa métrica, fazemos o seguinte cálculo:

MSE=1n∑i=1n​(yi​−y^​i​)2MSE = \frac{1}{n} \sum_{i=1}^{n} ​(y_ {i} ​− \hat{y}_{​i}​)^2

O MSE, por sua vez, é mais difícil de interpretar diretamente porque eleva os erros ao quadrado. Se a variável está em reais, o MSE fica em “reais ao quadrado”, o que não possui interpretação cotidiana simples. Sua utilidade principal está em penalizar fortemente erros grandes. Um MSE muito alto em relação ao MAE pode indicar que o modelo comete alguns erros extremos.

Por exemplo, dois modelos podem ter MAE parecido, mas MSE bastante diferente. Nesse caso, o modelo com maior MSE provavelmente está errando muito em alguns casos específicos. Isso é importante quando grandes erros são perigosos ou custosos. Em previsão de crédito, saúde, logística ou precificação, poucos erros extremos podem causar prejuízos relevantes.

Raiz quadrada do Erro Quadrático Médio (Root Mean Squared Error – RMSE)

Também é comum usarmos a raiz quadrada do erro quadrático médio, chamada de RMSE (do inglês, Root Mean Squared Error – RMSE), como instrumento de avaliação do algoritmo. Para obtê-la, basta “tirar” a raiz quadrada do valor obtido na MSE:

RMSE=MSE​RMSE = \sqrt{MSE​}

O RMSE tem a vantagem de voltar à unidade original da variável. Se a variável prevista é preço em reais, por exemplo, o RMSE também será interpretado em reais. Assim como o MAE, ele pode ser interpretado diretamente. No entanto, o RMSE costuma ser maior que o MAE quando existem erros grandes, porque ele também sofre influência da penalização quadrática.

Uma comparação prática é observar a distância entre MAE e RMSE. Se o MAE é R$ 20.000 e o RMSE é R$ 22.000, os erros parecem relativamente homogêneos. Mas se o MAE é R$ 20.000 e o RMSE é R$ 60.000, provavelmente existem previsões muito ruins em alguns exemplos. Nesse caso, devemos investigar outliers, dados inconsistentes, variáveis omitidas ou relações não lineares.

Coeficiente de determinação R^2

Outra métrica fundamental é o coeficiente de determinação, chamado R2R^2. Esse coeficiente é obtido a partir de uma razão, tal como descrito:

R2=1−∑i=1n​(yi​−y​i^​)2∑i=1n​(yi​−y‾​)2R^2 = 1 − \frac{\sum_{i=1}^{n} ​(y_{i}​− \hat{y_{​i}}​)^2}{\sum_{i=1}^{n} ​(y_{i}​− \bar{y}​)^2}

O coeficiente R2R^2 mede a proporção da variabilidade da variável dependente que é explicada pelo modelo e seu valor geralmente varia de 0 a 1, embora possa ser negativo em alguns cenários de teste quando o modelo é pior que uma previsão ingênua baseada na média. Por exemplo, um valor de R2=0,80R^2 = 0,80 indica que aproximadamente 80% da variação observada nos dados foi explicada pelo modelo.

Em problemas controlados, como experimentos de laboratório ou fenômenos físicos bem definidos, espera-se frequentemente um R2R^2 alto. Em ciências sociais, economia, educação, comportamento humano e mercado imobiliário, valores mais modestos podem ser esperados, pois os fenômenos são influenciados por muitas variáveis difíceis de medir. Wooldridge (2020) observa que, em modelos aplicados a dados sociais e econômicos, a interpretação dos coeficientes e da adequação do modelo deve considerar o contexto substantivo, não apenas medidas agregadas de ajuste.

De forma didática, podemos dizer que um R2R^2 abaixo de 0,30 costuma indicar baixa capacidade explicativa; entre 0,30 e 0,60 pode indicar capacidade moderada, dependendo do problema; entre 0,60 e 0,80 pode ser considerado bom em muitos contextos aplicados; acima de 0,80 geralmente indica forte ajuste. Porém, essa classificação não substitui a análise do problema. Um R2=0,95R^2 = 0,95 pode parecer excelente, mas também pode indicar vazamento de dados, sobreajuste ou uma variável explicativa que contém indiretamente a resposta.

Como saber se os valores de avaliação são bons?

Uma dúvida comum é se determinado valor de MAE, MSE, RMSE ou R2R^2 “é bom”. A resposta tecnicamente correta é: depende do contexto, da unidade da variável prevista, do custo do erro e da comparação com modelos de referência. Em inteligência artificial e ciência de dados, uma métrica raramente é boa ou ruim de forma absoluta, sendo melhor avalia-la em relação ao problema, aos dados e ao uso prático do modelo.

No caso do exemplo que demos antes (previsão de preços de imóveis), um MAE de R$ 20.000 pode parecer alto. Entretanto, se os imóveis custam em média R$ 1.000.000,00 esse erro médio representa cerca de 2% do valor, o que pode ser aceitável em uma análise exploratória. Por outro lado, se os imóveis custam em média R$ 80.000, um erro médio de R$ 20.000 representa 25% do valor, o que provavelmente é inadequado para uma aplicação prática.

Por isso, uma boa prática é interpretar o erro absoluto em relação à escala do problema. Podemos calcular o erro percentual aproximado da seguinte maneira:

ErroPercentualMedio≈MAEy‾​×100ErroPercentualMedio ≈ \frac{MAE}{\bar{y}} ​× 100

Se o preço médio dos imóveis é R$ 400.000,00 e o MAE é R$ 20.000,00, então:

20000400000​×100=5%\frac{20000}{400000}​×100=5\%

Nesse caso, o modelo erra, em média, cerca de 5% do valor médio dos imóveis.

Uma regra didática, não universal, que podemos adotar é a seguinte: erros médios abaixo de 5% da média da variável prevista costumam ser muito bons em muitos problemas aplicados; entre 5% e 10%, podem ser aceitáveis; entre 10% e 20%, exigem análise cuidadosa; acima de 20%, geralmente indicam que o modelo está fraco, que faltam variáveis importantes ou que a relação entre os dados não é bem representada por uma regressão linear simples. 

Mas lembre-se: essa regra deve ser tratada como orientação pedagógica, não como lei estatística!

Uma forma tecnicamente mais segura de responder se uma métrica é boa é comparar o modelo com um modelo de referência, também chamado de baseline. Um baseline simples em regressão é prever sempre a média dos valores de treino. Se a regressão linear apresenta MAE e RMSE menores que o baseline, ela está agregando valor. Se o R2R^2 é maior que o do baseline, ela explica melhor a variação dos dados. Caso contrário, o modelo precisa ser revisto.

Por exemplo, se o preço médio dos imóveis no treino é R$ 350.000,00, o baseline prevê R$ 350.000,00 para todos os imóveis. A regressão linear precisa ser melhor que isso. Se ela não supera esse modelo ingênuo, provavelmente não aprendeu uma relação útil.

Também é importante comparar o erro com a tolerância do usuário ou da organização. Em um sistema acadêmico que prevê evasão, um erro pequeno pode ser necessário porque decisões pedagógicas importantes serão tomadas. Em uma estimativa preliminar de preço de imóveis para fins exploratórios, um erro maior pode ser aceitável. Portanto, “bom” significa “suficientemente preciso para apoiar a decisão pretendida”.

Quando as métricas não são satisfatórias, não dizemos exatamente que é preciso “aprimorar os pesos” manualmente, pois em regressão linear os coeficientes são estimados pelo algoritmo. O mais correto é dizer que precisamos melhorar o processo de modelagem. Isso pode envolver adicionar variáveis relevantes, remover variáveis ruidosas, tratar outliers, normalizar ou padronizar variáveis, testar transformações, coletar mais dados ou usar modelos mais adequados.

Em síntese, podemos tentar nos guiar com quatro perguntas práticas para decidir se os valores são “bons”ou “ruins”:

  1. O erro está pequeno em relação à escala da variável prevista? Exemplo: um MAE de R$ 10.000,00 pode ser baixo para imóveis de luxo, mas alto para produtos baratos.
  2. O modelo é melhor que um baseline simples? Se não for, ele provavelmente não é útil.
  3. O erro é aceitável para a decisão que será tomada? Métricas estatísticas precisam ser interpretadas junto ao custo prático do erro.
  4. Há sinais de problemas nos resíduos, outliers ou sobreajuste? Um bom número isolado não garante um bom modelo.

Fica a dica: o julgamento correto combina estatística, domínio do problema e comparação empírica.

Vantagens e desvantagens da técnica

A principal vantagem da técnica é a sua simplicidade conceitual. Ela parte de uma ideia bastante intuitiva: encontrar uma reta, no caso simples, ou um hiperplano, no caso múltiplo, que aproxime a relação entre variáveis de entrada e uma variável numérica de saída. Essa simplicidade ajuda a compreender o funcionamento básico de modelos preditivos, pois a equação final pode ser lida diretamente. Essa clareza é uma das razões pelas quais modelos lineares são amplamente usados tanto para previsão quanto para inferência estatística (James et al., 2021).

Outra vantagem importante é a interpretabilidade. Em muitos problemas reais, é preciso prever bem e explicar por que o modelo chegou a determinada previsão. Em um modelo para preços de imóveis, por exemplo, é possível observar diretamente quanto a variável area_m2 contribui para o preço previsto. Essa característica torna a regressão linear útil em contextos educacionais, científicos, econômicos, administrativos e jurídicos, nos quais a explicação do resultado é tão importante quanto a previsão.

A técnica também tem baixo custo computacional. Em comparação com modelos mais complexos, como redes neurais, florestas aleatórias ou métodos de boosting, a regressão linear é rápida para treinar e simples de aplicar. Isso a torna adequada para bases pequenas, análises exploratórias e construção de modelos de referência, também chamados de baselines. Antes de testar modelos mais sofisticados, é comum construir uma regressão linear para verificar qual desempenho mínimo razoável pode ser obtido (Géron, 2019).

Outra vantagem é que a regressão linear ajuda a identificar relações iniciais entre variáveis. Quando usamos uma regressão para investigar a relação entre área e preço de imóveis, horas de estudo e nota, investimento em marketing e vendas, ou tempo de experiência e salário, conseguimos uma primeira aproximação quantitativa do fenômeno. Essa aproximação pode não capturar toda a complexidade da realidade, mas oferece uma base analítica importante.

A regressão linear também permite analisar o efeito marginal das variáveis, pois cada coeficiente pode ser interpretado como a variação esperada em yy associada ao aumento de uma unidade em uma variável explicativa, mantendo as demais constantes. Essa ideia é muito usada em estatística aplicada e econometria, embora dependa de hipóteses que precisam ser avaliadas com cuidado (Wooldridge, 2020).

Apesar de sua utilidade, a regressão linear possui limites importantes. O primeiro limite está na própria palavra “linear”. O modelo assume que a relação entre as variáveis pode ser bem aproximada por uma reta ou por uma combinação linear de variáveis. Se a relação real for curva, segmentada, exponencial ou altamente irregular, a regressão linear pode produzir resultados ruins.

Por exemplo, o preço de um imóvel pode crescer com a área, mas esse crescimento pode não ser perfeitamente linear. Em determinados mercados, imóveis muito pequenos ou muito grandes podem ter valorização diferente por metro quadrado. Nesse caso, uma única reta pode simplificar demais o fenômeno. O modelo ainda pode funcionar como aproximação, mas seus erros tendem a aumentar em regiões em que a relação real se afasta da linearidade.

Outro limite é a sensibilidade a outliers (valores extremos). Como a regressão linear tradicional minimiza a soma dos erros quadráticos, observações muito distantes podem influenciar fortemente a reta ajustada. Um único imóvel com preço muito fora do padrão, seja por erro de cadastro ou por características especiais, pode deslocar a reta e prejudicar as previsões para os demais casos. Montgomery, Peck e Vining (2012) destacam que a análise de resíduos e a investigação de observações influentes são etapas interessantes na avaliação de modelos de regressão.

Também há o problema da homocedasticidade, isto é, a suposição de que os erros têm variância aproximadamente constante ao longo das previsões. Em termos simples, espera-se que o modelo erre de modo relativamente equilibrado para valores baixos, médios e altos. Quando isso não acontece, temos heterocedasticidade. Em um exemplo de imóveis, o modelo pode errar pouco em apartamentos baratos e errar muito em casas de alto padrão. Isso indica que o erro não está distribuído de forma uniforme.

A heterocedasticidade não significa necessariamente que o modelo é inútil para previsão, mas torna algumas interpretações estatísticas menos confiáveis, especialmente quando o objetivo é inferência, intervalos de confiança e testes de hipótese. Em aplicações acadêmicas e econométricas, esse problema precisa ser diagnosticado e tratado com técnicas apropriadas (Wooldridge, 2020).

Outro problema importante é a multicolinearidade, comum na regressão múltipla. Ela ocorre quando duas ou mais variáveis explicativas estão fortemente correlacionadas. No exemplo dos imóveis, area_m2, quartos e idade_anos podem estar relacionadas. Imóveis maiores tendem a ter mais quartos, ou imóveis novos podem estar concentrados em certos padrões de tamanho, ou determinadas regiões podem associar idade, área e preço. Quando há multicolinearidade, o modelo pode até prever razoavelmente bem, mas os coeficientes ficam instáveis e difíceis de interpretar.

A regressão linear também depende da qualidade e da representatividade dos dados. Se a base é pequena, enviesada ou pouco variada, o modelo aprende uma relação frágil. Isso pode gerar também o risco de extrapolação, que ocorre quando a regressão linear gera previsões pouco confiáveis para valores fora da faixa observada. Se o modelo foi treinado com imóveis entre 40 m² e 130 m², por exemplo, prever o preço de um imóvel de 400 m² pode ser arriscado. A reta continuará produzindo um número, mas esse número não necessariamente representa uma estimativa plausível.

Outro ponto essencial é que regressão linear não implica causalidade. Um coeficiente positivo entre área e preço indica associação estatística, não prova causal. Para afirmar causalidade, seria necessário um desenho de pesquisa adequado, controle de confundidores e fundamentação teórica. Em estatística aplicada um modelo pode prever bem sem explicar causalmente o fenômeno (James et al., 2021; Wooldridge, 2020).

Prática com Python: regressão linear simples

Nesta seção, usaremos a linguagem Python para criar um modelo que tente prever o preço de imóveis com base apenas na área em metros quadrados. Obviamente, esse é um exemplo didático e simplista, mas nos ajudará a compreender de maneira prática as ideias discutidas até agora. Além disso, destacamos que este exemplo trata-se de uma regressão linear simples, porque há uma única variável explicativa (área em metros quadrados).

A lógica geral que adotamos para este algoritmo foi: criar os dados, separar entrada e saída, dividir treino e teste, treinar o modelo, prever valores, avaliar o erro e usar o modelo para estimar o preço de um novo imóvel.

Importando as bibliotecas, classes e métodos

Para alcançarmos a lógica desejada, começamos importando as bibliotecas numpy e pandas. Além delas, buscamos classes e métodos da biblioteca scikit-learn (sklearn) para trabalhar especificamente com regressão linear:

import numpy as np
import pandas as pd

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

A função train_test_split serve para dividir os dados em conjunto de treino e conjunto de teste. Ela foi escolhida porque é uma função padrão do scikit-learn para separar dados antes do treinamento, reduzindo o risco de avaliar o modelo nos mesmos dados usados para ajustá-lo.

A classe LinearRegression foi importada porque ela implementa o modelo clássico de regressão linear por mínimos quadrados ordinários, adequado para problemas em que se deseja prever uma variável numérica contínua. Enquanto isso, buscamos também as funções mean_absolute_error, mean_squared_error e r2_score que calculam as métricas de avaliação tradicionais em problemas de regressão.

Criando o conjunto de dados simples

Seguindo a lógica, vamos construir o conjunto dos dados que será utilizado. O DataFrame vai criar uma estrutura tabular (linhas e colunas) a partir de um dicionário Python, onde cada chave representa o nome de uma coluna e cada lista representa os valores daquela coluna. Estamos utilizando DataFrame para nossa estrutura porque os modelos do scikit-learn trabalham muito bem com dados organizados em formato tabular. 

# ---------------------------------------------------------
# Criando um conjunto de dados simples sobre imóveis
# ---------------------------------------------------------

dados = pd.DataFrame({
    "area_m2": [40, 50, 60, 70, 80, 90, 100, 110, 120, 130],
    "preco": [180000, 210000, 250000, 280000, 320000,
              360000, 390000, 430000, 460000, 500000]
})

Com o código acima, o dicionário possuirá duas colunas e será preenchido da seguinte maneira:

area_m2preco
40180000
50210000
60250000
70280000
80320000
90360000
100390000
110430000
120460000
130500000

Cabe destacar que esse conjunto de dados é pequeno e artificial, mas é útil para fins didáticos, pois permite visualizar com facilidade a relação entre área e preço.

Separando a variável explicativa e a variável alvo

Agora iremos segmentar o conjunto de entrada e o conjunto de saída. O bloco abaixo separa os dados para termos a variável explicativa ( X ) e a variável que queremos prever ( y ). Em nosso exemplo, o modelo usará a área do imóvel ( X ) para prever o preço ( y ).

# ---------------------------------------------------------
# Separando a variável explicativa X e a variável alvo y
# ---------------------------------------------------------

X = dados[["area_m2"]]   # Entrada: área do imóvel
y = dados["preco"]       # Saída: preço do imóvel

Aqui há um detalhe importante: observe que foram usados dois colchetes em X = dados[["area_m2"]]. Isso faz com que X continue sendo uma tabela com uma coluna. O scikit-learn espera que as variáveis explicativas estejam em formato bidimensional, com a estrutura:

número de linhas × número de variáveis

Portanto, mesmo tendo apenas uma variável explicativa, ela precisa ser passada como uma tabela. Logo, a saída dessa linha é um DataFrame contendo apenas a coluna area_m2.

Já na variável y (variável alvo, variável resposta ou variável dependente) foi usado apenas um colchete. Isso faz com que y seja uma estrutura diferente do Pandas chamada Series, que é uma estrutura unidimensional. Portanto, a saída é uma sequência de valores com os preços dos imóveis.

Separando os dados de treino e teste

No bloco abaixo vamos separar os dados de treino e teste do conjunto.

# ---------------------------------------------------------
# Separando dados de treino e teste
# ---------------------------------------------------------

X_treino, X_teste, y_treino, y_teste = train_test_split(
    X,
    y,
    test_size=0.3,
    random_state=42
)

A função train_test_split() recebe os dados de entrada X e os valores reais y, embaralha os registros e separa uma parte para treinamento e outra para teste. Ela foi escolhida porque é uma função simples e padronizada para avaliar modelos de aprendizado supervisionado. Sem essa divisão, poderíamos cometer o erro de treinar e avaliar o modelo nos mesmos dados, obtendo uma avaliação excessivamente otimista.

Os parâmetros de entrada são:

  • X – que representa as variáveis explicativas (área dos imóveis);
  • y – que representa a variável alvo (preços dos imóveis);
  • test_size=0.3 – definindo que 30% dos dados serão separados para teste. Como o conjunto possui 10 imóveis, aproximadamente 3 serão usados para teste e 7 para treino;
  • random_state=42 – que estabelece uma semente para o processo aleatório de divisão. Isso garante que a divisão será sempre a mesma quando o código for executado novamente. O número 42 não tem significado estatístico especial; é apenas uma escolha convencional para reprodutibilidade.

A saída da função são quatro objetos:

  • X_treino – contém as áreas dos imóveis usadas para treinar o modelo.
  • X_teste – Contém as áreas dos imóveis usadas para testar o modelo.
  • y_treino – Contém os preços reais correspondentes aos imóveis de treino.
  • y_teste – Contém os preços reais correspondentes aos imóveis de teste.

A ideia central é que o modelo deve aprender com X_treino e y_treino para que depois sua qualidade seja avaliada em X_teste e y_teste.

Criando e treinando o modelo

Para criar o modelo capaz de ajustar uma equação linear aos dados, usaremos a função/classe LinearRegression(). Optamos por ela porque o problema é de regressão e, além disso, como usamos apenas uma variável explicativa, estamos trabalhando com uma regressão linear simples.

A entrada de LinearRegression() no código abaixo está vazia, ou seja, usamos os parâmetros padrão da classe. A saída é um objeto de modelo, armazenado na variável modelo_simples.

# ---------------------------------------------------------
# Criando e treinando o modelo de regressão linear
# ---------------------------------------------------------

modelo_simples = LinearRegression()
modelo_simples.fit(X_treino, y_treino)

No momento da criação, o objeto ainda não sabe prever preços, pois ele apenas foi declarado. Para aprender a relação entre área e preço, precisamos submeter o algoritmo a um treinamento. Por isso, usamos a função fit().

O método fit() serve para treinar os modelos. Ele recebe os dados de entrada e saída do conjunto de treino e calcula os melhores coeficientes da reta (β0\beta_{0} e β1\beta_{1}). A saída do método fit() é o próprio modelo ajustado. Na prática, depois dessa linha, o objeto modelo_simples passa a armazenar os coeficientes aprendidos.

A regressão linear simples de nosso exemplo tenta ajustar uma equação semelhante à que apresentamos na seção Exemplo didático:

preco=β0+β1⋅areapreco = \beta_{0} + \beta_{1} \cdot area

Portanto, o método fit() estima os valores do intercepto (β0\beta_{0}) e do coeficiente (β1\beta_{1}).

Testando o modelo com os dados de teste

Agora que o modelo foi construído e estimou os coeficientes para a reta, vamos testá-lo. O bloco a seguir usa o modelo treinado para prever os preços dos imóveis do conjunto de teste por meio do método predict().

# ---------------------------------------------------------
# Fazendo previsões com os dados de teste
# ---------------------------------------------------------

previsoes = modelo_simples.predict(X_teste)

O predict() aplica a equação aprendida pelo modelo aos novos dados de entrada, sendo o método padrão dos modelos do scikit-learn para gerar previsões após o treinamento.

O parâmetro de entrada dele é o conjunto X_teste, que contém as áreas dos imóveis que o modelo ainda não usou para aprender, enquanto a saída contendo os preços estimados pelo modelo para cada imóvel do conjunto de teste é inserida na variável previsoes.

Por exemplo, se X_teste tiver três imóveis, previsoes terá três valores previstos. Em termos conceituais, para cada imóvel, o modelo calcula:

precoPrevisto=β0+β1⋅areaprecoPrevisto = \beta_{0} + \beta_{1} \cdot area

Essas os valores previstos e alocados na variável previsoes depois serão comparadas com y_teste, que contém os preços reais.

Avaliando o modelo

Conforme apresentamos na seção Métricas de Avaliação, existem algumas formas de avaliar a qualidade do modelo obtido. No algoritmo, vamos calcular as métricas MAE, MSE, RMSE e R2R^{2} para comparar as previsões com os valores reais, conforme abaixo.

# ---------------------------------------------------------
# Avaliando o modelo
# ---------------------------------------------------------

mae = mean_absolute_error(y_teste, previsoes)
mse = mean_squared_error(y_teste, previsoes)
rmse = np.sqrt(mse)
r2 = r2_score(y_teste, previsoes)

print("Coeficiente angular:", modelo_simples.coef_[0])
print("Intercepto:", modelo_simples.intercept_)

print("\nMétricas de avaliação:")
print("MAE:", mae)
print("MSE:", mse)
print("RMSE:", rmse)
print("R²:", r2)

Para encontrar as métricas, utilizamos as funções que importamos do scikit-learn no início. Em seguida, imprimimos o modelo_simples.coef_[0] para mostrar quanto o preço tende a aumentar para cada metro quadrado adicional e o valor modelo_simples.intercept_ que indica o ponto em que a reta intercepta o eixo vertical.

Fazendo a previsão para um novo imóvel

Estamos quase encerrando a lógica que propusemos no começo da seção Prática com Python: regressão linear simples. Para verificar como está funcionando o modelo treinado e testado, criamos um novo dado de entrada para o modelo e o atribuímos ao objeto novo_imovel.

# ---------------------------------------------------------
# Fazendo uma previsão para um novo imóvel
# ---------------------------------------------------------

novo_imovel = pd.DataFrame({
    "area_m2": [95]
})

preco_previsto = modelo_simples.predict(novo_imovel)

print("\nPreço previsto para imóvel de 95 m²:")
print(preco_previsto[0])

Usamos novamente pd.DataFrame() porque o modelo espera que a entrada tenha o mesmo formato usado no treinamento: uma tabela com a coluna area_m2. O parâmetro de entrada é um dicionário com uma coluna que representa um imóvel com 95 metros quadrados.

Por meio da função predict(), o modelo treinado irá prever o preço do novo imóvel. Ela recebe o parâmetro de entrada novo_imovel e retorna como saída um vetor com o preço previsto, armazenado em preco_previsto.

Detalhe: mesmo havendo apenas um imóvel, o predict() vai retornar uma estrutura semelhante a uma lista ou vetor. Por isso, o resultado final é acessado com índice [0], conforme o exemplo abaixo:

print("\nPreço previsto para imóvel de 95 m²:")
print(preco_previsto[0])

A saída impressa é o preço estimado pelo modelo para um imóvel de 95 m².

Como dissemos, esse modelo é simples e interpretável, mas também limitado. Ele considera apenas a área do imóvel, mas, na prática, imóveis com a mesma área podem ter preços muito diferentes dependendo da localização, número de quartos, idade da construção e outros fatores. Para casos como estes, o ideal seria aplicarmos a regressão linear múltipla.

Prática com Python: regressão linear múltipla

No exemplo dos imóveis, a regressão múltipla tende a ser mais realista porque o preço dificilmente depende apenas da área. Em um projeto real de ciência de dados e/ou ciência de dados, ainda poderíamos incluir localização, proximidade de serviços, padrão de acabamento, vagas de garagem e indicadores econômicos.

Porém, para efeitos didáticos, vamos ampliar o contexto do exemplo para somente três variáveis: área, número de quartos e idade do imóvel, seguindo o exemplo que apresentamos na seção Exemplo didático.

Para a versão abaixo, observe que começamos o código importando as mesmas bibliotecas, classes e métodos da regressão linear. Contudo, o DataFrame dados possui mais colunas desta vez ( area_m2, quartos, idade_anos e preco).

import numpy as np
import pandas as pd

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# ---------------------------------------------------------
# Criando um conjunto de dados com mais variáveis
# ---------------------------------------------------------

dados = pd.DataFrame({
    "area_m2": [40, 50, 60, 70, 80, 90, 100, 110, 120, 130],
    "quartos": [1, 1, 2, 2, 2, 3, 3, 3, 4, 4],
    "idade_anos": [20, 18, 15, 12, 10, 8, 6, 5, 3, 1],
    "preco": [180000, 210000, 250000, 280000, 320000,
              360000, 390000, 430000, 460000, 500000]
})

Antes de irmos diretamente para a versão com múltiplas variáveis, incluímos a regressão linear simples para efeitos de comparação dos resultados. Então, no código a seguir, estamos buscando a lógica de estimar o preço dos imóveis (preco) a partir apenas da metragem ao quadrado (area_m2). O restante da lógica segue a mesma que discutimos anteriormente na seção Prática com Python: regressão linear simples (separação dos conjuntos de treino e teste, criação, treinamento, teste e avaliação do modelo).

# ---------------------------------------------------------
# Modelo simples usando apenas a área
# ---------------------------------------------------------

X_simples = dados[["area_m2"]]
y = dados["preco"]

X_treino_s, X_teste_s, y_treino, y_teste = train_test_split(
    X_simples,
    y,
    test_size=0.3,
    random_state=42
)

modelo_simples = LinearRegression()
modelo_simples.fit(X_treino_s, y_treino)

previsoes_simples = modelo_simples.predict(X_teste_s)

mae_simples = mean_absolute_error(y_teste, previsoes_simples)
rmse_simples = np.sqrt(mean_squared_error(y_teste, previsoes_simples))
r2_simples = r2_score(y_teste, previsoes_simples)

Chegamos então à parte que nos cabe nesta seção. A estrutura X_multiplo servirá de conjunto de entrada considerando as três variáveis (colunas) que desejamos usar para estimar o preço.

Após atribuirmos as colunas area_m2, quartos e idade_anos à variável X_multiplo, faremos a separação dos conjuntos de registros (linhas) que servirão para treinamento e para teste do modelo. Em seguida criamos, treinamos (método fit) e testamos (método predict) o modelo.

# ---------------------------------------------------------
# Modelo múltiplo usando área, quartos e idade
# ---------------------------------------------------------

X_multiplo = dados[["area_m2", "quartos", "idade_anos"]]

X_treino_m, X_teste_m, y_treino, y_teste = train_test_split(
    X_multiplo,
    y,
    test_size=0.3,
    random_state=42
)

modelo_multiplo = LinearRegression()
modelo_multiplo.fit(X_treino_m, y_treino)

previsoes_multiplas = modelo_multiplo.predict(X_teste_m)

mae_multiplo = mean_absolute_error(y_teste, previsoes_multiplas)
rmse_multiplo = np.sqrt(mean_squared_error(y_teste, previsoes_multiplas))
r2_multiplo = r2_score(y_teste, previsoes_multiplas)

Ao reparar bem, você será capaz de ver que ambas as lógicas e os passos são idênticos, tanto para a versão simples quanto para a versào múltipla do algoritmo. O que os diferencia é realmente a quantidade de atributos que serão adotados no conjunto de entrada X.

Além disso, considerando a lógica interna do algoritmo de treinamento representado pelo método fit(), obviamente nosso código está obtendo mais coeficientes para a equação da reta na versão múltipla do que na simples durante o treinamento.

Em seguida, buscamos criar um DataFrame para concatenar os resultados das duas versões. Os valores impressos serão aqueles encontrados para o MAE, RMSE e o R2R^2. 

# ---------------------------------------------------------
# Comparando os resultados
# ---------------------------------------------------------

comparacao = pd.DataFrame({
    "modelo": ["Regressão simples", "Regressão múltipla"],
    "MAE": [mae_simples, mae_multiplo],
    "RMSE": [rmse_simples, rmse_multiplo],
    "R2": [r2_simples, r2_multiplo]
})

print(comparacao)

A comparação entre os modelos aparece na tabela comparacao e será algo parecido com o descrito abaixo:

               modelo          MAE         RMSE        R2
0   Regressão simples  3465.346535  3477.583298  0.998854
1  Regressão múltipla  6075.581395  6275.412551  0.996269

O ponto principal é observar se os valores do MAE e do RMSE diminuíram e se o valor do R2R^2 aumentou. Quando isso acontece, há indícios de que as novas variáveis ajudaram o modelo. Caso ocorra o contrário — MAE e RMSE maiores e R2R^2 menor —, a regressão múltipla não trouxe ganho preditivo naquele conjunto de teste. Isso pode ocorrer por amostra pequena, variáveis redundantes, ruído nos dados, multicolinearidade ou sobreajuste.

Em termos práticos, a leitura da tabela podemos ser entendida assim:

Se MAE aumenta  → o erro médio absoluto aumentou.
Se RMSE aumenta → os erros grandes ficaram mais relevantes.
Se R² diminui   → o modelo explicou menos a variação dos preços no teste.

Portanto, a regressão múltipla, nesse exemplo, não foi melhor do que a regressão simples.

Cabe destacar que isso não contradiz a teoria. A regressão múltipla pode melhorar o modelo quando as novas variáveis trazem informação útil e independente. Mas ela também pode piorar quando as novas variáveis são pouco informativas, redundantes, mal distribuídas ou quando o conjunto de dados é pequeno demais.

No exemplo em que estamos trabalhando, temos apenas 10 imóveis. Depois da divisão test_size=0.3, o modelo treina com aproximadamente 7 registros e testa com aproximadamente 3 registros e isso é muito pouco. Quando adicionamos mais variáveis, o modelo passa a estimar mais coeficientes com poucos dados. Ou seja, o modelo múltiplo precisa estimar mais parâmetros com praticamente a mesma quantidade de exemplos. Com poucos dados, isso pode gerar instabilidade. O modelo pode ajustar bem alguns padrões do treino, mas generalizar pior no teste.

Outro ponto é que as variáveis quartos e idade_anos estão muito relacionadas com area_m2 nesse conjunto artificial. Conforme a área aumenta, o número de quartos também tende a aumentar, e a idade do imóvel tende a diminuir. Isso pode gerar multicolinearidade, isto é, variáveis explicativas carregando informações muito parecidas. Em vez de ajudar, elas podem tornar os coeficientes mais instáveis.

Sendo assim, a interpretação da tabela comparacao torna-se algo como:

A regressão simples foi melhor neste experimento.
A variável area_m2, sozinha, explicou melhor os preços do conjunto de teste.
As variáveis adicionais não trouxeram ganho preditivo neste exemplo.
O modelo múltiplo ficou mais complexo, mas não ficou mais eficaz.

O resultado mostra que mais variáveis não significam automaticamente melhor modelo. Em ciência de dados, um modelo mais complexo só é preferível se melhorar o desempenho em dados não vistos.

Mesmo que nosso modelo não tenha se saído conforme esperávamos, continuamos programando-o para exibir os valores dos coeficientes encontrados para cada variável de entrada, conforme abaixo:

# ---------------------------------------------------------
# Exibindo os coeficientes do modelo múltiplo
# ---------------------------------------------------------

coeficientes = pd.DataFrame({
    "variavel": X_multiplo.columns,
    "coeficiente": modelo_multiplo.coef_
})

print("\nCoeficientes do modelo múltiplo:")
print(coeficientes)

print("\nIntercepto do modelo múltiplo:")
print(modelo_multiplo.intercept_)

A saída será algo como:

Coeficientes do modelo múltiplo:
     variavel  coeficiente
0     area_m2  4302.325581
1     quartos -2529.069767
2  idade_anos  3139.534884

Intercepto do modelo múltiplo:
-51715.11627907021

Esses resultados mostram a equação final aprendida pela regressão linear múltipla. O modelo estimou uma relação entre preço, área, número de quartos e idade do imóvel que ficou da seguinte forma:

preco=−51715,12+(4302,33⋅area_m2)+(−2529,07⋅quartos)+(3139,53⋅idade_anos)preco = −51715,12 + (4302,33 \cdot area\_m2) + (-2529,07 \cdot quartos) + (3139,53 \cdot idade\_anos)

O coeficiente da variável area_m2 foi 4302,325581. Isso significa que, mantendo as demais variáveis constantes, o modelo estima que cada metro quadrado adicional aumenta o preço do imóvel em aproximadamente R$ 4.302,33. Esse sinal positivo tem sentido intuitivo para nós, indicando que imóveis maiores tendem a ser mais caros.

Já o coeficiente da variável quartos foi – 2529,069767, ou seja, negativo. Isso quer dizer que, mantendo área e idade constantes, o modelo estima que cada quarto adicional reduziria o preço em aproximadamente R$ 2.529,07. Esse resultado parece estranho do ponto de vista do domínio, porque normalmente esperamos que mais quartos aumentem o valor do imóvel. Porém, ele pode ocorrer por causa do conjunto de dados muito pequeno, da relação forte entre area_m2 e quartos e da instabilidade estatística do modelo.

Finalmente, o coeficiente da variável idade_anos foi 3139,534884, que nos diz que mantendo a área e os quartos constantes, o modelo estima que cada ano adicional de idade aumentaria o preço em aproximadamente R$ 3.139,53. Também é um resultado contraintuitivo, pois imóveis mais antigos geralmente tendem a perder valor, salvo contextos específicos. Aqui, novamente, isso indica que o modelo está capturando padrões artificiais ou instáveis do pequeno conjunto de dados.

O intercepto obtido foi -51715,11627907021. Ele representa o valor previsto quando todas as variáveis explicativas são zero:

area_m2=0,quartos=0,idade_anos=0area\_m2 = 0, \; quartos = 0, \; idade\_anos=0

Nesse caso, o modelo estimaria um preço de aproximadamente – R$ 51.715,12. Isso não tem interpretação prática realista, porque um imóvel com 0 m², 0 quartos e 0 anos de idade não faz sentido no contexto do problema. O intercepto é necessário do ponto de vista matemático para posicionar o hiperplano da regressão, mas nem sempre tem significado substantivo útil.

O mais importante para nós é a interpretação conjunta: esses coeficientes indicam que o modelo múltiplo aprendeu uma equação matematicamente válida para os dados de treino, mas não necessariamente uma relação confiável sobre o mercado imobiliário. Como pudemos observar antes, o MAE e o RMSE aumentaram e o R2R^2 diminuiu. Então, esses coeficientes devem ser lidos com cautela.

Para finalizar o algoritmo, vamos prever o preço de um imóvel a partir do modelo múltiplo, mesmo que ele seja ruim. O resultado encontrado está apreesntado logo após o código construído.

# ---------------------------------------------------------
# Prevendo o preço de um novo imóvel
# ---------------------------------------------------------

novo_imovel = pd.DataFrame({
    "area_m2": [95],
    "quartos": [3],
    "idade_anos": [7]
})

preco_previsto = modelo_multiplo.predict(novo_imovel)

print("\nPreço previsto para o novo imóvel:")
print(preco_previsto[0])
Preço previsto para o novo imóvel:
371395.3488372092

Considerando que o valor estimado na versão simples da regressão era 374009.900990099 (em reais seria R$ 374.009,90), temos a percepção final de que realmente o modelo piorou. Na versão múltipla, após a inclusão de mais variáveis, ele passou a estimar um valor menor para um imóvel de 95 m2, projetando “apenas” R$ 371.395,35.

Após refletirmos sobre os resultados alcançados nas duas versões da regressão linear, podemos concluir que adicionar mais variáveis nem sempre melhora o modelo de forma real. Às vezes, o erro diminui apenas porque o modelo ficou mais ajustado aos dados disponíveis, mas perde capacidade de generalização para novos dados. Esse problema é conhecido como sobreajuste, ou overfitting. Por isso, James et al. (2021) recomendam avaliar modelos com dados de teste ou validação, e não apenas com os dados usados no treinamento.

Conclusão

A regressão linear é uma técnica fundamental porque combina simplicidade matemática, interpretação clara e aplicabilidade prática. Ela permite prever valores numéricos e também compreender a relação entre variáveis.

Sua forma simples usa uma única variável explicativa. Sua forma múltipla permite combinar várias variáveis para melhorar a capacidade preditiva. A avaliação do modelo depende de métricas como MAE, MSE, RMSE e R2R^2R2. Já o treinamento consiste em encontrar coeficientes que minimizem uma função de custo, frequentemente associada ao erro quadrático médio.

Mesmo sendo um modelo simples, a regressão linear permanece central na formação em estatística, ciência de dados e aprendizado de máquina. Ela é adequada quando há uma relação aproximadamente linear entre as variáveis, quando se deseja interpretabilidade, quando a variável de saída é numérica contínua e quando o objetivo é construir uma primeira aproximação explicável do problema.

Ela também é indicada como modelo inicial, servindo como ponto de comparação quando se pretende usar modelos mais complexos. A lógica é que se um modelo sofisticado não supera uma regressão linear simples, talvez sua complexidade não se justifique.

Para finalizar, devemos lembrar que é preciso ter cuidado com a técnica quando os dados são poucos, quando há muitos preditores, quando as variáveis explicativas são altamente correlacionadas, quando existem muitos outliers, quando os resíduos apresentam padrão evidente ou quando o fenômeno analisado é fortemente não linear. Nesses casos, o modelo pode até executar normalmente e produzir coeficientes, previsões e métricas. No entanto, o fato de o código rodar não garante que o modelo seja estatisticamente adequado.

Obrigado pela leitura e bons estudos!

Referências

BELCIC, Ivan; STRYKER, Cole. O que é aprendizado supervisionado? Portal IBM. Disponível em: <https://www.ibm.com/br-pt/think/topics/supervised-learning>. Acesso em: 20 mai. 2026.

GÉRON, Aurélien. Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow. 2. ed. Sebastopol: O’Reilly Media, 2019.

HASTIE, Trevor; TIBSHIRANI, Robert; FRIEDMAN, Jerome. The Elements of Statistical Learning: Data Mining, Inference, and Prediction. 2. ed. New York: Springer, 2009.

JAMES, Gareth; WITTEN, Daniela; HASTIE, Trevor; TIBSHIRANI, Robert. An Introduction to Statistical Learning: with Applications in R. 2. ed. New York: Springer, 2021.

MONTGOMERY, Douglas C.; PECK, Elizabeth A.; VINING, G. Geoffrey. Introduction to Linear Regression Analysis. 5. ed. Hoboken: Wiley, 2012.

WOOLDRIDGE, Jeffrey M. Introductory Econometrics: A Modern Approach. 7. ed. Boston: Cengage Learning, 2020.

Tag

Artigos relacionados

Prof. Felipe Túlio de Castro - Blog | © Todos os direitos reservados, 2026