Introdução

Se você chegou até aqui é porque compreende a importância da visualização de dados dentro da área de Ciência de Dados e dito isto, parto do principio que você já usou tanto plataformas como Jupyter Notebook quanto bibliotecas como Pandas, Matplotlib, Seaborn ou Plotly para análise exploratória de dados. O objetivo desse pequeno tutorial é agregar a biblioteca Altair como mais uma opção para este ferramental.

Dentro das ferramentas citadas acima, a biblioteca Altair encaixa-se em meio ao conjunto Matplotlib, Seaborn e Plotly, isto quer dizer que, se trata de uma biblioteca projetada para visualização de dados, porém a grande pergunta é: O que a Altair nos agrega que a torna diferente das bibliotecas que já conhecemos?

Altair

Altair é uma biblioteca de visualização estatística declarativa que utiliza a gramática Vega e Vega-Lite a qual possibilita descrever tanto o comportamento como a aparência de uma visualização usando o formato JSON.

Como neste tutorial nos ateremos a implementar a Altair e plotar seu primeiro gráfico a partir de uma base de dados, sugiro uma olhada no site abaixo para entender um pouco mais sobre como funciona a gramática Vega e Vega-Lite:

Let's Make A Bar Chart Tutorial

Instalação

É bastante simples a instalação da biblioteca Altair, basta utilizar o pip ou o conda, e voilà a biblioteca está pronta para ser usada.

Utilizando pip:

$ pip install altair vega_datasets

Utilizando conda:

$ conda install -c conda-forge altair vega_datasets

Existe um bônus nos dois código acima que é a instalação da base de dados vega_datasets, a qual possuí conjuntos de dados já tratados e prontos para serem usados em uma análise exploratória de dados. Com a vega_dataset já podemos começar a aprender mais sobre a biblioteca Altair, sem nos preocuparmos em procurar uma base de dados para isso. Lógico, se você não desejar a base de dados vega_dataset, basta retirá-la do comando de instalação.

Conceitos

Existem alguns conceitos que são bons de saber de antemão:

• Data: Os dados dentro da biblioteca Altair devem ser um quadro de dados (dataframe) do Pandas.
• Chart: Esta é uma classe que recebe alguns argumentos, dentro os quais está o dataframe com o qual deseja-se trabalhar.
• Chart.mark: Método que define como os dados devem ser visualizados no gráfico (linhas, pontos, barras…).
• Chart.encoding: Método que define, entre outras coisas, como os dados serão representados (eixo x, eixo y , tamanho, cor)

Mãos à obra

No Jupyter, vamos importar as bibliotecas necessárias para nossa análise exploratória de dados:

import pandas as pd
import altair as alt
from vega_datasets import data

Para este exercício, escolhemos a base de dados Cars. para dar uma olhada nas informações desta base de dados, basta escrever:

data.cars()

No próximo passo, vamos criar um dataframe df_cars que receberar a base de dados cars, retiraremos o dia e mês da coluna Year e extrairemos a marca dos carros da coluna Name, criando uma nova coluna chamada Brand. Por fim mostraremos as primeiras cinco linhas do dataframe. Esses passo de manipulação, são apenas para podermos ter mais alternativas de características para realizar plotar os gráficos.

df_cars = data.cars()

df_cars[‘Year’] = df_cars[‘Year’].dt.year

df_cars[‘Brand’] = df_cars[‘Name’].str.extract(r’^([\w\-]+)’,expand = True)

df_cars.head()

É sempre importante ver os tipos de dados do nosso dataframe, pois isto nos dirá quais tipos de trabalho poderemos fazer.

with pd.option_context(‘display.max_rows’, None):
 print(df_cars.dtypes)

Feito isto, vamos criar uma instância da classe Chart que faz parte da biblioteca Altair, e passaremos como argumento o dataframe que iremos trabalhar.

chart = alt.Chart(df_cars)

Acabamos de criar o objeto chart, a partir do qual podemos chamar os diversos métodos que nos ajudaram a criar nossas visualizações. E o primeiro método que iremos chamar é o mark_* (este asterisco mostra as diversas formas as quais podemos usar para mostrar os dados no gráfico.

chart.mark_point()

Acima definimos que desejamos usar o método mark_point() o qual nos ajuda a criar um gráfico de dispersão, mostrando os dados como pontos no gráfico. Mas só este método não basta, pois ainda não definimos quais dados farão parte do eixo X e eixo Y. Para tal, precisamos usar o método encode().

Antes de aplicar o método encode(), ainda não falamos sobre a pergunta que gostaríamos de responder com esse gráfico de dispersão. E bom, estamos curiosos para ver qual a relação entre a massa dos carros (Weight_in_libs) e sua autonomia (Miles_per_Gallon). Feito isto, agora podemos definir os dados do eixo X e eixo Y.

chart.mark_point().encode(
 x = ‘Weight_in_lbs’,
 y = ‘Miles_per_Gallon’
 )

Conseguimos ver que realmente quanto maior a massa do carro, isto é, quanto mais pesado ele é, menor fica sua autonomia.

Se você deseja customizar cada eixo do gráfico, a Altair possui um meio um pouco mais verboso, mas que ajuda neste tipo de configuração.

Neste caso trabalharemos com as classes X e Y da biblioteca Altair, dentro do método encode().

A customização que faremos será alterar a escala dos eixos, retirando o zero, para que os dados fiquem no centro do gráfico.

chart.mark_point().encode(
 alt.X(‘Weight_in_lbs’, scale=alt.Scale(zero=False)),
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False))
)

Podemos alterar a cor de cada ponto de acordo com o país de origem dos veículo.

Repare que além de inserir a classe Color, também definimos o parâmetro filled do método mark_point como True, para que os pontos sejam preenchidos.

chart.mark_point(filled=True).encode(
 alt.X(‘Weight_in_lbs’, scale=alt.Scale(zero=False)),
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False)),
 alt.Color(‘Origin’) 
)

Para adicionar informações a cada ponto no gráfico, basta usar a classe Tooltip.

No nosso caso, queremos que as informações sobre ano, nome e marca do carro apareçam sobre cada ponto, quanto o mouse pousar sobre este.

chart.mark_point(filled=True).encode(
 alt.X(‘Weight_in_lbs’, scale=alt.Scale(zero=False)),
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False)),
 alt.Color(‘Origin’),
 tooltip = [alt.Tooltip(‘Name’), 
 alt.Tooltip(‘Year’)
 ]
)

Também podemos aumentar o tamanho dos pontos com a classe Size, por exemplo, de acordo com a potência dos carros.

Para complementar adicionamos a classe OpacityValue para dar um pouco de transpareência aos pontos.

chart.mark_point(filled=True).encode(
 alt.X(‘Weight_in_lbs’, scale=alt.Scale(zero=False)),
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False)),
 alt.Color(‘Origin’),
 alt.OpacityValue(0.7),
 alt.Size(‘Horsepower’),
 tooltip = [alt.Tooltip(‘Name’), 
 alt.Tooltip(‘Year’)
 ]
 )

Se adicionarmos o métdos interactive(), damos a possibilidade de aproximar ou afastar o gráfico, para melhor vermos os pontos.

chart.mark_point(filled=True).encode(
 alt.X(‘Weight_in_lbs’, scale=alt.Scale(zero=False)),
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False)),
 alt.Color(‘Origin’),
 alt.OpacityValue(0.7),
 alt.Size(‘Horsepower’),
 tooltip = [alt.Tooltip(‘Name’), 
 alt.Tooltip(‘Year’)
 ]
).interactive()

Agora, imagine que desejassemos mostrar os dados como base no ano.

Essa ação pode ser realizada com a propriedade selection.

Antes precisamos ver qual é o maior e menor ano registrado na base de dados.

df_cars[‘Year’].max()

df_cars[‘Year’].min()

Assim nos criamos variável select_year que recebe o método selection_single no qual definimos com qual coluna trabalharemos, quando é a data inicial e qual é a faixa, que no caso vai de 1970 a 1982.

Após isto, adicionamos ao objeto chart o métdo add_selection() e o método transform_filter(), ambos métodos recebem com argumento select_year.

select_year = alt.selection_single(
 name=’Select’, fields=[‘Year’], init={‘Year’: 1970},
 bind=alt.binding_range(min=1970, max=1982, step=1)
)

chart.mark_point(filled=True).encode(
 alt.X(‘Weight_in_lbs’, scale=alt.Scale(zero=False)),
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False)),
 alt.Color(‘Origin’),
 alt.OpacityValue(0.7),
 alt.Size(‘Horsepower’),
 tooltip = [alt.Tooltip(‘Name’), 
 alt.Tooltip(‘Year’)
 ]
).interactive().add_selection(select_year).transform_filter(select_year)

Vamos ver como plotar um boxplot.

chart.mark_boxplot(size=100, extent=0.5).encode(
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False))
)

Para tornar o gráfico mais apresentável, há algumas propriedades que podemos configurar como properties(), configure_axis() e configure_mark():

chart.mark_boxplot(size=100, extent=0.5).encode(
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False))
).properties(
 width=400,
 height=400,
 title=’Distribuição da autonomia de vários carros’
).configure_axis(
 labelFontSize=14,
 titleFontSize=14
).configure_mark(
 opacity=0.6,
 color=’darkmagenta’
)

Já usamos o método transform_filter(), mas vamos usá-lo novamente para criar um filtro para que em nosso gráfico só conste carros da marca Ford.

No campo field da classe ieldOneOfPredicate definimos a coluna que vamos filtrar, e no campo oneOf um ou mais termos que não serão filtrados.

chart.mark_boxplot(size=100, extent=0.5).encode(
 alt.Y(‘Miles_per_Gallon’, scale=alt.Scale(zero=False))
).transform_filter(
 alt.FieldOneOfPredicate(
 field=’Brand’,
 oneOf=[‘ford’])
).properties(
 width=400,
 height=400,
 title=’Distribuição da autonomia de carros da Ford’
).configure_axis(
 labelFontSize=14,
 titleFontSize=14
).configure_mark(
 opacity=0.6,
 color=’darkmagenta’
)

Vamos fazer também um Histograma.

chart.mark_bar().encode(
 x=alt.X(‘Miles_per_Gallon’, bin=alt.Bin(maxbins=30)),
 y=’count()’
)

E um gráfico de linha comparando a autonomia através dos anos.

Conclusão

Há muito o que se explorar nos diversos recursos disponíveis dentro da biblioteca Altair. Sem dúvida ela se mostrou uma alternativa eficiente para criar visualizações de maneira mais simples, fazendo com que o cientista de dados volte mais sua atenção a visualização, do que a programação em si, dado que o uso da gramática Vega, em JSON torna tudo mais ágil.