Seaborn Visualização Estatística

Visão Geral

Seaborn é uma biblioteca Python para criar gráficos estatísticos de qualidade para publicação. Use essa skill para plotagem orientada a dataset, análise multivariada, estimação estatística automática e figuras complexas em múltiplos painéis com código mínimo.

Filosofia de Design

Seaborn segue esses princípios fundamentais:

1. Orientada a dataset: Trabalhe diretamente com DataFrames e variáveis nomeadas em vez de coordenadas abstratas
2. Mapeamento semântico: Traduzir automaticamente valores de dados em propriedades visuais (cores, tamanhos, estilos)
3. Consciente estatisticamente: Agregação integrada, estimação de erros e intervalos de confiança
4. Padrões estéticos: Temas prontos para publicação e paletas de cores pronta para uso
5. Integração com matplotlib: Compatibilidade total com customização matplotlib quando necessário

Início Rápido

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# Carregar dataset de exemplo
df = sns.load_dataset('tips')

# Criar uma visualização simples
sns.scatterplot(data=df, x='total_bill', y='tip', hue='day')
plt.show()

Interfaces Principais de Plotagem

Interface de Função (Tradicional)

A interface de função fornece funções de plotagem especializadas organizadas por tipo de visualização. Cada categoria tem funções em nível de eixo (plotam em um único eixo) e funções em nível de figura (gerenciam a figura inteira com faceting).

Quando usar:

• Análise exploratória rápida
• Visualizações com um único propósito
• Quando você precisa de um tipo de gráfico específico

Interface de Objetos (Moderna)

A interface seaborn.objects fornece uma API declarativa e composável semelhante a ggplot2. Construa visualizações encadeando métodos para especificar mapeamentos de dados, marcadores, transformações e escalas.

Quando usar:

• Visualizações em camadas complexas
• Quando você precisa de controle fino sobre transformações
• Criar tipos de gráficos personalizados
• Geração programática de gráficos

from seaborn import objects as so

# Sintaxe declarativa
(
    so.Plot(data=df, x='total_bill', y='tip')
    .add(so.Dot(), color='day')
    .add(so.Line(), so.PolyFit())
)

Funções de Plotagem por Categoria

Gráficos de Relação (Relacionamento Entre Variáveis)

Use para: Explorar como duas ou mais variáveis se relacionam

• scatterplot() - Exibir observações individuais como pontos
• lineplot() - Mostrar tendências e mudanças (agrega automaticamente e calcula IC)
• relplot() - Interface em nível de figura com faceting automático

Parâmetros principais:

• x, y - Variáveis primárias
• hue - Codificação de cor para variável categórica/contínua adicional
• size - Codificação de tamanho de ponto/linha
• style - Codificação de estilo de marcador/linha
• col, row - Facet em múltiplos subgráficos (somente nível de figura)

# Dispersão com múltiplos mapeamentos semânticos
sns.scatterplot(data=df, x='total_bill', y='tip',
                hue='time', size='size', style='sex')

# Gráfico de linhas com intervalos de confiança
sns.lineplot(data=timeseries, x='date', y='value', hue='category')

# Gráfico de relação facetado
sns.relplot(data=df, x='total_bill', y='tip',
            col='time', row='sex', hue='smoker', kind='scatter')

Gráficos de Distribuição (Distribuições Univariadas e Bivariadas)

Use para: Entender dispersão, forma e densidade de probabilidade dos dados

• histplot() - Distribuições de frequência baseadas em barras com binagem flexível
• kdeplot() - Estimativas de densidade suave usando kernels gaussianos
• ecdfplot() - Distribuição cumulativa empírica (sem parâmetros para sintonizar)
• rugplot() - Marcas de tick para observações individuais
• displot() - Interface em nível de figura para distribuições univariadas e bivariadas
• jointplot() - Gráfico bivariado com distribuições marginais
• pairplot() - Matriz de relacionamentos aos pares em todo o dataset

Parâmetros principais:

• x, y - Variáveis (y opcional para univariado)
• hue - Separar distribuições por categoria
• stat - Normalização: "count", "frequency", "probability", "density"
• bins / binwidth - Controle de binagem do histograma
• bw_adjust - Multiplicador de largura de banda KDE (maior = mais suave)
• fill - Preencher área sob a curva
• multiple - Como lidar com hue: "layer", "stack", "dodge", "fill"

# Histograma com normalização de densidade
sns.histplot(data=df, x='total_bill', hue='time',
             stat='density', multiple='stack')

# KDE bivariado com contornos
sns.kdeplot(data=df, x='total_bill', y='tip',
            fill=True, levels=5, thresh=0.1)

# Gráfico conjunto com marginais
sns.jointplot(data=df, x='total_bill', y='tip',
              kind='scatter', hue='time')

# Relacionamentos aos pares
sns.pairplot(data=df, hue='species', corner=True)

Gráficos Categóricos (Comparações Através de Categorias)

Use para: Comparar distribuições ou estatísticas entre categorias discretas

Gráficos categóricos de dispersão:

• stripplot() - Pontos com jitter para mostrar todas as observações
• swarmplot() - Pontos não sobrepostos (algoritmo beeswarm)

Comparações de distribuição:

• boxplot() - Quartis e outliers
• violinplot() - KDE + informação de quartil
• boxenplot() - Boxplot aprimorado para datasets maiores

Estimativas estatísticas:

• barplot() - Média/agregado com intervalos de confiança
• pointplot() - Estimativas pontuais com linhas conectoras
• countplot() - Contagem de observações por categoria

Em nível de figura:

• catplot() - Gráficos categóricos facetados (defina o parâmetro kind)

Parâmetros principais:

• x, y - Variáveis (uma tipicamente categórica)
• hue - Agrupamento categórico adicional
• order, hue_order - Controlar ordem de categorias
• dodge - Separar níveis de hue lado a lado
• orient - "v" (vertical) ou "h" (horizontal)
• kind - Tipo de gráfico para catplot: "strip", "swarm", "box", "violin", "bar", "point"

# Gráfico swarm mostrando todos os pontos
sns.swarmplot(data=df, x='day', y='total_bill', hue='sex')

# Gráfico violin com split para comparação
sns.violinplot(data=df, x='day', y='total_bill',
               hue='sex', split=True)

# Gráfico de barras com barras de erro
sns.barplot(data=df, x='day', y='total_bill',
            hue='sex', estimator='mean', errorbar='ci')

# Gráfico categórico facetado
sns.catplot(data=df, x='day', y='total_bill',
            col='time', kind='box')

Gráficos de Regressão (Relacionamentos Lineares)

Use para: Visualizar regressões lineares e resíduos

• regplot() - Gráfico de regressão em nível de eixo com dispersão + linha ajustada
• lmplot() - Nível de figura com suporte a faceting
• residplot() - Gráfico de resíduos para avaliar ajuste do modelo

Parâmetros principais:

• x, y - Variáveis para regressão
• order - Ordem de regressão polinomial
• logistic - Ajustar regressão logística
• robust - Usar regressão robusta (menos sensível a outliers)
• ci - Largura do intervalo de confiança (padrão 95)
• scatter_kws, line_kws - Customizar propriedades de dispersão e linha

# Regressão linear simples
sns.regplot(data=df, x='total_bill', y='tip')

# Regressão polinomial com faceting
sns.lmplot(data=df, x='total_bill', y='tip',
           col='time', order=2, ci=95)

# Verificar resíduos
sns.residplot(data=df, x='total_bill', y='tip')

Gráficos de Matriz (Dados Retangulares)

Use para: Visualizar matrizes, correlações e dados estruturados em grade

• heatmap() - Matriz codificada por cor com anotações
• clustermap() - Mapa de calor agrupado hierarquicamente

Parâmetros principais:

• data - Dataset retangular bidimensional (DataFrame ou array)
• annot - Exibir valores nas células
• fmt - String de formato para anotações (ex: ".2f")
• cmap - Nome do colormap
• center - Valor no centro do colormap (para colormaps divergentes)
• vmin, vmax - Limites da escala de cor
• square - Forçar células quadradas
• linewidths - Espaço entre células

# Mapa de calor de correlação
corr = df.corr()
sns.heatmap(corr, annot=True, fmt='.2f',
            cmap='coolwarm', center=0, square=True)

# Mapa de calor agrupado
sns.clustermap(data, cmap='viridis',
               standard_scale=1, figsize=(10, 10))

Grids Multi-Plot

Seaborn fornece objetos grid para criar figuras complexas em múltiplos painéis:

FacetGrid

Criar subgráficos baseados em variáveis categóricas. Mais útil quando chamado através de funções em nível de figura (relplot, displot, catplot), mas pode ser usado diretamente para gráficos personalizados.

g = sns.FacetGrid(df, col='time', row='sex', hue='smoker')
g.map(sns.scatterplot, 'total_bill', 'tip')
g.add_legend()

PairGrid

Mostrar relacionamentos aos pares entre todas as variáveis em um dataset.

g = sns.PairGrid(df, hue='species')
g.map_upper(sns.scatterplot)
g.map_lower(sns.kdeplot)
g.map_diag(sns.histplot)
g.add_legend()

JointGrid

Combinar gráfico bivariado com distribuições marginais.

g = sns.JointGrid(data=df, x='total_bill', y='tip')
g.plot_joint(sns.scatterplot)
g.plot_marginals(sns.histplot)

Funções em Nível de Figura vs Nível de Eixo

Entender essa distinção é crucial para uso efetivo de seaborn:

Funções em Nível de Eixo

• Plotar em um único objeto Axes matplotlib
• Integram-se facilmente em figuras matplotlib complexas
• Aceitam parâmetro ax= para posicionamento preciso
• Retornam objeto Axes
• Exemplos: scatterplot, histplot, boxplot, regplot, heatmap

Quando usar:

• Construir layouts customizados multi-plot
• Combinar diferentes tipos de gráficos
• Precisar de controle em nível matplotlib
• Integrar com código matplotlib existente

fig, axes = plt.subplots(2, 2, figsize=(10, 10))
sns.scatterplot(data=df, x='x', y='y', ax=axes[0, 0])
sns.histplot(data=df, x='x', ax=axes[0, 1])
sns.boxplot(data=df, x='cat', y='y', ax=axes[1, 0])
sns.kdeplot(data=df, x='x', y='y', ax=axes[1, 1])

Funções em Nível de Figura

• Gerenciar figura inteira incluindo todos os subgráficos
• Faceting integrado via parâmetros col e row
• Retornar objetos FacetGrid, JointGrid ou PairGrid
• Usar height e aspect para tamanho (por subgráfico)
• Não podem ser colocadas em figura existente
• Exemplos: relplot, displot, catplot, lmplot, jointplot, pairplot

Quando usar:

• Visualizações facetadas (múltiplos pequenos)
• Análise exploratória rápida
• Layouts multi-painel consistentes
• Não precisa combinar com outros tipos de gráficos

# Faceting automático
sns.relplot(data=df, x='x', y='y', col='category', row='group',
            hue='type', height=3, aspect=1.2)

Requisitos de Estrutura de Dados

Dados em Forma Longa (Preferido)

Cada variável é uma coluna, cada observação é uma linha. Esse formato "tidy" fornece máxima flexibilidade:

# Estrutura de forma longa
   subject  condition  measurement
0        1    control         10.5
1        1  treatment         12.3
2        2    control          9.8
3        2  treatment         13.1

Vantagens:

• Funciona com todas as funções seaborn
• Fácil remapear variáveis para propriedades visuais
• Suporta complexidade arbitrária
• Natural para operações DataFrame

Dados em Forma Larga

Variáveis espalhadas por colunas. Útil para dados retangulares simples:

# Estrutura de forma larga
   control  treatment
0     10.5       12.3
1      9.8       13.1

Casos de uso:

• Série temporal simples
• Matrizes de correlação
• Mapas de calor
• Gráficos rápidos de dados de array

Convertendo forma larga para longa:

df_long = df.melt(var_name='condition', value_name='measurement')

Paletas de Cores

Seaborn fornece paletas de cores cuidadosamente projetadas para diferentes tipos de dados:

Paletas Qualitativas (Dados Categóricos)

Distinguir categorias através de variação de matiz:

• "deep" - Padrão, cores vívidas
• "muted" - Mais suave, menos saturado
• "pastel" - Claro, dessaturado
• "bright" - Altamente saturado
• "dark" - Valores escuros
• "colorblind" - Seguro para deficiência de visão de cores

sns.set_palette("colorblind")
sns.color_palette("Set2")

Paletas Sequenciais (Dados Ordenados)

Mostrar progressão de valores baixos para altos:

• "rocket", "mako" - Ampla gama de luminância (bom para mapas de calor)
• "flare", "crest" - Luminância restrita (bom para pontos/linhas)
• "viridis", "magma", "plasma" - Uniforme perceptualmente do matplotlib

sns.heatmap(data, cmap='rocket')
sns.kdeplot(data=df, x='x', y='y', cmap='mako', fill=True)

Paletas Divergentes (Dados Centrados)

Enfatizar desvios de um ponto médio:

• "vlag" - Azul para vermelho
• "icefire" - Azul para laranja
• "coolwarm" - Frio para quente
• "Spectral" - Arco-íris divergente

sns.heatmap(correlation_matrix, cmap='vlag', center=0)

Paletas Personalizadas

# Criar paleta personalizada
custom = sns.color_palette("husl", 8)

# Gradiente claro para escuro
palette = sns.light_palette("seagreen", as_cmap=True)

# Paleta divergente de matizes
palette = sns.diverging_palette(250, 10, as_cmap=True)

Temas e Estética

Definir Tema

set_theme() controla a aparência geral:

# Definir tema completo
sns.set_theme(style='whitegrid', palette='pastel', font='sans-serif')

# Redefinir para padrões
sns.set_theme()

Estilos

Controlar fundo e aparência da grade:

• "darkgrid" - Fundo cinza com grade branca (padrão)
• "whitegrid" - Fundo branco com grade cinza
• "dark" - Fundo cinza, sem grade
• "white" - Fundo branco, sem grade
• "ticks" - Fundo branco com marcas de eixo

sns.set_style("whitegrid")

# Remover espinhas
sns.despine(left=False, bottom=False, offset=10, trim=True)

# Estilo temporário
with sns.axes_style("white"):
    sns.scatterplot(data=df, x='x', y='y')

Contextos

Escalar elementos para diferentes casos de uso:

• "paper" - Menor (padrão)
• "notebook" - Ligeiramente maior
• "talk" - Slides de apresentação
• "poster" - Grande formato

sns.set_context("talk", font_scale=1.2)

# Contexto temporário
with sns.plotting_context("poster"):
    sns.barplot(data=df, x='category', y='value')

Melhores Práticas

1. Preparação de Dados

Sempre use DataFrames bem estruturados com nomes de coluna significativos:

# Bom: Colunas nomeadas em DataFrame
df = pd.DataFrame({'bill': bills, 'tip': tips, 'day': days})
sns.scatterplot(data=df, x='bill', y='tip', hue='day')

# Evitar: Arrays sem nome
sns.scatterplot(x=x_array, y=y_array)  # Perde rótulos de eixo

2. Escolha o Tipo de Gráfico Certo

Contínuo x, contínuo y: scatterplot, lineplot, kdeplot, regplot Contínuo x, categórico y: violinplot, boxplot, stripplot, swarmplot Uma variável contínua: histplot, kdeplot, ecdfplot Correlações/matrizes: heatmap, clustermap Relacionamentos aos pares: pairplot, jointplot

3. Use Funções em Nível de Figura para Faceting

# Em vez de criação manual de subgráficos
sns.relplot(data=df, x='x', y='y', col='category', col_wrap=3)

# Não: Criar subgráficos manualmente para faceting simples

4. Aproveite Mapeamentos Semânticos

Use hue, size e style para codificar dimensões adicionais:

sns.scatterplot(data=df, x='x', y='y',
                hue='category',      # Cor por categoria
                size='importance',    # Tamanho por variável contínua
                style='type')         # Estilo de marcador por tipo

5. Controle Estimação Estatística

Muitas funções calculam estatísticas automaticamente. Entenda e customize:

# Lineplot calcula média e IC de 95% por padrão
sns.lineplot(data=df, x='time', y='value',
             errorbar='sd')  # Usar desvio padrão em vez disso

# Barplot calcula média por padrão
sns.barplot(data=df, x='category', y='value',
            estimator='median',  # Usar mediana em vez disso
            errorbar=('ci', 95))  # IC com bootstrap

6. Combine com Matplotlib

Seaborn integra-se perfeitamente com matplotlib para ajuste fino:

ax = sns.scatterplot(data=df, x='x', y='y')
ax.set(xlabel='Rótulo X Personalizado', ylabel='Rótulo Y Personalizado',
       title='Título Personalizado')
ax.axhline(y=0, color='r', linestyle='--')
plt.tight_layout()

7. Salve Figuras de Alta Qualidade

fig = sns.relplot(data=df, x='x', y='y', col='group')
fig.savefig('figure.png', dpi=300, bbox_inches='tight')
fig.savefig('figure.pdf')  # Formato vetorial para publicações

Padrões Comuns

Análise Exploratória de Dados

# Visão geral rápida de todos os relacionamentos
sns.pairplot(data=df, hue='target', corner=True)

# Exploração de distribuição
sns.displot(data=df, x='variable', hue='group',
            kind='kde', fill=True, col='category')

# Análise de correlação
corr = df.corr()
sns.heatmap(corr, annot=True, cmap='coolwarm', center=0)

Figuras de Qualidade para Publicação

sns.set_theme(style='ticks', context='paper', font_scale=1.1)

g = sns.catplot(data=df, x='treatment', y='response',
                col='cell_line', kind='box', height=3, aspect=1.2)
g.set_axis_labels('Condição de Tratamento', 'Resposta (μM)')
g.set_titles('{col_name}')
sns.despine(trim=True)

g.savefig('figure.pdf', dpi=300, bbox_inches='tight')

Figuras Complexas em Múltiplos Painéis

# Usando subplots matplotlib com seaborn
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

sns.scatterplot(data=df, x='x1', y='y', hue='group', ax=axes[0, 0])
sns.histplot(data=df, x='x1', hue='group', ax=axes[0, 1])
sns.violinplot(data=df, x='group', y='y', ax=axes[1, 0])
sns.heatmap(df.pivot_table(values='y', index='x1', columns='x2'),
            ax=axes[1, 1], cmap='viridis')

plt.tight_layout()

Série Temporal com Bandas de Confiança

# Lineplot agrega automaticamente e mostra IC
sns.lineplot(data=timeseries, x='date', y='measurement',
             hue='sensor', style='location', errorbar='sd')

# Para mais controle
g = sns.relplot(data=timeseries, x='date', y='measurement',
                col='location', hue='sensor', kind='line',
                height=4, aspect=1.5, errorbar=('ci', 95))
g.set_axis_labels('Data', 'Medição (unidades)')

Solução de Problemas

Problema: Legenda Fora da Área do Gráfico

Funções em nível de figura colocam legendas fora por padrão. Para mover para dentro:

g = sns.relplot(data=df, x='x', y='y', hue='category')
g._legend.set_bbox_to_anchor((0.9, 0.5))  # Ajuste posição

Problema: Rótulos Sobrepostos

plt.xticks(rotation=45, ha='right')
plt.tight_layout()

Problema: Figura Muito Pequena

Para funções em nível de figura:

sns.relplot(data=df, x='x', y='y', height=6, aspect=1.5)

Para funções em nível de eixo:

fig, ax = plt.subplots(figsize=(10, 6))
sns.scatterplot(data=df, x='x', y='y', ax=ax)

Problema: Cores Não Suficientemente Distintas

# Usar paleta diferente
sns.set_palette("bright")

# Ou especificar número de cores
palette = sns.color_palette("husl", n_colors=len(df['category'].unique()))
sns.scatterplot(data=df, x='x', y='y', hue='category', palette=palette)

Problema: KDE Muito Suave ou Áspero

# Ajuste largura de banda
sns.kdeplot(data=df, x='x', bw_adjust=0.5)  # Menos suave
sns.kdeplot(data=df, x='x', bw_adjust=2)    # Mais suave

Recursos

Esta skill inclui materiais de referência para exploração mais aprofundada:

references/

• function_reference.md - Listagem abrangente de todas as funções seaborn com parâmetros e exemplos
• objects_interface.md - Guia detalhado da API moderna seaborn.objects
• examples.md - Casos de uso comuns e padrões de código para diferentes cenários de análise

Carregue arquivos de referência conforme necessário para assinaturas de função detalhadas, parâmetros avançados ou exemplos específicos.