Como criar featurização de texto em Python para dados: passo a passo

João Barros 04 de August de 2026 5 min de leitura

Transformar texto em features numéricas é essencial para aplicações de Machine Learning e análise de dados. Este tutorial mostra como fazer featurização de texto em Python para dados, incluindo limpeza simples, TF‑IDF, n‑grams e redução de dimensionalidade, útil para classificação ou clustering. Vamos explicar o porquê de cada passo e dar exemplos concretos que funcionam em conjuntos pequenos (10–1 000 linhas) e em conjuntos médios (até 100 000 linhas).

Pré‑requisitos

Python 3.8+ e pip
Bibliotecas: pandas, scikit‑learn, nltk (instalar com pip)
Conhecimentos básicos de pandas e Python

Para processamento de texto em grande escala considere também ferramentas como spaCy ou soluções distribuídas, mas para protótipos e pipelines de engenharia de features scikit‑learn + nltk são suficientes.

Passo 1: Instalar e importar dependências

Instale as bibliotecas necessárias e importe os módulos. Usamos nltk para tokenização e scikit‑learn para TF‑IDF e redução de dimensionalidade. O download de recursos do nltk é feito uma vez.

pip install pandas scikit-learn nltk

# Código Python
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
from sklearn.pipeline import make_pipeline
import nltk
nltk.download('punkt')

Porquê: TfidfVectorizer converte texto para uma matriz esparsa, eficiente em memória. TruncatedSVD funciona bem sobre matrizes esparsas (ao contrário de PCA).

Passo 2: Carregar e visualizar dados de texto

Carregue um conjunto de dados com uma coluna de texto. Aqui criamos um exemplo mínimo com frases para testar a featurização. Em cenários reais, a coluna pode ser comentários, descrição de produto ou textos de reviews (ex.: 10k–100k registos).

# Exemplo mínimo de DataFrame
data = {
    'id': [1, 2, 3, 4],
    'texto': [
        'O produto é excelente e muito rápido',
        'Entrega atrasada, mau atendimento',
        'Qualidade boa, preço razoável',
        'Produto com defeito, devolvi e reembolsaram'
    ]
}
df = pd.DataFrame(data)
print(df.head())

Verifique valores nulos, duplicados ou textos demasiado curtos — esses casos costumam requerer tratamento específico (por exemplo, eliminar ou imputar).

Passo 3: Limpeza básica de texto (normalização)

Normalizar texto reduz ruído: colocar em minúsculas, remover pontuação e tokens irrelevantes. Mantemos o processo simples para que seja fácil adaptar. Em Português, atenção a acentos; mantivemos caracteres acentuados no regex para conservar significado.

import re
from nltk.tokenize import word_tokenize

def limpar_texto(s):
    s = s.lower()
    s = re.sub(r'[^a-záâãàçéêíóôõúü0-9\s]', ' ', s)
    tokens = word_tokenize(s)
    tokens = [t for t in tokens if len(t) > 2]
    return ' '.join(tokens)

df['texto_limpo'] = df['texto'].apply(limpar_texto)
print(df[['texto','texto_limpo']])

Dica: para conjuntos maiores acrescente remoção de stopwords (por exemplo stop_words='portuguese' no TfidfVectorizer) e normalização mais avançada (stemming/lemmatization) se necessário.

Passo 4: Criar features com TF‑IDF e n‑grams

TF‑IDF pondera termos por frequência no documento vs frequência no corpus — útil para dar menos peso a termos muito frequentes. Os parâmetros importantes incluem ngram_range, max_df e min_df.

vectorizer = TfidfVectorizer(ngram_range=(1,2), max_df=0.8, min_df=1)
X_tfidf = vectorizer.fit_transform(df['texto_limpo'])
print('TF‑IDF shape:', X_tfidf.shape)
print('Algumas features:', vectorizer.get_feature_names_out()[:10])

Explicação de parâmetros: ngram_range=(1,2) captura unigrams e bigrams; max_df=0.8 ignora termos presentes em >80% dos documentos (possível ruído); min_df=1 inclui termos que aparecem pelo menos 1 vez — em produção convém usar min_df=2 ou min_df=0.01 (1% do corpus) para reduzir a dimensionalidade.

Passo 5: Reduzir dimensionalidade com TruncatedSVD

Reduzir dimensionalidade ajuda modelos e visualizações. TruncatedSVD (LSA) preserva variação importante. Escolha n_components conforme o caso: 2 para visualização, 20–100 para modelos. Em conjuntos com 10k documentos é comum usar 50–200 componentes.

n_components = 2
svd = TruncatedSVD(n_components=n_components, random_state=42)
X_reduced = svd.fit_transform(X_tfidf)
# Adicionar ao DataFrame para utilização em modelos
for i in range(n_components):
    df[f'feature_text_{i+1}'] = X_reduced[:, i]
print(df.head())

Nota: a matriz TF‑IDF é esparsa, por isso TruncatedSVD é eficiente. Verifique a percentagem de variância explicada (svd.explained_variance_ratio_.sum()) para ver quanto da informação foi preservada.

Passo 6: Pipeline completo e reutilizável

Criar um pipeline facilita aplicar o mesmo processo a novos dados sem repetir código. Isto garante reprodutibilidade — importante em produção e em testes A/B.

pipeline = make_pipeline(
    TfidfVectorizer(ngram_range=(1,2), max_df=0.8, min_df=1),
    TruncatedSVD(n_components=50, random_state=42)
)

# Treinar pipeline e transformar
X_features = pipeline.fit_transform(df['texto_limpo'])
print('Features shape (pipeline):', X_features.shape)

Exemplo: com 1 000 documentos e 20 000 features TF‑IDF, TruncatedSVD com 50 componentes reduz para (1000, 50) — muito mais manejável para modelos como LogisticRegression ou RandomForest.

Verificar o resultado

Verifique se obteve uma matriz numérica com dimensões esperadas e se as features fazem sentido: inspeccione valores extremos, similaridade entre registos (cosine similarity) e destaque de componentes principais. Teste o pipeline com um classificador simples e valide por cross‑validation.

# Verificar shape e algumas linhas
print('DataFrame final:\n', df.head())
print('Matriz reduzida exemplo (primeiras 3 linhas):\n', X_reduced[:3])

# Erro comum: ter muitas features vazias - ajustar min_df/max_df ou remover stopwords

Conclusão

Concretizou a featurização de texto em Python para dados: limpeza, TF‑IDF com n‑grams e redução de dimensionalidade. Teste parâmetros como ngram_range, min_df, max_df e n_components para o seu caso; por exemplo, em reviews com 50k registos experimente min_df=5 e n_components=100. Próximos passos incluem treinar um classificador (ex.: LogisticRegression) e medir métricas (accuracy, F1), ou usar embeddings pré‑treinados se precisar de maior capacidade sem engenharia manual de features. Dica prática: mantenha o pipeline versionado para reproduzir resultados em produção.