6 Machine Learning — Módulo completo

📖 Glossário - Machine Learning

A

Acurácia (Accuracy): Proporção de predições corretas (TP+TN / Total).

Ajuste (Fitting): Processo de treinar modelo aos dados.

Algoritmo: Sequência de passos para resolver problema.

Aprendizado Não-Supervisionado: ML sem rótulos (clustering, PCA).

Aprendizado Supervisionado: ML com dados rotulados (classificação, regressão).

Árvore de Decisão: Modelo que toma decisões seguindo estrutura de árvore.

B

Bagging: Técnica de ensemble que treina múltiplos modelos em subamostras.

Baseline: Modelo simples de referência para comparação.

Batch: Subconjunto de dados usado em uma iteração de treinamento.

Bias (Viés): Tendência do modelo a sistematicamente errar em uma direção.

C

Centroide: Centro de cluster em algoritmos de agrupamento.

Classificação: Tarefa de prever categoria/classe.

Cluster: Grupo de dados similares identificado por algoritmo.

Clusterização: Agrupamento de dados por similaridade.

Coeficiente de Silhueta: Métrica de qualidade de clustering (-1 a +1).

Componente Principal: Direção de máxima variância em PCA.

Confusion Matrix (Matriz de Confusão): Tabela mostrando VP, VN, FP, FN.

Cross-Validation (Validação Cruzada): Técnica para avaliar modelo dividindo dados em k-folds.

D

Dataset: Conjunto de dados para treinar/testar modelo.

Decision Boundary (Fronteira de Decisão): Limite que separa classes.

Dendrograma: Diagrama de árvore mostrando agrupamento hierárquico.

Dimensionalidade: Número de features em dataset.

E

Elbow Method (Método do Cotovelo): Técnica para escolher número de clusters.

Ensemble: Combinação de múltiplos modelos para melhorar predições.

Epoch: Uma passagem completa por todos dados de treino.

Erro: Diferença entre predição e valor real.

Escala: Intervalo de valores de variável.

Especificidade: Proporção de negativos corretamente identificados (VN / VN+FP).

Estimador: Algoritmo que aprende de dados (ex: RandomForest, KMeans).

F

F1-Score: Média harmônica de precisão e recall (2×P×R / P+R).

Falso Negativo (FN): Predizer negativo quando é positivo.

Falso Positivo (FP): Predizer positivo quando é negativo.

Feature (Característica): Atributo/variável de entrada no modelo.

Feature Engineering: Criação de novas features a partir das existentes.

Feature Selection: Escolha das features mais relevantes.

Fit: Treinar modelo com dados.

G

Generalização: Capacidade de modelo performar bem em dados novos.

Grid Search: Busca exaustiva por melhores hiperparâmetros.

H

Hiperparâmetro: Configuração externa ao modelo (ex: n_clusters, max_depth).

Holdout: Divisão simples de dados em treino e teste.

I

Inércia: Soma das distâncias quadráticas de pontos aos centroides (KMeans).

Iteração: Repetição de processo de otimização.

K

K-Fold: Técnica de cross-validation com k divisões.

K-Means: Algoritmo de clustering que agrupa em k grupos.

KNN (K-Nearest Neighbors): Algoritmo que classifica baseado em k vizinhos mais próximos.

L

Label (Rótulo): Categoria/valor alvo que queremos prever.

Learning Rate: Taxa de atualização de parâmetros em otimização.

Logistic Regression: Modelo para classificação binária.

M

MAE (Mean Absolute Error): Média dos erros absolutos.

Matriz de Confusão: Ver Confusion Matrix.

Métrica: Medida de performance do modelo.

Modelo: Representação matemática aprendida dos dados.

MSE (Mean Squared Error): Média dos erros quadráticos.

N

Normalização: Ajuste de features para mesma escala (0 a 1).

n_clusters: Número de clusters desejado.

n_components: Número de componentes principais em PCA.

O

Outlier: Ponto muito distante do padrão geral.

Overfitting (Sobreajuste): Modelo muito ajustado aos dados de treino, ruim em generalizar.

P

Parâmetro: Valor interno aprendido pelo modelo (pesos, coeficientes).

PCA (Principal Component Analysis): Técnica de redução de dimensionalidade.

Pipeline: Sequência automatizada de transformações e modelo.

Precisão (Precision): Proporção de positivos preditos que são realmente positivos (VP / VP+FP).

Predição: Saída do modelo para nova entrada.

Predict: Usar modelo treinado para fazer predições.

Pre-processamento: Preparação de dados antes do treino.

R

Random Forest: Ensemble de árvores de decisão.

Random State: Semente para reprodutibilidade.

Recall (Sensibilidade): Proporção de positivos corretamente identificados (VP / VP+FN).

Redução de Dimensionalidade: Diminuir número de features mantendo informação.

Regressão: Tarefa de prever valor numérico contínuo.

RMSE (Root Mean Squared Error): Raiz quadrada de MSE.

ROC Curve: Gráfico de taxa VP vs FP para diferentes thresholds.

R² (R-Squared): Coeficiente de determinação (0 a 1).

S

Scaler: Transformador que ajusta escala de features.

Score: Métrica de avaliação do modelo.

Sensibilidade: Ver Recall.

Silhouette Score: Ver Coeficiente de Silhueta.

StandardScaler: Normalização usando média e desvio padrão (z-score).

Supervisionado: Aprendizado com dados rotulados.

T

Target: Variável que queremos prever.

Test Set (Conjunto de Teste): Dados não usados no treino para avaliar modelo.

Threshold (Limiar): Valor de corte para decisão de classificação.

Train Set (Conjunto de Treino): Dados usados para treinar modelo.

Transformação: Operação aplicada aos dados (normalização, PCA, etc).

True Negative (TN - Verdadeiro Negativo): Predição negativa correta.

True Positive (TP - Verdadeiro Positivo): Predição positiva correta.

U

Underfitting (Subajuste): Modelo muito simples que não captura padrões.

V

Validação: Avaliação de performance do modelo.

Variância Explicada: Proporção de variância capturada por componentes principais.

Viés-Variância: Trade-off entre simplicidade e flexibilidade do modelo.

Fórmulas Essenciais

Métricas de Classificação

Acurácia = (VP + VN) / Total

Precisão = VP / (VP + FP)

Recall = VP / (VP + FN)

F1-Score = 2 × (Precisão × Recall) / (Precisão + Recall)

Especificidade = VN / (VN + FP)

Métricas de Regressão

MAE = Σ|y_real - y_pred| / n

MSE = Σ(y_real - y_pred)² / n

RMSE = √MSE

R² = 1 - (SS_res / SS_tot)

KMeans

Inércia = Σ min(||x - μⱼ||²)
onde μⱼ são os centroides

Silhueta = (b - a) / max(a, b)
a = distância média intra-cluster
b = distância média ao cluster mais próximo

Exemplos Práticos

Classificação Completa

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# Carregar dados
df = pd.read_csv('especies.csv')
X = df[['temperatura', 'salinidade', 'profundidade', 'ph']]
y = df['especie']

# Dividir treino/teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Normalizar
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Treinar modelo
modelo = RandomForestClassifier(n_estimators=100, random_state=42)
modelo.fit(X_train_scaled, y_train)

# Predizer
y_pred = modelo.predict(X_test_scaled)

# Avaliar
print("Acurácia:", modelo.score(X_test_scaled, y_test))
print("\nRelatório de Classificação:")
print(classification_report(y_test, y_pred))

# Matriz de confusão
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title('Matriz de Confusão')
plt.ylabel('Real')
plt.xlabel('Predito')
plt.savefig('confusion_matrix.png', dpi=300, bbox_inches='tight')

# Importância de features
importancias = pd.DataFrame({
    'feature': X.columns,
    'importancia': modelo.feature_importances_
}).sort_values('importancia', ascending=False)

print("\nImportância de Features:")
print(importancias)

Clusterização com K-Means

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# Dados
df = pd.read_csv('locais_coleta.csv')
X = df[['latitude', 'longitude', 'temperatura', 'salinidade']]

# Normalizar
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Método do cotovelo para escolher k
inercias = []
K_range = range(2, 11)

for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X_scaled)
    inercias.append(kmeans.inertia_)

# Plotar cotovelo
plt.figure(figsize=(10, 6))
plt.plot(K_range, inercias, 'bo-')
plt.xlabel('Número de Clusters (k)')
plt.ylabel('Inércia')
plt.title('Método do Cotovelo')
plt.grid(True)
plt.savefig('elbow.png', dpi=300, bbox_inches='tight')

# Aplicar K-Means com k escolhido
k_ideal = 4
kmeans = KMeans(n_clusters=k_ideal, random_state=42)
clusters = kmeans.fit_predict(X_scaled)

# Adicionar clusters ao DataFrame
df['cluster'] = clusters

# Avaliar silhueta
from sklearn.metrics import silhouette_score
silhueta = silhouette_score(X_scaled, clusters)
print(f"Coeficiente de Silhueta: {silhueta:.3f}")

# Plotar clusters
plt.figure(figsize=(12, 8))
scatter = plt.scatter(df['longitude'], df['latitude'], 
                     c=clusters, cmap='viridis', s=100, alpha=0.6)
plt.xlabel('Longitude')
plt.ylabel('Latitude')
plt.title(f'Clusters Identificados (k={k_ideal})')
plt.colorbar(scatter, label='Cluster')
plt.savefig('clusters.png', dpi=300, bbox_inches='tight')

PCA (Redução de Dimensionalidade)

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# Dados com muitas features
df = pd.read_csv('medicoes_complexas.csv')
X = df.drop('especie', axis=1)
y = df['especie']

# Normalizar
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Aplicar PCA
pca = PCA()
X_pca = pca.fit_transform(X_scaled)

# Variância explicada
var_explicada = pca.explained_variance_ratio_
var_acumulada = var_explicada.cumsum()

# Plotar variância
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))

ax1.bar(range(1, len(var_explicada)+1), var_explicada)
ax1.set_xlabel('Componente Principal')
ax1.set_ylabel('Variância Explicada')
ax1.set_title('Variância por Componente')

ax2.plot(range(1, len(var_acumulada)+1), var_acumulada, 'bo-')
ax2.axhline(y=0.95, color='r', linestyle='--', label='95%')
ax2.set_xlabel('Número de Componentes')
ax2.set_ylabel('Variância Acumulada')
ax2.set_title('Variância Acumulada')
ax2.legend()
ax2.grid(True)

plt.savefig('pca_variance.png', dpi=300, bbox_inches='tight')

# Reduzir para 2 componentes
pca_2d = PCA(n_components=2)
X_2d = pca_2d.fit_transform(X_scaled)

print(f"Variância explicada com 2 componentes: {pca_2d.explained_variance_ratio_.sum():.2%}")

# Plotar
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y.astype('category').cat.codes, 
                     cmap='viridis', s=100, alpha=0.6)
plt.xlabel(f'PC1 ({pca_2d.explained_variance_ratio_[0]:.1%})')
plt.ylabel(f'PC2 ({pca_2d.explained_variance_ratio_[1]:.1%})')
plt.title('Dados Projetados em 2 Componentes Principais')
plt.colorbar(scatter, label='Espécie')
plt.savefig('pca_2d.png', dpi=300, bbox_inches='tight')

Pipeline Completo

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

# Criar pipeline
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA()),
    ('classifier', RandomForestClassifier(random_state=42))
])

# Definir grid de hiperparâmetros
param_grid = {
    'pca__n_components': [2, 3, 4, 5],
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [None, 10, 20]
}

# Grid search com validação cruzada
grid_search = GridSearchCV(pipeline, param_grid, cv=5, 
                           scoring='accuracy', n_jobs=-1)
grid_search.fit(X_train, y_train)

# Melhores parâmetros
print("Melhores parâmetros:", grid_search.best_params_)
print("Melhor acurácia:", grid_search.best_score_)

# Avaliar no teste
y_pred = grid_search.predict(X_test)
print("\nAcurácia no teste:", accuracy_score(y_test, y_pred))

Guia de Escolha de Algoritmo

Tarefa	Algoritmo Recomendado
Classificação simples	Logistic Regression, KNN
Classificação complexa	Random Forest, XGBoost
Regressão simples	Linear Regression
Regressão complexa	Random Forest Regressor
Clustering	K-Means, DBSCAN
Redução de dimensionalidade	PCA, t-SNE
Dados desbalanceados	SMOTE + Classificador

💡 Dica: Sempre normalize seus dados antes de aplicar KMeans ou PCA!

🤖 Introdução ao Machine Learning para Biologia

🎯 Objetivo da Lição

Aprender os conceitos fundamentais de Machine Learning e como aplicá-los em problemas de biologia e oceanografia.

O que é Machine Learning? - Algoritmos que aprendem padrões a partir de dados - Fazem previsões sem programação explícita - Melhoram com mais dados e experiência

🧠 Tipos de Machine Learning

1. Aprendizado Supervisionado

Definição: Aprende a partir de exemplos rotulados.

Entrada (X) → Modelo → Saída (y)

Exemplos em Biologia: - Classificar espécies a partir de características morfológicas - Prever biomassa com base em temperatura e salinidade - Identificar imagens de macroalgas

Tipos: - Classificação: Saída categórica (espécie A, B ou C) - Regressão: Saída numérica (biomassa em gramas)

2. Aprendizado Não-Supervisionado

Definição: Encontra padrões em dados sem rótulos.

Exemplos: - Agrupar estações de coleta por similaridade (clustering) - Reduzir dimensionalidade de dados genômicos (PCA) - Detectar anomalias em séries temporais

3. Aprendizado por Reforço

Definição: Aprende por tentativa e erro com recompensas.

Exemplo: Otimizar estratégias de coleta para maximizar biodiversidade.

📊 Workflow de Machine Learning

1. COLETAR DADOS
   ↓
2. EXPLORAR E LIMPAR
   ↓
3. PREPARAR FEATURES (características)
   ↓
4. DIVIDIR: Treino (80%) | Teste (20%)
   ↓
5. ESCOLHER MODELO
   ↓
6. TREINAR MODELO
   ↓
7. AVALIAR DESEMPENHO
   ↓
8. AJUSTAR E MELHORAR
   ↓
9. USAR EM PRODUÇÃO

🔧 Bibliotecas Python para ML

# Instalar
pip install scikit-learn pandas numpy matplotlib seaborn

# Importar
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Machine Learning
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

🎯 Exemplo 1: Classificação de Espécies

Problema

Dado comprimento, largura e espessura de macroalgas, prever a espécie.

Dataset

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report

# Dados sintéticos de 3 espécies
dados = {
    'comprimento_cm': [12.5, 15.2, 18.7, 20.3, 25.1,  # Ulva
                       8.3, 9.5, 10.2, 11.8, 12.1,    # Gracilaria
                       30.5, 35.8, 40.2, 38.5, 42.1], # Sargassum
    'largura_cm': [8.2, 9.5, 11.3, 12.8, 15.2,
                   3.5, 4.1, 4.8, 5.2, 5.5,
                   10.5, 12.3, 15.8, 14.2, 16.5],
    'espessura_mm': [0.5, 0.6, 0.7, 0.8, 0.9,
                     1.2, 1.3, 1.5, 1.6, 1.7,
                     2.5, 2.8, 3.2, 3.0, 3.5],
    'especie': ['Ulva']*5 + ['Gracilaria']*5 + ['Sargassum']*5
}

df = pd.DataFrame(dados)

print("="*60)
print("🌿 CLASSIFICAÇÃO DE ESPÉCIES DE MACROALGAS")
print("="*60)
print("\n📊 Dataset:")
print(df.head(10))

# ====================
# PREPARAR DADOS
# ====================

# Features (X) e Target (y)
X = df[['comprimento_cm', 'largura_cm', 'espessura_mm']]
y = df['especie']

print(f"\n📏 Features (X): {X.shape}")
print(f"🎯 Target (y): {y.shape}")

# Dividir em treino e teste (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"\n📚 Dados de treino: {len(X_train)} amostras")
print(f"🧪 Dados de teste: {len(X_test)} amostras")

# ====================
# TREINAR MODELO
# ====================

print("\n" + "="*60)
print("🤖 TREINANDO MODELO (DECISION TREE)")
print("="*60)

# Criar e treinar modelo
modelo = DecisionTreeClassifier(max_depth=3, random_state=42)
modelo.fit(X_train, y_train)

print("✅ Modelo treinado!")

# ====================
# FAZER PREVISÕES
# ====================

print("\n" + "="*60)
print("🔮 FAZENDO PREVISÕES")
print("="*60)

# Prever no conjunto de teste
y_pred = modelo.predict(X_test)

print("\nPrevisões vs Real:")
print("-"*60)
for i, (real, pred) in enumerate(zip(y_test, y_pred)):
    correto = "✅" if real == pred else "❌"
    print(f"Amostra {i+1}: Real={real:12s} | Previsto={pred:12s} {correto}")

# ====================
# AVALIAR DESEMPENHO
# ====================

print("\n" + "="*60)
print("📊 AVALIAÇÃO DO MODELO")
print("="*60)

# Acurácia
acuracia = accuracy_score(y_test, y_pred)
print(f"\n🎯 Acurácia: {acuracia*100:.1f}%")

# Relatório detalhado
print("\n📋 Relatório de Classificação:")
print("-"*60)
print(classification_report(y_test, y_pred))

# ====================
# TESTAR COM NOVA AMOSTRA
# ====================

print("\n" + "="*60)
print("🆕 PREVER ESPÉCIE DE NOVA AMOSTRA")
print("="*60)

# Nova amostra desconhecida
nova_amostra = pd.DataFrame({
    'comprimento_cm': [22.5],
    'largura_cm': [13.8],
    'espessura_mm': [0.75]
})

predicao = modelo.predict(nova_amostra)
probabilidades = modelo.predict_proba(nova_amostra)

print(f"\n📏 Características:")
print(f"   Comprimento: {nova_amostra['comprimento_cm'].values[0]} cm")
print(f"   Largura: {nova_amostra['largura_cm'].values[0]} cm")
print(f"   Espessura: {nova_amostra['espessura_mm'].values[0]} mm")

print(f"\n🔮 Previsão: {predicao[0]}")
print(f"\n📊 Probabilidades:")
for especie, prob in zip(modelo.classes_, probabilidades[0]):
    print(f"   {especie}: {prob*100:.1f}%")

print("\n" + "="*60)
print("✅ CLASSIFICAÇÃO CONCLUÍDA!")
print("="*60)

📈 Exemplo 2: Regressão - Prever Biomassa

Problema

Prever biomassa com base em temperatura, salinidade e profundidade.

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler

# Dataset
dados = {
    'temperatura_c': [24.5, 26.1, 22.3, 21.5, 19.8, 18.2, 17.5, 18.0, 19.5, 21.0],
    'salinidade_psu': [35.0, 34.5, 35.2, 35.3, 35.4, 35.5, 35.6, 35.4, 35.2, 35.0],
    'profundidade_m': [3.2, 3.0, 3.5, 3.8, 3.6, 3.4, 3.9, 3.7, 3.5, 3.8],
    'biomassa_g': [245.3, 198.5, 302.1, 275.4, 310.8, 285.2, 320.5, 295.7, 260.8, 280.3]
}

df = pd.DataFrame(dados)

print("="*60)
print("📊 REGRESSÃO: PREVER BIOMASSA")
print("="*60)

# Preparar dados
X = df[['temperatura_c', 'salinidade_psu', 'profundidade_m']]
y = df['biomassa_g']

# Normalizar features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Dividir dados
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42
)

# Treinar modelo
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Prever
y_pred = modelo.predict(X_test)

# Avaliar
r2 = r2_score(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

print(f"\n📊 Desempenho do Modelo:")
print(f"   R² Score: {r2:.4f}")
print(f"   RMSE: {rmse:.2f}g")

print(f"\n🎯 Coeficientes:")
features = ['temperatura_c', 'salinidade_psu', 'profundidade_m']
for feature, coef in zip(features, modelo.coef_):
    print(f"   {feature}: {coef:.4f}")

# Prever nova amostra
nova_amostra = scaler.transform([[20.5, 35.1, 3.5]])
predicao = modelo.predict(nova_amostra)
print(f"\n🔮 Previsão para nova amostra: {predicao[0]:.2f}g")

print("\n" + "="*60)
print("✅ REGRESSÃO CONCLUÍDA!")
print("="*60)

🎨 Visualização de Modelos

Árvore de Decisão

from sklearn import tree
import matplotlib.pyplot as plt

# Visualizar árvore
plt.figure(figsize=(15, 10))
tree.plot_tree(modelo, 
               feature_names=['comprimento', 'largura', 'espessura'],
               class_names=modelo.classes_,
               filled=True, 
               rounded=True, 
               fontsize=10)
plt.title('Árvore de Decisão - Classificação de Espécies', fontsize=16)
plt.savefig('arvore_decisao.png', dpi=300, bbox_inches='tight')
plt.show()

Matriz de Confusão

from sklearn.metrics import confusion_matrix
import seaborn as sns

# Calcular matriz de confusão
cm = confusion_matrix(y_test, y_pred)

# Plotar
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=modelo.classes_,
            yticklabels=modelo.classes_)
plt.xlabel('Previsto')
plt.ylabel('Real')
plt.title('Matriz de Confusão')
plt.savefig('matriz_confusao.png', dpi=300)
plt.show()

🎓 Conceitos-Chave

Overfitting vs Underfitting

UNDERFITTING (modelo simples demais)
   Treino: 60% | Teste: 62%
   → Adicionar complexidade

BONS RESULTADOS
   Treino: 95% | Teste: 92%
   → Modelo equilibrado ✅

OVERFITTING (modelo complexo demais)
   Treino: 99% | Teste: 75%
   → Simplificar modelo ou mais dados

Cross-Validation

from sklearn.model_selection import cross_val_score

# Validação cruzada (k-fold)
scores = cross_val_score(modelo, X, y, cv=5)

print(f"Acurácia média: {scores.mean():.4f} ± {scores.std():.4f}")

🎓 Checklist desta Lição

[ ] Entendi os tipos de ML (supervisionado/não-supervisionado)
[ ] Criei modelo de classificação
[ ] Treinei modelo de regressão
[ ] Avaliei desempenho com métricas
[ ] Fiz previsões em novos dados

➡️ Próxima Lição

02-Classificacao-Avancada.html (Random Forest, SVM, Neural Networks)

Você entrou no mundo do Machine Learning! 🤖✨

🌿 Classificação Avançada de Espécies

🎯 Objetivo

Aprimorar a classificação de macroalgas com modelos mais robustos: Random Forest, SVM e boas práticas.

📦 Setup

Instalar dependências:

pip install scikit-learn pandas numpy matplotlib seaborn

🧪 Dataset Sintético

import pandas as pd
import numpy as np

np.random.seed(42)

n = 150
especies = ['Ulva', 'Gracilaria', 'Sargassum']

df = pd.DataFrame({
    'comprimento_cm': np.concatenate([
        np.random.normal(20, 3, n//3),
        np.random.normal(11, 2, n//3),
        np.random.normal(35, 4, n//3)
    ]),
    'largura_cm': np.concatenate([
        np.random.normal(13, 2, n//3),
        np.random.normal(5, 1, n//3),
        np.random.normal(15, 2.5, n//3)
    ]),
    'espessura_mm': np.concatenate([
        np.random.normal(0.7, 0.15, n//3),
        np.random.normal(1.5, 0.2, n//3),
        np.random.normal(3.0, 0.3, n//3)
    ]),
    'especie': np.repeat(especies, n//3)
})

🔧 Preparação + Split

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X = df[['comprimento_cm', 'largura_cm', 'espessura_mm']]
y = df['especie']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

🌲 Random Forest

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

rf = RandomForestClassifier(n_estimators=200, max_depth=None, random_state=42)
rf.fit(X_train, y_train)

y_pred_rf = rf.predict(X_test)
print(f"Acurácia RF: {accuracy_score(y_test, y_pred_rf)*100:.1f}%")
print(classification_report(y_test, y_pred_rf))

# Importância das features
importancias = pd.Series(rf.feature_importances_, index=X.columns)
print("\nImportância das características:")
print(importancias.sort_values(ascending=False).round(3))

— Vantagens: robusto, pouco tuning. — Interpretação: importância de variáveis.

🧭 SVM (Support Vector Machine)

from sklearn.svm import SVC

svm = SVC(kernel='rbf', C=2.0, gamma='scale', probability=True, random_state=42)
svm.fit(X_train_scaled, y_train)

y_pred_svm = svm.predict(X_test_scaled)
print(f"Acurácia SVM: {accuracy_score(y_test, y_pred_svm)*100:.1f}%")
print(classification_report(y_test, y_pred_svm))

— Sensível à escala → usar StandardScaler. — Kernel RBF captura não-linearidades.

🔄 Validação Cruzada

from sklearn.model_selection import cross_val_score

scores_rf = cross_val_score(rf, X, y, cv=5)
scores_svm = cross_val_score(SVC(kernel='rbf', C=2.0, gamma='scale'), X, y, cv=5)

print(f"RF CV: {scores_rf.mean():.3f} ± {scores_rf.std():.3f}")
print(f"SVM CV: {scores_svm.mean():.3f} ± {scores_svm.std():.3f}")

🎯 Tuning (Grid Search)

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [None, 5, 10],
    'min_samples_split': [2, 4]
}

gs = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=3, n_jobs=-1)
gs.fit(X_train, y_train)
print(f"Melhor RF: {gs.best_params_}")
print(f"Score (val): {gs.best_score_:.3f}")

🧪 Matriz de Confusão

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred_rf)
plt.figure(figsize=(6,5))
sns.heatmap(cm, annot=True, fmt='d', cmap='Greens',
            xticklabels=rf.classes_, yticklabels=rf.classes_)
plt.title('Random Forest - Matriz de Confusão')
plt.xlabel('Previsto'); plt.ylabel('Real')
plt.tight_layout(); plt.savefig('cm_rf.png', dpi=300); plt.show()

✅ Boas Práticas

Padronizar escala para SVM
Usar validação cruzada
Evitar overfitting (regularização / limitar profundidade)
Medir precisão, recall e F1 por classe
Interpretar importância de variáveis

— Próxima: Agrupamento (K-Means) e redução de dimensionalidade (PCA).

🧭 Clusterização (K-Means) e PCA

🎯 Objetivo

Agrupar coletas por similaridade e reduzir dimensionalidade para visualização e interpretação.

— K-Means: agrupa pontos em K clusters. — PCA: projeta dados em componentes principais.

📦 Setup

pip install scikit-learn pandas numpy matplotlib seaborn

🔢 Dataset de Características

import pandas as pd
import numpy as np
np.random.seed(42)

n = 120

df = pd.DataFrame({
    'biomassa_g': np.random.normal(280, 40, n),
    'temperatura_c': np.random.normal(20, 2.5, n),
    'salinidade_psu': np.random.normal(35.2, 0.4, n),
    'profundidade_m': np.random.normal(4.0, 1.0, n)
})

print(df.head())

🎛️ K-Means (Agrupamento)

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

X = df[['biomassa_g', 'temperatura_c', 'salinidade_psu', 'profundidade_m']]
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

kmeans = KMeans(n_clusters=3, n_init=10, random_state=42)
kmeans.fit(X_scaled)

labels = kmeans.labels_
df['cluster'] = labels
print(df['cluster'].value_counts())

— Cada cluster agrupa coletas com padrões semelhantes.

Visualização 2D (PCA)

from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import seaborn as sns

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

plt.figure(figsize=(7,5))
sns.scatterplot(x=X_pca[:,0], y=X_pca[:,1], hue=df['cluster'], palette='Set2', s=80, edgecolor='black')
plt.title('K-Means clusters (PCA 2D)')
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]*100:.1f}% var.)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]*100:.1f}% var.)')
plt.tight_layout(); plt.savefig('clusters_pca.png', dpi=300); plt.show()

📐 PCA: Componentes e Cargas

componentes = pd.DataFrame(pca.components_, columns=X.columns, index=['PC1', 'PC2'])
print('\nCargas dos componentes:')
print(componentes.round(3))

print('\nVariância explicada:')
print(pca.explained_variance_ratio_.round(3))

Interpretação: - Cargas altas (positivas/negativas) mostram variáveis que mais pesam em cada PC.

🔍 Escolha de K (Elbow Method)

inertias = []
for k in range(2, 8):
    km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(X_scaled)
    inertias.append(km.inertia_)

plt.figure(figsize=(6,4))
plt.plot(range(2,8), inertias, 'o--')
plt.xlabel('Número de clusters (K)')
plt.ylabel('Inércia')
plt.title('Elbow Method')
plt.tight_layout(); plt.savefig('elbow.png', dpi=300); plt.show()

— Ponto de inflexão sugere bom K.

✅ Boas Práticas

Padronizar dados antes de K-Means
Interpretar PCA com cargas das variáveis
Validar clusters (silhouette score)
Evitar inferências causais com clusters

— Com isso, você consegue agrupar e visualizar padrões em dados complexos.