import numpy as np

# X: matriz de atributos (amostras nas linhas, atributos nas colunas)
X = np.array([[2.0, 30.0],     # [distancia_km, elevacao_graus]
              [5.0, 10.0],
              [1.0, 45.0],
              [8.0,  5.0]])

# y: a resposta de cada amostra
y = np.array([1, 0, 1, 0])     # 1 = enlace bom, 0 = ruim

print("amostras:", X.shape[0])
print("atributos:", X.shape[1])
print("classes:", np.unique(y))
print("proporção da classe 1:", y.mean())

# Manutencao preditiva de um enlace de radio
CUSTO_ALARME_FALSO = 250.0     # deslocamento de equipe sem falha
CUSTO_FALHA_NAO_VISTA = 7000.0 # enlace fora do ar por horas

proporcao_de_falhas = 0.03
enlaces_por_mes = 400

def custo_mensal(revocacao, precisao):
    """Custo esperado dado o desempenho de um detector."""
    falhas = enlaces_por_mes * proporcao_de_falhas
    detectadas = falhas * revocacao
    nao_vistas = falhas - detectadas
    alarmes = detectadas / precisao if precisao > 0 else 0
    falsos = alarmes - detectadas
    return falsos * CUSTO_ALARME_FALSO + nao_vistas * CUSTO_FALHA_NAO_VISTA

print(f"sem modelo (nada é detectado): "
      f"R$ {custo_mensal(0.0, 1.0):>9,.2f}")
print()
print(f"{'revocação':>10}{'precisão':>10}{'custo mensal':>16}")
for revocacao, precisao in [(0.50, 0.80), (0.80, 0.50),
                            (0.90, 0.30), (0.95, 0.20)]:
    print(f"{revocacao:>10.2f}{precisao:>10.2f}"
          f"{custo_mensal(revocacao, precisao):>16,.2f}")

import numpy as np

y_teste = np.array([1, 1, 0, 1, 0, 1, 1, 1, 0, 1])

# 1. responder sempre a classe majoritaria
majoritaria = np.bincount(y_teste).argmax()
acerto = (y_teste == majoritaria).mean()

# 2. responder ao acaso, respeitando a proporcao das classes
rng = np.random.default_rng(0)
sorteio = rng.choice([0, 1], size=(2000, len(y_teste)),
                     p=[1 - y_teste.mean(), y_teste.mean()])
acaso = (sorteio == y_teste).mean()

print("classe majoritária:", majoritaria)
print(f"acurácia respondendo sempre {majoritaria}: {acerto:.0%}")
print(f"acurácia sorteando pela proporção: {acaso:.0%}")
print("\nqualquer modelo precisa superar esses números")

import json

requisitos = {
    "decisao": "enviar equipe de manutenção ao enlace",
    "unidade": "um enlace observado em uma janela de 24 h",
    "rotulo": "houve indisponibilidade nas 48 h seguintes",
    "tipo": "supervisionado, classificação binária",
    "metrica_principal": "revocação da classe falha",
    "meta": 0.85,
    "restricao": "no máximo 3 alarmes falsos por semana",
    "custo_falso_positivo_reais": 250,
    "custo_falso_negativo_reais": 7000,
    "dados_disponiveis": "18 meses de telemetria, 400 enlaces",
    "linha_de_base": "regra atual por limiar de RSSI",
    "revisao_humana": "técnico confirma antes do deslocamento",
}

with open("requisitos.json", "w", encoding="utf-8") as f:
    json.dump(requisitos, f, indent=2, ensure_ascii=False)

print(json.dumps(requisitos, indent=2, ensure_ascii=False)[:430])
print("...")

import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler

X = np.array([[2.0, 1500.0],
              [5.0, 1200.0],
              [1.0, 1800.0],
              [8.0,  900.0]])

padrao = StandardScaler().fit_transform(X)
faixa = MinMaxScaler().fit_transform(X)

print("original:\n", X)
print("\npadronizado (média 0, desvio 1):\n", padrao.round(3))
print("\nnormalizado (0 a 1):\n", faixa.round(3))

import numpy as np
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

modulacoes = np.array([["BPSK"], ["QPSK"], ["16QAM"], ["QPSK"]])

codificador = OneHotEncoder(sparse_output=False)
binario = codificador.fit_transform(modulacoes)

print("categorias:", codificador.categories_[0])
print(binario)

rotulos = LabelEncoder()
print("\nrótulos como inteiros:",
      rotulos.fit_transform(["bom", "ruim", "bom", "médio"]))
print("classes:", rotulos.classes_)

import numpy as np
from sklearn.impute import SimpleImputer

X = np.array([[2.0, 1500.0],
              [5.0, np.nan],
              [np.nan, 1800.0],
              [8.0, 900.0]])

print("faltantes por coluna:", np.isnan(X).sum(axis=0))

preenchido = SimpleImputer(strategy="mean").fit_transform(X)
print("preenchido com a média:\n", preenchido.round(2))

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

X, y = load_wine(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=1, stratify=y)

sem_escala = SVC().fit(X_tr, y_tr)
fluxo = make_pipeline(StandardScaler(), SVC()).fit(X_tr, y_tr)

print(f"SVM sem escala:  {sem_escala.score(X_te, y_te):.3f}")
print(f"SVM com escala:  {fluxo.score(X_te, y_te):.3f}")
print("validação cruzada:",
      cross_val_score(fluxo, X, y, cv=5).mean().round(3))

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)

modelo = KNeighborsClassifier(n_neighbors=5)
modelo.fit(X_tr, y_tr)

print("amostras de treino:", X_tr.shape[0])
print("amostras de teste:", X_te.shape[0])
print(f"acurácia no teste: {modelo.score(X_te, y_te):.3f}")
print("previsão para uma flor:", modelo.predict([X_te[0]]))
print("classe verdadeira:", y_te[0])

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC

X, y = load_iris(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)

modelos = {
    "k vizinhos": KNeighborsClassifier(),
    "árvore": DecisionTreeClassifier(random_state=0),
    "regressão logística": LogisticRegression(max_iter=1000),
    "floresta aleatória": RandomForestClassifier(random_state=0),
    "SVM": SVC(),
}

for nome, modelo in modelos.items():
    modelo.fit(X_tr, y_tr)
    print(f"{nome:<22}{modelo.score(X_te, y_te):.3f}")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (confusion_matrix,
                             classification_report)

X, y = load_iris(return_X_y=True)
nomes = load_iris().target_names
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y)

modelo = RandomForestClassifier(random_state=0).fit(X_tr, y_tr)
previsto = modelo.predict(X_te)

print("matriz de confusão (linha = verdadeiro):")
print(confusion_matrix(y_te, previsto))
print()
print(classification_report(y_te, previsto, target_names=nomes))

from sklearn.metrics import (accuracy_score, precision_score,
                             recall_score, f1_score)

# Detector de falha em enlace: 1 = falhou
real =     [0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
previsto = [0, 0, 0, 1, 0, 0, 1, 1, 0, 0]

print(f"acurácia:  {accuracy_score(real, previsto):.2f}")
print(f"precisão:  {precision_score(real, previsto):.2f}"
      "   (dos alarmes, quantos eram reais)")
print(f"revocação: {recall_score(real, previsto):.2f}"
      "   (das falhas, quantas foram detectadas)")
print(f"F1:        {f1_score(real, previsto):.2f}"
      "   (equilíbrio entre as duas)")

from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier

X, y = load_iris(return_X_y=True)
modelo = RandomForestClassifier(random_state=0)

notas = cross_val_score(modelo, X, y, cv=5)

print("acurácia em cada partição:", notas.round(3))
print(f"média {notas.mean():.3f} desvio {notas.std():.3f}")

from sklearn.datasets import load_iris
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier

X, y = load_iris(return_X_y=True)

grade = {"n_neighbors": [1, 3, 5, 7, 9, 15],
         "weights": ["uniform", "distance"]}

busca = GridSearchCV(KNeighborsClassifier(), grade, cv=5)
busca.fit(X, y)

print("melhor combinação:", busca.best_params_)
print(f"melhor acurácia: {busca.best_score_:.3f}")
print("combinações testadas:", len(busca.cv_results_["params"]))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=400, noise=0.30, random_state=7)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=7)

profundidades = range(1, 16)
treino, teste = [], []
for d in profundidades:
    m = DecisionTreeClassifier(max_depth=d, random_state=0)
    m.fit(X_tr, y_tr)
    treino.append(m.score(X_tr, y_tr))
    teste.append(m.score(X_te, y_te))

plt.figure(figsize=(6.4, 2.9))
plt.plot(profundidades, treino, "o-", color="#2f9e41",
         label="treino")
plt.plot(profundidades, teste, "s--", color="#cd191e",
         label="teste")
plt.xlabel("profundidade da árvore")
plt.ylabel("acurácia")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("m01.png", dpi=100, bbox_inches="tight")

melhor = profundidades[int(np.argmax(teste))]
print("melhor profundidade no teste:", melhor)
print(f"treino {treino[-1]:.3f} contra teste {teste[-1]:.3f} "
      "na profundidade 15")

from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score
from sklearn.naive_bayes import GaussianNB
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_wine(return_X_y=True)
modelo = GaussianNB().fit(X, y)

print("acurácia por validação cruzada:",
      round(cross_val_score(GaussianNB(), X, y, cv=5).mean(), 4))
print("probabilidade das três classes na 1ª amostra:",
      modelo.predict_proba(X[:1]).round(4))
print("média do atributo 0 em cada classe:",
      modelo.theta_[:, 0].round(2))

from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score
from sklearn.discriminant_analysis import (
    LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis)

X, y = load_wine(return_X_y=True)

for nome, modelo in [("LDA", LinearDiscriminantAnalysis()),
                     ("QDA", QuadraticDiscriminantAnalysis())]:
    nota = cross_val_score(modelo, X, y, cv=5).mean()
    print(f"{nome}  {nota:.4f}")

# o LDA tambem reduz dimensao, para no maximo (classes - 1) eixos
reduzido = LinearDiscriminantAnalysis(n_components=2).fit_transform(X, y)
print("\n13 atributos ->", reduzido.shape[1], "eixos discriminantes")

from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

X, y = make_moons(n_samples=600, noise=0.25, random_state=2)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=2, stratify=y)

for kernel in ["linear", "poly", "rbf"]:
    m = make_pipeline(StandardScaler(),
                      SVC(kernel=kernel, degree=3)).fit(X_tr, y_tr)
    print(f"kernel {kernel:<7}{m.score(X_te, y_te):.4f}")

# C controla o quanto o modelo tolera erro no treino
print()
for c in [0.01, 1, 100]:
    m = make_pipeline(StandardScaler(),
                      SVC(C=c)).fit(X_tr, y_tr)
    print(f"C={c:<6}treino {m.score(X_tr, y_tr):.4f}  "
          f"teste {m.score(X_te, y_te):.4f}")

import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier

X, y = make_moons(n_samples=400, noise=0.25, random_state=2)

modelos = {
    "logística": make_pipeline(StandardScaler(),
                               LogisticRegression()),
    "naive bayes": GaussianNB(),
    "k vizinhos": make_pipeline(StandardScaler(),
                                KNeighborsClassifier(15)),
    "SVM rbf": make_pipeline(StandardScaler(), SVC()),
    "árvore": DecisionTreeClassifier(max_depth=5, random_state=0),
    "floresta": RandomForestClassifier(n_estimators=100,
                                       random_state=0),
}

fig, eixos = plt.subplots(2, 3, figsize=(6.8, 4.0))
for eixo, (nome, modelo) in zip(eixos.flat, modelos.items()):
    modelo.fit(X, y)
    DecisionBoundaryDisplay.from_estimator(
        modelo, X, ax=eixo, alpha=0.55, cmap="RdYlGn",
        response_method="predict")
    eixo.scatter(X[:, 0], X[:, 1], c=y, s=5, cmap="RdYlGn",
                 edgecolors="k", linewidths=0.2)
    eixo.set_title(f"{nome} ({modelo.score(X, y):.3f})", fontsize=8)
    eixo.set_xticks([]); eixo.set_yticks([])

fig.tight_layout()
fig.savefig("c01.png", dpi=100, bbox_inches="tight")
print("seis fronteiras traçadas sobre o mesmo conjunto")

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

dados = load_breast_cancer()
modelo = make_pipeline(StandardScaler(),
                       LogisticRegression(max_iter=5000))
modelo.fit(dados.data, dados.target)

coef = modelo[-1].coef_[0]
ordem = np.argsort(np.abs(coef))[::-1][:6]

print("atributos mais influentes (coeficiente padronizado):")
for i in ordem:
    sinal = "aumenta" if coef[i] > 0 else "reduz"
    print(f"  {dados.feature_names[i]:<26}{coef[i]:+.3f}  "
          f"{sinal} a chance da classe 1")

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score

rng = np.random.default_rng(3)
d = np.linspace(1, 50, 60)
rssi = -40 - 20 * np.log10(d) + rng.normal(0, 2, d.size)

X = np.log10(d).reshape(-1, 1)      # uma coluna
modelo = LinearRegression().fit(X, rssi)
previsto = modelo.predict(X)

print(f"modelo: RSSI = {modelo.coef_[0]:.2f}*log10(d) "
      f"{modelo.intercept_:+.2f}")
print(f"expoente de perda n = {-modelo.coef_[0] / 10:.2f}")
print(f"erro absoluto médio: {mean_absolute_error(rssi, previsto):.2f} dB")
print(f"R²: {r2_score(rssi, previsto):.4f}")

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

rng = np.random.default_rng(5)
X = rng.uniform(-3, 3, size=(300, 1))
y = np.sin(X).ravel() + rng.normal(0, 0.2, 300)

X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=5)

for nome, modelo in [("linear", LinearRegression()),
                     ("ridge", Ridge(alpha=1.0)),
                     ("árvore", DecisionTreeRegressor(max_depth=4,
                                                      random_state=0)),
                     ("floresta", RandomForestRegressor(
                         n_estimators=100, random_state=0))]:
    modelo.fit(X_tr, y_tr)
    erro = mean_squared_error(y_te, modelo.predict(X_te))
    print(f"{nome:<10} EQM {erro:.4f}")

import numpy as np

serie = np.array([10, 12, 13, 15, 14, 16, 18, 17, 19, 21])

def janelar(serie, janela):
    """Cria X com 'janela' valores passados e y com o seguinte."""
    X = np.array([serie[i:i + janela]
                  for i in range(len(serie) - janela)])
    y = np.array(serie[janela:])
    return X, y

X, y = janelar(serie, janela=3)
print("X (três valores anteriores):\n", X)
print("y (próximo valor):", y)
print("formato:", X.shape, y.shape)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error

rng = np.random.default_rng(11)
t = np.arange(400)
serie = (20 + 5 * np.sin(2 * np.pi * t / 50)
         + 0.01 * t + rng.normal(0, 0.6, t.size))

janela = 20
X = np.array([serie[i:i + janela]
              for i in range(len(serie) - janela)])
y = serie[janela:]

corte = int(len(X) * 0.75)          # divisao temporal, sem sortear
X_tr, X_te, y_tr, y_te = X[:corte], X[corte:], y[:corte], y[corte:]

persistencia = X_te[:, -1]          # "amanha e igual a hoje"
modelo = RandomForestRegressor(n_estimators=200,
                               random_state=0).fit(X_tr, y_tr)
previsto = modelo.predict(X_te)

print(f"erro da persistência: {mean_absolute_error(y_te, persistencia):.4f}")
print(f"erro do modelo:       {mean_absolute_error(y_te, previsto):.4f}")

plt.figure(figsize=(6.6, 2.8))
plt.plot(y_te, color="#101214", linewidth=1, label="real")
plt.plot(previsto, color="#2f9e41", linewidth=1, label="previsto")
plt.plot(persistencia, color="#cd191e", linewidth=0.8,
         linestyle=":", label="persistência")
plt.xlabel("amostra do conjunto de teste")
plt.legend(fontsize=8, ncol=3)
plt.grid(alpha=0.3)
plt.savefig("a02.png", dpi=100, bbox_inches="tight")

import numpy as np
from sklearn.model_selection import TimeSeriesSplit, cross_val_score
from sklearn.ensemble import RandomForestRegressor

rng = np.random.default_rng(11)
t = np.arange(400)
serie = 20 + 5 * np.sin(2 * np.pi * t / 50) + rng.normal(0, 0.6, 400)
janela = 20
X = np.array([serie[i:i + janela] for i in range(len(serie) - janela)])
y = serie[janela:]

divisor = TimeSeriesSplit(n_splits=4)
for i, (treino, teste) in enumerate(divisor.split(X), 1):
    print(f"dobra {i}: treino [0:{treino[-1] + 1}] "
          f"teste [{teste[0]}:{teste[-1] + 1}]")

notas = cross_val_score(RandomForestRegressor(n_estimators=100,
                                              random_state=0),
                        X, y, cv=divisor,
                        scoring="neg_mean_absolute_error")
print("\nerro médio por dobra:", (-notas).round(4))

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_wine(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=1, stratify=y)

base = [
    ("logística", make_pipeline(StandardScaler(),
                                LogisticRegression(max_iter=2000))),
    ("árvore", DecisionTreeClassifier(random_state=0)),
    ("vizinhos", make_pipeline(StandardScaler(),
                               KNeighborsClassifier())),
]

for nome, modelo in base:
    modelo.fit(X_tr, y_tr)
    print(f"{nome:<12}{modelo.score(X_te, y_te):.4f}")

votacao = VotingClassifier(base, voting="soft").fit(X_tr, y_tr)
print(f"{'votação':<12}{votacao.score(X_te, y_te):.4f}")

from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier, RandomForestClassifier

X, y = load_wine(return_X_y=True)

modelos = {
    "árvore única": DecisionTreeClassifier(random_state=0),
    "bagging de 100": BaggingClassifier(
        DecisionTreeClassifier(random_state=0),
        n_estimators=100, random_state=0),
    "floresta de 100": RandomForestClassifier(
        n_estimators=100, random_state=0),
}

for nome, modelo in modelos.items():
    notas = cross_val_score(modelo, X, y, cv=5)
    print(f"{nome:<18}{notas.mean():.4f} "
          f"(desvio {notas.std():.4f})")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier

dados = load_wine()
X, y, nomes = dados.data, dados.target, dados.feature_names

floresta = RandomForestClassifier(n_estimators=300,
                                  random_state=0).fit(X, y)
ordem = np.argsort(floresta.feature_importances_)[::-1][:8]

plt.figure(figsize=(6.4, 3.0))
plt.barh([nomes[i] for i in ordem][::-1],
         floresta.feature_importances_[ordem][::-1],
         color="#2f9e41")
plt.xlabel("importância")
plt.tick_params(labelsize=7)
plt.savefig("e01.png", dpi=100, bbox_inches="tight")

for i in ordem[:5]:
    print(f"{nomes[i]:<28}{floresta.feature_importances_[i]:.4f}")

from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import (RandomForestClassifier,
                              HistGradientBoostingClassifier,
                              AdaBoostClassifier)

X, y = load_wine(return_X_y=True)

modelos = {
    "floresta": RandomForestClassifier(n_estimators=200,
                                       random_state=0),
    "gradiente (hist)": HistGradientBoostingClassifier(
        max_iter=200, random_state=0),
    "adaboost": AdaBoostClassifier(n_estimators=200,
                                   random_state=0),
}

for nome, modelo in modelos.items():
    notas = cross_val_score(modelo, X, y, cv=5)
    print(f"{nome:<20}{notas.mean():.4f}")

from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import StackingClassifier, RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_wine(return_X_y=True)

pilha = StackingClassifier(
    estimators=[
        ("floresta", RandomForestClassifier(n_estimators=100,
                                            random_state=0)),
        ("svm", make_pipeline(StandardScaler(),
                              SVC(probability=True))),
    ],
    final_estimator=LogisticRegression(max_iter=1000),
    cv=5,
)

print("empilhamento:",
      round(cross_val_score(pilha, X, y, cv=5).mean(), 4))

import numpy as np
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance

dados = load_wine()
X_tr, X_te, y_tr, y_te = train_test_split(
    dados.data, dados.target, test_size=0.3, random_state=1,
    stratify=dados.target)

modelo = RandomForestClassifier(n_estimators=200,
                                random_state=0).fit(X_tr, y_tr)
resultado = permutation_importance(modelo, X_te, y_te,
                                   n_repeats=20, random_state=0)

ordem = resultado.importances_mean.argsort()[::-1][:5]
print("queda de acurácia ao embaralhar cada atributo:")
for i in ordem:
    print(f"  {dados.feature_names[i]:<28}"
          f"{resultado.importances_mean[i]:.4f} "
          f"± {resultado.importances_std[i]:.4f}")

import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_curve, roc_auc_score

X, y = make_classification(n_samples=2000, n_informative=6,
                           weights=[0.85, 0.15], random_state=3)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=3, stratify=y)

plt.figure(figsize=(4.8, 3.6))
for nome, modelo, cor in [
        ("logística", LogisticRegression(max_iter=2000), "#2f9e41"),
        ("floresta", RandomForestClassifier(n_estimators=200,
                                            random_state=0),
         "#cd191e")]:
    modelo.fit(X_tr, y_tr)
    prob = modelo.predict_proba(X_te)[:, 1]
    fpr, tpr, _ = roc_curve(y_te, prob)
    auc = roc_auc_score(y_te, prob)
    plt.plot(fpr, tpr, color=cor, label=f"{nome} (AUC {auc:.3f})")
    print(f"{nome:<12}AUC {auc:.4f}")

plt.plot([0, 1], [0, 1], "--", color="#999", label="aleatório")
plt.xlabel("taxa de falso positivo")
plt.ylabel("taxa de verdadeiro positivo")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("r01.png", dpi=100, bbox_inches="tight")

import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import precision_recall_curve, average_precision_score

X, y = make_classification(n_samples=2000, n_informative=6,
                           weights=[0.95, 0.05], random_state=3)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=3, stratify=y)

modelo = LogisticRegression(max_iter=2000).fit(X_tr, y_tr)
prob = modelo.predict_proba(X_te)[:, 1]
precisao, revocacao, limiares = precision_recall_curve(y_te, prob)

plt.figure(figsize=(5.2, 3.2))
plt.plot(revocacao, precisao, color="#2f9e41")
plt.axhline(y_te.mean(), color="#cd191e", linestyle="--",
            label=f"acaso ({y_te.mean():.3f})")
plt.xlabel("revocação"); plt.ylabel("precisão")
plt.legend(fontsize=8); plt.grid(alpha=0.3)
plt.savefig("r02.png", dpi=100, bbox_inches="tight")

print("proporção da classe rara:", round(y_te.mean(), 4))
print("precisão média:", round(average_precision_score(y_te, prob), 4))

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix

X, y = make_classification(n_samples=2000, n_informative=6,
                           weights=[0.9, 0.1], random_state=3)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=3, stratify=y)

modelo = LogisticRegression(max_iter=2000).fit(X_tr, y_tr)
prob = modelo.predict_proba(X_te)[:, 1]

CUSTO_FALSO_ALARME = 1      # deslocamento de equipe a toa
CUSTO_FALHA_NAO_VISTA = 20  # enlace fora do ar

print(f"{'limiar':>7}{'falso+':>8}{'falso-':>8}{'custo':>8}")
melhor = (None, 1e9)
for limiar in np.arange(0.05, 0.96, 0.10):
    previsto = (prob >= limiar).astype(int)
    vn, fp, fn, vp = confusion_matrix(y_te, previsto).ravel()
    custo = fp * CUSTO_FALSO_ALARME + fn * CUSTO_FALHA_NAO_VISTA
    print(f"{limiar:>7.2f}{fp:>8}{fn:>8}{custo:>8}")
    if custo < melhor[1]:
        melhor = (limiar, custo)

print(f"\nmelhor limiar: {melhor[0]:.2f} (custo {melhor[1]})")
print("o padrão 0.50 quase nunca é o ótimo")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.calibration import CalibratedClassifierCV, calibration_curve

X, y = make_classification(n_samples=3000, n_informative=6,
                           random_state=5)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=5, stratify=y)

cru = RandomForestClassifier(n_estimators=100,
                             random_state=0).fit(X_tr, y_tr)
calibrado = CalibratedClassifierCV(
    RandomForestClassifier(n_estimators=100, random_state=0),
    cv=5, method="isotonic").fit(X_tr, y_tr)

plt.figure(figsize=(4.8, 3.6))
plt.plot([0, 1], [0, 1], "--", color="#999", label="ideal")
for nome, modelo, cor in [("cru", cru, "#cd191e"),
                          ("calibrado", calibrado, "#2f9e41")]:
    prob = modelo.predict_proba(X_te)[:, 1]
    real, previsto = calibration_curve(y_te, prob, n_bins=10)
    plt.plot(previsto, real, "o-", color=cor, label=nome)
    erro = np.abs(real - previsto).mean()
    print(f"{nome:<12}erro médio de calibração {erro:.4f}")

plt.xlabel("probabilidade prevista")
plt.ylabel("frequência observada")
plt.legend(fontsize=8); plt.grid(alpha=0.3)
plt.savefig("r03.png", dpi=100, bbox_inches="tight")

import numpy as np
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

X, y = load_wine(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=0, stratify=y)

modelo = RandomForestClassifier(n_estimators=200,
                                random_state=0).fit(X_tr, y_tr)
previsto = modelo.predict(X_te)

rng = np.random.default_rng(0)
amostras = []
for _ in range(2000):
    indices = rng.integers(0, len(y_te), len(y_te))
    amostras.append(accuracy_score(y_te[indices], previsto[indices]))

baixo, alto = np.percentile(amostras, [2.5, 97.5])
print(f"acurácia pontual: {accuracy_score(y_te, previsto):.4f}")
print(f"intervalo de 95%: [{baixo:.4f}, {alto:.4f}]")
print(f"amostras de teste: {len(y_te)}")

import numpy as np
from scipy import stats
from sklearn.datasets import load_wine
from sklearn.model_selection import RepeatedStratifiedKFold, cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

X, y = load_wine(return_X_y=True)
divisor = RepeatedStratifiedKFold(n_splits=5, n_repeats=6,
                                  random_state=0)

a = cross_val_score(RandomForestClassifier(n_estimators=100,
                                           random_state=0),
                    X, y, cv=divisor)
b = cross_val_score(make_pipeline(StandardScaler(),
                                  LogisticRegression(max_iter=2000)),
                    X, y, cv=divisor)

print(f"floresta:  {a.mean():.4f} ± {a.std():.4f}")
print(f"logística: {b.mean():.4f} ± {b.std():.4f}")

t, p = stats.ttest_rel(a, b)
print(f"\nteste t pareado: t={t:.3f}  p={p:.4f}")
print("diferença significativa?" , "sim" if p < 0.05 else "não")

from sklearn.datasets import load_wine
from sklearn.tree import DecisionTreeClassifier, export_text

dados = load_wine()
arvore = DecisionTreeClassifier(max_depth=2,
                                random_state=0).fit(dados.data,
                                                    dados.target)

print(export_text(arvore, feature_names=list(dados.feature_names),
                  class_names=list(dados.target_names)))
print("acurácia com apenas duas perguntas:",
      round(arvore.score(dados.data, dados.target), 4))

import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.inspection import PartialDependenceDisplay

dados = load_diabetes()
modelo = HistGradientBoostingRegressor(
    max_iter=200, random_state=0).fit(dados.data, dados.target)

alvos = [2, 8, 3]        # imc, medida sanguinea, pressao
fig, eixos = plt.subplots(1, 3, figsize=(6.8, 2.4))
PartialDependenceDisplay.from_estimator(
    modelo, dados.data, alvos, ax=eixos,
    feature_names=list(dados.feature_names))
for eixo in eixos:
    eixo.tick_params(labelsize=7)
    eixo.set_xlabel(eixo.get_xlabel(), fontsize=8)
    eixo.set_ylabel(eixo.get_ylabel(), fontsize=8)
    eixo.grid(alpha=0.3)
fig.tight_layout()
fig.savefig("i01.png", dpi=100, bbox_inches="tight")
print("curvas de dependência parcial geradas")
print("cada curva mostra o efeito médio do atributo na previsão")

import matplotlib.pyplot as plt
from sklearn.datasets import load_diabetes
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.inspection import PartialDependenceDisplay

dados = load_diabetes()
modelo = HistGradientBoostingRegressor(
    max_iter=200, random_state=0).fit(dados.data, dados.target)

fig, eixo = plt.subplots(figsize=(4.6, 3.0))
PartialDependenceDisplay.from_estimator(
    modelo, dados.data, [2], ax=eixo, kind="both",
    feature_names=list(dados.feature_names),
    ice_lines_kw={"alpha": 0.15, "color": "#2f9e41"},
    pd_line_kw={"color": "#cd191e", "linewidth": 2})
eixo.grid(alpha=0.3)
eixo.tick_params(labelsize=7)
fig.tight_layout()
fig.savefig("i02.png", dpi=100, bbox_inches="tight")
print("cada linha verde é uma amostra, a vermelha é a média")
print("linhas com inclinações opostas indicam interação escondida")

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

dados = load_breast_cancer()
X_tr, X_te, y_tr, y_te = train_test_split(
    dados.data, dados.target, test_size=0.3, random_state=0,
    stratify=dados.target)
modelo = RandomForestClassifier(n_estimators=200,
                                random_state=0).fit(X_tr, y_tr)

def contribuicoes(modelo, amostra, base, n=5):
    """Quanto a previsão muda ao trocar cada atributo pelo valor médio."""
    p0 = modelo.predict_proba(amostra.reshape(1, -1))[0, 1]
    efeitos = []
    for j in range(len(amostra)):
        alterada = amostra.copy()
        alterada[j] = base[j]
        p = modelo.predict_proba(alterada.reshape(1, -1))[0, 1]
        efeitos.append(p0 - p)
    ordem = np.argsort(np.abs(efeitos))[::-1][:n]
    return p0, [(dados.feature_names[j], efeitos[j]) for j in ordem]

media = X_tr.mean(axis=0)
for i in [0, 1]:
    prob, itens = contribuicoes(modelo, X_te[i], media)
    print(f"\namostra {i}: probabilidade prevista {prob:.3f}, "
          f"classe real {y_te[i]}")
    for nome, efeito in itens:
        seta = "+" if efeito > 0 else "-"
        print(f"  {seta} {nome:<26}{efeito:+.4f}")

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.model_selection import train_test_split

dados = load_breast_cancer()
X_tr, X_te, y_tr, y_te = train_test_split(
    dados.data, dados.target, test_size=0.3, random_state=0,
    stratify=dados.target)

floresta = RandomForestClassifier(n_estimators=200,
                                  random_state=0).fit(X_tr, y_tr)

# a arvore aprende a imitar a floresta, nao os rotulos verdadeiros
substituto = DecisionTreeClassifier(max_depth=3, random_state=0)
substituto.fit(X_tr, floresta.predict(X_tr))

concorda = (substituto.predict(X_te) == floresta.predict(X_te)).mean()
print(f"a árvore reproduz {concorda:.1%} das decisões da floresta")
print(f"acurácia da floresta:  {floresta.score(X_te, y_te):.4f}")
print(f"acurácia do substituto:{substituto.score(X_te, y_te):.4f}\n")
print(export_text(substituto,
                  feature_names=list(dados.feature_names))[:520])

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA

X, y = load_digits(return_X_y=True)
pca = PCA().fit(X / 16.0)

acumulada = np.cumsum(pca.explained_variance_ratio_)

plt.figure(figsize=(6.4, 2.8))
plt.plot(range(1, len(acumulada) + 1), acumulada, color="#2f9e41")
plt.axhline(0.95, color="#cd191e", linestyle="--",
            label="95% da variância")
plt.xlabel("componentes")
plt.ylabel("variância explicada acumulada")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("p01.png", dpi=100, bbox_inches="tight")

print("atributos originais:", X.shape[1])
print("componentes para 90%:", int(np.argmax(acumulada >= 0.90)) + 1)
print("componentes para 95%:", int(np.argmax(acumulada >= 0.95)) + 1)
print("primeiros três:", pca.explained_variance_ratio_[:3].round(4))

import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA

X, y = load_digits(return_X_y=True)
reduzido = PCA(n_components=2, random_state=0).fit_transform(X / 16.0)

plt.figure(figsize=(5.4, 4.0))
dispersao = plt.scatter(reduzido[:, 0], reduzido[:, 1], c=y, s=8,
                        cmap="tab10")
plt.colorbar(dispersao, label="dígito", shrink=0.85)
plt.xlabel("componente 1")
plt.ylabel("componente 2")
plt.savefig("p02.png", dpi=100, bbox_inches="tight")

print("formato antes:", X.shape, "depois:", reduzido.shape)

from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

X, y = load_digits(return_X_y=True)

for n in [2, 10, 20, 40, None]:
    etapas = [StandardScaler()]
    if n:
        etapas.append(PCA(n_components=n, random_state=0))
    etapas.append(SVC())
    nota = cross_val_score(make_pipeline(*etapas), X, y, cv=5).mean()
    rotulo = f"{n} componentes" if n else "sem PCA (64)"
    print(f"{rotulo:<18}{nota:.4f}")

import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.manifold import TSNE

X, y = load_digits(return_X_y=True)
X, y = X[:600] / 16.0, y[:600]

mapa = TSNE(n_components=2, perplexity=30, init="pca",
            random_state=0).fit_transform(X)

plt.figure(figsize=(5.4, 4.0))
d = plt.scatter(mapa[:, 0], mapa[:, 1], c=y, s=10, cmap="tab10")
plt.colorbar(d, label="dígito", shrink=0.85)
plt.xticks([]); plt.yticks([])
plt.savefig("p03.png", dpi=100, bbox_inches="tight")

print("t-SNE aplicado a", X.shape[0], "amostras")

import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs

X, verdadeiro = make_blobs(n_samples=300, centers=3,
                           cluster_std=1.1, random_state=8)
kmeans = KMeans(n_clusters=3, n_init=10, random_state=0).fit(X)

plt.figure(figsize=(6.4, 3.0))
plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, s=14, cmap="Dark2")
plt.scatter(*kmeans.cluster_centers_.T, marker="X", s=150,
            color="#cd191e", label="centros")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("p04.png", dpi=100, bbox_inches="tight")

print("centros:\n", kmeans.cluster_centers_.round(2))
print("inércia:", round(kmeans.inertia_, 2))

import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.metrics import silhouette_score

X, _ = make_blobs(n_samples=400, centers=4, cluster_std=1.0,
                  random_state=5)

ks = range(2, 9)
inercias, silhuetas = [], []
for k in ks:
    modelo = KMeans(n_clusters=k, n_init=10, random_state=0).fit(X)
    inercias.append(modelo.inertia_)
    silhuetas.append(silhouette_score(X, modelo.labels_))

fig, (esq, dir_) = plt.subplots(1, 2, figsize=(6.8, 2.6))
esq.plot(list(ks), inercias, "o-", color="#2f9e41")
esq.set_xlabel("k"); esq.set_ylabel("inércia"); esq.grid(alpha=0.3)
dir_.plot(list(ks), silhuetas, "s-", color="#cd191e")
dir_.set_xlabel("k"); dir_.set_ylabel("silhueta"); dir_.grid(alpha=0.3)
fig.tight_layout()
fig.savefig("p05.png", dpi=100, bbox_inches="tight")

melhor = list(ks)[silhuetas.index(max(silhuetas))]
print("melhor k pela silhueta:", melhor)
for k, s in zip(ks, silhuetas):
    print(f"  k={k}  silhueta={s:.4f}")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import DBSCAN, KMeans
from sklearn.datasets import make_moons

X, _ = make_moons(n_samples=400, noise=0.06, random_state=0)

kmeans = KMeans(n_clusters=2, n_init=10, random_state=0).fit(X)
dbscan = DBSCAN(eps=0.2, min_samples=5).fit(X)

fig, (esq, dir_) = plt.subplots(1, 2, figsize=(6.8, 2.6))
esq.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, s=10, cmap="Dark2")
esq.set_title("KMeans", fontsize=9)
dir_.scatter(X[:, 0], X[:, 1], c=dbscan.labels_, s=10, cmap="Dark2")
dir_.set_title("DBSCAN", fontsize=9)
for eixo in (esq, dir_):
    eixo.set_xticks([]); eixo.set_yticks([])
fig.tight_layout()
fig.savefig("p06.png", dpi=100, bbox_inches="tight")

print("grupos do DBSCAN:", len(set(dbscan.labels_)) - 
      (1 if -1 in dbscan.labels_ else 0))
print("pontos marcados como ruído:", int((dbscan.labels_ == -1).sum()))

import numpy as np

rng = np.random.default_rng(4)
normal = rng.normal(-60, 3, 200)          # RSSI tipico
medidas = np.concatenate([normal, [-25, -95, -20]])

media, desvio = medidas.mean(), medidas.std()
escore = np.abs((medidas - media) / desvio)
suspeitos = np.where(escore > 3)[0]

print(f"média {media:.2f} desvio {desvio:.2f}")
print("índices suspeitos:", suspeitos)
print("valores:", medidas[suspeitos].round(2))

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest

rng = np.random.default_rng(2)
normais = rng.normal(0, 1, size=(300, 2))
anomalias = rng.uniform(-6, 6, size=(15, 2))
X = np.vstack([normais, anomalias])

detector = IsolationForest(contamination=0.05, random_state=0)
rotulo = detector.fit_predict(X)      # -1 = anomalia

plt.figure(figsize=(6.4, 3.0))
plt.scatter(X[rotulo == 1, 0], X[rotulo == 1, 1], s=12,
            color="#2f9e41", label="normal")
plt.scatter(X[rotulo == -1, 0], X[rotulo == -1, 1], s=30,
            color="#cd191e", marker="X", label="anomalia")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("a01.png", dpi=100, bbox_inches="tight")

print("pontos marcados como anomalia:", int((rotulo == -1).sum()))
print("escore dos cinco mais suspeitos:",
      np.sort(detector.score_samples(X))[:5].round(3))

import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor
from sklearn.svm import OneClassSVM

rng = np.random.default_rng(2)
X = np.vstack([rng.normal(0, 1, size=(300, 2)),
               rng.uniform(-6, 6, size=(15, 2))])
verdade = np.r_[np.ones(300), -np.ones(15)]

detectores = {
    "isolation forest": IsolationForest(contamination=0.05,
                                        random_state=0),
    "local outlier": LocalOutlierFactor(contamination=0.05),
    "one-class SVM": OneClassSVM(nu=0.05, gamma="scale"),
}

for nome, det in detectores.items():
    previsto = (det.fit_predict(X) if nome == "local outlier"
                else det.fit(X).predict(X))
    detectadas = int(((previsto == -1) & (verdade == -1)).sum())
    falsos = int(((previsto == -1) & (verdade == 1)).sum())
    print(f"{nome:<18}detectou {detectadas:>2}/15  "
          f"falsos alarmes {falsos:>2}")

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

X, y = load_digits(return_X_y=True)
X = X / 16.0
X_pool, X_te, y_pool, y_te = train_test_split(
    X, y, test_size=0.3, random_state=0, stratify=y)

print(f"{'rótulos usados':>16}{'acurácia':>11}")
for n in [20, 50, 100, 300, len(y_pool)]:
    rng = np.random.default_rng(0)
    idx = rng.choice(len(y_pool), n, replace=False)
    m = SVC().fit(X_pool[idx], y_pool[idx])
    print(f"{n:>16}{m.score(X_te, y_te):>11.4f}")

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.semi_supervised import SelfTrainingClassifier
from sklearn.linear_model import LogisticRegression

X, y = load_digits(return_X_y=True)
X = X / 16.0
X_pool, X_te, y_pool, y_te = train_test_split(
    X, y, test_size=0.3, random_state=0, stratify=y)

rng = np.random.default_rng(0)
rotulados = rng.choice(len(y_pool), 30, replace=False)

y_parcial = np.full(len(y_pool), -1)      # -1 significa sem rotulo
y_parcial[rotulados] = y_pool[rotulados]
print("rotuladas:", (y_parcial != -1).sum(),
      "| sem rótulo:", (y_parcial == -1).sum())

base = LogisticRegression(max_iter=2000)
sozinho = base.fit(X_pool[rotulados], y_pool[rotulados]).score(X_te, y_te)
print(f"\nsó com os 30 rótulos: {sozinho:.4f}\n")

print(f"{'limiar':>8}{'novos rótulos':>15}{'rodadas':>9}{'acurácia':>11}")
for limiar in [0.70, 0.90, 0.99]:
    m = SelfTrainingClassifier(LogisticRegression(max_iter=2000),
                               threshold=limiar).fit(X_pool, y_parcial)
    novos = int((m.transduction_ != -1).sum()) - len(rotulados)
    print(f"{limiar:>8.2f}{novos:>15}{m.n_iter_:>9}"
          f"{m.score(X_te, y_te):>11.4f}")

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.semi_supervised import LabelSpreading

X, y = load_digits(return_X_y=True)
X = X / 16.0
X_pool, X_te, y_pool, y_te = train_test_split(
    X, y, test_size=0.3, random_state=0, stratify=y)

rng = np.random.default_rng(0)
rotulados = rng.choice(len(y_pool), 50, replace=False)
y_parcial = np.full(len(y_pool), -1)
y_parcial[rotulados] = y_pool[rotulados]

modelo = LabelSpreading(kernel="knn", n_neighbors=7)
modelo.fit(X_pool, y_parcial)

nao_rotulados = y_parcial == -1
acerto = (modelo.transduction_[nao_rotulados]
          == y_pool[nao_rotulados]).mean()
print(f"rótulos inferidos corretamente no pool: {acerto:.4f}")
print(f"acurácia no teste: {modelo.score(X_te, y_te):.4f}")

import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X, y = load_digits(return_X_y=True)
X = X / 16.0
X_pool, X_te, y_pool, y_te = train_test_split(
    X, y, test_size=0.3, random_state=0, stratify=y)

def rodar(estrategia, rodadas=12, por_rodada=10):
    rng = np.random.default_rng(0)
    tem_rotulo = np.zeros(len(y_pool), bool)
    tem_rotulo[rng.choice(len(y_pool), 20, replace=False)] = True

    for _ in range(rodadas):
        m = LogisticRegression(max_iter=2000)
        m.fit(X_pool[tem_rotulo], y_pool[tem_rotulo])
        restantes = np.where(~tem_rotulo)[0]
        if estrategia == "aleatória":
            escolhidos = rng.choice(restantes, por_rodada,
                                    replace=False)
        else:                       # menor confianca primeiro
            prob = m.predict_proba(X_pool[restantes]).max(axis=1)
            escolhidos = restantes[np.argsort(prob)[:por_rodada]]
        tem_rotulo[escolhidos] = True

    m = LogisticRegression(max_iter=2000)
    m.fit(X_pool[tem_rotulo], y_pool[tem_rotulo])
    return tem_rotulo.sum(), m.score(X_te, y_te)

for estrategia in ["aleatória", "incerteza"]:
    n, acc = rodar(estrategia)
    print(f"{estrategia:<12}{n} rótulos -> acurácia {acc:.4f}")

import numpy as np

# Seis canais com taxas de sucesso desconhecidas pelo agente
VERDADEIRO = np.array([0.20, 0.35, 0.55, 0.30, 0.72, 0.45])

def simular(epsilon, passos=4000, semente=0):
    rng = np.random.default_rng(semente)
    soma = np.zeros(6)
    usos = np.zeros(6)
    ganho = 0
    for _ in range(passos):
        if rng.random() < epsilon or usos.min() == 0:
            canal = int(rng.integers(6))          # explora
        else:
            canal = int(np.argmax(soma / usos))   # aproveita
        premio = float(rng.random() < VERDADEIRO[canal])
        usos[canal] += 1
        soma[canal] += premio
        ganho += premio
    return ganho / passos, int(np.argmax(soma / usos))

print(f"melhor canal real: {VERDADEIRO.argmax()} "
      f"(taxa {VERDADEIRO.max():.2f})\n")
print(f"{'epsilon':>8}{'ganho médio':>14}{'canal eleito':>15}")
for eps in [0.0, 0.05, 0.1, 0.3, 1.0]:
    ganho, eleito = simular(eps)
    print(f"{eps:>8.2f}{ganho:>14.4f}{eleito:>15}")

import numpy as np

MAPA = [
    "S..#",
    ".#..",
    "...#",
    "#..G",
]
LINHAS, COLUNAS = len(MAPA), len(MAPA[0])
ACOES = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}
SIMBOLO = {0: "^", 1: "v", 2: "<", 3: ">"}

def celula(estado):
    return divmod(estado, COLUNAS)

def passo(estado, acao):
    i, j = celula(estado)
    di, dj = ACOES[acao]
    ni, nj = i + di, j + dj
    if not (0 <= ni < LINHAS and 0 <= nj < COLUNAS):
        return estado, -1.0, False          # bateu na parede
    if MAPA[ni][nj] == "#":
        return estado, -5.0, False          # obstaculo
    novo = ni * COLUNAS + nj
    if MAPA[ni][nj] == "G":
        return novo, 20.0, True             # chegou
    return novo, -0.2, False                # custo do passo

print("mapa: S início, G destino, # obstáculo")
for linha in MAPA:
    print("   ", linha)
print("\nestados:", LINHAS * COLUNAS, "| ações:", len(ACOES))

import numpy as np

MAPA = ["S..#", ".#..", "...#", "#..G"]
LINHAS, COLUNAS = 4, 4
ACOES = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}
SIMBOLO = {0: "^", 1: "v", 2: "<", 3: ">"}

def passo(estado, acao):
    i, j = divmod(estado, COLUNAS)
    di, dj = ACOES[acao]
    ni, nj = i + di, j + dj
    if not (0 <= ni < LINHAS and 0 <= nj < COLUNAS):
        return estado, -1.0, False
    if MAPA[ni][nj] == "#":
        return estado, -5.0, False
    novo = ni * COLUNAS + nj
    if MAPA[ni][nj] == "G":
        return novo, 20.0, True
    return novo, -0.2, False

rng = np.random.default_rng(7)
Q = np.zeros((LINHAS * COLUNAS, len(ACOES)))
ALFA, GAMA, EPISODIOS = 0.15, 0.95, 3000

historico = []
for episodio in range(EPISODIOS):
    epsilon = max(0.05, 1.0 - episodio / 1500)
    estado, total, fim = 0, 0.0, False
    for _ in range(60):
        if rng.random() < epsilon:
            acao = int(rng.integers(4))
        else:
            acao = int(np.argmax(Q[estado]))
        novo, premio, fim = passo(estado, acao)
        Q[estado, acao] += ALFA * (premio + GAMA * Q[novo].max()
                                   - Q[estado, acao])
        estado, total = novo, total + premio
        if fim:
            break
    historico.append(total)

for faixa in range(0, EPISODIOS, 600):
    media = np.mean(historico[faixa:faixa + 600])
    print(f"episódios {faixa:>5}-{faixa + 600:<5} "
          f"retorno médio {media:>7.2f}")

import numpy as np

MAPA = ["S..#", ".#..", "...#", "#..G"]
LINHAS, COLUNAS = 4, 4
ACOES = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}
SIMBOLO = {0: "^", 1: "v", 2: "<", 3: ">"}

def passo(estado, acao):
    i, j = divmod(estado, COLUNAS)
    di, dj = ACOES[acao]
    ni, nj = i + di, j + dj
    if not (0 <= ni < LINHAS and 0 <= nj < COLUNAS):
        return estado, -1.0, False
    if MAPA[ni][nj] == "#":
        return estado, -5.0, False
    novo = ni * COLUNAS + nj
    if MAPA[ni][nj] == "G":
        return novo, 20.0, True
    return novo, -0.2, False

rng = np.random.default_rng(7)
Q = np.zeros((16, 4))
for episodio in range(3000):
    epsilon = max(0.05, 1.0 - episodio / 1500)
    estado, fim = 0, False
    for _ in range(60):
        acao = (int(rng.integers(4)) if rng.random() < epsilon
                else int(np.argmax(Q[estado])))
        novo, premio, fim = passo(estado, acao)
        Q[estado, acao] += 0.15 * (premio + 0.95 * Q[novo].max()
                                   - Q[estado, acao])
        estado = novo
        if fim:
            break

print("+" + "-" * (COLUNAS * 4 - 1) + "+")
for i in range(LINHAS):
    linha = "|"
    for j in range(COLUNAS):
        c = MAPA[i][j]
        if c == "#":
            linha += " # |"
        elif c == "G":
            linha += " G |"
        else:
            linha += f" {SIMBOLO[int(np.argmax(Q[i * COLUNAS + j]))]} |"
    print(linha)
    print("+" + "-" * (COLUNAS * 4 - 1) + "+")

estado, caminho = 0, [0]
for _ in range(20):
    estado, _, fim = passo(estado, int(np.argmax(Q[estado])))
    caminho.append(estado)
    if fim:
        break
print("\ncaminho ótimo em células:",
      " -> ".join(str(divmod(e, COLUNAS)) for e in caminho))

import numpy as np

def sigmoide(z):
    return 1 / (1 + np.exp(-z))

entradas = np.array([0.7, -1.2, 0.3])
pesos = np.array([0.5, -0.4, 0.9])
vies = 0.1

z = entradas @ pesos + vies
saida = sigmoide(z)

print("soma ponderada:", round(z, 4))
print("saída do neurônio:", round(saida, 4))
print("decisão:", 1 if saida >= 0.5 else 0)

import numpy as np
import matplotlib.pyplot as plt

z = np.linspace(-6, 6, 400)
funcoes = {
    "sigmoide": 1 / (1 + np.exp(-z)),
    "tanh": np.tanh(z),
    "ReLU": np.maximum(0, z),
}

plt.figure(figsize=(6.4, 2.7))
for (nome, valores), cor in zip(funcoes.items(),
                                ["#2f9e41", "#cd191e", "#101214"]):
    plt.plot(z, valores, label=nome, color=cor)
plt.axhline(0, color="#999", linewidth=0.6)
plt.axvline(0, color="#999", linewidth=0.6)
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("m03.png", dpi=100, bbox_inches="tight")

for nome, valores in funcoes.items():
    print(f"{nome:<9} em z=-2: {valores[np.argmin(abs(z + 2))]:+.4f}")

import numpy as np

def perda(w):
    return (w - 3) ** 2 + 1        # minimo em w = 3

def derivada(w):
    return 2 * (w - 3)

w = -4.0
taxa = 0.2

for passo in range(1, 13):
    w -= taxa * derivada(w)
    if passo % 3 == 0:
        print(f"passo {passo:>2}: w = {w:+.4f}  perda = {perda(w):.4f}")

print("\nmínimo encontrado em w =", round(w, 4))

import numpy as np

rng = np.random.default_rng(1)

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([[0], [1], [1], [0]], dtype=float)   # XOR

def sigmoide(z):
    return 1 / (1 + np.exp(-z))

# camada oculta com 4 neuronios
W1 = rng.normal(0, 1, (2, 4))
b1 = np.zeros((1, 4))
W2 = rng.normal(0, 1, (4, 1))
b2 = np.zeros((1, 1))
taxa = 0.5

for epoca in range(1, 8001):
    # propagacao direta
    h = sigmoide(X @ W1 + b1)
    saida = sigmoide(h @ W2 + b2)

    # retropropagacao
    erro = saida - y
    d_saida = erro * saida * (1 - saida)
    d_h = (d_saida @ W2.T) * h * (1 - h)

    W2 -= taxa * h.T @ d_saida
    b2 -= taxa * d_saida.sum(axis=0, keepdims=True)
    W1 -= taxa * X.T @ d_h
    b1 -= taxa * d_h.sum(axis=0, keepdims=True)

    if epoca % 2000 == 0:
        print(f"época {epoca:>5}  perda = {(erro ** 2).mean():.6f}")

print("\nentrada -> saída da rede (esperado)")
for entrada, previsto, esperado in zip(X, saida.ravel(), y.ravel()):
    print(f"{entrada}  ->  {previsto:.4f}  ({esperado:.0f})")

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(1)
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=float)
y = np.array([[0], [1], [1], [0]], dtype=float)

sig = lambda z: 1 / (1 + np.exp(-z))
W1, b1 = rng.normal(0, 1, (2, 4)), np.zeros((1, 4))
W2, b2 = rng.normal(0, 1, (4, 1)), np.zeros((1, 1))

historico = []
for epoca in range(6000):
    h = sig(X @ W1 + b1)
    saida = sig(h @ W2 + b2)
    erro = saida - y
    historico.append((erro ** 2).mean())

    d_s = erro * saida * (1 - saida)
    d_h = (d_s @ W2.T) * h * (1 - h)
    W2 -= 0.5 * h.T @ d_s
    b2 -= 0.5 * d_s.sum(axis=0, keepdims=True)
    W1 -= 0.5 * X.T @ d_h
    b1 -= 0.5 * d_h.sum(axis=0, keepdims=True)

plt.figure(figsize=(6.4, 2.7))
plt.plot(historico, color="#2f9e41")
plt.xlabel("época")
plt.ylabel("erro quadrático médio")
plt.yscale("log")
plt.grid(alpha=0.3, which="both")
plt.savefig("m04.png", dpi=100, bbox_inches="tight")

print("perda inicial:", round(historico[0], 5))
print("perda final:", round(historico[-1], 8))

import tensorflow as tf

escalar = tf.constant(3.0)
vetor = tf.constant([1.0, 2.0, 3.0])
matriz = tf.constant([[1.0, 2.0], [3.0, 4.0]])

print("formato do vetor:", vetor.shape, "tipo:", vetor.dtype)
print("soma:", tf.reduce_sum(vetor).numpy())
print("produto matricial:\n", tf.matmul(matriz, matriz).numpy())
print("de tensor para NumPy:", vetor.numpy())

import tensorflow as tf

x = tf.Variable(3.0)

with tf.GradientTape() as fita:
    y = x ** 2 + 2 * x + 1        # y = (x+1)^2

derivada = fita.gradient(y, x)

print("y em x=3:", y.numpy())
print("dy/dx em x=3:", derivada.numpy(), "(esperado 2x+2 = 8)")

import numpy as np
import keras
from keras import layers

keras.utils.set_random_seed(42)

modelo = keras.Sequential([
    layers.Input(shape=(2,)),
    layers.Dense(8, activation="relu"),
    layers.Dense(8, activation="relu"),
    layers.Dense(1, activation="sigmoid"),
])

modelo.compile(optimizer="adam", loss="binary_crossentropy",
               metrics=["accuracy"])
modelo.summary()

import numpy as np
import keras
from keras import layers
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(42)
X, y = make_moons(n_samples=1200, noise=0.2, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25,
                                          random_state=42)

modelo = keras.Sequential([
    layers.Input(shape=(2,)),
    layers.Dense(16, activation="relu"),
    layers.Dense(16, activation="relu"),
    layers.Dense(1, activation="sigmoid"),
])
modelo.compile("adam", "binary_crossentropy", metrics=["accuracy"])

historico = modelo.fit(X_tr, y_tr, epochs=40, batch_size=32,
                       validation_split=0.2, verbose=0)

perda, acuracia = modelo.evaluate(X_te, y_te, verbose=0)
print(f"perda no teste:    {perda:.4f}")
print(f"acurácia no teste: {acuracia:.4f}")
print("épocas registradas:", len(historico.history["loss"]))
print("acurácia na última época de treino:",
      round(historico.history["accuracy"][-1], 4))

import keras
import matplotlib.pyplot as plt
from keras import layers
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(42)
X, y = make_moons(n_samples=1200, noise=0.2, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25,
                                          random_state=42)

modelo = keras.Sequential([
    layers.Input(shape=(2,)),
    layers.Dense(16, activation="relu"),
    layers.Dense(16, activation="relu"),
    layers.Dense(1, activation="sigmoid"),
])
modelo.compile("adam", "binary_crossentropy", metrics=["accuracy"])
h = modelo.fit(X_tr, y_tr, epochs=60, batch_size=32,
               validation_split=0.2, verbose=0)

fig, (esq, dir_) = plt.subplots(1, 2, figsize=(6.8, 2.7))
esq.plot(h.history["loss"], color="#2f9e41", label="treino")
esq.plot(h.history["val_loss"], color="#cd191e", label="validação")
esq.set_xlabel("época"); esq.set_ylabel("perda")
esq.legend(fontsize=8); esq.grid(alpha=0.3)

dir_.plot(h.history["accuracy"], color="#2f9e41", label="treino")
dir_.plot(h.history["val_accuracy"], color="#cd191e",
          label="validação")
dir_.set_xlabel("época"); dir_.set_ylabel("acurácia")
dir_.legend(fontsize=8); dir_.grid(alpha=0.3)

fig.tight_layout()
fig.savefig("k01.png", dpi=100, bbox_inches="tight")
print("perda final de treino:", round(h.history["loss"][-1], 4))
print("perda final de validação:",
      round(h.history["val_loss"][-1], 4))

import numpy as np
import keras
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = X / 16.0                        # escala 0 a 1
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(32, activation="relu"),
    layers.Dense(10, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.fit(X_tr, y_tr, epochs=30, batch_size=32, verbose=0)

perda, acc = modelo.evaluate(X_te, y_te, verbose=0)
print(f"acurácia no teste: {acc:.4f}")

probabilidades = modelo.predict(X_te[:3], verbose=0)
for i, p in enumerate(probabilidades):
    print(f"amostra {i}: prevista {p.argmax()} "
          f"com confiança {p.max():.3f}, verdadeira {y_te[i]}")

import keras
from keras import layers, regularizers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = X / 16.0
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

def construir(com_regularizacao):
    if com_regularizacao:
        meio = [layers.Dense(128, activation="relu",
                             kernel_regularizer=regularizers.l2(1e-3)),
                layers.Dropout(0.3)]
    else:
        meio = [layers.Dense(128, activation="relu")]
    modelo = keras.Sequential(
        [layers.Input(shape=(64,))] + meio
        + [layers.Dense(10, activation="softmax")])
    modelo.compile("adam", "sparse_categorical_crossentropy",
                   metrics=["accuracy"])
    return modelo

for rotulo, flag in [("sem regularização", False),
                     ("com dropout e L2", True)]:
    m = construir(flag)
    h = m.fit(X_tr, y_tr, epochs=40, batch_size=32,
              validation_split=0.2, verbose=0)
    treino = h.history["accuracy"][-1]
    validacao = h.history["val_accuracy"][-1]
    print(f"{rotulo:<20} treino {treino:.4f} "
          f"validação {validacao:.4f} "
          f"diferença {treino - validacao:+.4f}")

import keras
from keras import layers, callbacks
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = X / 16.0
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(10, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])

parada = callbacks.EarlyStopping(monitor="val_loss", patience=5,
                                 restore_best_weights=True)
guarda = callbacks.ModelCheckpoint("melhor.keras",
                                   monitor="val_loss",
                                   save_best_only=True)

h = modelo.fit(X_tr, y_tr, epochs=200, batch_size=32,
               validation_split=0.2, verbose=0,
               callbacks=[parada, guarda])

print("épocas executadas:", len(h.history["loss"]), "de 200")
print("melhor época:", parada.best_epoch + 1)
print(f"acurácia no teste: "
      f"{modelo.evaluate(X_te, y_te, verbose=0)[1]:.4f}")

import keras
import numpy as np
from keras import layers

keras.utils.set_random_seed(1)
modelo = keras.Sequential([
    layers.Input(shape=(4,)),
    layers.Dense(8, activation="relu"),
    layers.Dense(3, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy")

modelo.save("modelo.keras")
recarregado = keras.models.load_model("modelo.keras")

entrada = np.random.default_rng(0).normal(size=(2, 4))
iguais = np.allclose(modelo.predict(entrada, verbose=0),
                     recarregado.predict(entrada, verbose=0))
print("previsões idênticas após recarregar?", iguais)

import os
print("tamanho do arquivo:",
      os.path.getsize("modelo.keras") // 1024, "KB")

import numpy as np
from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)
imagens = X.reshape(-1, 8, 8, 1) / 16.0

print("formato do lote:", imagens.shape)
print("uma imagem:", imagens[0].shape, "rótulo:", y[0])
print("\nprimeiro dígito em texto:")
for linha in imagens[0, :, :, 0]:
    print("".join("#" if v > 0.5 else ("+" if v > 0.2 else ".")
                  for v in linha))

import numpy as np

imagem = np.array([
    [0, 0, 1, 1, 0, 0],
    [0, 0, 1, 1, 0, 0],
    [0, 0, 1, 1, 0, 0],
    [0, 0, 1, 1, 0, 0],
], dtype=float)

filtro = np.array([[-1, 1]], dtype=float)   # detector de borda

altura = imagem.shape[0]
largura = imagem.shape[1] - filtro.shape[1] + 1
saida = np.zeros((altura, largura))
for i in range(altura):
    for j in range(largura):
        janela = imagem[i, j:j + filtro.shape[1]]
        saida[i, j] = (janela * filtro).sum()

print("entrada:\n", imagem.astype(int))
print("\nresposta do filtro (bordas verticais):\n",
      saida.astype(int))

import keras
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = X.reshape(-1, 8, 8, 1) / 16.0
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(8, 8, 1)),
    layers.Conv2D(16, 3, activation="relu", padding="same"),
    layers.MaxPooling2D(2),
    layers.Conv2D(32, 3, activation="relu", padding="same"),
    layers.Flatten(),
    layers.Dropout(0.3),
    layers.Dense(10, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.summary()

modelo.fit(X_tr, y_tr, epochs=15, batch_size=32, verbose=0)
print(f"\nacurácia no teste: "
      f"{modelo.evaluate(X_te, y_te, verbose=0)[1]:.4f}")

import numpy as np
import keras
import matplotlib.pyplot as plt
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = X.reshape(-1, 8, 8, 1) / 16.0
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(8, 8, 1)),
    layers.Conv2D(16, 3, activation="relu", padding="same"),
    layers.MaxPooling2D(2),
    layers.Flatten(),
    layers.Dense(10, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.fit(X_tr, y_tr, epochs=15, batch_size=32, verbose=0)

previsto = modelo.predict(X_te, verbose=0).argmax(axis=1)
matriz = confusion_matrix(y_te, previsto)

plt.figure(figsize=(4.6, 4.0))
plt.imshow(matriz, cmap="Greens")
plt.colorbar(shrink=0.8)
plt.xlabel("previsto"); plt.ylabel("verdadeiro")
plt.xticks(range(10), fontsize=7); plt.yticks(range(10), fontsize=7)
for i in range(10):
    for j in range(10):
        if matriz[i, j]:
            plt.text(j, i, matriz[i, j], ha="center", va="center",
                     fontsize=6,
                     color="white" if i == j else "#cd191e")
plt.savefig("k02.png", dpi=100, bbox_inches="tight")

erros = np.where(previsto != y_te)[0]
print("erros no teste:", len(erros), "de", len(y_te))
for i in erros[:5]:
    print(f"  amostra {i}: previu {previsto[i]}, era {y_te[i]}")

import numpy as np
import keras
from keras import layers
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(3)
rng = np.random.default_rng(3)

def gerar(n_por_classe=400, tamanho=128):
    t = np.linspace(0, 1, tamanho, endpoint=False)
    X, y = [], []
    for classe in range(3):
        for _ in range(n_por_classe):
            f = rng.uniform(3, 8)
            fase = rng.uniform(0, 2 * np.pi)
            if classe == 0:                      # senoide
                onda = np.sin(2 * np.pi * f * t + fase)
            elif classe == 1:                    # quadrada
                onda = np.sign(np.sin(2 * np.pi * f * t + fase))
            else:                                # ruido
                onda = rng.normal(0, 1, tamanho)
            X.append(onda + rng.normal(0, 0.25, tamanho))
            y.append(classe)
    return np.array(X)[..., None], np.array(y)

X, y = gerar()
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=3, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(128, 1)),
    layers.Conv1D(16, 9, activation="relu", padding="same"),
    layers.MaxPooling1D(4),
    layers.Conv1D(32, 5, activation="relu", padding="same"),
    layers.GlobalAveragePooling1D(),
    layers.Dense(3, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.fit(X_tr, y_tr, epochs=12, batch_size=32, verbose=0)

acc = modelo.evaluate(X_te, y_te, verbose=0)[1]
print("classes: 0 senoide, 1 quadrada, 2 ruído")
print(f"acurácia no teste: {acc:.4f}")

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(3)
t = np.linspace(0, 1, 128, endpoint=False)

exemplos = {
    "senoide": np.sin(2 * np.pi * 5 * t),
    "quadrada": np.sign(np.sin(2 * np.pi * 5 * t)),
    "ruído": rng.normal(0, 1, 128),
}

fig, eixos = plt.subplots(1, 3, figsize=(6.8, 2.0))
cores = ["#2f9e41", "#cd191e", "#101214"]
for eixo, (nome, onda), cor in zip(eixos, exemplos.items(), cores):
    eixo.plot(t, onda + rng.normal(0, 0.25, 128), color=cor,
              linewidth=0.8)
    eixo.set_title(nome, fontsize=9)
    eixo.tick_params(labelsize=6)
    eixo.grid(alpha=0.3)
fig.tight_layout()
fig.savefig("k03.png", dpi=100, bbox_inches="tight")
print("três classes com ruído aditivo")

import keras
from keras import layers

keras.utils.set_random_seed(0)

# Duas entradas: espectro e metadados do enlace
espectro = keras.Input(shape=(128,), name="espectro")
contexto = keras.Input(shape=(3,), name="contexto")

x = layers.Dense(32, activation="relu")(espectro)
x = layers.Dense(16, activation="relu")(x)
juntos = layers.Concatenate()([x, contexto])
saida = layers.Dense(1, activation="sigmoid")(juntos)

modelo = keras.Model([espectro, contexto], saida)
modelo.compile("adam", "binary_crossentropy", metrics=["accuracy"])

print("entradas:", [e.shape for e in modelo.inputs])
print("parâmetros:", modelo.count_params())

import keras
from keras import layers

keras.utils.set_random_seed(0)

entrada = keras.Input(shape=(64,))
x = layers.Dense(64, activation="relu")(entrada)
x = layers.Dense(64)(x)
somado = layers.Add()([entrada, x])        # atalho
x = layers.Activation("relu")(somado)
saida = layers.Dense(10, activation="softmax")(x)

modelo = keras.Model(entrada, saida)
print("camadas:", len(modelo.layers))
print("parâmetros:", modelo.count_params())

import numpy as np
import keras
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(1)
X, _ = load_digits(return_X_y=True)
X = X / 16.0
X_tr, X_te = train_test_split(X, test_size=0.25, random_state=1)

codificador = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(32, activation="relu"),
    layers.Dense(8, activation="relu", name="codigo"),
])
decodificador = keras.Sequential([
    layers.Input(shape=(8,)),
    layers.Dense(32, activation="relu"),
    layers.Dense(64, activation="sigmoid"),
])
auto = keras.Sequential([codificador, decodificador])
auto.compile("adam", "mse")
auto.fit(X_tr, X_tr, epochs=60, batch_size=32, verbose=0)

reconstruido = auto.predict(X_te, verbose=0)
erro = np.mean((X_te - reconstruido) ** 2)
print("dimensão original:", X.shape[1], "-> código:", 8)
print(f"erro quadrático médio da reconstrução: {erro:.5f}")
print("compressão de", round(64 / 8, 1), "vezes")

import numpy as np
import keras
import matplotlib.pyplot as plt
from keras import layers
from sklearn.datasets import load_digits

keras.utils.set_random_seed(1)
X, y = load_digits(return_X_y=True)
X = X / 16.0

auto = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(32, activation="relu"),
    layers.Dense(8, activation="relu"),
    layers.Dense(32, activation="relu"),
    layers.Dense(64, activation="sigmoid"),
])
auto.compile("adam", "mse")
auto.fit(X, X, epochs=60, batch_size=32, verbose=0)

amostras = X[:8]
saida = auto.predict(amostras, verbose=0)

fig, eixos = plt.subplots(2, 8, figsize=(6.8, 2.0))
for i in range(8):
    eixos[0, i].imshow(amostras[i].reshape(8, 8), cmap="Greys")
    eixos[1, i].imshow(saida[i].reshape(8, 8), cmap="Greys")
    for linha in (0, 1):
        eixos[linha, i].set_xticks([]); eixos[linha, i].set_yticks([])
eixos[0, 0].set_ylabel("original", fontsize=7)
eixos[1, 0].set_ylabel("recons.", fontsize=7)
fig.tight_layout()
fig.savefig("d01.png", dpi=100, bbox_inches="tight")
print("oito dígitos reconstruídos a partir de 8 números cada")

import numpy as np
import keras
import matplotlib.pyplot as plt
from keras import layers

keras.utils.set_random_seed(2)
rng = np.random.default_rng(2)

def gerar(n, tamanho=128):
    t = np.linspace(0, 1, tamanho, endpoint=False)
    limpo = np.array([np.sin(2 * np.pi * rng.uniform(2, 6) * t
                             + rng.uniform(0, 6.28)) for _ in range(n)])
    sujo = limpo + rng.normal(0, 0.5, limpo.shape)
    return sujo, limpo

X_sujo, X_limpo = gerar(3000)
T_sujo, T_limpo = gerar(200)

modelo = keras.Sequential([
    layers.Input(shape=(128,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(16, activation="relu"),
    layers.Dense(64, activation="relu"),
    layers.Dense(128),
])
modelo.compile("adam", "mse")
modelo.fit(X_sujo, X_limpo, epochs=40, batch_size=64, verbose=0)

recuperado = modelo.predict(T_sujo, verbose=0)
antes = np.mean((T_sujo - T_limpo) ** 2)
depois = np.mean((recuperado - T_limpo) ** 2)
print(f"erro antes:  {antes:.5f}")
print(f"erro depois: {depois:.5f}")
print(f"redução de ruído: {10 * np.log10(antes / depois):.2f} dB")

plt.figure(figsize=(6.6, 2.6))
plt.plot(T_sujo[0], color="#cccccc", linewidth=0.9, label="ruidoso")
plt.plot(T_limpo[0], color="#101214", linewidth=1.0, label="limpo")
plt.plot(recuperado[0], color="#2f9e41", linewidth=1.0,
         label="recuperado")
plt.legend(fontsize=8, ncol=3)
plt.grid(alpha=0.3)
plt.savefig("d02.png", dpi=100, bbox_inches="tight")

import numpy as np
import keras
import matplotlib.pyplot as plt
from keras import layers

keras.utils.set_random_seed(3)
rng = np.random.default_rng(3)

t = np.arange(1200)
serie = (20 + 5 * np.sin(2 * np.pi * t / 60)
         + 2 * np.sin(2 * np.pi * t / 17)
         + rng.normal(0, 0.4, t.size))

janela = 40
X = np.array([serie[i:i + janela] for i in range(len(serie) - janela)])
y = serie[janela:]
X = X[..., None]                      # (amostras, tempo, canais)

corte = int(len(X) * 0.8)
X_tr, X_te, y_tr, y_te = X[:corte], X[corte:], y[:corte], y[corte:]

modelo = keras.Sequential([
    layers.Input(shape=(janela, 1)),
    layers.LSTM(32),
    layers.Dense(1),
])
modelo.compile("adam", "mse", metrics=["mae"])
modelo.fit(X_tr, y_tr, epochs=15, batch_size=32, verbose=0)

previsto = modelo.predict(X_te, verbose=0).ravel()
persistencia = X_te[:, -1, 0]
print(f"erro absoluto do modelo:       "
      f"{np.abs(previsto - y_te).mean():.4f}")
print(f"erro absoluto da persistência: "
      f"{np.abs(persistencia - y_te).mean():.4f}")

plt.figure(figsize=(6.6, 2.6))
plt.plot(y_te[:150], color="#101214", linewidth=1, label="real")
plt.plot(previsto[:150], color="#2f9e41", linewidth=1,
         label="LSTM")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("d03.png", dpi=100, bbox_inches="tight")

import keras
import matplotlib.pyplot as plt
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

X, y = load_digits(return_X_y=True)
X = X / 16.0
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

plt.figure(figsize=(6.4, 2.8))
cores = {"sgd": "#101214", "rmsprop": "#cd191e", "adam": "#2f9e41"}

for nome, cor in cores.items():
    keras.utils.set_random_seed(0)
    modelo = keras.Sequential([
        layers.Input(shape=(64,)),
        layers.Dense(64, activation="relu"),
        layers.Dense(10, activation="softmax"),
    ])
    modelo.compile(nome, "sparse_categorical_crossentropy",
                   metrics=["accuracy"])
    h = modelo.fit(X_tr, y_tr, epochs=30, batch_size=32, verbose=0)
    plt.plot(h.history["loss"], color=cor, label=nome)
    print(f"{nome:<9}perda final {h.history['loss'][-1]:.4f}  "
          f"teste {modelo.evaluate(X_te, y_te, verbose=0)[1]:.4f}")

plt.xlabel("época"); plt.ylabel("perda de treino")
plt.yscale("log"); plt.legend(fontsize=8); plt.grid(alpha=0.3)
plt.savefig("d04.png", dpi=100, bbox_inches="tight")

import keras
from keras import layers, callbacks
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

X, y = load_digits(return_X_y=True)
X = X / 16.0
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

def treinar(com_bn, com_agenda):
    keras.utils.set_random_seed(0)
    camadas = [layers.Input(shape=(64,))]
    for _ in range(3):
        camadas.append(layers.Dense(128, activation="relu"))
        if com_bn:
            camadas.append(layers.BatchNormalization())
    camadas.append(layers.Dense(10, activation="softmax"))

    modelo = keras.Sequential(camadas)
    modelo.compile("adam", "sparse_categorical_crossentropy",
                   metrics=["accuracy"])
    cb = []
    if com_agenda:
        cb.append(callbacks.ReduceLROnPlateau(monitor="loss",
                                              factor=0.5,
                                              patience=3))
    modelo.fit(X_tr, y_tr, epochs=30, batch_size=32, verbose=0,
               callbacks=cb)
    return modelo.evaluate(X_te, y_te, verbose=0)[1]

for rotulo, bn, agenda in [("base", False, False),
                           ("com batchnorm", True, False),
                           ("com agenda de taxa", False, True),
                           ("com os dois", True, True)]:
    print(f"{rotulo:<22}{treinar(bn, agenda):.4f}")

import numpy as np
import keras
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(4)
X, y = load_digits(return_X_y=True)
X = X.reshape(-1, 8, 8, 1) / 16.0

# Tarefa A: muitos dados, digitos de 0 a 4
a = y < 5
modelo_a = keras.Sequential([
    layers.Input(shape=(8, 8, 1)),
    layers.Conv2D(16, 3, activation="relu", padding="same"),
    layers.MaxPooling2D(2),
    layers.Conv2D(32, 3, activation="relu", padding="same"),
    layers.Flatten(),
    layers.Dense(5, activation="softmax"),
])
modelo_a.compile("adam", "sparse_categorical_crossentropy",
                 metrics=["accuracy"])
modelo_a.fit(X[a], y[a], epochs=20, batch_size=32, verbose=0)
print(f"tarefa A (dígitos 0-4): "
      f"{modelo_a.evaluate(X[a], y[a], verbose=0)[1]:.4f}")

# Tarefa B: poucos dados, digitos de 5 a 9
b = y >= 5
Xb, yb = X[b], y[b] - 5
Xb_tr, Xb_te, yb_tr, yb_te = train_test_split(
    Xb, yb, train_size=150, random_state=0, stratify=yb)

def do_zero():
    keras.utils.set_random_seed(4)
    m = keras.Sequential([
        layers.Input(shape=(8, 8, 1)),
        layers.Conv2D(16, 3, activation="relu", padding="same"),
        layers.MaxPooling2D(2),
        layers.Conv2D(32, 3, activation="relu", padding="same"),
        layers.Flatten(),
        layers.Dense(5, activation="softmax"),
    ])
    m.compile("adam", "sparse_categorical_crossentropy",
              metrics=["accuracy"])
    return m

def transferido():
    # reaproveita as camadas ja treinadas, menos a ultima
    corpo = keras.Sequential([layers.Input(shape=(8, 8, 1))]
                             + modelo_a.layers[:-1])
    corpo.trainable = False            # congela o que ja aprendeu
    m = keras.Sequential([layers.Input(shape=(8, 8, 1)), corpo,
                          layers.Dense(5, activation="softmax")])
    m.compile("adam", "sparse_categorical_crossentropy",
              metrics=["accuracy"])
    return m

for rotulo, construir in [("do zero", do_zero),
                          ("transferido", transferido)]:
    m = construir()
    m.fit(Xb_tr, yb_tr, epochs=20, batch_size=16, verbose=0)
    print(f"tarefa B com 150 amostras, {rotulo:<12}"
          f"{m.evaluate(Xb_te, yb_te, verbose=0)[1]:.4f}")

import torch

escalar = torch.tensor(3.0)
vetor = torch.tensor([1.0, 2.0, 3.0])
matriz = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

print(vetor.shape, vetor.dtype)
print(vetor.sum(), vetor.mean())
print(matriz @ matriz)
print(torch.zeros(2, 3), torch.ones(2), torch.arange(0, 5))

# conversao com NumPy
import numpy as np
print(torch.from_numpy(np.array([1.0, 2.0])))
print(vetor.numpy())

# dispositivo
dispositivo = "cuda" if torch.cuda.is_available() else "cpu"
print("rodando em:", dispositivo)
vetor = vetor.to(dispositivo)

import torch

x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 2 * x + 1

y.backward()                  # calcula dy/dx

print("y =", y.item())        # 16.0
print("dy/dx =", x.grad.item())   # 8.0

# gradiente de uma funcao de varias variaveis
w = torch.tensor([1.0, 2.0], requires_grad=True)
perda = (w ** 2).sum()
perda.backward()
print("gradiente:", w.grad)   # tensor([2., 4.])

import torch
from torch import nn

torch.manual_seed(42)

# Forma rapida, equivalente ao Sequential do Keras
modelo = nn.Sequential(
    nn.Linear(2, 16),
    nn.ReLU(),
    nn.Linear(16, 16),
    nn.ReLU(),
    nn.Linear(16, 1),
)

# Forma explicita, usada quando a rede nao e uma pilha simples
class Rede(nn.Module):
    def __init__(self):
        super().__init__()
        self.oculta = nn.Linear(2, 16)
        self.saida = nn.Linear(16, 1)

    def forward(self, x):
        x = torch.relu(self.oculta(x))
        return self.saida(x)

rede = Rede()
print(rede)
print("parâmetros:", sum(p.numel() for p in rede.parameters()))

import torch
from torch import nn
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

torch.manual_seed(42)
X, y = make_moons(n_samples=1200, noise=0.2, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25,
                                          random_state=42)

X_tr = torch.tensor(X_tr, dtype=torch.float32)
y_tr = torch.tensor(y_tr, dtype=torch.float32).unsqueeze(1)
X_te = torch.tensor(X_te, dtype=torch.float32)
y_te = torch.tensor(y_te, dtype=torch.float32).unsqueeze(1)

modelo = nn.Sequential(nn.Linear(2, 16), nn.ReLU(),
                       nn.Linear(16, 16), nn.ReLU(),
                       nn.Linear(16, 1))
criterio = nn.BCEWithLogitsLoss()
otimizador = torch.optim.Adam(modelo.parameters(), lr=0.01)

for epoca in range(1, 201):
    modelo.train()
    otimizador.zero_grad()          # 1. zera gradientes antigos
    saida = modelo(X_tr)            # 2. propagacao direta
    perda = criterio(saida, y_tr)   # 3. calcula a perda
    perda.backward()                # 4. retropropaga
    otimizador.step()               # 5. atualiza os pesos

    if epoca % 50 == 0:
        print(f"época {epoca:>3}  perda {perda.item():.4f}")

modelo.eval()
with torch.no_grad():
    previsto = (torch.sigmoid(modelo(X_te)) >= 0.5).float()
    acuracia = (previsto == y_te).float().mean()
print(f"acurácia no teste: {acuracia.item():.4f}")

import torch
from torch.utils.data import TensorDataset, DataLoader

X = torch.randn(1000, 4)
y = torch.randint(0, 2, (1000, 1)).float()

conjunto = TensorDataset(X, y)
carregador = DataLoader(conjunto, batch_size=32, shuffle=True)

print("lotes por época:", len(carregador))
for entradas, alvos in carregador:
    print("formato do lote:", entradas.shape, alvos.shape)
    break

# dentro do treino:
# for entradas, alvos in carregador:
#     otimizador.zero_grad()
#     perda = criterio(modelo(entradas), alvos)
#     perda.backward()
#     otimizador.step()

import torch
from torch import nn

modelo = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 3))

# Recomendado: salvar apenas os pesos
torch.save(modelo.state_dict(), "modelo.pt")

novo = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 3))
novo.load_state_dict(torch.load("modelo.pt"))
novo.eval()

print("pesos carregados")

import joblib
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

X, y = load_iris(return_X_y=True)
modelo = RandomForestClassifier(random_state=0).fit(X, y)

joblib.dump(modelo, "modelo.joblib")
recarregado = joblib.load("modelo.joblib")

print("previsões idênticas?",
      (modelo.predict(X) == recarregado.predict(X)).all())
import os
print("tamanho do arquivo:",
      os.path.getsize("modelo.joblib") // 1024, "KB")

import time
import numpy as np
from sklearn.datasets import load_digits
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier

X, y = load_digits(return_X_y=True)
X = X / 16.0
amostra = X[:1]

print(f"{'modelo':<14}{'treino (s)':>12}{'1 amostra (ms)':>17}"
      f"{'1000 juntas (ms)':>18}")
for nome, modelo in [
        ("logística", LogisticRegression(max_iter=2000)),
        ("k vizinhos", KNeighborsClassifier()),
        ("floresta", RandomForestClassifier(n_estimators=200,
                                            random_state=0))]:
    t0 = time.perf_counter()
    modelo.fit(X, y)
    treino = time.perf_counter() - t0

    t0 = time.perf_counter()
    for _ in range(200):
        modelo.predict(amostra)
    uma = (time.perf_counter() - t0) / 200 * 1000

    t0 = time.perf_counter()
    modelo.predict(X[:1000])
    lote = (time.perf_counter() - t0) * 1000

    print(f"{nome:<14}{treino:>12.3f}{uma:>17.3f}{lote:>18.2f}")

import os
import joblib
from sklearn.datasets import load_digits
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier

X, y = load_digits(return_X_y=True)

for nome, modelo in [
        ("logística", LogisticRegression(max_iter=2000)),
        ("árvore", DecisionTreeClassifier(random_state=0)),
        ("floresta 200", RandomForestClassifier(n_estimators=200,
                                                random_state=0))]:
    modelo.fit(X, y)
    arquivo = f"{nome}.joblib".replace(" ", "_")
    joblib.dump(modelo, arquivo, compress=3)
    tamanho = os.path.getsize(arquivo) / 1024
    print(f"{nome:<14}{tamanho:>9.1f} KB   "
          f"acurácia {modelo.score(X, y):.4f}")

import os
import numpy as np
import keras
import tensorflow as tf
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(32, activation="relu"),
    layers.Dense(10, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.fit(X_tr, y_tr, epochs=25, batch_size=32, verbose=0)
acuracia = modelo.evaluate(X_te, y_te, verbose=0)[1]

modelo.save("modelo.keras")
modelo.export("modelo_exportado", verbose=0)

conversor = tf.lite.TFLiteConverter.from_saved_model(
    "modelo_exportado")
comum = conversor.convert()
open("modelo.tflite", "wb").write(comum)

conversor.optimizations = [tf.lite.Optimize.DEFAULT]
quantizado = conversor.convert()
open("modelo_q.tflite", "wb").write(quantizado)

print(f"acurácia do modelo treinado: {acuracia:.4f}\n")
print(f"{'formato':<22}{'KB':>9}")
print(f"{'keras':<22}{os.path.getsize('modelo.keras')/1024:>9.1f}")
print(f"{'tflite':<22}{len(comum)/1024:>9.1f}")
print(f"{'tflite quantizado':<22}{len(quantizado)/1024:>9.1f}")
print(f"\nredução pela quantização: "
      f"{100 * (1 - len(quantizado) / len(comum)):.1f}%")

import numpy as np
import keras
import tensorflow as tf
from keras import layers
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, random_state=0, stratify=y)

modelo = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(10, activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.fit(X_tr, y_tr, epochs=25, batch_size=32, verbose=0)
modelo.export("exp", verbose=0)

conversor = tf.lite.TFLiteConverter.from_saved_model("exp")
conversor.optimizations = [tf.lite.Optimize.DEFAULT]
open("q.tflite", "wb").write(conversor.convert())

interprete = tf.lite.Interpreter(model_path="q.tflite")
interprete.allocate_tensors()
entrada = interprete.get_input_details()[0]
saida = interprete.get_output_details()[0]

previstos = []
for amostra in X_te:
    interprete.set_tensor(entrada["index"], amostra[None, :])
    interprete.invoke()
    previstos.append(interprete.get_tensor(saida["index"]).argmax())

original = modelo.evaluate(X_te, y_te, verbose=0)[1]
convertido = (np.array(previstos) == y_te).mean()
print(f"acurácia no Keras:  {original:.4f}")
print(f"acurácia no TFLite: {convertido:.4f}")
print(f"diferença: {abs(original - convertido):.4f}")

import numpy as np
from scipy import stats

rng = np.random.default_rng(0)

referencia = rng.normal(-60, 3, 2000)        # medidas do treino
cenarios = {
    "sem mudança": rng.normal(-60, 3, 500),
    "deslocamento": rng.normal(-56, 3, 500),
    "mais dispersa": rng.normal(-60, 7, 500),
}

print(f"{'cenário':<16}{'média':>9}{'desvio':>9}"
      f"{'p (KS)':>10}  alerta")
for nome, atual in cenarios.items():
    _, p = stats.ks_2samp(referencia, atual)
    alerta = "SIM" if p < 0.01 else "não"
    print(f"{nome:<16}{atual.mean():>9.2f}{atual.std():>9.2f}"
          f"{p:>10.2e}  {alerta}")

import json
import numpy as np

class Preditor:
    """Encapsula validação, inferência e registro."""

    def __init__(self, modelo, nomes, versao):
        self.modelo = modelo
        self.nomes = nomes
        self.versao = versao
        self.chamadas = 0

    def prever(self, entrada):
        if len(entrada) != len(self.nomes):
            raise ValueError(
                f"esperava {len(self.nomes)} atributos, "
                f"recebi {len(entrada)}")
        vetor = np.asarray(entrada, dtype=float).reshape(1, -1)
        if not np.isfinite(vetor).all():
            raise ValueError("entrada com valor ausente ou infinito")

        prob = self.modelo.predict_proba(vetor)[0]
        self.chamadas += 1
        return {
            "classe": int(prob.argmax()),
            "confianca": round(float(prob.max()), 4),
            "versao_modelo": self.versao,
            "revisar": bool(prob.max() < 0.60),
        }

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

dados = load_iris()
modelo = RandomForestClassifier(random_state=0).fit(dados.data,
                                                    dados.target)
preditor = Preditor(modelo, dados.feature_names, "2026.07.1")

print(json.dumps(preditor.prever([5.1, 3.5, 1.4, 0.2]), indent=2))
try:
    preditor.prever([5.1, 3.5])
except ValueError as erro:
    print("\nrecusado:", erro)
print("chamadas atendidas:", preditor.chamadas)

import random
import numpy as np

def fixar_sementes(semente=42):
    """Fixa as sementes de todas as fontes de aleatoriedade."""
    random.seed(semente)
    np.random.seed(semente)
    # keras.utils.set_random_seed(semente)
    # torch.manual_seed(semente)

fixar_sementes(42)
primeiro = np.random.rand(3)

fixar_sementes(42)
segundo = np.random.rand(3)

print("mesma sequência?", np.allclose(primeiro, segundo))
print(primeiro.round(4))

import numpy as np
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.svm import SVC

X, y = load_wine(return_X_y=True)

# ERRADO: seleciona atributos usando o conjunto inteiro
X_vazado = SelectKBest(f_classif, k=5).fit_transform(X, y)
errado = cross_val_score(SVC(), StandardScaler().fit_transform(X_vazado),
                         y, cv=5).mean()

# CERTO: selecao e escala dentro do pipeline, refeitas a cada dobra
fluxo = make_pipeline(StandardScaler(),
                      SelectKBest(f_classif, k=5), SVC())
certo = cross_val_score(fluxo, X, y, cv=5).mean()

print(f"com vazamento: {errado:.4f}")
print(f"sem vazamento: {certo:.4f}")
print(f"otimismo indevido: {errado - certo:+.4f}")

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

X, y = load_digits(return_X_y=True)

X_resto, X_teste, y_resto, y_teste = train_test_split(
    X, y, test_size=0.2, random_state=0, stratify=y)
X_treino, X_val, y_treino, y_val = train_test_split(
    X_resto, y_resto, test_size=0.25, random_state=0,
    stratify=y_resto)

print(f"treino {len(y_treino)} | validação {len(y_val)} "
      f"| teste {len(y_teste)}")

melhor, melhor_n = -1, None
for n in [5, 25, 100, 300]:
    m = RandomForestClassifier(n_estimators=n, random_state=0)
    m.fit(X_treino, y_treino)
    nota = m.score(X_val, y_val)
    print(f"  n_estimators={n:>3}  validação {nota:.4f}")
    if nota > melhor:
        melhor, melhor_n = nota, n

final = RandomForestClassifier(n_estimators=melhor_n,
                               random_state=0)
final.fit(X_resto, y_resto)
print(f"\nescolhido n={melhor_n}")
print(f"acurácia no teste (usado uma única vez): "
      f"{final.score(X_teste, y_teste):.4f}")

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, recall_score,
                             f1_score, confusion_matrix)
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=2000, weights=[0.97, 0.03],
                           n_informative=5, random_state=7)
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.3, random_state=7, stratify=y)

print("proporção da classe rara:", round(y.mean(), 4))

for rotulo, peso in [("sem ajuste", None),
                     ("com class_weight", "balanced")]:
    m = LogisticRegression(max_iter=2000, class_weight=peso)
    m.fit(X_tr, y_tr)
    p = m.predict(X_te)
    print(f"\n{rotulo}")
    print(f"  acurácia  {accuracy_score(y_te, p):.4f}")
    print(f"  revocação {recall_score(y_te, p):.4f}")
    print(f"  F1        {f1_score(y_te, p):.4f}")
    print("  matriz:", confusion_matrix(y_te, p).tolist())

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import learning_curve
from sklearn.ensemble import RandomForestClassifier

X, y = load_digits(return_X_y=True)

tamanhos, treino, validacao = learning_curve(
    RandomForestClassifier(n_estimators=60, random_state=0),
    X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 8),
    random_state=0)

plt.figure(figsize=(6.4, 2.9))
plt.plot(tamanhos, treino.mean(axis=1), "o-", color="#2f9e41",
         label="treino")
plt.plot(tamanhos, validacao.mean(axis=1), "s--", color="#cd191e",
         label="validação")
plt.xlabel("amostras de treino")
plt.ylabel("acurácia")
plt.legend(fontsize=8)
plt.grid(alpha=0.3)
plt.savefig("m05.png", dpi=100, bbox_inches="tight")

print("com 10% dos dados:", round(validacao.mean(axis=1)[0], 4))
print("com 100% dos dados:", round(validacao.mean(axis=1)[-1], 4))