AI / ML / DL

Cheat Sheet Completo v3 — Hiperparâmetros, Normalização, Distribuição & Pacotes Python/R
🧠 Inteligência Artificial
📊 Machine Learning
🔬 Deep Learning
🧠 Inteligência Artificial — Técnicas Clássicas
TIPO Categoria
TAREFA O que resolve
DOMÍNIO Aplicação
COMPLEX. Complexidade
HIPER. Hiperparâmetros
NORM. Obrigatório
NORM. Não necessário
DISTRIB. Sensibilidade
PYTHON/R Pacotes
🔍 Busca e Planejamento
BFS — Breadth-First Search
Explora todos os nós por nível. Garante caminho mais curto em grafos não-ponderados.
Busca Cega Caminho Mínimo Grafos / Rotas O(V+E)
Completo:Sim Ótimo:Sim (custos iguais) Memória:O(b^d) — exponencial Hiper.:Nenhum (método exato) Python:networkx (nx.bfs_edges), collections.deque, igraph R:igraph (bfs), cppRouting
Fila FIFO → Expandir nó → Enfileirar filhos → Testar objetivo
DFS — Depth-First Search
Explora o mais fundo possível antes de retroceder. Menos memória, não garante ótimo.
Busca Cega Exploração Puzzles / Grafos O(V+E)
Completo:Não (pode ciclar) Ótimo:Não Memória:O(b·m) — linear Hiper.:depth_limit (DLS/IDDFS) Python:networkx (nx.dfs_edges), igraph, recursão nativa R:igraph (dfs), cppRouting
Pilha LIFO → Expandir nó → Empilhar filhos → Backtrack
A* Search
Busca informada: g(n) + h(n). Ótimo e completo com heurística admissível.
Busca Heurística Caminho Ótimo Navegação / Jogos / Robótica
f(n) = g(n) + h(n)  |  h(n) ≤ h*(n) admissível
Heurísticas:Manhattan, Euclidiana, Chebyshev, Octile Hiper.:Escolha de h(n), peso w para WA* Python:networkx (nx.astar_path), python-astar, heapq R:igraph, cppRouting, astar (custom)
IDA* / Uniform Cost (Dijkstra) / Greedy
IDA*: A* com memória linear. UCS/Dijkstra: menor custo g(n). Greedy: só h(n), rápido mas não ótimo.
Busca Caminhos Redes / Puzzles
UCS: f(n)=g(n)  |  Greedy: f(n)=h(n)  |  IDA*: threshold crescente
Python:networkx (nx.dijkstra_path, nx.shortest_path), scipy.sparse.csgraph R:igraph (shortest_paths), cppRouting, Rgraphviz
STRIPS / Planejamento / Beam Search
STRIPS: ações com pré-condições e efeitos (PDDL). Beam: mantém w melhores candidatos por nível.
Planejamento / Busca Sequenciamento / Decodif. Robótica / NLP
Beam Hiper.:w (beam width, 4-10) Python:pyperplan (PDDL), unified-planning, pddlgym, transformers (beam search em generate()) R:Não há pacote padrão (custom implementation)
Estado Inicial → Precondições → Efeitos → Objetivo
🎮 Teoria de Jogos e Decisão
Minimax / Alpha-Beta Pruning
Minimax: MAX vs MIN em soma zero. Alpha-Beta poda ramos irrelevantes, O(b^m) → O(b^(m/2)).
Busca Adversarial Decisão em Jogos Xadrez / Damas / Go O(b^m)
minimax(s) = max_a min_b U(s,a,b)  |  Podar se α ≥ β
Hiper.:depth_limit, função de avaliação heurística Python:python-chess (chess.engine), easyAI, OpenSpiel R:Não há pacote padrão (custom)
Monte Carlo Tree Search (MCTS)
Simulações aleatórias constroem árvore. UCB balanceia exploração/explotação. Base do AlphaGo.
Busca Estocástica Jogos Complexos Go / Poker
UCB1 = X̄i + C·√(ln N / ni)
Hiper.:C (~√2), n_simulations (1K-100K), rollout_depth Python:mcts, OpenSpiel, PettingZoo, custom R:Não há pacote padrão
Selection → Expansion → Simulation → Backpropagation
Expectimax
Minimax com nós de chance (dados, cartas). Calcula valor esperado nas transições aleatórias.
Adversarial + Chance Jogos Estocásticos
E[v] = Σ P(si) · V(si)
Python:Custom implementation, OpenSpiel R:Custom implementation
📜 Lógica e Representação de Conhecimento
Lógica Proposicional / FOL
Proposicional: V/F + conectivos, SAT. FOL: quantificadores, predicados, unificação. Semi-decidível.
Lógica Formal Inferência / Prova Verificação / Prolog
Modus Ponens: (P→Q) ∧ P ⊢ Q  |  FOL: ∀x[H(x)→M(x)]
Python:pysat (SAT), z3-solver (SMT), sympy.logic, pyDatalog, pyswip (SWI-Prolog) R:Não há pacote padrão. Interfaces: rswipl (Prolog)
Redes Bayesianas / HMM
Bayes Net: DAG probabilístico. HMM: estados ocultos + emissões, prop. de Markov.
Modelo Probabilístico Incerteza / Sequências Diagnóstico / Fala / Genômica
P(X1,...,Xn) = Π P(Xi|Parents(Xi))  |  Viterbi: argmax P(Q|O)
HMM Hiper.:n_states, n_iter (EM), covariance_type Distribuição:BN: qualquer conjunta. HMM: Gaussian, Multinomial, GMM Python BN:pgmpy, pomegranate, bnlearn (py), causalnex R BN:bnlearn, gRain, deal, pcalg Python HMM:hmmlearn, pomegranate, pyhsmm R HMM:depmixS4, HMM, seqHMM, mhsmm
Sist. Especialistas / Ontologias / Knowledge Graphs
Especialistas: regras SE-ENTÃO. Ontologias: OWL/RDF. KG: triplas (s, p, o).
Repr. Conhecimento Diagnóstico / Semântica Medicina / Web
Python:experta (regras), owlready2 (OWL), rdflib (RDF/SPARQL), networkx, py2neo (Neo4j) R:rrdf, rdflib (via reticulate), neo4r (Neo4j)
⚡ Otimização e Metaheurísticas
Algoritmos Genéticos (GA)
Evolução: seleção + crossover + mutação. Cada indivíduo = solução candidata.
Computação Evolutiva Otimiz. Global Engenharia / Scheduling
Hiper.:pop_size (50-200), crossover_rate (0.6-0.9), mutation_rate (0.01-0.1), elite_size, tournament_k Distribuição:Não-paramétrico Python:deap, pygad, pymoo, geneticalgorithm, inspyred R:GA, genalg, ecr, nsga2R, rmoo
Pop Inicial → Fitness → Seleção → Crossover → Mutação → Nova Geração
Simulated Annealing / Tabu Search
SA: aceita piores com prob. decrescente. Tabu: lista proíbe movimentos recentes.
Metaheurística Otimiz. Combinatória TSP / VRP
SA: P(aceitar) = exp(−ΔE / T)
SA Hiper.:T_initial, T_min, cooling_rate (0.9-0.999) Tabu Hiper.:tabu_list_size (5-20), max_iter Python:scipy.optimize.dual_annealing, simanneal, optuna, tabu-search R:GenSA, optimization, tabuSearch
PSO / ACO
PSO: partículas com pBest/gBest. ACO: formigas + feromônio + evaporação.
Inteligência de Enxame Otimiz. Contínua / Comb. Engenharia / Roteamento
PSO: vi = w·vi + c1·r1·(pBest−xi) + c2·r2·(gBest−xi)
PSO Hiper.:n_particles (20-50), w (0.4-0.9), c1 (~2), c2 (~2) ACO Hiper.:n_ants, α, β, ρ (0.1-0.5) Python:pyswarms (PSO), pymoo, pants (ACO), inspyred R:pso, metaheuristicOpt, irace
Hill Climbing / ES / GP
HC: busca local gulosa. ES: mutação gaussiana. GP: evolui árvores de expressão.
Local / Evolutiva Otimização
ES Hiper.:μ, λ, σ (auto-adaptativo) GP Hiper.:pop_size, max_depth Python:deap (ES+GP), gplearn (GP simbólica), cma (CMA-ES), pymoo R:gramEvol, rgp, cmaes, ecr
🌀 Lógica Fuzzy, CSP e Outros
Lógica Fuzzy
Pertinência [0,1]. Regras linguísticas SE-ENTÃO. Controle sem modelo matemático preciso.
Raciocínio Aproximado Controle Automação / Industrial
μ_A(x) ∈ [0,1]  |  SE temp=ALTA ENTÃO válvula=ABERTA
Hiper.:Funções pertinência, regras, defuzzificação (centróide/MOM) Python:scikit-fuzzy, fuzzylogic, simpful R:FuzzyR, sets, frbs
Fuzzificação → Regras → Inferência → Defuzzificação
CSP / CBR / Sistemas Multi-Agente
CSP: AC-3, MRV. CBR: 4Rs. MAS: agentes autônomos cooperando.
Restrições / Analógico / Agentes Sudoku / Diagnóstico / Simulação
Python:python-constraint (CSP), mesa (MAS), SPADE (MAS), JADE (Java) R:Não há pacotes padrão (custom / reticulate)
📊 Machine Learning — Algoritmos e Técnicas
TIPO Categoria
TAREFA O que resolve
DOMÍNIO Aplicação
COMPLEX. Complexidade
HIPER. Hiperparâmetros
NORM. Obrigatório
NORM. Não necessário
DISTRIB. Sensibilidade
PYTHON/R Pacotes
📈 Supervisionado — Regressão
Regressão Linear
Modelo linear, minimiza MSE (OLS). Simples, interpretável, solução fechada.
Supervisionado Regressão Finanças / Previsão O(n·p²)
y = β₀ + β₁x₁ + ... + βₚxₚ  |  MSE = (1/n)Σ(yi−ŷi)²
Hiper.:fit_intercept (True), positive (False) Normaliz.:Recomendado se features em escalas diferentes Distribuição:ASSUME: resíduos normais, homocedasticidade, independência, linearidade, sem multicolinearidade Python:sklearn.linear_model.LinearRegression, statsmodels.OLS, numpy.linalg.lstsq R:stats::lm(), broom, caret, tidymodels
Ridge (L2) / Lasso (L1) / ElasticNet
Ridge: Σβj², mantém features. Lasso: Σ|βj|, zera coefs. ElasticNet: combina ambos.
Supervisionado Regressão Regularizada
Ridge: +λ·Σβj²  |  Lasso: +λ·Σ|βj|  |  EN: α·L1+(1−α)·L2
Hiper.:alpha (1e-4 a 1e4, CV!), l1_ratio (EN, 0-1), max_iter, solver Normaliz.:OBRIGATÓRIO (regularização sensível a escala!) Distribuição:Mesmas da reg. linear. Lasso assume esparsidade Python:sklearn.linear_model.Ridge/Lasso/ElasticNet/RidgeCV/LassoCV, statsmodels R:glmnet::glmnet(alpha=0/1/0.5), MASS::lm.ridge, caret, tidymodels
🎯 Supervisionado — Classificação
Regressão Logística
Sigmoid → probabilidade. Decision boundary linear. Extensível via softmax (multiclasse).
Supervisionado Classif. Binária / Multi Medicina / Crédito / Spam O(n·p)
P(y=1|x) = 1/(1+e^(−w^T·x−b))  |  BCE = −[y·log(p)+(1−y)·log(1−p)]
Hiper.:C (0.001-1000), penalty (l1/l2/elasticnet/none), solver (lbfgs/liblinear/saga), max_iter, class_weight Normaliz.:OBRIGATÓRIO (com regularização) Distribuição:NÃO assume normalidade. ASSUME linearidade do log-odds Python:sklearn.linear_model.LogisticRegression, statsmodels.Logit, torch.nn (custom) R:stats::glm(family=binomial), glmnet, caret, tidymodels, nnet::multinom
KNN — K-Nearest Neighbors
Voto majoritário dos K vizinhos. Lazy learner. Sensível a escala e maldição da dimensionalidade.
Supervisionado Classif. / Regressão Recomendação / Imputação O(n·d)/query
d(x,y) = √Σ(xi−yi)²  |  ŷ = mode(K vizinhos)
Hiper.:n_neighbors (3-15, ímpar, CV!), weights (uniform/distance), metric, p, leaf_size, algorithm Normaliz.:OBRIGATÓRIO (StandardScaler ou MinMaxScaler) Distribuição:NENHUMA. Não-paramétrico Python:sklearn.neighbors.KNeighborsClassifier/Regressor, annoy (ANN), faiss R:class::knn, caret, kknn, FNN, tidymodels
Naive Bayes
Bayes + independência condicional. Rápido, excelente para texto mesmo violando suposição.
Supervisionado Classificação Texto / Spam / Sentimento O(n·p)
P(C|X) ∝ P(C) · Π P(xi|C)
Hiper.:alpha (Laplace, 0.01-10), var_smoothing (Gaussian, 1e-9), fit_prior, class_prior Normaliz.:NÃO necessário (Multi/Bern). GaussianNB: recomendado Distribuição:ASSUME independência condicional. GaussianNB: features NORMAIS. MultinomialNB: contagens Python:sklearn.naive_bayes.GaussianNB/MultinomialNB/BernoulliNB/ComplementNB R:e1071::naiveBayes, naivebayes, klaR, caret, tidymodels
SVM — Support Vector Machine
Hiperplano de máxima margem. Kernel trick: RBF, Poly. Eficaz em alta dimensionalidade.
Supervisionado Classif. / Regressão Texto / Imagem / Bio O(n²·p)~O(n³)
max 2/‖w‖ s.t. yi(w^T·xi+b) ≥ 1  |  K(x,z) = φ(x)^T·φ(z)
Hiper.:C (0.01-1000), kernel (linear/rbf/poly), gamma ('scale'/'auto'), degree (poly, 2-5) Normaliz.:OBRIGATÓRIO (StandardScaler) Distribuição:NENHUMA suposição. Não-paramétrico Python:sklearn.svm.SVC/SVR/LinearSVC, thundersvm (GPU), libsvm R:e1071::svm, kernlab::ksvm, caret, tidymodels, liquidSVM
Decision Tree (Árvore de Decisão)
Splits recursivos. Interpretável, sem normalização, captura interações naturalmente.
Supervisionado Classif. / Regressão Crédito / Diagnóstico O(n·p·log n)
Gini = 1−Σpk²  |  Entropia = −Σpk·log₂(pk)
Hiper.:criterion (gini/entropy), max_depth (3-20), min_samples_split, min_samples_leaf, ccp_alpha, max_features Normaliz.:NÃO necessário Distribuição:NENHUMA. Não-paramétrico Python:sklearn.tree.DecisionTreeClassifier/Regressor, dtreeviz (visualização), graphviz R:rpart, rpart.plot, party::ctree, C50, tidymodels
Random Forest
Ensemble de árvores: bagging + random features. Robusto, versátil, OOB estimate.
Ensemble — Bagging Classif. / Regressão Tabular / Genômica O(T·n·p·log n)
ŷ = mode(h₁,...,hT)  |  Cada ht: bootstrap + √p features
Hiper.:n_estimators (100-1000), max_depth (None/10-30), max_features ('sqrt'/'log2'), min_samples_split, oob_score Normaliz.:NÃO necessário Distribuição:NENHUMA. Não-paramétrico. Robusto a outliers Python:sklearn.ensemble.RandomForestClassifier/Regressor, skranger (ranger wrapper) R:randomForest, ranger (mais rápido!), randomForestSRC, caret, tidymodels
Gradient Boosting (GBDT)
Árvores sequenciais corrigindo resíduos via gradient descent funcional.
Ensemble — Boosting Classif. / Regressão Tabular
Fm(x) = Fm-1(x) + η·hm(x)
Hiper.:n_estimators (100-5000), learning_rate (0.01-0.3), max_depth (3-8), subsample Normaliz.:NÃO necessário Distribuição:NENHUMA Python:sklearn.ensemble.GradientBoostingClassifier/Regressor, HistGradientBoosting (sklearn) R:gbm, caret, tidymodels
XGBoost
GBDT otimizado: regulariz. L1/L2, NaN nativo, GPU. Rei do tabular e competições.
Ensemble — Boosting Classif. / Reg. / Ranking Kaggle / Indústria
Obj = Σ L(yi,ŷi) + Σ[γ·T + 0.5·λ·‖w‖²]
Hiper.:eta (0.01-0.3), max_depth (3-10), min_child_weight, subsample, colsample_bytree, lambda (L2), alpha (L1), gamma Normaliz.:NÃO necessário Distribuição:NENHUMA Python:xgboost (xgb.XGBClassifier/Regressor, DMatrix), optuna (tuning) R:xgboost::xgb.train/xgboost, caret, tidymodels
LightGBM / CatBoost
LightGBM: GOSS+EFB, leaf-wise, rápido. CatBoost: Ordered Target Encoding, menos tuning.
Ensemble — Boosting Classif. / Regressão Dados c/ Categóricas
LGBM Hiper.:num_leaves (31), learning_rate, min_child_samples, feature_fraction, reg_alpha/lambda CatBoost Hiper.:iterations (1000), depth (6), l2_leaf_reg, cat_features Normaliz.:NÃO necessário (ambos) Distribuição:NENHUMA (ambos) Python:lightgbm (lgb.LGBMClassifier), catboost (CatBoostClassifier/Pool) R:lightgbm::lgb.train, catboost::catboost.train, caret, tidymodels
AdaBoost / Bagging / Stacking
AdaBoost: pesos em amostras erradas. Bagging: bootstrap+voto. Stacking: meta-learner.
Ensemble Combinação
AdaBoost: αt = 0.5·ln((1−εt)/εt)
Ada Hiper.:n_estimators (50-500), learning_rate, estimator (stump) Stacking Hiper.:estimators, final_estimator, cv Normaliz.:Depende dos modelos base Distribuição:Depende dos modelos base Python:sklearn.ensemble.AdaBoostClassifier, BaggingClassifier, StackingClassifier/VotingClassifier R:ada, adabag, ipred::bagging, caretEnsemble, stacks (tidymodels)
🔮 Não-Supervisionado
K-Means
K clusters minimizando inércia. Iterativo: atribui + recalcula centróides.
Não-Supervisionado Clusterização Segmentação / Marketing O(n·K·d·I)
J = Σk Σ_{x∈Ck} ‖x−μk‖²
Hiper.:n_clusters (Elbow/Silhouette), init ('k-means++'), n_init (10), max_iter (300) Normaliz.:OBRIGATÓRIO Distribuição:ASSUME clusters esféricos/convexos de tamanho similar Python:sklearn.cluster.KMeans/MiniBatchKMeans, scipy.cluster.vq, faiss.Kmeans (GPU) R:stats::kmeans, cluster::pam, factoextra, ClusterR, tidymodels
DBSCAN / HDBSCAN
Densidade: clusters arbitrários + outliers (-1). Não precisa K. HDBSCAN: adaptativo.
Não-Supervisionado Cluster + Outliers Geoespacial / Anomalias O(n log n)
DBSCAN Hiper.:eps (k-distance plot!), min_samples (2·dim ou ≥5) HDBSCAN Hiper.:min_cluster_size, min_samples Normaliz.:OBRIGATÓRIO Distribuição:NENHUMA sobre forma Python:sklearn.cluster.DBSCAN/OPTICS, hdbscan, cuml.DBSCAN (GPU) R:dbscan::dbscan/hdbscan, fpc::dbscan, cluster
Hierarchical / GMM
Hierárquico: dendrograma. GMM: mistura de Gaussianas, soft clustering via EM.
Não-Supervisionado Cluster Bioinformática / Fala
GMM: P(x) = Σ πk · N(x|μk, Σk)
Hier. Hiper.:linkage (ward/complete/average), n_clusters ou distance_threshold GMM Hiper.:n_components (BIC/AIC), covariance_type (full/diag) Normaliz.:OBRIGATÓRIO (Ward). GMM: recomendado Distribuição:GMM ASSUME mistura de Gaussianas Python:sklearn.cluster.AgglomerativeClustering, scipy.cluster.hierarchy, sklearn.mixture.GaussianMixture R:stats::hclust, cluster::agnes, mclust (GMM, excelente!), factoextra
PCA / t-SNE / UMAP
PCA: linear, máx variância. t-SNE: não-linear, vizinhança. UMAP: rápido, preserva global.
Não-Supervisionado Redução / Visualização Embeddings
PCA: C·v = λ·v  |  t-SNE: KL(P‖Q)  |  UMAP: topologia
PCA Hiper.:n_components (0.95=95%), svd_solver, whiten t-SNE Hiper.:perplexity (5-50), learning_rate, n_iter UMAP Hiper.:n_neighbors (5-50), min_dist, metric Normaliz.:PCA: OBRIGATÓRIO. t-SNE/UMAP: recomendado Distribuição:PCA: só variância linear. t-SNE/UMAP: nenhuma Python:sklearn.decomposition.PCA, sklearn.manifold.TSNE, umap-learn, openTSNE, cuml (GPU) R:stats::prcomp, Rtsne, uwot::umap, irlba (PCA rápido), FactoMineR
Apriori / FP-Growth / Isolation Forest
Associação: suporte/confiança/lift. Isolation Forest: anomalias com path curto.
Não-Supervisionado Associação / Anomalias Compras / Fraude / IoT
Suporte=freq(X∪Y)/N  |  IsoForest: Score=2^(−E[h]/c(n))
Assoc. Hiper.:min_support, min_confidence, min_lift IF Hiper.:n_estimators, contamination, max_samples Normaliz.:Assoc: N/A. IF: NÃO necessário Distribuição:NENHUMA Python:mlxtend (Apriori/FP-Growth), sklearn.ensemble.IsolationForest, pyod (detecção anomalias) R:arules::apriori, arulesViz, isotree, solitude, caret
🤖 Aprendizado por Reforço
Q-Learning / SARSA
Q-Learning: off-policy, max Q'. SARSA: on-policy, Q(s',a'). TD learning.
Reforço Controle Jogos / Robótica
Q(s,a) ← Q(s,a) + α[r + γ·max Q(s',a') − Q(s,a)]
Hiper.:α (0.01-0.5), γ (0.9-0.999), ε (decay 1.0→0.01) Python:gymnasium (env), stable-baselines3, RLlib, CleanRL, custom numpy R:ReinforcementLearning, MDPtoolbox, gym (via reticulate)
Policy Gradient / Actor-Critic / PPO
REINFORCE: gradiente direto. PPO: clipped objective, estado da arte prático.
Reforço Política Ótima RLHF / Robótica / Games
PPO: L = min(rt·Ât, clip(rt, 1±ε)·Ât)
PPO Hiper.:clip_range (0.1-0.3), lr (3e-4), n_epochs (3-10), γ (0.99), gae_λ (0.95) Python:stable-baselines3 (PPO/A2C/SAC/TD3), CleanRL, RLlib (Ray), TorchRL, trl (RLHF) R:Não há pacote maduro. Usar reticulate → SB3
📐 Avaliação e Pré-processamento
Cross-Validation / Métricas / Tuning
K-Fold, métricas (F1, AUC, MCC), tuning (Grid/Random/Bayesian).
Avaliação Performance
F1 = 2PR/(P+R)  |  AUC-ROC  |  MCC  |  κ = (p0−pe)/(1−pe)
Python:sklearn.model_selection (KFold, cross_val_score, GridSearchCV, RandomizedSearchCV), sklearn.metrics, optuna, hyperopt R:caret::trainControl, yardstick, rsample, tune (tidymodels), mlr3, MLmetrics
Normalização / Feature Engineering / Bias-Variance
Escalonamento, encoding, seleção, imputação. Erro = Bias² + Variância + Ruído.
Pré-processamento / Teoria
StandardScaler:z=(x−μ)/σ. P/: SVM, KNN, PCA, NN MinMaxScaler:[0,1]. P/: NN, imagens NÃO precisa:DT, RF, XGBoost, LightGBM, CatBoost, NB(Multi/Bern) Python:sklearn.preprocessing (Standard/MinMax/RobustScaler, OneHotEncoder, LabelEncoder, OrdinalEncoder), sklearn.impute, sklearn.feature_selection, category_encoders, feature-engine R:recipes (tidymodels), caret::preProcess, mice (imputação), vip, Boruta
🔬 Deep Learning — Arquiteturas e Técnicas
TIPO Categoria
TAREFA O que resolve
DOMÍNIO Aplicação
COMPLEX. Complexidade
HIPER. Hiperparâmetros
NORM. Obrigatório
NORM. Não necessário
DISTRIB. Sensibilidade
PYTHON/R Pacotes
🧩 Fundamentos
MLP — Multilayer Perceptron
Feedforward totalmente conectado. Backpropagation + SGD/Adam.
Feedforward Classif. / Regressão Tabular
a^(l) = σ(W^(l)·a^(l-1) + b^(l))  |  W ← W − η·∂L/∂W
Hiper.:hidden_layers, neurons (64-1024), lr (1e-4 a 1e-2), batch_size (32-256), optimizer (Adam), weight_init (He/Xavier) Normaliz.:OBRIGATÓRIO Distribuição:NENHUMA formal Python:torch.nn (Linear, Sequential), keras/tensorflow, sklearn.neural_network.MLPClassifier R:keras::keras_model_sequential, nnet, neuralnet, torch (R), caret
Otimizadores / LR Schedulers / Regularização
Adam, AdamW, SGD. Dropout, BN, LN, Label Smoothing, Data Augmentation, Transfer Learning.
Componentes DL Generalização
Adam:lr=1e-3, betas=(0.9,0.999) AdamW:lr=1e-4 (fine-tune), weight_decay=0.01-0.1 Dropout:p=0.1 (Transformers) a 0.5 Data Aug:RandAugment, Mixup, CutMix Python:torch.optim (Adam/AdamW/SGD), torch.optim.lr_scheduler, torchvision.transforms, albumentations, timm R:keras::compile(optimizer), luz (R torch wrapper)
🖼️ CNN — Redes Convolucionais
CNN — Convolutional Neural Network
Filtros convolucionais extraem features espaciais. Weight sharing + translation invariance.
Convolucional Classif. / Det. / Segm. Imagens / Vídeo / Médica
out(i,j) = Σ input(i+m,j+n)·kernel(m,n)+b  |  dim_out=(W−K+2P)/S+1
Hiper.:filters (32-512), kernel (3×3), stride (1-2), padding, pool (2×2) Normaliz.:Sim: /255 ou ImageNet stats Distribuição:NENHUMA Python:torch.nn (Conv2d, MaxPool2d), torchvision, keras.layers.Conv2D, timm R:keras::layer_conv_2d, torch::nn_conv2d, luz
Conv → BN → ReLU → Pool → [repetir] → FC → Softmax
ResNet / VGG / Inception / DenseNet / EfficientNet / MobileNet
ResNet: skip conn. VGG: 3×3. Inception: multi-scale. EfficientNet: compound scaling. MobileNet: edge.
CNN Arquiteturas Backbone / Mobile
ResNet: y = F(x) + x  |  EfficientNet: compound scaling d,w,r
Fine-tune:lr_head=1e-3, lr_backbone=1e-5, epochs=20-50 Python:torchvision.models (resnet50, efficientnet_b0, mobilenet_v3), timm (800+ modelos!), keras.applications R:keras::application_resnet50/application_mobilenet_v2, torch::model_resnet18 (torchvision)
📦 Detecção e Segmentação
YOLO / Faster R-CNN / RT-DETR
YOLO: single-shot, real-time. Faster R-CNN: two-stage. RT-DETR: Transformer, sem NMS.
Detecção Objetos Autônomos / Vigilância
YOLO Hiper.:imgsz (640), epochs (100-300), batch (16), lr0 (0.01), conf (0.25), iou (0.45) Métricas:mAP@0.5, mAP@0.5:0.95, FPS Python:ultralytics (YOLOv8/v11), torchvision.models.detection (Faster R-CNN, SSD, FCOS), mmdetection, detectron2 R:Não há pacote nativo. Usar reticulate → ultralytics/detectron2
U-Net / Mask R-CNN / SAM
U-Net: enc-dec + skip (segm. médica). Mask R-CNN: instância. SAM: zero-shot promptable.
Segmentação Semântica / Instância Médica / Satélite
Dice = 1 − 2|X∩Y|/(|X|+|Y|)  |  IoU = |X∩Y|/|X∪Y|
U-Net Hiper.:encoder, decoder_channels, loss (Dice+BCE), lr=1e-4 Python:segmentation_models_pytorch (smp), monai (médica), torchvision (Mask R-CNN), segment-anything (SAM) R:keras (custom U-Net), Não há pacote nativo p/ SAM
🔄 Redes Recorrentes
RNN / LSTM / GRU
RNN: vanishing gradient. LSTM: 3 gates + célula. GRU: 2 gates, mais leve.
Recorrente Sequências NLP / Fala / Séries
LSTM: ft=σ(Wf[ht-1,xt]) | ct=ft·ct-1+it·tanh(...) | ht=ot·tanh(ct)
Hiper.:hidden_size (64-512), num_layers (1-4), dropout (0.1-0.5), bidirectional Normaliz.:Recomendado p/ features de entrada Distribuição:NENHUMA Python:torch.nn (LSTM, GRU, RNN), keras.layers.LSTM/GRU, pytorch-forecasting (séries) R:keras::layer_lstm/layer_gru, torch::nn_lstm, forecast
Seq2Seq + Attention
Encoder→Decoder com mecanismo de atenção. Base pré-Transformer.
Encoder-Decoder Tradução / Sumarização NLP
αij = softmax(score(si,hj))  |  ci = Σ αij · hj
Hiper.:enc/dec hidden (256-1024), attention (bahdanau/luong), teacher_forcing Python:torch.nn (custom), fairseq, OpenNMT-py R:keras (custom), Não há pacote padrão
⚡ Transformers e LLMs
Transformer (2017)
Self-attention paralela. 'Attention Is All You Need'. Base de NLP, CV e multimodal.
Attention-based Tudo
Attn(Q,K,V) = softmax(QK^T/√dk)·V  |  MultiHead = Concat(heads)·WO
Hiper.:d_model (256-4096), nhead (4-64), num_layers (6-96), d_ff (4·d_model), dropout (0.1) Pos Encoding:Sinusoidal, Learned, RoPE, ALiBi Python:torch.nn.Transformer, transformers (HuggingFace), x-transformers, flash-attn R:Não há pacote nativo. Usar reticulate → transformers
Embed → PosEnc → Multi-Head Attn → Add&Norm → FFN → Add&Norm
BERT (Encoder) / GPT (Decoder) / T5 (Enc-Dec)
BERT: bidirecional, MLM. GPT: autorregressivo. T5: text-to-text.
Transformer LLM NLP / Code / Multi 110M → 1.5T+
BERT Fine-tune:lr=2e-5 a 5e-5, epochs=2-4, batch=16-32, warmup=10% GPT Inferência:temperature (0-2), top_p, top_k, repetition_penalty Python:transformers (AutoModel, pipeline, Trainer), sentence-transformers, tokenizers, datasets (HuggingFace) R:text (wraps transformers), tidytext, quanteda (NLP clássico), reticulate → transformers
LLMs: LLaMA / Mistral / DeepSeek / Claude
LLaMA: RoPE+SwiGLU+GQA. Mistral: sliding window. DeepSeek: MoE. Claude: Constitutional AI.
LLM Geração / Instrução / Código 7B → 405B+
Alinhamento:SFT, RLHF, DPO, ORPO, KTO Python:transformers, vllm (inferência rápida), llama.cpp (python-bindings), ollama, text-generation-inference, litellm R:ollamar, ellmer (multi-provider), reticulate → transformers/vllm
LoRA / QLoRA / PEFT
Fine-tuning eficiente: matrizes low-rank. Treina ~1% params. QLoRA: 4-bit + LoRA.
Fine-tuning Eficiente Adaptação LLMs / Difusão
W' = W + B·A  |  B∈ℝ^(d×r), A∈ℝ^(r×d), r ≪ d
Hiper.:r (4-64), lora_alpha (16-64), target_modules (q/k/v_proj), lora_dropout (0.05-0.1) Python:peft (HuggingFace), unsloth (2x faster), axolotl, trl (SFTTrainer), bitsandbytes (QLoRA) R:Não há pacote nativo. reticulate → peft/unsloth
RAG / MoE / Agents
RAG: retriever + LLM. MoE: router + experts. Agents: LLM + tools + planning.
Híbrido / Escalável QA / Eficiência / Autonomia Enterprise
RAG Hiper.:chunk_size (256-1024), top_k (3-10), embedding_model, reranker Python RAG:langchain, llama-index, haystack, chromadb, faiss, pinecone-client, weaviate-client Python Agents:langchain, crewai, autogen, smolagents, openai-agents-sdk R:Não há pacote nativo. reticulate → langchain/llama-index
Query → Embed → VectorSearch → Top-K → LLM+Context → Resposta
👁️ Vision Transformers e Multimodal
ViT / Swin / DeiT
ViT: patches + Transformer puro. Swin: janelas locais O(n). DeiT: distillation.
Vision Transformer Classif. / Det. / Segm. 86M — 197M
ViT Hiper.:patch_size (16/14), image_size (224-384) Fine-tune:lr=1e-5 a 5e-5, aug forte Python:timm (vit_base_patch16_224, swin_base), transformers (ViTForImageClassification), torchvision R:keras (custom), Não há pacote nativo. reticulate → timm
CLIP / VLMs (Multimodais)
CLIP: alinha img+texto contrastivo. VLMs: GPT-4V, Claude, Gemini, LLaVA.
Multimodal Zero-Shot / VQA Visão + Linguagem
CLIP: L = −log[exp(sim(I,T)/τ) / Σ exp(sim(I,Tj)/τ)]
Python:open_clip, transformers (CLIPModel), sentence-transformers (CLIP), openai (API) R:reticulate → open_clip/transformers
🎨 Modelos Generativos
GAN / VAE
GAN: Gerador vs Discriminador. VAE: encoder→latente→decoder, ELBO.
Generativo Geração Arte / Moléculas
GAN: min_G max_D E[log D(x)] + E[log(1−D(G(z)))]  |  VAE: ELBO
GAN Hiper.:latent_dim (100-512), lr_G/lr_D (1e-4), n_critic (WGAN: 5) VAE Hiper.:latent_dim, β (KL weight), recon_loss Distribuição:Latente: N(0,I) Python:torch (custom GAN/VAE), pytorch-lightning, keras, stylegan2-ada-pytorch, pythae (VAE zoo) R:keras (custom), torch (custom), Não há pacote específico
Diffusion Models (DDPM / Stable Diffusion)
Forward: ruído gradual. Reverse: denoise. Latent Diffusion: espaço latente comprimido.
Difusão Geração Img / Vídeo / 3D SD / DALL·E / Midjourney
q(xt|xt-1) = N(√(1−βt)·xt-1, βt·I)
Train Hiper.:T (1000), beta_schedule, lr (1e-4), ema_decay (0.9999) Inference Hiper.:steps (20-50), guidance_scale/CFG (7.5), scheduler (DDIM/DPM-Solver) Python:diffusers (HuggingFace, StableDiffusionPipeline), denoising-diffusion-pytorch, ComfyUI, AUTOMATIC1111 R:Não há pacote nativo. reticulate → diffusers
x₀ → Forward(ruído) → xT → Reverse(denoise) → x₀(gerado)
Normalizing Flows / Autoencoder
Flows: transformações invertíveis. AE: bottleneck + reconstrução.
Generativo / Compressão
Flows:RealNVP, Glow, Flow Matching (Flux, SD3) AE Variantes:Sparse, Denoising, Contractive, VQ-VAE Python:nflows, normflows, flowtorch, torch (custom AE) R:keras (custom AE)
🌐 Grafos, SSM, Áudio e Especiais
GNN / Mamba (SSM) / KAN
GNN: message passing em grafos. Mamba: SSM O(n). KAN: B-splines aprendíveis.
Grafos / SSM / Alternativa Especializados
GNN: hv = UPDATE(hv, AGG({hu : u∈N(v)}))  |  Mamba: x'=Ax+Bu
GNN Hiper.:hidden_channels, num_layers, heads (GAT) Mamba Hiper.:d_model, d_state, d_conv Python GNN:torch_geometric (PyG), dgl, spektral (keras), networkx Python SSM:mamba-ssm, state-spaces/mamba (GitHub), transformers (Jamba) Python KAN:pykan, efficient-kan, torch (custom) R:igraph (grafos clássicos). GNN/Mamba: reticulate → PyG
Whisper / Self-Supervised / Distillation / Quantização
Whisper: STT. SSL: SimCLR, DINO, MAE. Distill: student←teacher. Quant: FP32→INT4.
Áudio / SSL / Compressão ASR / Deploy Edge / Mobile
Contrastive: L = −log[exp(sim/τ)/Σ]  |  Distill: (1−α)·CE + α·T²·KL
Whisper:tiny(39M)→large-v3(1.5B) SSL:SimCLR, DINO(v2), MAE. τ=0.07-0.5 Quant.:PTQ, QAT, GPTQ, AWQ, GGUF, NF4 Python ASR:transformers (WhisperForConditionalGeneration), faster-whisper, whisper.cpp Python SSL:lightly, vissl, solo-learn, timm (DINOv2), transformers (MAE) Python Quant:bitsandbytes, auto-gptq, autoawq, llama.cpp (GGUF), optimum (HuggingFace), onnxruntime, TensorRT R:Não há pacotes nativos. reticulate → transformers/bitsandbytes
AI / ML / DL Cheat Sheet Completo v3 — Prof. Ramon Mayor Martins, Ph.D. — IFSC Campus São José — 2026
Ref: Russell & Norvig (AIMA), Bishop (PRML), Goodfellow (DL Book), Vaswani et al. (2017), scikit-learn / PyTorch / R docs