Darrera lliçó del mòdul, i la família de models que domina els titulars. Les xarxes neuronals no porten una idea geomètrica nova com el marge de la SVM o les preguntes de l'arbre: porten un principi de composició — apilar moltes unitats de càlcul diminutes, cadascuna sospitosament semblant a la regressió logística de 04-02, fins a poder aproximar pràcticament qualsevol funció. En aquesta lliçó desmuntaràs la neurona artificial peça a peça (reprenent el perceptró que la història de 01-02 va deixar plantat el 1958), faràs un forward pass amb números reals, entendràs backpropagation com el descens de gradient de 04-01 aplicat en cadena, i entrenaràs un MLPClassifier sobre el churn de MercaFresh. Tancarem amb la comparativa dels set algorismes del mòdul — el teu mapa per triar model — i la pregunta que obre el mòdul 5.

Contingut

  1. La neurona artificial: pesos, biaix i activació
  2. Funcions d'activació: sigmoide, tanh i ReLU
  3. L'arquitectura en capes
  4. Forward pass: un exemple numèric complet
  5. Backpropagation i descens de gradient (conceptual)
  6. Implementació amb scikit-learn: MLPClassifier sobre el churn
  7. Quan aporta una xarxa davant dels models anteriors
  8. Comparativa final: els 7 algorismes del mòdul

La neurona artificial: pesos, biaix i activació

Una neurona artificial fa tres coses, en fila:

  1. Combina les seves entrades linealment: $z = w_1 x_1 + w_2 x_2 + \dots + w_n x_n + b$ (els pesos $w_i$ ponderen cada entrada; el biaix $b$ desplaça el resultat — és l'intercepte de 04-01 amb un altre nom).
  2. Activa: passa $z$ per una funció no lineal $f$.
  3. Emet la sortida $a = f(z)$ cap a les neurones següents.

Et sona? Una neurona amb activació sigmoide és exactament la regressió logística de 04-02: combinació lineal + sigmoide. El perceptró de Rosenblatt (1958), que vas conèixer a la història de 01-02, era això mateix amb una activació esglaó (0 o 1, sense matisos) — i la seva limitació famosa era la de tots els nostres models lineals: només fronteres rectes. La revolució no és a la neurona, sinó en el que passa en connectar-les: la sortida d'unes és l'entrada d'altres, i la composició de moltes transformacions no lineals senzilles pot corbar la frontera tant com faci falta. Sense la no-linealitat de l'activació, per cert, apilar capes seria inútil: una cadena de funcions lineals es col·lapsa en una sola funció lineal.

Funcions d'activació: sigmoide, tanh i ReLU

Funció Fórmula Rang Ús típic Observacions
Sigmoide $1/(1+e^{-z})$ (0, 1) Capa de sortida binària (probabilitat, com a 04-02) En capes ocultes satura: gradients gairebé nuls als extrems
Tanh $\tanh(z)$ (−1, 1) Capes ocultes (clàssic) Com la sigmoide però centrada en 0; també satura
ReLU $\max(0, z)$ [0, ∞) Capes ocultes (estàndard actual) Baratíssima; no satura per a z > 0; el valor per defecte de sklearn

La ReLU (Rectified Linear Unit) mereix explicació per la seva aparent rusticitat: si l'entrada és negativa, emet 0 (la neurona "calla"); si és positiva, la deixa passar tal qual. Aquesta simplicitat és la seva virtut — el seu pendent és 1 en tota la zona activa, així que el gradient flueix sense esvair-se per moltes capes que travessi, el problema que va llastar sigmoide i tanh durant dècades. Per a la capa de sortida es mantenen la sigmoide (binària) o softmax (multiclasse, 04-02).

L'arquitectura en capes

Les neurones s'organitzen en capes: una d'entrada (una neurona per feature — no calcula, només reparteix), una o més d'ocultes (extreuen representacions intermèdies) i una de sortida (emet la predicció). Cada neurona d'una capa es connecta amb totes les de la següent — d'aquí el nom tècnic perceptró multicapa (MLP) o xarxa densa:

flowchart LR
    subgraph entrada ["Capa d'entrada"]
        X1["recencia"]
        X2["tendencia"]
        X3["comandes/mes"]
        X4["... (15 features)"]
    end
    subgraph oculta ["Capa oculta (ReLU)"]
        H1["h1"]
        H2["h2"]
        H3["h3"]
        H4["... (8 neurones)"]
    end
    subgraph sortida ["Capa de sortida (sigmoide)"]
        S1["P(churn)"]
    end
    X1 --> H1 & H2 & H3
    X2 --> H1 & H2 & H3
    X3 --> H2 & H3 & H4
    X4 --> H1 & H4
    H1 --> S1
    H2 --> S1
    H3 --> S1
    H4 --> S1

Intuïció de què aprèn cada capa: les neurones ocultes s'especialitzen a detectar patrons intermedis — una podria activar-se davant del perfil "silenci creixent" (recència alta + tendència baixa), una altra davant de "client premium refredant-se" — i la capa de sortida combina aquests detectors com una regressió logística sobre features apreses. Aquí hi ha la promesa profunda del model: la xarxa fa la seva pròpia enginyeria de característiques (03-06), aprenent les combinacions que a nosaltres ens tocava dissenyar a mà. El nombre de capes i de neurones per capa són hiperparàmetres: més = més capacitat expressiva i més risc de sobreajustament (06-05).

Forward pass: un exemple numèric complet

El forward pass és el recorregut d'una dada des de l'entrada fins a la predicció. Xarxa mínima: 2 entrades, 2 neurones ocultes amb ReLU, 1 sortida sigmoide. Client amb features escalades: recència = 1.0 (alta), tendència = −0.5 (caient).

Capa oculta (pesos inventats però versemblants):

  • Neurona h1 (pesos 1.2 i −1.0, biaix −0.2), detectora de "client apagant-se": $z_1 = 1.2(1.0) + (-1.0)(-0.5) - 0.2 = 1.2 + 0.5 - 0.2 = 1.5 \Rightarrow a_1 = \text{ReLU}(1.5) = 1.5$
  • Neurona h2 (pesos −0.8 i 1.5, biaix 0.1), detectora de "client reactivant-se": $z_2 = -0.8(1.0) + 1.5(-0.5) + 0.1 = -0.8 - 0.75 + 0.1 = -1.45 \Rightarrow a_2 = \text{ReLU}(-1.45) = 0$

Capa de sortida (pesos 1.1 i −1.3, biaix −0.4):

$z_s = 1.1(1.5) + (-1.3)(0) - 0.4 = 1.25 \Rightarrow \sigma(1.25) = \frac{1}{1+e^{-1.25}} \approx 0.78$

Predicció: 78% de probabilitat de churn. Llegeix la història que expliquen els números: el detector d'apagada es va activar amb força (1.5), el de reactivació va callar del tot (la ReLU el va silenciar), i la sortida va traduir aquest balanç a probabilitat amb la sigmoide de 04-02. Onze números de paràmetres, i ja es veu la mecànica que, a escala de milers de neurones, reconeix cares o tradueix idiomes.

Backpropagation i descens de gradient (conceptual)

D'on surten els pesos? Del mateix bucle de 04-01: definir una funció de cost (log-loss, com a 04-02) i baixar pel seu pendent. La novetat és calcular aquest pendent quan entre cada pes i l'error hi ha diverses capes pel mig. Aquí entra backpropagation (retropropagació):

  1. Forward pass: amb els pesos actuals, calcula la predicció i el seu error.
  2. Backward pass: propaga l'error cap enrere, capa per capa, repartint a cada pes la seva quota de responsabilitat (la regla de la cadena del càlcul, aplicada sistemàticament): "la sortida s'ha passat 0.3; h1 hi ha contribuït tant, per tant els pesos de h1 s'han de corregir tant...".
  3. Actualització: cada pes fa un passet contra el seu gradient, amb la taxa d'aprenentatge de 04-01.
  4. Repetir amb més dades, moltes èpoques (passades completes al dataset), fins a convergir.

Diferència crucial amb 04-01 i 04-02: el paisatge d'error d'una xarxa no és un bol — té valls múltiples, altiplans i barrancs. El descens de gradient ja no garanteix el mínim global: entrenar dues vegades amb llavors diferents dona xarxes diferents (per això els pesos s'inicialitzen a l'atzar i random_state importa). A la pràctica funciona notablement bé, amb variants del descens (Adam, la que sklearn fa servir per defecte) que adapten la mida del pas pel camí.

Implementació amb scikit-learn: MLPClassifier sobre el churn

Les xarxes exigeixen features escalades (el descens de gradient pateix amb escales dispars — mateixa raó que a 04-02, agreujada): una vegada més, el preprocessador de 03-06 al rescat:

from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.neural_network import MLPClassifier

# 'preprocessador': el ColumnTransformer de 03-06, RobustScaler inclos
X_entrenament, X_prova, y_entrenament, y_prova = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)

xarxa = Pipeline([
    ("prep", preprocessador),
    ("model", MLPClassifier(hidden_layer_sizes=(16, 8),  # 2 capes ocultes
                            activation="relu",
                            max_iter=2000,
                            early_stopping=True,   # frena si deixa de millorar
                            random_state=42)),
])
xarxa.fit(X_entrenament, y_entrenament)
print(f"Accuracy en prova: {xarxa.score(X_prova, y_prova):.2%}")

model = xarxa.named_steps["model"]
print(f"Epoques executades: {model.n_iter_}")
print(f"Parametres totals: "
      f"{sum(w.size for w in model.coefs_) + sum(b.size for b in model.intercepts_)}")

Lectura del codi:

  • hidden_layer_sizes=(16, 8): dues capes ocultes de 16 i 8 neurones. Per a tabular petit, començar modest: una o dues capes de 8–32 neurones. Cada neurona afegeix pesos a ajustar i capacitat de memoritzar.
  • early_stopping=True: aparta internament un 10% de l'entrenament com a validació i atura l'entrenament quan aquesta validació deixa de millorar — l'antídot més simple contra el sobreajustament per excés d'èpoques (la lògica completa, a 06-05).
  • max_iter=2000: sostre d'èpoques. Si surt un avís de no convergència, apuja'l o revisa l'escalat.
  • El comptador de paràmetres posa les coses en perspectiva: la nostra xarxa petita ja maneja diversos centenars de pesos, davant de la dotzena llarga de la regressió logística. Més capacitat, més apetit de dades i més risc de memoritzar — amb 800 clients, l'avantatge sobre models simples pot ser nul o negatiu, i això també és una lliçó.

Sobre aquest mateix churn, és habitual que la xarxa empati o guanyi per poc a la logística: les nostres features de 03-06 ja codifiquen a mà bona part de la no-linealitat útil (ràtios, tendència, interacció). Les xarxes brillen quan aquesta enginyeria no està feta o no és possible.

Quan aporta una xarxa davant dels models anteriors

  • Aporta: relacions no lineals complexes amb dades abundants (desenes de milers de files en endavant); problemes on les features útils són combinacions que ningú no sap dissenyar; dades no tabulars — imatges, àudio, text seqüencial — on les arquitectures especialitzades no tenen rival.
  • No aporta (o resta): datasets tabulars petits o mitjans amb bones features, on la logística, els arbres o els seus ensembles (07-02, 07-03) rendeixen igual o millor amb una fracció del cost i del misteri; contextos que exigeixen explicar cada decisió (un MLP no produeix regles llegibles ni odds ratios).

El que aquesta lliçó ha mostrat és la xarxa mínima. Les arquitectures que justifiquen el bombo — xarxes profundes amb desenes de capes, convolucionals (CNN) per a imatges, recurrents (RNN) per a seqüències, transformers per al llenguatge — juntament amb les tècniques que les fan entrenables, es tracten a la lliçó de deep learning (07-04). Tot l'essencial, però, ja el tens: són neurones, capes, forward pass i backpropagation, a una altra escala.

Comparativa final: els 7 algorismes del mòdul

El mapa de decisió del mòdul complet:

Algorisme Tasca Frontera / forma Necessita escalat? Interpretabilitat Cost (entrenar / predir) Idea-força
Regressió lineal (04-01) Regressió Hiperplà No (sí amb regularització 07-01) Alta: coeficients Baix / ínfim Minimitzar el MSE
Regressió logística (04-02) Classificació Hiperplà Alta: odds ratios Baix / ínfim Sigmoide + log-loss
Arbre de decisió (04-03) Totes dues Esglaonada (rectangles) No Molt alta: regles dibuixables Baix / ínfim Comprar puresa pregunta a pregunta
SVM (04-04) Totes dues Hiperplà o corba (kernel) Sí, crític Baixa (mitjana amb kernel lineal) Alt amb kernel / mitjà Marge màxim
K-NN (04-05) Totes dues Local, arbitrària Sí, crític Mitjana: ensenyar els veïns Nul / alt Votar entre semblants
Naive Bayes (04-06) Classificació Suau (quadràtica en Gaussian) No Mitjana: priors i versemblances Ínfim / ínfim Multiplicar evidències
Xarxa neuronal (04-07) Totes dues Arbitrària Baixa Alt / baix Compondre no-linealitats

Com fer servir la taula en un projecte real tipus MercaFresh: comença per la línia base interpretable (logística per classificar, lineal per a regressió); posa-hi un arbre al costat per les seves regles i la seva tolerància al preprocessament mínim; si sospites fronteres corbes i el dataset és manejable, prova SVM RBF i una xarxa petita; fes servir K-NN com a sonda de la qualitat de les teves features i Naive Bayes quan la velocitat o l'escassetat de dades manin. I recorda que les dues caselles més potents en tabular — els ensembles d'arbres i el boosting — arriben a 07-02 i 07-03 construïdes sobre el que ja saps.

Errors Comuns i Consells

  • Començar el projecte per la xarxa neuronal. És el model amb més comandaments, més apetit de dades i menys explicacions. Es guanya el dret a existir només si supera la logística i l'arbre en validació — la majoria de vegades, en tabular, no ho fa.
  • Entrenar sense escalar. El descens de gradient zigzagueja i no convergeix; l'avís de max_iter sol ser símptoma d'això, no de poques èpoques. El Pipeline amb 03-06 ho prevé.
  • Ignorar l'aleatorietat de la inicialització. Dos entrenaments amb llavors diferents donen resultats diferents; fixa random_state per reproduir i, si el resultat varia molt entre llavors, desconfia: el model està al límit de les seves dades.
  • Interpretar neurones ocultes com a conceptes garantits. "h1 detecta l'apagada del client" és una lectura plausible a posteriori, no una propietat verificada; les representacions internes d'una xarxa real estan repartides i barrejades.
  • Consell: cronometra i compara sempre contra la taula del mòdul. Un punt extra d'accuracy pot costar 100 vegades més entrenament, memòria i opacitat; que la decisió sigui conscient — i amb les mètriques adequades, que és just el que ve al mòdul 6.

Exercicis

Exercici 1. Repeteix el forward pass de l'exemple numèric per a un client sa: recència = −0.8, tendència = 1.2 (escalades). Fes servir els mateixos pesos. Quina neurona oculta s'activa ara i quina probabilitat de churn surt?

Exercici 2. Amb el Pipeline de la lliçó, entrena tres xarxes amb hidden_layer_sizes = (2,), (16, 8) i (128, 64, 32), i compara l'accuracy en entrenament i prova. Relaciona el patró amb el nombre de paràmetres i amb el que has vist a l'exercici 2 de 04-03.

Exercici 3. Sense codi: la capa de sortida del nostre MLP binari és una neurona amb sigmoide sobre les activacions ocultes. Explica en quin sentit exacte l'MLP "és una regressió logística amb features apreses", i què implica això sobre la frontera de decisió de la xarxa a l'espai de les activacions ocultes davant de l'espai de les features originals.

Solucions

Exercici 1

  • h1: $z_1 = 1.2(-0.8) + (-1.0)(1.2) - 0.2 = -0.96 - 1.2 - 0.2 = -2.36 \Rightarrow a_1 = 0$ (la ReLU silencia).
  • h2: $z_2 = -0.8(-0.8) + 1.5(1.2) + 0.1 = 0.64 + 1.8 + 0.1 = 2.54 \Rightarrow a_2 = 2.54$.
  • Sortida: $z_s = 1.1(0) + (-1.3)(2.54) - 0.4 = -3.70 \Rightarrow \sigma(-3.70) \approx 0.024$.

Un 2.4% de churn: els detectors s'han intercanviat els papers — ara calla el d'"apagada" i crida el de "reactivació", el pes de sortida del qual, negatiu (−1.3), empeny la probabilitat cap avall. La mateixa xarxa, sense canviar un pes, respon coherentment a perfils oposats: això és el que compren les capes.

Exercici 2

for capes in [(2,), (16, 8), (128, 64, 32)]:
    m = Pipeline([("prep", preprocessador),
                  ("model", MLPClassifier(hidden_layer_sizes=capes,
                                          max_iter=3000, random_state=42))])
    m.fit(X_entrenament, y_entrenament)
    n_params = (sum(w.size for w in m.named_steps["model"].coefs_)
                + sum(b.size for b in m.named_steps["model"].intercepts_))
    print(f"{str(capes):15s} | params: {n_params:6d} | "
          f"entrenament: {m.score(X_entrenament, y_entrenament):.2%} | "
          f"prova: {m.score(X_prova, y_prova):.2%}")

Patró esperat: (2,) es queda curta (pocs paràmetres, entrenament i prova mediocres — underfitting); (16, 8) dona la millor prova; (128, 64, 32) — milers de paràmetres per a 640 files d'entrenament — dispara l'entrenament i estanca o empitjora la prova: memorització. És exactament la corba de l'exercici 2 de 04-03 amb max_depth, i la de gamma a 04-04: cada família de models té el seu comandament de complexitat (profunditat, gamma, K, capes) i tots dibuixen la mateixa U. Aquest patró universal té nom i tractament: overfitting/underfitting, a 06-05.

Exercici 3

La neurona de sortida calcula $\sigma(w \cdot \mathbf{a} + b)$ on $\mathbf{a}$ són les activacions ocultes: això és literalment la regressió logística de 04-02, amb $\mathbf{a}$ en el paper de les features. La diferència és que $\mathbf{a}$ no ve del ColumnTransformer: la van aprendre les capes ocultes durant l'entrenament. Implicació geomètrica: a l'espai de les activacions, la frontera de la xarxa és un hiperplà (la logística ho garanteix); però com que la transformació features→activacions és no lineal, aquest hiperplà vist des de l'espai original és una superfície corba arbitrària. És la mateixa jugada que el kernel de la SVM (04-04) — separar linealment en un espai transformat — amb una diferència capital: el kernel fixa la transformació per endavant; la xarxa l'aprèn de les dades.

Conclusió

Has desmuntat la xarxa neuronal fins a les seves peces — neurones que combinen, esbiaixen i activen; capes que componen detectors; forward pass que pots calcular a mà; backpropagation repartint culpes cap enrere perquè el descens de gradient de 04-01 ajusti cada pes — i l'has entrenada sobre el churn amb el mateix Pipeline de sempre. Saps situar-la: màxima flexibilitat, màxim apetit de dades, mínima transparència, i la seva versió profunda (CNN, RNN, transformers) esperant-te a 07-04.

Amb ella es tanca el mòdul: set algorismes, set idees-força, i una taula comparativa que és el teu mapa per triar. Però fixa't en el que els set exigien sense excepció: una columna y — l'etiqueta que diu quin client va abandonar, quant va gastar. I quan no existeix? MercaFresh no té una columna que digui a quin segment pertany cada client, perquè els segments són precisament el que vol descobrir. Aprendre estructura de dades sense etiquetes és l'aprenentatge no supervisat, i el mòdul 5 l'obre amb el seu algorisme emblema: K-means — el nom del qual, ara sí, ja no confondràs amb el K-NN d'aquesta setmana.

Curs de Machine Learning

Mòdul 1: Introducció al Machine Learning

Mòdul 2: Fonaments d'Estadística i Probabilitat

Mòdul 3: Preprocessament de Dades

Mòdul 4: Algorismes de Machine Learning Supervisat

Mòdul 5: Algorismes de Machine Learning No Supervisat

Mòdul 6: Avaluació i Validació de Models

Mòdul 7: Tècniques Avançades i Optimització

Mòdul 8: Implementació i Desplegament de Models

Mòdul 9: Projectes Pràctics

Mòdul 10: Recursos Addicionals

© Copyright 2026. Tots els drets reservats