DEV Community: Walter R P Cortes

Parte 1: Introdução ao dbt

Walter R P Cortes — Mon, 11 Nov 2024 00:00:00 +0000

Introdução

Considerando um cenário corporativo, a maior parte dos dados que um analista de dados tem para trabalhar já estão nos data warehouses, lake houses e afins, para que o mesmo esteja respeitando as políticas de data management e compliance. Mas o cenário se modifica quando vamos para empresas menores, que tem uma politica mais liberal de data management: é comum que os dados nos lakes precisem ser enriquecidos pelo próprio analista com arquivos de texto, planilhas, APIs ou até mesmo de páginas web enquanto tentam criar as visualizações.

A partir do momento em que os dados estão disponíveis, o próximo passo é trabalha-los para que os mesmos atendam às necessidades do projeto. Nesta fase, a biblioteca Pandas é uma das mais utilizadas para manipulação de dados em Python. Pandas é uma biblioteca de código aberto que fornece estruturas de dados de alto desempenho e fáceis de usar, além de ferramentas de análise de dados. Se considerarmos um analista que não tem background em programação, Pandas é uma excelente opção para manipulação de dados.

Para aqueles analistas com background em programação, apesar do poder que Pandas disponibiliza, sabemos que a maior parte das transformações de dados poderiam ser feitas de maneira mais tradicional e eficiente com o uso de SQL, que é a linguagem nativa dos bancos de dados relacionais e especializada para trabalhar com dados tabulares.

Mas, devido a algumas limitações, usar SQL nesta tarefa acaba não sendo tão popular. Entre os problemas mais comuns estão:

Os ambientes de desenvolvimento em SQL não tem integração nativa com ferramentas de source control, como Git
Não é possível executar testes automatizados de maneira simples
Não é possível reutilizar código de maneira eficiente.

Para resolver esses problemas e outros relacionados a modelagem e transformação de dados, é que a ferramenta dbt foi criada.

Nesta série de artigos, vamos explorar o dbt e como ele pode ser utilizado para transformar dados de maneira eficiente e escalável. Para isso, vamos criar um projeto de exemplo: um repositório de dados para ser utilizado em visualizações de dados em geral. Este projeto pode ser um bom ponto de partida para quem está começando a trabalhar com dbt e quer adicionar alfo prático ao seu portfolio.

dbt (data build tool)

O dbt é uma ferramenta de transformação de dados que permite que você escreva transformações de dados em SQL, e que você possa executar essas transformações de maneira programática, testar e documentar essas transformações.

O dbt vêm em duas versões: dbt Core e dbt Cloud. A versão dbt Core é a versão open source, que você pode instalar e rodar em sua máquina. A versão dbt Cloud é a versão paga, que roda na nuvem e que oferece funcionalidades adicionais, como agendamento de execuções, monitoramento de execuções, alertas, etc.

Este artigo irá focar na versão dbt Core.

Instalação

O dbt-core é uma ferramenta de linha de comando, e mais objetivamente, um pacote Python. Para instalar o dbt, você precisa ter o Python instalado em sua máquina. Para instalar o dbt, você pode usar o pip, o gerenciador de pacotes do Python. Para instalar o dbt, execute o seguinte comando:

pip install dbt

Após a instalação, você pode verificar se o dbt foi instalado corretamente executando o seguinte comando:

dbt --version

A saída do comando acima deve ser algo como:

dbt version: 0.21.0

A próxima etapa é baixar o driver de conexão com o banco de dados que você irá utilizar. O dbt suporta diversos bancos de dados, como PostgreSQL, Redshift, BigQuery, Snowflake, SQL Server, MySQL, SQLite, entre outros. O driver de conexão com o banco de dados que vamos utilizar aqui é do PostgreSQL, e você pode executar o seguinte comando para instala-lo:

pip install dbt-postgres

Configuração

Agora que você já instalou o dbt e o driver de conexão com o banco de dados, o próximo passo é configurar o dbt para que ele possa se conectar ao seu banco de dados. Para isso, você precisa criar um arquivo chamado profiles.yml. Este arquivo pode estar localizado em dois locais:

na pasta ~/.dbt/ no linux ou mac
na pasta do projeto. –> usaremos essa opção, para mantermos todos os arquivos em um único local.

O arquivo profiles.yml é um arquivo de configuração que contém as informações de conexão com o banco de dados. Abaixo está um exemplo de um arquivo profiles.yml:

default:
 outputs:
 dev:
 type: postgres
 host: localhost
 user: myuser
 pass: mypass
 port: 5432
 dbname: mydb
 schema: my_schema
 threads: 4
 keepalives_idle: 0
 target: dev

Neste exemplo, temos um perfil chamado dev que se conecta a um banco de dados PostgreSQL local. Você pode adicionar quantos perfis quiser, e cada perfil pode se conectar a um banco de dados diferente.

Outro fator importante é a questão de segurança. Você não deve armazenar informações sensíveis, como senhas, diretamente no arquivo profiles.yml. Para isso, você pode utilizar variáveis de ambiente. Por exemplo, você pode substituir o valor da chave pass por uma variável de ambiente chamada DBT_PASS:

default:
 outputs:
 dev:
 type: postgres
 host: localhost
 user: myuser
 pass: "{{ env_var('DBT_PASS') }}"
 port: 5432
 dbname: mydb
 schema: my_schema
 threads: 4
 keepalives_idle: 0
 target: dev

Dessa forma, você pode definir a variável de ambiente DBT_PASS no seu terminal antes de executar o dbt:

export DBT_PASS=mypass

No Windows, você pode definir variáveis de ambiente da seguinte maneira:

set DBT_PASS=mypass

Outra maneira de definir variáveis de ambiente é criar um arquivo .env na raiz do seu projeto e adicionar as variáveis de ambiente nele. O dbt irá ler automaticamente as variáveis de ambiente definidas no arquivo .env.

Exemplo de arquivo .env:

DBT_PASS=mypass

Inicializando um projeto dbt

Para inicializar um projeto dbt, você pode executar o seguinte comando:

dbt init my_project

Este comando irá criar uma estrutura de pastas e arquivos para o seu projeto dbt. A estrutura de pastas e arquivos criada é a seguinte:

my_project/
|-- analyses
|-- macros
|-- models
|-- seeds
|-- snapshots
|-- tests
|-- .env
|-- .gitignore
|-- dbt_project.yml
|-- profiles.yml

Aqui está uma breve descrição de cada pasta e arquivo:

analyses: Pasta onde você pode escrever consultas SQL que serão executadas pelo dbt. As consultas nesta pasta são consultas ad-hoc, ou seja, consultas que você executa manualmente.
macros: Pasta onde você pode escrever macros, que são consultas SQL reutilizáveis.
models: Pasta onde você escreve as transformações de dados. Cada arquivo nesta pasta é um modelo dbt.
seeds: Pasta onde você pode colocar arquivos estáticos com dados de origem - por exemplo - lista de municipios, status, …
snapshots: Pasta onde você pode escrever consultas SQL que criam snapshots de tabelas.
tests: Pasta onde você pode escrever testes para os modelos dbt.
.env: Arquivo onde você pode definir variáveis de ambiente.
.gitignore: Arquivo que contém os arquivos e pastas que você deseja ignorar no Git.
dbt_project.yml: Arquivo de configuração do projeto dbt.
profiles.yml: Arquivo de configuração de conexão com o banco de dados.

dbt_project.yml

O arquivo dbt_project.yml é o arquivo de configuração do projeto dbt. Este arquivo contém informações sobre o projeto, como o nome do projeto, a versão do projeto, o diretório onde os modelos dbt estão localizados, etc. Aqui está um exemplo de um arquivo dbt_project.yml:

name: 'pipeline'
version: '1.0.0'

# This setting configures which "profile" dbt uses for this project.
profile: 'pipeline'

model-paths: ["models"]
analysis-paths: ["analyses"]
test-paths: ["tests"]
seed-paths: ["seeds"]
macro-paths: ["macros"]
snapshot-paths: ["snapshots"]

clean-targets: # directories to be removed by `dbt clean`
 - "target"
 - "dbt_packages"

models:
 pipeline:
 # Config indicated by + and applies to all files under models/example/
 bronze:
 schema: bronze
 +materialized: table
 silver:
 schema: silver
 +materialized: table
 gold:
 schema: gold
 +materialized: table
 +post-hook: "{{ grant_and_notify(this) }}"
 src:
 schema: src
 +materialized: table
seeds:
 src:
 +schema: src
 +materialized: seed

Neste exemplo, temos um projeto chamado pipeline com três modelos: bronze, silver e gold. Cada modelo tem um esquema associado e um tipo de materialização. O tipo de materialização pode ser table, view ou incremental. O tipo de materialização table é o tipo de materialização padrão, e é usado para criar tabelas a partir de consultas SQL. O tipo de materialização view é usado para criar visualizações a partir de consultas SQL. O tipo de materialização incremental é usado para criar tabelas incrementais a partir de consultas SQL.

Este arquivo tem mais itens que são bem interessantes de aprender, e ao longo desta série de artigos, vamos voltar e abordar cada um deles.

Escrita de modelos dbt

Vamos ao ponto principal do dbt: a escrita de modelos dbt. Um modelo dbt é um arquivo .sql que contém uma consulta SQL que transforma os dados. Aqui está um exemplo de um modelo dbt:

-- bronze/my_model.sql
with my_cte as (
 select
 column1,
 column2
 from
 my_table
)
select
 column1,
 column2
from
 my_cte

Este modelo dbt é um modelo table, que cria uma tabela chamada my_model no esquema bronze. O modelo dbt contém uma consulta SQL que seleciona as colunas column1 e column2 da tabela my_table e as insere na tabela my_model.

Executando o dbt

Agore que você já tem um projeto dbt configurado e um modelo dbt escrito, você pode executar o dbt para criar as tabelas no banco de dados. Para executar o dbt, você pode usar o seguinte comando:

dbt run

Este comando irá executar todos os modelos dbt no diretório models e criar as tabelas no banco de dados. Se você quiser executar um modelo dbt específico, você pode usar o seguinte comando:

dbt run --models my_model

Este comando irá executar apenas o modelo my_model.

Conclusão

Neste artigo, você aprendeu o que é o dbt, como instalar o dbt, como configurar o dbt, como inicializar um projeto dbt, como escrever modelos dbt e como executar o dbt. Nos próximos artigos, vamos falar em maiores detalhes sobre as funcionalidades e começar efetivamente a criar o nosso repositório de dados.

Teste em Dados - Básico

Walter R P Cortes — Mon, 28 Oct 2024 00:00:00 +0000

Olá Devs!

Quando trabalhamos com dados, é necessário que, além de desenvolver todas as transformações necessárias para que os dados estejam prontos para serem utilizados na execução de análises, tenhamos uma maneira de validar a correção e validade dos dados segundo as regras que foram determinadas.

Uma maneira automatizada e eficiente de fazer isso é através da criação de testes unitários que validem os dados de acordo com as regras estabelecidas.

Vamos começar???

Obtendo os Dados

Para este artigo, vamos carregar dados que apresentam alguns erros e vamos construir os testes unitários para valida-los.

import pandas as pd

df = pd.read_csv('https://media.githubusercontent.com/media/labeduc/datasets/main/testes/problematic_data.csv')

Aqui podemos ver uma amostra dos dados:

df.sample(5)

	Unnamed: 0	ID	Name	Age	Salary	Join_Date	Category
16	16	17	Name17	56	4700	2023-05-31	Category C
12	12	13	Name13	74	4300	2023-01-31	Category B
42	42	43	Name43	74	7300	2025-07-31	Category A
13	13	14	Name14	35	4400	2023-02-28	Category B
17	17	18	Name18	35	4800	2023-06-30	Category A

Para iniciar o nosso processo de validação, precisamos realizar a primeira inspeção nos dados. Para isso, a biblioteca Pandas nos dá algumas funções bem interessantes.

# A função info() exibe informações sobre o DataFrame, 
# incluindo o tipo de dados de cada coluna, 
# valores não nulos e uso de memória.
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 50 entries, 0 to 49
Data columns (total 7 columns):
 # Column Non-Null Count Dtype 
--- ------ -------------- ----- 
 0 Unnamed: 0 50 non-null int64 
 1 ID 50 non-null int64 
 2 Name 40 non-null object
 3 Age 50 non-null object
 4 Salary 50 non-null int64 
 5 Join_Date 50 non-null object
 6 Category 50 non-null object
dtypes: int64(3), object(4)
memory usage: 2.9+ KB

Podemos perceber 2 situações que demandam maior verificação:

A coluna Name tem 10 valores nulos, o que pode ser um problema para as regra de negócio;
A coluna Age (idade) tem todas as linhas preenchidas, mas seu tipo, em vez de ser um valor do tipo inteiro, é do tipo objeto, o que infica possível problema nos dados.

O que a função info não nos mostra é a presença de valores duplicados, ou até mesmo uma linha inteira duplicada. Vamos então aprender como conseguir essas informações.

Tipos de Validação

Dataset está vazio

A proprieadade empty do DataFrame nos informa se o DataFrame está vazio ou não. Se o DataFrame estiver vazio, a propriedade retornará True, caso contrário, retornará False.

vazio = df.empty

print(f"{'' if vazio else 'Não'} está vazio")

Não está vazio

Coluna está vazia

A propriedade empty do DataFrame nos informa se a coluna está vazia ou não. Se a coluna estiver vazia, a propriedade retornará True, caso contrário, retornará False.

vazio = df['Name'].empty

print(f" Coluna Name {'' if vazio else 'Não'} está vazia")

 Coluna Name Não está vazia

Verificando Valores Nulos

Este teste visa descobrir se existem dados faltando em nosso dataset. Podemos testar de maneira geral ou coluna a coluna. Para isso, utilizamos a função isnull() que retorna True para valores nulos e False para valores não nulos.

# Testando se existe algum valor nulo
valores_nulos = df.isnull().values.any()

print(f"{'' if valores_nulos else 'Náo'} Existem Valores Nulos.")

 Existem Valores Nulos.

# O teste pode ser feito para uma coluna específica
valores_nulos = df['Name'].isnull().values.any()

print(f"A coluna Name {'tem' if valores_nulos else 'não tem'} valores nulos.")

A coluna Name tem valores nulos.

# O teste pode ser feito para uma coluna específica
valores_nulos = df['Age'].isnull().values.any()

print(f"A coluna Age {'tem' if valores_nulos else 'não tem'} valores nulos.")

A coluna Age não tem valores nulos.

Verificando os tipos de dados

Este teste visa verificar se o tipo de dados de uma coluna em todas as linhas do seu dataset é consistente com o objetivo de uso desta coluna. Por exemplo, vimos nos exemplos de dados, que a coluna Age está identificada com o tipo de dados objeto, o que certamente nos causará problemas se quisermos calcular a média de idade de nosso dataset, pois é um indicativo de que em alguma linha desta coluna, o valor não é numérico. Podemos fazer uma inspeção manual, já que estamos falando apenas de 50 linhas, mas vamos aprender a fazer isso de maneira automatizada.

# Testando se a coluna Age é do tipo numérico
# A função isna() retorna um DataFrame de valores booleanos que indicam se um elemento é um número ou não.
eh_numero = df['Age'].isna().values.any()

print(f"A coluna Age {'é' if eh_numero else 'não é'} do tipo numérico.")

A coluna Age não é do tipo numérico.

Mas que valor é este? Vamos usar outra função para descobrir.

# A função unique() retorna uma matriz de valores exclusivos em uma coluna. 
# A função tolist() converte a matriz em uma lista.
print(f" Valores únicos de Age: {df['Age'].unique().tolist()}")

 Valores únicos de Age: ['46', '19', '30', '60', '69', '36', '64', '48', '53', '52', '32', '74', '35', '56', '49', 'Unknown', '57', '44', '54', '28', '41', '39', '62', '21', '71', '42', '38', '22', '59', '55']

Ao usar a função unique(), podemos descobrir quais são os valores únicos de uma coluna. Se a coluna tiver um tipo de dados numérico, a função retornará uma lista de valores únicos. Se a coluna tiver um tipo de dados não numérico, a função retornará uma lista de strings. Existem uma ou mais linhas com o valor ‘Unknown’ na coluna Age, o que causa o comportamento que vimos anteriormente. Esse é mais um dos problemas a serem corrigidos, que o nosso teste unitário vai nos ajudar a identificar.

Outros Tipos de Validação

Veja abaixo alguns outros tipos de validação comum em testes de dados

Teste contra valores

Neste tipo de teste, verificamos se as colunas do nosso dataset respeitam, por exemplo, valores mínimos, máximos, conjunto especificos e limitados de opções, se obedecem a uma lógica dependente de outras colunas, etc.

Apenas maiores de 40 anos

# Primeiro vamos corrigir os unknown

df['Age'] = (df['Age'].apply(lambda x: 40 if x == 'Unknown' else x)).astype(int)


# Agora fazemos a validação

menores_de_quarenta = df.query('Age < 40').empty

print(f"{'Não Temos' if menores_de_quarenta else 'Temos'} menores de quarenta")

Temos menores de quarenta

Verifica contra Lista de Valores

#
categoria_invalida = (df['Category'].apply(lambda x: x not in ['Category A', 'Category B', 'Category C'])).empty

print(f"{'Não tem' if categoria_invalida else 'Tem'} categorias invalidas.")

Tem categorias invalidas.

EDA

EDA é a sigla para Exploratory Data Analysis, que em português significa Análise Exploratória de Dados. Este tipo de teste visa verificar se os dados estão de acordo com o esperado, ou seja, se estão dentro de um intervalo esperado, se não há outliers, se a distribuição dos dados está correta, etc. Ou seja, é uma análise mais aprofundada dos dados, que fazem validações mais complexas e de cunho estatístico.

Para nos ajudar com essa análise, podemos utilizar a função describe() do Pandas, que nos dá um resumo estatístico dos dados.

df.describe()

	Unnamed: 0	ID	Age	Salary
count	50.00000	50.00000	50.000000	50.000000
mean	24.50000	25.50000	46.320000	5310.000000
std	14.57738	14.57738	14.618188	1653.351574
min	0.00000	1.00000	19.000000	2000.000000
25%	12.25000	13.25000	36.500000	4025.000000
50%	24.50000	25.50000	46.000000	5350.000000
75%	36.75000	37.75000	56.000000	6675.000000
max	49.00000	50.00000	74.000000	8000.000000

Como podemos ver, a função describe() nos dá um resumo estatístico dos dados numéricos, como a média, desvio padrão, mínimo, máximo, etc. Com essas informações, podemos fazer validações mais complexas, como verificar se a média de idade está dentro de um intervalo esperado, se a distribuição dos dados está correta, etc. Mas, como podemos ver, a coluna Age não está sendo considerada como numérica, o que nos impede de fazer essas validações. Vamos corrigir isso.

# A correção aplicada foi a substituição dos valores 'Unknown' por 40 e a conversão para inteiro.
# Por que 40? Porque é um valor que não altera a média e a mediana dos dados.

df['Age'] = df['Age'].apply(lambda x: 40 if x == 'Unknown' else x).astype(int)

df.describe()

	Unnamed: 0	ID	Age	Salary
count	50.00000	50.00000	50.000000	50.000000
mean	24.50000	25.50000	46.320000	5310.000000
std	14.57738	14.57738	14.618188	1653.351574
min	0.00000	1.00000	19.000000	2000.000000
25%	12.25000	13.25000	36.500000	4025.000000
50%	24.50000	25.50000	46.000000	5350.000000
75%	36.75000	37.75000	56.000000	6675.000000
max	49.00000	50.00000	74.000000	8000.000000

Bom, agora que temos isso resolvido, vamos ao próximo passo: rodar o EDA. O EDA pode ser feito manualmente, mas vamos aprender a fazer isso de maneira automatizada. Para essa análise mais automatizada, vamos usar três ferramentas: jupyter-summarytools, sweetviz e dtale.

Jupyter-summarytools

É a versão mais bonita do describe(). Ele nos dá um resumo estatístico dos dados, mas de uma maneira mais visual e interativa. Para instalar, basta rodar o comando !pip install jupyter-summarytools no seu Jupyter Notebook.

from summarytools import dfSummary

dfSummary(df)

T_e3ff2 thead>tr>th {

text-align: left;
}

T_e3ff2_row0_col0, #T_e3ff2_row1_col0, #T_e3ff2_row2_col0, #T_e3ff2_row3_col0, #T_e3ff2_row4_col0, #T_e3ff2_row5_col0, #T_e3ff2_row6_col0 {

text-align: left;
font-size: 12px;
vertical-align: middle;
width: 5%;
max-width: 50px;
min-width: 20px;
}

T_e3ff2_row0_col1, #T_e3ff2_row1_col1, #T_e3ff2_row2_col1, #T_e3ff2_row3_col1, #T_e3ff2_row4_col1, #T_e3ff2_row5_col1, #T_e3ff2_row6_col1 {

text-align: left;
font-size: 12px;
vertical-align: middle;
width: 15%;
max-width: 200px;
min-width: 100px;
word-break: break-word;
}

T_e3ff2_row0_col2, #T_e3ff2_row1_col2, #T_e3ff2_row2_col2, #T_e3ff2_row3_col2, #T_e3ff2_row4_col2, #T_e3ff2_row5_col2, #T_e3ff2_row6_col2 {

text-align: left;
font-size: 12px;
vertical-align: middle;
width: 30%;
min-width: 100px;
}

T_e3ff2_row0_col3, #T_e3ff2_row1_col3, #T_e3ff2_row2_col3, #T_e3ff2_row3_col3, #T_e3ff2_row4_col3, #T_e3ff2_row5_col3, #T_e3ff2_row6_col3 {

text-align: left;
font-size: 12px;
vertical-align: middle;
width: 25%;
min-width: 100px;
}

T_e3ff2_row0_col4, #T_e3ff2_row1_col4, #T_e3ff2_row2_col4, #T_e3ff2_row3_col4, #T_e3ff2_row4_col4, #T_e3ff2_row5_col4, #T_e3ff2_row6_col4 {

text-align: left;
font-size: 12px;
vertical-align: middle;
width: 20%;
min-width: 150px;
}

T_e3ff2_row0_col5, #T_e3ff2_row1_col5, #T_e3ff2_row2_col5, #T_e3ff2_row3_col5, #T_e3ff2_row4_col5, #T_e3ff2_row5_col5, #T_e3ff2_row6_col5 {

text-align: left;
font-size: 12px;
vertical-align: middle;
width: 10%;
}

Table 1: Data Frame Summary
df
Dimensions: 50 x 7
Duplicates: 0

No	Variable	Stats / Values	Freqs / (% of Valid)	Missing
1	Unnamed: 0 [int64]	Mean (sd) : 24.5 (14.6) min < med < max: 0.0 < 24.5 < 49.0 IQR (CV) : 24.5 (1.7)	50 distinct values	0 (0.0%)
2	ID [int64]	Mean (sd) : 25.5 (14.6) min < med < max: 1.0 < 25.5 < 50.0 IQR (CV) : 24.5 (1.7)	50 distinct values	0 (0.0%)
3	Name [object]	1. nan 2. Name1 3. Name38 4. Name28 5. Name29 6. Name31 7. Name32 8. Name33 9. Name34 10. Name36 11. other	10 (20.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 31 (62.0%)	10 (20.0%)
4	Age [int64]	Mean (sd) : 46.3 (14.6) min < med < max: 19.0 < 46.0 < 74.0 IQR (CV) : 19.5 (3.2)	30 distinct values	0 (0.0%)
5	Salary [int64]	Mean (sd) : 5310.0 (1653.4) min < med < max: 2000.0 < 5350.0 < 8000.0 IQR (CV) : 2650.0 (3.2)	48 distinct values	0 (0.0%)
6	Join_Date [object]	1. 2022-01-31 2. 2025-02-28 3. 2024-04-30 4. 2024-05-31 5. 2024-06-30 6. 2024-07-31 7. 2024-08-31 8. 2024-09-30 9. 2024-10-31 10. 2024-11-30 11. other	1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 1 (2.0%) 40 (80.0%)	0 (0.0%)
7	Category [object]	1. Category A 2. Category B 3. Category C 4. No Category	19 (38.0%) 15 (30.0%) 13 (26.0%) 3 (6.0%)	0 (0.0%)

Sweetviz

O Sweetviz é uma ferramenta que nos dá um relatório completo dos dados, com gráficos e tabelas que nos ajudam a entender melhor os dados. Para instalar, basta rodar o comando !pip install sweetviz no seu Jupyter Notebook. Ele é muito fácil de usar, basta rodar o comando sweetviz.analyze([seu_dataframe]) e ele vai gerar um relatório completo dos seus dados.

import sweetviz as sv

my_report = sv.analyze(df)

# Exibindo o relatório no próprio notebook
# Existem outras opções de saída, como HTML e JSON.
my_report.show_notebook()

D-Tale

O D-Tale é uma ferramenta que nos dá um relatório completo dos dados, com gráficos e tabelas que nos ajudam a entender melhor os dados. Para instalar, basta rodar o comando !pip install dtale no seu Jupyter Notebook. Ele é muito fácil de usar, basta rodar o comando dtale.show([seu_dataframe]) e ele vai gerar um relatório completo dos seus dados.

import dtale

import dtale.app as dtale_app

dtale_app.USE_COLAB = True

dtale.show(df)

Infelizmente, não podemos ver o resultado aqui, mas você pode rodar no seu Jupyter Notebook ou Google Colab e ver o resultado.

Criando os testes unitários

Agora que sabemos sobre alguns dos tipos de testes que podemos aplicar aos nossos dados, vamos aprender como organizar isso de uma forma prática.

A idéia é englobar os testes aprendidos em funções que podem ser chamadas a qualquer momento, assim a cada alteração que fazemos no dataset, podemos validar o mesmo.

Em primeiro lugar, englobamos os testes que fizemos em funções.

def teste_nulos(data_frame, coluna=None):
 """Verifica se o DataFrame ou uma Coluna específica possui valores nulos.

 Returns:
 True se houver valores nulos, False caso contrário.
 """
 if coluna is None:
 return data_frame.isnull().values.any()
 else:
 return data_frame[coluna].isnull().values.any()


def teste_eh_numero(data_frame, coluna):
 """Verifica se os valores de uma coluna são numéricos.

 Returns:
 True se algum dos valores não é numérico, False caso contrário.
 """
 from pandas.api.types import is_numeric_dtype

 return is_numeric_dtype(data_frame[coluna])


def teste_vazio(data_frame, coluna=None):
 """Verifica se o DataFrame ou uma Coluna específica está vazio.

 Returns:
 True se estiver vazio, False caso contrário.
 """
 if coluna is None:
 return data_frame.empty
 else:
 return data_frame[coluna].empty


def teste_condicional(data_frame, condicao):
 """Verifica se o DataFrame atende a uma condição.

 Returns:
 True se atender a condicão, False caso contrário.
 """
 result = data_frame.query(condicao)
 return not(result.empty)


def teste_valores(data_frame, coluna, valores):
 """Verifica se os valores de uma coluna estão contidos em uma lista.

 Returns:
 True se estiver na lista, False caso contrário.
 """
 result = data_frame[coluna].apply(lambda x: x in valores).any()
 return result

A próxima etapa é criar uma função que irá chamar todas essas funções utilizando o comando assert

O comando assert é utilizado para verificar se uma expressão é verdadeira. Se a expressão for verdadeira, o programa continua a execução normalmente. Se a expressão for falsa, o programa lança uma exceção do tipo AssertionError.

def run_unit_test(data_frame):
 try:
 assert teste_nulos(data_frame) == False, 'Existem valores nulos'
 assert teste_nulos(data_frame, 'Name') == False, 'Existem valores nulos na coluna Name'
 assert teste_eh_numero(data_frame, 'Age'), 'A coluna Age não é do tipo numérico'
 assert teste_vazio(data_frame) == False, 'O data_frame está vazio'
 assert teste_condicional(data_frame, 'Age < 40') == True, 'Não tem menores de quarenta'
 assert teste_valores(data_frame, 'Category', ['Category A', 'Category B', 'Category C']) == True, 'Categoria Invalida'
 print('Testes finalizados com sucesso.')
 except AssertionError as e:
 print(e)

Tendo criado a função, agora só resta executa-la, observar as falhas, aplicar as correções e rodar os testes unitários novamente, até que todos passem.

1a Execução

run_unit_test(df)

Existem valores nulos

Para determinar isso, podemos apenas chamar a função info() do dataframe, que nos dá informações sobre o dataset, como o número de linhas, colunas, tipos de dados, etc.

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 50 entries, 0 to 49
Data columns (total 7 columns):
 # Column Non-Null Count Dtype 
--- ------ -------------- ----- 
 0 Unnamed: 0 50 non-null int64 
 1 ID 50 non-null int64 
 2 Name 40 non-null object
 3 Age 50 non-null int64 
 4 Salary 50 non-null int64 
 5 Join_Date 50 non-null object
 6 Category 50 non-null object
dtypes: int64(4), object(3)
memory usage: 2.9+ KB

O campo Name está com problema. Vamos corrigir isso.

df['Name'] = df['Name'].fillna('Desconhecido')

Agora, vamos para a segunda execução.

2a Execução

run_unit_test(df)

Testes finalizados com sucesso.

Agora, é a coluna Age que está com problema. Vamos corrigir isso.

df['Age'] = pd.to_numeric(df['Age'])

Vamos para a 3a execução.

3a Execução

run_unit_test(df)

Testes finalizados com sucesso.

Vamos ver os valores possíveis do campo Category.

df['Category'].unique().tolist()

['Category B', 'Category C', 'Category A', 'No Category']

Temos um No Category ali que está fazendo o teste falhar. Vamos corrigir isso. Mas qual seria a melhor correção? Trocar o valor por um dos válidos ou corrigir o teste? A resposta dependerá do contexto do negócio. Aqui, vamos assumir que corrigir o teste é a melhor alternativa.

def run_unit_test(data_frame):
 try:
 assert teste_nulos(data_frame) == False, "Existem valores nulos"
 assert (
 teste_nulos(data_frame, "Name") == False
 ), "Existem valores nulos na coluna Name"
 assert teste_eh_numero(data_frame, "Age"), "A coluna Age não é do tipo numérico"
 assert teste_vazio(data_frame) == False, "O data_frame está vazio"
 assert (
 teste_condicional(data_frame, "Age < 40") == True
 ), "Não tem menores de quarenta"
 assert (
 teste_valores(
 data_frame, "Category", ["Category A", "Category B", "Category C", "No Category"]
 )
 == True
 ), "Categoria Invalida"
 print("Testes finalizados com sucesso.")
 except AssertionError as e:
 print(e)

4a Execução

run_unit_test(df)

Testes finalizados com sucesso.

Agora sim, finalizamos o nosso processo de testar os dados. Agora, temos um dataset que está de acordo com as regras de negócio e podemos utilizá-lo para fazer análises.

Conclusão

Neste artigo, aprendemos como fazer testes unitários em dados utilizando a biblioteca Pandas. Vimos que é possível fazer testes simples, como verificar se o dataset está vazio, se uma coluna está vazia, se existem valores nulos, se os tipos de dados estão corretos, etc. Também vimos que é possível fazer testes mais complexos, como verificar se os valores de uma coluna estão dentro de um intervalo esperado, se obedecem a uma lógica dependente de outras colunas, etc.

Aprendemos também como organizar esses testes em funções e como criar uma função que chama todas essas funções e verifica se os testes passaram ou não. Com isso, podemos garantir que os dados estão de acordo com as regras de negócio e que podemos utilizá-los para fazer análises.

Mas é importante lembrar que os testes unitários não são a única forma de garantir a qualidade dos dados. É importante também fazer uma análise exploratória dos dados, verificar se os dados estão de acordo com o esperado, se não há outliers, se a distribuição dos dados está correta, etc. E, é claro, é importante também fazer validações manuais, para garantir que os dados estão corretos.

Um abraço e até a próxima,

Walter.

AI na Análise de Dados - Classificação de Texto com a API da OpenAI

Walter R P Cortes — Fri, 16 Jun 2023 00:00:00 +0000

Introdução

Olá, tudo bem?

A esta altura do ano de 2023, é quase impossível que você não tenha ouvido falar sobre o ChatGPT. E verdade seja dita, o ChatGPT é uma aplicação incrível, que permite sermos mais eficientes em diversas tarefas do dia dia-a-dia! Mas é importante salientar que ele é apenas uma aplicação, o que está por trás do ChatGPT e que chamamos de um LLM (Large Language Model) é o que realmente faz toda a mágica acontecer. Não iremos entrar em detalhes de como o modelo GPT (Generative Pretrained Transformer) funciona (veja os links no final do post), mas vamos explicar como podemos trazer todo esse poder para dentro de nossos códigos Python e criar scripts e aplicações que vão aumentar ainda mais nossa produtividade.

Este será o primeiro de uma série de artigos que visam auxiliar na compreensão de como as IAs podem ser assistentes poderosos para o Analista de Dados.

Classificação de Dados

Classificação de dados é uma tarefa de aprendizado supervisionado que envolve a categorização de uma determinada amostra de dados em uma das várias classes predefinidas. Cada amostra é atribuída a uma e somente uma classe, baseando-se nas características dessa amostra.

Por exemplo, imagine que você tem um conjunto de emails e você quer classificá-los como “spam” ou “não spam”. Nesse caso, “spam” e “não spam” são as classes, e cada email é uma amostra que será classificada em uma dessas classes.

A classificação é geralmente realizada utilizando algoritmos de aprendizado de máquina. Esses algoritmos aprendem a classificar novas amostras baseando-se em um conjunto de treinamento. O conjunto de treinamento é um conjunto de amostras para as quais as classes verdadeiras são conhecidas.

Os algoritmos de classificação incluem árvores de decisão, regressão logística, máquinas de vetores de suporte, redes neurais e muitos outros. A escolha do algoritmo depende de vários fatores, como a natureza dos dados, o número de classes, a necessidade de interpretabilidade e outros.

Mas e se não temos conjuntos de dados de treinamento?

Se você não tem um conjunto de dados de treinamento rotulado, ainda existem várias abordagens que você pode usar, tais como:

Aprendizado não supervisionado
Aprendizado semi-supervisionado
Aprendizado por reforço
Rotulagem manual
Geração de rótulos sintéticos
Processamento de Linguagem Natural

E é nesta última opção que podemos utilizar o GPT para nos ajudar, pois o modelo do GPT é gigantesco, tendo sido treinado com conteúdo de toda a internet.

GPT versus métodos mais tradicionais de classificação

Os modelos de linguagem como o GPT (Generative Pretrained Transformer) têm várias vantagens e desvantagens, especialmente quando comparados a outros métodos de análise de texto. Aqui estão algumas delas:

Vantagens:

Compreensão Profunda da Linguagem: O GPT é treinado em enormes quantidades de texto, o que lhe permite aprender uma rica compreensão da linguagem natural. Isso inclui uma compreensão de sintaxe, semântica, e até mesmo alguns elementos de conhecimento do mundo real.
Versatilidade: O GPT pode ser usado para uma ampla gama de tarefas de processamento de linguagem natural, incluindo tradução de texto, geração de texto, resumo de texto, análise de sentimento, resposta a perguntas e muito mais.
Aprendizado Transferível: O GPT utiliza o aprendizado transferível, o que significa que o conhecimento aprendido durante o treinamento em um grande conjunto de dados pode ser aplicado a tarefas específicas com relativamente poucos dados de treinamento adicionais. Isso permite ao GPT se adaptar a uma ampla gama de tarefas com um desempenho impressionante.
Modelagem de Contexto: A arquitetura do Transformer, utilizada pelo GPT, é especialmente boa para entender o contexto em uma sequência de texto, o que é crucial para muitas tarefas de processamento de linguagem natural.

Desvantagens:

Necessidade de Grandes Quantidades de Dados de Treinamento: O GPT precisa de grandes quantidades de dados de treinamento para aprender efetivamente. Isso pode tornar o treinamento do modelo do zero proibitivamente caro em termos de tempo e recursos computacionais.
Dificuldade de Interpretação: O GPT, como muitos modelos de aprendizado profundo, pode ser difícil de interpretar. Ele pode produzir resultados impressionantes, mas pode ser difícil entender por que fez uma determinada previsão.
Sensibilidade ao Ruído e Erros: Embora o GPT seja robusto em muitos aspectos, ele pode ser sensível a ruído e erros no texto de entrada. Pequenas mudanças no texto de entrada podem às vezes levar a grandes mudanças nas previsões do modelo.
Potencial de Viés: O GPT aprende com os dados em que é treinado, e se esses dados contêm viés, o modelo também pode exibir viés. Isso pode ser um problema significativo quando o modelo é usado em contextos sensíveis.

Ok, o GPT é legal e tudo o mais… Mas e daí?

E daí que, graças ao modelo GPT, podemos ter um classificador de texto super calibrado para nos ajudar em nossas tarefas, sem o ônus de treinar tal modelo. E podemos utilizar o GPT a partir da API da OpenAI, de maneira muito simples! Outra vantagem que vale ressaltar é que, ao contrário de modelos tradicionais de classificação, podemos atribuir múltiplas categorias ao nosso texto.

Vamos ver um exemplo?

Organizando um catálogo de artigos

Imagine o seguinte cenário: temos uma lista de todos os artigos que salvamos no site Medium. O problema desta lista é que o Medium não oferece nenhum tipo de categorização dos artigos. A única maneira de fazer isso é separando em várias listas, o que dificulta principalmente o processo de busca dos artigos. Além, é claro, de pressupor a classificação antes de ler o artigo.

Essa tarefa realmente não é trivial, e seria muito útil poder fazer isso de forma automatizada. E o primeiro problema que temos é que nossa lista tem apenas o título e a url dos artigos. Para que a classificação seja mais precisa, precisamos de pelo menos algum texto que nos ajude a ter mais contexto a respeito do artigo.

Então, vamos criar o nosso script classificador? Esse script vai executar as seguintes tarefas:

flowchart LR
  A[Carregar Lista de Arquivos] --> B
  B[Buscar Título e Resumo<br>dos Artigos] --> C
  C[Classificar Artigos] --> D[Salvar Lista de Artigos]

Inicializando o ambiente

Vamos utilizar as seguintes bibliotecas: - beautifulsoup4 - biblioteca para extrair a informação do HTML que contém a lista de artigos - openai - biblioteca para utilizar a API da openAI - requests - bibliotea para buscar informações da internet

import os
import openai
import bs4
import json

from dotenv import load_dotenv
from requests_html import HTMLSession # importando o objeto de sessão do html requests

A próxima etapa é carregar variáveis de ambiente. Lembrando que é necessário ter uma API key para usar a API da OpenAI.

load_dotenv()

openai.api_key = os.getenv("OPENAI_API_KEY")

Agora, precisamos carregar nossa lista de artigos, que está em um arquivo HTML, que podemos baixar lá no site do Medium. Vamos criar uma função, de forma que poderemos re-utilizar essa parte da rotina sempre que for necessário.

def retorna_lista(nomearquivo: str):
 html_artigos = bs4.BeautifulSoup(open(nomearquivo, "r"))
 list_artigos = html_artigos.find_all("li")

 artigos = []
 for item in list_artigos:
 record = {}
 record = {
 "titulo": item.a.text,
 "link": item.a["href"],
 "autores": None,
 "resumo": None,
 "categorias": None
 }
 artigos.append(record)
 return artigos

Este código define uma função chamada “retorna_lista” que recebe um único parâmetro chamado “nomearquivo” do tipo string. A função primeiro abre o arquivo especificado pela string “nomearquivo” usando a função “open”, lê o conteúdo e usa o método “find_all” do Beautiful Soup para procurar todos os elementos de lista no documento HTML e armazená-los na variável “list_artigos”. A função, então, inicializa uma lista vazia chamada “artigos”. Em um loop, ela itera sobre cada item da lista na variável “list_artigos” e cria um dicionário chamado “record” com três chaves: “titulo”, “link”, “autores”, “resumo” e “categorias”. Os valores para “titulo” e “link” são extraídos do texto da tag “a” e do atributo “href”, respectivamente. O valor das chaves “autores”, “resumo” e “categorias” são uma string vazia. O dicionário “record” completo é então adicionado à lista “artigos”. Depois que todos os itens da lista são processados, a função retorna a lista “artigos”.

Então, podemos utilizar essa função conforme abaixo:

artigos = retorna_lista("reading-list-medium.html")

print(f" Número de Artigos: {len(artigos)}.")

 Número de Artigos: 1865.

Vamos ver como ficou um registro:

print(json.dumps(artigos[0], indent=4))

{
    "titulo": "Prompting ChatGPT for Python Code Generation: An Effective Framework",
    "link": "https://medium.com/p/e323b2d24987",
    "autores": null,
    "resumo": null,
    "categorias": null
}

Perfeito! Estamos com os artigos preparados para buscarmos os dados extra que nos darão mais contexto para a categorização.

Para fazer isso, vamos utilizar a biblioteca requests-html. Novamente, criaremos uma função para reutilizar depois.

def retorna_campos(registro: dict):
 # Declaramos variaveis que contem seletores HTML
 # Esses seletores nos ajudarão a encontrar os elementos HTML que contém o 
 # conteúdo referente ao autor, data publicação, titulo e lead
 seletor_autor = [
 "#root > div > div > div:nth-child(3) > div > article > div > div > section > div > div:nth-child(3) > div > div > div:nth-child(2) > div > div > div > div > div > div > div > span > div > div > div > div > div > p > a", 
 "#root > div > div > div:nth-child(3) > div > article > div > div > section > div > div:nth-child(3) > div > div > div:nth-child(1) > div > div > div > div > div > div > div > span > div > div > div > div > div > p > a", 
 "#root > div > div > div:nth-child(2) > div > article > div > div > section > div > div:nth-child(2) > div > div > div > div > div > div > div > div > div > div > span > div > div > div > div > div > p > a", 
 "#root > div > div > div:nth-child(2) > div > article > div > div > section > div > div:nth-child(3) > div:nth-child(1) > div > div:nth-child(2) > div > div > div > div > div > div > div > span > div > div > div > div > div > p > a"
 ]
 seletor_titulo_lead = [
 "#root > div > div > div:nth-child(3) > div > article > div > div > section > div > div:nth-child(3) > div > div > div:nth-child(2)", "#root > div > div > div:nth-child(2) > div > article > div > div > section > div > div:nth-child(3) > div:nth-child(1) > div > div:nth-child(2)"
 ]
 
 # Inicializamos o objeto HTMLSession para fazer a coleta da informação dos artigos
 request = HTMLSession()
 try:
 print(registro["link"])
 conteudo_html = request.get(registro["link"])
 autor = "Not available"
 
 for item in seletor_autor:
 aux_autor = None
 aux_autor = conteudo_html.html.find(item, first=True)
 if aux_autor is not None:
 autor = aux_autor
 break

 head = "Not available"
 for item in seletor_titulo_lead:
 aux_head = None
 aux_head = conteudo_html.html.find(item, first=True)
 if aux_head:
 aux_lead = aux_head.find('h2', first=True)
 if aux_lead is not None:
 head = aux_lead.text
 
 registro["autores"] = autor.text
 registro["resumo"] = head
 
 return registro
 except:
 print('URL {0} com erro. Verifique.'.format(registro["link"]))
 return None

A função retorna_campos faz o scraping de dados de páginas da web, especificamente páginas de notícias ou artigos de blog do Medium. Ele pega um dicionário de “registro” como entrada, que parece conter um “link” para uma página da web.

Passo-a-Passo:

Variáveis seletor_autor e seletor_titulo_lead são listas de seletores CSS. Seletores CSS são padrões usados para selecionar os elementos que você deseja estilizar. Aqui, eles são usados para identificar os elementos HTML onde as informações de autor e título/lead estão localizadas no HTML da página.
A função então inicia uma sessão HTML usando o módulo HTMLSession() do pacote requests_html, que é uma biblioteca Python para fazer solicitações HTTP e para parsing de HTML.
A função tenta fazer uma solicitação GET para a URL que está no campo “link” do dicionário de entrada.
Em seguida, a função tenta encontrar o autor do artigo. Para isso, itera sobre a lista seletor_autor e, para cada seletor, tenta encontrar um elemento correspondente na página HTML. Se encontrar um autor, interrompe o loop e guarda o autor encontrado.
Depois disso, a função tenta encontrar o título do artigo da mesma maneira, usando a lista seletor_titulo_lead.
Os resultados são então adicionados ao dicionário de entrada no campo “autores” para o autor e “resumo” para o título.
Se houver algum erro durante o processo, como um link quebrado ou se o seletor CSS não corresponder a nenhum elemento, a função exibe uma mensagem de erro e retorna None.
Se tudo correr bem, a função retorna o dicionário de entrada, agora com informações adicionais sobre o autor e o resumo do artigo.

Agora vamos a execução da função para cada artigo em nossa lista. Observe que colocamos um limitador para fazer isso para 10 registros.

artigos_comp = []
i = 0
for item in artigos:
 artigos_comp.append(retorna_campos(item))
 i += 1
 if i == 10:
 break

https://medium.com/p/e323b2d24987
https://medium.com/p/9e9536ebd839
https://medium.com/p/bb7d31ed2e76
https://medium.com/p/2688e319e2a5
https://medium.com/p/7edae42a20b3
https://medium.com/p/f87419cb14cb
https://medium.com/p/d6169fc81204
https://medium.com/p/74361bc3b92e
https://medium.com/p/9dc1566d960d
https://medium.com/p/3c053357c47f

Agora temos os nossos artigos com título, autor e uma lead line, que vai nos ajudar no processo da categorização.

Vamos agora, a nossa rotina de categorização, usando a API do OpenAI.

def retorna_categorias(titulo, resumo):
 response = openai.Completion.create(
 engine="text-davinci-003",
 prompt=f"We have these categories: dbt, Python, DataViz, Tableau, PowerBI, and Generative AI. Given those categories, please classify the following text with those categories: {titulo} - {resumo}. You can use only the categories listed. You can classify with multiple categories. If you think that none of the categories applies, you can tag as Other.",
 temperature=0.8,
 max_tokens=20,
 )
 return response.choices[0].text.strip()

Este código define uma função chamada “retorna_categorias” que recebe dois parâmetros: “titulo” e “resumo”. A função utiliza a API OpenAI para classificar o título e o resumo com base em um conjunto de categorias previamente determinadas - dbt, Python, DataViz, Tableau, PowerBI e Generative AI. Em seguida, retorna o resultado da classificação como uma string.

A função retorna então a primeira (e única) escolha da resposta da API OpenAI, que é a string que representa a categoria que foi escolhida como a melhor correspondência para o texto de entrada. O método strip() é usado para remover qualquer espaço em branco inicial ou final da string retornada.

Observação: Para usar este código, o módulo openai precisa ser importado e uma chave de API OpenAI precisa ser obtida.

lista_final = []
for item in artigos_comp:
 item["categorias"] = retorna_categorias(item['titulo'], item['resumo'])
 lista_final.append(item)

Agora que executamos a rotina acima, podemos imprimir os três primeiros registros e verificar que agora, temos categorias.

for idx, item in enumerate(lista_final):
 print(json.dumps(item, indent=4))
 if idx == 2:
 break

{
    "titulo": "Prompting ChatGPT for Python Code Generation: An Effective Framework",
    "link": "https://medium.com/p/e323b2d24987",
    "autores": "John Loewen",
    "resumo": "I\u2019ve done the prompt engineering research so you don\u2019t have to",
    "categorias": "Python, Generative AI"
}
{
    "titulo": "Power BI: How I Started Using Python To Automate Tasks",
    "link": "https://medium.com/p/9e9536ebd839",
    "autores": "Gabe Araujo, M.Sc.",
    "resumo": "Not available",
    "categorias": "PowerBI, Python"
}
{
    "titulo": "Chat with your databases using LangChain",
    "link": "https://medium.com/p/bb7d31ed2e76",
    "autores": "Vishnu Sivan",
    "resumo": "Not available",
    "categorias": "Other"
}

E aí estão os nossos artigos, devidamente categorizados. Inclusive, podemos ver um artigo que foi classificado como “Other”, indicando que o texto que foi enviado não foi suficiente para classificar com as categorias selecionadas.

Obrigado por ler até aqui! Espero que este script seja útil para vocês!!!

Links Úteis

Understanding GPT-3: OpenAI’s Language Generation AI: Blog oficial da OpenAI sobre GPT-3 - Apresenta uma explicação detalhada do GPT-3 e seu uso potencial
Data Classification in Machine Learning - Este é um artigo do site GeeksforGeeks que explica o conceito básico de classificação de dados em aprendizado de máquina, os diferentes tipos de algoritmos de classificação e como eles funcionam.
Bibliotecas Python utilizadas no artigo:

Power BI no Jupyter!

Walter R P Cortes — Tue, 30 May 2023 00:00:00 +0000

Introdução

Se você é um entusiasta de visualização de dados, cientista de dados ou analista de negócios em busca de novas maneiras de explorar e compartilhar seus dados, este post é para você. Prepare-se para descobrir como o poder do Power BI pode ser desbloqueado dentro do Jupyter Notebook, ampliando suas possibilidades de análise e proporcionando uma experiência envolvente e interativa.

PowerBI - Rápida Introdução

O Power BI é uma poderosa ferramenta de business intelligence desenvolvida pela Microsoft, projetada para ajudar as empresas a visualizar e analisar seus dados de maneira intuitiva e interativa. Com recursos avançados de criação de relatórios, painéis e dashboards personalizados, o Power BI permite que os usuários transformem seus dados em informações acionáveis, facilitando a tomada de decisões informadas em tempo real. E todo esse poder pode ser entregue tanto de forma independente quanto integrada a outros meios, através do que chamamos de embedded reports.

Power BI Embeddings

As capacidades de embedding do Power BI permitem que os desenvolvedores incorporem relatórios, painéis e visualizações interativas do Power BI diretamente em seus aplicativos, sites ou portais. Essa funcionalidade de integração oferece uma maneira flexível e personalizada de compartilhar informações e insights com usuários finais, proporcionando uma experiência perfeita e integrada. Com as capacidades de embedding do Power BI, os desenvolvedores podem aproveitar as APIs e SDKs disponíveis para incorporar visualizações interativas em seus aplicativos existentes, personalizar a aparência e a funcionalidade, controlar a segurança e permissões de acesso aos dados e até mesmo habilitar recursos como filtragem dinâmica e interação com os dados subjacentes. Essa flexibilidade permite que as organizações integrem as poderosas capacidades analíticas do Power BI diretamente em seus fluxos de trabalho, fornecendo aos usuários acesso direto a informações relevantes e atualizadas, tudo dentro do contexto de sua própria aplicação.

Entre outros conhecimentos, para trabalhar com embeddings, é necessário compreender:

Linguagens de programação: Ter conhecimentos básicos de programação é fundamental para interagir com as APIs e SDKs do Power BI. Python, JavaScript e .NET são exemplos de linguagens comumente usadas.
Desenvolvimento web: Familiaridade com desenvolvimento web é importante para incorporar e personalizar visualizações do Power BI. Isso inclui conhecimentos em HTML, CSS e JavaScript para integrar o código do Power BI em aplicativos e sites.
Autenticação e segurança: Compreender os conceitos de autenticação e autorização é crucial para garantir a segurança dos dados. Isso envolve entender como autenticar usuários no Power BI e definir permissões de acesso adequadas.
Power BI Desktop e serviço Power BI: Ter conhecimento sobre o Power BI Desktop e o serviço Power BI é essencial. Isso inclui habilidades em criação de relatórios, painéis e visualizações interativas, além de recursos de filtragem e interação.
Modelagem e transformação de dados: Noções básicas de modelagem e transformação de dados são úteis para preparar os dados antes de incorporá-los. Isso envolve limpeza, filtragem e organização dos dados para criar visualizações eficazes.

Neste post, exploraremos a integração do Power BI com o Jupyter Notebook, combinando a flexibilidade do ambiente de codificação do Python com a riqueza de recursos do Power BI. Descobriremos como utilizar a biblioteca powerbiclient para trazer o poder do Power BI para dentro de um Jupyter Notebook.

Biblioteca `powerbiclient`

A biblioteca powerbiclient é uma ferramenta poderosa que permite interagir com o serviço do Power BI diretamente por meio de APIs. Essa biblioteca, desenvolvida pela Microsoft, fornece uma interface de programação fácil de usar para criar, publicar, atualizar e gerenciar relatórios, dashboards e conjuntos de dados no Power BI. Com o powerbiclient, os desenvolvedores podem automatizar tarefas, extrair informações e integrar o Power BI a aplicativos, permitindo a criação de soluções personalizadas e aprimorando a capacidade de visualização e análise de dados. Essa biblioteca é uma excelente opção para aqueles que desejam aproveitar ao máximo o ecossistema do Power BI e incorporar suas funcionalidades em seus próprios fluxos de trabalho e aplicativos.

Dentre todas as possibilidades que esta biblioteca oferece, vamos focar em como carregar gráficos interativos em Power BI dentro do nosso notebook Jupyter. E vamos lá, sem demora!

Preparando o ambiente

Como sempre, o nosso primeiro passo é instalar as bibliotecas que estão faltando.

$ pip install powerbiclient

Nosso próximo passo é inicializar o ambiente, chamando nossas bibliotecas.

::: {#cell-11 .cell execution_count=4}


```

 {.python .cell-code}
from powerbiclient import QuickVisualize, get_dataset_config, Report
from powerbiclient.authentication import DeviceCodeLoginAuthentication

import pandas as pd

:::

Depois disso, vamos ao código de verdade!

Carregando os dados

A primeira tarefa, como em todo o trabalho de um cientista de dados, é carregar os dados em um DataFrame.

pokemons = pd.read_csv('pokemons.csv')

Autenticando no Serviço do Power BI

Em seguida, temos que fazer a autenticação no serviço do Power BI. O Power BI, como todos os aplicativos do Office 365, requer que estejamos autenticados para utiliza-los. Aqui, o processo é simplificado, mas ainda requerido. Esse modo é o mais simples, se estiver interessado em outras maneiras, dê uma olhada mais a fundo na documentação da Microsoft.

device_auth = DeviceCodeLoginAuthentication()

Performing device flow authentication. Please follow the instructions below.
To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code A8EL2Y8WJ to authenticate.

Device flow authentication successfully completed.
You are now logged in .

The result should be passed only to trusted code in your notebook.

Visualizando!

O próximo passo é plotar o gráfico usando o Power BI. Neste post vamos explorar a classe QuickVisualize que nos entregará um tipo de sumário dos nossos dados, como em uma Análise Exploratória de Dados. Para isso, enviamos nosso DataFrame, o objeto de autenticação e chamamos a função PBI_visualize.

# Create a Power BI report from your data
PBI_visualize = QuickVisualize(get_dataset_config(pokemons), auth=device_auth)

# Render the new report
PBI_visualize

{"model_id":"43ce7f1b3c004463a9409fb5cd45a9d9","version_major":2,"version_minor":0,"quarto_mimetype":"application/vnd.jupyter.widget-view+json"}

Finalizando

E desta forma, conseguimos trazer o Power BI e todo o seu poder para dentro do nosso notebook! E essa é apenas uma das formas que temos para trabalhar com Power BI dentro do notebook! Se você quiser aprender mais, não deixe de acessar a documentação da biblioteca powerbiclient em Power BI - Jupyter.

Pandas AI - Converse com seu DataFrame

Walter R P Cortes — Mon, 29 May 2023 00:00:00 +0000

Introdução

Desde outubro do ano passado, com a liberação do ChatGPT 3.5, as interfaces conversacionais vem se popularizando de maneira muito rápida. É verdade que interfaces conversacionais não são novidade, e chatbots e assistentes virtuais vem dominando tarefas relacionadas a atendimento de clientes, mas desde o advento do ChatGPT, tem-se expandido para outras áreas de atuação.

Utilizamos o ChatGPT para criarmos resumos de textos longos, para consultar algo que ocorreu no passado, explicar conceitos e por aí vai. Já existem cursos que ensinam como utilizar o ChatGPT para criar campanhas de marketing nas redes sociais e outras tantas funções que são basicamente apoiadas em texto.

Dentro da programação, é possível gerar pequenos trechos de código e até páginas HTML e arquivos CSS inteiros.

Status Outubro/2024

Se você não estava embaixo de uma pedra, certamente já sabe que as LLMs vigentes são muito boas em análise de dados, gerando códigos muito bons, inclusive para alguns casos mais complexos. No entanto, o conteúdo deste artigo ainda tem relevância, pois mostra uma das muitas maneiras de integrar uma LLM ao processo de análise de dados.

E o que isso tem a ver com Ciências de Dados?

Os DataFrames são basicamente textos organizados em tabelas e colunas, que são correlacionados. Portanto, é possível carregar os dados em um modelo LLM (Large Language Model), habilitando a extração da informação destes DataFrames de maneira conversacional, como se estivéssemos dialogando. Mas o que realmente instiga esta nossa área é descobrir se podemos fazer este modelo realizar o trabalho de análise para nós, cientistas e analistas iniciantes (e até mesmo os mais experientes). A resposta mais recente que temos para isso é chamada de Pandas AI.

O que é o Pandas AI?

Pandas e Llamas

O Pandas AI é o melhor amigo do seu DataFrame! Com esta nova biblioteca, podemos dar aos nossos DataFrames a capacidade de serem consultados de maneira simples e eficiente, utilizando uma interface conversacional.

Então, vamos ver como podemos utilizar Pandas AI?

Preparando o Ambiente

A primeira coisa é garantir que seu ambiente tenha todas as bibliotecas necessárias instaladas: Pandas, PandasAI, OpenAI.

$ pip install pandas pandasai openai

Então, vamos iniciar o nosso notebook. Temos que fazer o import das bibliotecas que vamos utilizar na nossa demonstração.

import os
import pandas as pd

from pandasai import PandasAI
from pandasai.llm.openai import OpenAI
from dotenv import load_dotenv

Observe que carregamos a função load_dotenv, pois iremos precisar carregar a chave de acesso para a API da OpenAI. Para fazer isso, podemos simplesmente executar a função.

load_dotenv()

True

O próximo passo é carregar os nossos dados no DataFrame. Como sempre, vamos utilizar o dataset de pokemons.

pokemons = pd.read_csv('pokemons.csv')

Em seguida, vamos inicializar o LLM para que consigamos conversar com o nosso DataFrame.

llm = OpenAI(api_token=os.environ['OPENAI_API_KEY'])
pandas_ai = PandasAI(llm)

Até agora, tudo correu bem! Agora, podemos executar diversas vezes a função pandas_ai.run, passando nosso DataFrame e um prompt, e ele nos responderá. Vamos testar?

pandas_ai.run(pokemons, prompt="Quantos pokemons temos no DataFrame?")

'Unfortunately, I was not able to answer your question. Please try again. If the problem persists, try rephrasing your question.'

Para verificar isso, podemos apenas ver o shape do DataFrame e confirmar:

pokemons.shape

(1032, 44)

De fato, 1032 pokemons. Vamos continuar?

pandas_ai.run(pokemons, prompt="Quantos tipos de pokemons existem?")

'Well, there are actually 18 different types of pokemons out there!'

Vamos conferir?

tipos = pd.concat([pokemons['Type 1'], pokemons['Type 2']]).unique().tolist()


print(len(tipos))
print(tipos)

19
['Grass', 'Fire', 'Water', 'Bug', 'Normal', 'Dark', 'Poison', 'Electric', 'Ground', 'Ice', 'Fairy', 'Steel', 'Fighting', 'Psychic', 'Rock', 'Ghost', 'Dragon', 'Flying', nan]

Parece que funciona mesmo! Note que o nosso vetor tem 19 posições porque está contando o nulo como um valor. Vamos nos aprofundar mais um pouco…

pandas_ai.run(pokemons, prompt='Liste os tipos com as quantidades de pokemons')

'Existem diversos tipos de pokemons e suas quantidades variam. O tipo mais comum é o Normal, com 114 pokemons, seguido pelo tipo Água, com 131. Já o tipo Voador é o menos comum, com apenas 8 pokemons. Além disso, existem outros tipos como Fogo, Grama, Elétrico, Psíquico, entre outros, cada um com sua quantidade específica de pokemons. No total, existem mais de 800 espécies diferentes de pokemons.'

Ele respondeu, mas não exatamente como queríamos - observe que ele listou alguns tipos apenas com suas quantidades. Vamos tentar melhorar, aplicando um pouco de prompt engineering (ou seja, escrever nossa solicitação de forma mais explícita).

pandas_ai.run(pokemons, prompt="Crie uma tabela que tem duas colunas: tipo de pokemon e quantidade. Liste todos os tipos possíveis e suas quantidades.")

'Para responder à pergunta, criei uma tabela com duas colunas: tipo de pokemon e quantidade. Nessa tabela, listei todos os tipos possíveis de pokemon e suas respectivas quantidades. Por exemplo, há 81 pokemons do tipo Bug, 46 do tipo Dark, 42 do tipo Dragon, e assim por diante. No total, foram listados 18 tipos diferentes de pokemon e suas quantidades correspondentes.'

Humm, ainda não conseguimos listar todos os tipos. Vamos explicar um pouco mais?

pandas_ai.run(pokemons, prompt="Gerar uma listagem completa da quantidade de pokemons por tipo, em formato markdown.")

'Para saber a quantidade de pokemons por tipo, podemos gerar uma listagem completa em formato markdown. Aqui está a tabela com o número de pokemons para cada tipo: \n\n| Type | Count |\n|------|-------|\n| Bug | 81 |\n| Dark | 46 |\n| Dragon | 42 |\n| Electric | 59 |\n| Fairy | 22 |\n| Fighting | 42 |\n| Fire | 64 |\n| Flying | 8 |\n| Ghost | 41 |\n| Grass | 91 |\n| Ground | 41 |\n| Ice | 38 |\n| Normal | 114 |\n| Poison | 40 |\n| Psychic | 77 |\n| Rock | 59 |\n| Steel | 36 |\n| Water | 131 |\n\nAssim, você pode ter uma visão geral da distribuição dos tipos de pokemons na lista.'

Opa,agora foi. Mas como o notebook não formata markdown no output, precisamos fazer um copia e cola do resultado.

Para saber a quantidade de pokemons por tipo, podemos gerar uma listagem completa em formato markdown. Aqui está a tabela com o número de pokemons para cada tipo:

Type	Count
Bug	81
Dark	46
Dragon	42
Electric	59
Fairy	22
Fighting	42
Fire	64
Flying	8
Ghost	41
Grass	91
Ground	41
Ice	38
Normal	114
Poison	40
Psychic	77
Rock	59
Steel	36
Water	131

Assim, você pode ter uma visão geral da distribuição dos tipos de pokemons na lista.’

Vamos complicar um pouco?

Nas primeiras perguntas, utilizamos perguntas que pedem respostas quase que diretas das métricas que temos no DataFrame. Contamos o número de pokemons, contamos valores distinto de tipos, agrupamos a contagem por tipos. Mas será que o Pandas AI pode fazer uma análise comparativa simples, tal como analisar uma métrica e retornar o insight solicitado?

pandas_ai.run(pokemons, prompt="Qual o pokemon mais pesado?")

'Bem, o pokemon mais pesado é o Snorlax, ele pode chegar a pesar mais de 460 quilos!'

Opa, e não é que respondeu? Mas, sem precipitação, vamos conferir: vamos executar uma query em pandas que filtra os pokemons com peso >= ao do Snorlax.

pokemons[["Name","Weight"]].sort_values("Weight").query("Weight > 459")

	Name	Weight
925	Dusk Mane Necrozma	460.0
181	Snorlax	460.0
837	Hoopa Unbound	490.0
826	Avalugg	505.0
1001	Stonjourner	520.0
445	Metagross	550.0
833	Zygarde Complete	610.0
578	Giratina-Origin	650.0
1007	Copperajah	650.0
573	Dialga	683.0
254	Mega Steelix	740.0
577	Giratina	750.0
1019	Zamazenta Crowned Shield	785.0
1027	Glastrier	800.0
936	Melmetal	800.0
1030	Calyrex Ice Rider	809.1
932	Stakataka	820.0
923	Guzzlord	888.0
873	Mudsdale	920.0
446	Mega Metagross	942.9
1020	Eternatus	950.0
456	Groudon	950.0
457	Primal Groudon	999.7
914	Cosmoem	999.9
921	Celesteela	999.9

Ops, algo deu errado. Temos vários pokemons mais pesados. Será que ele não analisou todos os pokemons antes de responder? Quem sabe um problema nos dados? Vamos perguntar algo mais direto.

pandas_ai.run(pokemons, prompt="O pokemon Dialga é mais ou menos pesado que o Snorlax?")

'Well, it turns out that Snorlax is actually heavier than Dialga.'

Isso certamente deve ser um problema. Ele passou a responder em inglês, como se tivesse perdido o contexto. Vamos perguntar de maneira diferente…

pandas_ai.run(pokemons, prompt="Porque o pokemon Dialga é mais pesado que o Snorlax?")

'Well, actually, Snorlax weighs more than Dialga.'

É, ele realmente tem uma implicância com o Snorlax… Caso você não tenha lido nada a respeito do ChatGPT e LLMs em geral, esse tipo de erro é chamado de “alucinação” que ocorre quando o modelo produz resultados incorretos, correlacionando informações de maneira espúria.

Usando outras funcionalidades do Pandas via conversação

Agora vamos testar se o pandasAI consegue entender instruções para plotar gráficos. Isso é um DataFrame pandas, correto? Será que eu posso plotar um countplot() por geração?

pandas_ai.run(pokemons, prompt="Plote um gráfico de colunas totalizando pokemons por geração.")

'Claro! Vou plotar um gráfico de colunas que mostra a quantidade total de pokemons por geração.'

Parece que funcionou bem! Vamos tentar mais um?


pandas_ai.run(pokemons, prompt="Plote um gráfico de pizza totalizando pokemons pelo campo lendário.")

'Sure, I can help you with that! To plot a pie chart showing the total number of legendary Pokémon, we need to gather the data first. Once we have the numbers, we can create a visual representation of the data using a pie chart. Would you like me to proceed with the task?'

O que aprendemos até aqui

A biblioteca Pandas AI é uma biblioteca interessante, que nos permite “dialogar”com nossos DataFrames, extraindo informações do mesmo. Através de nossos exemplos, podemos verificar que quase tudo que podemos descobrir através de consultas normais pandas, podemos perguntar ao DataFrame através do Pandas AI.

Mas nem tudo são flores…

Apesar dos acertos, observamos que a biblioteca Pandas AI não é imune aos problemas comuns das LLM, e mesmo com uma base de conhecimento mais limitada, é acometida de alucinações. A biblioteca também sofre de um problema de performance: uma resposta que em pandas leva um segundo ou menos para ser mostrada, como podemos ver, pode levar até mais de 1 minuto usando PandasAI.

Por último, podemos perceber que a biblioteca ainda precisa um pouco mais de trabalho até mesmo em sua usabilidade - notamos que a mesma passa a responder em inglês quando a resposta está errada, deixando o usuário confuso.

Vale a pena utilizar?

Se você quer fazer explorações simples dos dados, parece ser uma boa idéia utilizar o PandasAI, visto que é mais fácil perguntar em português ou inglês do que lembrar a sintaxe de todos os comandos Pandas que você teria que fazer para isso. No entanto, é preciso tomar muito cuidado com os resultados, que podem estar errados, mas são comunicados com convicção.

É, com certeza, mais uma ferramenta no seu cinto de utilidades de cientista de dados, e como toda ferramenta, devemos conhece-la bem antes de usar. Explore mais, entenda suas limitações e faça o melhor uso possivel!

Até mais!!!

Walter.

Parte 09 - Seaborn - Melhorando seus Visuais

Walter R P Cortes — Sun, 12 Feb 2023 00:00:00 +0000

Olá Devs!

Se você chegou até aqui, você já se familiarizou com o básico das bibliotecas seaborn, matplotlib e pandas! Esse conhecimento já garante a você a capacidade de realizar análises de dados e apresentar resultados de maneira simples e eficiente.

O próximo passo é ensiná-lo a dar a esses gráficos uma aparência extremamente profissional e que leve em conta as boas práticas da área de Visualização de Dados. Para isso, vamos apresentar um pequeno problema e a versão inicial da visualização com o conhecimento que temos e, depois, apresentamos o passo a passo com as boas práticas e como codifica-las, chegando a nossa versão final da visualização.

Problema

Considere o seguinte cenário: Você é um cientista de dados encarregado de fazer uma análise em cima dos dados da população mundial. Os seus gráficos serão incorporados em uma apresentação PowerPoint.

O gráfico que você deve montar mostra a evolução no tamanho da população dos países do bloco econômico BRICS (Brasil, Russia, India, China e Africa do Sul), fazendo uma comparação com os Estados Unidos. Deve ser um gráfico de barras, onde cada barra irá representar um ano ou década.

O arquivo com os dados pode ser encontrado aqui. Você pode fazer o download e subir no seu Google Colab ou carregar diretamente do endereço.

Solução Passo a Passo

Carregando Bibliotecas

O primeiro passo é sempre carregar as bibliotecas que vamos utilizar.

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

Carregando dados

A próxima etapa é carregar os dados. Durante o curso, utilizamos um arquivo local para fazer isso. Hoje vamos exercitar uma pequena variação. Como explicamos anteriormente, todos os nossos conjuntos de dados estão em um repositório no GitHub -> https://github.com/labeduc/datasets. Ensinamos vocês a baixarem o repositório no seu computador e subir o arquivo que vocês vão trabalhar direto no Google Colab (que é temporário e precisar ser salvo lá cada vez que se abre o notebook) ou colocar no seu Google Drive e mapear o Google Drive no Google Colab.

Agora, vamos explorar uma capacidade da biblioteca pandas que é ler o arquivo direto da internet. O que fizemos foi ir até o Github e observar qual era a URL de download do arquivo que pretendemos usar. Copiamos e colocamos no primeiro parâmetro da função read_csv().

worldpop = pd.read_csv('https://media.githubusercontent.com/media/labeduc/datasets/main/worldpop/world_population.csv')

Para verificar que temos os dados carregados, vamos pedir um sample de 2 linhas.

worldpop.sample(2)

	Rank	CCA3	Country	Capital	Continent	2022 Population	2020 Population	2015 Population	2010 Population	2000 Population	1990 Population	1980 Population	1970 Population	Area (km²)	Density (per km²)	Growth Rate	World Population Percentage
131	10	MEX	Mexico	Mexico City	North America	127504125	125998302	120149897	112532401	97873442	81720428	67705186	50289306	1964375	64.9082	1.0063	1.60
194	29	KOR	South Korea	Seoul	Asia	51815810	51844690	50994401	48813042	46788591	44120039	38170501	32601143	100210	517.0722	0.9997	0.65

Perfeito, temos os dados, e estamos prontos para prosseguir.

Analisando os dados

A primeira coisa que podemos fazer nesta análise é descobrir quais são todos os campos de conjunto de dados, seus tipos de dados e se temos muitos campos vazios.

worldpop.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 234 entries, 0 to 233
Data columns (total 17 columns):
 # Column Non-Null Count Dtype  
--- ------ -------------- -----  
 0 Rank 234 non-null int64  
 1 CCA3 234 non-null object 
 2 Country 234 non-null object 
 3 Capital 234 non-null object 
 4 Continent 234 non-null object 
 5 2022 Population 234 non-null int64  
 6 2020 Population 234 non-null int64  
 7 2015 Population 234 non-null int64  
 8 2010 Population 234 non-null int64  
 9 2000 Population 234 non-null int64  
 10 1990 Population 234 non-null int64  
 11 1980 Population 234 non-null int64  
 12 1970 Population 234 non-null int64  
 13 Area (km²) 234 non-null int64  
 14 Density (per km²) 234 non-null float64
 15 Growth Rate 234 non-null float64
 16 World Population Percentage 234 non-null float64
dtypes: float64(3), int64(10), object(4)
memory usage: 31.2+ KB

A informação está bem estruturada: todos os campos tem valores, os campos númerico são de um tipo numérico, temos poucas categorias e são do tipo object, que basicamente diz que são texto.

Podemos perceber que estruturalmente, esse conjunto de dados tem um país por linha, com os anos sendo colunas. Em um cenário ideal, os nossos gráficos devem plotar a partir de uma única coluna de valor, e teríamos algum outro atributo para separa-los se for o caso.

Outro ponto a ser considerado é que precisamos apenas dos Estados Unidos e dos países do bloco econômico BRICS, então temos mais dados do que o necessário.

Isso significa que vamos fazer alguns ajustes nos nossos dados.

Transformando os dados

Acompanhem explicações nos comentários.

# Primeira coisa é selecionar apenas as colunas que vamos utilizar
worldpop_sb = worldpop[["Country", 
 "1970 Population",
 "1980 Population",
 "1990 Population",
 "2000 Population",
 "2010 Population",
 "2015 Population",
 "2020 Population",
 "2022 Population"]]

# Em seguida, filtramos as linhas para pegar apenas US e os países do BRICS
worldpop_sb2 = worldpop_sb.query("Country in ('United States', 'Brazil', 'Russia', 'India', 'China', 'South Africa')")

# Fazemos a transformação das colunas de ano em linhas.
brics_us = worldpop_sb2.melt(id_vars='Country', var_name='Year', value_name='Population')

# Pedimos uma amostra para ver como nossos dados ficaram.
# Parece tudo certo, temos apenas paises do BRICS e US,
# no caso do Brasil, vemos agora duas linhas, uma para a
# informação do ano de 2022 e outra para 2015.
brics_us.sample(5)

	Country	Year	Population
1	China	1970 Population	822534450
13	China	1990 Population	1153704252
32	India	2015 Population	1322866505
19	China	2000 Population	1264099069
18	Brazil	2000 Population	175873720

Aí estão nossos dados, devidamente formatados. Vamos agora plotar o gráfico.

Primeira Versão

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

plt.show()

E aí está nosso gráfico. A partir de agora, vamos passo a passo aplicando melhorias sucessivas.

Passo 1 - Adicionando Títulos

Os gráficos precisam de títulos, preferencialmente um título que esclareça o significado do gráfico. Em nossas aulas anteriores, já haviamos adicionado títulos significativos em nossos gráficos e nos eixos também. Então, vamos apenas relembrar.

sns.barplot(brics_us, x='Country', y='Population', hue='Year')
# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('Países')
plt.ylabel('População')

plt.show()

Passo 2 - Ajustando tamanho da imagem

Ao olharmos nosso gráfico, logo percebemos que os nomes dos países estão se sobrepondo no final. Para este e muitos outros ajustes, vamos introduzir a propriedade rcParams. Esta propriedade é um dicionário que armazena outras configurações. Você pode encontrar mais informaç!oes aqui.

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('Países')
plt.ylabel('População')

plt.show()

Esse tamanho deixou as barras mais separadas, e agora conseguimos ver claramente todos os países.

Passo 3 - Ajustando Qualidade da Imagem

Dentro do contexto de visualização online, nosso gráfico parece bom. Mas, se precisarmos exportar esse gráfico como imagem para usar em um powerpoint, por exemplo, veremos que a qualidade da imagem ficará ruim. Isso acontece porque o padrão do matplotlib é gerar imagens com resolução de 100dpi. Para exportar, normalmente é recomendado utilizar 300dpi. Vamos arrumar isso e ver como fica?

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('Países')
plt.ylabel('População')

plt.show()

Passo 4 - Removendo o “Ruído” do Gráfico

De acordo com as boas práticas na área de visualização, uma boa visualização é limpa, ou seja, não possui elementos que não estejam relacionados aos dados. No gráfico acima, o box em torno do gráfico, a legenda com muito texto, aquela informação 1e9 perdida no gráfico são ruídos, que tiram a atenção das barras que são os dados.

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

plt.ticklabel_format(style="plain", useLocale=True)

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('Países')
plt.ylabel('População')

plt.show()

Conseguimos deixar a imagem maior, removemos alguns elementos que adicionavam apenas ruído no gráfico. Mas observem que agora a formatação dos valores no eixo Y está estranho. Vamos corrigir?

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

plt.ticklabel_format(style="plain", useLocale=True)

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks()
plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('Países')
plt.ylabel('População (bilhões)')

plt.show()

/tmp/ipykernel_382990/823456077.py:26: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

Por último, vamos remover o label do eixo X.

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

plt.ticklabel_format(style="plain", useLocale=True)

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks()
plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('')
plt.ylabel('População (bilhões)')

plt.show()

/tmp/ipykernel_382990/1234354454.py:26: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

Passo 5 - Colocando foco nos dados

Agora que trabalhamos na formatação inicial, precisamos realizar melhorias que irão nos ajudar a colocar o foco nos dados. Eis o que vamos fazer: - diminuir a legenda - Alinhar o título a esquerda - o título centralizado faz com que os olhos façam um escaneamento extra do gráfico, dificultando a compreensão - vamos colocar os valores em cima de cada barra. Também para evitar que precisemos olhar no eixo a esquerda para ver o valor de cada barra, ou seja, que fiquemos constantemente escaneando o gráfico - ajustar o tamanho das fontes - ajustar as cores.

Diminuindo a legenda

A princípio, podemos resolver isso manipulando os dados.

brics_us['Year'] = brics_us['Year'].apply(lambda x: x.replace(' Population',''))

Vamos ver o resultado?

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

plt.ticklabel_format(style="plain", useLocale=True)

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks()
plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('')
plt.ylabel('População (bilhões)')

plt.show()

/tmp/ipykernel_382990/1234354454.py:26: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

Alinhar o Titulo e Diminuir fontes

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

#Fontes
plt.rcParams["legend.fontsize"] = 5
plt.rcParams["legend.title_fontsize"] = 6
plt.rcParams["legend.frameon"] = False

plt.ticklabel_format(style="plain", useLocale=True)
plt.tick_params(axis='both', which='major', labelsize=6)

sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks()
plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)', fontsize=8, loc='left')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('')
plt.ylabel('População (bilhões)')

plt.show()

/tmp/ipykernel_382990/1419233821.py:32: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

Removendo o eixo Y e adicionando os valores nas barras

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.left"] = False
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

#Fontes
plt.rcParams["legend.fontsize"] = 5
plt.rcParams["legend.title_fontsize"] = 6
plt.rcParams["legend.frameon"] = False

plt.ticklabel_format(style="plain", useLocale=True)
plt.tick_params(axis='both', which='major', labelsize=6)

sx = sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks()
plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)', fontsize=8, loc='left')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('')

# Removendo todo o eixo Y
sx.get_yaxis().set_visible(False)

# O Objeto patches contém todos os elementos (neste caso barras) que foram plotados no gráfico
# Então percorremos eles e fazemos os seguintes calculos:
# a coordenada x para posicionar o texto = Coordenada X do canto superior da barra + largura da barra / 2
# a coordenada Y para posicionar o texto = Coordenada Y do canto superior da barra + 1% desta altura
for p in sx.patches:
 _x = (p.get_x() + p.get_width() / 2)
 _y = p.get_y() + p.get_height() + (p.get_height()*0.01)
 value = '{:.2f}'.format(p.get_height()/1000000000)
 sx.text(_x, _y, value, ha="center", size=3) 

plt.show()

/tmp/ipykernel_382990/1997790246.py:33: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  plt.gca().set_yticklabels(['{:,.1f}'.format(x) for x in current_values/1000000000]);

Acertando as cores

A paleta de cores precisa ser ajustada para respeitar as cores da empresa.

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Definindo a paleta de cores
cores = ["#0c4f6a", "#177498", "#0a8faa", "#bfdce5", "#82bd4a", "#b8d67a", "#b2b3b6", "#58585a", "#edb634", "#d97933", "#f1bdb1", "#eca091", "#e26c54", "#b0391e"]
sns.set_palette(sns.color_palette(cores))

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.left"] = False
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

#Fontes
plt.rcParams["legend.fontsize"] = 5
plt.rcParams["legend.title_fontsize"] = 6
plt.rcParams["legend.frameon"] = False

plt.ticklabel_format(style="plain", useLocale=True)
plt.tick_params(axis='both', which='major', labelsize=6)

sx = sns.barplot(brics_us, x='Country', y='Population', hue='Year')

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks().tolist()
formatted_values = ['{:,.1f}'.format(x/1000000000) for x in current_values]
plt.gca().set_yticklabels(formatted_values)

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)', fontsize=8, loc='left')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('')

# Removendo todo o eixo Y
sx.get_yaxis().set_visible(False)

# O Objeto patches contém todos os elementos (neste caso barras) que foram plotados no gráfico
# Então percorremos eles e fazemos os seguintes calculos:
# a coordenada x para posicionar o texto = Coordenada X do canto superior da barra + largura da barra / 2
# a coordenada Y para posicionar o texto = Coordenada Y do canto superior da barra + 1% desta altura
for p in sx.patches:
 _x = (p.get_x() + p.get_width() / 2)
 _y = p.get_y() + p.get_height() + (p.get_height()*0.01)
 value = '{:.2f}'.format(p.get_height()/1000000000)
 sx.text(_x, _y, value, ha="center", size=3) 

plt.show()

/tmp/ipykernel_382990/620366550.py:38: UserWarning: set_ticklabels() should only be used with a fixed number of ticks, i.e. after set_ticks() or using a FixedLocator.
  plt.gca().set_yticklabels(formatted_values)

E aí está o nosso gráfico, com suas cores modificadas. Para este gráfico ficar realmente bom, faltam apenas duas correções: deixar nossas barras um pouco mais largas para que possamos aumentar a fonte dos valores.

# É aconselhavel mudar o tamanho da imagem antes de plotar
# Para tanto, o MatPlotLib nos permite modificar entradas 
# em um dicionário de parâmetros chamado rcParams.
# A nossa modificação será da entrada figure.figsize
# Este parâmetro recebe uma tupla com largura e altura em polegadas
# O valor padrão é 6.4 de largura e 4.8 de altura em polegadas
plt.rcParams["figure.figsize"] = (9,5)

#Definindo a paleta de cores
cores = ["#0c4f6a", "#177498", "#0a8faa", "#bfdce5", "#82bd4a", "#b8d67a", "#b2b3b6", "#58585a", "#edb634", "#d97933", "#f1bdb1", "#eca091", "#e26c54", "#b0391e"]
sns.set_palette(sns.color_palette(cores))

#Ajustando qualidade da imagem
plt.rcParams["figure.dpi"] = 300
plt.rcParams["savefig.dpi"] = 300
plt.rcParams["savefig.format"] = "svg"

# Para remover parte do box da imagem, fazemos isso:
plt.rcParams["axes.spines.left"] = False
plt.rcParams["axes.spines.right"] = False
plt.rcParams["axes.spines.top"] = False
plt.rcParams["axes.spines.bottom"] = False

#Fontes
plt.rcParams["legend.fontsize"] = 5
plt.rcParams["legend.title_fontsize"] = 6
plt.rcParams["legend.frameon"] = False

plt.ticklabel_format(style="plain", useLocale=True)
plt.tick_params(axis='both', which='major', labelsize=6)

# O padrão para tamanho das barras é 0.8. Quando colocamos 1, as barras se encostam. 
# Portanto, aumentamos para 0.95 para que não se encostem, mas fiquem mais largas.
# A nossa outra alteração foi na rotina que imprime os valores, onde pudemos ajustar
# o tamanho da fonte de 3 para 4
sx = sns.barplot(brics_us, x='Country', y='Population', hue='Year', width=0.95)

# Aqui buscamos os valores que foram adicionados no eixo e os modificamos 
# com a formatação adequada
current_values = plt.gca().get_yticks().tolist()
formatted_values = ['{:,.1f}'.format(x/1000000000) for x in current_values]
plt.gca().set_yticklabels(formatted_values)

# Esta função adiciona um título no gráfico
plt.title('Crescimento Populacional no BRICS (1970 - 2020)', fontsize=8, loc='left')

# Estas funções nos permitem alterar o títulos nos eixos
plt.xlabel('')

# Removendo todo o eixo Y
sx.get_yaxis().set_visible(False)

# O Objeto patches contém todos os elementos (neste caso barras) que foram plotados no gráfico
# Então percorremos eles e fazemos os seguintes calculos:
# a coordenada x para posicionar o texto = Coordenada X do canto superior da barra + largura da barra / 2
# a coordenada Y para posicionar o texto = Coordenada Y do canto superior da barra + 1% desta altura
for p in sx.patches:
 _x = (p.get_x() + p.get_width() / 2)
 _y = p.get_y() + p.get_height() + (p.get_height()*0.01)
 value = '{:.2f}'.format(p.get_height()/1000000000)
 sx.text(_x, _y, value, ha="center", size=4) 

# Essa alteração foi no improviso, pois estava dizendo Year, ou seja,
# uma parte do gráfico utilizava um idioma diferente.
plt.legend(title='Ano')

plt.show()

/var/folders/fc/hns7cg2j2xg_05kdl6cbxkw40000gn/T/ipykernel_47418/1546591451.py:42: UserWarning: FixedFormatter should only be used together with FixedLocator
  plt.gca().set_yticklabels(formatted_values)

Acho que agora, estamos prontos para enviar esse belo gráfico para quem vai usá-lo!

Conclusão

Nesta aula, aprendemos sobre como configurar nossos gráficos para que fiquem com uma aparência mais profissional e respeitem as boas práticas da área de Visualização de Dados. Vamos deixar também os links para as documentações das bibliotecas que utilizamos: - Seaborn - Matplotlib

Este artigo também marca o final da nossa série Visualização de Dados com Python! Com o conhecimento aqui compartilhado, você já é capaz de criar visualizações de dados incríveis e profissionais. Esperamos que você tenha gostado e que tenha aprendido muito!

Até a próxima!

Walter

Parte 08 - MatplotLib - Tudo acaba em Pizza

Walter R P Cortes — Sat, 11 Feb 2023 00:00:00 +0000

Olá Devs!

Dentro da área de Visualização de Dados existe uma grande polêmica em relação a um tipo de gráfico: o gráfico de pizza ou torta. E a polêmica não é quanto ao nome, mas a quando devemos utilizar este tipo de gráfico.

Neste artigo, iremos aprender um pouco sobre essa polêmica e depois, vamos ver como podemos criar este gráfico usando as bibliotecas python seaborn, matplotlib e pandas!

Definindo Gráfico de Pizza… ou será Torta?

O gráfico de pizza (ou torta) é um gráfico que tem por objetivo representar as categorias ou dimensões como parte de um todo.

Exemplo

Considere o seguinte cenário: você realizou uma votação sobre qual sabor de pizza é o mais popular. Essa votação foi feita junto aos clientes da pizzaria onde você trabalha, durante o curso de 1 semana. Hoje haverá uma reunião com o dono da pizzaria, onde vocês discutirão quais são os sabores que entrarão na próxima grande promoção da loja. Para isso, você vai apresentar os resultados da votação. E (piada interna) você decidiu que nada melhor que usar um gráfico de pizza para esta tarefa!

Um gráfico de pizza!

Como vocês podem ver pela deliciosa imagem acima, o gráfico de pizza é composto por um círculo, que irá representar a totalidade dos votos que foram coletados. Então, cada sabor que foi votado irá representar uma fatia desta pizza. Se olharmos os valores representados no gráfico (que são porcentagens), conseguimos ter uma idéia do quanto cada fatia representa em relação ao todo.

E, olhando essa imagem, você pode se perguntar: está tudo tão claro, onde está a polêmica? Para isso, vamos ver outra imagem:

Exemplo de Gráfico Ruim

Esse gráfico, que visa demonstrar os tweeters mais ativos, representa o principal problema dos gráficos de pizza: quanto mais categorias você tem, menos cada uma representa do todo, deixando mais díficil para o público entender essa representação. A próxima imagem ilustra o outro problema que geralmente encontramos em gráficos de pizza:

Por algum motivo estranho, gráficos de pizza também tem uma perspectiva diferente. E essa mudança de perspectiva torna ainda pior a capacidade do público de perceber a diferença entre cada ‘fatia’.

Características de uma boa Pizza (Gráfico de Pizza)

Então, devemos usar gráficos de pizza ou não? A resposta mais simples é - depende. Baseado em inúmeros especialistas da área de visualização, você pode usar gráficos de pizza quando tem poucas categorias para serem representados. Outra recomendação é evitar mostrar o gráfico em perspectiva, além de utilizar rótulos informativos e bem simples para cada fatia.

Então, antes de ver como montar esse tipo de gráfico, vamos ficar com uma imagem que reforça o aprendizado até aqui:

Utilização básica

Para criar o gráfico de pizza teremos que abandonar um pouco o seaborn, e nos concentrarmos em utilizar apenas o matplotlib. Já estamos usando parte do matplotlib para colocarmos títulos no gráfico e nos eixos, acertarmos faixas de valores nos eixos e mais alguns detalhes. Agora, iremos utiliza-lo também para plotar o gráfico. Em primeiro lugar, vamos inicializar o ambiente e carregar os dados.

import pandas as pd
import matplotlib.pyplot as plt

pokemons = pd.read_csv('pokemons.csv')

Depois, fazemos a agregação dos dados no nível da categoria que vamos plotar. Para criarmos um gráfico de pizza bom, vamos plotar o número de pokemons por geração. Isso nos dará poucas categorias (8), e faz sentido ver a distribuição do número de pokemons. Se quiséssemos plotar qualquer outro atributo, como ataque, defesa, etc…, provavelmente um gráfico de pizza não seria indicado, pois não faz sentido representar a soma dos poderes de ataque dos pokemons como um todo.

pokemons['Generation Desc'] = pokemons['Generation'].apply(lambda gen: 'Gen ' + str(int(gen)))

pokemons_gen = pokemons.groupby(['Generation Desc'])[['Generation','Number']].count().reset_index()
pokemons_gen.sort_values('Generation Desc', inplace=True)

plt.pie(pokemons_gen['Number'], labels=pokemons_gen['Generation Desc'], autopct="%.2f%%", counterclock=False)

plt.show()

E aí está o nosso gráfico de pizza! Importante observar que novamente, fizemos algumas transformações nos dados, incluindo ordenar os dados, porque caso contrário, as fatias ficarão fora de ordem. Vamos adicionar título e legenda, como em todos os nossos outros gráficos.

pokemons['Generation Desc'] = pokemons['Generation'].apply(lambda gen: 'Gen ' + str(int(gen)))

pokemons_gen = pokemons.groupby(['Generation Desc'])[['Generation','Number']].count().reset_index()
pokemons_gen.sort_values('Generation Desc', inplace=True)

plt.pie(pokemons_gen['Number'], labels=pokemons_gen['Generation Desc'], autopct="%.2f%%", counterclock=False)

plt.title('Pokemons por Geração')
plt.legend(loc='upper right', bbox_to_anchor=(1.40,1.02))

plt.show()

Pronto, aí está o polêmico gráfico de pizza!

Conclusão

Neste artigo, aprendemos como criar gráficos que nos ajudam a entender como nossas variáveis categóricas se relacionam enquanto partes de um todo. E para isto utilizamos o tão famoso gráfico de Pizza. Também aprendemos em quais casos este tipo de gráfico faz sentido e quando sua utilização prejudica a compreensão dos dados. Se quiser saber mais sobre gráficos de pizza, clique aqui.

Um abraço e até a próxima,

Walter.

Parte 07 - Dispersão e Quadrantes

Walter R P Cortes — Fri, 10 Feb 2023 00:00:00 +0000

Olá Devs!

Nos artigos anteriores aprendemos a criar gráficos que nos permitem realizar comparações entre categorias de uma dimensão, e também observar as variações de uma categoria ao longo de uma dimensão contínua (podendo ser uma dimensão numérica ou a mais popular, o tempo). Outra característica que esses gráficos possuem é que eles demonstram valores agregados no nível das categorias que estão sendo comparadas.

Neste artigo, iremos explorar gráficos que nos permitirão: - analisar a distribuição dos valores ao longo de variáveis contínuas de forma individualizada - analisar a correlação entre variáveis - identificar o que chamamos de outliers, que são os pontos que fogem da distribuição observada (aquele ponto fora da curva).

Para realizar esse tipo de análise, vamos trabalhar com os Gráficos de Dispersão e Pontos.

Preparação

Vamos carregar nossa bibliotecas e os dados.

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

pokemons = pd.read_csv('pokemons.csv')

Utilização Básica

Como mencionamos anteriormente, uma das características dos gráficos de dispersão e pontos é que normalmente queremos que cada linha do nosso conjunto de dados esteja representado, com seus valores individualizados, ao contrário dos gráficos de barras, onde as informações estão agregadas através de cálculos de média, soma, …

Outra notada diferença é que neste tipo de gráfico, os eixos não utilizam categorias discretas. O que vemos é representação do domínio contínuo de variáveis, e os pontos correspondem a uma ocorrência.

Trazendo para a realidade do nosso conjunto de dados: os gráficos de dispersão não terão em seus eixos valores como Tipo ou Geração - o que iremos colocar nos eixos serão Ataque e Defesa, e os pontos plotados no gráfico representarão cada um dos pokemons no nosso conjunto de dados.

Para fazer isso, utilizaremos a função scatterplot() do seaborn.

Vamos ver na prática?

sns.scatterplot(pokemons, x='Att', y='Def')
plt.title('Análise de Pontos de Ataque X Defesa')
plt.xlabel('Pontos de Ataque')
plt.ylabel('Pontos de Defesa')
plt.show()

É bem simples, não é mesmo? Escolhemos a variável do eixo X e a variável do eixo Y e é isso, vemos cada um dos nossos pokemons plotados no gráfico.

Esse tipo de gráfico serve para mostrarmos a relação que existe entre as duas variáveis. No gráfico acima, podemos perceber que existe uma maior concentração de pokemons na faixa de 50-100 pontos de ataque e defesa. Também percebemos outras informações, tais como: - pelo menos 1 pokemon tem um alto valor de pontos de defesa, mas quase nada de pontos de ataque - pelo menos 1 pokemon tem um alto valor de pontos de ataque, mas quase nada de pontos de defesa.

Isso são o que chamamos de outliers, pois fogem da distribuição que percebemos como padrão.

Mas podemos melhorar um pouco nosso gráfico. Por exemplo, podemos colorir nossos pontos de acordo com a geração, assim podemos entender qual é a distribuição de cada geração.

sns.scatterplot(pokemons, x='Att', y='Def', hue='Generation')
plt.title('Análise de Pontos de Ataque X Defesa')
plt.xlabel('Pontos de Ataque')
plt.ylabel('Pontos de Defesa')
plt.show()

Melhorou um pouco, agora temos noção das gerações, mas a distribuição náo é uniforme, pois como o valor é numérico ele criou faixas de valores. Se quisermos ver cada geração individualmente, teremos que trabalhar nossos dados.

Adicionando uma coluna em nossos dados

Adicionar uma nova coluna em um DataFrame pandas é bem simples:

pokemons['Generation Desc'] = ""

Isso criará uma nova coluna chamada ‘Generation Desc’ que terá cada linha populada com o valor “” (vazio). Isso é um bom início, mas precisamos atribuir um valor a esta coluna, preferencialmente baseado no valor do campo ‘Generation’ original. Para isso, iremos utilizar a função apply() do DataFrame. Vamos ao comando.

pokemons['Generation Desc'] = pokemons['Generation'].apply(lambda gen: 'Gen ' + str(int(gen)))

A função apply() nos permite aplicar uma função (aqui utilizamos uma função lambda) que transforma o valor do campo Generation em um valor inteiro sem casas decimais para depois transforma-lo em texto, de forma que consigamos juntar com a string ‘Gen’. Assim, temos uma descrição textual da geração. Com isso, podemos agora, tentar novamente o plot do gráfico.

sns.scatterplot(pokemons, x='Att', y='Def', hue='Generation Desc')
plt.title('Análise de Pontos de Ataque X Defesa')
plt.xlabel('Pontos de Ataque')
plt.ylabel('Pontos de Defesa')
plt.show()

As cores ficaram bem melhores, mas a posição da legenda ficou bem ruim. Vamos arrumar?

sns.scatterplot(pokemons, x='Att', y='Def', hue='Generation Desc')
plt.title('Análise de Pontos de Ataque X Defesa')
plt.xlabel('Pontos de Ataque')
plt.ylabel('Pontos de Defesa')
plt.legend(loc='upper right', bbox_to_anchor=(1.21,1.02))
plt.show()

Agora temos nosso gráfico de dispersão pronto. Na próxima seção, vamos discutir um caso específico de gráfico de dispersão, chamado de Gráfico de Quadrantes.

Gráfico de Quadrantes

O gráfico de quadrantes é um caso específico de um gráfico de dispersão, onde dividimos a área do gráfico em quadrantes - superior esquerdo, superior direito, inferior esquerdo e inferior direito - e a presença de um ponto nesses quadrantes tem um significado especial. O maior exemplo deste tipo de gráfico é o “Quadrante Mágico” do Grupo Gartner, que publica todos os anos neste formato quais as empresas ou produtos que se posicionam como líderes do mercado em cada setor. Veja o exemplo abaixo, que representa O Quadrante Mágico de 2022 para a área de Business Intelligence.

Quadrante Mágico 2022 - BI

Neste formato do Gartner, os pontos que estiverem no quadrante superior direito são considerados os líderes do mercado, levando em conta as variáveis completude da visão e capacidade de execução, que são dois scores calculados e ficam em uma escala de 1 a 10 pontos.

Então, levando em consideração que o nosso gráfico de dispersão utiliza os atributos de Ataque e Defesa, vamos imaginar como transformar esse gráfico em um ‘Quadrante Mágico’ que nos permitirá saber quais são os pokemons mais capazes e que possuem a melhor relação entre pontos de ataque e defesa.

As mudanças que iremos aplicar no nosso gráfico original de dispersão são: - deixar os eixos com a mesma faixa de valores. Agora eles estão levemente desencontrados - plotar os eixos que dividem os quadrantes - plotar um texto descritivo para cada quadrante - se possível, poder nomear cada ponto no gráfico, com o nome do pokemon.

Acompanhe os comentários no código para entender o que foi feito!

# gera o gráfico original
sns.scatterplot(pokemons, x='Att', y='Def', hue='Generation Desc')

# adiciona os títulos
plt.title('Análise de Pontos de Ataque X Defesa')
plt.xlabel('Pontos de Ataque')
plt.ylabel('Pontos de Defesa')

# adiciona e posiciona a legenda
plt.legend(loc='upper right', bbox_to_anchor=(1.21,1.02))

# ajusta a faixa de valores para os dois eixos
# observe que utilizamos valores fixos. O ideal seria utilizar alguma
# fórmula ou função para dinamizar, mas vamos deixar simples
plt.xlim(0, 225)
plt.ylim(0, 225)

# traçamos as linhas de divisão dos quadrantes
# observe que a posição delas é na exata metade do 
# valor máximo de cada eixo
plt.axhline(y=112.5, color='blue', linestyle='--', linewidth=1) 
plt.axvline(x=112.5, color='blue',linestyle='--', linewidth=1) 

# criamos o label que identifica cada quadrante e o seu significado
plt.text(x=40, y=10, s="Fracos", color='blue')
plt.text(x=145, y=10, s="Atacantes", color='blue')
plt.text(x=155, y=210, s="Fortes", color='blue')
plt.text(x=30, y=210, s="Defensivos", color='blue')

# mostra o gráfico
plt.show()

Ficou bem bonito o nosso quadrante! A única coisa que não fizemos foi adicionar um “tooltip” a cada ponto para sabermos que pokemon é aquele. Para isso, precisamos que o gráfico seja do tipo interativo, o que requer utilizar outra biblioteca. Em um dos próximos artigos iremos explorar uma biblioteca que permite esse tipo de interação.

Conclusão

Neste artigo exercitamos ainda mais nossa capacidade de criar gráficos, expandido nosso conhecimento para a aplicação de mais uma função, chamada scatterplot() que nos permite criar gráficos de dispersão e os populares quadrantes mágicos. Também aprendemos mais algumas funções que nos ajudam a melhor formatar os nossos gráficos.

Um abraço e até a próxima,

Walter.

Parte 06 - Linhas e Áreas

Walter R P Cortes — Thu, 09 Feb 2023 00:00:00 +0000

Olá Devs!

No artigo anterior, começamos de maneira efetiva o nosso aprendizado da biblioteca seaborn, para a criação de gráficos utilizando a linguagem Python, e tecnologias interativas como o Google Colab.

Mais especificamente, aprendemos a criar gráficos de barras e suas variações como o gráfico de colunas, barras agrupadas ou até mesmo empilhadas (stacked). Esses gráficos correspondem com certeza à maior parte da nossa necessidade em termos de gráficos, mas ainda temos outra categoria que é muito importante: os gráficos de Linhas e Áreas.

Gráficos de Linhas e Áreas

Os gráficos de Linhas e Áreas são utilizados quando precisamos representar a distribuição de métrica ao longo de um eixo de valores categóricos mas contínuos. O exemplo mais clássico é representar a distribuição de valores ao longo da dimensão do tempo. Mas também é possível utilizar qualquer outra dimensão numérica e contínua.

Então, estão preparados para mais uma dose de conhecimento?

Preparação

A primeira coisa que iremos fazer no nosso notebook é carregar todas as bibliotecas que iremos utilizar e também o nosso conjunto de dados.

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

pokemons = pd.read_csv('pokemons.csv')

Utilização Básica

A utilização básica aqui não é muito diferente do que fizemos para os gráficos de barra: temos uma função que deve poder gerar a visualização, através da passagem de alguns parâmetros básicos: fonte de dados, eixo X, Y, …

Neste caso, a função em questão é a lineplot(). Vamos tentar?

sns.lineplot(pokemons, x='Generation', y='Spe')
plt.title('Variação de Velocidade de acordo com as Gerações')
plt.xlabel('Geração')
plt.ylabel('Velocidade')
plt.show()

Padronização é uma maravilha, não é mesmo? Pegamos o nosso código para gráficos de barras e trocamos a função e tudo funcionou! Podemos perceber, no entanto, que a nossa linha representando está envolta por um delimitador azulado. Para resolver isso, vamos dar uma analisada nos parâmetros específicos da função lineplot().

Por padrão, o gráfico de linhas também plota o que chamamos de error band, ou margem de erro. Se não for interessante, podemos eliminar essa error band.

sns.lineplot(pokemons, x='Generation', y='Spe', errorbar=None)
plt.title('Variação de Velocidade de acordo com as Gerações')
plt.xlabel('Geração')
plt.ylabel('Velocidade')
plt.show()

E, assim como no gráfico de barras, temos a necessidade de plotar mais de uma série no nosso gráfico de linhas. Como fazemos isso? É simples:

pokemons_sb = pokemons[['Generation','Spa','Spd']] # Primeiro selecionamos apenas as colunas que queremos trabalhar
tidy = pokemons_sb.melt(id_vars='Generation').rename(columns=str.title)

sns.lineplot(tidy, x='Generation', y='Value', hue='Variable', errorbar=None)
plt.title('Análise das Gerações')
plt.xlabel('Geração')
plt.ylabel('Atributos')
plt.show()

Basicamente, tivemos que fazer a mesma operação que fizemos para as múltiplas barras. E o resto do código já é bem conhecido.

O outro tipo de gráfico baseado em linhas é o popular gráfico de área. Mas somente conseguimos gerar esse gráfico utilizando a função stackplot() do MatplotLib. Veja o exemplo abaixo:

pokemons_gb = pokemons.groupby(['Generation'])[['Spa', 'Spd']].mean().reset_index()

plt.stackplot(pokemons_gb['Generation'], pokemons_gb['Spa'], pokemons_gb['Spd'], labels=['Special Attack', 'Special Defense'])
plt.title('Análise das Gerações')
plt.xlabel('Geração')
plt.ylabel('Atributos')
plt.show()

E aí está o nosso gráfico de área! Mais uma vez, recorremos a matplotlib para concluir a plotagem.

Conclusão

Neste artigos, aprendemos a criar mais dois tipos de gráfico: linha e área, revisamos a utilização de pandas para transformar os dados e acrescentamos mais uma ferramenta no nosso cinto de utilidades.

Se você quiser aprender mais sobre gráficos de linha e área em seaborn, seguem alguns links: - Documentação oficial do Seaborn em português: A documentação oficial do Seaborn tem uma versão em português que fornece uma visão geral da biblioteca, exemplos de uso, informações sobre os diferentes tipos de gráficos, e muito mais - Gráficos de Linha em Seaborn

Um abraço e até a próxima,

Walter.

Parte 05 - Iniciando com Seaborn

Walter R P Cortes — Wed, 08 Feb 2023 00:00:00 +0000

Olá Devs!

Bem-vindos de volta! Na Parte 04 aprendemos como utilizar a biblioteca Pandas para carregar no notebook os dados que pretendemos trabalhar. Também aprendemos a utilizar algumas funções mais avançadas que nos permitem filtrar ou agregar informações em nosso conjunto de dados.

A linguagem Python possui inúmeras bibliotecas não-nativas para gerar visualizações de dados. A biblioteca mais famosa e que muitas vezes serve de base para as outras se chama matplotlib. Por uma questão de conveniência e facilidade de uso, utilizaremos no curso a biblioteca seaborn.

As principais vantagens do seaborn são: - interface alto nível - existe uma função para cada tipo de gráfico, e permite fazer chaining de chamadas - facilidade de configuração - possui objetos de configuração globais e locais (em cada gráfico).

Nesta aula, vamos passar pelo processo de instalação e utilização dos tipos de gráficos mais básicos no seaborn.

Instalação

Assim como no artigo de Pandas, tenho uma boa notícia: no Google Colab o seaborn já vem instalado no nosso ambiente! Mas caso você esteja também se aventurando em fazer este curso no VS Code, PyCharm, Sublime ou até mesmo Notepad, o comando para instalar a biblioteca seaborn é o seguinte:

(venv) $ pip install seaborn

Visualizando com seaborn

Agora vamos ver na prática como o seaborn funciona. Neste artigo, veremos os tipos de gráficos mais comuns, indicando sua utilização e dando exemplos. Se você quiser mais detalhes, sempre pode consultar a documentação do seaborn em Seaborn Docs.

Hoje vamos gerar gráficos de barras ou colunas, baseados nas funções: countplot() e barplot(). Nas partes seguintes do artigo, iremos explorar outros tipos de gráficos, que são um pouco mais avançados.

Inicializando o seaborn

Como toda a biblioteca python, precisamos indicar em nosso script quando queremos utilizar a biblioteca seaborn. Fazemos isso através do comando import.

import seaborn as sns

Da mesma forma que falamos na aula de Pandas, o import do seaborn geralmente utiliza o apelido de sns, que pode ser encontrado em muitos artigos na internet. Vamos manter essa convenção para que vocês se acostumem ao procurar material de apoio.

Por falar de Pandas, precisamos carregar ele também, afinal, precisamos dos nossos dados!

import pandas as pd

Carregando os dados

E vamos continuar nossas demonstrações com o conjunto de dados de pokemons:

pokemons = pd.read_csv('pokemons.csv')

Gráficos de barras ou colunas

Um gráfico de barras ou colunas é uma representação gráfica de dados em que as informações são exibidas em barras verticais ou horizontais de comprimentos variáveis. Cada barra ou coluna representa uma categoria ou conjunto de dados diferentes, e a altura ou comprimento da barra é proporcional à quantidade ou valor correspondente.

Os gráficos de barras são frequentemente usados para comparar quantidades ou valores entre diferentes categorias, enquanto os gráficos de colunas são mais adequados para exibir uma série temporal de dados. Ambos os tipos de gráficos podem ser usados para exibir dados discretos ou contínuos, e podem ser personalizados para incluir rótulos, legendas e outras informações relevantes. Os gráficos de barras e colunas são comumente usados em relatórios, apresentações e em análises de dados.

`countplot()`

A primeira função que iremos aprender a utilizar é a função countplot(). Ela é indicada quando queremos realizar a contagem de uma categoria, ou seja, escolhemos um campo categórico em nossos dados e indicamos quantas ocorrências encontramos em nossos dados. Nos próximos blocos de código, veremos vários exemplos de como fazer isso.

# contando o número de pokemons por geração

plot = sns.countplot(pokemons, x="Generation")

plot

Olha só, parece bem fácil, não? Está ali o nosso gráfico, com o número de pokemons por geração. No entanto, temos algumas melhorias que podem ser feitas:

adicionar um título
corrigir os títulos dos eixos.

Para realizar esses ajustes, vamos precisar de uma nova biblioteca, chamada matplotlib. Na verdade, essa biblioteca é a base de muitas outras bibliotecas de visualização, tais como seaborn, plotly e por aí vai.

Neste cenário, matplotlib é utilizada para preparar o que chamamos de área de plotagem, que é o retângulo branco onde nosso gráfico será exibido.

import matplotlib.pyplot as plt
# contando o número de pokemons por geração

sns.countplot(pokemons, x="Generation")
plt.title('Pokemons por Geração') # título do gráfico
plt.xlabel('Geração') # eixo X
plt.ylabel('Número de Pokemons') # eixo Y

plt.show() # mostra o gráfico

Agora sim, temos um gráfico bem desenhado!

Este gráfico é um Gráfico de Colunas, de acordo com as definições, pois as barras são verticais. Para transformar em um gráfico de barras, na função countplot() precisamos apenas trocar o x pelo y no segundo parâmetro, além de trocar os títulos na funções xlabel e ylabel. Vamos ver como fica:

sns.countplot(pokemons, y="Generation")
plt.title('Pokemons por Geração') # título do gráfico
plt.ylabel('Geração') # eixo Y
plt.xlabel('Número de Pokemons') # eixo X

plt.show() # mostra o gráfico

`barplot()`

Nos gráficos utilizando countplot() podemos apenas exibir a contagem de elementos para cada valor categórico da coluna que escolhemos. Não temos como, por exemplo, apresentar a média dos pontos de vida dos pokemons. Para isso, precisamos de mais controle sobre os dados que iremos mostrar. Entra em cena a função barplot():

import numpy as np

sns.barplot(pokemons, x='Generation', y='HP', estimator=np.mean)
plt.title('Média dos pontos de vida de Pokemons por Geração')
plt.xlabel('Geração')
plt.ylabel('Média dos pontos de vida')

Text(0, 0.5, 'Média dos pontos de vida')

E aí está o nosso gráfico. Algumas observações:

Precisamos trazer mais uma biblioteca para o nosso script, a biblioteca numpy, para podermos especificar que nosso gráfico de barras iria calcular a média do campo especificado
Além de definirmos o eixo X, definimos também o eixo Y e qual o tipo de cálculo a ser realizado
Cada barra tem um risco preto. Esse risco se refere a margem de erro. Se você não quiser ver essa informação, apenas adicionamos mais um parâmetro a função e ela desaparece.

sns.barplot(pokemons, x='Generation', y='HP', estimator=np.mean, errwidth=0)
plt.title('Média dos pontos de vida de Pokemons por Geração')
plt.xlabel('Geração')
plt.ylabel('Média dos pontos de vida')

/tmp/ipykernel_227049/3891424301.py:1: FutureWarning: 

The `errwidth` parameter is deprecated. And will be removed in v0.15.0. Pass `err_kws={'linewidth': 0}` instead.

  sns.barplot(pokemons, x='Generation', y='HP', estimator=np.mean, errwidth=0)

Text(0, 0.5, 'Média dos pontos de vida')

E aí está o nosso gráfico de colunas. Outra coisa que podemos explorar é ter mais de uma métrica sendo analisada pela categoria selecionada. Por exemplo, vamos analisar a média dos pontos de ataque e defesa através das gerações.

# Precisamos fazer ajustes no conjunto de dados
pokemons_sb = pokemons[['Generation','Att','Def']] # Primeiro selecionamos apenas as colunas que queremos trabalhar
tidy = pokemons_sb.melt(id_vars='Generation').rename(columns=str.title)
# A função melt() recebe como parâmetro a coluna categórica e pega todas as colunas de métricas e transformam em uma 
# única coluna, em uma nova linha para cada coluna. Para identificar cada nova linha, outra coluna é adicionada, com
# a descrição. Ou seja, realizamos uma transposição do nosso conjunto de dados.

# Gráfico
sns.barplot(tidy, x='Generation', y='Value', hue='Variable', estimator=np.mean, err_kws={"linewidth": 0})
plt.title('Média dos pontos de ataque e defesa de Pokemons por Geração')
plt.xlabel('Geração')
plt.ylabel('Média dos pontos de ataque e defesa')
plt.legend()

plt.show()

No código acima, a parte que faz a plotagem do gráfico continua a mesma, mas temos as duas linhas iniciais que servem para fazer um ajuste nos dados. Quanto mais complexo os gráficos que queremos plotar, mais necessário se torna entender como formatar os dados. Então, aprenda principalmente Pandas e SQL e mantenha todos os seus gráficos fáceis de plotar!

Agora, vamos ver mais um subtipo de gráfico de barras ou colunas: o gráfico de colunas “stacked” ou empilhadas.

pokemons_gb = pokemons.groupby(['Generation'])[['Generation','Att', 'Def']].mean()

plt.bar(pokemons_gb['Generation'], pokemons_gb['Att'], color='blue', edgecolor='white', width=1)
plt.bar(pokemons_gb['Generation'], pokemons_gb['Def'], bottom=pokemons_gb['Att'], color='red', edgecolor='white', width=1)
plt.title('Média dos pontos de ataque e defesa de Pokemons por Geração')
plt.xlabel('Geração')
plt.ylabel('Média dos pontos de ataque e defesa')

plt.show()

Nesta versão de stacked bar chart, como podemos perceber pelo código, foi necessária uma nova transformação nos dados, desta vez com as funções groupby() e mean(). Além disso, desenhamos as barras com o matplotlib direto, não chegamos a utilizar o seaborn.

A transformação nos dados foi necessária para agruparmos os valores de ataque e defensa por geração e calcular a média. A opção de utilizar matplotlib direto produziu um gráfico com a aparência bem diferente, e sinceramente, feia se comparada aos outros gráficos que criamos. E existe uma alternativa! Podemos usar o seaborn através do próprio DataFrame, garantindo uma aparência alinhada com o que geramos anteriormente.

pokemons_gb.plot(kind='bar', x='Generation', stacked=True)
plt.title('Média dos pontos de ataque e defesa de Pokemons por Geração')
plt.xlabel('Geração')
plt.ylabel('Média dos pontos de ataque e defesa')
plt.legend()

plt.show()

Concluindo

Conseguimos ver como gerar um dos gráficos mais utilizados na área de Visualização de Dados, o gráfico de barras e suas variações utilizando a biblioteca seaborn. Também aprendemos que para gerar certos tipos de gráficos, é necessário fazer algumas transformações nos dados, o que conecta este artigo ao de Pandas.

Se você quiser aprender mais sobre seaborn, seguem alguns links: - Documentação oficial do Seaborn em português: A documentação oficial do Seaborn tem uma versão em português que fornece uma visão geral da biblioteca, exemplos de uso, informações sobre os diferentes tipos de gráficos, e muito mais - Tutorial de visualização de dados com Python e Seaborn: Este tutorial do Towards Data Science fornece uma introdução prática à visualização de dados com Seaborn, incluindo exemplos de código e gráficos. O tutorial abrange tópicos como gráficos de barras, gráficos de dispersão, heatmap e muito mais.

Um abraço e até mais,

Walter.

Parte 04 - Pandas

Walter R P Cortes — Tue, 07 Feb 2023 00:00:00 +0000

Olá Devs!

Se você chegou até aqui, significa que já deve ter aprendido como carregar os dados no Google Colab utilizando as bibliotecas padrão do python. E deve ter percebido que a tarefa não é simples, e requer muitas linhas de código (Rapadura é doce mas não é mole não, diria o Yusuke Urameshi).

Justamente com a intenção de simplificar o trabalho dos cientistas e engenheiros de dados é que a biblioteca Pandas foi criada. Com a biblioteca Pandas, todo o trabalho de manipulação dos dados fica simplificado, rápido e mais organizado.

Instalando Pandas

Tenho uma boa notícia: como estamos utilizando o Google Colab para nossas aulas, ele já vem instalado no nosso ambiente! Mas caso você esteja também se aventurando em fazer este curso no VS Code, PyCharm, Sublime ou até mesmo Notepad, o comando para instalar a biblioteca Pandas é o seguinte:

(venv) $ pip install pandas

Este comando irá instalar a biblioteca Pandas e todos as bibliotecas dependentes. É aconselhável que você crie um ambiente virtual para instalar as bibliotecas, mas isso é assunto para um outro dia.

Utilizando Pandas

Iremos ver, passo a passo, como utilizar a biblioteca Pandas em nosso notebook Google Colab, passando pelos seus principais conceitos.

Carregando Pandas no notebook

A primeira coisa que devemos fazer é carregar a biblioteca em nosso notebook. Fazemos isso com o comando import.

import pandas as pd

Tip

É considerado uma boa prática ao carregar a biblioteca sempre utilizar o alias pd. Observe que todos os artigos na internet utilizam essa mesma referência.

Carregando os dados

Na aula 3, aprendemos que uma maneira de carregar os dados em um notebook on Google Colab é a seguinte:

import csv

pokemons = {}
with open('pokemons.csv', 'r', encoding='utf-8') as arquivo:
 dados = csv.DictReader(arquivo)

 for pokemon in dados:
 for key, value in pokemon.items():
 pokemons.setdefault(key,[]).append(value)

Utilizando pandas, isso será substituído por uma única linha:

pokemons = pd.read_csv('pokemons.csv')

Ficou bem mais fácil, não é mesmo? Da mesma forma, verificar o conteúdo que foi carregado também se simplifica - vai disso aqui:

for indice in range(0, 2): # executa um loop dos dois primeiros elementos do array
 print(pokemons[indice]) # imprime o elemento

para isso aqui:

pokemons.head(2)

	Number	Name	Type 1	Type 2	Abilities	HP	Att	Def	Spa	Spd	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
0	1	Bulbasaur	Grass	Poison	['Chlorophyll', 'Overgrow']	45	49	49	65	65	...	1.0	1.0	1.0	1.0	1.0	1.0	0.5	0.7	6.9	14.1
1	2	Ivysaur	Grass	Poison	['Chlorophyll', 'Overgrow']	60	62	63	80	80	...	1.0	1.0	1.0	1.0	1.0	1.0	0.5	1.0	13.0	13.0

2 rows × 44 columns

Mas não é só isso…

Outra grande vantagem de se utilizar pandas é que temos a nossa disposição um grande número de opções para carregar dados. Além do read_csv, temos readers especializados: read_json, read_excel, e por aí vai… Aconselho a dar uma olhada no manual do pandas aqui.

Inspecionando os dados

Após termos os dados carregados, a nossa próxima atividade é inspecionar os dados. Além do comando que vimos acima head(), que pode nos mostrar as primeiras linhas do DataFrame, temos outras funções, como:

tail() - mostra as últimas linhas do DataFrame
sample() - mostra linhas aleatórias do DataFrame
describe() - mostra os valores de diversas medidas
info() - mostra os campos do DataFrame com seus tipos
shape - dá as dimensões (coluna, linha) do DataFrame

Vamos ver em detalhes cada uma destas funções.

`head()`

Esta função lista as primeiras linhas de dados. O pârametro é opcional, o que fará com que a função liste 10 linhas de dados.

pokemons.head(5)

	Number	Name	Type 1	Type 2	Abilities	HP	Att	Def	Spa	Spd	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
0	1	Bulbasaur	Grass	Poison	['Chlorophyll', 'Overgrow']	45	49	49	65	65	...	1.0	1.0	1.0	1.0	1.0	1.0	0.5	0.7	6.9	14.1
1	2	Ivysaur	Grass	Poison	['Chlorophyll', 'Overgrow']	60	62	63	80	80	...	1.0	1.0	1.0	1.0	1.0	1.0	0.5	1.0	13.0	13.0
2	3	Venusaur	Grass	Poison	['Chlorophyll', 'Overgrow']	80	82	83	100	100	...	1.0	1.0	1.0	1.0	1.0	1.0	0.5	2.0	100.0	25.0
3	3	Mega Venusaur	Grass	Poison	['Thick Fat']	80	100	123	122	120	...	1.0	1.0	1.0	1.0	1.0	1.0	0.5	2.4	155.5	27.0
4	4	Charmander	Fire	NaN	['Blaze', 'Solar Power']	39	52	43	60	50	...	0.5	2.0	1.0	1.0	1.0	0.5	0.5	0.6	8.5	23.6

5 rows × 44 columns

`tail()`

Esta função lista as últimas linhas de dados. O pârametro é opcional, o que fará com que a função liste 10 linhas de dados.

pokemons.tail(5)

	Number	Name	Type 1	Type 2	Abilities	HP	Att	Def	Spa	Spd	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
1027	896	Glastrier	Ice	NaN	['Chilling Neigh']	100	145	130	65	110	...	1.0	2.0	1.0	1.0	1.0	2.0	1.0	2.2	800.0	165.3
1028	897	Spectrier	Ghost	NaN	['Grim Neigh']	100	65	60	145	80	...	0.5	1.0	2.0	1.0	2.0	1.0	1.0	2.0	44.5	11.1
1029	898	Calyrex	Psychic	Grass	['Unnerve']	100	80	80	80	80	...	4.0	1.0	2.0	1.0	2.0	1.0	1.0	1.1	7.7	6.4
1030	898	Calyrex Ice Rider	Psychic	Ice	['As One']	100	165	150	85	130	...	2.0	2.0	2.0	1.0	2.0	2.0	1.0	2.4	809.1	140.5
1031	898	Calyrex Shadow Rider	Psychic	Ghost	['As One']	100	85	80	165	100	...	1.0	1.0	4.0	1.0	4.0	1.0	1.0	2.4	53.6	9.3

5 rows × 44 columns

`sample()`

Enquanto head() e tail() mostra o início e o fim do conjunto de dados, o sample() traz linhas aleatórias do conjunto, o que pode ser bem interessante.

pokemons.sample(5)

	Number	Name	Type 1	Type 2	Abilities	HP	Att	Def	Spa	Spd	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
519	438	Bonsly	Rock	NaN	['Rattled', 'Rock Head', 'Sturdy']	50	80	95	10	45	...	1.0	1.0	1.0	1.0	1.0	2.0	1.0	0.5	15.0	60.0
635	542	Leavanny	Bug	Grass	['Chlorophyll', 'Overcoat', 'Swarm']	75	103	80	70	80	...	2.0	2.0	1.0	1.0	1.0	1.0	1.0	1.2	20.5	14.2
405	340	Whiscash	Water	Ground	['Anticipation', 'Hydration', 'Oblivious']	110	78	73	76	71	...	1.0	0.5	1.0	1.0	1.0	0.5	1.0	0.9	23.6	29.1
502	422	Shellos	Water	NaN	['Sand Force', 'Sticky Hold', 'Storm Drain']	76	48	48	57	62	...	1.0	1.0	1.0	1.0	1.0	0.5	1.0	0.3	6.3	70.0
976	849	Toxtricity	Electric	Poison	['Plus', 'Punk Rock', 'Technician']	75	98	70	114	70	...	0.5	1.0	1.0	1.0	1.0	0.5	0.5	1.6	40.0	15.6

5 rows × 44 columns

`describe()`

Esta função nos ajuda a ter uma idéia dos valores que temos em nosso conjunto de dados. A função lista todas as colunas numéricas e apresenta os resultados para os seguintes cálculos estatísticos: média, desvio padrão, valor mínimo, percentil 25%, 50%, 75% e valor máximo.

Isso nos dá uma idéia da variabilidade dos nossos dados, bem como permite uma análise de correlação superficial entre os valores numéricos.

pokemons.describe()

	Number	HP	Att	Def	Spa	Spd	Spe	BST	Mean	Standard Deviation	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
count	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	...	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000	1032.000000
mean	439.226744	69.906008	80.526163	74.609496	72.918605	72.139535	68.548450	438.648256	73.108043	20.028104	...	1.002180	1.239826	1.025678	0.974806	1.074855	0.992006	1.094234	1.286822	71.879845	136.735756
std	261.871350	26.189155	32.542374	30.905972	32.773495	27.625876	30.219526	120.675545	20.112591	10.830298	...	0.613111	0.699361	0.577269	0.378040	0.475292	0.511859	0.535159	1.391501	132.872741	3111.666658
min	1.000000	1.000000	5.000000	5.000000	10.000000	20.000000	5.000000	175.000000	29.166667	0.000000	...	0.250000	0.250000	0.000000	0.000000	0.250000	0.250000	0.250000	0.100000	0.100000	0.000000
25%	211.750000	50.000000	55.000000	50.000000	50.000000	50.000000	45.000000	330.000000	55.000000	12.801910	...	0.500000	1.000000	1.000000	1.000000	1.000000	0.500000	1.000000	0.600000	9.000000	18.600000
50%	434.500000	67.000000	78.000000	70.000000	65.000000	70.000000	65.000000	459.000000	76.500000	18.484228	...	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	29.750000	28.350000
75%	667.250000	83.000000	100.000000	90.000000	95.000000	90.000000	90.000000	515.000000	85.833333	24.835709	...	1.000000	2.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.600000	71.275000	42.200000
max	898.000000	255.000000	190.000000	230.000000	194.000000	230.000000	200.000000	780.000000	130.000000	103.215659	...	4.000000	4.000000	4.000000	2.000000	4.000000	4.000000	4.000000	20.000000	999.900000	99990.000000

8 rows × 39 columns

`info()`

Outra função útil é a função info() que traz a descrição da estrutura do DataFrame. Com esta função, você pode verificar os seguintes dados:

lista colunas do DataFrame
para cada coluna, quantos elementos não-nulos ela possui
para cada coluna, seu tipo
E ainda o número total de linhas e colunas no DataFrame

pokemons.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1032 entries, 0 to 1031
Data columns (total 44 columns):
 # Column Non-Null Count Dtype  
--- ------ -------------- -----  
 0 Number 1032 non-null int64  
 1 Name 1032 non-null object 
 2 Type 1 1032 non-null object 
 3 Type 2 548 non-null object 
 4 Abilities 1032 non-null object 
 5 HP 1032 non-null int64  
 6 Att 1032 non-null int64  
 7 Def 1032 non-null int64  
 8 Spa 1032 non-null int64  
 9 Spd 1032 non-null int64  
 10 Spe 1032 non-null int64  
 11 BST 1032 non-null int64  
 12 Mean 1032 non-null float64
 13 Standard Deviation 1032 non-null float64
 14 Generation 1032 non-null float64
 15 Experience type 1032 non-null object 
 16 Experience to level 100 1032 non-null int64  
 17 Final Evolution 1032 non-null float64
 18 Catch Rate 1032 non-null int64  
 19 Legendary 1032 non-null float64
 20 Mega Evolution 1032 non-null float64
 21 Alolan Form 1032 non-null float64
 22 Galarian Form 1032 non-null float64
 23 Against Normal 1032 non-null float64
 24 Against Fire 1032 non-null float64
 25 Against Water 1032 non-null float64
 26 Against Electric 1032 non-null float64
 27 Against Grass 1032 non-null float64
 28 Against Ice 1032 non-null float64
 29 Against Fighting 1032 non-null float64
 30 Against Poison 1032 non-null float64
 31 Against Ground 1032 non-null float64
 32 Against Flying 1032 non-null float64
 33 Against Psychic 1032 non-null float64
 34 Against Bug 1032 non-null float64
 35 Against Rock 1032 non-null float64
 36 Against Ghost 1032 non-null float64
 37 Against Dragon 1032 non-null float64
 38 Against Dark 1032 non-null float64
 39 Against Steel 1032 non-null float64
 40 Against Fairy 1032 non-null float64
 41 Height 1032 non-null float64
 42 Weight 1032 non-null float64
 43 BMI 1032 non-null float64
dtypes: float64(29), int64(10), object(5)
memory usage: 354.9+ KB

`shape`

Esta não é uma função, mas sim uma propriedade, que retorna uma tupla com as dimensões de linha e coluna do DataFrame.

pokemons.shape

(1032, 44)

Filtrando os dados

Agora vamos aprender como executar uma das tarefas mais comuns de manipular DataFrames com o objetivo de realizar análises: filtragem dos dados. A versão atual do pandas trouxe algumas funções que nos facilitam enormemente o processo. Mas, com o objetivo de equipa-los com o máximo de informação possível, vamos também aprender os métodos mais conhecidos.

Mas, antes de mostrarmos como realizar os filtros, vamos explicar alguns conceitos básicos, mas bem relevantes para a operação de filtragem dos dados.

Acessando uma coluna do DataFrame

Pode parecer óbvio, mas para acessar a coluna de um DataFrame, basta fazer o seguinte:

tipos = pokemons["Type 1"]

Assim, a variável tipos conterá o que chamamos de uma Series, que é um array numpy (biblioteca especializada para criação de arrays numéricos) que contém todas as linhas daquela coluna. Para comprovar isso, vamos imprimir o conteúdo.

tipos

0 Grass
1 Grass
2 Grass
3 Grass
4 Fire
         ...   
1027 Ice
1028 Ghost
1029 Psychic
1030 Psychic
1031 Psychic
Name: Type 1, Length: 1032, dtype: object

Parece interessante. Mas e se quisessemos criar um novo DataFrame apenas com as colunas Number, Name e Type 1? Parece simples, basta enviar ao DataFrame um array com o nome das colunas que quero extrair.

sub_df = pokemons[["Number", "Name", "Type 1"]]

sub_df

	Number	Name	Type 1
0	1	Bulbasaur	Grass
1	2	Ivysaur	Grass
2	3	Venusaur	Grass
3	3	Mega Venusaur	Grass
4	4	Charmander	Fire
...	...	...	...
1027	896	Glastrier	Ice
1028	897	Spectrier	Ghost
1029	898	Calyrex	Psychic
1030	898	Calyrex Ice Rider	Psychic
1031	898	Calyrex Shadow Rider	Psychic

1032 rows × 3 columns

Tip

Observe a questão da sintaxe de array: quando queremos apenas uma coluna a sintaxe de array não é necessária, ela se aplica apenas a múltiplos campos.

Mas, e como podemos acessar uma linha específica de um DataFrame? Se você está seguindo a linha de raciocínio, já imaginou que não é da maneira tradicional. Na verdade, é exatamente ao contrário do que estamos acostumados. Primeiro acessamos a coluna, e depois a linha, enquanto que em conjuntos de dados em formato tabular largo, primeiro acessamos a linha e depois a coluna.

pokemons["Name"][0]

'Bulbasaur'

Percorrendo um DataFrame

Interessante, certo? Mas isso levanta o seguinte questionamento: quando vou manipular os dados, como filtra-los ou fazer alguma modificação? Nos conjuntos de dados mais tradicionais, eu geralmente percorro o meu conjunto de dados linha a linha e faço os filtros e então altero as colunas. Como fazer isso em pandas?

for index, pokemon in pokemons.iterrows():
 if index <= 2:
 print(pokemon["Name"])
 else:
 break

Bulbasaur
Ivysaur
Venusaur

Como pode ser visto no código acima, basta usarmos a função iterrows() e iremos manipular o DataFrame como uma estrutura de dados mais tradicional, como um array de dicionário de dados. No código acima, fizemos um filtro que pega apenas as linhas com index menor ou igual 2, e mostra apenas o nome. Se DataFrames fossem estruturas de dados tradicionais, isso seria a maneira mais lógica de executar esse comando. Mas com pandas, podemos fazer isso:

pokemons[pokemons["Number"] <= 3]["Name"]

0 Bulbasaur
1 Ivysaur
2 Venusaur
3 Mega Venusaur
Name: Name, dtype: object

Wow, em uma única linha fizemos o filtro de linha e a seleção de coluna, e a principal vantagem sendo que este comando continuou retornando um DataFrame, o que ainda nos permite continuar trabalhando de forma eficiente com os dados que eu escolhi!

Warning

Embora a utilização da função iterrows() pareça ser a forma mais natural e fácil de se trabalhar com Dataframes Pandas, é com a certeza a que apresenta a pior performance. Então, faça um esforço e aprenda muito bem os métodos mais “pandônicos” de manipular Dataframes, Cientista de Dados!

Esta linha também nos introduz ao primeiro jeito de realizar filtros de linha: adicionando a expressão lógica nos primeiros parenteses. Parece simples, embora para referenciar ao campo que será utilizado no filtro, eu ainda precise referenciar o próprio DataFrame. E esse foi apenas um filtro simples. Como seria utilizar mais de um campo no filtro? Vamos ver agora mesmo.

pokemons[(pokemons["Number"] < 11) & (pokemons["Type 1"] == "Bug")]["Name"]

13 Caterpie
Name: Name, dtype: object

Podemos perceber duas coisas: cada condição de filtro deve estar envolta em parenteses (vá em frente, se remover, teremos um erro), e em vez de usar o conector lógico tradicional AND ou OR, utilizamos & (AND) ou | (OR). E quanto mais condições, pior será para lermos com clareza nosso código.

Uma variação deste tipo de filtragem é a utilização da propriedade loc. Ela nos permite acessar linhas diretamente, e utilizando a notação de manipulação de arrays, filtrar rapidamente o DataFrame. Vamos a um exemplo: gostaria de extrair 10 linhas do DataFrame, iniciando na linha 10.

pokemons.loc[10:19]

	Number	Name	Type 1	Type 2	Abilities	HP	Att	Def	Spa	Spd	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
10	8	Wartortle	Water	NaN	['Rain Dish', 'Torrent']	59	63	80	65	80	...	1.0	1.0	1.0	1.0	1.0	0.5	1.0	1.0	22.5	22.5
11	9	Blastoise	Water	NaN	['Rain Dish', 'Torrent']	79	83	100	85	105	...	1.0	1.0	1.0	1.0	1.0	0.5	1.0	1.6	85.5	33.4
12	9	Mega Blastoise	Water	NaN	['Mega Launcher']	79	103	120	135	115	...	1.0	1.0	1.0	1.0	1.0	0.5	1.0	1.6	101.1	39.5
13	10	Caterpie	Bug	NaN	['Run Away', 'Shield Dust']	45	30	35	20	20	...	1.0	2.0	1.0	1.0	1.0	1.0	1.0	0.3	2.9	32.2
14	11	Metapod	Bug	NaN	['Shed Skin']	50	20	55	25	25	...	1.0	2.0	1.0	1.0	1.0	1.0	1.0	0.7	9.9	20.2
15	12	Butterfree	Bug	Flying	['Tinted Lens']	60	45	50	90	80	...	0.5	4.0	1.0	1.0	1.0	1.0	1.0	1.1	32.0	26.4
16	13	Weedle	Bug	Poison	['Run Away', 'Shield Dust']	40	35	30	20	20	...	0.5	2.0	1.0	1.0	1.0	1.0	0.5	0.3	3.2	35.6
17	14	Kakuna	Bug	Poison	['Shed Skin']	45	25	50	25	25	...	0.5	2.0	1.0	1.0	1.0	1.0	0.5	0.6	10.0	27.8
18	15	Beedrill	Bug	Poison	['Sniper', 'Swarm']	65	90	40	45	80	...	0.5	2.0	1.0	1.0	1.0	1.0	0.5	1.0	29.5	29.5
19	15	Mega Beedrill	Bug	Poison	['Adaptability']	65	150	40	15	80	...	0.5	2.0	1.0	1.0	1.0	1.0	0.5	1.4	40.5	20.7

10 rows × 44 columns

Bem prático. A propriedade loc também pode entender o filtro anterior.

E agora, a última maneira pela qual podemos realizar filtros em nossos DataFrames e a mais recomendada devido a legibilidade do código gerado: vamos utilizar a função query(). Esta função permite que escrevamos filtros para o DataFrame como se o mesmo fosse um banco de dados, deixando o código mais limpo, pois eliminamos a necessidade de referenciar o DataFrame a cada filtro, bem como parênteses redundantes. Vamos ver um exemplo:

pokemons.query("Number < 11 and `Type 1` == 'Bug'")

	Number	Name	Type 1	Type 2	Abilities	HP	Att	Def	Spa	Spd	...	Against Bug	Against Rock	Against Ghost	Against Dragon	Against Dark	Against Steel	Against Fairy	Height	Weight	BMI
13	10	Caterpie	Bug	NaN	['Run Away', 'Shield Dust']	45	30	35	20	20	...	1.0	2.0	1.0	1.0	1.0	1.0	1.0	0.3	2.9	32.2

1 rows × 44 columns

Assim ficou bem mais limpo. Uma única observação é quanto ao uso do caracter “`” para campos com nomes compostos.

Agregando os dados

Em muitos casos, não queremos apenas filtrar os dados, mas também realizar totalizações, calcular valores médios, ou até mesmo cálculos mais complexos, de dados que devem ser agregados em um ou mais níveis.

Como exemplo, vamos supor que quisessemos totalizar o número de pokemons de acordo com o seu tipo.

pokemons.groupby(['Type 1'])["Name"].count().reset_index(name="Pokemons")

	Type 1	Pokemons
0	Bug	81
1	Dark	46
2	Dragon	42
3	Electric	59
4	Fairy	22
5	Fighting	42
6	Fire	64
7	Flying	8
8	Ghost	41
9	Grass	91
10	Ground	41
11	Ice	38
12	Normal	114
13	Poison	40
14	Psychic	77
15	Rock	59
16	Steel	36
17	Water	131

Mas quanta coisa nova naquela linha, não é mesmo? Vamos explicar passo a passo:

A primeira função é o groupby, onde especificamos por qual coluna ou colunas iremos fazer o agrupamento. No nosso exemplo, utilizamos a coluna ‘Type 1’
Em seguida, especificamos que, além da coluna ‘Type 1’, queremos apenas a coluna ‘Name’ nos nossos resultados
Logo após, indicamos que o valor original da coluna ‘Name’ será substituído pelo resultado da contagem de quantas linhas do DataFrame tem aquele valor específico da coluna ‘Type 1’
E por último, utilizamos uma função que irá trocar o nome da coluna ‘Name’ por um nome mais significativo

Ufa, e tudo isso em apenas uma linha!

A fórmula para a agregação é sempre a mesma: groupby() e tipo de calculo (sum, count, mean, …). Por exemplo, no código abaixo, vamos agrupar também pela geração.

pokemons.groupby(['Generation', 'Type 1'])['Name'].count().reset_index(name='Pokemons')

	Generation	Type 1	Pokemons
0	1.0	Bug	12
1	1.0	Dragon	3
2	1.0	Electric	9
3	1.0	Fairy	2
4	1.0	Fighting	7
...	...	...	...
129	8.0	Poison	4
130	8.0	Psychic	11
131	8.0	Rock	4
132	8.0	Steel	5
133	8.0	Water	9

134 rows × 3 columns

E se quisermos saber a média de pontos de vida por geração de pokemon? Parece simples…

pokemons.groupby(['Generation'])['HP'].mean().reset_index(name='Average HP')

	Generation	Average HP
0	1.0	64.211921
1	2.0	70.980000
2	3.0	65.326087
3	4.0	72.775862
4	5.0	71.601227
5	6.0	73.323308
6	7.0	69.793103
7	8.0	72.808696

Encerrando

Neste artigo, conhecemos um pouco mais a respeito da biblioteca Pandas e como ela pode nos ajudar a carregar e analisar conjuntos de dados que podem ser utilizados em nossas visualizações, de forma simplificada e eficiente.

Dentro do processo de utilização de Pandas, aprendemos as executar as principais tarefas:

aprender sobre os metadados do conjunto de dados, utilizando: describe, info e shape
listar conteúdo com head, tail, sample e iterrows
acessar células diretamente
realizar filtros em cima do DataFrame utilizando o método colunar, utilizando loc ou utilizando a função query
agregar os dados para sumarizar a informação e facilitar a análise.

Se você quiser saber mais sobre Pandas, eis aqui alguns links que podem ajudar:

Um abraço e até a próxima,

Walter.

Parte 03 - Formatos de Dados

Walter R P Cortes — Sun, 05 Feb 2023 00:00:00 +0000

Olá Devs!

Neste artigo, vamos aprender um pouco mais sobre os formatos utilizados para armazenar os dados que nossas visualizações irão consumir.

Fontes de dados e seus formatos

Para realizarmos nossas tarefas como Cientistas de Dados, é necessário que acessemos aquilo que nos é mais caro, o nosso combustível: os dados.

Estes dados vem das mais diversas fontes: websites, dispositivos IoT, bancos de dados, documentos, … Estas diferentes fontes significam que os dados possuem diferentes formatos, e uma de nossas tarefas é transformar este dado em um formato com o qual seja possível trabalhar e gerar os resultados esperados.

Dentro da área de Ciência da Computação, o formato mais utilizado para servir como base para o processamento de informação é o formato tabular.

Formato Tabular

O formato tabular é utilizado para descrever uma estrutura de dados organizada em linhas e colunas, formando uma tabela. É um formato muito utilizado em bancos de dados relacionais e em arquivos CSV (Comma-Separated Values), onde cada linha representa um registro ou observação e cada coluna representa uma variável ou campo. Esse formato é muito útil para representar dados estruturados de forma clara e organizada, permitindo a fácil manipulação e análise dos dados.

Abaixo, temos um exemplo prático de como podemos utilizar Python para carregar um arquivo CSV em nosso notebook.

import csv

# Abre o arquivo CSV em modo leitura
with open('exemplo.csv', 'r') as arquivo_csv:
 # Cria um objeto para ler o arquivo CSV
 leitor_csv = csv.reader(arquivo_csv, delimiter=',')

 # Percorre as linhas do arquivo CSV
 for linha in leitor_csv:
 print(linha)

['Nome', 'Idade', 'Cidade']
['Maria', '25', 'São Paulo']
['João', '30', 'Rio de Janeiro']
['Ana', '20', 'Belo Horizonte']
['Andre', '23', 'Porto Alegre']

Neste exemplo, utilizamos a função open para abrir o arquivo CSV em modo leitura e, em seguida, criamos um objeto csv.reader para ler o arquivo CSV. Utilizamos o parâmetro delimiter para indicar o caractere separador utilizado no arquivo CSV (no caso, a vírgula). Em seguida, utilizamos um loop for para percorrer as linhas do arquivo CSV e imprimir cada uma delas na tela.

Note que, neste exemplo, o resultado é uma lista de listas, onde cada lista interna representa uma linha do arquivo CSV. Para manipular os dados, é necessário fazer a conversão manualmente para o formato desejado.

E, apesar deste formato ser adequado ao processamento dos dados para visualização, ainda precisamos fazer alguns ajustes até chegar ao formato ideal.

Otimizando o Formato Tabular

O formato tabular padrão também pode ser referenciado pelo termo ‘Formato Largo’ (Wide format em inglês), por sua característica de organização em linhas e colunas, com a linha sendo uma observação e as colunas sendo as variáveis da observação. Isto pode ser percebido pelo formato que nossos código percorrem os arquivos ou selecionam a informação de um banco de dados: sempre pensando em extrair linhas que depois são usadas em algum tipo de processamento. Isso gera o que chamamos de overhead no processamento, porque por vezes precisamos apenas fazer o processamento de uma coluna de dados, mas somos obrigados a acessar todas as colunas para depois selecionar a coluna que queremos.

Para resolver essa questão, foi criado um caso especial de formato tabular, o chamado ‘Formato Longo’ (Long format em inglês), onde a orientação da organização dos dados é colunas e linhas, ou seja, podemos acessar uma coluna individualmente, com todas as suas linhas.

Formato Longo X Formato Largo

Em Python e em muitas outras linguagens de programação que são utilizadas para Ciência de Dados, o formato tabular é representado por estruturas de dados especiais, chamadas de DataFrames e Series.

Mas antes de explicar em mais detalhes essas estruturas, vamos conhecer um pouco das suas origens.

Dicionários e Listas

Se você já conhece o básico de Python, já aprendeu que temos os tipos de dados conhecidos como listas e dicionário de dados. Com estes tipos, podemos representar dados mais complexos, como uma sequência ou um objeto, que são compostos de vários tipos simples. Se você quiser aprender mais sobre listas e dicionários, vá para o final deste notebook.

Em Python, a representação de dados no formato tabular, seja longo ou largo, passa pela combinação destes dois tipos de dados.

Representação em Python do Formato Largo

Para criar um objeto em Python que represente um conjunto de dados no Formato Largo, é necessário montar uma lista de dicionários.

dados_largos = [
 {"codigo": 1, "nome": "Jose"},
 {"codigo": 2, "nome": "Maria"},
 {"codigo": 3, "nome": "Fernandez"}
]

Neste objeto, temos uma lista que contém 3 elementos. Cada elemento é um dicionário com dois campos. Conforme explicamos anteriormente, no formato largo, para acessar o nome de uma pessoa, precisamos identificar em que linha ela está. Para identificar a linha, percorremos nossa lista. Para inspecionar o nome, recuperamos todo o dicionário que está naquela posição da lista.

Representação em Python do Formato Longo

Para criar um objeto em Python que represente um conjunto de dados no Formato Longo, é necessário montar um dicionário de listas.

dados_longos = {
 "codigo": [1,2,3], 
 "nome": ["Jose","Maria","Fernandez"]
 }

Neste objeto, temos o dicionário com seus campos, e cada campo é uma lista com os valores para cada linha.

Entendendo a diferença

Vamos ver um exemplo prático para entender a diferença entre os dois. Acompanhe no código abaixo e leia os comentários.

# Queremos saber o nome do usuário que está na segunda linha do nosso conjunto de dados.

# Formato largo
print(dados_largos[1]["nome"]) # utilizamos o indice 1 porque em Python listas começam no indice 0

# Formato longo
print(dados_longos["nome"][1]) # apenas invertemos a referência - primeiro a coluna, depois a linha

Maria
Maria

A diferença parece pouca, certo? Apenas invertemos como os indices são acessados, onde está a tal otimização?

A otimização está no fato de que, ao acessar a linha de um dado no formato largo, estamos acessando todas as colunas de informação daquela linha.

print(dados_largos[1])

{'codigo': 2, 'nome': 'Maria'}

Já no formato longo, antes de especificar a linha, eu preciso referenciar a coluna, portanto, sempre terei apenas um valor.

print(dados_longos["nome"][1])

Maria

DataFrames e Series

O DataFrame e as Series são dois dos principais conceitos utilizados para trabalhar com dados em Python. Ambos estão presentes na biblioteca Pandas, que é uma das ferramentas mais usadas para análise de dados.

O DataFrame é um objeto que tem como base o conceito de dicionário de listas, onde as listas são representadas por Series. O DataFrame adiciona uma série de funcionalidades ao dicionário de listas, simplificando a manipulação dos mesmos.

Exemplo de código:

import pandas as pd 
df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
print(df[2][2])

A Series é uma lista com superpoderes. Assim como o DataFrame, a Series acrescenta muitas facilidades para manipular a lista. Exemplo de código:

import pandas as pd 
s = pd.Series([1, 2, 3]) 
print(s[2])

Além do Pandas existem outras bibliotecas que utilizam esses conceitos para trabalhar com dados como NumPy (Numerical Python), SciPy (Scientific Python) e Scikit-learn (Machine Learning).

Finalizando

Neste artigo, aprendemos sobre os formatos de dados que podemos utilizar em nossas visualizações e conhecemos mais detalhes dos DataFrames e Series.

Aqui temos alguns links sobre o assunto: - Listas - Dicionários

DEV Community: Walter R P Cortes

Parte 1: Introdução ao dbt

Introdução

dbt (data build tool)

Instalação

Configuração

Inicializando um projeto dbt

dbt_project.yml

Escrita de modelos dbt

Executando o dbt

Conclusão

Teste em Dados - Básico

Obtendo os Dados

Tipos de Validação

Dataset está vazio

Coluna está vazia

Verificando Valores Nulos

Verificando os tipos de dados

Outros Tipos de Validação

Teste contra valores

Apenas maiores de 40 anos

Verifica contra Lista de Valores

EDA

Jupyter-summarytools

T_e3ff2 thead>tr>th {

T_e3ff2_row0_col0, #T_e3ff2_row1_col0, #T_e3ff2_row2_col0, #T_e3ff2_row3_col0, #T_e3ff2_row4_col0, #T_e3ff2_row5_col0, #T_e3ff2_row6_col0 {

T_e3ff2_row0_col1, #T_e3ff2_row1_col1, #T_e3ff2_row2_col1, #T_e3ff2_row3_col1, #T_e3ff2_row4_col1, #T_e3ff2_row5_col1, #T_e3ff2_row6_col1 {

T_e3ff2_row0_col2, #T_e3ff2_row1_col2, #T_e3ff2_row2_col2, #T_e3ff2_row3_col2, #T_e3ff2_row4_col2, #T_e3ff2_row5_col2, #T_e3ff2_row6_col2 {

T_e3ff2_row0_col3, #T_e3ff2_row1_col3, #T_e3ff2_row2_col3, #T_e3ff2_row3_col3, #T_e3ff2_row4_col3, #T_e3ff2_row5_col3, #T_e3ff2_row6_col3 {

T_e3ff2_row0_col4, #T_e3ff2_row1_col4, #T_e3ff2_row2_col4, #T_e3ff2_row3_col4, #T_e3ff2_row4_col4, #T_e3ff2_row5_col4, #T_e3ff2_row6_col4 {

T_e3ff2_row0_col5, #T_e3ff2_row1_col5, #T_e3ff2_row2_col5, #T_e3ff2_row3_col5, #T_e3ff2_row4_col5, #T_e3ff2_row5_col5, #T_e3ff2_row6_col5 {

Sweetviz

D-Tale

Criando os testes unitários

1a Execução

2a Execução

3a Execução

4a Execução

Conclusão

AI na Análise de Dados - Classificação de Texto com a API da OpenAI

Introdução

Classificação de Dados

Mas e se não temos conjuntos de dados de treinamento?

GPT versus métodos mais tradicionais de classificação

Ok, o GPT é legal e tudo o mais… Mas e daí?

Organizando um catálogo de artigos

Inicializando o ambiente

Links Úteis

Power BI no Jupyter!

Introdução

PowerBI - Rápida Introdução

Power BI Embeddings

Biblioteca powerbiclient

Preparando o ambiente

Carregando os dados

Autenticando no Serviço do Power BI

Visualizando!

Finalizando

Pandas AI - Converse com seu DataFrame

Introdução

Status Outubro/2024

E o que isso tem a ver com Ciências de Dados?

O que é o Pandas AI?

Preparando o Ambiente

Vamos complicar um pouco?

Usando outras funcionalidades do Pandas via conversação

O que aprendemos até aqui

Mas nem tudo são flores…

Vale a pena utilizar?

Parte 09 - Seaborn - Melhorando seus Visuais

Problema

Solução Passo a Passo

Carregando Bibliotecas

Carregando dados

Analisando os dados

Transformando os dados

Primeira Versão

Passo 1 - Adicionando Títulos

Passo 2 - Ajustando tamanho da imagem

Passo 3 - Ajustando Qualidade da Imagem

Biblioteca `powerbiclient`

`countplot()`

`barplot()`

`head()`

`tail()`

`sample()`

`describe()`

`info()`

`shape`