import numpy as np, pandas as pd, torch, torch.nn as nn, time
from torch.utils.data import TensorDataset, DataLoader
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import roc_auc_score
from novamarket_ml import generar_comandes_ml, embrutar_comandes, preparar_comandes, crear_preparacio

X, y = preparar_comandes(embrutar_comandes(generar_comandes_ml(3000, 42), 42))
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
Xtr2, Xval, ytr2, yval = train_test_split(Xtr, ytr, test_size=0.2, random_state=42, stratify=ytr)
prep = crear_preparacio().fit(Xtr2)                               # nomes amb entrenament
def a_tensor(Xd, yd):
    return torch.tensor(prep.transform(Xd).astype(np.float32)), torch.tensor(yd.values.astype(np.float32)).view(-1, 1)
Xtr_t, ytr_t = a_tensor(Xtr2, ytr2); Xval_t, yval_t = a_tensor(Xval, yval); Xte_t, yte_t = a_tensor(Xte, yte)

def crear_xarxa(capes=(16, 8), dropout=0.2, entrada=21):
    peces, n = [], entrada
    for h in capes:
        peces += [nn.Linear(n, h), nn.ReLU(), nn.Dropout(dropout)]; n = h
    return nn.Sequential(*peces, nn.Linear(n, 1))                 # sense sigmoide: la posa BCEWithLogitsLoss

def avaluar(xarxa, X_t, y_t):
    xarxa.eval()
    with torch.no_grad():
        logits = xarxa(X_t)
    return nn.BCEWithLogitsLoss()(logits, y_t).item(), roc_auc_score(y_t.numpy().ravel(), torch.sigmoid(logits).numpy().ravel())

def entrenar(xarxa, taxa=0.001, epoques=300, lot=64, paciencia=15, llavor=0):
    torch.manual_seed(llavor)
    carregador = DataLoader(TensorDataset(Xtr_t, ytr_t), batch_size=lot, shuffle=True)
    opt, fn = torch.optim.Adam(xarxa.parameters(), lr=taxa), nn.BCEWithLogitsLoss()
    millor_val, millor_estat, sense_millora, millor_ep = float("inf"), None, 0, 0
    for ep in range(1, epoques + 1):
        xarxa.train()
        for xb, yb in carregador:
            opt.zero_grad(); fn(xarxa(xb), yb).backward(); opt.step()
        L_val, _ = avaluar(xarxa, Xval_t, yval_t)
        if L_val < millor_val - 1e-4:
            millor_val, sense_millora, millor_ep = L_val, 0, ep
            millor_estat = {k: v.clone() for k, v in xarxa.state_dict().items()}
        else:
            sense_millora += 1
            if sense_millora >= paciencia: break
    xarxa.load_state_dict(millor_estat)
    return millor_ep, ep

configs = [((16, 8), 0.001, 0.2), ((16, 8), 0.01, 0.2), ((16, 8), 0.0001, 0.2), ((32, 16), 0.001, 0.2),
           ((64, 32, 16), 0.001, 0.3), ((8,), 0.001, 0.0), ((16, 8), 0.001, 0.0)]
files = []
for capes, taxa, do in configs:
    t = time.time(); torch.manual_seed(42); xarxa = crear_xarxa(capes, do)
    millor_ep, ult = entrenar(xarxa, taxa=taxa)
    (Lv, auc_v), (_, auc_t) = avaluar(xarxa, Xval_t, yval_t), avaluar(xarxa, Xte_t, yte_t)
    files.append([str(capes), taxa, do, sum(p.numel() for p in xarxa.parameters()), millor_ep, ult, round(Lv, 4), round(auc_v, 3), round(auc_t, 3), round(time.time() - t, 1)])
taula = pd.DataFrame(files, columns=["capes", "taxa", "dropout", "params", "millor_ep", "ult_ep", "perdua_val", "AUC_val", "AUC_test", "seg"])
print(taula.to_string(index=False))
millor = taula.sort_values("AUC_val", ascending=False).iloc[0]
aucs = []
for s in range(5):
    torch.manual_seed(s); xarxa = crear_xarxa(eval(millor["capes"]), millor["dropout"]); entrenar(xarxa, taxa=millor["taxa"], llavor=s)
    aucs.append(avaluar(xarxa, Xte_t, yte_t)[1])
print("Millor per validacio:", millor["capes"], millor["taxa"], "| AUC test 5 llavors:", np.round(aucs, 3), round(np.mean(aucs), 3))
log = Pipeline([("prep", crear_preparacio()), ("model", LogisticRegression(max_iter=1000))]).fit(Xtr2, ytr2)
print("Logistica (mateixes 1799): AUC val", round(roc_auc_score(yval, log.predict_proba(Xval)[:, 1]), 3), "| AUC test", round(roc_auc_score(yte, log.predict_proba(Xte)[:, 1]), 3))

       capes   taxa  dropout  params  millor_ep  ult_ep  perdua_val  AUC_val  AUC_test  seg
     (16, 8) 0.0010      0.2     497         75      90      0.3241    0.835     0.834  3.1
     (16, 8) 0.0100      0.2     497         11      26      0.3316    0.825     0.830  0.7
     (16, 8) 0.0001      0.2     497        299     300      0.3423    0.821     0.831  8.1
    (32, 16) 0.0010      0.2    1249         26      41      0.3317    0.829     0.839  1.2
(64, 32, 16) 0.0010      0.3    4033         17      32      0.3337    0.831     0.838  1.1
        (8,) 0.0010      0.0     185         97     112      0.3232    0.843     0.836  2.5
     (16, 8) 0.0010      0.0     497         49      64      0.3219    0.837     0.832  1.7
Millor per validacio: (8,) 0.001 | AUC test 5 llavors: [0.837 0.841 0.837 0.84  0.842] 0.84
Logistica (mateixes 1799): AUC val 0.832 | AUC test 0.842

from sklearn.metrics import confusion_matrix
CLASSES = ["correcta", "danyada", "mullada"]

def generar_fotos3(n=900, llavor=42, mida=16):
    """16x16 en gris: caixa clara sobre fons fosc. 0 = correcta, 1 = danyada (esquerda/bonyada), 2 = mullada (taca difusa)."""
    rng = np.random.default_rng(llavor)
    X, y = np.zeros((n, 1, mida, mida), dtype=np.float32), np.zeros(n, dtype=np.int64)
    for i in range(n):
        img = rng.normal(0.1, 0.05, (mida, mida))
        x0, y0 = rng.integers(1, 5, size=2); x1, y1 = rng.integers(mida - 5, mida - 1, size=2)
        img[y0:y1, x0:x1] = rng.normal(0.7, 0.05, (y1 - y0, x1 - x0))
        classe = rng.integers(0, 3); y[i] = classe
        if classe == 1:                                                    # igual que a 05-04
            if rng.random() < 0.5:
                r0, c0 = rng.integers(y0, y1 - 4), rng.integers(x0, x1 - 4); llargada = rng.integers(4, min(y1 - r0, x1 - c0) + 1)
                for k in range(llargada): img[r0 + k, c0 + k] = 0.05
            else:
                r0, c0 = rng.integers(y0, y1 - 3), rng.integers(x0, x1 - 3); costat = rng.integers(2, 4)
                img[r0:r0 + costat, c0:c0 + costat] = rng.normal(0.15, 0.05, (costat, costat))
        elif classe == 2:                                                  # taca: 5-8 pixels, gris mitja, vores suaus
            alt, ample = rng.integers(5, 9, size=2)
            r0 = rng.integers(y0, max(y0 + 1, y1 - alt)); c0 = rng.integers(x0, max(x0 + 1, x1 - ample))
            r1, c1 = min(r0 + alt, y1), min(c0 + ample, x1)
            taca = rng.normal(0.45, 0.06, (r1 - r0, c1 - c0))
            fil, col = np.linspace(-1, 1, r1 - r0)[:, None], np.linspace(-1, 1, c1 - c0)[None, :]
            pes = np.clip(1.2 - (fil ** 2 + col ** 2), 0, 1)              # mes intensa al centre, es difumina a la vora
            img[r0:r1, c0:c1] = pes * taca + (1 - pes) * img[r0:r1, c0:c1]
        X[i, 0] = np.clip(img, 0, 1)
    return X, y

X, y = generar_fotos3(); print(X.shape, np.bincount(y))
np.set_printoptions(linewidth=120)
print("mullada:"); print((X[np.where(y == 2)[0][0], 0] * 9).astype(int))
Xtr, ytr, Xte, yte = X[:675], y[:675], X[675:], y[675:]
Xtr_t, ytr_t, Xte_t, yte_t = map(torch.tensor, (Xtr, ytr, Xte, yte))

def crear_cnn(n_classes=3):
    return nn.Sequential(nn.Conv2d(1, 8, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),      # 1x16x16 -> 8x8x8
                         nn.Conv2d(8, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),     # -> 16x4x4
                         nn.Flatten(), nn.Linear(256, 32), nn.ReLU(), nn.Linear(32, n_classes))

def augmentar(xb, rng):
    """Mirall horitzontal/vertical i rotacio de 0/90/180/270° a l'atzar, imatge a imatge."""
    out = xb.clone()
    for i in range(len(out)):
        if rng.random() < 0.5: out[i] = torch.flip(out[i], dims=[2])
        if rng.random() < 0.5: out[i] = torch.flip(out[i], dims=[1])
        k = int(rng.integers(0, 4))
        if k: out[i] = torch.rot90(out[i], k, dims=[1, 2])
    return out

def encert(xarxa, Xt, yt):
    xarxa.eval()
    with torch.no_grad(): return (xarxa(Xt).argmax(1) == yt).float().mean().item()

def entrenar(xarxa, Xt, yt, epoques=30, taxa=0.003, lot=32, augment=False, llavor=0, verbose=False):
    torch.manual_seed(llavor); rng = np.random.default_rng(llavor)
    opt, fn = torch.optim.Adam(xarxa.parameters(), lr=taxa), nn.CrossEntropyLoss()
    for ep in range(1, epoques + 1):
        xarxa.train(); perm = torch.randperm(len(Xt))
        for i in range(0, len(perm), lot):
            idx = perm[i:i + lot]; xb = augmentar(Xt[idx], rng) if augment else Xt[idx]
            opt.zero_grad(); fn(xarxa(xb), yt[idx]).backward(); opt.step()
        if verbose and ep in (1, 5, 10, 20, 30):
            print(f"  epoca {ep:2d}  encert train {encert(xarxa, Xt, yt):.3f}  test {encert(xarxa, Xte_t, yte_t):.3f}")

t = time.time(); torch.manual_seed(0); cnn = crear_cnn(); print("parametres:", sum(p.numel() for p in cnn.parameters()))
entrenar(cnn, Xtr_t, ytr_t, verbose=True); print(f"{time.time() - t:.1f} s")
with torch.no_grad(): pred = cnn(Xte_t).argmax(1).numpy()
print(confusion_matrix(yte, pred)); print("Encert test:", round((pred == yte).mean(), 3))
print("Errors:", [(CLASSES[a], "->", CLASSES[b]) for a, b in zip(yte[pred != yte], pred[pred != yte])])
for n_tr, ep in ((150, 60), (675, 30)):
    for aug in (False, True):
        accs = []
        for s in range(4):
            torch.manual_seed(s); xarxa = crear_cnn(); entrenar(xarxa, Xtr_t[:n_tr], ytr_t[:n_tr], epoques=ep, augment=aug, llavor=s); accs.append(encert(xarxa, Xte_t, yte_t))
        print(f"n_train={n_tr:3d} epoques={ep} augment={aug!s:5s}: {np.round(accs, 3)} mitjana {np.mean(accs):.3f}")
torch.manual_seed(0); mlp = nn.Sequential(nn.Flatten(), nn.Linear(256, 64), nn.ReLU(), nn.Linear(64, 3)); entrenar(mlp, Xtr_t, ytr_t)
print("MLP:", sum(p.numel() for p in mlp.parameters()), "parametres, encert test", round(encert(mlp, Xte_t, yte_t), 3))

(900, 1, 16, 16) [298 293 309]
mullada:
[[1 0 1 1 1 0 1 1 1 1 1 0 0 0 1 1]
 [0 0 1 0 6 6 6 5 6 5 6 5 6 0 0 1]
 [0 0 1 0 5 5 6 5 2 4 6 6 6 0 1 1]
 [0 1 1 1 6 6 5 4 4 3 4 7 7 0 0 0]
 [0 0 1 0 6 5 6 4 4 4 6 6 5 0 0 1]
 [1 0 1 0 6 7 6 6 5 6 5 6 6 0 1 1]
 ...
parametres: 9571
  epoca  1  encert train 0.493  test 0.458
  epoca  5  encert train 0.630  test 0.600
  epoca 10  encert train 0.647  test 0.627
  epoca 20  encert train 0.963  test 0.911
  epoca 30  encert train 0.990  test 0.978
1.1 s
[[70  0  1]
 [ 1 74  3]
 [ 0  0 76]]
Encert test: 0.978
Errors: [('danyada', '->', 'mullada'), ('danyada', '->', 'correcta'), ('danyada', '->', 'mullada'), ('danyada', '->', 'mullada'), ('correcta', '->', 'mullada')]
n_train=150 epoques=60 augment=False: [0.924 0.862 0.907 0.867] mitjana 0.890
n_train=150 epoques=60 augment=True : [0.951 0.92  0.916 0.911] mitjana 0.924
n_train=675 epoques=30 augment=False: [0.978 0.978 0.951 0.982] mitjana 0.972
n_train=675 epoques=30 augment=True : [0.978 0.973 0.942 0.964] mitjana 0.964
MLP: 16643 parametres, encert test 0.48

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error
from novamarket_ml import generar_demanda_setmanal

d = generar_demanda_setmanal(104, 42); serie = d["unitats"].values.astype(np.float32)
FINESTRA, N_TEST, N_VAL = 12, 26, 13
def finestres(serie, finestra):
    return np.array([serie[t - finestra:t] for t in range(finestra, len(serie))]), serie[finestra:]
Xw, yw = finestres(serie, FINESTRA)                                # 92 finestres -> setmanes objectiu 13..104
setmana_obj = np.arange(FINESTRA + 1, len(serie) + 1)
es_test = setmana_obj > len(serie) - N_TEST                        # setmanes 79-104
ultim = Xw[:, -1]                                                  # ultima setmana de cada finestra
Xr, yr = Xw - ultim[:, None], yw - ultim                            # relatiu: la xarxa prediu l'increment
escala = Xr[~es_test].std()                                        # una sola escala, nomes amb entrenament
tensor = lambda a: torch.tensor(a / escala, dtype=torch.float32)
Xtr, ytr, Xte = tensor(Xr[~es_test]).unsqueeze(-1), tensor(yr[~es_test]).view(-1, 1), tensor(Xr[es_test]).unsqueeze(-1)
print("finestres:", Xw.shape, "| entrenament:", tuple(Xtr.shape), "| test:", tuple(Xte.shape))

class XarxaGRU(nn.Module):
    def __init__(self, ocult=8):
        super().__init__()
        self.gru = nn.GRU(input_size=1, hidden_size=ocult, batch_first=True)
        self.sortida = nn.Linear(ocult, 1)
    def forward(self, x):
        estats, ultim_estat = self.gru(x)             # estats: (lot, 12, ocult); ultim_estat: (1, lot, ocult)
        return self.sortida(ultim_estat[0])

def entrenar_gru(X_t, y_t, ocult=8, epoques=50, taxa=0.01, llavor=0):
    torch.manual_seed(llavor); xarxa = XarxaGRU(ocult)
    opt, fn = torch.optim.Adam(xarxa.parameters(), lr=taxa), nn.MSELoss()
    for _ in range(epoques):                           # lot complet: 66 finestres hi caben de sobres
        xarxa.train(); opt.zero_grad(); fn(xarxa(X_t), y_t).backward(); opt.step()
    return xarxa.eval()

def predir(xarxa, X_t, ultim_setmana):
    with torch.no_grad(): return xarxa(X_t).numpy().ravel() * escala + ultim_setmana

Xa, ya, Xv = Xtr[:-N_VAL], ytr[:-N_VAL], Xtr[-N_VAL:]            # validacio: setmanes 66-78
y_val, ult_val = yw[~es_test][-N_VAL:], ultim[~es_test][-N_VAL:]
resultats = {}
for ocult in (8, 16, 32):
    for epoques in (50, 100, 200, 400):
        maes = [mean_absolute_error(y_val, predir(entrenar_gru(Xa, ya, ocult, epoques, llavor=s), Xv, ult_val)) for s in range(3)]
        resultats[(ocult, epoques)] = np.mean(maes)
print({k: round(float(v), 1) for k, v in resultats.items()}); print("Ingenua en validacio:", round(mean_absolute_error(y_val, ult_val), 1))
millor = min(resultats, key=resultats.get); print("Millor configuracio:", millor)
maes = [mean_absolute_error(yw[es_test], predir(entrenar_gru(Xtr, ytr, *millor, llavor=s), Xte, ultim[es_test])) for s in range(5)]
print(f"GRU test, 5 llavors: {np.round(maes, 1)} mitjana {np.mean(maes):.1f}")
xarxa = entrenar_gru(Xtr, ytr, *millor, llavor=0); print("parametres:", sum(p.numel() for p in xarxa.parameters()))
d["sen"], d["cos"] = np.sin(2 * np.pi * d["setmana"] / 52), np.cos(2 * np.pi * d["setmana"] / 52)
d["black_friday"] = ((d["setmana"] - 1) % 52 == 47).astype(int)
feats, tr, te = ["setmana", "sen", "cos", "black_friday"], d["setmana"] <= 78, d["setmana"] > 78
comparar = {"GRU (llavor 0)": predir(xarxa, Xte, ultim[es_test]),
            "Ingènua: última setmana": Xw[es_test][:, -1], "Mitjana de 4 setmanes": Xw[es_test][:, -4:].mean(1),
            "Lineal sobre la finestra (12 coef.)": LinearRegression().fit(Xw[~es_test], yw[~es_test]).predict(Xw[es_test]),
            "Lineal de calendari (04-05)": LinearRegression().fit(d.loc[tr, feats], d.loc[tr, "unitats"]).predict(d.loc[te, feats])}
for nom, p in comparar.items():
    err = pd.Series(np.abs(yw[es_test] - p), index=setmana_obj[es_test])
    print(f"{nom:36s} MAE {err.mean():5.1f} | set. 100 (BF) {err[100]:5.1f} | set. 101 {err[101]:5.1f} | resta {err.drop([100, 101]).mean():4.1f} | biaix {np.mean(yw[es_test] - p):+.1f}")

finestres: (92, 12) | entrenament: (66, 12, 1) | test: (26, 12, 1)
{(8, 50): 15.9, (8, 100): 16.7, (8, 200): 25.5, (8, 400): 32.2, (16, 50): 16.3, (16, 100): 20.6, (16, 200): 19.9, (16, 400): 28.7, (32, 50): 19.3, (32, 100): 19.3, (32, 200): 19.5, (32, 400): 19.2}
Ingenua en validacio: 18.7
Millor configuracio: (8, 50)
GRU test, 5 llavors: [33.9 29.3 32.2 34.3 30.1] mitjana 32.0
parametres: 273
GRU (llavor 0)                       MAE  33.9 | set. 100 (BF) 212.9 | set. 101 118.7 | resta 22.9 | biaix -12.7
Ingènua: última setmana              MAE  34.3 | set. 100 (BF) 215.0 | set. 101 238.0 | resta 18.3 | biaix -1.5
Mitjana de 4 setmanes                MAE  31.4 | set. 100 (BF) 241.5 | set. 101  59.5 | resta 21.5 | biaix -4.1
Lineal sobre la finestra (12 coef.)  MAE  29.8 | set. 100 (BF) 231.8 | set. 101  92.2 | resta 18.8 | biaix -0.4
Lineal de calendari (04-05)          MAE  16.8 | set. 100 (BF)  27.5 | set. 101   8.6 | resta 16.7 | biaix -7.0

import re
from collections import Counter
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import GroupKFold, StratifiedKFold, cross_val_score
from ressenyes_nm import POSITIVES, NEGATIVES, PRODUCTES
PATRO_TOKEN = r"(?u)\b\w[\w·]+\b"                                  # com a 05-05: respecta la ela geminada

def generar_ressenyes_ampliat(n=400, llavor=42):
    rng = np.random.default_rng(llavor); files = []
    for i in range(n):
        sentiment = i % 2; llista = POSITIVES if sentiment else NEGATIVES
        k = int(rng.integers(len(llista))); p = rng.choice(PRODUCTES)
        files.append({"id_ressenya": f"R{1000 + i}", "text": llista[k].format(p=p, P=p[0].upper() + p[1:]),
                      "sentiment": sentiment, "plantilla": f"{'P' if sentiment else 'N'}{k:02d}"})
    return pd.DataFrame(files).sample(frac=1, random_state=llavor).reset_index(drop=True)

res = generar_ressenyes_ampliat(); print(res.shape, "plantilles diferents:", res["plantilla"].nunique())
bow = Pipeline([("bossa", CountVectorizer(token_pattern=PATRO_TOKEN)), ("log", LogisticRegression(max_iter=1000))])
skf, gkf = StratifiedKFold(5, shuffle=True, random_state=42), GroupKFold(5)
print("BoW, CV estratificada:", cross_val_score(bow, res["text"], res["sentiment"], cv=skf).round(3))
sc = cross_val_score(bow, res["text"], res["sentiment"], cv=gkf, groups=res["plantilla"]); print("BoW, CV per plantilla:", sc.round(3), round(sc.mean(), 3))

def tokenitzar(t): return re.findall(r"\w[\w·]*", t.lower())
def construir_vocab(textos):
    vocab = {"<unk>": 0}
    for w in Counter(w for t in textos for w in tokenitzar(t)): vocab[w] = len(vocab)
    return vocab
def a_indexs(textos, vocab):
    idx, offsets = [], [0]
    for t in textos:
        toks = [vocab.get(w, 0) for w in tokenitzar(t)]; idx += toks; offsets.append(offsets[-1] + len(toks))
    return torch.tensor(idx), torch.tensor(offsets[:-1])

class XarxaEmb(nn.Module):
    def __init__(self, n_vocab, dim=8):
        super().__init__(); self.emb = nn.EmbeddingBag(n_vocab, dim, mode="mean"); self.sortida = nn.Linear(dim, 1)
    def forward(self, idx, off): return self.sortida(self.emb(idx, off))

def entrenar_emb(textos, y, vocab, dim=8, epoques=100, taxa=0.02, wd=1e-3, llavor=0):
    torch.manual_seed(llavor); xarxa = XarxaEmb(len(vocab), dim)
    opt, fn = torch.optim.Adam(xarxa.parameters(), lr=taxa, weight_decay=wd), nn.BCEWithLogitsLoss()
    idx, off = a_indexs(textos, vocab); y_t = torch.tensor(y, dtype=torch.float32).view(-1, 1)
    for _ in range(epoques):
        xarxa.train(); opt.zero_grad(); fn(xarxa(idx, off), y_t).backward(); opt.step()
    return xarxa.eval()

def encert_emb(xarxa, textos, y, vocab):
    idx, off = a_indexs(textos, vocab)
    with torch.no_grad(): return float(((xarxa(idx, off) > 0).numpy().ravel().astype(int) == np.asarray(y)).mean())

for nom, cv, grups in (("estratificada", skf, None), ("per plantilla", gkf, res["plantilla"])):
    accs = []
    for tr, te in cv.split(res["text"], res["sentiment"], groups=grups):
        vocab = construir_vocab(res["text"].iloc[tr])                     # vocabulari nomes amb entrenament
        xarxa = entrenar_emb(res["text"].iloc[tr].tolist(), res["sentiment"].iloc[tr].values, vocab)
        accs.append(encert_emb(xarxa, res["text"].iloc[te].tolist(), res["sentiment"].iloc[te].values, vocab))
    print(f"EmbeddingBag, CV {nom}:", np.round(accs, 3), round(np.mean(accs), 3))

vocab = construir_vocab(res["text"]); xarxa = entrenar_emb(res["text"].tolist(), res["sentiment"].values, vocab)
print("vocabulari:", len(vocab), "| parametres:", sum(p.numel() for p in xarxa.parameters()))
noves = ["La cafetera és genial, molt contenta amb la compra", "El televisor va arribar trencat i el suport no respon",
         "El robot aspirador no és gens silenciós, un desastre", "No està gens malament, la fregidora funciona bé i va arribar ràpid",
         "Esperava que fos dolent però els auriculars són excel·lents", "La bateria del portàtil dura poquíssim, decebedor"]
bow.fit(res["text"], res["sentiment"]); idx, off = a_indexs(noves, vocab)
with torch.no_grad(): p_emb = torch.sigmoid(xarxa(idx, off)).numpy().ravel()
for t, pb, pe in zip(noves, bow.predict_proba(noves)[:, 1], p_emb): print(f"BoW {pb:.2f}  Emb {pe:.2f}  {t}")
E, inv = xarxa.emb.weight.detach(), {i: w for w, i in vocab.items()}
puntuacio = (E @ xarxa.sortida.weight[0].detach()).numpy(); ordre = np.argsort(puntuacio)   # projeccio de cada paraula sobre la direccio de sortida
print("Mes negatives:", [inv[i] for i in ordre[:8]]); print("Mes positives:", [inv[i] for i in ordre[-8:][::-1]])

(400, 4) plantilles diferents: 56
BoW, CV estratificada: [1. 1. 1. 1. 1.]
BoW, CV per plantilla: [0.85  0.638 0.675 0.8   0.725] 0.737
EmbeddingBag, CV estratificada: [1. 1. 1. 1. 1.] 1.0
EmbeddingBag, CV per plantilla: [0.888 0.588 0.75  0.738 0.7  ] 0.733
vocabulari: 267 | parametres: 2145
BoW 0.95  Emb 0.99  La cafetera és genial, molt contenta amb la compra
BoW 0.05  Emb 0.02  El televisor va arribar trencat i el suport no respon
BoW 0.15  Emb 0.21  El robot aspirador no és gens silenciós, un desastre
BoW 0.31  Emb 0.21  No està gens malament, la fregidora funciona bé i va arribar ràpid
BoW 0.54  Emb 0.69  Esperava que fos dolent però els auriculars són excel·lents
BoW 0.19  Emb 0.28  La bateria del portàtil dura poquíssim, decebedor
Mes negatives: ['no', 'es', 'mala', 'venir', 'sorollós', 'gens', 'obert', 'car']
Mes positives: ['que', 'genial', 'és', 'tot', 'preu', 'bé', 'bona', 'funciona']