Criação do primeiro Pipeline: escalonador e classificador
Os alunos encadearão StandardScaler e LogisticRegression em um Pipeline, chamarão fit e predict e confirmarão que o escalonador foi ajustado apenas aos dados de treinamento.
Criação do primeiro Pipeline: escalonador e classificador é uma aula grátis de Machine Learning Academy no CoddyKit. Esta é a aula 1 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 Machine Learning Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Machine Learning Academy inclui 4 aulas no total.
O que é um Pipeline do scikit-learn?
Um Pipeline encadeia várias etapas de processamento em um único objeto estimador. Cada etapa, exceto a última, deve implementar fit e transform; a etapa final precisa apenas de fit e predict. Chamar pipeline.fit(X, y) executa todas as etapas em sequência, e pipeline.predict(X) passa os dados por todas as transformações antes de classificá-los. Isso elimina erros de controle manual e evita vazamento de dados.
Por que os fluxos evitam vazamentos
Se você ajustar um StandardScaler ao conjunto de dados completo e só depois dividi-lo em treinamento e teste, o escalonador terá visto as estatísticas do conjunto de teste — isso é vazamento de dados. Um Pipeline resolve isso automaticamente: quando você passa um Pipeline para cross_val_score ou GridSearchCV, o fluxo inteiro (incluindo o escalonador) é reajustado do zero em cada divisão de treinamento, portanto a divisão de teste nunca influencia os parâmetros do escalonador.
Construindo seu primeiro Pipeline
Crie um Pipeline passando uma lista de tuplas (name, estimator). Os nomes são textos arbitrários escolhidos por você — eles servem para referenciar as etapas posteriormente (por exemplo, nos hiperparâmetros da busca em grade). O primeiro fluxo mais comum consiste em um escalonador seguido de um classificador.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(C=1.0, max_iter=200))
])
print('Steps:', [name for name, _ in pipe.steps])
print('Named steps:', list(pipe.named_steps.keys()))Ajustando e fazendo previsões
Depois de construído, use o Pipeline exatamente como qualquer estimador do sklearn: fit nos dados de treinamento, predict nos dados de teste e score para obter a precisão. Internamente, fit chama fit_transform em todas as etapas intermediárias e fit no estimador final.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(max_iter=300))
])
pipe.fit(X_train, y_train)
print('Test accuracy:', pipe.score(X_test, y_test).round(4))
y_pred = pipe.predict(X_test)
print('Predictions[:5]:', y_pred[:5])Confirmando que o escalonador foi ajustado somente nos dados de treinamento
Depois de ajustar o Pipeline aos dados de treinamento, você pode inspecionar os parâmetros ajustados de cada etapa. O escalonador dentro do fluxo terá os atributos mean_ e scale_ calculados somente a partir do conjunto de treinamento — não do conjunto completo. Isso confirma que o fluxo está funcionando corretamente.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
pipe.fit(X_train, y_train)
# Scaler mean from pipeline vs computed from X_train
print('Pipeline scaler mean[0]:', pipe.named_steps['sc'].mean_[0].round(4))
print('Direct train mean[0]: ', X_train[:, 0].mean().round(4))Acessando resultados intermediários
Para obter o resultado transformado de uma etapa específica, use pipeline[:-1].transform(X) ou acesse etapas individuais por meio de pipeline.named_steps['step_name']. Você também pode chamar pipeline[:'step_name'] com a notação de fatias do Python para obter um subfluxo até essa etapa, incluindo-a. Isso é útil para depurar ou inspecionar a aparência dos dados depois do escalonamento.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
pipe.fit(X, y)
# Get scaled output (all steps except the last)
X_scaled = pipe[:-1].transform(X)
print('After scaling — mean per feature:', X_scaled.mean(axis=0).round(4))
print('After scaling — std per feature:', X_scaled.std(axis=0).round(4))make_pipeline: um atalho
make_pipeline cria um Pipeline sem exigir que você especifique manualmente os nomes das etapas — ele gera nomes a partir dos nomes das classes em letras minúsculas. Isso é conveniente para experimentos rápidos, mas menos legível em código de produção, no qual nomes explícitos ajudam a identificar as etapas nas strings de parâmetros da busca em grade.
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_iris(return_X_y=True)
# Auto-names: 'minmaxscaler' and 'kneighborsclassifier'
pipe = make_pipeline(MinMaxScaler(), KNeighborsClassifier(n_neighbors=5))
print('Step names:', list(pipe.named_steps.keys()))
print('CV accuracy:', cross_val_score(pipe, X, y, cv=5).mean().round(4))Pipeline com previsões de probabilidade
Se o estimador final oferecer suporte a predict_proba, o Pipeline também o disponibilizará. Isso permite usar um Pipeline com qualquer função que espere resultados de probabilidade — como a pontuação ROC-AUC, curvas de calibração ou ajuste de limiar — sem precisar aplicar manualmente o pré-processamento antes de chamar o modelo.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression(max_iter=300))])
pipe.fit(X_train, y_train)
proba = pipe.predict_proba(X_test)[:, 1]
print('ROC-AUC:', roc_auc_score(y_test, proba).round(4))Definindo parâmetros após a construção
Você pode atualizar o parâmetro de qualquer etapa depois de criar o Pipeline usando set_params(step__param=value) com o separador de dois sublinhados. Essa é a mesma sintaxe usada em GridSearchCV. Isso é útil quando você quer experimentar configurações diferentes sem reconstruir todo o fluxo do zero.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
# Change C and max_iter after construction
pipe.set_params(lr__C=10.0, lr__max_iter=500)
print('C after set_params:', pipe.named_steps['lr'].C)Serializando e compartilhando fluxos
Um Pipeline ajustado é um único objeto Python que pode ser serializado com pickle ou joblib. Compartilhar o fluxo como um único arquivo garante que exatamente as mesmas etapas de pré-processamento — com exatamente os mesmos parâmetros do escalonador — sejam aplicadas no momento da previsão, eliminando erros de consistência entre os ambientes de treinamento e de disponibilização.
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())])
pipe.fit(X, y)
# Save and reload
joblib.dump(pipe, '/tmp/iris_pipeline.pkl')
loaded_pipe = joblib.load('/tmp/iris_pipeline.pkl')
print('Predictions match:', (pipe.predict(X) == loaded_pipe.predict(X)).all())Prática recomendada de validação cruzada com Pipeline
Sempre envolva seu Pipeline em cross_val_score em vez de percorrer manualmente as divisões. Isso garante que o escalonador seja reajustado em cada divisão de treinamento e nunca tenha contato com a divisão de validação, fornecendo uma estimativa honesta do desempenho de generalização.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_digits(return_X_y=True)
pipe = Pipeline([
('sc', StandardScaler()),
('svm', SVC(kernel='rbf', C=5.0, gamma='scale'))
])
scores = cross_val_score(pipe, X, y, cv=5, n_jobs=-1)
print(f'CV accuracy: {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Verificação rápida
Teste sua compreensão dos Pipelines do scikit-learn nesta lição.
Resumo da lição
Nesta lição, você aprendeu que: um Pipeline encadeia etapas em um único estimador, evitando vazamentos ao ajustar cada etapa somente aos dados de treinamento que ela recebe; make_pipeline oferece atalhos com nomes automáticos, enquanto nomes explícitos melhoram a legibilidade da busca em grade; e um Pipeline ajustado pode ser serializado e compartilhado como um único artefato para garantir um pré-processamento consistente no momento da disponibilização. Em seguida, vamos adicionar ColumnTransformer dentro de um Pipeline para lidar com dados numéricos e categóricos mistos.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Criação do primeiro Pipeline: escalonador e classificador” é grátis?
Sim — o texto completo de “Criação do primeiro Pipeline: escalonador e classificador” é 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 Machine Learning Academy, atualize para CoddyKit PRO. O curso de Machine Learning Academy inclui 4 aulas no total.
O que vou aprender em “Criação do primeiro Pipeline: escalonador e classificador”?
Os alunos encadearão StandardScaler e LogisticRegression em um Pipeline, chamarão fit e predict e confirmarão que o escalonador foi ajustado apenas aos dados de treinamento. Você pratica Machine Learning 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 Machine Learning Academy?
Nenhuma experiência prévia é necessária. Machine Learning 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 1 de 4.
Quanto tempo leva a aula “Criação do primeiro Pipeline: escalonador e classificador”?
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 Machine Learning Academy?
Sim. Cada aula de Machine Learning 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
- Criação do primeiro Pipeline: escalonador e classificador
- ColumnTransformer dentro de um Pipeline
- Validação cruzada e busca em grade de um Pipeline completo
- Salvamento e carregamento de um Pipeline com joblib