Criando Gráficos com Eixo Quebrado em Python

Beginner

This tutorial is from open-source community. Access the source code

Introdução

A visualização de dados frequentemente apresenta desafios ao lidar com outliers (valores discrepantes). Esses valores extremos podem comprimir a maioria dos seus pontos de dados, dificultando a observação de padrões ou detalhes importantes. Um gráfico com eixo quebrado (broken axis plot) oferece uma solução elegante, "quebrando" o eixo para mostrar diferentes intervalos de valores, permitindo que você se concentre tanto na distribuição principal dos dados quanto nos outliers simultaneamente.

Neste tutorial, aprenderemos como criar um gráfico com eixo quebrado usando Matplotlib em Python. Essa técnica é particularmente útil ao visualizar conjuntos de dados com disparidades significativas de valores, permitindo uma representação mais clara tanto dos dados normais quanto dos valores extremos.

Dicas para a VM

Após a inicialização da VM ser concluída, clique no canto superior esquerdo para mudar para a aba Notebook e acessar o Jupyter Notebook para praticar.

click-notebook

Você pode precisar esperar alguns segundos para que o Jupyter Notebook termine de carregar. Devido a limitações no Jupyter Notebook, a validação das operações não pode ser automatizada.

Se você encontrar algum problema durante este laboratório, sinta-se à vontade para pedir ajuda ao Labby. Por favor, forneça feedback após a sessão para que possamos resolver prontamente quaisquer problemas que você tenha experimentado.

Preparando o Ambiente e Criando Dados

Nesta primeira etapa, configuraremos nosso ambiente de trabalho importando as bibliotecas necessárias e criando dados de exemplo para nossa visualização. Nos concentraremos em gerar dados que incluem alguns outliers (valores discrepantes), o que demonstrará o valor de usar um gráfico com eixo quebrado.

Importando as Bibliotecas Necessárias

Vamos começar importando as bibliotecas que precisamos para este tutorial. Usaremos Matplotlib para criar nossas visualizações e NumPy para gerar e manipular dados numéricos.

Crie uma nova célula no seu Jupyter Notebook e digite o seguinte código:

import matplotlib.pyplot as plt
import numpy as np

print(f"NumPy version: {np.__version__}")

Ao executar esta célula, você deverá ver uma saída semelhante a esta:

NumPy version: 2.0.0
numpy-version

Os números exatos das versões podem variar dependendo do seu ambiente, mas isso confirma que as bibliotecas estão devidamente instaladas e prontas para uso.

Gerando Dados de Exemplo com Outliers

Agora, vamos criar um conjunto de dados de exemplo que inclua alguns outliers. Geraremos números aleatórios e, em seguida, adicionaremos deliberadamente valores maiores a certas posições para criar nossos outliers.

Crie uma nova célula e adicione o seguinte código:

## Set random seed for reproducibility
np.random.seed(19680801)

## Generate 30 random points with values between 0 and 0.2
pts = np.random.rand(30) * 0.2

## Add 0.8 to two specific points to create outliers
pts[[3, 14]] += 0.8

## Display the first few data points to understand our dataset
print("First 10 data points:")
print(pts[:10])
print("\nData points containing outliers:")
print(pts[[3, 14]])

Ao executar esta célula, você deverá ver uma saída semelhante a:

First 10 data points:
[0.01182225 0.11765474 0.07404329 0.91088185 0.10502995 0.11190702
 0.14047499 0.01060192 0.15226977 0.06145634]

Data points containing outliers:
[0.91088185 0.97360754]

Nesta saída, você pode ver claramente que os valores nos índices 3 e 14 são muito maiores do que os outros valores. Estes são nossos outliers. A maioria dos nossos pontos de dados está abaixo de 0.2, mas esses dois outliers estão acima de 0.9, criando uma disparidade significativa em nosso conjunto de dados.

Este tipo de distribuição de dados é perfeito para demonstrar a utilidade de um gráfico com eixo quebrado. Na próxima etapa, criaremos a estrutura do gráfico e a configuraremos para exibir corretamente tanto os dados principais quanto os outliers.

Criando e Configurando o Gráfico com Eixo Quebrado

Nesta etapa, criaremos a estrutura real do gráfico com eixo quebrado. Um gráfico com eixo quebrado consiste em múltiplos subplots (subgráficos) que mostram diferentes intervalos dos mesmos dados. Configuraremos esses subplots para exibir nossos dados principais e outliers de forma eficaz.

Criando os Subplots

Primeiramente, precisamos criar dois subplots dispostos verticalmente. O subplot superior exibirá nossos outliers, enquanto o subplot inferior mostrará a maioria dos nossos pontos de dados.

Crie uma nova célula no seu notebook e adicione o seguinte código:

## Create two subplots stacked vertically with shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 6))

## Add a main title to the figure
fig.suptitle('Broken Axis Plot Example', fontsize=16)

## Plot the same data on both axes
ax1.plot(pts, 'o-', color='blue')
ax2.plot(pts, 'o-', color='blue')

## Display the figure to see both subplots
plt.tight_layout()
plt.show()
broken-axis-plot

Ao executar esta célula, você deverá ver uma figura com dois subplots, ambos mostrando os mesmos dados. Observe como os outliers comprimem o restante dos dados em ambos os gráficos, tornando difícil ver os detalhes da maioria dos pontos de dados. Este é exatamente o problema que estamos tentando resolver com um gráfico com eixo quebrado.

Configurando os Limites do Eixo Y

Agora precisamos configurar cada subplot para focar em um intervalo específico de valores y. O subplot superior se concentrará no intervalo de outliers, enquanto o subplot inferior se concentrará no intervalo de dados principais.

Crie uma nova célula e adicione o seguinte código:

## Create two subplots stacked vertically with shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 6))

## Plot the same data on both axes
ax1.plot(pts, 'o-', color='blue')
ax2.plot(pts, 'o-', color='blue')

## Set y-axis limits for each subplot
ax1.set_ylim(0.78, 1.0)    ## Top subplot shows only the outliers
ax2.set_ylim(0, 0.22)      ## Bottom subplot shows only the main data

## Add a title to each subplot
ax1.set_title('Outlier Region')
ax2.set_title('Main Data Region')

## Display the figure with adjusted y-axis limits
plt.tight_layout()
plt.show()

Ao executar esta célula, você deverá ver que cada subplot agora se concentra em um intervalo diferente de valores y. O gráfico superior mostra apenas os outliers, e o gráfico inferior mostra apenas os dados principais. Isso já melhora a visualização, mas para torná-lo um gráfico com eixo quebrado adequado, precisamos adicionar mais algumas configurações.

Ocultando as Spines e Ajustando as Marcas de Escala

Para criar a ilusão de um eixo "quebrado", precisamos ocultar as spines (bordas) de conexão entre os dois subplots e ajustar as posições das marcas de escala.

Crie uma nova célula e adicione o seguinte código:

## Create two subplots stacked vertically with shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 6))

## Plot the same data on both axes
ax1.plot(pts, 'o-', color='blue')
ax2.plot(pts, 'o-', color='blue')

## Set y-axis limits for each subplot
ax1.set_ylim(0.78, 1.0)    ## Top subplot shows only the outliers
ax2.set_ylim(0, 0.22)      ## Bottom subplot shows only the main data

## Hide the spines between ax1 and ax2
ax1.spines.bottom.set_visible(False)
ax2.spines.top.set_visible(False)

## Adjust the position of the ticks
ax1.xaxis.tick_top()          ## Move x-axis ticks to the top
ax1.tick_params(labeltop=False)  ## Hide x-axis tick labels at the top
ax2.xaxis.tick_bottom()       ## Keep x-axis ticks at the bottom

## Add labels to the plot
ax2.set_xlabel('Data Point Index')
ax2.set_ylabel('Value')
ax1.set_ylabel('Value')

plt.tight_layout()
plt.show()

Ao executar esta célula, você deverá ver que o gráfico agora tem spines ocultas entre os dois subplots, criando uma aparência mais limpa. As marcas de escala do eixo x agora estão posicionadas corretamente, com rótulos apenas na parte inferior.

Neste ponto, criamos com sucesso um gráfico com eixo quebrado básico. Na próxima etapa, adicionaremos os toques finais para deixar claro aos espectadores que o eixo está quebrado.

Adicionando os Toques Finais ao Gráfico com Eixo Quebrado

Nesta etapa final, adicionaremos os toques finais ao nosso gráfico com eixo quebrado para deixar claro que o eixo y está quebrado. Adicionaremos linhas diagonais entre os subplots para indicar a quebra e melhoraremos a aparência geral do gráfico com rótulos adequados e uma grade.

Adicionando Linhas Diagonais de Quebra

Para indicar visualmente que o eixo está quebrado, adicionaremos linhas diagonais entre os dois subplots. Esta é uma convenção comum que ajuda os espectadores a entender que alguma parte do eixo foi omitida.

Crie uma nova célula e adicione o seguinte código:

## Create two subplots stacked vertically with shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 6))

## Plot the same data on both axes
ax1.plot(pts, 'o-', color='blue')
ax2.plot(pts, 'o-', color='blue')

## Set y-axis limits for each subplot
ax1.set_ylim(0.78, 1.0)    ## Top subplot shows only the outliers
ax2.set_ylim(0, 0.22)      ## Bottom subplot shows only the main data

## Hide the spines between ax1 and ax2
ax1.spines.bottom.set_visible(False)
ax2.spines.top.set_visible(False)

## Adjust the position of the ticks
ax1.xaxis.tick_top()          ## Move x-axis ticks to the top
ax1.tick_params(labeltop=False)  ## Hide x-axis tick labels at the top
ax2.xaxis.tick_bottom()       ## Keep x-axis ticks at the bottom

## Add diagonal break lines
d = 0.5  ## proportion of vertical to horizontal extent of the slanted line
kwargs = dict(marker=[(-1, -d), (1, d)], markersize=12,
              linestyle='none', color='k', mec='k', mew=1, clip_on=False)
ax1.plot([0, 1], [0, 0], transform=ax1.transAxes, **kwargs)
ax2.plot([0, 1], [1, 1], transform=ax2.transAxes, **kwargs)

## Add labels and a title
ax2.set_xlabel('Data Point Index')
ax2.set_ylabel('Value')
ax1.set_ylabel('Value')
fig.suptitle('Dataset with Outliers', fontsize=16)

## Add a grid to both subplots for better readability
ax1.grid(True, linestyle='--', alpha=0.7)
ax2.grid(True, linestyle='--', alpha=0.7)

plt.tight_layout()
plt.subplots_adjust(hspace=0.1)  ## Adjust the space between subplots
plt.show()

Ao executar esta célula, você deverá ver o gráfico completo com eixo quebrado com linhas diagonais indicando a quebra no eixo y. O gráfico agora tem um título, rótulos de eixo e linhas de grade para melhorar a legibilidade.

Entendendo o Gráfico com Eixo Quebrado

Vamos dedicar um momento para entender os componentes-chave do nosso gráfico com eixo quebrado:

  1. Dois Subplots: Criamos dois subplots separados, cada um focado em um intervalo diferente de valores y.
  2. Spines Ocultas: Ocultamos as spines de conexão entre os subplots para criar uma separação visual.
  3. Linhas Diagonais de Quebra: Adicionamos linhas diagonais para indicar que o eixo está quebrado.
  4. Limites do Eixo Y: Definimos limites diferentes para o eixo y para cada subplot para focar em partes específicas dos dados.
  5. Linhas de Grade: Adicionamos linhas de grade para melhorar a legibilidade e facilitar a estimativa de valores.

Esta técnica é especialmente útil quando você tem outliers em seus dados que, de outra forma, comprimiriam a visualização da maioria dos seus pontos de dados. Ao "quebrar" o eixo, você pode mostrar tanto os outliers quanto a distribuição principal dos dados claramente em uma única figura.

Experimentando com o Gráfico

Agora que você entende como criar um gráfico com eixo quebrado, pode experimentar diferentes configurações. Tente alterar os limites do eixo y, adicionar mais recursos ao gráfico ou aplicar esta técnica aos seus próprios dados.

Por exemplo, você pode modificar o código anterior para incluir uma legenda, alterar o esquema de cores ou ajustar os estilos dos marcadores:

## Create two subplots stacked vertically with shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 6))

## Plot the same data on both axes with different styles
ax1.plot(pts, 'o-', color='darkblue', label='Data Points', linewidth=2)
ax2.plot(pts, 'o-', color='darkblue', linewidth=2)

## Mark the outliers with a different color
outlier_indices = [3, 14]
ax1.plot(outlier_indices, pts[outlier_indices], 'ro', markersize=8, label='Outliers')

## Set y-axis limits for each subplot
ax1.set_ylim(0.78, 1.0)    ## Top subplot shows only the outliers
ax2.set_ylim(0, 0.22)      ## Bottom subplot shows only the main data

## Hide the spines between ax1 and ax2
ax1.spines.bottom.set_visible(False)
ax2.spines.top.set_visible(False)

## Adjust the position of the ticks
ax1.xaxis.tick_top()          ## Move x-axis ticks to the top
ax1.tick_params(labeltop=False)  ## Hide x-axis tick labels at the top
ax2.xaxis.tick_bottom()       ## Keep x-axis ticks at the bottom

## Add diagonal break lines
d = 0.5  ## proportion of vertical to horizontal extent of the slanted line
kwargs = dict(marker=[(-1, -d), (1, d)], markersize=12,
              linestyle='none', color='k', mec='k', mew=1, clip_on=False)
ax1.plot([0, 1], [0, 0], transform=ax1.transAxes, **kwargs)
ax2.plot([0, 1], [1, 1], transform=ax2.transAxes, **kwargs)

## Add labels and a title
ax2.set_xlabel('Data Point Index')
ax2.set_ylabel('Value')
ax1.set_ylabel('Value')
fig.suptitle('Dataset with Outliers - Enhanced Visualization', fontsize=16)

## Add a grid to both subplots for better readability
ax1.grid(True, linestyle='--', alpha=0.7)
ax2.grid(True, linestyle='--', alpha=0.7)

## Add a legend to the top subplot
ax1.legend(loc='upper right')

plt.tight_layout()
plt.subplots_adjust(hspace=0.1)  ## Adjust the space between subplots
plt.show()

Ao executar este código aprimorado, você deverá ver uma visualização aprimorada com outliers marcados especificamente e uma legenda explicando os pontos de dados.

Parabéns! Você criou com sucesso um gráfico com eixo quebrado em Python usando Matplotlib. Esta técnica o ajudará a criar visualizações mais eficazes ao lidar com dados que contêm outliers.

Resumo

Neste tutorial, você aprendeu como criar um gráfico com eixo quebrado usando Matplotlib em Python. Esta técnica de visualização é valiosa ao lidar com dados que contêm outliers, pois permite exibir tanto a distribuição principal dos dados quanto os outliers claramente em uma única figura.

Aqui está um resumo do que você realizou:

  1. Configuração do Ambiente e Criação de Dados: Você importou as bibliotecas necessárias e criou dados de amostra contendo outliers para demonstrar o conceito.

  2. Criando a Estrutura Básica do Gráfico: Você criou dois subplots com diferentes limites no eixo y para focar em diferentes intervalos de valores e configurou a aparência dos eixos.

  3. Aprimorando a Visualização: Você adicionou linhas diagonais de quebra para indicar o eixo quebrado, melhorou a aparência do gráfico com rótulos e uma grade, e aprendeu como personalizar ainda mais a visualização.

A técnica do eixo quebrado resolve um problema comum de visualização de dados, permitindo que os espectadores vejam simultaneamente a estrutura geral e os detalhes de um conjunto de dados, mesmo quando os outliers normalmente comprimiriam a visualização da maioria dos pontos de dados.

Você pode aplicar esta técnica às suas próprias tarefas de análise e visualização de dados sempre que precisar representar dados com intervalos de valores significativamente diferentes de maneira clara e eficaz.