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()

Resultado