DEV Community: Vinicius Aguiar

Como funciona o sistema de inserção de dados na BD

Vinicius Aguiar — Fri, 28 May 2021 15:32:31 +0000

TL;DR: Vamos conhecer um pouquinho sobre como funciona a infraestrutura de inserção de dados da Base dos Dados e como você pode melhorar seu portfólio de cientista de dados e/ou desenvolvedor contribuindo com a nossa missão de universalizar o acesso a dados.

A Infraestrutura

O time de infraestrutura da Base dos Dados é responsável pelas ferramentas de ingestão de dados, que englobam desde o upload de dados até a disponibilização de dados no ambiente de produção; pelo acesso de dados através de pacotes em Python e R; e pelo website. Neste cenário o time é atualmente dividido em várias frentes, tratando da renovação do site e da implementação de pesos e contrapesos automatizados.

Procuramos simplificar e automatizar todos os processos, começando com o upload de dados e inserção dos mesmos no Ambiente de Experimentação. Neste ponto o colaborador pode adicionar dados em sua nuvem do Google, limpar e tratar os dados, e então criar as tabelas locais com a interface de linha de comando desenvolvida pela infra. Por fim, o colaborador pode submeter a base de dados para revisão, criando um pull request no Github.

Após o pull request de revisão entra em ação o sistema de Pesos e Contrapesos, com o time de dados checando a qualidade dos dados e metadados. Esse ponto é crucial para manter a qualidade dos dados, um diferencial da BD. O time de infra atua procurando automatizar o máximo possível o processo de revisão dos dados, realizando a validação de metadados como descrições e nomes de colunas; e tipos de dados, como dados chaves primárias.

Após a checagem dos dados, o pull request de inserção de dados é aprovado e os dados entram no Ambiente de Produção. Logo podem ser acessados por uma de nossas ferramentas, como os pacotes em Python e R, ou diretamente pelo BigQuery.

Paralelamente ao processo de inserção de dados, o time de Infra também trabalha com a renovação do portal, visando oferecer uma interface moderna.

Contribuindo com dados

No caminho para se tornar um analista de dados ou desenvolvedor nos encontramos com certas dificuldades de entrada no mercado de trabalho. Por vezes não existe balanço entre estudo e aplicação prática, ou somente a análise de dados de brincadeirinha. Levante a mão quem não passou uma época paralisado em bases de dados como o Titanic ou Iris. E apesar dessas bases de dados serem uma boa alternativa para aprender novos métodos ou ferramentas, o conhecimento obtido trabalhando com as mesmas não é transferível para o mundo real.

Uma boa alternativa para lidar com dados reais e melhorar seu portfólio é ajudar a Base dos Dados com a sua ingestão de dados. No mínimo você irá lidar com a captura de dados, preferencialmente de forma automatizada, a arquitetura de dados, e a limpeza dos mesmos. Também vai interagir com ferramentas do dia a dia de um cientista de dados, como interfaces de linha de comando, YAML e BigQuery. A experiência conquistada pode ser crucial na entrada no mercado de trabalho.

Descrevemos em detalhes esse processo em Colaborando com dados na BD+. Em resumo o processo é dividido em quatro partes. Inicialmente você informa seu interesse para a BD. Então limpa e trata os dados. Em seguida realiza upload dos dados em seu BigQuery pessoal. E por fim envia os dados para revisão.

Contribuindo com a infra

Aliás, outra forma de contribuir e melhorar seu portfólio, mas agora de desenvolvedor, é colaborando com a infraestrutura da BD.

A colaboração começa conversando conosco, no bate papo da infra ou nas reuniões às 19h da segunda-feira, ambas nos canais da infra no Discord. Após este passo podemos escolher uma feature ou problema para desenvolvimento, isto é, caso ainda não tenha escolhido algum problema contido nas issues.

Como você pode colaborar? Aqui estão algumas ideias:

Adicionando novos conjuntos de dados
Fazendo a revisão de submissões de dados
Aprimorando e criando novas funcionalidades do pacote em Python
Aprimorando e criando novas funcionalidades do pacote em R
Criando um pacote em Stata
Adicionando checagens automáticas de dados
Adicionando checagens automáticas de metadados
Desenvolvendo novas features para o site

Nosso projeto já te ajudou de alguma forma? Saiba como nos ajudar:

Apoie o projeto
Seja um(a) colaborador(a) de dados na BD
Colabore com nossos pacotes
Compartilhe nas redes sociais!

Texto produzido por Vinicius e Fernanda, com apoio de Diego, João e Caio do time de Infra da Base dos Dados 💚

Base dos Dados Python 102

Vinicius Aguiar — Sat, 08 May 2021 15:51:41 +0000

TL;DR: Neste artigo vamos demonstrar como acessar os dados do BD+ via consulta SQL pelo pacote da Base Dos Dados em Python. Em seguida vamos continuar as análises do post Base Dos Dados Python 101, sobre a popularidade de nomes nos estados brasileiros, com o conteúdo adaptado do Workshop "Brincando com dados da BD+ em Python".

import pandas as pd
import geopandas as gpd
import basedosdados as bd
import matplotlib.pyplot as plt

Consultas SQL na BD+

Já vimos em um artigo anterior que podemos acessar a BD+ pela função read_table, capaz de carregar uma tabela por vez. Hoje vamos acessar a BD+ por meio de consultas SQL, com a função read_sql. Recomendamos essa opção, por contar com toda a capacidade da linguagem SQL, acesso amplo ao acervo da BD+ e retorno em formato de dataframe. Além do mais, sua sintaxe é análoga a read_table. Isto é, precisamos apenas fornecer uma consulta válida e um id de projeto do Google Cloud.

A seguir ilustramos uma consulta de dados da tabela de nomes brasileiros do IBGE (2010) cruzada com diretórios brasileiros, com fim de obter o nome mais popular de cada estado. Observe que precisamos fornecer o nome do datalake (basedosdados), dataset (br_bd_diretorios_brasil) e tabela (municipio).

df = bd.read_sql(
    '''
    SELECT estado.uf AS state, estado.municipio AS town, nomes.nome AS name, nomes.qtde_nascimentos_ate_2010 AS freq
    FROM  basedosdados.br_ibge_nomes_brasil.quantidade_municipio_nome_2010 AS nomes
    INNER JOIN basedosdados.br_bd_diretorios_brasil.municipio AS estado ON nomes.id_municipio = estado.id_municipio
    ''',
    billing_project_id='basedosdados42'
)

Após lermos os dados realizamos um pré-processamento. Neste processo, eliminamos nomes únicos ou erros em municípios, como: Awo, Yorane e Zilneide. Por fim, também calculamos a frequência dos nomes nos estados por 100.000 pessoas.

df = df[df.duplicated('name', keep=False)] # seleciona nomes que aparecem mais de uma vez

total_by_state = df.groupby('state').freq.sum() # agrupa o total por estado
df = df.merge(total_by_state, on='state', suffixes=('', '_total_by_state')) # une os dados com total por estado

df['freq_per_100k'] = 100_000 * df.freq / df.freq_total_by_state # cria o total por estado por 100k pessoas

Em que estado Fred é mais famoso?

Nossa primeira questão de análise é descobrir como está distribuída a frequência de um nome nos estados brasileiros. Em particular gostaríamos de saber em qual estado Fred, nome de um de nossos desenvolvedores, é o nome mais famoso. Então vamos contar a frequência do nome Fred por 100.000 pessoas em cada estado, e em seguida representar este dado com um mapa com gradiente de cores (coroplético).

Para isso, previamente instalamos a biblioteca geopandas para auxiliar o desenho do mapa e manualmente criamos um mapeamento entre o nome de um estado e sua abreviação nos dados geográficos state2abbr.

state2abbr = {
    'Acre': 'BR.AC', 'Alagoas': 'BR.AL', 'Amapá': 'BR.AP',
    'Amazonas': 'BR.AM', 'Bahia': 'BR.BA', 'Ceará': 'BR.CE',
    'Distrito Federal': 'BR.DF', 'Espírito Santo': 'BR.ES',
    'Goiás': 'BR.GO', 'Maranhão': 'BR.MA', 'Mato Grosso': 'BR.MT',
    'Mato Grosso do Sul': 'BR.MS', 'Minas Gerais': 'BR.MG',
    'Pará': 'BR.PA', 'Paraíba': 'BR.PB', 'Paraná': 'BR.PR',
    'Pernambuco': 'BR.PE', 'Piauí': 'BR.PI', 'Rio de Janeiro': 'BR.RJ',
    'Rio Grande do Norte': 'BR.RN', 'Rio Grande do Sul': 'BR.RS',
    'Rondônia': 'BR.RO', 'Roraima': 'BR.RR', 'Santa Catarina': 'BR.SC',
    'São Paulo': 'BR.SP', 'Sergipe': 'BR.SE', 'Tocantins': 'BR.TO',
}

Em seguida criamos a função visualize_name que filtra os dados do nome, agrupa a frequência por estados e desenha o mapa.

def visualize_name(df, name):
    name_df = df.query(f'name == "{name}"') # filtra o nome escolhido
    name_df = name_df.groupby('state', as_index=False).sum() # agrupa pelos estados
    name_df.state = name_df.state.apply(lambda x: state2abbr[x]) # abrevia os estados
    name_df = name_df.rename(columns={'state': 'HASC_1'}) # renomeia a coluna

    fig, ax = plt.subplots(1, 1)
    br_map = gpd.read_file('./shapes/gadm36_BRA_1.shp') # lê o mapa
    br_map = br_map.merge(name_df, on='HASC_1', how='outer') # une o mapa com os dados
    br_map.plot(column='freq_per_100k', ax=ax, legend=True) # desenha o gráfico

visualize_name(df, 'Fred')

Interessante notar como Fred parece um nome comum em estados como Amazonas e Roraima, devido a população nestes estados ser menor quando comparada com São Paulo.

Quais são os nomes mais regionais?

Essa é uma boa pergunta a se fazer: qual nome é mais exclusivo de uma região? Ou seja, é mais provável de ser encontrado numa determinada região e não em outros estados.

Vamos solucionar esta dúvida agrupando a frequência de nomes dos municípios em estados. Em seguida excluímos os nomes que aparecem apenas em um estado. Para então calcular a mediana e desvio padrão das frequências de cada nome distinto, e por fim normalizamos as frequências de nomes.

state_df = df.groupby(['name', 'state'], as_index=False).sum() # soma as frequências de municípios
state_df = state_df[state_df.duplicated('name', keep=False)] # elimina nomes não duplicados

median = state_df.groupby('name', as_index=False).freq_per_100k.median()
state_df = state_df.merge(median, on='name', suffixes=('', '_median'))

std = state_df.groupby('name', as_index=False).freq_per_100k.std()
state_df = state_df.merge(std, on='name', suffixes=('', '_std'))

state_df['freq_per_100k_zscore'] = state_df.freq_per_100k
state_df['freq_per_100k_zscore'] -= state_df.freq_per_100k_median
state_df['freq_per_100k_zscore'] /= state_df.freq_per_100k_std

Podemos então visualizar quais são os nomes mais regionais, procurando pela máxima frequência normalizada de cada estado.

idxmax = state_df[['state', 'freq_per_100k_zscore']].groupby('state').idxmax()
idxmax = idxmax.values.ravel()

max_name_by_state = state_df.loc[idxmax][['state', 'name', 'freq_per_100k_zscore']]
max_name_by_state = max_name_by_state.sort_values(by='state').set_index('state')

Para aprender como funciona, nada melhor que brincar com o código. Agora é com você!! Como ficou seu nome no ranking? Em qual estado aparece com maior frequência? Fez uma análise da sua família e descobriu alguma coisa legal? Conta pra gente no twitter!

Confira o notebook com a análise completa no nosso repositório:

basedosdados / analises

📊 Repositório de códigos simples e replicáveis das análises publicadas.

Texto produzido por Vinicius, Fernanda e Paolo, da Base dos Dados 💚

Razões para se tornar um Alquimista I

Vinicius Aguiar — Tue, 04 May 2021 18:19:08 +0000

Introdução a poções e receitas em Elixir

Desenvolver em Elixir tem se mostrado uma experiência agradável e gostaria de compartilhar um pouco do meu aprendizado. Nesta série de posts vou apresentar as razões que me motivaram a continuar estudando esta linguagem e seu ecossistema. E neste post em específico vou apresentar o operador Pipe e Pattern Matching.

Digressões

No final da minha última entrevista de emprego (em que não obtive sucesso) o gestor perguntou como eu enxergava meu futuro no cargo e o que gostaria de aprender. Para surpresa de ninguém respondi que gostaria de não estar trabalhando na área e sim estudando algo mais interessante (quem iria imaginar que eu não iria passar no processo seletivo hein), como processing ou programação funcional. Sem entrar no mérito da área ser interessante ou não, afinal é uma questão de preferência, foi uma péssima resposta que me fez refletir melhor se gostaria de trabalhar na área.

Para entender melhor quais seriam meus próximos passos resolvi estudar uma linguagem funcional, e Elixir foi a escolhida. Esses são meus primeiros passos neste paradigma, e não é uma assunto simples. Citando Joe Armstrong:

"When you start working with a new programming language, on the
surface it seems that all you are doing is learning a new anguage. But at a deeper level, you are doing something much more profound - you are learning a new way of thinking."

Pipe

O pipe é um operador que passa o resultado de uma expressão como primeiro parâmetro da próxima expressão, de acordo com a Elixir School. É bem conveniente quando precisamos passar um valor por uma série operações em cadeia, provendo uma forma de expressarmos melhor o processo. Através do pipe podemos evitar códigos escritos desta forma:

E abrir espaço para forma mais elegante:

Note que o pipe é um operador bastante conhecido na comunidade de programação, já foi previamente adotado por F#, Ocaml e Julia. E há pouco tempo atrás o operador foi adotado como síntaxe nativa na linguagem R, apesar de ser utilizado anteriormente. Como programador usual de Python, eu sinto que gostaria de uma feature semelhante.

Pattern Matching

Segundo a Elixir School, em Elixir o operador de igualdade ou atribuição (=) é na verdade o operador de match. Ele compara os lados esquerdo e direito da expressão, tentando igualar os mesmos, e caso consiga retorna o valor da expressão. Desta forma ao compararmos uma variável não declarada previamente a um valor, atribuímos o valor a variável.

Apesar de parecer exatamente igual ao operador de atribuição clássico neste exemplo, pattern matching permite uma gama de operações interessantes. Por exemplo, é possível extrair valores de bearer tokens com:

E aplicar pattern matching no nome de funções:

No primeiro exemplo a expressão à esquerda realiza o pattern matching com a entrada da forma ["Bearer password"]. Desta forma extraio o token e em seguida retorno uma tupla com uma flag de sucesso e o token. Já o segundo exemplo mostra uma forma de declarar a mesma função com entradas distintas. Desta forma evitamos a necessidade de criar funções com assinaturas distintas ou utilizar estruturas de controle dentro das funções.

A capacidade de pattern matching se extende muito além dos exemplos apresentados, e em particular acho muito prático para extrair campos específicos de structs. Para conhecer melhor suas capacidades eu indico o próprio Getting Started da Elixir.

Bônus: O tema drácula para Elixir do VSCode

Uma sólida escolha para visualizar o código de noite. Esse tema é uma extensão do VSCode que permite uma boa visualização do código, em particular gosto do highlight amarelo dos módulos.

E por onde estou aprendendo?

Comecei a jornada pelo livro Learn Functional Programming with Elixir de Ulisses Almeida, e daí segui pra implementação de programas simples com suporte do Getting Started. Agora estou lendo Programming Phoenix 1.4 de Chris McCord, Bruce Tate e José Valim (O criador da linguagem é BR).

E quem pode ajudar?

A comunidade é bem ativa e prestativa, apesar das perguntas meio bobas que me vem em mente. (Não se engane, existem perguntas ruins, mas nunca deixe de perguntar). Recomendo conversar em Elug CE, Elixir BR e Elixir UTFPR.

Agradecimentos

Obrigado.