Python Academy · Aula

Modelos lineares: regressão e classificação

Treine modelos de regressão linear e regressão logística.

Modelos lineares: regressão e classificação é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Regressão linear

LinearRegression ajusta uma linha reta (ou hiperplano) minimizando o erro dos mínimos quadrados.

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

X, y = make_regression(n_samples=200, n_features=5, noise=10, random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)

model = LinearRegression().fit(X_tr, y_tr)
print("RMSE:", mean_squared_error(y_te, model.predict(X_te))**0.5)

Coeficientes do modelo

Depois do ajuste, examine coef_ (pesos das características) e intercept_.

from sklearn.linear_model import LinearRegression
import numpy as np

X = np.array([[1],[2],[3]])
y = np.array([2, 4, 6])

model = LinearRegression().fit(X, y)
print("Coef:", model.coef_)       # [2.]
print("Intercept:", model.intercept_)  # ~0

Regressão Ridge e Lasso

Ridge (L2) e Lasso (L1) acrescentam regularização para evitar o sobreajuste. alpha controla a intensidade da regularização.

from sklearn.linear_model import Ridge, Lasso
from sklearn.datasets import make_regression

X, y = make_regression(n_features=20, noise=15, random_state=0)

ridge = Ridge(alpha=1.0).fit(X, y)
lasso = Lasso(alpha=0.1).fit(X, y)
print("Ridge coef[:5]:", ridge.coef_[:5])
print("Lasso coef[:5]:", lasso.coef_[:5])  # some are 0 (sparse)

Regressão logística

LogisticRegression é um classificador linear para problemas binários ou multiclasse. Apesar do nome, ele prevê probabilidades de classe.

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

X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = LogisticRegression().fit(X_tr, y_tr)
print("Accuracy:", accuracy_score(y_te, model.predict(X_te)))

Regressão logística multiclasse

Defina multi_class="multinomial" ou use o OvR padrão (um contra o restante) para 3 ou mais classes.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
model = LogisticRegression(max_iter=200).fit(X, y)
print("Classes:", model.classes_)   # [0 1 2]
print("Accuracy:", model.score(X, y))

Escalonamento de características para modelos lineares

Escale sempre as características para modelos lineares, especialmente com regularização. Características não escalonadas recebem penalizações aparentemente diferentes.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipe = Pipeline([
    ("scale", StandardScaler()),
    ("clf",   LogisticRegression())
])
pipe.fit(X_tr, y_tr)
print(pipe.score(X_te, y_te))

Curva de aprendizagem

Uma curva de aprendizagem mostra como o desempenho do modelo melhora com mais dados de treinamento — é útil para diagnosticar subajuste ou sobreajuste.

from sklearn.model_selection import learning_curve
import numpy as np

train_sizes, train_scores, val_scores = learning_curve(
    LogisticRegression(), X, y, cv=5,
    train_sizes=np.linspace(0.1, 1.0, 5)
)
print("Val mean:", val_scores.mean(axis=1))

Pontuação R² para regressão

r2_score mede a proporção da variância explicada. 1.0 é perfeito; 0 significa que o modelo não é melhor do que prever a média.

from sklearn.metrics import r2_score
from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

X, y = make_regression(noise=20, random_state=0)
model = LinearRegression().fit(X, y)
print("R²:", r2_score(y, model.predict(X)))

Características polinomiais

Use PolynomialFeatures para ajustar relações não lineares com um modelo linear.

from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression
import numpy as np

X = np.array([[1],[2],[3],[4],[5]])
y = np.array([1, 4, 9, 16, 25])  # y = x^2

pipe = Pipeline([
    ("poly", PolynomialFeatures(degree=2)),
    ("lr",   LinearRegression())
])
pipe.fit(X, y)
print(pipe.predict([[6]]))   # ~36

SGDClassifier e SGDRegressor

A descida de gradiente estocástica pode lidar com conjuntos de dados muito grandes, nos quais os solucionadores padrão são lentos demais.

from sklearn.linear_model import SGDClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=100_000, random_state=0)
pipe = Pipeline([("sc", StandardScaler()), ("sgd", SGDClassifier())])
pipe.fit(X, y)
print(pipe.score(X, y))

Caminhos de regularização

Varie alpha em uma grade com RidgeCV/LassoCV, que selecionam automaticamente o melhor alpha por validação cruzada.

from sklearn.linear_model import RidgeCV, LassoCV
from sklearn.datasets import make_regression

X, y = make_regression(n_features=20, noise=10, random_state=0)
ridge = RidgeCV(alphas=[0.1, 1, 10]).fit(X, y)
print("Best alpha:", ridge.alpha_)

Verificação rápida

Qual é a principal diferença entre as regressões Ridge e Lasso?

Recapitulação

Use LinearRegression para regressão e LogisticRegression para classificação. Acrescente Ridge/Lasso para regularização. Escale sempre as características. Use PolynomialFeatures para problemas não lineares. Avalie com r2_score (regressão) ou accuracy_score (classificação).

Perguntas Frequentes

A aula “Modelos lineares: regressão e classificação” é grátis?

Sim — o texto completo de “Modelos lineares: regressão e classificação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Modelos lineares: regressão e classificação”?

Treine modelos de regressão linear e regressão logística. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Modelos lineares: regressão e classificação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

A API do scikit-learn: fit, transform, predict
Modelos lineares: regressão e classificação
Modelos baseados em árvores: árvores de decisão e florestas aleatórias
Avaliação de modelos e validação cruzada

← Voltar para Python Academy