Seaborn - Guia Rápido
No mundo do Analytics, a melhor maneira de obter insights é visualizando os dados. Os dados podem ser visualizados representando-os como gráficos fáceis de entender, explorar e apreender. Esses dados ajudam a chamar a atenção de elementos-chave.
Para analisar um conjunto de dados usando Python, usamos Matplotlib, uma biblioteca de plotagem 2D amplamente implementada. Da mesma forma, Seaborn é uma biblioteca de visualização em Python. Ele é construído em cima do Matplotlib.
Seaborn Vs Matplotlib
Resume-se que se Matplotlib “tenta tornar as coisas fáceis fáceis e as difíceis possíveis”, Seaborn tenta tornar um conjunto bem definido de coisas difíceis fáceis também. ”
Seaborn ajuda a resolver os dois principais problemas enfrentados pelo Matplotlib; os problemas são -
- Parâmetros Matplotlib padrão
- Trabalhando com frames de dados
À medida que Seaborn elogia e estende o Matplotlib, a curva de aprendizado é bastante gradual. Se você conhece o Matplotlib, já está na metade do Seaborn.
Características importantes do Seaborn
Seaborn é construído em cima da biblioteca de visualização Matplotlib do núcleo do Python. Pretende servir de complemento e não de substituição. No entanto, o Seaborn vem com alguns recursos muito importantes. Vamos ver alguns deles aqui. Os recursos ajudam em -
- Temas integrados para estilizar gráficos matplotlib
- Visualizando dados univariados e bivariados
- Ajustando e visualizando modelos de regressão linear
- Traçando dados estatísticos de série temporal
- Seaborn funciona bem com estruturas de dados NumPy e Pandas
- Ele vem com temas integrados para estilizar gráficos Matplotlib
Na maioria dos casos, você ainda usará Matplotlib para plotagem simples. O conhecimento do Matplotlib é recomendado para ajustar os gráficos padrão da Seaborn.
Neste capítulo, discutiremos a configuração do ambiente para Seaborn. Vamos começar com a instalação e entender como começar à medida que avançamos.
Instalando o Seaborn e começando
Nesta seção, entenderemos as etapas envolvidas na instalação do Seaborn.
Usando Pip Installer
Para instalar a versão mais recente do Seaborn, você pode usar pip -
pip install seaborn
Para Windows, Linux e Mac usando Anaconda
Anaconda (de https://www.anaconda.com/é uma distribuição Python gratuita para a pilha SciPy. Também está disponível para Linux e Mac.
Também é possível instalar a versão lançada usando conda -
conda install seaborn
Para instalar a versão de desenvolvimento do Seaborn diretamente do github
https://github.com/mwaskom/seaborn"
Dependências
Considere as seguintes dependências do Seaborn -
- Python 2.7 ou 3.4+
- numpy
- scipy
- pandas
- matplotlib
Neste capítulo, discutiremos como importar conjuntos de dados e bibliotecas. Vamos começar entendendo como importar bibliotecas.
Importando Bibliotecas
Vamos começar importando o Pandas, que é uma ótima biblioteca para gerenciar conjuntos de dados relacionais (formato de tabela). Seaborn é útil ao lidar com DataFrames, que é a estrutura de dados mais amplamente usada para análise de dados.
O seguinte comando irá ajudá-lo a importar Pandas -
# Pandas for managing datasets
import pandas as pd
Agora, vamos importar a biblioteca Matplotlib, que nos ajuda a customizar nossos gráficos.
# Matplotlib for additional customization
from matplotlib import pyplot as plt
Vamos importar a biblioteca Seaborn com o seguinte comando -
# Seaborn for plotting and styling
import seaborn as sb
Importando conjuntos de dados
Importamos as bibliotecas necessárias. Nesta seção, vamos entender como importar os conjuntos de dados necessários.
Seaborn vem com alguns conjuntos de dados importantes na biblioteca. Quando o Seaborn é instalado, os conjuntos de dados são baixados automaticamente.
Você pode usar qualquer um desses conjuntos de dados para o seu aprendizado. Com a ajuda da seguinte função, você pode carregar o conjunto de dados necessário
load_dataset()
Importando dados como Pandas DataFrame
Nesta seção, importaremos um conjunto de dados. Este conjunto de dados carrega como Pandas DataFrame por padrão. Se houver alguma função no DataFrame do Pandas, ela funciona neste DataFrame.
A seguinte linha de código ajudará você a importar o conjunto de dados -
# Seaborn for plotting and styling
import seaborn as sb
df = sb.load_dataset('tips')
print df.head()
A linha de código acima irá gerar a seguinte saída -
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4
Para visualizar todos os conjuntos de dados disponíveis na biblioteca Seaborn, você pode usar o seguinte comando com o get_dataset_names() função conforme mostrado abaixo -
import seaborn as sb
print sb.get_dataset_names()
A linha de código acima retornará a lista de conjuntos de dados disponíveis como a seguinte saída
[u'anscombe', u'attention', u'brain_networks', u'car_crashes', u'dots',
u'exercise', u'flights', u'fmri', u'gammas', u'iris', u'planets', u'tips',
u'titanic']
DataFramesarmazene dados na forma de grades retangulares pelas quais os dados podem ser facilmente visualizados. Cada linha da grade retangular contém valores de uma instância e cada coluna da grade é um vetor que contém dados para uma variável específica. Isso significa que as linhas de um DataFrame não precisam conter valores do mesmo tipo de dados, eles podem ser numéricos, caracteres, lógicos, etc. DataFrames para Python vêm com a biblioteca Pandas e são definidos como estruturas de dados rotuladas bidimensionais com tipos de colunas potencialmente diferentes.
Para obter mais detalhes sobre DataFrames, visite nosso tutorial sobre pandas.
Visualizar dados é uma etapa e tornar os dados visualizados mais agradáveis é outra etapa. A visualização desempenha um papel vital na comunicação de insights quantitativos a um público para chamar sua atenção.
Estética significa um conjunto de princípios voltados para a natureza e a valorização da beleza, principalmente na arte. A visualização é uma arte de representar dados da maneira mais fácil e eficaz possível.
A biblioteca Matplotlib suporta altamente a personalização, mas saber quais configurações ajustar para obter um gráfico atraente e antecipado é o que se deve estar ciente para usá-lo. Ao contrário do Matplotlib, o Seaborn vem com temas personalizados e uma interface de alto nível para personalizar e controlar a aparência das figuras Matplotlib.
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
sinplot()
plt.show()
É assim que um gráfico se parece com os padrões Matplotlib -
Para alterar o mesmo gráfico para os padrões Seaborn, use o set() função -
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set()
sinplot()
plt.show()
Resultado
As duas figuras acima mostram a diferença nos gráficos padrão de Matplotlib e Seaborn. A representação dos dados é a mesma, mas o estilo de representação varia em ambos.
Basicamente, o Seaborn divide os parâmetros Matplotlib em dois grupos−
- Estilos de plotagem
- Escala do gráfico
Estilos de bonecos marinhos
A interface para manipular os estilos é set_style(). Usando esta função você pode definir o tema do enredo. De acordo com a última versão atualizada, abaixo estão os cinco temas disponíveis.
- Darkgrid
- Whitegrid
- Dark
- White
- Ticks
Vamos tentar aplicar um tema da lista mencionada acima. O tema padrão do enredo serádarkgrid que vimos no exemplo anterior.
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("whitegrid")
sinplot()
plt.show()
Resultado
A diferença entre os dois gráficos acima é a cor de fundo
Removendo Espinhos de Machado
Nos temas branco e carrapato, podemos remover as espinhas do eixo superior e direito usando o despine() função.
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("white")
sinplot()
sb.despine()
plt.show()
Resultado
Nos gráficos regulares, usamos apenas os eixos esquerdo e inferior. Usando odespine() função, podemos evitar os spines dos eixos direito e superior desnecessários, que não são suportados no Matplotlib.
Substituindo os Elementos
Se você quiser personalizar os estilos Seaborn, você pode passar um dicionário de parâmetros para o set_style() função. Os parâmetros disponíveis são visualizados usandoaxes_style() função.
Exemplo
import seaborn as sb
print sb.axes_style
Resultado
{'axes.axisbelow' : False,
'axes.edgecolor' : 'white',
'axes.facecolor' : '#EAEAF2',
'axes.grid' : True,
'axes.labelcolor' : '.15',
'axes.linewidth' : 0.0,
'figure.facecolor' : 'white',
'font.family' : [u'sans-serif'],
'font.sans-serif' : [u'Arial', u'Liberation
Sans', u'Bitstream Vera Sans', u'sans-serif'],
'grid.color' : 'white',
'grid.linestyle' : u'-',
'image.cmap' : u'Greys',
'legend.frameon' : False,
'legend.numpoints' : 1,
'legend.scatterpoints': 1,
'lines.solid_capstyle': u'round',
'text.color' : '.15',
'xtick.color' : '.15',
'xtick.direction' : u'out',
'xtick.major.size' : 0.0,
'xtick.minor.size' : 0.0,
'ytick.color' : '.15',
'ytick.direction' : u'out',
'ytick.major.size' : 0.0,
'ytick.minor.size' : 0.0}
Alterar os valores de qualquer um dos parâmetros alterará o estilo do gráfico.
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("darkgrid", {'axes.axisbelow': False})
sinplot()
sb.despine()
plt.show()
Resultado
Dimensionando os Elementos do Plot
Também temos controle sobre os elementos do gráfico e podemos controlar a escala do gráfico usando o set_context()função. Temos quatro modelos predefinidos para contextos, com base no tamanho relativo, os contextos são nomeados da seguinte forma
- Paper
- Notebook
- Talk
- Poster
Por padrão, o contexto é definido como notebook; e foi usado nas parcelas acima.
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("darkgrid", {'axes.axisbelow': False})
sinplot()
sb.despine()
plt.show()
Resultado
O tamanho de saída do gráfico real é maior quando comparado aos gráficos acima.
Note - Devido ao dimensionamento das imagens em nossa página da web, você pode perder a diferença real em nossos gráficos de exemplo.
A cor desempenha um papel importante do que qualquer outro aspecto nas visualizações. Quando usada de forma eficaz, a cor agrega mais valor ao gráfico. Uma paleta significa uma superfície plana na qual um pintor organiza e mistura tintas.
Paleta de cores de construção
Seaborn fornece uma função chamada color_palette(), que pode ser usado para dar cores às tramas e agregar mais valor estético a elas.
Uso
seaborn.color_palette(palette = None, n_colors = None, desat = None)
Parâmetro
A tabela a seguir lista os parâmetros para a construção da paleta de cores -
Sr. Não. | Palatte e descrição |
---|---|
1 | n_colors Número de cores na paleta. Se Nenhum, o padrão dependerá de como a paleta é especificada. Por padrão, o valor den_colors tem 6 cores. |
2 | desat Proporção para dessaturar cada cor. |
Retorna
Return refere-se à lista de tuplas RGB. A seguir estão as paletas Seaborn prontamente disponíveis -
- Deep
- Muted
- Bright
- Pastel
- Dark
- Colorblind
Além destes, também se pode gerar uma nova paleta
É difícil decidir qual paleta deve ser usada para um determinado conjunto de dados sem conhecer as características dos dados. Conscientes disso, classificaremos as diferentes formas de usocolor_palette() tipos -
- qualitative
- sequential
- diverging
Temos outra função seaborn.palplot()que lida com paletas de cores. Esta função plota a paleta de cores como matriz horizontal. Saberemos mais sobreseaborn.palplot() nos próximos exemplos.
Paletas de cores qualitativas
Paletas qualitativas ou categóricas são mais adequadas para plotar os dados categóricos.
Exemplo
from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(current_palette)
plt.show()
Resultado
Não passamos nenhum parâmetro em color_palette();por padrão, estamos vendo 6 cores. Você pode ver o número desejado de cores passando um valor para on_colorsparâmetro. Aqui opalplot() é usado para plotar a matriz de cores horizontalmente.
Paletas de cores sequenciais
Os gráficos sequenciais são adequados para expressar a distribuição de dados que variam de valores mais baixos relativos a valores mais altos dentro de um intervalo.
Anexar um caractere adicional 's' à cor passada para o parâmetro de cor traçará o gráfico Sequencial.
Exemplo
from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette("Greens"))
plt.show()
Note −Precisamos adicionar 's' ao parâmetro como 'Verdes' no exemplo acima.
Paleta de cores divergentes
Paletas divergentes usam duas cores diferentes. Cada cor representa a variação no valor que varia de um ponto comum em qualquer direção.
Suponha que plote os dados que variam de -1 a 1. Os valores de -1 a 0 usam uma cor e 0 a +1 usa outra cor.
Por padrão, os valores são centrados em zero. Você pode controlá-lo com o parâmetro center passando um valor.
Exemplo
from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette("BrBG", 7))
plt.show()
Resultado
Configurando a paleta de cores padrão
As funções color_palette() tem um companheiro chamado set_palette()A relação entre eles é semelhante à dos pares abordados no capítulo de estética. Os argumentos são os mesmos para ambosset_palette() e color_palette(), mas os parâmetros padrão do Matplotlib são alterados para que a paleta seja usada para todos os gráficos.
Exemplo
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("white")
sb.set_palette("husl")
sinplot()
plt.show()
Resultado
Traçando distribuição univariada
A distribuição de dados é a coisa mais importante que precisamos entender ao analisar os dados. Aqui, veremos como o seaborn nos ajuda a entender a distribuição univariada dos dados.
Função distplot()fornece a maneira mais conveniente de dar uma olhada rápida na distribuição univariada. Esta função irá traçar um histograma que se ajusta à estimativa de densidade do kernel dos dados.
Uso
seaborn.distplot()
Parâmetros
A tabela a seguir lista os parâmetros e suas descrições -
Sr. Não. | Parâmetro e Descrição |
---|---|
1 | data Série, array 1d ou uma lista |
2 | bins Especificação de bins hist |
3 | hist bool |
4 | kde bool |
Esses são parâmetros básicos e importantes a serem observados.
Os histogramas representam a distribuição dos dados formando caixas ao longo do intervalo dos dados e, a seguir, desenhando barras para mostrar o número de observações que caem em cada caixa.
Seaborn vem com alguns conjuntos de dados e usamos poucos conjuntos de dados em nossos capítulos anteriores. Aprendemos como carregar o conjunto de dados e como consultar a lista de conjuntos de dados disponíveis.
Seaborn vem com alguns conjuntos de dados e usamos poucos conjuntos de dados em nossos capítulos anteriores. Aprendemos como carregar o conjunto de dados e como consultar a lista de conjuntos de dados disponíveis.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'],kde = False)
plt.show()
Resultado
Aqui, kdesinalizador é definido como False. Como resultado, a representação do gráfico de estimativa do kernel será removida e apenas o histograma será plotado.
A estimativa de densidade do kernel (KDE) é uma maneira de estimar a função de densidade de probabilidade de uma variável aleatória contínua. É usado para análises não paramétricas.
Configurando o hist sinalizar como falso em distplot irá produzir o gráfico de estimativa da densidade do kernel.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'],hist=False)
plt.show()
Resultado
Distribuição Paramétrica de Ajuste
distplot() é usado para visualizar a distribuição paramétrica de um conjunto de dados.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'])
plt.show()
Resultado
Plotando distribuição bivariada
A distribuição bivariada é usada para determinar a relação entre duas variáveis. Isso lida principalmente com o relacionamento entre duas variáveis e como uma variável está se comportando em relação à outra.
A melhor maneira de analisar a distribuição bivariada em peixes do mar é usando o jointplot() função.
Jointplot cria uma figura de vários painéis que projeta a relação bivariada entre duas variáveis e também a distribuição univariada de cada variável em eixos separados.
Gráfico de dispersão
O gráfico de dispersão é a maneira mais conveniente de visualizar a distribuição onde cada observação é representada em um gráfico bidimensional através dos eixos xey.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df)
plt.show()
Resultado
A figura acima mostra a relação entre o petal_length e petal_widthnos dados da íris. Uma tendência no gráfico diz que existe correlação positiva entre as variáveis em estudo.
Hexbin Plot
O binning hexagonal é usado na análise de dados bivariados quando os dados são esparsos em densidade, ou seja, quando os dados estão muito dispersos e difíceis de analisar por meio de gráficos de dispersão.
Um parâmetro de adição chamado 'tipo' e valor 'hex' traça o gráfico hexbin.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df,kind = 'hex')
plt.show()
Estimativa de densidade do kernel
A estimativa da densidade do kernel é uma forma não paramétrica de estimar a distribuição de uma variável. No seaborn, podemos traçar um kde usandojointplot().
Passe o valor 'kde' para o tipo de parâmetro para traçar o gráfico do kernel.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df,kind = 'hex')
plt.show()
Resultado
Os conjuntos de dados em estudo em tempo real contêm muitas variáveis. Nesses casos, a relação entre cada uma das variáveis deve ser analisada. Traçar a distribuição bivariada para combinações (n, 2) será um processo muito complexo e demorado.
Para plotar várias distribuições bivariadas de pares em um conjunto de dados, você pode usar o pairplot()função. Isso mostra a relação para (n, 2) combinação de variável em um DataFrame como uma matriz de gráficos e os gráficos diagonais são os gráficos univariados.
Eixos
Nesta seção, aprenderemos o que são eixos, seu uso, parâmetros e assim por diante.
Uso
seaborn.pairplot(data,…)
Parâmetros
A tabela a seguir lista os parâmetros para eixos -
Sr. Não. | Parâmetro e Descrição |
---|---|
1 | data Quadro de dados |
2 | hue Variável em dados para mapear aspectos de plotagem para cores diferentes. |
3 | palette Conjunto de cores para mapear a variável matiz |
4 | kind Tipo de trama para as relações de não identidade. {'scatter', 'reg'} |
5 | diag_kind Tipo de plotagem para subtramas diagonais. {'hist', 'kde'} |
Exceto os dados, todos os outros parâmetros são opcionais. Existem alguns outros parâmetros quepairplotpode aceitar. Os parâmetros mencionados acima são freqüentemente usados.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.set_style("ticks")
sb.pairplot(df,hue = 'species',diag_kind = "kde",kind = "scatter",palette = "husl")
plt.show()
Resultado
Podemos observar as variações em cada parcela. Os gráficos estão em formato de matriz onde o nome da linha representa o eixo xe o nome da coluna representa o eixo y.
Os gráficos diagonais são gráficos de densidade de kernel, onde os outros gráficos são gráficos de dispersão, conforme mencionado.
Em nossos capítulos anteriores, aprendemos sobre gráficos de dispersão, gráficos hexbin e gráficos kde que são usados para analisar as variáveis contínuas em estudo. Esses gráficos não são adequados quando a variável em estudo é categórica.
Quando uma ou ambas as variáveis em estudo são categóricas, usamos gráficos como striplot (), swarmplot (), etc ,. Seaborn fornece interface para fazer isso.
Gráficos de dispersão categóricos
Nesta seção, aprenderemos sobre gráficos de dispersão categóricos.
stripplot ()
stripplot () é usado quando uma das variáveis em estudo é categórica. Ele representa os dados em ordem classificada ao longo de qualquer um dos eixos.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.stripplot(x = "species", y = "petal_length", data = df)
plt.show()
Resultado
No gráfico acima, podemos ver claramente a diferença de petal_lengthem cada espécie. Mas, o maior problema com o gráfico de dispersão acima é que os pontos no gráfico de dispersão estão sobrepostos. Usamos o parâmetro 'Jitter' para lidar com esse tipo de cenário.
Jitter adiciona algum ruído aleatório aos dados. Este parâmetro ajustará as posições ao longo do eixo categórico.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.stripplot(x = "species", y = "petal_length", data = df, jitter = Ture)
plt.show()
Resultado
Agora, a distribuição dos pontos pode ser vista facilmente.
Swarmplot ()
Outra opção que pode ser usada como alternativa para 'Jitter' é a função swarmplot(). Esta função posiciona cada ponto do gráfico de dispersão no eixo categórico e, assim, evita pontos sobrepostos -
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.swarmplot(x = "species", y = "petal_length", data = df)
plt.show()
Resultado
Em gráficos de dispersão categóricos que tratamos no capítulo anterior, a abordagem torna-se limitada nas informações que pode fornecer sobre a distribuição de valores dentro de cada categoria. Agora, indo mais longe, vamos ver o que pode nos facilitar na realização de comparação em categorias.
Box Plots
Boxplot é uma maneira conveniente de visualizar a distribuição de dados por meio de seus quartis.
Os gráficos de caixa geralmente têm linhas verticais que se estendem das caixas, que são denominadas de bigodes. Esses bigodes indicam variabilidade fora dos quartis superior e inferior, portanto, os Box Plots também são denominados comobox-and-whisker trama e box-and-whisker diagrama. Quaisquer outliers nos dados são plotados como pontos individuais.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.swarmplot(x = "species", y = "petal_length", data = df)
plt.show()
Resultado
Os pontos no gráfico indicam o outlier.
Tramas de violino
Os Violin Plots são uma combinação do box plot com as estimativas de densidade do kernel. Portanto, esses gráficos são mais fáceis de analisar e compreender a distribuição dos dados.
Vamos usar o conjunto de dados de dicas chamado para aprender mais sobre tramas de violino. Este conjunto de dados contém as informações relacionadas às dicas dadas pelos clientes em um restaurante.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y = "total_bill", data=df)
plt.show()
Resultado
Os valores de quartil e bigode do boxplot são mostrados dentro do violino. Como o enredo do violino usa o KDE, a parte mais larga do violino indica a densidade mais alta e a região estreita representa densidade relativamente mais baixa. O intervalo interquartil no boxplot e a porção de densidade mais alta no kde estão na mesma região de cada categoria do plot de violino.
O gráfico acima mostra a distribuição de total_bill em quatro dias da semana. Mas, além disso, se quisermos ver como a distribuição se comporta em relação ao sexo, vamos explorá-la no exemplo abaixo.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y = "total_bill",hue = 'sex', data = df)
plt.show()
Resultado
Agora podemos ver claramente o comportamento de gastos entre homens e mulheres. Podemos facilmente dizer que os homens faturam mais do que as mulheres olhando para a trama.
E, se a variável hue tiver apenas duas classes, podemos embelezar o enredo dividindo cada violino em dois, em vez de dois violinos em um determinado dia. Qualquer uma das partes do violino se refere a cada classe na variável hue.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y="total_bill",hue = 'sex', data = df)
plt.show()
Resultado
Na maioria das situações, lidamos com estimativas de toda a distribuição dos dados. Mas quando se trata de estimativa de tendência central, precisamos de uma maneira específica de resumir a distribuição. A média e a mediana são as técnicas muito utilizadas para estimar a tendência central da distribuição.
Em todas as plotagens que aprendemos na seção acima, fizemos a visualização de toda a distribuição. Agora, vamos discutir sobre os gráficos com os quais podemos estimar a tendência central da distribuição.
Bar Plot
o barplot()mostra a relação entre uma variável categórica e uma variável contínua. Os dados são representados em barras retangulares, onde o comprimento da barra representa a proporção dos dados nessa categoria.
O gráfico de barras representa a estimativa da tendência central. Vamos usar o conjunto de dados 'titânico' para aprender gráficos de barras.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.barplot(x = "sex", y = "survived", hue = "class", data = df)
plt.show()
Resultado
No exemplo acima, podemos ver o número médio de sobreviventes de machos e fêmeas em cada classe. A partir do gráfico, podemos entender que mais mulheres sobreviveram do que homens. Tanto em homens quanto em mulheres, o maior número de sobreviventes é de primeira classe.
Um caso especial no gráfico de barras é mostrar o número de observações em cada categoria, em vez de calcular uma estatística para uma segunda variável. Para isso, usamoscountplot().
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.countplot(x = " class ", data = df, palette = "Blues");
plt.show()
Resultado
O enredo diz que, o número de passageiros na terceira classe é maior do que na primeira e segunda classes.
Gráficos de pontos
Os gráficos de pontos funcionam da mesma forma que os gráficos de barra, mas em um estilo diferente. Em vez da barra inteira, o valor da estimativa é representado pelo ponto em uma certa altura no outro eixo.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.pointplot(x = "sex", y = "survived", hue = "class", data = df)
plt.show()
Resultado
É sempre preferível usar conjuntos de dados 'longos' ou 'organizados'. Mas, às vezes, quando não temos outra opção a não ser usar um conjunto de dados de 'formato amplo', as mesmas funções também podem ser aplicadas a dados de formato amplo em uma variedade de formatos, incluindo Pandas Data Frames ou NumPy bidimensional matrizes. Esses objetos devem ser passados diretamente para o parâmetro de dados, as variáveis xey devem ser especificadas como strings
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.boxplot(data = df, orient = "h")
plt.show()
Resultado
Além disso, essas funções aceitam vetores de objetos Pandas ou NumPy em vez de variáveis em um DataFrame.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.boxplot(data = df, orient = "h")
plt.show()
Resultado
A principal vantagem de usar o Seaborn para muitos desenvolvedores no mundo Python é que ele pode usar o objeto DataFrame do pandas como parâmetro.
Os dados categóricos podem ser visualizados usando dois gráficos, você pode usar as funções pointplot(), ou a função de nível superior factorplot().
Factorplot
Factorplot desenha um gráfico categórico em um FacetGrid. Usando o parâmetro 'kind', podemos escolher o gráfico como boxplot, violinplot, barplot e stripplot. FacetGrid usa pointplot por padrão.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = pulse", hue = "kind",data = df);
plt.show()
Resultado
Podemos usar gráficos diferentes para visualizar os mesmos dados usando o kind parâmetro.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = "pulse", hue = "kind", kind = 'violin',data = df);
plt.show()
Resultado
No factorplot, os dados são plotados em uma grade de faceta.
O que é Facet Grid?
Facet grid forma uma matriz de painéis definidos por linha e coluna, dividindo as variáveis. Devido aos painéis, um único gráfico se parece com vários gráficos. É muito útil analisar todas as combinações em duas variáveis discretas.
Vamos visualizar acima a definição com um exemplo
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = "pulse", hue = "kind", kind = 'violin', col = "diet", data = df);
plt.show()
Resultado
A vantagem de usar o Facet é que podemos inserir outra variável no gráfico. O gráfico acima é dividido em dois gráficos com base em uma terceira variável chamada 'dieta' usando o parâmetro 'col'.
Podemos fazer muitas facetas de coluna e alinhá-las com as linhas da grade -
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.factorplot("alive", col = "deck", col_wrap = 3,data = df[df.deck.notnull()],kind = "count")
plt.show()
resultado
Na maioria das vezes, usamos conjuntos de dados que contêm várias variáveis quantitativas, e o objetivo de uma análise é relacionar essas variáveis entre si. Isso pode ser feito por meio das linhas de regressão.
Ao construir os modelos de regressão, costumamos verificar multicollinearity,onde tivemos que ver a correlação entre todas as combinações de variáveis contínuas e tomaremos as medidas necessárias para remover a multicolinearidade, se houver. Nesses casos, as técnicas a seguir ajudam.
Funções para desenhar modelos de regressão linear
Existem duas funções principais no Seaborn para visualizar uma relação linear determinada por meio de regressão. Essas funções sãoregplot() e lmplot().
regplot vs lmplot
regplot | lmplot |
---|---|
aceita as variáveis xey em uma variedade de formatos, incluindo matrizes numpy simples, objetos da série pandas ou como referências a variáveis em um DataFrame do pandas | tem dados como um parâmetro obrigatório e as variáveis xey devem ser especificadas como strings. Este formato de dados é chamado de dados de "formato longo" |
Vamos agora desenhar os gráficos.
Exemplo
Plotagem do regplot e, em seguida, lmplot com os mesmos dados neste exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.regplot(x = "total_bill", y = "tip", data = df)
sb.lmplot(x = "total_bill", y = "tip", data = df)
plt.show()
Resultado
Você pode ver a diferença de tamanho entre duas parcelas.
Também podemos ajustar uma regressão linear quando uma das variáveis assume valores discretos
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.lmplot(x = "size", y = "tip", data = df)
plt.show()
Resultado
Adaptando-se a diferentes tipos de modelos
O modelo de regressão linear simples usado acima é muito simples de ajustar, mas na maioria dos casos, os dados são não lineares e os métodos acima não podem generalizar a linha de regressão.
Vamos usar o conjunto de dados de Anscombe com os gráficos de regressão -
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x="x", y="y", data=df.query("dataset == 'I'"))
plt.show()
Nesse caso, os dados são adequados para o modelo de regressão linear com menos variância.
Vejamos outro exemplo em que os dados apresentam alto desvio, o que mostra que a linha de melhor ajuste não é boa.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x = "x", y = "y", data = df.query("dataset == 'II'"))
plt.show()
Resultado
O gráfico mostra o alto desvio dos pontos de dados da linha de regressão. Essa ordem não linear superior pode ser visualizada usando olmplot() e regplot().Estes podem ajustar um modelo de regressão polinomial para explorar tipos simples de tendências não lineares no conjunto de dados -
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x = "x", y = "y", data = df.query("dataset == 'II'"),order = 2)
plt.show()
Resultado
Uma abordagem útil para explorar dados de dimensão média é desenhar várias instâncias do mesmo gráfico em diferentes subconjuntos de seu conjunto de dados.
Essa técnica é comumente chamada de “plotagem em rede”, ou “treliça”, e está relacionada à ideia de “pequenos múltiplos”.
Para usar esses recursos, seus dados devem estar em um DataFrame do Pandas.
Plotando pequenos múltiplos de subconjuntos de dados
No capítulo anterior, vimos o exemplo FacetGrid em que a classe FacetGrid ajuda a visualizar a distribuição de uma variável, bem como o relacionamento entre várias variáveis separadamente dentro de subconjuntos de seu conjunto de dados usando vários painéis.
Um FacetGrid pode ser desenhado com até três dimensões - linha, coluna e matiz. Os dois primeiros têm correspondência óbvia com a matriz de eixos resultante; pense na variável de matiz como uma terceira dimensão ao longo de um eixo de profundidade, onde diferentes níveis são plotados com cores diferentes.
FacetGrid O objeto recebe um dataframe como entrada e os nomes das variáveis que formarão as dimensões de linha, coluna ou matiz da grade.
As variáveis devem ser categóricas e os dados em cada nível da variável serão usados para uma faceta ao longo desse eixo.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "time")
plt.show()
Resultado
No exemplo acima, acabamos de inicializar o facetgrid objeto que não desenha nada sobre eles.
A abordagem principal para visualizar dados nesta grade é com o FacetGrid.map()método. Vejamos a distribuição de dicas em cada um desses subconjuntos, usando um histograma.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "time")
g.map(plt.hist, "tip")
plt.show()
Resultado
O número de plotagens é maior que um por causa do parâmetro col. Discutimos sobre o parâmetro col em nossos capítulos anteriores.
Para fazer um gráfico relacional, passe os nomes de várias variáveis.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "sex", hue = "smoker")
g.map(plt.scatter, "total_bill", "tip")
plt.show()
Resultado
PairGrid nos permite desenhar uma grade de subtramas usando o mesmo tipo de gráfico para visualizar os dados.
Ao contrário do FacetGrid, ele usa diferentes pares de variáveis para cada subplot. Ele forma uma matriz de subtramas. Às vezes também é chamado de “matriz de gráfico de dispersão”.
O uso de pairgrid é semelhante ao facetgrid. Inicialize primeiro a grade e depois passe a função de plotagem.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map(plt.scatter);
plt.show()
Também é possível plotar uma função diferente na diagonal para mostrar a distribuição univariada da variável em cada coluna.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()
Resultado
Podemos personalizar a cor desses gráficos usando outra variável categórica. Por exemplo, o conjunto de dados da íris tem quatro medições para cada uma das três espécies diferentes de flores da íris, então você pode ver como elas diferem.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()
Resultado
Podemos usar uma função diferente nos triângulos superior e inferior para ver diferentes aspectos do relacionamento.
Exemplo
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_upper(plt.scatter)
g.map_lower(sb.kdeplot, cmap = "Blues_d")
g.map_diag(sb.kdeplot, lw = 3, legend = False);
plt.show()