Big Data

Analisando Comércio Mundial com Hadoop

$ cat conhecendo_hadoop.md

Como usamos MapReduce para processar milhões de registros do UN Comtrade, os erros reais que encontramos e como resolvemos

8 min← blog

Em um projeto de Big Data na faculdade, o desafio foi processar milhões de linhas de dados de comércio internacional usando Apache Hadoop e o modelo de programação MapReduce. O dataset era do UN Comtrade — uma base pública com registros de exportações e importações de países do mundo inteiro, de 1988 até os dias de hoje.

Neste post vou mostrar o que construímos, os erros reais que encontramos e como chegamos às respostas.


O problema: dados demais para um computador só

O arquivo tinha esta cara:

country_or_area ; year ; comm_code ; commodity            ; flow   ; trade_usd ; weight_kg ; quantity_name   ; quantity ; category
Afghanistan     ; 2016 ; 010410    ; Sheep, live          ; Export ; 6088      ; 2339      ; Number of items ; 51       ; 01_live_animals
Albania         ; 2016 ; 010511    ; Fowls, live < 185g   ; Import ; 2671732   ; 254652    ; Number of items ; 5629138  ; 01_live_animals
...

Milhões de linhas assim. Perguntas simples como "quantas transações o Brasil fez?" ou "qual foi a transação mais cara por ano e país?" exigem varrer o arquivo inteiro — algo lento demais para fazer de forma convencional.

A solução é o Hadoop MapReduce: dividir o arquivo entre várias máquinas e processar tudo em paralelo.


Como o MapReduce funciona (em 30 segundos)

Imagine que você precisa contar quantas vezes cada palavra aparece em um livro enorme. Você divide o livro entre 10 pessoas (Mappers), cada uma conta as palavras do seu trecho e passa um resumo para um contador central (Reducer), que soma tudo.

Arquivo CSV
    ↓
[MAPPER]  — lê cada linha e extrai o que importa
    ↓
[COMBINER] — soma parcialmente antes de enviar pela rede (opcional, mas eficiente)
    ↓
[SHUFFLE & SORT] — Hadoop agrupa automaticamente por chave
    ↓
[REDUCER] — recebe os grupos e calcula o resultado final
    ↓
Arquivo de saída

O programador escreve apenas o Mapper e o Reducer. O Hadoop cuida de tudo no meio.


Os 8 jobs do projeto

Cada "job" responde uma pergunta sobre os dados:

JobPergunta
1Quantas transações envolvem o Brasil?
2Quantas transações por ano?
3Quantas transações por categoria?
4Quantas transações por tipo de fluxo (Export, Import...)?
5Qual o valor médio das transações por ano só no Brasil?
6Qual a transação mais cara e mais barata no Brasil em 2016?
7Qual o valor médio das exportações brasileiras por ano?
8Qual a transação com maior e menor valor por ano e país?

Job 4 — o mais simples: contando por tipo de fluxo

O Job 4 é o clássico "Word Count" do MapReduce: conta quantas transações existem para cada tipo de fluxo (Export, Import, Re-Export, Re-Import).

Como funciona

O Mapper lê cada linha do CSV, extrai a coluna flow (coluna 4) e emite o par (fluxo, 1):

Linha: "Albania;2016;010511;Fowls...;Import;..."
         ↓
Mapper emite: ("Import", 1)

Linha: "Albania;2016;010600;Animals...;Export;..."
         ↓
Mapper emite: ("Export", 1)

Depois de processar todas as linhas, o Combiner soma localmente antes de enviar pela rede:

Buffer local após Mapper:
  ("Import", 1), ("Import", 1), ("Import", 1), ("Export", 1), ...

Combiner comprime para:
  ("Import", 17)   ← saem 2 pares em vez de 22 pela rede
  ("Export", 5)

O Reducer recebe os parciais de todas as máquinas e soma o total final.

Resultado

Export      2.855.135
Import      4.846.943
Re-Export     367.070
Re-Import     153.677

Simples, eficiente, e o Combiner reduziu drasticamente o tráfego de rede.


Job 8 — o mais complexo: min e max por ano e país

O Job 8 precisava responder: para cada combinação de ano e país, qual foi a transação com maior e menor valor?

Isso exigiu criar tipos de dados customizados — o Hadoop padrão não tem uma forma nativa de carregar "mínimo e máximo juntos" como chave ou valor.

Tipos customizados criados

YearCountryKey — chave composta com ano + país:

// Precisa de compareTo() porque o Hadoop ordena as chaves
// Ordena por ano primeiro, depois por país (alfabético)
public int compareTo(YearCountryKey o) {
    int y = Integer.compare(year, o.year);
    if (y != 0) return y;
    return country.compareTo(o.country);
}

MinMaxAmountWritable — valor que carrega mínimo e máximo juntos:

public void merge(MinMaxAmountWritable other) {
    min = Math.min(min, other.min);
    max = Math.max(max, other.max);
}

Como funciona

Linha: "Albania;2016;...;trade_usd=26485;...;quantity=64000;..."
         ↓
Mapper emite:
  chave:  YearCountryKey(2016, "Albania")
  valor:  MinMaxAmountWritable(min=26485, max=26485)

... outras linhas da Albania 2016 ...

Combiner agrupa localmente:
  chave: (2016, "Albania")
  valor: MinMaxAmountWritable(min=26485, max=14265937)

Reducer recebe parciais de todos os nós e faz o merge final:
  saída: "2016\tAlbania" → "26485.0\t14265937.0"

Os erros que encontramos (e como resolvemos)

Erro 1 — o mínimo era sempre 0.0

Ao rodar o Job 8, o resultado era suspeito:

1988    Australia    0.0    9.7535689788E10
1988    Finland      0.0    1.0394190848E10
1989    Brazil       0.0    9.2491235328E10
...

O mínimo era 0.0 para absolutamente todos os países e anos. Isso é estatisticamente improvável — significaria que todo país, em todo ano, tinha pelo menos uma transação com valor zero.

Investigando a causa

O Mapper aceitava qualquer valor numérico, incluindo zero:

Double amount = CsvLineParser.parseDoubleField(cols[COL_AMOUNT]);
if (amount == null) {
    return; // descarta apenas nulos
}
// ← zero passa sem filtro!
context.write(key, new MinMaxAmountWritable(amount));

No dataset UN Comtrade, muitos registros têm quantity = 0 porque a quantidade física não foi registrada para aquela mercadoria (metais preciosos, serviços, re-exportações). Esses zeros "contaminavam" o cálculo do mínimo.

A correção

Uma linha:

// antes
if (amount == null) { return; }

// depois
if (amount == null || amount <= 0) { return; }

Com esse filtro, valores zero passam a ser ignorados e o mínimo passa a refletir a menor transação real.


Erro 2 — a coluna errada estava sendo lida

Após corrigir o Erro 1, o resultado ainda parecia estranho. O mínimo e máximo vinham da coluna quantity (número de itens exportados), não do valor monetário da transação.

2016    Albania    6853.0    5629138.0
         ↑ min              ↑ max
     (6.853 itens)   (5.6 milhões de pintinhos)

Isso não responde "transação mais cara e mais barata" — responde "transação com mais e menos itens".

A raiz do problema

O requisito dizia "maior e menor preço (com base na coluna amount)". No código, COL_AMOUNT = 8 apontava para quantity (coluna física), quando o valor monetário real fica na coluna 5 (trade_usd).

country_or_area ; year ; ... ; flow   ; trade_usd ; weight_kg ; quantity_name ; quantity ; category
                              col 4     col 5       col 6        col 7          col 8      col 9
                                          ↑                                      ↑
                                    valor em USD                           número de itens
                                    (o que queremos)                       (o que estava sendo lido)

A correção

Trocar a constante no Mapper:

// antes — lia quantity (número de itens)
Double amount = CsvLineParser.parseDoubleField(cols[COL_AMOUNT]);

// depois — lê trade_usd (valor em dólares)
Double amount = CsvLineParser.parseDoubleField(cols[COL_PRICE]);

Resultado corrigido

2016    Afghanistan     3958.0       6088.0
2016    Albania        26485.0    14265937.0
2008    Afghanistan  1026804.0    1026804.0

Agora os números representam dólares americanos — fazem sentido como "preço" de uma transação comercial.


O que aprendemos

1. Erros de domínio são silenciosos. Nenhum dos dois erros lançou uma exceção. O programa rodou normalmente, gerou um arquivo de saída — mas os resultados estavam errados. Em Big Data, um filtro ausente ou uma coluna trocada distorce silenciosamente milhões de registros.

2. Questionar o output é parte do trabalho. Ver 0.0 como mínimo para todos os países foi o sinal para investigar. Ver números na casa dos trilhões foi o sinal para questionar a coluna.

3. O Combiner é simples mas poderoso. Nos dois jobs, o Combiner reduziu drasticamente o volume de dados trafegando pela rede — de dezenas de pares para um único objeto por nó. Só funciona quando a operação é associativa (soma, min, max — sim; média direta — não).

4. Tipos customizados abrem possibilidades. O MinMaxAmountWritable e o YearCountryKey mostraram que o Hadoop é extensível: quando os tipos padrão não bastam, você cria os seus e o framework usa normalmente.


Conclusão

O projeto mostrou na prática a diferença entre código correto e análise correta. O Java estava certo — mas o que estava sendo calculado não respondia a pergunta. Entender o dado, questionar o resultado e rastrear o pipeline de ponta a ponta são habilidades tão importantes quanto saber escrever o Mapper e o Reducer.


Projeto desenvolvido em Java 11 com Hadoop 3.3.6. Dataset: UN Comtrade — comércio internacional de mercadorias.

esc

Paleta de comandos