ETAPAS = [
    ("1", "REQUISITOS",
     "não é acurácia: é utilidade, custo e risco"),
    ("2", "DADOS",
     "corpus, licença, tokenização e representação"),
    ("3", "TREINAMENTO",
     "pré-treino caríssimo, ajuste fino barato"),
    ("4", "AVALIAÇÃO",
     "sem gabarito único: perplexidade, humano, juiz"),
    ("5", "PREDIÇÃO",
     "geração com amostragem, e o contexto que você monta"),
    ("6", "EXPORTAÇÃO",
     "quantização, servidor, custo por token"),
]

MUDA = {
    "1": "o erro não é binário, é uma resposta ruim",
    "2": "o dado é o próprio texto, sem rótulo humano",
    "3": "quase ninguém treina do zero: adapta",
    "4": "duas respostas diferentes podem estar certas",
    "5": "a mesma entrada pode dar saídas diferentes",
    "6": "o modelo raramente cabe na sua máquina",
}

LARGURA = 56
for numero, titulo, detalhe in ETAPAS:
    print("+" + "=" * (LARGURA - 2) + "+")
    print("| " + f"{numero}  {titulo}".ljust(LARGURA - 4) + " |")
    print("| " + f"   {detalhe}".ljust(LARGURA - 4) + " |")
    print("| " + f"   >> {MUDA[numero]}".ljust(LARGURA - 4) + " |")
print("+" + "=" * (LARGURA - 2) + "+")

import numpy as np
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB

X, y = load_digits(return_X_y=True)
X = X / 16.0

discriminativo = LogisticRegression(max_iter=2000).fit(X, y)
generativo = GaussianNB().fit(X, y)

print("ambos classificam:")
print(f"  logística (discriminativa): {discriminativo.score(X, y):.4f}")
print(f"  naive bayes (generativo):   {generativo.score(X, y):.4f}")

# so o generativo sabe produzir uma amostra nova
rng = np.random.default_rng(0)
classe = 3
amostra = rng.normal(generativo.theta_[classe],
                     np.sqrt(generativo.var_[classe]))

print(f"\namostra sintética da classe {classe}:")
for linha in amostra.reshape(8, 8):
    print("  " + "".join("#" if v > 0.6 else ("+" if v > 0.25 else ".")
                         for v in linha))

frase = "o transformador aquece rapidamente"

por_caractere = list(frase)
por_palavra = frase.split()

print("caracteres:", len(por_caractere), "tokens |",
      len(set(por_caractere)), "símbolos distintos")
print("palavras:  ", len(por_palavra), "tokens |",
      len(set(por_palavra)), "símbolos distintos")
print()
print("por caractere: vocabulário minúsculo, sequências longas")
print("por palavra:   sequências curtas, vocabulário imenso")
print("subpalavra:    o meio-termo que todos usam hoje")

from collections import Counter

CORPUS = ("antena antenas antenado transmissor transmissores "
          "receptor receptores transmitir receber ") * 30

def preparar(corpus):
    """Cada palavra vira uma lista de caracteres com marca de fim."""
    contagem = Counter(corpus.split())
    return {tuple(list(p) + ["_"]): n for p, n in contagem.items()}

def pares_frequentes(palavras):
    pares = Counter()
    for simbolos, n in palavras.items():
        for i in range(len(simbolos) - 1):
            pares[(simbolos[i], simbolos[i + 1])] += n
    return pares

def fundir(palavras, par):
    novo = {}
    for simbolos, n in palavras.items():
        saida, i = [], 0
        while i < len(simbolos):
            if (i < len(simbolos) - 1
                    and (simbolos[i], simbolos[i + 1]) == par):
                saida.append(simbolos[i] + simbolos[i + 1])
                i += 2
            else:
                saida.append(simbolos[i])
                i += 1
        novo[tuple(saida)] = n
    return novo

palavras = preparar(CORPUS)
print("início:", list(palavras)[0])

fusoes = []
for rodada in range(14):
    pares = pares_frequentes(palavras)
    if not pares:
        break
    melhor = pares.most_common(1)[0][0]
    fusoes.append(melhor)
    palavras = fundir(palavras, melhor)

print("\nfusões aprendidas:", [a + b for a, b in fusoes])
print("\npalavras tokenizadas ao final:")
for simbolos in list(palavras)[:5]:
    print("  ", " ".join(simbolos))

import numpy as np
import keras
from keras import layers

keras.utils.set_random_seed(0)
VOCAB, DIMENSAO = 12, 4

camada = layers.Embedding(VOCAB, DIMENSAO)
tokens = np.array([[3, 7, 1]])
vetores = camada(tokens).numpy()

print("entrada:", tokens.shape, "->", "saída:", vetores.shape)
print("\nvetor do token 3:", vetores[0, 0].round(4))
print("a tabela inteira tem", VOCAB * DIMENSAO, "parâmetros")
print("todos treináveis: começam ao acaso e aprendem")

import numpy as np
import keras
from keras import layers

keras.utils.set_random_seed(1)

FRASES = [
    "a antena transmite o sinal", "a antena recebe o sinal",
    "o radio transmite o sinal", "o radio recebe o sinal",
    "o cabo conduz o sinal", "a fibra conduz o sinal",
    "o tecnico instala a antena", "o tecnico instala o radio",
    "o tecnico instala o cabo", "o tecnico instala a fibra",
    "a antena tem ganho", "o radio tem potencia",
    "o cabo tem perda", "a fibra tem perda",
] * 40

palavras = sorted({p for f in FRASES for p in f.split()})
idx = {p: i for i, p in enumerate(palavras)}

# tarefa auxiliar: prever a palavra do meio pelo contexto
entradas, alvos = [], []
for frase in FRASES:
    t = [idx[p] for p in frase.split()]
    for i in range(1, len(t) - 1):
        entradas.append([t[i - 1], t[i + 1]])
        alvos.append(t[i])
entradas, alvos = np.array(entradas), np.array(alvos)

modelo = keras.Sequential([
    layers.Input(shape=(2,)),
    layers.Embedding(len(palavras), 8),
    layers.GlobalAveragePooling1D(),
    layers.Dense(len(palavras), activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy")
modelo.fit(entradas, alvos, epochs=120, batch_size=64, verbose=0)

E = modelo.layers[0].embeddings.numpy()
E = E / np.linalg.norm(E, axis=1, keepdims=True)

def vizinhos(palavra, n=3):
    similar = E @ E[idx[palavra]]
    ordem = np.argsort(similar)[::-1]
    return [(palavras[i], round(float(similar[i]), 3))
            for i in ordem if palavras[i] != palavra][:n]

for p in ["antena", "transmite", "tecnico"]:
    print(f"{p:<12} vizinhos: {vizinhos(p)}")

import numpy as np

def cosseno(a, b):
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))

vetores = {
    "antena":  np.array([0.9, 0.1, 0.2]),
    "radio":   np.array([0.85, 0.15, 0.25]),
    "fatura":  np.array([0.1, 0.9, 0.3]),
}

print(f"{'par':<22}{'cosseno':>9}")
for a in vetores:
    for b in vetores:
        if a < b:
            print(f"{a + ' x ' + b:<22}{cosseno(vetores[a], vetores[b]):>9.4f}")

print("\n1.0 = mesma direção | 0.0 = sem relação | -1.0 = oposto")
print("é a métrica usada em toda busca vetorial, inclusive no RAG")

import numpy as np
import keras
import matplotlib.pyplot as plt
from keras import layers
from sklearn.decomposition import PCA

keras.utils.set_random_seed(1)
FRASES = [
    "a antena transmite o sinal", "a antena recebe o sinal",
    "o radio transmite o sinal", "o radio recebe o sinal",
    "o cabo conduz o sinal", "a fibra conduz o sinal",
    "o tecnico instala a antena", "o tecnico instala o radio",
    "o tecnico instala o cabo", "o tecnico instala a fibra",
    "a antena tem ganho", "o radio tem potencia",
    "o cabo tem perda", "a fibra tem perda",
] * 40
palavras = sorted({p for f in FRASES for p in f.split()})
idx = {p: i for i, p in enumerate(palavras)}
entradas, alvos = [], []
for frase in FRASES:
    t = [idx[p] for p in frase.split()]
    for i in range(1, len(t) - 1):
        entradas.append([t[i - 1], t[i + 1]]); alvos.append(t[i])

modelo = keras.Sequential([
    layers.Input(shape=(2,)),
    layers.Embedding(len(palavras), 8),
    layers.GlobalAveragePooling1D(),
    layers.Dense(len(palavras), activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy")
modelo.fit(np.array(entradas), np.array(alvos), epochs=120,
           batch_size=64, verbose=0)

E = modelo.layers[0].embeddings.numpy()
plano = PCA(n_components=2, random_state=0).fit_transform(E)

plt.figure(figsize=(5.6, 3.6))
plt.scatter(plano[:, 0], plano[:, 1], s=18, color="#2f9e41")
for i, p in enumerate(palavras):
    plt.annotate(p, plano[i], fontsize=7,
                 xytext=(3, 3), textcoords="offset points")
plt.grid(alpha=0.3)
plt.tick_params(labelsize=7)
plt.savefig("g01.png", dpi=100, bbox_inches="tight")
print("espaço de", E.shape[1], "dimensões projetado em 2")

import numpy as np

rng = np.random.default_rng(0)
n_posicoes, dimensao = 5, 8

X = rng.normal(size=(n_posicoes, dimensao))
Wq = rng.normal(size=(dimensao, dimensao)) * 0.3
Wk = rng.normal(size=(dimensao, dimensao)) * 0.3
Wv = rng.normal(size=(dimensao, dimensao)) * 0.3

Q, K, V = X @ Wq, X @ Wk, X @ Wv

escores = Q @ K.T / np.sqrt(dimensao)
pesos = np.exp(escores - escores.max(axis=1, keepdims=True))
pesos /= pesos.sum(axis=1, keepdims=True)      # softmax por linha
saida = pesos @ V

print("matriz de atenção (linha = posição que consulta):")
for i, linha in enumerate(pesos):
    barras = "".join("#" if p > 0.25 else ("+" if p > 0.12 else ".")
                     for p in linha)
    print(f"  pos {i}: {linha.round(3)}  {barras}")
print("\ncada linha soma:", pesos.sum(axis=1).round(6))
print("formato da saída:", saida.shape)

import numpy as np

n = 6
escores = np.zeros((n, n))
mascara = np.triu(np.ones((n, n), dtype=bool), k=1)
escores[mascara] = -np.inf

pesos = np.exp(escores - escores.max(axis=1, keepdims=True))
pesos /= pesos.sum(axis=1, keepdims=True)

print("quem cada posição pode olhar:")
for i, linha in enumerate(pesos):
    print(f"  pos {i}: " + " ".join("#" if p > 0 else "."
                                    for p in linha))

import numpy as np
import matplotlib.pyplot as plt

def codificar(posicoes, dimensao):
    pos = np.arange(posicoes)[:, None]
    i = np.arange(dimensao)[None, :]
    angulo = pos / np.power(10000, (2 * (i // 2)) / dimensao)
    codigo = np.zeros((posicoes, dimensao))
    codigo[:, 0::2] = np.sin(angulo[:, 0::2])
    codigo[:, 1::2] = np.cos(angulo[:, 1::2])
    return codigo

codigo = codificar(64, 32)

plt.figure(figsize=(5.4, 2.8))
plt.imshow(codigo.T, aspect="auto", cmap="RdYlGn")
plt.colorbar(shrink=0.8)
plt.xlabel("posição na sequência")
plt.ylabel("dimensão")
plt.tick_params(labelsize=7)
plt.savefig("t01.png", dpi=100, bbox_inches="tight")

print("formato:", codigo.shape)
print("posições próximas têm códigos parecidos:")
for a, b in [(0, 1), (0, 5), (0, 40)]:
    similar = codigo[a] @ codigo[b] / (np.linalg.norm(codigo[a])
                                       * np.linalg.norm(codigo[b]))
    print(f"  similaridade entre {a:>2} e {b:>2}: {similar:+.4f}")

import keras
from keras import layers

keras.utils.set_random_seed(0)

def bloco_transformer(x, cabecas=2, dim_ff=64, taxa=0.1):
    dim = x.shape[-1]
    atencao = layers.MultiHeadAttention(num_heads=cabecas,
                                        key_dim=dim)(x, x)
    atencao = layers.Dropout(taxa)(atencao)
    x = layers.LayerNormalization(epsilon=1e-6)(x + atencao)

    ff = layers.Dense(dim_ff, activation="relu")(x)
    ff = layers.Dense(dim)(ff)
    ff = layers.Dropout(taxa)(ff)
    return layers.LayerNormalization(epsilon=1e-6)(x + ff)

entrada = keras.Input(shape=(32, 16))
saida = bloco_transformer(entrada)
modelo = keras.Model(entrada, saida)

modelo.summary()

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:
                onda = np.sin(2 * np.pi * f * t + fase)
            elif classe == 1:
                onda = np.sign(np.sin(2 * np.pi * f * t + fase))
            else:
                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)

entrada = keras.Input(shape=(128, 1))
# reduz a sequencia e cria canais antes da atencao
x = layers.Conv1D(16, 7, strides=4, activation="relu",
                  padding="same")(entrada)
atencao = layers.MultiHeadAttention(num_heads=2, key_dim=16)(x, x)
x = layers.LayerNormalization(epsilon=1e-6)(x + atencao)
x = layers.GlobalAveragePooling1D()(x)
saida = layers.Dense(3, activation="softmax")(x)

modelo = keras.Model(entrada, saida)
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
modelo.fit(X_tr, y_tr, epochs=12, batch_size=32, verbose=0)

print("parâmetros:", modelo.count_params())
print(f"acurácia no teste: "
      f"{modelo.evaluate(X_te, y_te, verbose=0)[1]:.4f}")
print("compare com a CNN 1D da seção 40")

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

keras.utils.set_random_seed(5)
rng = np.random.default_rng(5)
t = np.linspace(0, 1, 64, endpoint=False)

# sinal com um estouro no meio: a atencao deveria olhar para la
X, y = [], []
for _ in range(1500):
    onda = 0.3 * np.sin(2 * np.pi * 4 * t) + rng.normal(0, 0.1, 64)
    tem = rng.random() < 0.5
    if tem:
        inicio = rng.integers(20, 40)
        onda[inicio:inicio + 6] += 2.5
    X.append(onda); y.append(int(tem))
X = np.array(X)[..., None]; y = np.array(y)

entrada = keras.Input(shape=(64, 1))
x = layers.Dense(8)(entrada)
camada = layers.MultiHeadAttention(num_heads=1, key_dim=8)
contexto, pesos = camada(x, x, return_attention_scores=True)
x = layers.GlobalAveragePooling1D()(contexto)
modelo = keras.Model(entrada, layers.Dense(1, "sigmoid")(x))
modelo.compile("adam", "binary_crossentropy", metrics=["accuracy"])
modelo.fit(X, y, epochs=8, batch_size=64, verbose=0)
print(f"acurácia: {modelo.evaluate(X, y, verbose=0)[1]:.4f}")

espiao = keras.Model(entrada, pesos)
exemplo = X[np.argmax(y)][None, ...]
mapa = espiao.predict(exemplo, verbose=0)[0, 0].mean(axis=0)

fig, (cima, baixo) = plt.subplots(2, 1, figsize=(6.2, 2.8),
                                  sharex=True)
cima.plot(exemplo[0, :, 0], color="#101214", linewidth=1)
cima.set_ylabel("sinal", fontsize=8)
baixo.bar(range(64), mapa, color="#2f9e41", width=1.0)
baixo.set_ylabel("atenção", fontsize=8)
baixo.set_xlabel("amostra", fontsize=8)
for eixo in (cima, baixo):
    eixo.tick_params(labelsize=7); eixo.grid(alpha=0.3)
fig.tight_layout()
fig.savefig("t02.png", dpi=100, bbox_inches="tight")
print("posição de maior atenção:", int(np.argmax(mapa)))

import numpy as np
import keras
from keras import layers, ops

class Amostrar(layers.Layer):
    """Sorteia z = media + desvio * ruido, de forma derivável."""

    def call(self, entradas):
        media, log_var = entradas
        ruido = keras.random.normal(shape=ops.shape(media))
        return media + ops.exp(0.5 * log_var) * ruido

keras.utils.set_random_seed(0)
media = ops.convert_to_tensor(np.array([[0.0, 0.0]], "float32"))
log_var = ops.convert_to_tensor(np.array([[0.0, 0.0]], "float32"))

camada = Amostrar()
for i in range(3):
    print(f"sorteio {i + 1}:", camada([media, log_var]).numpy().round(4))

print("\nmesma média, saídas diferentes: é isso que permite gerar")
print("o ruído entra por fora, então o gradiente ainda passa")

import numpy as np
import tensorflow as tf
import keras
from keras import layers, ops
from sklearn.datasets import load_digits

keras.utils.set_random_seed(0)
X, _ = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")

LATENTE = 2

class Amostrar(layers.Layer):
    def call(self, e):
        media, log_var = e
        ruido = keras.random.normal(shape=ops.shape(media))
        return media + ops.exp(0.5 * log_var) * ruido

entrada = keras.Input(shape=(64,))
h = layers.Dense(48, activation="relu")(entrada)
media = layers.Dense(LATENTE)(h)
log_var = layers.Dense(LATENTE)(h)
codificador = keras.Model(entrada, [media, log_var,
                                    Amostrar()([media, log_var])])

z = keras.Input(shape=(LATENTE,))
d = layers.Dense(48, activation="relu")(z)
decodificador = keras.Model(z, layers.Dense(64, activation="sigmoid")(d))

class VAE(keras.Model):
    def __init__(self, cod, dec):
        super().__init__()
        self.cod, self.dec = cod, dec

    def call(self, x):
        return self.dec(self.cod(x)[2])

    def train_step(self, dados):
        x = dados[0] if isinstance(dados, tuple) else dados
        with tf.GradientTape() as fita:
            media, log_var, z = self.cod(x)
            reconstruido = self.dec(z)
            erro = ops.sum(keras.losses.binary_crossentropy(
                x, reconstruido))
            kl = -0.5 * ops.sum(1 + log_var - ops.square(media)
                                - ops.exp(log_var))
            perda = erro + kl
        gradientes = fita.gradient(perda, self.trainable_weights)
        self.optimizer.apply_gradients(
            zip(gradientes, self.trainable_weights))
        return {"perda": perda, "reconstrucao": erro, "kl": kl}

vae = VAE(codificador, decodificador)
vae.compile(optimizer="adam")
historico = vae.fit(X, epochs=60, batch_size=64, verbose=0)

for chave in ["perda", "reconstrucao", "kl"]:
    serie = historico.history[chave]
    print(f"{chave:<14} início {serie[0]:>10.1f}  "
          f"fim {serie[-1]:>10.1f}")

import numpy as np
import tensorflow as tf
import keras
import matplotlib.pyplot as plt
from keras import layers, ops
from sklearn.datasets import load_digits

keras.utils.set_random_seed(0)
X, _ = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")

class Amostrar(layers.Layer):
    def call(self, e):
        m, lv = e
        return m + ops.exp(0.5 * lv) * keras.random.normal(
            shape=ops.shape(m))

entrada = keras.Input(shape=(64,))
h = layers.Dense(48, activation="relu")(entrada)
media = layers.Dense(2)(h); log_var = layers.Dense(2)(h)
cod = keras.Model(entrada, [media, log_var,
                            Amostrar()([media, log_var])])
z = keras.Input(shape=(2,))
dec = keras.Model(z, layers.Dense(64, activation="sigmoid")(
    layers.Dense(48, activation="relu")(z)))

class VAE(keras.Model):
    def __init__(s, c, d):
        super().__init__(); s.c, s.d = c, d
    def call(s, x):
        return s.d(s.c(x)[2])
    def train_step(s, dados):
        x = dados[0] if isinstance(dados, tuple) else dados
        with tf.GradientTape() as fita:
            m, lv, zz = s.c(x)
            erro = ops.sum(keras.losses.binary_crossentropy(x, s.d(zz)))
            kl = -0.5 * ops.sum(1 + lv - ops.square(m) - ops.exp(lv))
            perda = erro + kl
        g = fita.gradient(perda, s.trainable_weights)
        s.optimizer.apply_gradients(zip(g, s.trainable_weights))
        return {"perda": perda}

vae = VAE(cod, dec); vae.compile(optimizer="adam")
vae.fit(X, epochs=60, batch_size=64, verbose=0)

# percorre o espaco latente em grade
passos = np.linspace(-2, 2, 9)
grade = np.zeros((8 * 9, 8 * 9))
for i, a in enumerate(passos):
    for j, b in enumerate(passos):
        imagem = dec.predict(np.array([[a, b]]), verbose=0)
        grade[i * 8:(i + 1) * 8, j * 8:(j + 1) * 8] = imagem.reshape(8, 8)

plt.figure(figsize=(4.2, 4.2))
plt.imshow(grade, cmap="Greys")
plt.xticks([]); plt.yticks([])
plt.savefig("v01.png", dpi=100, bbox_inches="tight")

print("81 dígitos gerados a partir de 2 números cada")
print("nenhum deles existe no conjunto de treino")
print("andar no espaço latente transforma um dígito no outro")

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

keras.utils.set_random_seed(2)
X, _ = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")
RUIDO = 16

gerador = keras.Sequential([
    layers.Input(shape=(RUIDO,)),
    layers.Dense(64, activation="relu"),
    layers.Dense(64, activation="sigmoid"),
])
discriminador = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(64, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(1),
])

perda = keras.losses.BinaryCrossentropy(from_logits=True)
otim_g = keras.optimizers.Adam(2e-4)
otim_d = keras.optimizers.Adam(2e-4)

def passo(lote):
    ruido = tf.random.normal([len(lote), RUIDO])
    with tf.GradientTape() as tg, tf.GradientTape() as td:
        falsas = gerador(ruido, training=True)
        julga_real = discriminador(lote, training=True)
        julga_falsa = discriminador(falsas, training=True)

        perda_g = perda(tf.ones_like(julga_falsa), julga_falsa)
        perda_d = (perda(tf.ones_like(julga_real), julga_real)
                   + perda(tf.zeros_like(julga_falsa), julga_falsa))

    otim_g.apply_gradients(zip(
        tg.gradient(perda_g, gerador.trainable_variables),
        gerador.trainable_variables))
    otim_d.apply_gradients(zip(
        td.gradient(perda_d, discriminador.trainable_variables),
        discriminador.trainable_variables))
    return float(perda_g), float(perda_d)

rng = np.random.default_rng(0)
for epoca in range(1, 61):
    rng.shuffle(X)
    for i in range(0, len(X), 64):
        pg, pd = passo(X[i:i + 64])
    if epoca % 20 == 0:
        print(f"época {epoca:>3}  perda do gerador {pg:.4f}  "
              f"do discriminador {pd:.4f}")

amostras = gerador.predict(tf.random.normal([2, RUIDO]), verbose=0)
print("\ndois dígitos gerados:")
for amostra in amostras:
    for linha in amostra.reshape(8, 8):
        print("  " + "".join("#" if v > 0.6 else
                             ("+" if v > 0.3 else ".") for v in linha))
    print()

import numpy as np

PASSOS = 10
betas = np.linspace(1e-4, 0.35, PASSOS)
alfas = np.cumprod(1 - betas)          # quanto sobra do original

rng = np.random.default_rng(0)
original = np.sin(np.linspace(0, 4 * np.pi, 24))

print(f"{'passo':>6}{'sinal restante':>16}{'ruído':>9}   forma")
for t in [0, 3, 6, 9]:
    a = alfas[t]
    ruidoso = np.sqrt(a) * original + np.sqrt(1 - a) * rng.normal(size=24)
    traco = "".join("#" if v > 0.4 else ("+" if v > -0.4 else ".")
                    for v in ruidoso)
    print(f"{t:>6}{np.sqrt(a):>16.3f}{np.sqrt(1 - a):>9.3f}   {traco}")

import numpy as np
import keras
from keras import layers

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

TAMANHO, PASSOS = 32, 40
betas = np.linspace(1e-4, 0.2, PASSOS).astype("float32")
alfas = np.cumprod(1 - betas).astype("float32")

# dados reais: senoides de frequencia e fase variadas
t = np.linspace(0, 1, TAMANHO, endpoint=False)
reais = np.array([np.sin(2 * np.pi * rng.uniform(1, 3) * t
                         + rng.uniform(0, 6.28))
                  for _ in range(4000)], dtype="float32")

# cada exemplo de treino: sinal ruidoso + o passo, alvo = o ruido
passos = rng.integers(0, PASSOS, len(reais))
ruidos = rng.normal(size=reais.shape).astype("float32")
a = alfas[passos][:, None]
ruidosos = np.sqrt(a) * reais + np.sqrt(1 - a) * ruidos
entrada_passo = (passos / PASSOS).astype("float32")[:, None]

sinal = keras.Input(shape=(TAMANHO,))
quando = keras.Input(shape=(1,))
x = layers.Concatenate()([sinal, quando])
x = layers.Dense(128, activation="relu")(x)
x = layers.Dense(128, activation="relu")(x)
modelo = keras.Model([sinal, quando], layers.Dense(TAMANHO)(x))
modelo.compile("adam", "mse")

h = modelo.fit([ruidosos, entrada_passo], ruidos,
               epochs=30, batch_size=64, verbose=0)
print(f"erro ao prever o ruído: início {h.history['loss'][0]:.4f}  "
      f"fim {h.history['loss'][-1]:.4f}")
print("a rede aprendeu a enxergar o ruído dentro do sinal")

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

keras.utils.set_random_seed(0)
rng = np.random.default_rng(0)
TAMANHO, PASSOS = 32, 40
betas = np.linspace(1e-4, 0.2, PASSOS).astype("float32")
alfas_passo = (1 - betas)
alfas = np.cumprod(alfas_passo).astype("float32")

t = np.linspace(0, 1, TAMANHO, endpoint=False)
reais = np.array([np.sin(2 * np.pi * rng.uniform(1, 3) * t
                         + rng.uniform(0, 6.28))
                  for _ in range(4000)], dtype="float32")
passos = rng.integers(0, PASSOS, len(reais))
ruidos = rng.normal(size=reais.shape).astype("float32")
a = alfas[passos][:, None]
ruidosos = np.sqrt(a) * reais + np.sqrt(1 - a) * ruidos

sinal = keras.Input(shape=(TAMANHO,)); quando = keras.Input(shape=(1,))
x = layers.Concatenate()([sinal, quando])
x = layers.Dense(128, activation="relu")(x)
x = layers.Dense(128, activation="relu")(x)
modelo = keras.Model([sinal, quando], layers.Dense(TAMANHO)(x))
modelo.compile("adam", "mse")
modelo.fit([ruidosos, (passos / PASSOS).astype("float32")[:, None]],
           ruidos, epochs=30, batch_size=64, verbose=0)

# amostragem reversa: do passo final ate o zero
x_t = rng.normal(size=(1, TAMANHO)).astype("float32")
registro = {}
for passo in reversed(range(PASSOS)):
    previsto = modelo.predict(
        [x_t, np.array([[passo / PASSOS]], "float32")], verbose=0)
    termo = (1 - alfas_passo[passo]) / np.sqrt(1 - alfas[passo])
    x_t = (x_t - termo * previsto) / np.sqrt(alfas_passo[passo])
    if passo > 0:
        x_t += np.sqrt(betas[passo]) * rng.normal(size=x_t.shape)
    if passo in (39, 26, 13, 0):
        registro[passo] = x_t[0].copy()

fig, eixos = plt.subplots(1, 4, figsize=(6.8, 1.9))
for eixo, passo in zip(eixos, [39, 26, 13, 0]):
    eixo.plot(registro[passo], color="#2f9e41", linewidth=1)
    eixo.set_title(f"passo {passo}", fontsize=8)
    eixo.set_xticks([]); eixo.set_yticks([])
fig.tight_layout()
fig.savefig("v02.png", dpi=100, bbox_inches="tight")

print("de ruído puro a uma senoide, em 40 passos")
print("desvio padrão ao longo da geração:")
for passo in [39, 26, 13, 0]:
    print(f"  passo {passo:>2}: {registro[passo].std():.4f}")

import numpy as np
import keras
from keras import layers

keras.utils.set_random_seed(0)

TEXTO = ("a antena transmite o sinal. o radio recebe o sinal. "
         "o tecnico instala a antena. o cabo conduz o sinal. "
         "a fibra conduz o sinal sem perda. ") * 120

vocabulario = sorted(set(TEXTO))
para_id = {c: i for i, c in enumerate(vocabulario)}
para_char = {i: c for c, i in para_id.items()}
sequencia = np.array([para_id[c] for c in TEXTO])

JANELA = 24
X = np.array([sequencia[i:i + JANELA]
              for i in range(len(sequencia) - JANELA)])
y = sequencia[JANELA:]

modelo = keras.Sequential([
    layers.Input(shape=(JANELA,)),
    layers.Embedding(len(vocabulario), 24),
    layers.LSTM(96),
    layers.Dense(len(vocabulario), activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
h = modelo.fit(X, y, epochs=25, batch_size=128, verbose=0)

print("vocabulário:", len(vocabulario), "símbolos")
print("exemplos de treino:", len(X))
print(f"acurácia do próximo caractere: "
      f"{h.history['accuracy'][-1]:.4f}")

import numpy as np
import keras
from keras import layers

keras.utils.set_random_seed(0)
TEXTO = ("a antena transmite o sinal. o radio recebe o sinal. "
         "o tecnico instala a antena. o cabo conduz o sinal. "
         "a fibra conduz o sinal sem perda. ") * 120
vocabulario = sorted(set(TEXTO))
para_id = {c: i for i, c in enumerate(vocabulario)}
para_char = {i: c for c, i in para_id.items()}
seq = np.array([para_id[c] for c in TEXTO])
JANELA = 24
X = np.array([seq[i:i + JANELA] for i in range(len(seq) - JANELA)])
y = seq[JANELA:]

modelo = keras.Sequential([
    layers.Input(shape=(JANELA,)),
    layers.Embedding(len(vocabulario), 24),
    layers.LSTM(96),
    layers.Dense(len(vocabulario), activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy")
modelo.fit(X, y, epochs=25, batch_size=128, verbose=0)

def gerar(semente, quantidade=90, temperatura=1.0, rng=None):
    rng = rng or np.random.default_rng(0)
    contexto = [para_id[c] for c in semente[-JANELA:]]
    saida = semente
    for _ in range(quantidade):
        entrada = np.array([contexto[-JANELA:]])
        prob = modelo.predict(entrada, verbose=0)[0]
        if temperatura <= 0.01:
            escolhido = int(prob.argmax())
        else:
            logs = np.log(prob + 1e-9) / temperatura
            ajustada = np.exp(logs - logs.max())
            ajustada /= ajustada.sum()
            escolhido = int(rng.choice(len(prob), p=ajustada))
        contexto.append(escolhido)
        saida += para_char[escolhido]
    return saida

semente = "a antena transmite o sin"
for temperatura in [0.0, 0.5, 1.2]:
    rotulo = "greedy" if temperatura == 0 else f"T={temperatura}"
    print(f"[{rotulo}] {gerar(semente, 80, temperatura)}")
    print()

import numpy as np

# distribuicao hipotetica do proximo token
vocab = ["sinal", "cabo", "ruido", "antena", "xyz", "qwe"]
prob = np.array([0.55, 0.20, 0.12, 0.08, 0.03, 0.02])

def top_k(prob, k):
    corte = np.argsort(prob)[::-1][:k]
    nova = np.zeros_like(prob); nova[corte] = prob[corte]
    return nova / nova.sum()

def top_p(prob, p):
    ordem = np.argsort(prob)[::-1]
    acumulada = np.cumsum(prob[ordem])
    manter = ordem[:np.searchsorted(acumulada, p) + 1]
    nova = np.zeros_like(prob); nova[manter] = prob[manter]
    return nova / nova.sum()

print(f"{'token':<9}{'original':>10}{'top-k 3':>10}{'top-p 0.9':>12}")
k3, p9 = top_k(prob, 3), top_p(prob, 0.9)
for i, token in enumerate(vocab):
    print(f"{token:<9}{prob[i]:>10.3f}{k3[i]:>10.3f}{p9[i]:>12.3f}")

print("\ntop-k corta em quantidade fixa")
print("top-p corta por massa de probabilidade: adapta ao contexto")

import numpy as np
import keras
from keras import layers

keras.utils.set_random_seed(0)
TEXTO = ("a antena transmite o sinal. o radio recebe o sinal. "
         "o tecnico instala a antena. o cabo conduz o sinal. "
         "a fibra conduz o sinal sem perda. ") * 120
vocab = sorted(set(TEXTO))
para_id = {c: i for i, c in enumerate(vocab)}
seq = np.array([para_id[c] for c in TEXTO])
JANELA = 24
X = np.array([seq[i:i + JANELA] for i in range(len(seq) - JANELA)])
y = seq[JANELA:]
corte = int(len(X) * 0.9)

modelo = keras.Sequential([
    layers.Input(shape=(JANELA,)),
    layers.Embedding(len(vocab), 24),
    layers.LSTM(96),
    layers.Dense(len(vocab), activation="softmax"),
])
modelo.compile("adam", "sparse_categorical_crossentropy")

def perplexidade(X, y):
    prob = modelo.predict(X, verbose=0)
    certas = prob[np.arange(len(y)), y]
    return float(np.exp(-np.log(certas + 1e-9).mean()))

print(f"perplexidade de um modelo ao acaso: {len(vocab):.1f}")
print(f"antes do treino: {perplexidade(X[corte:], y[corte:]):.3f}")

for epocas in [5, 15, 30]:
    modelo.fit(X[:corte], y[:corte], epochs=epocas - 
               (0 if epocas == 5 else (5 if epocas == 15 else 15)),
               batch_size=128, verbose=0)
    print(f"após {epocas:>2} épocas: "
          f"{perplexidade(X[corte:], y[corte:]):.3f}")

print("\nperplexidade = quantas opções o modelo considera, em média")
print("quanto menor, mais certeza ele tem do próximo símbolo")

FASES = [
    ("PRÉ-TREINO", "trilhões de tokens da web",
     "prever o próximo token", "meses, milhares de GPUs"),
    ("AJUSTE DE INSTRUÇÃO", "milhares de pares pedido-resposta",
     "seguir instruções", "horas ou dias"),
    ("ALINHAMENTO", "comparações feitas por pessoas",
     "preferir respostas úteis e seguras", "dias"),
]

for i, (nome, dados, objetivo, custo) in enumerate(FASES, 1):
    print("+" + "-" * 62 + "+")
    print(f"| {i}. {nome:<58} |")
    print(f"|    dados:    {dados:<47} |")
    print(f"|    objetivo: {objetivo:<47} |")
    print(f"|    custo:    {custo:<47} |")
print("+" + "-" * 62 + "+")
print("\nquem usa a API pega o modelo depois das três fases")
print("a seção 53 mostra como adaptar sem repetir nenhuma delas")

# Instale antes: pip install openai
from openai import OpenAI

cliente = OpenAI(api_key="sua-chave-aqui")

resposta = cliente.chat.completions.create(
    model="um-modelo-de-chat",
    messages=[
        {"role": "system",
         "content": "Você é um assistente técnico de "
                    "telecomunicações. Responda de forma "
                    "objetiva e cite a unidade de cada grandeza."},
        {"role": "user",
         "content": "O que significa um enlace com RSSI de "
                    "-95 dBm?"},
    ],
    temperature=0.2,      # baixa: respostas mais previsíveis
    max_tokens=300,
)

print(resposta.choices[0].message.content)
print("tokens consumidos:", resposta.usage.total_tokens)

historico = [
    {"role": "system", "content": "Assistente de laboratório."},
]

def perguntar(cliente, texto):
    """Acrescenta a pergunta, chama o modelo e guarda a resposta."""
    historico.append({"role": "user", "content": texto})
    resposta = cliente.chat.completions.create(
        model="um-modelo-de-chat", messages=historico,
        temperature=0.3)
    conteudo = resposta.choices[0].message.content
    historico.append({"role": "assistant", "content": conteudo})
    return conteudo

# print(perguntar(cliente, "Qual a perda em espaço livre a 5 km?"))
# print(perguntar(cliente, "E se a frequência dobrar?"))

# O contexto tem limite: em conversas longas, descarte ou resuma
# as mensagens mais antigas antes de enviar.

PROMPT = """Classifique o registro de manutenção em uma das
categorias: ANTENA, ENERGIA, TRANSMISSAO ou OUTRO.
Responda apenas com JSON no formato
{"categoria": "...", "confianca": 0.0}.

Registro: "cabo de alimentação rompido no poste"
Resposta: {"categoria": "ENERGIA", "confianca": 0.9}

Registro: "refletor desalinhado após vendaval"
Resposta: {"categoria": "ANTENA", "confianca": 0.95}

Registro: "%s"
Resposta:"""

registro = "perda de sincronismo no enlace de micro-ondas"
# bruto = perguntar(cliente, PROMPT % registro)
# dados = json.loads(bruto)
# print(dados["categoria"], dados["confianca"])

# Sempre valide: o modelo pode devolver texto fora do formato.
# Um json.loads dentro de try/except evita derrubar o programa.

import json
import math

def perda_espaco_livre(distancia_km, frequencia_mhz):
    return (32.44 + 20 * math.log10(distancia_km)
            + 20 * math.log10(frequencia_mhz))

FERRAMENTAS = {"perda_espaco_livre": perda_espaco_livre}

# O modelo recebe a descrição das ferramentas e devolve, em JSON,
# qual chamar e com quais argumentos. O programa executa e
# devolve o resultado para o modelo redigir a resposta final.
decisao_simulada = json.dumps({
    "ferramenta": "perda_espaco_livre",
    "argumentos": {"distancia_km": 5, "frequencia_mhz": 2400},
})

pedido = json.loads(decisao_simulada)
funcao = FERRAMENTAS[pedido["ferramenta"]]
resultado = funcao(**pedido["argumentos"])

print("ferramenta escolhida:", pedido["ferramenta"])
print("argumentos:", pedido["argumentos"])
print(f"resultado: {resultado:.2f} dB")
print("\no cálculo é feito em Python, não pelo modelo")

ETAPAS = [
    ("INDEXAÇÃO", "uma vez, antes de tudo", [
        "1. quebrar os documentos em trechos",
        "2. gerar o embedding de cada trecho",
        "3. guardar os vetores em um índice",
    ]),
    ("CONSULTA", "a cada pergunta", [
        "4. gerar o embedding da pergunta",
        "5. buscar os trechos mais parecidos",
        "6. montar o prompt com os trechos recuperados",
        "7. o modelo responde usando só esse contexto",
    ]),
]

for titulo, quando, passos in ETAPAS:
    print("+" + "=" * 58 + "+")
    print(f"| {titulo:<20}{('(' + quando + ')'):>35} |")
    print("+" + "=" * 58 + "+")
    for passo in passos:
        print(f"|   {passo:<54} |")
    print("+" + "-" * 58 + "+")
    print()

print("o modelo não é retreinado: o conhecimento entra pelo prompt")

DOCUMENTO = (
    "A antena Yagi possui elementos diretores e um refletor. "
    "O ganho típico fica entre 7 e 15 dBi conforme o número de "
    "elementos. A polarização acompanha a orientação dos "
    "elementos. O cabo coaxial RG-213 apresenta perda de cerca "
    "de 6 dB por 100 metros em 145 MHz. Já o RG-58 chega a 16 dB "
    "nas mesmas condições. Conectores mal crimpados são a causa "
    "mais comum de perda em instalações novas."
)

def trechos(texto, tamanho=110, sobreposicao=30):
    """Divide o texto em janelas com sobreposição."""
    palavras = texto.split()
    saida, inicio = [], 0
    while inicio < len(palavras):
        pedaco, contagem = [], 0
        i = inicio
        while i < len(palavras) and contagem < tamanho:
            pedaco.append(palavras[i])
            contagem += len(palavras[i]) + 1
            i += 1
        saida.append(" ".join(pedaco))
        if i >= len(palavras):
            break
        inicio = max(i - sobreposicao // 6, inicio + 1)
    return saida

pedacos = trechos(DOCUMENTO)
for i, pedaco in enumerate(pedacos):
    print(f"[{i}] {pedaco[:76]}...")
print(f"\n{len(pedacos)} trechos com sobreposição")

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer

BASE = [
    "A antena Yagi tem ganho entre 7 e 15 dBi conforme o número "
    "de elementos diretores.",
    "O cabo RG-213 apresenta perda de 6 dB por 100 metros em "
    "145 MHz.",
    "O cabo RG-58 apresenta perda de 16 dB por 100 metros em "
    "145 MHz.",
    "Conectores mal crimpados são a causa mais comum de perda em "
    "instalações novas.",
    "A polarização da Yagi acompanha a orientação dos elementos.",
    "O rádio deve ser desligado antes de qualquer intervenção na "
    "torre.",
]

vetorizador = TfidfVectorizer()
indice = vetorizador.fit_transform(BASE)

print("trechos indexados:", indice.shape[0])
print("dimensão do vetor:", indice.shape[1])
print("termos:", vetorizador.get_feature_names_out()[:8], "...")

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

BASE = [
    "A antena Yagi tem ganho entre 7 e 15 dBi conforme o número "
    "de elementos diretores.",
    "O cabo RG-213 apresenta perda de 6 dB por 100 metros em 145 MHz.",
    "O cabo RG-58 apresenta perda de 16 dB por 100 metros em 145 MHz.",
    "Conectores mal crimpados são a causa mais comum de perda em "
    "instalações novas.",
    "A polarização da Yagi acompanha a orientação dos elementos.",
    "O rádio deve ser desligado antes de qualquer intervenção na torre.",
]
vetorizador = TfidfVectorizer()
indice = vetorizador.fit_transform(BASE)

def recuperar(pergunta, k=2):
    vetor = vetorizador.transform([pergunta])
    similar = cosine_similarity(vetor, indice)[0]
    ordem = np.argsort(similar)[::-1][:k]
    return [(BASE[i], float(similar[i])) for i in ordem]

for pergunta in ["qual a perda do cabo RG-58?",
                 "quanto de ganho tem uma Yagi?",
                 "qual a receita de bolo de cenoura?"]:
    print(f"P: {pergunta}")
    for trecho, nota in recuperar(pergunta):
        print(f"   [{nota:.3f}] {trecho[:62]}...")
    print()

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

BASE = [
    "A antena Yagi tem ganho entre 7 e 15 dBi conforme o número "
    "de elementos diretores.",
    "O cabo RG-213 apresenta perda de 6 dB por 100 metros em 145 MHz.",
    "O cabo RG-58 apresenta perda de 16 dB por 100 metros em 145 MHz.",
    "Conectores mal crimpados são a causa mais comum de perda em "
    "instalações novas.",
]
vetorizador = TfidfVectorizer()
indice = vetorizador.fit_transform(BASE)
LIMIAR = 0.15

def montar_prompt(pergunta, k=2):
    vetor = vetorizador.transform([pergunta])
    similar = cosine_similarity(vetor, indice)[0]
    ordem = [i for i in np.argsort(similar)[::-1][:k]
             if similar[i] >= LIMIAR]

    if not ordem:
        return None, "sem contexto suficiente na base"

    contexto = "\n".join(f"[{n + 1}] {BASE[i]}"
                         for n, i in enumerate(ordem))
    prompt = (
        "Responda apenas com base no contexto abaixo. "
        "Se a resposta não estiver nele, diga que não sabe. "
        "Cite o número do trecho usado.\n\n"
        f"CONTEXTO:\n{contexto}\n\n"
        f"PERGUNTA: {pergunta}\nRESPOSTA:")
    return prompt, None

prompt, aviso = montar_prompt("qual a perda do RG-213?")
print(prompt)
print("\n" + "=" * 60 + "\n")
prompt, aviso = montar_prompt("como faço um bolo?")
print("pergunta fora do escopo ->", aviso)

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

BASE = [
    "A antena Yagi tem ganho entre 7 e 15 dBi conforme o número "
    "de elementos diretores.",
    "O cabo RG-213 apresenta perda de 6 dB por 100 metros em 145 MHz.",
    "O cabo RG-58 apresenta perda de 16 dB por 100 metros em 145 MHz.",
    "Conectores mal crimpados são a causa mais comum de perda em "
    "instalações novas.",
    "A polarização da Yagi acompanha a orientação dos elementos.",
]
# gabarito: qual trecho responde cada pergunta
TESTES = [
    ("qual a perda do cabo RG-213", 1),
    ("perda do RG-58 em 145 MHz", 2),
    ("ganho da antena Yagi", 0),
    ("causa comum de perda em instalação", 3),
    ("como está polarizada a Yagi", 4),
]

vetorizador = TfidfVectorizer()
indice = vetorizador.fit_transform(BASE)

def posicoes(pergunta):
    similar = cosine_similarity(
        vetorizador.transform([pergunta]), indice)[0]
    return list(np.argsort(similar)[::-1])

for k in [1, 2, 3]:
    acertos = sum(1 for pergunta, certo in TESTES
                  if certo in posicoes(pergunta)[:k])
    print(f"acerto@{k}: {acertos}/{len(TESTES)} "
          f"= {acertos / len(TESTES):.0%}")

# posicao media do trecho correto (1 e o ideal)
rr = [1 / (posicoes(p).index(c) + 1) for p, c in TESTES]
print(f"\nMRR (posição recíproca média): {np.mean(rr):.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(0)
X, y = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")

# modelo "grande", ja treinado em uma tarefa anterior
base = keras.Sequential([
    layers.Input(shape=(64,)),
    layers.Dense(96, activation="relu"),
    layers.Dense(48, activation="relu"),
])
antigo = keras.Sequential([base, layers.Dense(10, activation="softmax")])
antigo.compile("adam", "sparse_categorical_crossentropy",
               metrics=["accuracy"])
antigo.fit(X, y, epochs=20, batch_size=64, verbose=0)

# tarefa nova: apenas dizer se o digito e par
y_novo = (y % 2 == 0).astype("float32")
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y_novo, train_size=120, random_state=0, stratify=y_novo)

base.trainable = False
adaptado = keras.Sequential([base, layers.Dense(1, activation="sigmoid")])
adaptado.compile("adam", "binary_crossentropy", metrics=["accuracy"])
adaptado.fit(X_tr, y_tr, epochs=40, batch_size=16, verbose=0)

treinaveis = sum(np.prod(v.shape) for v in adaptado.trainable_weights)
total = adaptado.count_params()
print(f"parâmetros totais:     {total:>8}")
print(f"parâmetros treinados:  {treinaveis:>8} "
      f"({100 * treinaveis / total:.2f}%)")
print(f"acurácia na tarefa nova: "
      f"{adaptado.evaluate(X_te, y_te, verbose=0)[1]:.4f}")

import numpy as np
import keras
from keras import layers, ops

class LoRA(layers.Layer):
    """Adaptador de posto baixo sobre uma camada densa congelada."""

    def __init__(self, densa, posto=2, escala=1.0, **kwargs):
        super().__init__(**kwargs)
        self.densa = densa
        self.densa.trainable = False       # a original nao muda
        self.posto = posto
        self.escala = escala

    def build(self, forma):
        entrada = int(forma[-1])
        saida = int(self.densa.units)
        self.A = self.add_weight(
            shape=(entrada, self.posto), initializer="glorot_uniform",
            trainable=True, name="A")
        self.B = self.add_weight(
            shape=(self.posto, saida), initializer="zeros",
            trainable=True, name="B")

    def call(self, x):
        return self.densa(x) + self.escala * ops.matmul(
            ops.matmul(x, self.A), self.B)

keras.utils.set_random_seed(0)
densa = layers.Dense(96)
densa.build((None, 64))
adaptador = LoRA(densa, posto=2)
adaptador.build((None, 64))

originais = int(np.prod(densa.kernel.shape) + densa.bias.shape[0])
novos = int(np.prod(adaptador.A.shape) + np.prod(adaptador.B.shape))

print(f"parâmetros da camada original: {originais:>7}")
print(f"parâmetros do adaptador LoRA:  {novos:>7}")
print(f"proporção treinada: {100 * novos / originais:.2f}%")
print("\nB começa em zero: no instante inicial o modelo é idêntico")

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

class LoRA(layers.Layer):
    def __init__(self, densa, posto=4, **kwargs):
        super().__init__(**kwargs)
        self.densa = densa; self.densa.trainable = False
        self.posto = posto
    def build(self, forma):
        self.A = self.add_weight(shape=(int(forma[-1]), self.posto),
                                 initializer="glorot_uniform", name="A")
        self.B = self.add_weight(shape=(self.posto, int(self.densa.units)),
                                 initializer="zeros", name="B")
    def call(self, x):
        return self.densa(x) + ops.matmul(ops.matmul(x, self.A), self.B)

keras.utils.set_random_seed(0)
X, y = load_digits(return_X_y=True)
X = (X / 16.0).astype("float32")

corpo = layers.Dense(96, activation=None)
base = keras.Sequential([layers.Input(shape=(64,)), corpo,
                         layers.Activation("relu"),
                         layers.Dense(10, activation="softmax")])
base.compile("adam", "sparse_categorical_crossentropy",
             metrics=["accuracy"])
base.fit(X, y, epochs=20, batch_size=64, verbose=0)
print(f"tarefa original (10 dígitos): "
      f"{base.evaluate(X, y, verbose=0)[1]:.4f}")

y_novo = (y % 2 == 0).astype("float32")
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y_novo, train_size=200, random_state=0, stratify=y_novo)

adaptado = keras.Sequential([
    layers.Input(shape=(64,)),
    LoRA(corpo, posto=4),
    layers.Activation("relu"),
    layers.Dense(1, activation="sigmoid"),
])
adaptado.compile("adam", "binary_crossentropy", metrics=["accuracy"])
adaptado.fit(X_tr, y_tr, epochs=40, batch_size=16, verbose=0)

treinaveis = sum(int(np.prod(v.shape))
                 for v in adaptado.trainable_weights)
print(f"\nparâmetros treinados: {treinaveis}")
print(f"acurácia na tarefa nova: "
      f"{adaptado.evaluate(X_te, y_te, verbose=0)[1]:.4f}")
print(f"tarefa original ainda intacta: "
      f"{base.evaluate(X, y, verbose=0)[1]:.4f}")

import numpy as np

def memoria(parametros, bits):
    return parametros * bits / 8 / 1e9        # em GB

MODELOS = [("pequeno", 1e9), ("médio", 7e9), ("grande", 70e9)]

print(f"{'modelo':<10}{'parâmetros':>13}{'fp32':>9}{'fp16':>9}"
      f"{'int8':>9}{'int4':>9}")
for nome, n in MODELOS:
    linha = f"{nome:<10}{n / 1e9:>11.0f} B"
    for bits in [32, 16, 8, 4]:
        linha += f"{memoria(n, bits):>9.1f}"
    print(linha + "   GB")

print("\numa GPU comum tem 8 a 24 GB")
print("é a quantização que faz um modelo de 7 B caber nela")

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).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(96, 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)
print(f"original (float32): {modelo.evaluate(X_te, y_te, verbose=0)[1]:.4f}")

originais = [v.numpy().copy() for v in modelo.weights]

def quantizar(valores, bits):
    """Simula a redução de precisão dos pesos."""
    niveis = 2 ** bits - 1
    minimo, maximo = valores.min(), valores.max()
    passo = (maximo - minimo) / niveis
    return np.round((valores - minimo) / passo) * passo + minimo

for bits in [8, 4, 2]:
    for v, original in zip(modelo.weights, originais):
        v.assign(quantizar(original, bits))
    acuracia = modelo.evaluate(X_te, y_te, verbose=0)[1]
    print(f"quantizado em {bits} bits: {acuracia:.4f}")

for v, original in zip(modelo.weights, originais):
    v.assign(original)

# ---- tokenizacao (secao 45) ------------------------------------
import tiktoken
cod = tiktoken.get_encoding("cl100k_base")
fichas = cod.encode("texto");  cod.decode(fichas)
# alternativas: sentencepiece, tokenizers (HuggingFace)

# ---- embeddings (secao 46) -------------------------------------
from keras import layers
layers.Embedding(tamanho_vocab, dimensao)      # treinado junto
# busca semantica sem rede neural:
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
from sklearn.metrics.pairwise import cosine_similarity

# ---- atencao (secao 47) ----------------------------------------
# Atencao(Q,K,V) = softmax(Q K^T / raiz(d)) V
layers.MultiHeadAttention(num_heads=8, key_dim=64)(x, x)
layers.MultiHeadAttention(...)(x, x, use_causal_mask=True)  # geracao
layers.LayerNormalization(epsilon=1e-6)(x + atencao)        # residual

# ---- familias generativas (secoes 48 a 50) ---------------------
# VAE      : codifica para uma distribuicao, amostra, decodifica
# GAN      : gerador contra discriminador
# difusao  : aprende a remover ruido, passo a passo
# autorregressivo: prediz o proximo simbolo, realimenta a saida

# ---- geracao (secao 50) ----------------------------------------
prob = modelo.predict(contexto)[0]
prob = prob ** (1 / temperatura)          # < 1 conservador, > 1 criativo
prob = prob / prob.sum()
proximo = rng.choice(len(prob), p=prob)   # amostragem
# top-k: zera tudo fora dos k maiores; top-p: mantem massa acumulada p

# ---- RAG (secao 52) --------------------------------------------
# 1. quebrar em trechos  2. indexar  3. recuperar
# 4. montar o prompt com o contexto  5. gerar  6. citar a fonte
import faiss
indice = faiss.IndexFlatIP(dimensao);  indice.add(vetores)
distancia, posicao = indice.search(consulta, k=4)

# ---- ajuste fino (secao 53) ------------------------------------
corpo.trainable = False                   # congela o que ja sabe
# LoRA: W + (A @ B), com A e B de posto baixo e so elas treinaveis
# quantizacao: float32 -> int8 reduz o arquivo em cerca de 75%