Performance

Otimize o processamento com paralelismo, rate limiting e tracking de tokens.

Processamento Paralelo

Use parallel_requests para acelerar o processamento:

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    parallel_requests=5  # 5 requisições simultâneas
)

Recomendações por Tamanho

Dataset	Configuração
< 50 linhas	parallel_requests=1 (padrão)
50-500 linhas	parallel_requests=3 a 5
> 500 linhas	parallel_requests=5 a 10

Auto-redução em Rate Limits

Quando detecta erro 429, o DataFrameIt reduz workers automaticamente:

Início: 10 workers
Rate limit detectado → 5 workers
Rate limit detectado → 2 workers
Rate limit detectado → 1 worker

Segurança

Workers são apenas reduzidos, nunca aumentados automaticamente. Isso evita custos inesperados.

Rate Limiting

Use rate_limit_delay para prevenir erros de rate limit:

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    rate_limit_delay=1.0  # 1 segundo entre requisições
)

Calculando o Delay Ideal

delay = 60 / requisições_por_minuto

Exemplos:
- 60 req/min  → delay = 1.0s
- 500 req/min → delay = 0.12s
- 50 req/min  → delay = 1.2s

Por Provider

Provider	Free Tier	Delay Recomendado
Google Gemini	60 req/min	1.0s
OpenAI (Tier 1)	500 req/min	0.15s
Anthropic (Free)	50 req/min	1.2s

Combinando com Paralelismo

# 5 workers + delay entre requisições
resultado = dataframeit(
    df,
    Model,
    PROMPT,
    parallel_requests=5,
    rate_limit_delay=0.5
)

Checkpoints em Execuções Longas

Em datasets grandes (milhares de linhas, horas de execução), um kill/crash perde todo o progresso em memória. Use batch_size + checkpoint_path para persistir o DataFrame a cada N linhas processadas:

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    batch_size=100,
    checkpoint_path="checkpoint.xlsx",
)

Formato inferido pela extensão do arquivo (.csv, .xlsx, .parquet). Em caso de interrupção, recarregue o DataFrame do disco e re-execute com resume=True:

df_parcial = pd.read_excel("checkpoint.xlsx")
resultado = dataframeit(
    df_parcial, Model, PROMPT,
    resume=True, batch_size=100, checkpoint_path="checkpoint.xlsx",
)

Tracking de Tokens

Monitore uso e custos com track_tokens=True:

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    track_tokens=True
)

# Ao final, exibe:
# ============================================================
# ESTATÍSTICAS DE USO DE TOKENS
# ============================================================
# Modelo: gemini-3-flash-preview
# Total de tokens: 15,432
#   • Input:  12,345 tokens
#   • Output: 3,087 tokens
# ============================================================

Colunas Adicionadas

Coluna	Descrição
_input_tokens	Tokens de entrada por linha
_output_tokens	Tokens de saída por linha

Calculando Custos

resultado = dataframeit(df, Model, PROMPT, track_tokens=True)

# Exemplo: preços Gemini 2.0 Flash
preco_input = 0.075 / 1_000_000   # $0.075 por 1M tokens
preco_output = 0.30 / 1_000_000   # $0.30 por 1M tokens

custo_input = resultado['_input_tokens'].sum() * preco_input
custo_output = resultado['_output_tokens'].sum() * preco_output
custo_total = custo_input + custo_output

print(f"Custo estimado: ${custo_total:.4f}")

Métricas de Throughput

O DataFrameIt exibe métricas automaticamente:

============================================================
MÉTRICAS DE THROUGHPUT
============================================================
Tempo total: 45.2s
Workers paralelos: 5
Requisições: 100
  - RPM (req/min): 132.7
  - TPM (tokens/min): 20,478
============================================================

Use essas métricas para calibrar parallel_requests para sua conta.

Configuração Otimizada

Para Máxima Velocidade

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    parallel_requests=10,     # Muitos workers
    rate_limit_delay=0.0,     # Sem delay
    max_retries=5,            # Retry agressivo
    track_tokens=True
)

Para Estabilidade

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    parallel_requests=3,      # Poucos workers
    rate_limit_delay=1.0,     # Delay conservador
    max_retries=3,
    base_delay=2.0,
    track_tokens=True
)

Para Economia

resultado = dataframeit(
    df,
    Model,
    PROMPT,
    parallel_requests=1,      # Sequencial
    rate_limit_delay=1.5,     # Delay alto
    model='gemini-3-flash-preview', # Modelo barato
    track_tokens=True
)