Sklearn Train Test Split: Guia Completo para Dividir Dados em Python

Name

Soren Atelier

Updated on 09/02/2026

Treinar um modelo de machine learning em todo o seu conjunto de dados e depois avaliá-lo nos mesmos dados leva a um problema crítico: seu modelo parecerá ter um bom desempenho, mas simplesmente memorizou os dados em vez de aprender padrões. Este overfitting significa que seu modelo falhará espetacularmente quando encontrar dados novos e não vistos. Os cientistas de dados precisam de uma maneira confiável de avaliar o desempenho do modelo em dados que o modelo nunca viu durante o treinamento.

A solução é a divisão treino-teste. Ao reservar uma parte dos seus dados para avaliação, você obtém uma avaliação honesta de como seu modelo funcionará no mundo real. A função train_test_split do sklearn torna este processo simples, mas usá-la incorretamente ainda pode levar a vazamento de dados, má generalização e métricas de desempenho enganosas.

Este guia cobre tudo o que você precisa saber sobre train_test_split do sklearn, desde uso básico até técnicas avançadas para dados de séries temporais, classes desbalanceadas e problemas de múltiplas saídas.

O que é Train Test Split?

Train test split é a técnica fundamental para avaliar modelos de machine learning. Você divide seu conjunto de dados em duas partes: um conjunto de treinamento usado para ajustar o modelo, e um conjunto de teste usado para avaliar o desempenho do modelo em dados não vistos.

A função train_test_split do scikit-learn (sklearn) automatiza este processo, lidando com o embaralhamento e divisão aleatória com apenas uma linha de código.

from sklearn.model_selection import train_test_split
 
# Uso básico
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Neste exemplo, X contém suas features (variáveis de entrada) e y contém sua variável alvo (o que você quer prever). A função retorna quatro arrays: features de treino, features de teste, rótulos de treino e rótulos de teste.

Sintaxe Básica do train_test_split

O uso mais simples de train_test_split requer apenas dois argumentos: suas features e sua variável alvo.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
 
# Carregar dados de exemplo
iris = load_iris()
X = iris.data
y = iris.target
 
# Dividir os dados (80% treino, 20% teste)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 
print(f"Training samples: {len(X_train)}")
print(f"Test samples: {len(X_test)}")

Isto divide seus dados aleatoriamente, com 80% indo para treinamento e 20% para teste. No entanto, este uso básico tem uma falha crítica: a divisão é diferente toda vez que você executa o código, tornando os resultados não reproduzíveis.

Parâmetros Essenciais

test_size e train_size

O parâmetro test_size controla quanto dados vão para o conjunto de teste. Você pode especificá-lo como:

• Um float entre 0.0 e 1.0 (proporção do conjunto de dados)
• Um inteiro (número absoluto de amostras de teste)

# Conjunto de teste de 30%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
 
# 50 amostras no conjunto de teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=50)
 
# Alternativamente, especificar train_size
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8)

Se você especificar tanto test_size quanto train_size, eles devem somar 1.0 (ou o tamanho total do conjunto de dados se usar inteiros). Na maioria dos casos, especificar apenas test_size é suficiente.

random_state para Reprodutibilidade

O parâmetro random_state é crucial para resultados reproduzíveis. Sem ele, você obtém uma divisão diferente toda vez que executa seu código, tornando impossível debugar ou comparar experimentos.

# Sem random_state - divisão diferente a cada vez
X_train1, X_test1, y_train1, y_test1 = train_test_split(X, y, test_size=0.2)
X_train2, X_test2, y_train2, y_test2 = train_test_split(X, y, test_size=0.2)
 
print(f"Same split? {(X_train1 == X_train2).all()}")  # False
 
# Com random_state - mesma divisão toda vez
X_train1, X_test1, y_train1, y_test1 = train_test_split(X, y, test_size=0.2, random_state=42)
X_train2, X_test2, y_train2, y_test2 = train_test_split(X, y, test_size=0.2, random_state=42)
 
print(f"Same split? {(X_train1 == X_train2).all()}")  # True

Use qualquer inteiro para random_state. O número específico não importa; o que importa é usar o mesmo número consistentemente em seu projeto.

Parâmetro shuffle

Por padrão, train_test_split embaralha os dados antes de dividir. Para a maioria das tarefas de machine learning, isto é exatamente o que você quer. No entanto, para dados de séries temporais ou quando a ordem importa, você deve desabilitar o embaralhamento.

# Embaralhamento habilitado (padrão)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True)
 
# Embaralhamento desabilitado (para séries temporais)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

Quando shuffle=False, a função simplesmente pega a primeira porção para treinamento e a última porção para teste, mantendo a ordem original.

Tabela de Referência de Parâmetros

Divisão Estratificada para Dados Desbalanceados

Quando seu conjunto de dados tem classes desbalanceadas (algumas classes têm muito menos amostras que outras), a divisão aleatória pode criar conjuntos de treinamento ou teste que representam mal a distribuição geral. Isto é especialmente problemático para tarefas de classificação.

O parâmetro stratify garante que a distribuição de classes nos conjuntos de treinamento e teste corresponda ao conjunto de dados original.

import numpy as np
from sklearn.model_selection import train_test_split
 
# Criar conjunto de dados desbalanceado (90% classe 0, 10% classe 1)
X = np.random.randn(1000, 5)
y = np.array([0] * 900 + [1] * 100)
 
# Sem estratificação
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(f"Train distribution: Class 0: {sum(y_train == 0)}, Class 1: {sum(y_train == 1)}")
print(f"Test distribution: Class 0: {sum(y_test == 0)}, Class 1: {sum(y_test == 1)}")
 
# Com estratificação
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print(f"\nStratified train distribution: Class 0: {sum(y_train == 0)}, Class 1: {sum(y_train == 1)}")
print(f"Stratified test distribution: Class 0: {sum(y_test == 0)}, Class 1: {sum(y_test == 1)}")

Com estratificação, tanto os conjuntos de treinamento quanto de teste mantêm a distribuição de classes 90/10. Sem ela, você pode ter sorte e obter uma divisão representativa, ou pode acabar com um conjunto de teste que tem apenas 5% da classe 1, levando a métricas de avaliação não confiáveis.

Dividir Múltiplos Arrays

Você pode dividir múltiplos arrays de uma vez, e o sklearn garantirá que sejam divididos da mesma maneira (mesmos índices para todos os arrays).

import numpy as np
 
X = np.random.randn(100, 5)
y = np.random.randint(0, 2, 100)
sample_weights = np.random.rand(100)
 
# Dividir todos os três arrays
X_train, X_test, y_train, y_test, weights_train, weights_test = train_test_split(
    X, y, sample_weights, test_size=0.2, random_state=42
)
 
print(f"X_train shape: {X_train.shape}")
print(f"y_train shape: {y_train.shape}")
print(f"weights_train shape: {weights_train.shape}")

Isto é particularmente útil quando você tem pesos de amostra, múltiplas variáveis alvo ou metadados adicionais que precisam ser divididos consistentemente.

Train/Test Split vs Validação Cruzada vs Holdout

Diferentes estratégias de validação servem propósitos diferentes. Aqui está uma comparação:

from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
 
iris = load_iris()
X, y = iris.data, iris.target
model = RandomForestClassifier(random_state=42)
 
# Método 1: Divisão simples train/test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model.fit(X_train, y_train)
print(f"Train/Test Split Score: {model.score(X_test, y_test):.3f}")
 
# Método 2: Validação cruzada de 5 folds
scores = cross_val_score(model, X, y, cv=5)
print(f"Cross-Validation Score: {scores.mean():.3f} (+/- {scores.std():.3f})")
 
# Método 3: Divisão Train/Val/Test
X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42)
model.fit(X_train, y_train)
print(f"Validation Score: {model.score(X_val, y_val):.3f}")
print(f"Test Score: {model.score(X_test, y_test):.3f}")

Para a maioria dos projetos, comece com uma divisão train/test simples. Use validação cruzada quando tiver dados limitados ou precisar de uma estimativa de desempenho mais robusta. Use train/val/test quando precisar ajustar hiperparâmetros.

Técnicas Avançadas de Divisão

Divisão de Séries Temporais

Para dados de séries temporais, o embaralhamento aleatório destrói a ordem temporal, o que pode levar a vazamento de dados (usar informações futuras para prever o passado). Use TimeSeriesSplit em vez disso:

from sklearn.model_selection import TimeSeriesSplit
import numpy as np
 
X = np.random.randn(100, 5)
y = np.random.randn(100)
 
tscv = TimeSeriesSplit(n_splits=5)
 
for train_index, test_index in tscv.split(X):
    X_train, X_test = X[train_index], X[test_index]
    y_train, y_test = y[train_index], y[test_index]
    print(f"Train size: {len(train_index)}, Test size: {len(test_index)}")

TimeSeriesSplit cria múltiplas divisões train/test onde cada conjunto de treinamento inclui todos os dados passados até um certo ponto, e o conjunto de teste inclui o período imediatamente seguinte. Isto simula previsões do mundo real onde você só tem dados passados para prever o futuro.

GroupShuffleSplit para Dados Agrupados

Quando seus dados têm grupos (por exemplo, múltiplas medições do mesmo paciente, múltiplas transações do mesmo cliente), você precisa garantir que grupos inteiros permaneçam juntos no conjunto de treinamento ou teste para evitar vazamento de dados.

from sklearn.model_selection import GroupShuffleSplit
import numpy as np
 
X = np.random.randn(100, 5)
y = np.random.randint(0, 2, 100)
groups = np.array([0] * 25 + [1] * 25 + [2] * 25 + [3] * 25)  # 4 grupos
 
gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
 
for train_idx, test_idx in gss.split(X, y, groups):
    X_train, X_test = X[train_idx], X[test_idx]
    y_train, y_test = y[train_idx], y[test_idx]
    print(f"Train groups: {np.unique(groups[train_idx])}")
    print(f"Test groups: {np.unique(groups[test_idx])}")

Isto garante que todas as amostras de um determinado grupo estejam no conjunto de treinamento ou no conjunto de teste, nunca em ambos.

Melhores Práticas para Train Test Split

Escolher a Proporção de Divisão Correta

As proporções de divisão mais comuns são:

• 80/20: Escolha padrão para conjuntos de dados médios a grandes (10.000+ amostras)
• 70/30: Melhor para conjuntos de dados menores (1.000-10.000 amostras) para ter avaliação de teste mais robusta
• 90/10: Para conjuntos de dados muito grandes (100.000+ amostras) onde até 10% fornece amostras de teste amplas
• 60/20/20: Para train/validation/test ao ajustar hiperparâmetros

import numpy as np
 
def recommend_split_ratio(n_samples):
    if n_samples < 1000:
        return "Consider cross-validation instead of simple split"
    elif n_samples < 10000:
        return "70/30 split recommended"
    elif n_samples < 100000:
        return "80/20 split recommended"
    else:
        return "90/10 or 80/20 split recommended"
 
sample_sizes = [500, 5000, 50000, 500000]
for size in sample_sizes:
    print(f"{size} samples: {recommend_split_ratio(size)}")

Evitar Vazamento de Dados

O vazamento de dados ocorre quando informações do conjunto de teste influenciam o processo de treinamento. Fontes comuns:

1. Pré-processamento antes da divisão: Sempre divida primeiro, depois pré-processe
2. Escalonamento de features em dados combinados: Ajuste o scaler apenas em dados de treinamento
3. Seleção de features em dados combinados: Selecione features usando apenas dados de treinamento

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import numpy as np
 
X = np.random.randn(1000, 10)
y = np.random.randint(0, 2, 1000)
 
# ERRADO: Escalonar antes de dividir (vazamento de dados!)
scaler_wrong = StandardScaler()
X_scaled_wrong = scaler_wrong.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled_wrong, y, test_size=0.2)
 
# CORRETO: Dividir primeiro, depois escalonar
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # Ajustar em dados de treinamento
X_test_scaled = scaler.transform(X_test)  # Transformar dados de teste usando estatísticas de treinamento

A abordagem errada usa informações do conjunto de dados inteiro (incluindo amostras de teste) para calcular parâmetros de escalonamento, o que vaza informações sobre o conjunto de teste no processo de treinamento.

Estratificar Sempre que Possível

Para problemas de classificação, sempre use divisão estratificada a menos que tenha uma razão específica para não fazê-lo. Isto é especialmente crítico para:

• Conjuntos de dados desbalanceados
• Conjuntos de dados pequenos
• Problemas multiclasse com classes raras

from sklearn.model_selection import train_test_split
import numpy as np
 
# Conjunto de dados de doença rara: 1% de casos positivos
X = np.random.randn(1000, 20)
y = np.array([0] * 990 + [1] * 10)
 
# Sem estratificação - pode não ter casos positivos no conjunto de teste!
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=123)
print(f"Non-stratified test positives: {sum(y_test)}")
 
# Com estratificação - garante representação proporcional
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.1, random_state=123, stratify=y
)
print(f"Stratified test positives: {sum(y_test)}")

Erros Comuns a Evitar

1. Esquecer random_state

Sem random_state, seus resultados mudam toda vez que você executa o código. Isto torna a depuração impossível e experimentos não reproduzíveis.

# RUIM: Sem random_state
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
 
# BOM: Definir random_state
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

2. Não Estratificar Classes Desbalanceadas

Para conjuntos de dados desbalanceados, divisão aleatória pode criar conjuntos de teste altamente não representativos, levando a métricas de desempenho não confiáveis.

# RUIM: Sem estratificação para dados desbalanceados
X_train, X_test, y_train, y_test = train_test_split(X, y_imbalanced, test_size=0.2)
 
# BOM: Usar estratificação
X_train, X_test, y_train, y_test = train_test_split(
    X, y_imbalanced, test_size=0.2, stratify=y_imbalanced, random_state=42
)

3. Dividir Dados de Séries Temporais com Shuffle

Modelos de séries temporais dependem da ordem temporal. Embaralhar destrói esta estrutura e pode levar a vazamento de dados severo.

# RUIM: Embaralhar dados de séries temporais
X_train, X_test, y_train, y_test = train_test_split(
    X_timeseries, y_timeseries, test_size=0.2, shuffle=True
)
 
# BOM: Desabilitar embaralhamento ou usar TimeSeriesSplit
X_train, X_test, y_train, y_test = train_test_split(
    X_timeseries, y_timeseries, test_size=0.2, shuffle=False
)

4. Pré-processar Antes de Dividir

Ajustar pré-processadores (scalers, imputers, encoders) no conjunto de dados inteiro antes de dividir causa vazamento de dados.

# RUIM: Pré-processar antes de dividir
X_scaled = StandardScaler().fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2)
 
# BOM: Dividir primeiro, depois pré-processar
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

5. Usar Conjunto de Teste para Ajuste de Hiperparâmetros

O conjunto de teste deve ser usado apenas para avaliação final. Se você o usa para escolher hiperparâmetros, está essencialmente treinando em seus dados de teste.

# RUIM: Ajustar em conjunto de teste
from sklearn.ensemble import RandomForestClassifier
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
best_score = 0
best_params = None
for n_estimators in [10, 50, 100]:
    model = RandomForestClassifier(n_estimators=n_estimators)
    model.fit(X_train, y_train)
    score = model.score(X_test, y_test)  # Usando conjunto de teste!
    if score > best_score:
        best_score = score
        best_params = n_estimators
 
# BOM: Usar conjunto de validação ou validação cruzada
X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42)
 
best_score = 0
best_params = None
for n_estimators in [10, 50, 100]:
    model = RandomForestClassifier(n_estimators=n_estimators)
    model.fit(X_train, y_train)
    score = model.score(X_val, y_val)  # Usando conjunto de validação
    if score > best_score:
        best_score = score
        best_params = n_estimators

Exemplo Prático: Fluxo de Trabalho Completo

Aqui está um fluxo de trabalho completo de machine learning usando train_test_split corretamente:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
 
# Carregar dados
np.random.seed(42)
X = np.random.randn(1000, 10)
y = (X[:, 0] + X[:, 1] > 0).astype(int)  # Classificação binária
 
# Passo 1: Dividir dados (estratificado para conjunto de teste balanceado)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
 
# Passo 2: Pré-processar (ajustar apenas em dados de treinamento)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
 
# Passo 3: Treinar modelo
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)
 
# Passo 4: Avaliar
y_pred = model.predict(X_test_scaled)
print("Classification Report:")
print(classification_report(y_test, y_pred))
print("\nConfusion Matrix:")
print(confusion_matrix(y_test, y_pred))
 
# Passo 5: Verificar overfitting
train_score = model.score(X_train_scaled, y_train)
test_score = model.score(X_test_scaled, y_test)
print(f"\nTrain accuracy: {train_score:.3f}")
print(f"Test accuracy: {test_score:.3f}")
print(f"Overfitting gap: {train_score - test_score:.3f}")

Usar RunCell para Divisão Interativa de Dados

Ao trabalhar em notebooks Jupyter, experimentar com diferentes proporções de divisão e parâmetros pode ser tedioso. RunCell (opens in a new tab) fornece um agente de IA especificamente projetado para fluxos de trabalho de ciência de dados em Jupyter. Pode ajudá-lo a:

• Testar automaticamente múltiplas proporções de divisão e comparar resultados
• Detectar vazamento de dados em seu pipeline de pré-processamento
• Sugerir estratégias de estratificação ideais para seu conjunto de dados específico
• Gerar curvas de validação para escolher a proporção train/test correta

RunCell se integra diretamente ao seu ambiente Jupyter, facilitando a iteração em sua estratégia de divisão de dados sem escrever código repetitivo.

Visualizar seus Dados com PyGWalker

Após dividir seus dados, é crucial verificar se seus conjuntos de treinamento e teste têm distribuições similares. PyGWalker (opens in a new tab) transforma seus DataFrames do pandas em visualizações interativas estilo Tableau, facilitando:

• Comparar distribuições de features entre conjuntos de treinamento e teste
• Identificar potencial viés de amostragem em suas divisões
• Visualizar desbalanceamentos de classes e verificar se a estratificação funcionou corretamente
• Explorar relações entre features em seus dados de treinamento

import pygwalker as pyg
import pandas as pd
 
# Converter para DataFrames para visualização
train_df = pd.DataFrame(X_train, columns=[f'feature_{i}' for i in range(X_train.shape[1])])
train_df['dataset'] = 'train'
test_df = pd.DataFrame(X_test, columns=[f'feature_{i}' for i in range(X_test.shape[1])])
test_df['dataset'] = 'test'
 
combined = pd.concat([train_df, test_df])
 
# Criar visualização interativa
pyg.walk(combined)

Isto permite explorar interativamente se suas distribuições de treino e teste correspondem, o que é crítico para avaliação confiável do modelo.

FAQ

Como escolher entre divisão 80/20 e 70/30?

Use 80/20 para conjuntos de dados maiores que 10.000 amostras, e 70/30 para conjuntos de dados menores (1.000-10.000 amostras). A chave é garantir que seu conjunto de teste tenha amostras suficientes para avaliação confiável—tipicamente pelo menos 200-500 amostras para problemas de classificação. Para conjuntos de dados muito grandes (100.000+ amostras), você pode usar 90/10 ou até 95/5 já que até 5% fornece milhares de amostras de teste.

O que é random_state e por que importa?

random_state é a semente para o gerador de números aleatórios que embaralha seus dados antes de dividir. Usar o mesmo valor de random_state garante que você obtenha a divisão idêntica toda vez que executar seu código, o que é essencial para reprodutibilidade e depuração. Sem ele, você obterá diferentes divisões train/test toda vez, tornando impossível determinar se mudanças de desempenho são devidas a melhorias do modelo ou apenas a divisões de dados sortudas/azaradas.

Quando devo usar o parâmetro stratify?

Use stratify=y para todos os problemas de classificação, especialmente quando você tem classes desbalanceadas ou conjuntos de dados pequenos. A estratificação garante que a distribuição de classes em seus conjuntos de treinamento e teste corresponda à distribuição geral. Por exemplo, se 10% de seus dados são casos positivos, a estratificação garante que tanto os conjuntos de treinamento quanto de teste tenham aproximadamente 10% de casos positivos, prevenindo viés de avaliação de divisões não representativas.

Posso usar train_test_split para dados de séries temporais?

Não, você não deve usar train_test_split com shuffle=True para dados de séries temporais, pois destrói a ordenação temporal e causa vazamento de dados (usar dados futuros para prever o passado). Em vez disso, use train_test_split com shuffle=False para uma divisão cronológica simples, ou use TimeSeriesSplit para validação cruzada que respeita a ordem temporal. Para séries temporais, sempre garanta que os dados de treinamento venham cronologicamente antes dos dados de teste.

Como train_test_split difere da validação cruzada?

train_test_split cria uma única partição train/test (tipicamente 80/20), dando-lhe uma estimativa de desempenho. Validação cruzada (como k-fold) cria múltiplas divisões train/test e calcula a média dos resultados, fornecendo uma estimativa de desempenho mais robusta. Use train_test_split para avaliação rápida e grandes conjuntos de dados. Use validação cruzada para pequenos conjuntos de dados (menos de 1.000 amostras) ou quando precisar de estimativas de desempenho mais confiáveis. A validação cruzada é k vezes mais lenta (por exemplo, 5-fold é 5× mais lento) mas reduz a variância em suas métricas de desempenho.

Conclusão

O train_test_split do sklearn é a ferramenta fundamental para avaliar modelos de machine learning. Ao dividir seus dados corretamente, você obtém estimativas honestas de desempenho que preveem o comportamento do modelo no mundo real. Lembre-se dos princípios-chave: sempre defina random_state para reprodutibilidade, use stratify para problemas de classificação, evite pré-processar antes de dividir e escolha sua proporção de divisão com base no tamanho do conjunto de dados.

Domine esses fundamentos e você evitará as armadilhas mais comuns que levam a modelos com overfitting e métricas de desempenho enganosas. Seja você construindo um classificador simples ou um sistema complexo de deep learning, a divisão train-test adequada é o primeiro passo para machine learning confiável.