# Atlas de Dados — caderno aberto de ciência de dados e IA

Conteúdo completo, 15 matérias. Site: https://atlas.frediania.com

# Estatística para Ciência de Dados

> Tipos de variável, estatística descritiva, distribuições de probabilidade, testes de hipótese, correlação e intervalo de confiança — a base de tudo que vem depois.

## Visão geral

Quase todo erro em análise de dados começa na estatística: uma variável classificada errado, uma média calculada onde não cabe, um teste aplicado sem conferir a pergunta. Esta matéria organiza o raciocínio em três camadas:

1. **Estrutura**: o banco de dados tem **observações nas linhas** e **variáveis nas colunas**. É assim no Excel, no pandas e em qualquer modelo.
2. **Descrição**: resumir a amostra que você tem (frequências, posição, dispersão, forma).
3. **Inferência**: usar distribuições teóricas para tirar conclusões sobre a população (testes de hipótese e intervalos de confiança).

A regra que atravessa tudo: **o tipo da variável decide a ferramenta**.

## Tipos de variável

- **Qualitativa (categórica)**: classifica, não mede. Ex.: estado civil, cor, região, aprovado/reprovado, faixa de renda.
- **Quantitativa (métrica)**: conta ou mede.
  - **Discreta**: valores inteiros (número de filhos, de pedidos).
  - **Contínua**: qualquer valor real (renda, temperatura, tempo).
- **Armadilha central**: número não significa métrica. Codificar Brasil = 1, Argentina = 2, Chile = 3 é só um rótulo; tirar média disso é uma *ponderação arbitrária*.
- O contrário é permitido: transformar métrica em categórica (renda → faixas) é **categorização**.
- Escala de 0 a 10 com só os extremos descritos tende a ser tratada como métrica; escala em que todos os pontos têm rótulo ("pouco satisfeito"... "muito satisfeito") é categórica.

## Estatística descritiva

### Tabela de frequências (variáveis categóricas)
- **Absoluta** (contagem), **relativa** (% do total), **acumuladas** (somatório até a categoria).
- A relativa permite comparar amostras de tamanhos diferentes.
- As acumuladas dependem da ordem das categorias; servem para mostrar composição (curva ABC / Pareto).
- Para variável contínua, crie faixas antes — **mutuamente exclusivas**, para nenhuma observação ser contada duas vezes.

### Medidas de posição (variáveis métricas)
- **Média** $\bar X = \sum X_i / n$ — sensível a valores extremos.
- **Mediana** — valor central dos dados ordenados; robusta a extremos.
- **Moda** — valor mais frequente (em contínua, pode não existir).
- **Percentis, quartis e decis** — $P_i$ deixa $i\%$ das observações abaixo ou iguais a ele. $Q_1 = P_{25}$, $Q_2 = P_{50}$ (mediana), $Q_3 = P_{75}$.
- Posição do percentil: $\text{Pos}(P_i) = (n-1)\cdot\frac{i}{100} + 1$, com interpolação linear entre posições.

### Medidas de dispersão
- **Mínimo e máximo**: sempre reporte; denunciam erro de coleta (preço zero, valor absurdo).
- **Amplitude** $A = X_{max} - X_{min}$.
- **Amplitude interquartil** $AIQ = Q_3 - Q_1$ (a "caixa" do boxplot). Regra de outlier: abaixo de $Q_1 - 1{,}5\,AIQ$ ou acima de $Q_3 + 1{,}5\,AIQ$.
- **Variância amostral** $S^2 = \sum (X_i - \bar X)^2 / (n-1)$ e **desvio padrão** $S = \sqrt{S^2}$ (mesma unidade dos dados).
- **Erro padrão** $S/\sqrt{n}$: a precisão da média; cai quando a amostra cresce.
- **Coeficiente de variação** $CV = S/\bar X \cdot 100$: dispersão relativa, para comparar variáveis de escalas diferentes.

### Medidas de forma
- **Assimetria** ($g_1$): 0 = simétrica; $>0$ cauda à direita (média > mediana); $<0$ cauda à esquerda.
- **Curtose** ($g_2$, excesso): 0 = como a normal; $>0$ concentrada e alongada (leptocúrtica); $<0$ achatada (platicúrtica).

## Distribuições de probabilidade

| Distribuição | O que modela | Fórmula / parâmetros |
|---|---|---|
| Uniforme discreta | resultados igualmente prováveis | $1/n$ |
| Bernoulli | um ensaio com sucesso/fracasso | $p^x(1-p)^{1-x}$ |
| Binomial | nº de sucessos em $n$ ensaios | $\binom{n}{k}p^k(1-p)^{n-k}$ |
| Binomial negativa | nº de ensaios até $k$ sucessos; contagem com superdispersão | $\binom{x-1}{k-1}p^k(1-p)^{x-k}$ |
| Poisson | contagem num intervalo de tempo/área (eventos raros) | $e^{-\lambda}\lambda^k/k!$ |
| Normal | variável contínua simétrica | $\mu$, $\sigma$ |
| $\chi^2$, $t$, $F$ | estatísticas de teste | dependem dos graus de liberdade |

- **Padronização**: $Z = (X - \mu)/\sigma$ leva qualquer normal para média 0 e desvio 1, sem mudar a forma.
- Em variável contínua não se calcula $P(X = x)$ pontual: trabalha-se com **áreas de intervalos**.
- **Graus de liberdade**: quantas observações ficam livres para variar depois de estimar parâmetros (ex.: $n-1$). Definem a forma de $\chi^2$, $t$ e $F$.
- A $t$ tem caudas mais pesadas que a normal e converge para ela quando os graus de liberdade crescem.

## Testes de hipótese

- $H_0$: hipótese de "não efeito" (sem diferença, sem associação).
- $H_1$: bilateral ($\neq$) ou unilateral ($<$ ou $>$).
- $\alpha$ = probabilidade de **erro tipo I** (rejeitar $H_0$ verdadeira). Confiança = $1-\alpha$.
- Decisão: estatística além do valor crítico, ou **p-valor < α → rejeita $H_0$**.

### Qual teste usar

| Situação | Estatística | Graus de liberdade |
|---|---|---|
| Associação entre duas categóricas | $\chi^2 = \sum (O-E)^2/E$, com $E = L\cdot C/N$ | $(l-1)(c-1)$ |
| Uma categórica contra distribuição esperada | $\chi^2$ de aderência | $K-1$ |
| Correlação de Pearson | $t = r/\sqrt{(1-r^2)/(n-2)}$ | $n-2$ |
| Média de uma amostra, $\sigma$ conhecido ou $n$ grande | $Z = (\bar X - \mu_0)/(\sigma/\sqrt n)$ | — |
| Média de uma amostra, $\sigma$ desconhecido | $T = (\bar X - \mu_0)/(S/\sqrt n)$ | $n-1$ |
| Duas variâncias | $F = S^2_{maior}/S^2_{menor}$ | $n_1-1$ e $n_2-1$ |
| Duas médias independentes | $t$ com variância combinada (ou Welch) | $n_1+n_2-2$ |
| Intervalo de confiança da média | $\bar x \pm t\cdot s/\sqrt n$ | $n-1$ |

## Passo a passo de um teste

1. Escolha o teste pelo **tipo e número de variáveis**.
2. Escreva $H_0$ e $H_1$ e fixe $\alpha$ **antes** de olhar o resultado.
3. Calcule a estatística do teste.
4. Ache o valor crítico ou o p-valor.
5. Decida e escreva a conclusão **em termos do problema**, citando o $\alpha$.

## Armadilhas

- Não rejeitar $H_0$ **não prova** $H_0$: só não houve evidência suficiente.
- O $\chi^2$ diz que há associação, mas **não onde** ela está.
- A conclusão pode mudar com o $\alpha$: um resultado pode rejeitar a 5% e não a 1%.
- Média sozinha engana com assimetria ou outliers: olhe média, mediana, quartis, desvio, mínimo, máximo e forma juntos.
- Correlação não é causalidade.
- No Excel, algumas funções de distribuição devolvem só a cauda esquerda; use as versões de cauda direita ou bicaudal para não errar o sinal.

## Em Python

```python
import pandas as pd
from scipy import stats

df.describe()                      # descritivas
df["categoria"].value_counts(normalize=True)
df[["x", "y"]].corr()

stats.chi2_contingency(pd.crosstab(df.a, df.b))
stats.pearsonr(df.x, df.y)
stats.ttest_1samp(df.x, popmean=50)
stats.ttest_ind(g1, g2, equal_var=False)   # Welch
stats.shapiro(df.x)                # normalidade
stats.norm.sf(1)                   # P(Z > 1) = 0,1587
```

Bibliotecas: `pandas`, `scipy.stats`, `statsmodels`, `matplotlib`/`seaborn` (histograma e boxplot).

## Perguntas de revisão

1. **Como o banco de dados é organizado?** Observações nas linhas e variáveis nas colunas.
2. **Por que codificar países como 1, 2, 3 não cria uma variável métrica?** Porque são rótulos; média e desvio perdem o sentido (ponderação arbitrária).
3. **Com cauda à direita, quem é maior: média ou mediana?** A média, puxada pelos valores altos.
4. **Como identificar outliers pela regra do boxplot?** Valores abaixo de $Q_1 - 1{,}5\,AIQ$ ou acima de $Q_3 + 1{,}5\,AIQ$.
5. **O que significa o percentil 85?** Que 85% das observações são menores ou iguais a ele.
6. **Qual a diferença entre desvio padrão, erro padrão e CV?** Desvio: dispersão dos dados; erro padrão ($S/\sqrt n$): precisão da média; CV: dispersão relativa à média.
7. **O que indicam $g_1 > 0$ e $g_2 < 0$?** Cauda à direita e distribuição achatada.
8. **Qual a diferença entre Bernoulli, binomial, binomial negativa e Poisson?** Um ensaio binário; sucessos em $n$ ensaios; ensaios até $k$ sucessos; contagem numa exposição contínua.
9. **Quando preferir binomial negativa a Poisson?** Quando a contagem tem variância maior que a média (superdispersão).
10. **Como padronizar uma variável normal?** $Z = (X-\mu)/\sigma$, que resulta em média 0 e desvio 1.
11. **Para que servem os graus de liberdade?** Definem a forma das distribuições $\chi^2$, $t$ e $F$.
12. **Em que a distribuição t difere da normal?** Tem caudas mais pesadas e converge para a normal com muitos graus de liberdade.
13. **O que é erro tipo I?** Rejeitar $H_0$ quando ela é verdadeira; sua probabilidade é $\alpha$.
14. **Qual a regra de decisão pelo p-valor?** p < α rejeita $H_0$; p > α não rejeita.
15. **Como se calcula a frequência esperada numa tabela de contingência?** $E_{ij} = L_i \cdot C_j / N$.
16. **Qual a hipótese nula do teste de correlação de Pearson?** $\rho = 0$, testada com $t$ e $n-2$ graus de liberdade.
17. **Z ou t para testar uma média?** Z com $\sigma$ conhecido ou amostra grande; t quando se usa o desvio amostral.
18. **Como comparar duas médias independentes?** Teste F das variâncias primeiro; variâncias iguais → t com variância combinada; diferentes → Welch.
19. **Como interpretar um IC 95% de [46,6; 47,4]?** Com 95% de confiança, a média populacional está nesse intervalo.
20. **Não rejeitar $H_0$ prova que ela é verdadeira?** Não; apenas faltou evidência para rejeitá-la.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/estatistica


# Python para Análise de Dados

> Ambiente, estruturas de dados, pandas, funções, condições e laços, e o ciclo importar → inspecionar → limpar → agrupar → visualizar.

## Visão geral

Python é a linguagem de trabalho de todas as outras matérias. O objetivo aqui não é virar programador, e sim dominar um ciclo que se repete em qualquer projeto de dados:

**importar → inspecionar → converter tipos → tratar faltantes → filtrar e agrupar → descrever → visualizar.**

Antes do código, vale fixar o mapa de machine learning, porque ele define o que fazer com os dados depois:

- **Aprendizado supervisionado**: existe uma variável resposta $Y$ e o objetivo é prever $Y$ para observações novas, $Y = f(X_1, \dots, X_k)$. Se $Y$ é métrica → **regressão**; se é categórica → **classificação**.
- **Aprendizado não supervisionado**: não há $Y$; busca-se estrutura nos dados (agrupamento/clustering, redução de dimensão como PCA, análise de correspondência).

## Ambiente

- **Anaconda** traz Python e bibliotecas científicas; IDEs comuns: **Spyder**, **VS Code**, **Jupyter** e **Google Colab** (na nuvem, sem instalar nada).
- `pip install pacote` baixa o pacote (uma vez); `import pacote` carrega na sessão (toda vez).
- No Spyder, `#%%` cria células; `Shift+Enter` roda a célula; `F9` roda a linha ou seleção; `Ctrl+I` abre a ajuda.
- Trabalhe em **projetos** (uma pasta por análise), com caminhos curtos e sem caracteres especiais.
- **Erro** interrompe a execução; **warning** só avisa.

## Estruturas de dados

| Estrutura | O que é | Exemplo |
|---|---|---|
| `list` | sequência ordenada e mutável | `[1, 2, 3]` |
| `dict` | pares chave → valor | `{"nome": "Ana", "idade": 30}` |
| `Series` (pandas) | uma coluna com índice | `df["idade"]` |
| `DataFrame` (pandas) | tabela de várias séries | `pd.DataFrame(dict)` |

## Bibliotecas do dia a dia

- **pandas**: tabelas, leitura e escrita de arquivos, filtros, agrupamentos.
- **numpy**: funções numéricas (`np.mean`, `np.std`, `np.round`, `np.where`).
- **matplotlib**: moldura do gráfico (título, rótulos, eixos, legenda, `savefig`).
- **seaborn**: gráficos estatísticos prontos sobre DataFrames.
- **plotly**: gráficos interativos, exportáveis em HTML.

## Passo a passo do ciclo de dados

1. **Importar**: `pd.read_csv`, `pd.read_excel` ou uma URL de API. No CSV, confira `sep` e `decimal`.
2. **Inspecionar**: `head()`, `columns`, `info()`, `shape`, `describe()`, `value_counts()`.
3. **Converter tipos**: `pd.to_numeric(col, errors="coerce")` transforma texto inválido em `NaN`; `astype("category")` marca variáveis qualitativas.
4. **Tratar faltantes**: `dropna()` ou outra regra explícita, sempre documentada.
5. **Filtrar e selecionar**: condições com `&` (e) e `|` (ou), cada uma entre parênteses; `iloc` por posição, nomes por rótulo.
6. **Agrupar e ordenar**: `groupby(...).agg(...)`, `sort_values(...)`, `pd.crosstab(...)`.
7. **Descrever** cada variável de acordo com o seu tipo.
8. **Visualizar** com o gráfico adequado e **exportar** com `to_csv(..., index=False)`.

## Funções, condições e laços

```python
def resumo(serie):
    """Média e desvio arredondados."""
    return round(serie.mean(), 2), round(serie.std(), 2)

if nota >= 7:
    situacao = "aprovado"
elif nota >= 5:
    situacao = "recuperação"
else:
    situacao = "reprovado"

for coluna in df.columns:          # percorre elementos conhecidos
    print(coluna, df[coluna].dtype)

while saldo > 0:                   # repete enquanto a condição valer
    saldo -= parcela
```

## Qual gráfico usar

| Pergunta | Gráfico |
|---|---|
| Frequência de uma categórica | `countplot` / `barplot` (pizza só com poucas partes) |
| Distribuição de uma métrica | `histplot` (com `kde`) e `boxplot` |
| Relação entre duas métricas | `scatterplot` (+ `hue`, `size`, `style`) ou `regplot` |
| Várias métricas de uma vez | `pairplot` e mapa de calor de correlação |
| Evolução no tempo | `lineplot` / `px.line` |

## Boas práticas

1. Primeira célula com instalações e `import`; funções definidas no topo.
2. Toda alteração nos dados por código, nunca editando à mão: a análise fica reprodutível.
3. Operações geram objetos novos; sobrescreva nomes conscientemente e cuidado com `inplace=True`.
4. Paletas acessíveis a daltônicos (ex.: `viridis`) e rótulos nas barras (`bar_label`).
5. Leia a documentação em vez de decorar parâmetros.

## Como ler os resultados

- `describe()`: média muito diferente da mediana sugere assimetria ou outliers; `count` menor que o total indica faltantes.
- `info()`: coluna numérica aparecendo como `object` denuncia texto sujo (hífens, vírgulas, símbolos).
- Boxplot: pontos fora dos bigodes são **candidatos** a outliers, não necessariamente erros.
- Dispersão com reta mostra direção e força da relação, nunca causalidade.
- `np.std` usa por padrão o desvio populacional (`ddof=0`) e o `Series.std()` do pandas usa o amostral (`ddof=1`).

## Perguntas de revisão

1. **Qual a diferença entre `pip install` e `import`?** `pip install` baixa o pacote uma vez; `import` o carrega em cada sessão.
2. **Qual a diferença entre erro e warning?** O erro interrompe a execução; o warning só avisa.
3. **O que é uma Series e o que é um DataFrame?** Series é uma coluna com índice; DataFrame é uma tabela formada por várias séries.
4. **Para que serve `astype("category")`?** Para marcar uma variável como qualitativa, mesmo que esteja codificada com números.
5. **Quais parâmetros conferir no `read_csv`?** O separador (`sep`) e o separador decimal (`decimal`).
6. **Por que usar `index=False` ao exportar?** Para não gravar o índice como uma coluna extra.
7. **O que faz `to_numeric(errors="coerce")`?** Converte para número e troca valores inválidos por `NaN`.
8. **Qual a diferença entre `iloc` e seleção por nome?** `iloc` usa posição (começa em 0, fim exclusivo); a seleção por nome usa o rótulo da coluna.
9. **Como combinar condições num filtro do pandas?** Com `&` (e) e `|` (ou), cada condição entre parênteses.
10. **Para que serve o `groupby`?** Para calcular estatísticas separadas por categoria.
11. **O que faz `pd.crosstab(..., normalize=True)`?** Uma tabela cruzada com proporções em vez de contagens.
12. **Qual a estrutura de uma função em Python?** `def nome(argumentos):`, corpo indentado e `return`.
13. **Quando usar `while` em vez de `for`?** `for` percorre elementos conhecidos; `while` repete enquanto uma condição for verdadeira.
14. **Que gráfico mostra a distribuição de uma variável métrica?** Histograma e boxplot.
15. **Como acrescentar variáveis a um gráfico de dispersão?** Com os parâmetros `hue`, `size` e `style`.
16. **Como salvar um gráfico do Plotly?** `fig.write_html("arquivo.html")`.
17. **Quando usar aprendizado supervisionado?** Quando existe uma variável resposta $Y$ e o objetivo é prevê-la para casos novos.
18. **Regressão ou classificação?** Regressão quando $Y$ é métrica; classificação quando $Y$ é categórica.
19. **Por que fazer toda alteração por código?** Para que a análise seja reprodutível e auditável.
20. **Qual paleta de cores é acessível a daltônicos?** `viridis`.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/python


# Data Wrangling

> Transformar o dado bruto numa base pronta para análise e modelagem — importar, inspecionar, limpar, transformar, juntar, reformatar, validar e versionar.

## Visão geral

**Data wrangling** é levar o dado da estrutura bruta para uma estrutura adequada à extração de informação. Vem antes das descritivas finais, dos gráficos e dos modelos, e costuma consumir de 40% a 80% do tempo de um projeto.

- **Limpeza** (faltantes, valores incorretos, extremos, linhas e colunas inúteis) é **parte** do wrangling, não sinônimo.
- Não existe roteiro fixo: cada base traz problemas próprios. O método é **olhar → achar o problema → aplicar a função certa → conferir**.
- No ciclo **CRISP-DM** (entendimento do negócio, entendimento dos dados, preparação, modelagem, avaliação, implantação), o wrangling começa no entendimento dos dados e domina a preparação. O ciclo é iterativo.

## Funções essenciais (pandas)

### Importar e inspecionar
- `pd.read_excel(..., na_values=["..", "-"])` e `pd.read_csv(..., sep=";", encoding="latin1")`.
- `head()`, `tail()` (rodapés e notas no fim do arquivo!), `info()`, `describe()`, `unique()`, `nunique()`, `isna().sum()`.
- `pd.set_option("display.max_columns", None)` para ver todas as colunas.

### Renomear e selecionar
- Renomeie **por nome** (dicionário), nunca por posição: nomes curtos, minúsculos, sem espaço nem acento.
- `iloc[linhas, colunas]` (posição; o limite final não entra), `loc` (rótulos), `df[["a", "b"]]`.

### Criar e transformar variáveis
- Conta direta: `df["margem"] = df.lucro / df.receita`.
- `assign` + `map` com dicionário de correspondência.
- `np.where` (aninhado, com critérios sem sobreposição; o último argumento cobre o restante).
- `pd.qcut` para faixas por quantis; `astype` para tipos.
- Datas: `pd.to_datetime(col).dt.year`.
- Defasagem: `groupby("entidade")["valor"].shift(1)` — sempre agrupado, para não misturar entidades.

### Filtrar
- Máscara booleana: `==`, `!=`, `&`, `|`, `~`, `between(...)`, `isin([...])`.
- `query("idade > 30 and uf == @estado")` — combina bem com encadeamento.

### Agregar
- `groupby([...]).size()`, `.describe()`, `.agg({"valor": "mean", "id": "count"})`.
- Cuidado para não sobrescrever o DataFrame original com o objeto agrupado.

### Juntar e reformatar
- `concat`: **empilha** tabelas com a mesma estrutura (use `reset_index(drop=True)` depois).
- `merge(how=..., on=chave)`: **junta colunas** de fontes diferentes por uma chave.
  - `left`/`right`: mantêm todas as linhas de um lado; `inner`: só chaves presentes nos dois; `outer`: todas, com `NaN` onde falta.
- `pivot` (longo → largo) e `melt` (largo → longo).

### Texto
- `.str.slice`, `.str.strip`, `.str.split(" ").str[0]`, `.str.contains`, `.str.extractall(regex)`.
- Expressões regulares quando o padrão se repete dentro do texto.

### Faltantes e extremos
- Declare códigos de falta na importação (`na_values`).
- `inf` aparece em divisão por zero: remova com `isin([np.nan, np.inf, -np.inf])`.
- Cortes de extremos (ex.: variações acima de ±200%) precisam ser **declarados** no código.

## Método passo a passo

1. Importar com os parâmetros certos e conferir `shape`, `head`, `tail`, `info`.
2. Renomear colunas e ajustar tipos.
3. Inspecionar valores e localizar problemas: faltantes, duplicatas, extremos, categorias inconsistentes, rodapés.
4. Limpar: remover ou preencher faltantes, descartar duplicatas e colunas sem uso, corrigir valores.
5. Criar e transformar variáveis (cálculos, faixas, defasagens, extração de texto).
6. Juntar tabelas por chave e reformatar, **conferindo o número de linhas antes e depois**.
7. Validar: descritivas finais, contagens por grupo, casos conhecidos conferidos à mão.
8. Versionar o script (Git) e documentar as regras de corte.

## Encadeamento de métodos

```python
resultado = (
    df.assign(margem=lambda d: d.lucro / d.receita)
      .query("ano >= 2020")
      .rename(columns={"uf": "estado"})
      .groupby("estado")
      .agg(margem_media=("margem", "mean"), empresas=("id", "nunique"))
      .sort_values("margem_media", ascending=False)
)
```

Rode linha a linha para depurar; encadeie quando o fluxo já estiver claro.

## Versionamento com Git

- Ciclo básico: `git add` (prepara) → `git commit -m "mensagem"` (registra o estado) → `git push` (envia ao GitHub); `git pull` traz o que está no remoto.
- **Branch** isola mudanças ainda não validadas; `merge` (ou pull request) incorpora na principal.
- `.gitignore` mantém bases de dados e credenciais fora do repositório; repositório público pode ser copiado por qualquer pessoa.

## Quando usar cada coisa

- `np.where` → rótulos vindos de regras; `map` → tabela de correspondência; `qcut` → regra por quantis.
- `merge` sempre que as fontes forem diferentes; `concat` para empilhar a mesma estrutura.
- `.str` simples para padrões fixos; regex para padrões que se repetem.

## Armadilhas

- Tirar média de categórica codificada (1, 2, 3).
- Renomear por posição: se a ordem das colunas mudar no próximo arquivo, renomeia a coluna errada sem avisar.
- Atribuir colunas "pela ordem" em vez de usar `merge`.
- Duplicatas por várias versões do mesmo registro inflando contagens.
- Nota de rodapé no fim do arquivo lida como dado.
- Agregados (regiões, "total") misturados às unidades na mesma coluna.
- Valores de texto (`..`, `-`, `False`) que transformam uma coluna numérica em `object`.

## Perguntas de revisão

1. **O que é data wrangling?** Transformar o dado bruto numa estrutura adequada para análise e modelagem.
2. **Limpeza e wrangling são a mesma coisa?** Não; a limpeza é uma das partes do wrangling.
3. **Onde o wrangling entra no CRISP-DM?** Começa no entendimento dos dados e pesa na preparação dos dados.
4. **Por que renomear colunas por nome e não por posição?** Porque se a ordem mudar, a posição renomeia a coluna errada sem nenhum aviso.
5. **O que `iloc[2:5]` seleciona?** As posições 2, 3 e 4; o 5 não entra.
6. **Qual a diferença entre `concat` e `merge`?** `concat` empilha tabelas de mesma estrutura; `merge` junta colunas por uma chave comum.
7. **O que fazem os tipos de `how` no `merge`?** `left`/`right` preservam um lado; `inner` só chaves comuns; `outer` todas, com `NaN` onde falta.
8. **Como detectar duplicidade num painel de dados?** Contando observações por chave e comparando com o número esperado.
9. **O que `value_counts(normalize=True)` devolve?** A frequência relativa de cada categoria.
10. **Como tratar um código como `..` numa coluna numérica?** Declarando `na_values=".."` na importação, ou trocando por `NaN` e convertendo o tipo.
11. **Como converter uma tabela longa em larga?** Com `pivot`; o inverso é `melt`.
12. **Para que serve `shift` agrupado?** Para criar defasagens dentro de cada entidade, sem misturar grupos.
13. **De onde vem `inf` numa variação percentual?** De divisão por zero; deve ser removido antes de resumir.
14. **O que faz `str.split(" ").str[0]`?** Separa o texto pelos espaços e pega a primeira palavra.
15. **Quando usar regex com `str.extractall`?** Quando um padrão aparece várias vezes no mesmo texto e é preciso capturar todas as ocorrências.
16. **Qual o ciclo básico do Git?** `add`, `commit` e `push`; `pull` traz o remoto.
17. **Para que serve uma branch?** Para isolar mudanças não validadas da versão principal.
18. **Por que usar `.gitignore`?** Para manter bases de dados e credenciais fora do versionamento.
19. **Como validar o resultado do tratamento?** Conferindo linhas e colunas, tipos, faltantes, descritivas antes/depois e casos conhecidos à mão.
20. **Por que encadear métodos?** O fluxo fica legível e sem objetos intermediários; para depurar, rode linha a linha.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/data-wrangling


# Coleta de Dados e Web Scraping

> Como obter dados de sites e APIs com requests, BeautifulSoup e pandas — HTTP, HTML, seletores, paginação, qualidade da coleta, ética e LGPD.

## Visão geral

Muitos dados úteis estão em páginas web que não oferecem acesso ao banco de dados. **Web scraping** é a extração automática desses dados a partir do que o servidor já entrega publicamente; **crawler** (ou spider) é o programa que percorre muitas páginas seguindo links. Scraping não é invasão: lê o mesmo HTML que o navegador recebe.

Quando o site oferece uma **API**, ela é sempre preferível: entrega JSON estruturado e quebra menos que o HTML.

## Como a web funciona (o mínimo)

- Cada acesso é uma **requisição HTTP** e uma **resposta**. Métodos principais: `GET` (pede dados) e `POST` (envia dados).
- **Códigos de status**: 1xx informativo, **2xx sucesso** (200), 3xx redirecionamento, **4xx erro do cliente** (400, 403, 404), **5xx erro do servidor** (500).
- **HTML** dá a estrutura (tags, classes, ids), **CSS** o estilo, **JavaScript** o comportamento. Conteúdo montado por JavaScript depois do carregamento não aparece no HTML bruto e exige navegador automatizado.
- As **DevTools** do navegador (F12 → Inspecionar) mostram em que tag, classe ou id está cada dado.

## Passo a passo (método base)

1. Abra a página e inspecione o elemento que contém o dado.
2. Baixe o HTML e confira o status:
   ```python
   import requests
   HEAD = {"User-Agent": "Mozilla/5.0"}
   res = requests.get(URL, headers=HEAD, timeout=20)
   res.raise_for_status()   # ou: if res.status_code != 200: ...
   ```
3. Interprete o HTML:
   ```python
   from bs4 import BeautifulSoup
   soup = BeautifulSoup(res.text, "lxml")
   ```
4. Localize elementos: `soup.find(...)` (primeiro), `soup.find_all(...)` (lista) ou `soup.select("article.produto h3 a")` (seletor CSS).
5. Extraia texto com `get_text(strip=True)` ou atributos com `tag["href"]`, `tag["title"]`.
6. Guarde numa lista de dicionários, converta com `pd.DataFrame(...)` e salve com `to_csv`.
7. **Paginação**: monte a URL de cada página com f-string, espere entre chamadas (`time.sleep(1)`) e pare (`break`) quando o status não for 200.
8. Envolva cada fonte em `try/except` para que uma falha não derrube a coleta inteira.

```python
dados = []
for pagina in range(1, 51):
    res = requests.get(f"{BASE}/page-{pagina}.html", headers=HEAD, timeout=20)
    if res.status_code != 200:
        break
    soup = BeautifulSoup(res.text, "lxml")
    for item in soup.select("article.produto"):
        dados.append({
            "titulo": item.h3.a["title"],
            "preco": item.select_one(".preco").get_text(strip=True),
        })
    time.sleep(1)
df = pd.DataFrame(dados)
```

## Quando usar cada ferramenta

| Situação | Ferramenta |
|---|---|
| Página estática | `requests` + `BeautifulSoup` (simples e rápido) |
| Site com API | `requests` + `res.json()` |
| Página com tabelas `<table>` prontas | `pd.read_html` (devolve lista de DataFrames) |
| Clique, formulário, login, conteúdo por JavaScript | **Selenium** ou **Playwright** |
| Crawler grande e recorrente | **Scrapy** (filas, pipelines, saída padronizada) |

## Qualidade da coleta

- **Contagem esperada**: se cada página tem 20 itens, confira o total.
- **Campos nulos** inesperados indicam mudança de layout.
- **Conversão de tipos**: preço com símbolo e vírgula precisa virar `float`.
- **Deduplicação** entre coletas por ID, timestamp ou hash do registro.
- **Resiliência**: o que acontece se o site mudar o layout ou sair do ar? Registre falhas em log.
- Scraping é a etapa **E** (extração) de um ETL; transformação e carga vêm depois.

## Ética e legalidade

Três eixos guiam a decisão:

1. **Consentimento**: termos de uso do site e o arquivo `robots.txt` (convenção que indica o que robôs podem acessar; não é barreira técnica, mas deve ser respeitada).
2. **Impacto no servidor**: limite a taxa de requisições; não derrube o site dos outros.
3. **Intenção de uso**: para que o dado será usado.

A LGPD não fala em "scraping", mas dados pessoais de acesso público continuam protegidos: o tratamento precisa respeitar **finalidade, boa-fé e interesse público** (art. 7º, §3º). Coletar perfis pessoais em massa é o tipo de uso que gera problema.

## Perguntas de revisão

1. **Scraping e crawler são a mesma coisa?** Não; o crawler navega por muitas páginas, o scraping extrai dados de uma página.
2. **Por que raspar em vez de pedir o banco de dados?** Normalmente não há acesso ao banco; o HTML é o que o site entrega.
3. **Qual a diferença entre `find` e `find_all`?** `find` devolve o primeiro elemento; `find_all` devolve a lista de todos.
4. **Como pegar o texto limpo de um elemento?** Com `get_text(strip=True)`.
5. **Como pegar um valor que está num atributo da tag?** Indexando a tag pelo nome do atributo, ex.: `tag["title"]`.
6. **O que significam os códigos 200, 404 e 500?** Sucesso, página não encontrada e erro interno do servidor.
7. **Para que serve o `break` na paginação?** Para parar o laço quando a página não existe, sem quebrar o programa.
8. **Por que usar `time.sleep` entre requisições?** Para não sobrecarregar o servidor e evitar bloqueio.
9. **Para que serve o cabeçalho `User-Agent`?** Para se identificar como navegador comum; alguns sites bloqueiam o padrão do `requests`.
10. **Quando preferir uma API?** Sempre que existir: entrega JSON estruturado e é mais estável que o HTML.
11. **O que faz `pd.read_html`?** Lê as tabelas HTML de uma página e devolve uma lista de DataFrames.
12. **Quando o `requests` não basta?** Quando o conteúdo depende de JavaScript, cliques ou login; usa-se Selenium ou Playwright.
13. **O que é o `robots.txt`?** Arquivo que indica o que robôs podem acessar; é uma convenção a ser respeitada.
14. **O que a LGPD diz sobre dados pessoais públicos?** Continuam protegidos; o uso deve respeitar finalidade, boa-fé e interesse público.
15. **Como evitar duplicatas entre coletas?** Usando ID, timestamp ou hash de cada registro.
16. **Por que usar `try/except` em cada fonte?** Para que uma falha de rede ou de layout não derrube a coleta inteira.
17. **Scraping é um ETL completo?** Não; é a etapa de extração. Transformar e carregar vêm depois.
18. **Quais os três eixos éticos do scraping?** Consentimento, impacto no servidor e intenção de uso.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/web-scraping


# Text Mining, Análise de Sentimento e NLP

> Pipeline de mineração de texto (coleta, pré-processamento, vetorização, modelagem, avaliação) e quatro jeitos de classificar sentimento — léxico, Naive Bayes, Transformer pronto e LLM.

## Visão geral

Texto é dado não estruturado: antes de qualquer modelo, ele precisa virar números. Quatro áreas se cruzam aqui:

- **NLP** (processamento de linguagem natural): fazer o computador lidar com a língua. É mais amplo e mais antigo que os LLMs.
- **Análise de sentimento**: medir a polaridade (positivo, negativo, neutro) de um texto.
- **LLM** (grande modelo de linguagem): gera texto e conversa.
- **Text mining**: garimpar informação em grandes volumes de texto.

A lição que mais se repete: **a qualidade do dado e do pré-processamento pesa mais que o algoritmo**.

## Vocabulário

- **Corpus**: o conjunto de textos.
- **Documento**: uma unidade do corpus (uma avaliação, um e-mail).
- **Token**: pedaço mínimo (palavra, subpalavra, pontuação).
- **Vocabulário**: os tokens distintos do corpus.
- **Feature**: atributo numérico derivado do texto.
- **Granularidade** do sentimento: por documento, por frase ou por **aspecto** (ABSA — um rótulo para cada característica citada: "a comida é ótima, mas o atendimento é lento").

## Pipeline, passo a passo

1. **Coleta**: arquivos, APIs, scraping.
2. **Pré-processamento**:
   - minúsculas;
   - remover URLs, menções e hashtags (se não importarem);
   - acentos: depende do caso (remover ajuda com erros de digitação, mas pode juntar palavras diferentes);
   - pontuação;
   - **tokenização**;
   - **stopwords** (palavras muito frequentes e sem conteúdo: "de", "o", "que");
   - **stemming** (corta sufixos até um radical, que pode não ser palavra) ou **lematização** (leva à forma de dicionário usando a classe gramatical).
3. **Vetorização**:
   - **Bag of Words**: cada documento vira um vetor de contagens das palavras do vocabulário;
   - **TF-IDF**: $tf(t,d)\cdot\log(N/df(t))$ — valoriza termos frequentes no documento e raros no corpus;
   - **Embeddings**: vetores densos que capturam significado.
4. **Modelagem** (classificação).
5. **Avaliação**: treino e teste separados, métricas e leitura manual de frases-desafio.
6. **Interpretação**: olhar erros, confiança, ajustar dados ou léxico.

## Quatro abordagens para sentimento

### 1. Léxico
Duas listas de palavras (positivas e negativas); conta-se cada uma e o maior saldo vence (empate = neutro). Rápido, sem treino e explicável. Falha em **negação** ("não é bom"), **ironia**, termos compostos ("mal posso esperar"), gírias novas e pontuação colada à palavra.

Bibliotecas de léxico: VADER (inglês) e LeIA (adaptação para português). O índice `compound` vai de -1 a +1; ≥ 0,05 positivo, ≤ -0,05 negativo.

### 2. Machine learning clássico (Naive Bayes)
$P(c \mid d) \propto P(c)\prod_i P(w_i \mid c)$ sobre as contagens do Bag of Words. Aprende a associação palavra-classe a partir de exemplos **rotulados**. Barato, treina em segundos, ótimo com dados do próprio domínio — mas não entende ordem nem negação.

### 3. Transformer pronto
Modelos pré-treinados (ex.: Hugging Face): texto → tokens → embeddings → Transformer → **logits** (pontuações brutas) → **softmax** $p_i = e^{z_i}/\sum_j e^{z_j}$ → classe e **score**. Entende melhor contexto e negação, sem treinar nada; ainda erra sarcasmo.

### 4. LLM por API
Prompt **zero-shot** (só a instrução) ou **few-shot** (instrução + alguns exemplos). Entende contexto e pode explicar a resposta, mas tem **custo por chamada, latência, dependência externa e questões de privacidade**.

| Abordagem | Vantagem | Limite |
|---|---|---|
| Léxico | rápido, explicável, sem treino | negação, ironia, gíria; idioma do léxico |
| Naive Bayes | barato, bom com rótulos do domínio | não entende ordem; precisa de rótulos |
| Transformer pronto | contexto, sem treino | modelo genérico; sarcasmo |
| LLM | contexto e explicação | custo, latência, privacidade |

**Estratégia híbrida**: usar um LLM para rotular uma amostra, treinar um modelo clássico com ela e rodar o grande volume no modelo barato.

## Avaliação

```python
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report

X_tr, X_te, y_tr, y_te = train_test_split(
    textos, rotulos, test_size=0.2, stratify=rotulos, random_state=42)

vet = CountVectorizer()
Xtr = vet.fit_transform(X_tr)   # vocabulário só do treino
Xte = vet.transform(X_te)

modelo = MultinomialNB().fit(Xtr, y_tr)
print(classification_report(y_te, modelo.predict(Xte)))
```

- `stratify` mantém a proporção das classes; `random_state` torna reprodutível.
- `fit_transform` **só no treino**: o teste simula dados novos (senão há vazamento).
- O score de confiança é a probabilidade da classe escolhida, **não** a intensidade do sentimento.
- A linguagem muda (gírias, expressões): reavalie o modelo periodicamente.
- Critérios de escolha: **custo, volume, explicabilidade e latência**.

## Bibliotecas

`re`, `unicodedata`, `collections.Counter`, `nltk` (stopwords, tokenize, stemmer RSLP para português), `spacy` (modelos em português), `scikit-learn`, `transformers` (+ PyTorch), `textblob`, LeIA, SDKs de LLM.

## Perguntas de revisão

1. **Qual a diferença entre NLP, análise de sentimento, LLM e text mining?** NLP trata a língua; sentimento mede polaridade; LLM gera texto; text mining extrai informação de grandes volumes de texto.
2. **O que são corpus, documento e token?** O conjunto de textos, uma unidade de texto e o pedaço mínimo do texto.
3. **Quais as etapas do pipeline de text mining?** Coleta, pré-processamento, vetorização, modelagem, avaliação e interpretação.
4. **Por que remover stopwords?** São palavras frequentes e sem valor semântico; removê-las reduz ruído e volume.
5. **Qual a diferença entre stemming e lematização?** Stemming corta sufixos até um radical; lematização leva à forma de dicionário usando a classe gramatical.
6. **Sempre se deve remover acentos?** Não; depende do contexto e dos erros de digitação esperados.
7. **Como um classificador por léxico decide?** Conta palavras positivas e negativas; o maior saldo vence e o empate é neutro.
8. **Cite falhas do método de léxico.** Negação, ironia, termos compostos, gírias e pontuação colada.
9. **O que é Bag of Words?** Representar cada texto como um vetor de contagens das palavras do vocabulário.
10. **O que o TF-IDF valoriza?** Termos frequentes no documento e raros no corpus.
11. **Por que aplicar `fit_transform` só no treino?** Para o vocabulário vir apenas do treino e o teste simular dados novos.
12. **O que faz o `stratify` no `train_test_split`?** Mantém a proporção das classes no treino e no teste.
13. **O que são logits?** As pontuações brutas por classe, antes do softmax.
14. **O que representa o score de um Transformer de sentimento?** A confiança na classe escolhida, isto é, a probabilidade após o softmax.
15. **O que é ABSA?** Análise de sentimento por aspecto: um rótulo para cada característica mencionada.
16. **Por que VADER dá resultados ruins em português?** Porque seu léxico é em inglês; é preciso checar o suporte ao idioma.
17. **O que é zero-shot e few-shot?** Zero-shot pede a tarefa sem exemplos; few-shot inclui alguns exemplos no prompt.
18. **Por que não usar LLM para tudo?** Custo por chamada, latência, dependência externa e privacidade.
19. **O que é a estratégia híbrida LLM + modelo clássico?** Rotular uma amostra com LLM, treinar um modelo barato e aplicá-lo ao volume.
20. **Quais critérios guiam a escolha da abordagem?** Custo, volume, explicabilidade e latência.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/text-mining-nlp


# Pesquisa Operacional e Otimização

> Transformar uma decisão num modelo com variáveis, função objetivo e restrições, e resolvê-lo — solução gráfica, simplex, programação inteira, branch-and-bound, transporte, Excel Solver e PuLP.

## Visão geral

**Pesquisa operacional (PO)** é a ciência da tomada de decisão: alocar recursos escassos com métodos quantitativos. Nasceu de operações militares e hoje está em produção, logística, finanças, escalas de trabalho. Não tem nada a ver com "programar computadores": *programação* aqui significa *planejamento*.

A previsão responde **"o que vai acontecer?"**; a otimização responde **"o que fazer diante disso?"**. Um modelo preditivo pode fornecer os parâmetros (demanda, preços, capacidade) de um modelo de otimização.

## Anatomia de um modelo

Todo modelo de otimização tem três partes:

1. **Variáveis de decisão** — o que você controla.
2. **Função objetivo** — o que maximizar ou minimizar.
3. **Restrições** — as condições que a solução precisa respeitar.

### Famílias
- **PL** (programação linear): variáveis contínuas, expressões lineares e aditivas.
- **PLI** (inteira): todas as variáveis inteiras.
- **PLIM** (inteira mista): parte inteira, parte contínua.
- **Não linear** (ex.: $x_1 x_2$, $x^2$): fora do escopo da PL.
- **Heurísticas e metaheurísticas**: soluções boas em tempo razoável, sem garantia de ótimo. É o trade-off tempo × qualidade.

## Receita de formulação (7 passos)

1. Entender o problema.
2. Dizer em palavras quais são as respostas procuradas.
3. Definir as variáveis (com unidade!).
4. Descrever o objetivo em palavras.
5. Escrever o objetivo como equação linear.
6. Descrever cada restrição em palavras.
7. Escrever as restrições como equações lineares.

Definir o objetivo **antes** das restrições evita modelar o foco errado.

| Tipo de restrição | Forma | Palavras-chave |
|---|---|---|
| Limitação de recurso | $\le$ | "até", "no máximo", "não pode ultrapassar" |
| Desempenho mínimo | $\ge$ | "pelo menos", "no mínimo" |
| Conservação / balanço | $=$ | "igual", "tudo que entra sai" |
| Domínio | $x \ge 0$, inteiro, binário | "unidades", "ativar ou não" |

## Exemplo resolvido

Uma marcenaria faz mesas (lucro 40) e cadeiras (lucro 30). Cada mesa usa 2 m² de madeira e cada cadeira 1 m²; há 100 m². Cada peça leva 1 hora e há 80 horas.

$$\max Z = 40x + 30y$$
$$\text{s.a.}\quad 2x + y \le 100,\qquad x + y \le 80,\qquad x, y \ge 0$$

Vértices da região factível: $(0, 80) \Rightarrow 2400$; $(20, 60) \Rightarrow 2600$; $(50, 0) \Rightarrow 2000$. **Ótimo: 20 mesas e 60 cadeiras, Z = 2600**, com as duas restrições ativas.

## Métodos de solução

1. **Enumeração**: listar todas as soluções. Inviável em problemas reais (a combinatória explode).
2. **Solução gráfica** (só duas variáveis): cada desigualdade vira uma reta; testa-se um ponto para achar o lado válido; desenha-se a região factível; desloca-se a reta do objetivo até o último vértice.
3. **Simplex**: parte de um vértice e caminha para o vizinho que mais melhora $Z$, parando quando nenhum melhora. Não visita todos os vértices.
4. **Branch-and-bound** (para inteiros): resolve o problema relaxado; se uma variável vem fracionária ($x = 5{,}7$), ramifica em $x \le 5$ e $x \ge 6$ e guarda a melhor solução inteira.

Por que o ótimo linear está num vértice? Porque o objetivo é linear: a reta de nível sai da região factível por um vértice (ou por uma aresta inteira, quando há **ótimos alternativos**).

## Truques de modelagem

- **Ativação binária**: $x \le M\,y$, com $y \in \{0,1\}$ e um custo fixo $c\,y$ no objetivo (ex.: abrir um depósito de capacidade 50 → $x \le 50y$).
- **Múltiplos**: "só em lotes de 7" → $x = 7k$, $k$ inteiro.
- **Minimizar** equivale a maximizar o negativo (o solver faz isso sozinho).
- **Restrição "mole"**: variável de folga com penalidade no objetivo.
- **Tempo**: índice $t$ nas variáveis e balanço de estoque $E_t = E_{t-1} + P_t - D_t$.
- **Transporte**: origens com oferta, destinos com demanda, custo por rota; minimizar o custo total.
- **Transbordo**: pontos intermediários onde o que entra é igual ao que sai.

## Ferramentas

| Ferramenta | Quando usar | Limite |
|---|---|---|
| Solução gráfica | 2 variáveis, para entender a geometria | não escala |
| Excel Solver (LP Simplex) | modelos pequenos, comunicar com quem usa planilha | difícil de escalar, sem log, erros de sinal |
| PuLP + CBC (Python) | dezenas a milhares de variáveis, versionável | só linear |
| Pyomo, OR-Tools, Gurobi, CPLEX | modelos grandes ou não lineares | curva de aprendizado / licença |

```python
import pulp
m = pulp.LpProblem("marcenaria", pulp.LpMaximize)
x = pulp.LpVariable("mesas", lowBound=0, cat="Integer")
y = pulp.LpVariable("cadeiras", lowBound=0, cat="Integer")
m += 40*x + 30*y                 # objetivo
m += 2*x + y <= 100, "madeira"
m += x + y <= 80, "horas"
m.solve()
print(pulp.LpStatus[m.status], x.value(), y.value(), pulp.value(m.objective))
```

## Como avaliar a solução

- Confira o **status** (ótimo, inviável, ilimitado) e cada restrição no ponto encontrado.
- Identifique as **restrições ativas** (gargalos): aumentar um recurso que não é gargalo não muda nada.
- Faça **análise de cenários** trocando parâmetros e resolvendo de novo.
- Leituras complementares: dualidade, **preço sombra** (quanto o objetivo melhora com uma unidade a mais de recurso), folga e custo reduzido.
- Soluções diferentes com o mesmo valor podem ser ótimos alternativos.
- O solver garante o ótimo **do modelo** — se o modelo estiver errado (unidade, sinal, restrição esquecida), o ótimo também estará.

## Perguntas de revisão

1. **O que é pesquisa operacional?** A ciência da tomada de decisão: modelar e resolver problemas de alocação de recursos escassos.
2. **Quais são os três componentes de um modelo de otimização?** Variáveis de decisão, função objetivo e restrições.
3. **Qual a diferença entre restrição de limitação e de desempenho mínimo?** Limitação usa ≤ (recurso máximo); desempenho mínimo usa ≥.
4. **O que caracteriza um modelo de programação linear?** Variáveis contínuas e expressões lineares e aditivas.
5. **Por que o ótimo de uma PL está num vértice?** Porque, com objetivo linear, a reta de nível deixa a região factível por um vértice ou aresta.
6. **Quando existem ótimos alternativos?** Quando o objetivo é paralelo a uma restrição ativa.
7. **O simplex visita todos os vértices?** Não; vai ao vizinho que melhora o objetivo e para quando nenhum melhora.
8. **Por que a enumeração é inviável?** O número de combinações explode com o tamanho do problema.
9. **Por que o simplex sozinho não resolve problemas inteiros?** Pode devolver valores fracionários; é preciso branch-and-bound.
10. **Como funciona o branch-and-bound?** Resolve o relaxado, ramifica a variável fracionária em ≤ piso e ≥ teto e guarda o melhor inteiro.
11. **Como modelar "só em múltiplos de 7"?** $x = 7k$ com $k$ inteiro não negativo.
12. **Como modelar a ativação de uma instalação com capacidade 50?** $x \le 50y$ com $y$ binária e custo fixo no objetivo.
13. **Como converter minimização em maximização?** Maximizando o negativo do objetivo.
14. **O que é uma restrição ativa?** Uma restrição satisfeita com igualdade no ótimo — é o gargalo.
15. **Aumentar um recurso que não é gargalo melhora o resultado?** Não; só recursos de restrições ativas mudam o ótimo.
16. **Que erro comum acontece no Solver do Excel?** Esquecer a não negatividade ou inverter um sinal.
17. **Excel Solver ou PuLP?** Ambos dão o ótimo em modelos lineares; PuLP escala melhor, é versionável e mostra o log.
18. **Qual a relação entre previsão e otimização?** A previsão diz o que vai acontecer; a otimização decide o que fazer, usando a previsão como parâmetro.
19. **O que é preço sombra?** Quanto o objetivo melhora com uma unidade adicional de um recurso.
20. **Qual o ótimo do exemplo da marcenaria?** 20 mesas e 60 cadeiras, com lucro de 2600.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/otimizacao


# Árvores de Decisão e Modelos Ensemble

> Árvore de decisão, overfitting, métricas, validação cruzada, ajuste de hiperparâmetros, bagging, boosting, Random Forest, XGBoost e importância de variáveis.

## Visão geral

Árvores e seus ensembles são os modelos mais usados em dados **tabulares**. O caminho recomendado é progressivo:

**árvore (baseline explicável) → Random Forest (robusto) → XGBoost (desempenho máximo, com mais ajuste).**

Não existe "o melhor modelo": existe o mais adequado ao problema, aos dados e ao custo do erro.

## Árvore de decisão

- Modelo supervisionado, não paramétrico e "caixa branca": raiz, nós internos (um teste em uma variável) e folhas (a previsão).
- **Classificação**: a folha prevê a classe mais frequente. **Regressão**: a folha prevê a **média** dos casos que caíram nela.
- **Critério de divisão**: escolhe a variável e o corte que mais reduzem a impureza.
  - Gini: $1 - \sum_k p_k^2$ (0 = nó puro).
  - Entropia: $-\sum_k p_k \log_2 p_k$.
  - Regressão: erro quadrático (padrão) ou absoluto.
- Não exige padronização. No scikit-learn, categóricas precisam virar números (one-hot).
- **Fraquezas**: overfitting (a árvore completa decora o treino), instabilidade (poucas linhas mudam a árvore), sensibilidade a desbalanceamento e **não extrapola** (nunca prevê fora da faixa vista no treino).

## Overfitting

- **Diagnóstico**: métrica de treino muito acima da de teste (ex.: 100% no treino e 80% no teste).
- O que importa é a **distância treino × teste** e o desempenho absoluto no teste.
- 100% de acerto também no teste deve levantar suspeita de **vazamento de dados** (o alvo, ou algo derivado dele, entre as variáveis).
- **Controles**: limitar `max_depth`, aumentar `min_samples_split` e `min_samples_leaf`, usar ensembles, regularização, subamostragem, early stopping e validação cruzada.

## Hiperparâmetros principais

| Modelo | Hiperparâmetro | Efeito |
|---|---|---|
| Árvore | `max_depth` | profundidade; principal freio de overfitting |
| Árvore | `min_samples_split` / `min_samples_leaf` | mínimo para dividir / por folha; maior = mais conservador |
| Árvore | `criterion` | gini, entropy; costuma mudar pouco |
| Árvore | `class_weight` | pesos por classe (desbalanceamento) |
| Random Forest | `n_estimators` | nº de árvores; mais estabiliza, raramente piora |
| Random Forest | `max_features` | variáveis sorteadas por divisão; descorrelaciona as árvores |
| XGBoost | `learning_rate` | tamanho do passo; menor = mais lento e estável |
| XGBoost | `max_depth`, `min_child_weight` | complexidade de cada árvore |
| XGBoost | `subsample`, `colsample_bytree` | fração de linhas / colunas por árvore |
| XGBoost | `reg_alpha` (L1), `reg_lambda` (L2), `gamma` | regularização |
| XGBoost | `early_stopping_rounds` | para quando a validação não melhora |

Em Random Forest, limitar a profundidade costuma **piorar**: as árvores individuais precisam de viés baixo; a média é que reduz a variância.

## Validação e seleção de modelo

- **Hold-out**: `train_test_split` 80/20 ou 70/30, com `stratify=y` em classificação e `random_state` fixo. O teste só serve para a avaliação **final**.
- **Treino / validação / teste**: a validação escolhe hiperparâmetros e decide quando parar.
- **K-Fold** (`cross_val_score`, `cross_validate`): K treinos, cada um validado num bloco diferente; reporte **média ± desvio** (o desvio mostra estabilidade). `StratifiedKFold` em classificação.
- **GridSearchCV** testa todas as combinações (cada uma com CV); **RandomizedSearchCV** sorteia `n_iter` combinações — mais barato. Estratégia: busca aleatória ampla, depois grade pequena ao redor do melhor.
- `scoring` define o que otimizar (ex.: `recall` quando a classe rara importa).
- **Faça a busca só no treino** (ou use CV aninhada). Buscar com todos os dados e avaliar no teste dá uma estimativa otimista.
- **Séries temporais**: separe por data (treino no passado, teste no futuro) e use `TimeSeriesSplit`; embaralhar mistura o futuro no treino.

## Métricas

### Classificação
- **Matriz de confusão**: VN, FP, FN, VP.
- Acurácia $= (VP+VN)/\text{total}$ — engana com classes desbalanceadas (prever só a classe majoritária já dá número alto).
- **Precisão** $= VP/(VP+FP)$; **recall** $= VP/(VP+FN)$; **F1** = média harmônica das duas (pune desequilíbrio: 90% e 10% dão F1 ≈ 18%).
- **ROC/AUC**: separação entre classes independente do corte; calcule com **probabilidades** (`predict_proba`), não com classes.
- Escolha pela regra de negócio: se deixar passar um positivo custa caro (FN), maximize recall; se alarme falso custa caro (FP), precisão.
- Baixar o limiar de 0,5 aumenta o recall à custa da precisão.

### Regressão
- **MAE**: média dos erros absolutos (mesma unidade, robusto).
- **MSE**: média dos erros ao quadrado (penaliza erros grandes).
- **RMSE**: raiz do MSE (mesma unidade).
- **R²**: fração da variância explicada (1 = perfeito).
- **MAPE**: erro percentual; quebra com valores reais próximos de zero.

Exemplo: reais 300, 500, 700, 900 e previstos 280, 550, 650, 1000 → erros 20, 50, 50, 100 → MAE = 55, MSE = 3850, RMSE ≈ 62.

## Ensembles

A ideia do **júri**: muitos modelos diversos, combinados, erram menos que um só.

| Família | Como combina | Efeito | Exemplo |
|---|---|---|---|
| Voting / averaging | voto (hard) ou média de probabilidades (soft) | reduz o erro individual | `VotingClassifier` |
| Bagging | modelos em paralelo, cada um num **bootstrap** | reduz **variância** | Random Forest |
| Boosting | modelos em **sequência**, cada um corrige o resíduo do anterior | reduz **viés** | AdaBoost, Gradient Boosting, XGBoost |
| Stacking | modelos base alimentam um metamodelo | aprende a combinar | `StackingClassifier` |

**Viés × variância**: árvore profunda = viés baixo, variância alta; árvore rasa = o inverso. Bagging ataca a variância; boosting, o viés.

### Random Forest, passo a passo
1. Gerar B amostras bootstrap (cada uma com ~63% das linhas únicas; ~37% ficam **fora da amostra**, OOB).
2. Em cada nó, sortear um subconjunto de variáveis e escolher a melhor divisão entre elas.
3. Crescer cada árvore profunda.
4. Classificação: voto ou média de probabilidades; regressão: média.
5. OOB como validação "gratuita"; `feature_importances_` para ranking.

### XGBoost, passo a passo
1. Começar com uma previsão simples.
2. Calcular o resíduo (gradiente da perda).
3. Ajustar uma árvore rasa a esse resíduo.
4. Somar a nova árvore multiplicada pelo `learning_rate`.
5. Repetir até `n_estimators` ou até o early stopping.
6. Objetivo = erro nos dados + penalidade de complexidade (L1/L2 nos pesos das folhas e `gamma` por divisão).

Aceita `NaN` nativamente e o tipo `category` do pandas; é muito sensível a hiperparâmetros.

## Importância de variáveis

- `feature_importances_` (redução de impureza/ganho): rápida, mas **favorece variáveis contínuas e de alta cardinalidade**, divide o crédito entre variáveis correlacionadas e **não mostra o sentido** do efeito.
- **Permutation importance**: embaralha uma variável no teste e mede a queda da métrica.
- **SHAP (valores de Shapley)**: contribuição de cada variável em cada previsão, com sinal.

## Comparação rápida

| | Árvore | Random Forest | XGBoost |
|---|---|---|---|
| Ideia | modelo único | bagging | boosting |
| Overfitting | alto | menor | controlável com regularização |
| Sensibilidade a hiperparâmetros | média | baixa | alta |
| Pré-processamento | mínimo | mínimo | mínimo |
| Interpretabilidade | muito alta | média | média/baixa (use SHAP) |

## Perguntas de revisão

1. **Como uma árvore escolhe a divisão?** Pela variável e corte que mais reduzem a impureza (Gini/entropia) ou o erro quadrático.
2. **O que a folha prevê?** A classe mais frequente na classificação e a média do alvo na regressão.
3. **Como diagnosticar overfitting?** Métrica de treino muito acima da de teste.
4. **O que sugere 100% de acerto no teste?** Possível vazamento de dados.
5. **Quais hiperparâmetros controlam o overfitting numa árvore?** `max_depth`, `min_samples_split` e `min_samples_leaf`.
6. **Por que usar `stratify=y`?** Para manter a proporção das classes no treino e no teste.
7. **Para que serve a validação cruzada?** Estimar desempenho e estabilidade (média ± desvio) sem gastar o teste.
8. **Grid search ou random search?** Grid testa todas as combinações; random sorteia algumas e é mais barato.
9. **Por que a acurácia engana?** Com classe rara, prever só a majoritária já dá acurácia alta.
10. **Precisão ou recall?** Depende do custo: FN caro → recall; FP caro → precisão.
11. **Por que o F1 usa média harmônica?** Porque penaliza o desequilíbrio entre precisão e recall.
12. **Qual a diferença entre MAE e RMSE?** Os dois estão na unidade do alvo; o RMSE penaliza mais os erros grandes.
13. **Bagging ou boosting?** Bagging: paralelo, reduz variância; boosting: sequencial, corrige resíduos, reduz viés.
14. **O que é OOB?** As linhas que ficaram fora do bootstrap de uma árvore (~37%), usadas como validação.
15. **O que o Random Forest faz além do bagging?** Sorteia um subconjunto de variáveis em cada divisão, descorrelacionando as árvores.
16. **Qual o papel do learning rate e do early stopping no XGBoost?** O learning rate é o tamanho do passo; o early stopping para quando a validação deixa de melhorar.
17. **O que L1 e L2 fazem no XGBoost?** Penalizam os pesos das folhas; L1 pode zerá-los, L2 os suaviza.
18. **Por que `feature_importances_` não basta?** É enviesada e não mostra o sentido do efeito; use permutation importance e SHAP.
19. **Como validar modelos com séries temporais?** Separando por data e usando `TimeSeriesSplit`, nunca embaralhando.
20. **As árvores extrapolam?** Não; nunca preveem fora da faixa de valores vista no treino.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/arvores-ensembles


# Support Vector Machines (SVM)

> Classificação (SVC) e regressão (SVR) por margem máxima — vetores de suporte, parâmetro C, kernels linear, polinomial e RBF, pipeline com pré-processamento, grid search e permutation importance.

## Visão geral

O SVM é um modelo supervisionado que serve para **classificação** (`SVC`, $Y$ categórica) e **regressão** (`SVR`, $Y$ métrica). A ideia é encontrar a fronteira que separa as classes com a **maior margem possível**, tolerando algumas violações. Com **kernels**, essa fronteira pode ser não linear sem que você precise criar interações à mão.

O roteiro prático é sempre o mesmo: **pré-tratar (padronizar e dummizar) → separar treino e teste → Pipeline + GridSearchCV → avaliar no teste → interpretar → prever casos novos.**

## Conceitos centrais

- **Fronteira de decisão (hiperplano)**: com 2 variáveis é uma reta; com muitas, um hiperplano. A previsão depende do lado em que a observação cai.
- **Margem**: distância entre a fronteira e as observações mais próximas de cada classe. Margem larga = menos sensibilidade a pequenas variações de $X$ e melhor generalização.
- **Vetores de suporte**: as observações sobre a margem ou violando-a. São elas que fixam a fronteira; as demais não influenciam.
- **Hard margin**: nenhuma violação (raro na prática). **Soft margin**: violações permitidas e penalizadas — é o que se usa.
- **C**: penalização das violações.
  - C alto → margens justas, modelo complexo, risco de **overfitting**;
  - C baixo → margens largas, modelo tolerante, risco de **underfitting**.

## Kernels

O kernel é uma função de similaridade entre pares de observações num espaço transformado. A separação linear nesse espaço aparece como uma fronteira curva no espaço original — e isso sem calcular as coordenadas transformadas (*kernel trick*).

| Kernel | Fórmula | Hiperparâmetros |
|---|---|---|
| Linear | $K(a,b) = a^\top b$ | C |
| Polinomial | $K(a,b) = (\gamma\, a^\top b + r)^d$ | C, `degree` (d), `coef0` (r), `gamma` |
| RBF (gaussiano) | $K(a,b) = \exp(-\gamma \lVert a-b \rVert^2)$ | C, `gamma` |

- **gamma** define o alcance da influência de cada observação: gamma alto → influência localizada e fronteira complexa (risco de overfitting).
- Não há regra intuitiva entre polinomial e RBF: teste os dois.

## SVR (regressão)

O SVR ajusta um "tubo" de largura **ε (epsilon)** ao redor da função. Erros dentro do tubo não são penalizados; só os de fora entram, ponderados por C. O epsilon deve respeitar a escala de $Y$ — grande demais causa underfitting.

## Multiclasse

O `SVC` usa **one-vs-one**: treina um SVM para cada par de classes e decide por votação. O código é idêntico ao binário; a matriz de confusão vira $n \times n$ e as métricas usam média macro.

## Passo a passo (receita)

1. Separe as listas de variáveis métricas e categóricas (sem o alvo e sem IDs).
2. Monte o pré-processamento com `ColumnTransformer`: `StandardScaler` nas métricas e `OneHotEncoder` nas categóricas (variáveis já dummizadas passam direto).
3. Separe treino e teste (30% para teste, `stratify` na classificação).
4. Crie o Pipeline e a grade, um dicionário por kernel, com o prefixo `svm__`.
5. Ajuste o `GridSearchCV` com os dados **sem** pré-tratar (o pipeline cuida disso dentro de cada dobra).
6. Avalie treino e teste e compare (overfitting?). Não reajuste depois de olhar o teste.
7. Interprete com `permutation_importance` no teste.
8. Preveja casos novos com `best_estimator_.predict(novos)` usando os valores originais.

```python
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split, GridSearchCV

pre = ColumnTransformer([
    ("num", StandardScaler(), metricas),
    ("cat", OneHotEncoder(drop="if_binary", handle_unknown="ignore",
                          sparse_output=False), categoricas),
])
X = dados.drop(columns=["alvo", "id"]); y = dados["alvo"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3,
                                          stratify=y, random_state=42)
pipe = Pipeline([("pre", pre), ("svm", SVC())])
grade = [
    {"svm__kernel": ["linear"], "svm__C": [0.1, 1, 10]},
    {"svm__kernel": ["rbf"], "svm__C": [0.1, 1, 10], "svm__gamma": ["scale", 0.1, 1]},
    {"svm__kernel": ["poly"], "svm__C": [0.1, 1], "svm__degree": [2, 3]},
]
busca = GridSearchCV(pipe, grade, scoring="f1", cv=5, n_jobs=-1).fit(X_tr, y_tr)
print(busca.best_params_, busca.best_score_)
```

## Por que padronizar

O SVM se baseia em **distâncias**: uma variável medida em milhares domina outra medida em unidades. Por isso `StandardScaler` (escore z) nas métricas — ajustado **só no treino** (`fit`) e aplicado ao teste e a casos novos (`transform`). O Pipeline garante isso automaticamente e evita vazamento.

## Quando usar

- Bases pequenas e médias; com bases muito grandes o treino fica lento (sobretudo com kernel não linear e C alto).
- Quando se quer fronteira não linear sem criar interações à mão.
- Não substitui árvores e ensembles: teste todos e compare no mesmo conjunto de teste.
- Limitações: não dá probabilidade nativa nem coeficientes interpretáveis (exceto no kernel linear) — daí o uso de permutation importance.

## Avaliação

- **Classificação**: matriz de confusão, acurácia $(VP+VN)/\text{total}$, sensibilidade/recall $VP/(VP+FN)$, especificidade $VN/(VN+FP)$, precisão $VP/(VP+FP)$, F1.
- **Regressão**: MSE, RMSE, MAE (menor é melhor) e R² (mais perto de 1 é melhor); no grid, `scoring="neg_mean_squared_error"`.
- **Desbalanceamento** (80/20, 90/10): acurácia engana; use recall, precisão e F1; SMOTE ou undersampling, com cautela e validando no teste.

## Perguntas de revisão

1. **Para que serve o SVM?** Classificação (SVC) e regressão (SVR), com fronteiras lineares ou não lineares.
2. **O que é um vetor de suporte?** Uma observação sobre a margem ou violando-a, que determina a posição da fronteira.
3. **Por que maximizar a margem?** Uma fronteira afastada das observações é menos sensível a pequenas variações e generaliza melhor.
4. **Qual a diferença entre hard margin e soft margin?** Hard exige separação perfeita; soft permite violações penalizadas por C.
5. **O que faz o parâmetro C?** Penaliza violações: C alto dá margem justa e risco de overfitting; C baixo dá margem larga e risco de underfitting.
6. **Por que padronizar as variáveis no SVM?** Porque ele se baseia em distâncias e é sensível à escala.
7. **Como tratar variáveis categóricas preditoras?** Com `OneHotEncoder`; `drop="if_binary"` evita dummy redundante nas binárias.
8. **O que é o kernel?** Uma função de similaridade num espaço transformado que permite fronteiras não lineares sem calcular as coordenadas (kernel trick).
9. **Quais os hiperparâmetros de cada kernel?** Linear: C. Polinomial: C, degree, coef0, gamma. RBF: C, gamma.
10. **O que faz o gamma?** Define o alcance da influência de cada observação; alto produz fronteiras complexas.
11. **Como escolher os hiperparâmetros?** Com grid search e validação cruzada k-fold no conjunto de treino.
12. **Por que usar Pipeline no grid search?** Para aplicar o pré-processamento dentro de cada dobra e evitar vazamento de dados.
13. **Como evitar vazamento ao padronizar?** `fit` só no treino; `transform` no teste e nos casos novos.
14. **Por que olhar o teste só no fim?** Para medir a generalização de forma independente; ajustar depois de vê-lo é "treinar disfarçado".
15. **Quando privilegiar recall ou precisão?** Recall quando perder positivos custa caro; precisão quando falso positivo custa caro.
16. **Como o SVC trata mais de duas classes?** Por one-vs-one: um modelo por par de classes e votação.
17. **O que muda no SVR?** Erros dentro do tubo de largura epsilon não são penalizados; só os de fora, via C.
18. **O que é permutation importance?** Embaralhar uma variável por vez no teste e medir a piora da métrica.
19. **Quando o SVM sofre?** Em bases muito grandes, especialmente com kernel não linear e C alto.
20. **Como lidar com classes desbalanceadas?** Usando recall, precisão e F1, e técnicas como SMOTE ou undersampling validadas no teste.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/svm


# Deep Learning e Redes Neurais

> Do perceptron ao Transformer — tensores, MLP, ativações, funções de perda, gradiente descendente, otimizadores, regularização, CNN, autoencoder, embeddings e atenção, com Keras.

## Visão geral

Uma rede neural é uma **função composta ajustada por gradiente**. A arquitetura (MLP, CNN, Transformer...) é só a forma de organizar essa função para o tipo de dado. Os fundamentos — neurônio, perda, gradiente, overfitting — não mudam de uma arquitetura para outra.

Duas regras práticas:
1. **Comece pelo baseline mais barato** (regra simples, regressão, árvore) e só suba a complexidade se houver ganho real na validação.
2. Modelo mais complexo só compensa com **dados suficientes**.

Definição clássica de aprendizado (Mitchell): um programa aprende se seu desempenho **D** numa tarefa **T** melhora com a experiência **E**.

## Tensores

- Dados em redes são **tensores**: escalar (rank 0), vetor (rank 1), matriz (rank 2), imagem (rank 3: altura × largura × canais), lote de imagens (rank 4).
- **Rank** = número de eixos (`ndim`); **shape** = tamanho de cada eixo.

## O neurônio e o MLP

- Neurônio: $\hat y = g\left(\sum_i x_i w_i + b\right)$ — soma ponderada mais viés, passada por uma **ativação** $g$.
- **Ativações**: ReLU $\max(0,z)$ (camadas ocultas), sigmoide $1/(1+e^{-z})$ (saída binária), softmax $e^{z_i}/\sum_j e^{z_j}$ (saída multiclasse), linear (regressão).
- Por que a ativação precisa ser **não linear**? Combinação de funções lineares é linear: sem ela, a rede inteira seria uma reta.
- **MLP** (perceptron multicamadas): camadas densas empilhadas. Parâmetros de uma camada densa: `entradas × neurônios + neurônios` (ex.: 4 → 8 tem 40 parâmetros).

## Como a rede aprende

- **Função de perda** mede o erro:
  - regressão: MSE ou MAE;
  - binária: entropia cruzada binária $-[y\log\hat y + (1-y)\log(1-\hat y)]$;
  - multiclasse: entropia cruzada categórica (`SparseCategoricalCrossentropy` com rótulo inteiro + softmax).
- **Gradiente descendente**: $W \leftarrow W - \eta \nabla J(W)$, onde $\eta$ é a taxa de aprendizado.
- **Backpropagation**: regra da cadeia para calcular o gradiente de cada peso, da saída para a entrada.
- **Batch e época**: o gradiente é estimado em lotes (`batch_size`); uma época é uma passada por todos os dados.
- **Otimizadores**: SGD, SGD com momentum, RMSprop, **Adam** (padrão seguro), AdamW (comum em Transformers).
- A razão taxa de aprendizado / tamanho do lote funciona como uma "temperatura" do treino: ao mudar um, ajuste o outro.

## Overfitting e regularização

- Sinal: a perda de **validação** para de cair e começa a subir enquanto a de treino continua descendo.
- **Early stopping** com paciência e `restore_best_weights=True`.
- **Dropout**, regularização L1/L2 nos pesos, **data augmentation** (imagens), mais dados, modelo menor.
- Treino é estocástico: diferenças pequenas entre modelos podem ser só a semente aleatória.

## Arquiteturas e quando usar

| Arquitetura | Dado típico | Ideia central |
|---|---|---|
| MLP | tabela, vetores | camadas densas; baseline |
| CNN | imagem, sinais 1D/2D | filtros (kernels) compartilhados e pooling |
| Autoencoder | qualquer | comprimir e reconstruir; anomalias, ruído, sem rótulo |
| LSTM / GRU | séries temporais, áudio | recorrência; custo linear, bom com pouco dado |
| Transformer | texto, LLMs, multimodal | atenção; custo quadrático, pede muito dado |
| GAN / difusão | geração de imagens | gerador × discriminador / remoção de ruído |

### CNN
- Um **filtro** desliza pela imagem detectando padrões locais (bordas, texturas); camadas seguintes combinam padrões em formas mais complexas.
- Pesos compartilhados → muito menos parâmetros que um MLP e **invariância à translação**.
- **Max pooling** mantém o maior valor de cada janela, reduzindo a resolução sem parâmetros.
- **Data augmentation** (girar, deslocar, espelhar) precisa **preservar o rótulo** e pede mais paciência no early stopping.

### Autoencoder
- Codificador comprime a entrada num vetor pequeno; decodificador reconstrói.
- Treinado só com casos normais, um **erro de reconstrução alto** sinaliza anomalia — útil quando os casos raros são poucos demais para treino supervisionado.

### Texto, embeddings e Transformer
- One-hot de palavras gera vetores enormes e esparsos; **embeddings** são vetores densos aprendidos (parâmetros: `vocabulário × dimensão`).
- **Atenção**: $\text{softmax}(QK^\top/\sqrt{d})\,V$ — cada token "consulta" (Q) os demais (K) e combina seus valores (V).
- **Codificação posicional** informa a ordem: $PE(pos, 2i) = \sin(pos/10000^{2i/d})$.
- Um mini-GPT é uma pilha de blocos de atenção treinada para prever o próximo token.

## Passo a passo de um projeto

1. Definir tarefa e métrica; coletar o dado mais simples e barato.
2. Baseline simples antes de qualquer rede.
3. Limpar os dados; separar treino/validação/teste (estratificado, semente fixa).
4. Escalonar com `fit` **só no treino**; codificar categorias (one-hot, label ou embedding).
5. Montar o modelo (Sequential ou API funcional) e compilar com otimizador, perda e métricas.
6. Treinar com `EarlyStopping` e `ModelCheckpoint`, acompanhando as curvas por época.
7. Regularizar se houver overfitting.
8. Avaliar no teste **uma vez**; com pouco dado, validação cruzada repetida.
9. Empacotar o pré-processamento dentro do modelo (`Rescaling`, `TextVectorization`) para colocar em produção.

```python
import keras
from keras import layers

modelo = keras.Sequential([
    keras.Input(shape=(n_features,)),
    layers.Dense(32, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(16, activation="relu"),
    layers.Dense(1, activation="sigmoid"),
])
modelo.compile(optimizer="adam", loss="binary_crossentropy",
               metrics=[keras.metrics.AUC(name="auc"), "recall"])
pare = keras.callbacks.EarlyStopping(monitor="val_auc", mode="max",
                                     patience=5, restore_best_weights=True)
modelo.fit(X_tr, y_tr, validation_split=0.2, epochs=100,
           batch_size=32, callbacks=[pare])
```

## Avaliação

- Regressão: MAE, MSE, R². Classificação: acurácia só com classes balanceadas; senão precisão, recall, F1, AUROC e AUPR.
- Compare sempre com um baseline aleatório (10% em 10 classes) e com ML tradicional.
- Em dados **tabulares** pequenos e médios, árvores de gradiente costumam vencer redes.
- Redes profundas trocam explicabilidade por poder preditivo.

## Perguntas de revisão

1. **O que é aprendizado, segundo Mitchell?** Quando o desempenho D numa tarefa T melhora com a experiência E.
2. **Por que a ativação precisa ser não linear?** Porque composições de funções lineares continuam lineares.
3. **Qual a fórmula de um neurônio?** $\hat y = g(\sum x_i w_i + b)$.
4. **Quantos parâmetros tem uma camada densa de 4 entradas e 8 neurônios?** 4 × 8 + 8 = 40.
5. **Qual a diferença entre rank e shape?** Rank é o número de eixos; shape é o tamanho de cada eixo.
6. **Como o gradiente descendente atualiza os pesos?** $W \leftarrow W - \eta\nabla J(W)$.
7. **O que faz o backpropagation?** Calcula o gradiente de cada peso pela regra da cadeia, da saída para a entrada.
8. **Qual otimizador usar se não houver tempo de testar?** Adam (AdamW em Transformers).
9. **Quando parar o treino?** Quando a perda de validação deixa de melhorar, com paciência e restaurando os melhores pesos.
10. **Qual perda usar em multiclasse com rótulos inteiros?** `SparseCategoricalCrossentropy` com saída softmax.
11. **Por que a CNN é melhor que o MLP em imagens?** Usa padrões locais e hierárquicos, compartilha pesos, é invariante à translação e tem menos parâmetros.
12. **O que faz o max pooling?** Mantém o maior valor de cada janela, reduzindo a resolução sem parâmetros.
13. **O que o data augmentation exige?** Que as transformações preservem o rótulo.
14. **Para que serve um autoencoder na detecção de anomalias?** Treinado com casos normais, erro de reconstrução alto indica anomalia.
15. **O que é um embedding?** Um vetor denso aprendido que representa uma palavra ou categoria.
16. **Qual a fórmula da atenção?** $\text{softmax}(QK^\top/\sqrt d)\,V$.
17. **Por que o Transformer precisa de codificação posicional?** Porque a atenção, sozinha, não sabe a ordem dos tokens.
18. **LSTM ou Transformer para série temporal com pouco dado?** LSTM costuma ser competitiva; Transformer pede muito dado.
19. **Redes neurais vencem sempre em dados tabulares?** Não; em tabelas pequenas e médias, árvores de gradiente costumam vencer.
20. **Por que empacotar o pré-processamento dentro do modelo?** Para que a produção receba o dado bruto e aplique exatamente o mesmo tratamento do treino.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/deep-learning


# APIs, LLMs e RAG

> Do protótipo ao serviço — HTTP/REST, FastAPI e Pydantic, LLM como componente de engenharia (tokens, custo, temperatura, limites, chaves), embeddings, similaridade de cosseno, bancos vetoriais e uma API de RAG.

## Visão geral

Um notebook que funciona não é um produto. Entre os dois existe o **abismo de integração**: concorrência, formatos, latência, dependências, segurança. Três pilares organizam a travessia:

- **API** — a ponte entre sistemas;
- **LLM** — o "cérebro" que interpreta e gera texto;
- **RAG** — a "memória": buscar trechos relevantes de uma base e entregá-los ao LLM.

## HTTP e REST

- HTTP é **stateless**: cada requisição é independente; o servidor não lembra da anterior.
- `GET` para consultar (sem corpo); `POST` para enviar dados (com corpo/payload).
- Respostas em **JSON**; códigos 2xx sucesso, 4xx erro do cliente (400 entrada inválida, 401/403 sem permissão, 429 limite excedido), 5xx erro do servidor.
- Rota `/health` responde se o serviço está vivo (usada por balanceadores e orquestradores).

## FastAPI + Pydantic

- **FastAPI** cria APIs em Python com documentação automática em `/docs`.
- **Pydantic** valida o **contrato** de entrada e saída: tipo errado vira erro de validação antes do seu código rodar.
- Rodar localmente com **Uvicorn**.

```python
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Pergunta(BaseModel):
    texto: str
    top_k: int = 4

class Resposta(BaseModel):
    resposta: str
    fontes: list[str]

@app.get("/health")
def health():
    return {"status": "ok"}

@app.post("/query", response_model=Resposta)
def query(p: Pergunta):
    trechos = buscar(p.texto, p.top_k)          # banco vetorial
    texto = gerar(p.texto, trechos)              # LLM
    return Resposta(resposta=texto, fontes=[t.fonte for t in trechos])
```

## LLM como componente de engenharia

- **Tokens**: unidade de cobrança e de limite de contexto (aprox. ¾ de palavra em inglês; um pouco menos em português).
- **Custo por chamada**: $\text{custo} = \frac{\text{tokens}_{in}}{10^6}p_{in} + \frac{\text{tokens}_{out}}{10^6}p_{out}$ — a saída costuma custar mais que a entrada.
- **Temperatura**: baixa (0–0,2) para extração, JSON e RAG; alta (0,7–1,0) para criação.
- **Limites de taxa** (requisições e tokens por minuto): ao receber 429, aplique **backoff exponencial** e tenha um modelo de reserva.
- **Chaves de API** em variáveis de ambiente (`.env` + `load_dotenv()`), nunca no código; chaves diferentes por ambiente.
- **FinOps**: medir tokens e custo por rota; cache de respostas repetidas.
- Modelo proprietário (simples e potente, mas o prompt vai ao provedor) × pesos abertos (soberania, porém custo de infraestrutura).

## Embeddings e similaridade

- **Embedding**: vetor denso que representa o significado; textos de sentido parecido ficam próximos no espaço.
- **Similaridade de cosseno**: $\cos\theta = \dfrac{A\cdot B}{\lVert A\rVert\,\lVert B\rVert}$ — 1 = mesma direção, 0 = ortogonais, -1 = opostos. Ex.: $A=(1,2,3)$ e $B=(2,4,6)$ dão 1.
- **Banco vetorial** guarda vetores + metadados e faz busca dos mais próximos (top-K):
  - protótipo local: Chroma, DuckDB, FAISS;
  - serviço compartilhado: Qdrant, Milvus, Pinecone, **pgvector** (PostgreSQL).

## RAG, passo a passo

**Fase offline (ingestão)**
1. Extrair o texto (PDF, páginas, documentos).
2. **Chunking**: quebrar em pedaços com **sobreposição** (comece com 10–15%) para não cortar uma informação no limite.
3. Gerar embeddings em lote (com retry em erro 429).
4. Gravar no banco vetorial com metadados (fonte, página, data).

**Fase online (consulta)**
1. Gerar o embedding da pergunta.
2. Buscar os top-K trechos mais próximos.
3. Montar o prompt com **ancoragem**: "responda só com base no contexto; se não estiver lá, diga que não consta".
4. Chamar o LLM com temperatura baixa.
5. Devolver resposta + fontes + métricas.

## RAG ou fine-tuning?

| Necessidade | Escolha |
|---|---|
| Conhecimento factual que muda (políticas, manuais, catálogos) | **RAG** |
| Citar a fonte da resposta | **RAG** |
| Estilo, tom, formato fixo | **fine-tuning** |
| Capacidades gerais novas | treinamento |

RAG **não conserta dado ruim** (lixo entra, lixo sai) e **não altera os pesos** do modelo.

## Observabilidade e avaliação

- Latência por etapa: em geral o gargalo é a **geração do LLM** (segundos), não a busca vetorial (milissegundos).
- Tokens e custo estimado por chamada, melhor distância de cosseno, motivo de término (`finish_reason`).
- Teste perguntas **dentro e fora** da base: fora, o sistema deve responder "não consta".
- Produção: réplicas atrás de balanceador, banco vetorial dedicado, testes de carga, chaves por ambiente, respeito às **permissões** de quem pergunta (o RAG não pode devolver um documento que o usuário não poderia ver).

## Bibliotecas

`fastapi`, `uvicorn`, `pydantic`, `python-dotenv`, `python-multipart`, `pypdf`, `requests`, `numpy`, SDKs de LLM e embeddings, `chromadb` / `qdrant-client` / `pgvector`.

## Perguntas de revisão

1. **Por que um protótipo não vira produto sozinho?** Por causa do abismo de integração: concorrência, formatos, latência, dependências e segurança.
2. **Quais os três pilares de um sistema com LLM?** API (ponte), LLM (cérebro) e RAG (memória).
3. **GET ou POST quando há payload?** POST; sem payload, GET.
4. **O que significa HTTP ser stateless?** Cada requisição é independente; o servidor não guarda estado entre elas.
5. **Para que serve a rota `/health`?** Para que balanceadores e orquestradores verifiquem se o serviço está vivo.
6. **O que o Pydantic faz numa API?** Valida o contrato de entrada e saída antes do código rodar.
7. **Que temperatura usar em RAG?** Baixa, entre 0 e 0,2.
8. **Onde guardar a chave de API?** Em variável de ambiente (`.env`), nunca no código.
9. **Como tratar o erro 429?** Com backoff exponencial, respeitando os limites, e um modelo de reserva.
10. **Por que a saída de um LLM custa mais?** Porque o preço por milhão de tokens de saída costuma ser maior que o de entrada.
11. **O que é um embedding?** Um vetor denso que representa o significado de um texto.
12. **Qual o cosseno de dois vetores na mesma direção?** 1 (0 se ortogonais, -1 se opostos).
13. **Por que usar sobreposição no chunking?** Para não cortar uma informação no limite entre dois pedaços.
14. **Quais as fases do RAG?** Offline (extrair, quebrar, vetorizar, gravar) e online (vetorizar a pergunta, buscar, montar o prompt, gerar).
15. **RAG corrige dado errado?** Não; lixo entra, lixo sai.
16. **RAG ou fine-tuning para uma política interna que muda?** RAG; fine-tuning é para estilo e formato.
17. **Onde costuma estar o gargalo de latência?** Na geração do LLM, não na busca vetorial.
18. **Por que não usar um banco vetorial local em produção?** Falta escala e alta disponibilidade; use um serviço dedicado.
19. **Como testar se o RAG está ancorado?** Fazendo perguntas fora da base: a resposta deve ser "não consta".
20. **O RAG altera os pesos do modelo?** Não; só fornece contexto na hora da pergunta.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/apis-llms-rag


# Análise Estatística Espacial

> Dados com localização — vetor e raster, sistemas de referência (CRS), operações espaciais com GeoPandas, estatística zonal, mapas e autocorrelação espacial (Moran e LISA).

## Visão geral

Quando o dado tem **onde**, aparece uma pergunta nova: a localização importa? A análise espacial trata dados com geometria, cruza camadas **pela posição** e testa estatisticamente se valores parecidos se agrupam no espaço.

A primeira lei da geografia resume a intuição: *tudo se relaciona com tudo, mas coisas próximas se relacionam mais que coisas distantes*.

## Modelos de dado

- **Vetor**: feições discretas com atributos — **ponto** (loja, poço), **linha** (rua, rio), **polígono** (município, talhão).
- **Raster**: grade de pixels com valores (contínuos como temperatura e altitude, ou categóricos como uso do solo); pode ter várias **bandas**; células sem dado são **NoData**.
- **Resolução espacial** = tamanho do pixel: menor pixel, mais detalhe e mais dados.

## Formatos

- **Shapefile**: vários arquivos juntos — `.shp` (geometria), `.shx` (índice), `.dbf` (atributos), `.prj` (CRS), `.cpg` (codificação).
- **GeoJSON** / Simple Features: texto, fácil de trocar na web.
- **GeoPackage** (`.gpkg`): um arquivo só, moderno.
- **GeoTIFF**: raster georreferenciado.

## Sistemas de referência (CRS)

- O CRS amarra as coordenadas à superfície da Terra — é a "identidade" geográfica da camada.
- **Geográfico** (graus de latitude/longitude): ex. EPSG 4326 (WGS84, o do GPS) e EPSG 4674 (SIRGAS 2000, datum oficial do Brasil).
- **Projetado** (metros): ex. UTM. No Brasil, SIRGAS 2000 / UTM do fuso local (EPSG 31981 a 31985, conforme a longitude).
- **Regra 1**: todas as camadas no **mesmo CRS** antes de cruzar.
- **Regra 2**: reprojete para um CRS **métrico** antes de calcular distância, área ou buffer. Um grau de longitude vale cerca de 111 km × cos(latitude) — varia com o lugar, e o buffer em graus sai distorcido.

## Operações com GeoPandas

| Necessidade | Operação |
|---|---|
| Criar pontos a partir de lat/lon | `gpd.points_from_xy(lon, lat)` com `crs=4326` |
| Em que polígono cada ponto está | `sjoin` (predicado `within` / `intersects`) |
| Recortar uma camada pelo limite de outra | `clip` |
| Agregar polígonos (município → região) | `dissolve(by=..., aggfunc=...)` |
| Área de influência por raio | `buffer` (em CRS métrico) |
| Interseção, união, diferença de geometrias | `overlay` |
| Juntar atributos por chave | `merge` |
| Valor de raster por polígono | **estatística zonal** |

- O `sjoin` pode **duplicar linhas** quando um ponto cai em mais de um polígono: confira a cardinalidade.
- Antes de qualquer média de raster: mascarar NoData, conferir unidade física, CRS e resolução.

## Passo a passo de um projeto

1. **Coletar** e registrar fonte, data e licença (malhas oficiais, OpenStreetMap, dados de clima e satélite, endereços geocodificados).
2. **Ler** com `gpd.read_file` e criar GeoDataFrames de pontos a partir de coordenadas.
3. **Padronizar o CRS** e reprojetar para métrico quando houver distância, área ou buffer.
4. **Validar**: geometrias válidas, sem nulos, chaves únicas nos merges.
5. **Operar**: filtro, clip, sjoin, dissolve, buffer, overlay.
6. **EDA espacial**: coropléticos com **taxas normalizadas**, hexbin ou KDE para muitos pontos, histogramas (às vezes em log).
7. **Estatística**: matriz de pesos espaciais, Moran global, LISA.
8. **Saída**: mapa estático (matplotlib), interativo (Folium, Plotly) ou tabela para BI.

## Mapas que não enganam

- **Coroplético** com contagem bruta só mostra onde mora mais gente. Normalize: taxa por habitante, por domicílio ou por km².
- **Hexbin** agrega contagens por célula hexagonal; **KDE** estima uma superfície contínua de densidade.

## Autocorrelação espacial

- **Matriz de pesos**: define quem é vizinho de quem.
  - **Queen**: qualquer ponto de contato (como a dama do xadrez).
  - **Rook**: precisa de aresta comum (como a torre).
  - Também por distância ou k vizinhos mais próximos.
- **Moran global (I)**: de -1 a 1.
  - I > 0 e p < 0,05: valores semelhantes próximos (**agrupamento**);
  - I ≈ 0: sem padrão espacial;
  - I < 0: dispersão (vizinhos diferentes).
  - O p-valor vem de **permutações** (Monte Carlo), não de fórmula fechada.
- **LISA** (Moran local): **onde** estão os agrupamentos.
  - **HH** (alto cercado de alto) = hotspot; **LL** = coldspot;
  - **HL** e **LH** = outliers espaciais;
  - só valem as unidades com p < 0,05.

```python
import geopandas as gpd
from libpysal.weights import Queen
from esda.moran import Moran, Moran_Local

mun = gpd.read_file("municipios.gpkg").to_crs(31983)
mun["taxa"] = mun.casos / mun.populacao * 1e5
w = Queen.from_dataframe(mun); w.transform = "r"
mi = Moran(mun.taxa, w)
print(mi.I, mi.p_sim)
lisa = Moran_Local(mun.taxa, w)
```

## Uso em negócios

- **Expansão e cobertura**: buffers ao redor de unidades existentes mostram onde há demanda sem atendimento ("espaços em branco").
- **Variáveis espaciais para ML**: distância ao ponto mais próximo, contagens na vizinhança, estatística zonal de clima ou vegetação.
- **Cuidado na validação**: autocorrelação espacial infla métricas de validação aleatória; valide por **blocos geográficos**.

## Bibliotecas

`geopandas`, `shapely`, `pyproj`, `libpysal` (pesos), `esda` (Moran, LISA), `splot`, `rasterio` e `rasterstats` (raster), `folium`, `plotly`, `matplotlib`.

## Perguntas de revisão

1. **Qual a diferença entre vetor e raster?** Vetor representa feições discretas com atributos; raster é uma grade de pixels com valores.
2. **Quais arquivos compõem um shapefile?** `.shp` (geometria), `.shx` (índice), `.dbf` (atributos), `.prj` (CRS) e `.cpg` (codificação).
3. **O que é CRS?** O sistema que amarra as coordenadas à superfície da Terra.
4. **Qual a diferença entre CRS geográfico e projetado?** Geográfico usa graus; projetado usa metros.
5. **Que CRS usar para calcular buffer e distância?** Um CRS projetado em metros, como SIRGAS 2000 / UTM do fuso local.
6. **Por que não medir distância em graus?** Porque o comprimento de um grau de longitude varia com a latitude.
7. **Qual o datum oficial do Brasil?** SIRGAS 2000 (EPSG 4674 na versão geográfica).
8. **Qual a regra antes de cruzar camadas?** Todas no mesmo CRS.
9. **Qual a diferença entre clip e overlay?** Clip recorta uma camada pelo limite de outra; overlay combina geometrias (interseção, união, diferença).
10. **O que faz o dissolve?** Funde polígonos por um atributo e agrega colunas — um group by espacial.
11. **Qual o risco do sjoin?** Duplicar linhas quando um ponto cai em mais de um polígono.
12. **O que é resolução espacial?** O tamanho do pixel do raster.
13. **O que é estatística zonal?** Resumir os pixels de um raster dentro de cada polígono (média, mínimo, máximo).
14. **Por que normalizar um mapa coroplético?** Porque a contagem bruta reflete a população; taxas permitem comparar de forma justa.
15. **Hexbin ou KDE?** Hexbin agrega contagens por célula; KDE estima uma superfície contínua de densidade.
16. **Qual a diferença entre vizinhança Queen e Rook?** Queen considera qualquer contato; Rook exige aresta comum.
17. **O que mede o Moran global?** A autocorrelação espacial, de -1 a 1, com significância por permutações.
18. **O que o LISA acrescenta ao Moran global?** Localiza os agrupamentos (HH, LL) e os outliers espaciais (HL, LH).
19. **Por que a validação aleatória engana com dados espaciais?** Vizinhos parecidos caem no treino e no teste; valide por blocos geográficos.
20. **Como encontrar "espaços em branco" para expansão?** Cruzando a cobertura por buffers com indicadores de demanda.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/estatistica-espacial


# Business Intelligence e Visualização de Dados

> BI como metodologia de decisão, self-service com governança, e o primeiro painel no Power BI — Power Query, medidas DAX, visuais adequados e segmentações.

## Visão geral

**Business Intelligence** é uma **metodologia** para transformar dados em informação que apoia decisões; Power BI, Tableau, Qlik e Looker Studio são **ferramentas**. O painel é a camada de entrega de quase todo projeto de dados: é onde o resultado chega a quem decide.

> Conteúdo em construção: esta matéria cobre os fundamentos e o primeiro painel de ponta a ponta. Relacionamentos entre tabelas, DAX avançado e storytelling entram nas próximas atualizações.

## O processo de BI

Identificação da fonte → coleta → limpeza → transformação → modelagem → armazenamento → análise e visualização.

Em termos de ferramenta: **ETL** (*extract, transform, load*) → modelagem → visualização → publicação.

## Self-service analytics e governança

- **Self-service**: usuários de negócio criam as próprias análises, apoiados numa base estruturada e confiável.
- Pilares: técnicos (tecnologia, data warehouse), humanos e organizacionais (capacitação, processos, recursos) e entregáveis (relatórios, análises, visualizações).
- Fatores de sucesso: **governança de dados**, cultura orientada a dados, capacitação, processos definidos e suporte tecnológico.
- Vantagens: agilidade, menos dependência de TI, menor custo, foco estratégico.
- Sem governança aparecem **números divergentes** entre áreas, retrabalho e a "IA/BI de sombra" (*shadow AI*): painéis e ferramentas usados sem conhecimento nem controle da organização.

## Premissas de um projeto de dados

Antes de abrir a ferramenta: **contexto, escopo, tecnologia e público**. Depois: identificar a fonte → importar e tratar → desenvolver relatórios → montar o painel.

## Passo a passo no Power BI

1. **Obter dados**: Excel, CSV, web, bancos (SQL Server, Databricks e outros).
2. **Transformar dados** no **Power Query**:
   - promover cabeçalhos e definir tipos (data como Data gera a hierarquia ano/trimestre/mês);
   - **preencher para baixo** células mescladas que viraram nulas (não use em vazios reais);
   - dividir coluna por delimitador (ex.: nome e sobrenome);
   - substituir valores;
   - **despivotar**: marque as colunas fixas e use "transformar *outras* colunas em linhas" — meses novos entram sozinhos no futuro.
3. **Fechar e aplicar**; conferir no modo tabela.
4. Criar **medidas** em DAX.
5. Montar os visuais, escolher o tipo de gráfico e formatar.
6. Adicionar **segmentações** (filtros) e atualizar quando a fonte mudar.
7. Salvar e, em produção, publicar no serviço com governança (acessos, atualização agendada).

Cada transformação vira uma **etapa aplicada** (removível pelo X). O **Editor Avançado** mostra todas em **linguagem M** — é a documentação do tratamento.

## DAX: medidas

```dax
Total Vendas = SUM ( Vendas[Valor] )
Ticket Médio = DIVIDE ( [Total Vendas], DISTINCTCOUNT ( Vendas[Pedido] ) )
```

- **Medida** é um cálculo reutilizável e mais performático que a agregação implícita (arrastar a coluna e deixar o Power BI somar).
- Funções DAX em inglês: `SUM`, `AVERAGE`, `MIN`, `MAX`, `DIVIDE`, `CALCULATE`.

## Qual visual usar

| Pergunta | Visual |
|---|---|
| Qual o número principal? | **cartão** (KPI), com unidade (mil, mi) e moeda |
| Comparar categorias | **barras** (horizontais quando os rótulos são longos) |
| Evolução no tempo | **linhas** |
| Composição com poucas partes | **rosca/pizza** (até ~5 fatias) |
| Relação entre duas métricas | **dispersão** |
| Detalhe linha a linha | **tabela/matriz** |
| Filtrar o painel | **segmentação** |

## Boas práticas de painel

- Uma pergunta principal por página; o KPI mais importante no canto superior esquerdo.
- Mesma escala e mesma cor para a mesma coisa em todo o painel.
- Títulos que dizem a conclusão ("Vendas caíram 8% no 3º trimestre"), não só o assunto.
- Base grande: **agregue na origem** (views, tabelas em camadas), use **modelo estrela** (fato + dimensões) e remova colunas sem uso.
- Num projeto de previsão, o painel compara **real × previsto** e mostra o erro por período.

## Alternativas

Tableau, Qlik, Looker Studio, Amazon QuickSight, visualizações do Databricks; em Python, pandas + Plotly/Dash ou Streamlit. O Power BI Desktop roda só no Windows (no Mac e no Linux, via máquina virtual).

## Perguntas de revisão

1. **BI é uma ferramenta ou uma metodologia?** Uma metodologia de transformar dados em informação para decisão; Power BI é uma ferramenta.
2. **Quais as fases do processo de BI?** Identificação, coleta, limpeza, transformação, modelagem, armazenamento, análise e visualização.
3. **O que significa ETL?** Extract, transform, load — extrair, transformar e carregar.
4. **O que é self-service analytics?** Autonomia para usuários de negócio criarem análises sobre uma base estruturada.
5. **Quais os fatores de sucesso do self-service?** Governança, cultura orientada a dados, capacitação, processos definidos e suporte tecnológico.
6. **Por que a governança de dados importa?** Evita números divergentes entre áreas e retrabalho, e define donos e acessos.
7. **O que é shadow AI?** Uso de IA ou painéis sem conhecimento nem controle da organização.
8. **Onde se tratam os dados no Power BI?** No Power Query, em "Transformar dados".
9. **O que são etapas aplicadas?** A sequência de transformações do Power Query; cada uma pode ser removida.
10. **Quando usar "preencher para baixo"?** Para células mescladas que viraram nulas, nunca para vazios reais.
11. **Como transformar colunas de meses em linhas?** Marcando as colunas fixas e usando "transformar outras colunas em linhas".
12. **Por que despivotar as "outras colunas"?** Para que colunas novas no futuro entrem automaticamente.
13. **O que é a linguagem M?** A linguagem do Power Query; o Editor Avançado mostra todas as etapas nela.
14. **Qual a vantagem de uma medida sobre a agregação implícita?** É reutilizável, documentada e mais performática.
15. **Como criar uma medida de total?** `Total = SUM(Tabela[Valor])`.
16. **Como obter a hierarquia de datas?** Definindo o tipo da coluna como Data.
17. **Qual visual para evolução no tempo?** Gráfico de linhas.
18. **Quando a pizza/rosca funciona?** Com poucas partes, cerca de cinco no máximo.
19. **O que fazer com bases grandes no Power BI?** Agregar na origem, usar modelo estrela e remover colunas sem uso.
20. **O que um painel de previsão deve mostrar?** Real × previsto e o erro por período.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/bi-visualizacao


# Gestão da Mudança na Era Digital

> Por que projetos de dados e IA falham na adoção — mudança × transição (Bridges), as cinco dimensões da mudança, pensamento adaptativo e o método de Kotter em 8 passos.

## Visão geral

A maioria das empresas já usa IA em alguma área, mas só uma minoria vê impacto real no resultado. O gargalo raramente é técnico: é **adoção**. A transformação digital é cognitiva, cultural e humana, e o desafio é conviver com a **ambivalência** — nem otimismo cego, nem medo — preservando a autonomia das pessoas.

Esta matéria é a parte "humana" da ciência de dados: um modelo excelente que ninguém usa vale zero.

## Contexto: antagonismos da IA

- Vozes otimistas e pessimistas sobre a IA são verdadeiras ao mesmo tempo em aspectos diferentes: ganhos de produtividade convivem com deslocamento de funções.
- A competência pedida ao líder é a **capacidade adaptativa**: ler e gerir um contexto cheio de incoerências.

## Mudança × transição (William Bridges)

- **Mudança** é um evento **externo** e planejável: novo sistema, nova estrutura, novo processo.
- **Transição** é o processo **interno**, psicológico, de quem vive a mudança, em três fases:
  1. **Término** (*ending*): perda e desapego do jeito antigo;
  2. **Zona neutra**: o antigo já não funciona e o novo ainda não chegou — a fase mais desconfortável e a mais criativa;
  3. **Novo começo**: nova identidade e novos hábitos.
- As duas acontecem juntas, mas têm ritmos diferentes. Preparar para a mudança (ferramentas, treinamento) **não** é preparar para a transição (identidade).
- As pessoas não resistem à mudança em si: **resistem à perda percebida**.
- A adoção **não** decorre da superioridade técnica: medo e ameaça à identidade profissional geram resistência.

## As cinco dimensões da mudança

1. **Estratégia** — onde a mudança começa: o encontro das forças do mercado com as da empresa.
2. **Estrutura** — papéis, responsabilidades e relações entre áreas.
3. **Sistemas** — fluxos formais e informais, inclusive a comunicação.
4. **Cultura** — a mais estável e a mais difícil de mudar; muda mais no dia a dia do que em treinamentos.
5. **Estilo de gestão** — os líderes como alavanca (ou freio).

## O que muda com a decisão baseada em dados

| Antes | Depois |
|---|---|
| decisão pela experiência | dados + experiência |
| conhecimento concentrado | conhecimento distribuído |
| autoridade pela hierarquia | dados como fonte de autoridade |
| trabalho previsível | trabalho dinâmico |
| especialista dono do saber | especialista + algoritmo |

*Os dados não eliminam o julgamento; mudam o lugar onde o julgamento acontece.* Fica a pergunta que toda organização precisa responder: **quem decide quando o algoritmo discorda do especialista?**

## Pensamento mecanicista × adaptativo

- **Complexidade** não é o número de componentes, e sim o grau de **interconexão e interdependência**. Organizações são sistemas vivos, auto-organizáveis, que precisam de feedback.
- Risco da **mecanização**: medir → modelar → automatizar, e passar a considerar relevante só o que cabe nas métricas conhecidas.
- **Os dois navegadores**: um segue o plano à risca; o outro tem um objetivo claro e navega pelas circunstâncias. Bons projetos alternam entre planejar e se adaptar.
- **High concept e high touch** (Daniel Pink): criar conceitos e narrativas a partir de padrões; empatia e sutileza humana.
- **Techies e fuzzies** (Scott Hartley): pensamento técnico e pensamento de humanidades são complementares, não rivais.

## Armadilhas em projetos de IA

- Partir de uma tecnologia em busca de um problema.
- Não adequar a ferramenta ao estágio de maturidade do negócio.
- Esperar que a IA resolva o problema do jeito que o passado resolvia.

## Método: Kotter em 8 passos

1. Criar senso de **urgência**.
2. Formar uma **coalizão** (equipe-guia) com poder e credibilidade.
3. Desenvolver uma **visão** e uma estratégia.
4. **Comunicar** a visão e conquistar adesão.
5. **Empoderar** as pessoas e remover obstáculos.
6. Gerar **vitórias de curto prazo** visíveis.
7. **Consolidar** ganhos e persistir na mudança.
8. **Ancorar** a mudança na cultura para que perdure.

Na mobilização vale a "lei da inércia": é preciso mais força para **iniciar** o movimento do que para mantê-lo. Dois erros comuns: **instabilidade parcial** (abre espaço à resistência) e **estabilidade prematura** (declarar vitória cedo e a mudança morrer na praia).

### Dez alavancas práticas
Visão, mobilização, catalisação, direção, realização, participação, dimensão emocional, poder, treinamento e supervisão, comunicação ativa.

## Aplicando num projeto de dados

- Inclua no plano de implantação: urgência, equipe-guia, piloto, comunicação com quem vai usar, treinamento, **métrica de uso** (não só de acurácia).
- Antecipe as perguntas de resistência: "vou ser substituído?", "o modelo vai mandar em mim?", "quem responde se errar?".
- Mostre vitórias rápidas e visíveis antes de escalar.

## Perguntas de revisão

1. **Qual a diferença entre mudança e transição?** Mudança é um evento externo e planejável; transição é o processo psicológico interno de quem a vive.
2. **Quais as três fases da transição de Bridges?** Término, zona neutra e novo começo.
3. **Por que a zona neutra é desconfortável e criativa?** O antigo não funciona e o novo ainda não chegou; é preciso experimentar.
4. **As pessoas resistem à mudança?** Resistem à perda percebida, não necessariamente à mudança.
5. **A superioridade técnica garante a adoção?** Não; medo e ameaça à identidade geram resistência.
6. **Quais as cinco dimensões da mudança?** Estratégia, estrutura, sistemas, cultura e estilo de gestão.
7. **Qual dimensão é a mais difícil de mudar?** A cultura.
8. **O que muda com a decisão baseada em dados?** Decisão por dados + experiência, conhecimento distribuído, dados como autoridade, trabalho dinâmico e especialista + algoritmo.
9. **Os dados eliminam o julgamento?** Não; mudam o lugar onde o julgamento acontece.
10. **O que define a complexidade de um sistema?** O grau de interconexão e interdependência, não o número de componentes.
11. **Qual o perigo da mecanização?** Considerar relevante só o que cabe nas métricas conhecidas.
12. **Quais os 8 passos de Kotter?** Urgência, coalizão, visão, comunicação, empoderamento, vitórias de curto prazo, consolidação e ancoragem na cultura.
13. **O que é a lei da inércia na mobilização?** É preciso mais força para iniciar o movimento do que para mantê-lo.
14. **Quais dois erros comuns na condução da mudança?** Instabilidade parcial e estabilidade prematura.
15. **O que significam high concept e high touch?** Criar conceitos e narrativas a partir de padrões; empatia e sutileza humana.
16. **Quem são os techies e os fuzzies?** Pensamento técnico e pensamento de humanidades, que precisam se complementar.
17. **Qual armadilha clássica de projetos de IA?** Partir de uma tecnologia em busca de um problema.
18. **O que medir num projeto de dados além da acurácia?** A adoção: quantas pessoas usam e se o uso muda decisões.
19. **Qual pergunta de governança surge com algoritmos?** Quem decide quando o algoritmo discorda do especialista.
20. **Por que gerar vitórias de curto prazo?** Para dar credibilidade à mudança e manter a mobilização.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/gestao-da-mudanca


# IA, LGPD e Compliance

> Como usar IA dentro da lei — princípios e bases legais da LGPD, dados pessoais em modelos e RAG, decisões automatizadas, supervisão humana, riscos, drift e um checklist antes de ir para produção.

## Visão geral

Colocar IA em produção exige três tipos de prova: **desempenho técnico** (o modelo acerta?), **desempenho organizacional** (gera resultado?) e **legitimidade jurídica e institucional** (é permitido e justo?). A LGPD (Lei nº 13.709/2018) é o marco brasileiro para o terceiro ponto sempre que houver dado pessoal.

A lógica de trabalho é: **princípio → pergunta de projeto → controle**.

## Lendo números de adoção sem se enganar

- Indicadores de pesquisas de mercado (uso de IA, impacto no lucro, empresas de alto desempenho) **não formam um funil**: são perguntas diferentes.
- Diferença de pontos percentuais não é crescimento percentual: de 15% para 34% são **19 p.p.**, não "19% de crescimento".
- "X% das horas têm potencial técnico de automação" **não** é previsão de desemprego: faltam viabilidade econômica, organizacional e jurídica.
- Dados de países diferentes, com anos e metodologias diferentes, não são comparáveis.

## Conceitos técnicos que importam para a lei

- **Treinamento** e **fine-tuning** alteram os parâmetros do modelo; o **RAG** não, por si só.
- O RAG pode **vazar dado** se ignorar permissões: um usuário não pode receber um trecho de documento que não poderia ver.
- **Data drift**: a distribuição das entradas muda. **Concept drift**: muda a relação entre entrada e saída. Os dois exigem **monitoramento** depois do deploy.
- **DSS** (sistema de apoio à decisão: o humano decide) × **ADM** (decisão automatizada: o sistema decide). Atenção ao **viés de automação** — aceitar a sugestão da máquina sem pensar.

## LGPD em 10 princípios (art. 6º)

Finalidade, adequação, necessidade, livre acesso, qualidade dos dados, transparência, segurança, prevenção, não discriminação, responsabilização e prestação de contas.

Cada princípio vira uma pergunta de projeto. Ex.: *necessidade* → "o modelo precisa mesmo do CPF ou basta um identificador interno?".

## Dados pessoais: o que conta

- **Pseudonimizado** (trocar nome por código, mantendo a chave) **continua sendo dado pessoal**.
- **Anonimizado** de forma irreversível deixa de ser.
- **Dado inferido** (o que o modelo deduz sobre a pessoa) também é coberto pela lei.
- **Dados sensíveis** (saúde, origem racial, religião, biometria, entre outros) têm regras mais rígidas.

## Bases legais

- O **consentimento não é a base universal**: há outras hipóteses nos arts. 7º (dados pessoais) e 11 (dados sensíveis), como execução de contrato, obrigação legal e legítimo interesse.
- **Legítimo interesse não serve como base geral para dado sensível.**

## Decisões automatizadas (art. 20)

O titular pode pedir **revisão** de decisões tomadas unicamente com base em tratamento automatizado que afetem seus interesses, e tem direito a informações sobre os **critérios e procedimentos** usados, respeitados os segredos comercial e industrial. A ANPD pode fazer auditoria. O texto atual não exige que a revisão seja feita por uma pessoa natural, mas a governança deve definir quem revisa.

## Três perguntas ao contratar uma solução de IA

1. Quais dados **ajustam** o modelo (treino e fine-tuning)?
2. Quais dados são **recuperados** durante o uso (RAG, conectores)?
3. Quais dados são **enviados ao fornecedor** na inferência — e ele os usa para treinar?

Usar ChatGPT, Claude, Gemini ou similares em geral implica **transferência internacional** de dados e dependência dos termos do fornecedor.

## Quando usar cada técnica

- **Fine-tuning**: taxonomias e tarefas estáveis (ex.: classificar fraude).
- **RAG**: documentos que mudam com frequência.
- **Treinamento do zero**: capacidades gerais (raro fora de grandes empresas).

## Supervisão humana

| Nível | Papel do humano | Quando |
|---|---|---|
| *Human in the loop* | integra cada decisão | alto impacto |
| *Human on the loop* | supervisiona e pode intervir | impacto moderado |
| *Human out of the loop* | não intervém | só baixo impacto e com controles |

Nenhuma dessas siglas é garantia jurídica por si: o que vale é a governança documentada. **Quem responde pela decisão de um agente de IA?** Quem a governança indicar — o sistema não tem personalidade jurídica.

## Riscos e impactos

- **Avaliação de risco** (*risk assessment*): eventos adversos possíveis e sua mitigação.
- **Avaliação de impacto** (*impact assessment*): efeito sobre pessoas e direitos. Na LGPD, o **RIPD** (relatório de impacto à proteção de dados).
- **Prova por evidência**: hipótese → protocolo de teste → execução → achados → mitigação. Ambientes de **sandbox regulatório** testam soluções sob supervisão, mas **não são aprovação comercial**.

## Checklist antes de colocar em produção

1. A **finalidade** está definida e documentada?
2. Os dados usados são os **necessários** (e só eles)?
3. Qual a **base legal**?
4. Os **titulares** foram informados?
5. Qual o **papel de cada fornecedor** (controlador, operador)?
6. Há **transferência internacional**?
7. **Riscos e discriminação** foram testados?
8. Os **direitos** dos titulares (acesso, correção, revisão) são viáveis na prática?
9. Há **segurança e logs** de auditoria?
10. O **RIPD** e as medidas estão documentados?

## Perguntas de revisão

1. **Indicadores de adoção de IA formam um funil?** Não; são indicadores distintos, de perguntas diferentes.
2. **Ir de 15% para 34% é crescer 19%?** Não; são 19 pontos percentuais.
3. **Potencial técnico de automação é previsão de desemprego?** Não; faltam viabilidade econômica, organizacional e jurídica.
4. **Qual a diferença entre data drift e concept drift?** Data drift: mudam as entradas; concept drift: muda a relação entre entrada e saída.
5. **O que distingue DSS de ADM?** No DSS o humano decide; na ADM o sistema decide.
6. **O RAG elimina o risco com dados pessoais?** Não; pode recuperar documentos indevidos se ignorar permissões.
7. **Treinamento, fine-tuning e RAG alteram os parâmetros?** Treinamento e fine-tuning sim; RAG não.
8. **Quais as três perguntas ao contratar IA?** Que dados ajustam o modelo, quais são recuperados no uso e quais vão ao fornecedor na inferência.
9. **Dado pseudonimizado é anônimo?** Não; continua sendo dado pessoal.
10. **Dados inferidos pelo modelo são protegidos?** Sim, também são cobertos pela LGPD.
11. **Quais os princípios do art. 6º da LGPD?** Finalidade, adequação, necessidade, livre acesso, qualidade, transparência, segurança, prevenção, não discriminação e responsabilização.
12. **O consentimento serve para tudo?** Não; há outras bases legais nos arts. 7º e 11.
13. **Legítimo interesse vale para dado sensível?** Não como base geral.
14. **O que garante o art. 20?** Revisão de decisões automatizadas e informação sobre os critérios usados.
15. **Usar um LLM de mercado implica o quê?** Em geral, transferência internacional e dependência dos termos do fornecedor.
16. **Quando usar human in the loop?** Em decisões de alto impacto.
17. **Quem responde pela decisão de um agente de IA?** Quem a governança documentada indicar.
18. **Qual a diferença entre avaliação de risco e de impacto?** Risco olha eventos adversos e mitigação; impacto olha o efeito sobre pessoas e direitos.
19. **Sandbox regulatório é aprovação?** Não; é um ambiente supervisionado de testes.
20. **Por que monitorar o modelo depois do deploy?** Porque o drift degrada o desempenho e pode gerar decisões erradas.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/ia-lgpd-compliance


# Business Case de Projetos de Dados

> Como estruturar um business case aplicado — problema A→B→C, contexto, objetivo, diagnóstico com evidências, método, plano de implantação, resultados e sumário executivo, com regras de dados e ética.

## Visão geral

Um **business case** é um trabalho aplicado: parte de um **problema ou oportunidade real**, mostra com evidências que ele existe, propõe um método para resolvê-lo, planeja a implantação e apresenta resultados reais ou projetados. Em ciência de dados, é a ponte entre o modelo e a decisão de negócio.

O que diferencia um bom business case é o **fio condutor**: temática, problema, contexto, objetivo, diagnóstico, método, plano e resultados conversam entre si do começo ao fim.

## Estrutura

1. **Sumário executivo** — escrito **por último**.
2. **Introdução**.
3. **Desenvolvimento**.
4. **Discussão dos resultados**.
5. **Considerações finais**.
6. **Referências**.
7. **Apêndice** (material próprio necessário à compreensão) e **anexo** (material ilustrativo, não necessariamente próprio) — opcionais.

## Introdução: do geral ao específico

- **Temática geral e recorte**: o assunto amplo e a fatia que você vai atacar.
- **Problema ou oportunidade**, com a fórmula: **"o problema A gera o efeito B, com impacto em C"**.
  - Ex.: *a previsão manual de demanda (A) gera excesso de estoque (B), com impacto de X% no capital de giro (C).*
- **Contexto**: do cenário amplo (setor, mercado) ao ambiente específico, com dados.
- **Objetivo geral**: **uma** ação no infinitivo que resolve o problema ou materializa a oportunidade ("desenvolver um modelo de previsão de demanda semanal para...").

## Desenvolvimento: quatro elementos

1. **Caracterização do objeto**: setor, organização, porte, produto, indicadores, partes interessadas.
2. **Diagnóstico**: evidências de que é um **problema, e não um sintoma** — análise exploratória de dados, indicadores, relatórios, entrevistas, SWOT, diagrama de Ishikawa.
3. **Métodos**: sequência lógica de etapas, dados e ferramentas **aderentes ao problema**. Uma tabela *fase × atividade × ferramenta* ajuda, sempre com texto explicando cada linha. O método deve ser detalhado o bastante para ser **replicado** em outra organização semelhante.
4. **Plano de implantação** (quando aplicável): etapas, coleta de dados, responsáveis, recursos, prazos, monitoramento, riscos e ajustes. Se usou IA na elaboração, declare aqui.

## Discussão dos resultados

- Resultados reais ou projetados; comparação **antes × depois** ou cenário projetado.
- Análise crítica, viabilidade, benefícios tangíveis e intangíveis.
- Os **indicadores usados no diagnóstico devem reaparecer aqui** — é isso que fecha o fio condutor.
- Resultado ruim ou indicador que não melhorou também vale, se for **explicado e rastreável**.
- Plano não implantado é aceitável com justificativa plausível e projeção fundamentada (dados de teste, benchmarks, consulta a especialistas).

## Considerações finais

Contribuições, implicações gerenciais, técnicas e econômicas, **limitações** e estudos futuros.

## Sumário executivo

Cerca de 250 palavras (uma página): problema → contexto → desenvolvimento (diagnóstico, método, proposta) → principais resultados → conclusão. Quem lê só ele precisa entender o caso inteiro.

## Dados, sigilo e ética

- Use **dados reais**. Cenários e simulações podem ser **projetados a partir** de dados reais; inventar dados não é aceitável.
- **Dados públicos** são uma ótima opção (séries temporais, previsão de demanda, bases abertas de governo).
- Dados de uma empresa exigem **autorização formal** (termo de anuência) e, em geral, não citar o nome da empresa nem detalhes que a identifiquem.
- **Dados sigilosos**: apresente em percentual de uma base ou multiplicados por um **fator de conversão justificado**, avisando no texto que valores foram transformados.
- **Dados pessoais ou sensíveis** (ex.: saúde) pedem cuidado ético e jurídico — ver LGPD.
- Reaproveitar trabalho próprio só como base ou comparação, citando; repetir resultados é autoplágio.
- **IA na escrita**: ajuda em fluência e estrutura, mas o autor escreve primeiro e valida depois; **confira todas as referências** (a IA pode inventar) e declare o uso.

## Para um business case de machine learning

- **Diagnóstico**: EDA (distribuições, correlações, sazonalidade, outliers, qualidade dos dados) e o **erro do método atual** como linha de base.
- **Método**: preparação de dados, validação sem vazamento (temporal, se for série), **comparação de vários modelos**, métricas, análise de erro e interpretabilidade.
- **Plano**: como o modelo entra na rotina — frequência, quem usa, limites de ação, monitoramento de drift — e como conduzir a adoção (gestão da mudança).
- **Resultados**: desempenho no teste e, se possível, piloto; senão, ganho projetado com base no teste.

## O que costuma ser avaliado

- Fio condutor e coerência entre as partes.
- **Rastreabilidade**: afirmações apoiadas em dados, relatórios e literatura.
- Ferramentas aderentes ao problema e método replicável.
- Tabelas e figuras **introduzidas e comentadas** no texto, não apenas coladas.
- **Entregar o que o objetivo promete.**
- Referências consistentes (tudo que é citado aparece na lista, e vice-versa) e linguagem objetiva.

## Perguntas de revisão

1. **O que é um business case aplicado?** Um trabalho que parte de um problema real, diagnostica com evidências, propõe método, planeja a implantação e apresenta resultados.
2. **Qual a fórmula do problema?** O problema A gera o efeito B, com impacto em C.
3. **Quais os três elementos da introdução?** Problema ou oportunidade, contexto e objetivo geral.
4. **Como deve ser o objetivo geral?** Uma única ação no infinitivo que resolve o problema.
5. **Quais os quatro elementos do desenvolvimento?** Caracterização do objeto, diagnóstico, métodos e plano de implantação.
6. **Por que o diagnóstico é essencial?** Para provar com evidências que se trata de um problema, e não de um sintoma.
7. **Que ferramentas ajudam no diagnóstico?** EDA, indicadores, relatórios, entrevistas, SWOT e Ishikawa.
8. **Quão detalhado deve ser o método?** O bastante para ser replicado em outra organização semelhante.
9. **Qual seção se escreve por último?** O sumário executivo.
10. **Qual o tamanho do sumário executivo?** Cerca de 250 palavras, uma página.
11. **O que fecha o fio condutor?** Os indicadores do diagnóstico reaparecerem na discussão dos resultados.
12. **Resultado ruim invalida o trabalho?** Não, se for explicado e rastreável.
13. **Pode-se inventar dados?** Não; cenários só podem ser projetados a partir de dados reais.
14. **Como apresentar dados sigilosos?** Em percentual de uma base ou com um fator de conversão justificado, avisando no texto.
15. **O que é preciso para usar dados de uma empresa?** Autorização formal e, em geral, não identificar a empresa.
16. **Qual a diferença entre apêndice e anexo?** Apêndice é material próprio; anexo é ilustrativo e pode ser de terceiros.
17. **Como usar IA na escrita?** Como apoio de fluência e estrutura, validando tudo e conferindo cada referência, com declaração do uso.
18. **O que é a linha de base num business case de ML?** O desempenho do método atual, contra o qual o modelo é comparado.
19. **O plano de implantação precisa estar executado?** Não; pode ser projetado, com justificativa plausível.
20. **Por que comparar vários modelos?** Para mostrar que a escolha é fundamentada, e não a primeira que funcionou.

---
Fonte: Atlas de Dados — https://atlas.frediania.com/materia/business-case
