El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Comparació de frameworks

Següent ►
►

A les dues lliçons anteriors vas construir el mateix gradient i la mateixa xarxa MNIST en TensorFlow/Keras i en PyTorch, i vas comprovar que arriben al mateix resultat. Ara toca la pregunta que tothom es fa tard o d'hora —i que l'equip de TecnoMarket té apuntada a la seva pissarra—: quin triar? Aquesta lliçó respon amb honestedat: sense bàndols, amb criteris. Compararem filosofia, corba d'aprenentatge, depuració, ecosistemes i adopció real; posarem el mateix mini-model costat a costat; presentarem breument els altres actors del panorama (JAX, Hugging Face, ONNX); i tancarem amb una guia de decisió pràctica. Spoiler del final: la tria importa menys del que sembla, perquè el que és valuós —els conceptes que portes cinc mòduls aprenent— és transferible.

Contingut

  1. Dues filosofies, un mateix objectiu
  2. Corba d'aprenentatge i depuració
  3. Ecosistemes: què envolta cada framework
  4. Adopció: indústria vs. recerca
  5. Rendiment: l'empat pràctic
  6. Taula comparativa detallada
  7. El mateix model, costat a costat
  8. Altres actors del panorama
  9. Guia de decisió: per a tu i per a TecnoMarket

Dues filosofies, un mateix objectiu

Si haguéssim de resumir cada framework en una frase:

  • TensorFlow/Keras: "el que és comú ha de ser trivial". Optimitzat per al camí estàndard: definir, compilar, entrenar, desplegar. Va néixer a Google (2015) pensant en producció a gran escala.
  • PyTorch: "tot ha de ser visible". Optimitzat per experimentar: cada pas de l'entrenament és al teu codi, modificable. Va néixer a Meta (2017) pensant en recerca.

Cap filosofia no és superior; responen a necessitats diferents. L'analogia del curs: Keras és l'electrodomèstic amb programes predefinits; PyTorch és la cuina professional on controles cada foc. En el 90 % dels plats el resultat és el mateix; en el 10 % experimental (una GAN amb bucle a mida com la de 05-01, una pèrdua exòtica, un paper acabat de publicar), la cuina professional s'agraeix — tot i que Keras també permet baixar a aquest nivell amb GradientTape, com vas veure a 06-01, simplement no és el seu camí per defecte.

Corba d'aprenentatge i depuració

Corba d'aprenentatge. Keras guanya a les primeres hores: la teva primera xarxa de 02-05 van ser cinc línies (Sequential, compile, fit). A PyTorch aquesta mateixa xarxa exigeix entendre nn.Module, DataLoader i el bucle de cinc passos abans de veure cap resultat. Però la corba es creua: l'usuari de PyTorch entén abans què està passant (perquè ho ha escrit ell), mentre que el de Keras pot trigar més a sortir de la "màgia" de fit(). Aquest curs va seguir deliberadament aquest ordre: primer productivitat amb Keras, després transparència amb PyTorch.

Depuració. Aquí PyTorch té un avantatge estructural gràcies al define-by-run: el forward pass és codi Python normal, així que pots posar print(x.shape) dins de forward(), fer servir el depurador del teu IDE pas a pas, i inspeccionar qualsevol tensor intermedi. A TensorFlow, el mode eager (el que vas fer servir a 06-01) permet el mateix, però quan Keras compila el model a graf per accelerar (tf.function, que fit() aplica per defecte), els errors arriben embolicats en traces llargues i menys llegibles. Traducció pràctica: a Keras depures sobretot llegint missatges; a PyTorch depures executant línia a línia.

Ecosistemes: què envolta cada framework

Un framework no és només la seva API: és tot el que s'ha construït al seu voltant.

L'ecosistema TensorFlow: fort en desplegament

Peça Per a què serveix
TFLite (LiteRT) Executar models en mòbils i dispositius encastats (Android, iOS, microcontroladors)
TF.js Executar i entrenar models al navegador, en JavaScript
TF Serving Servidor de models d'alt rendiment per a producció
TFX Pipelines complets de ML en producció (validació de dades, entrenament, desplegament)
TensorBoard Visualització d'entrenaments (el faràs servir a 06-04; també funciona amb PyTorch)

El fil comú: portar el model allà on és l'usuari. Del desplegament en parlarem amb detall a 06-05.

L'ecosistema PyTorch: fort en models i recerca

Peça Per a què serveix
torchvision / torchaudio / torchtext Datasets, transformacions i models preentrenats per domini
transformers (Hugging Face) Milers de models preentrenats (BERT, GPT i família — els de 05-05) a punt per al fine-tuning
PyTorch Lightning Estructura el bucle d'entrenament explícit (recupera part de la comoditat de fit())
TorchServe Servidor de models (equivalent a TF Serving)

El fil comú: accés immediat al més nou. Quan surt un paper, el seu codi acostuma a estar en PyTorch; quan surt un model de llenguatge obert, és a Hugging Face. Nota important: Hugging Face també suporta TensorFlow en molts models, però el seu ciutadà de primera classe és PyTorch.

Adopció: indústria vs. recerca

Les dades gruixudes, sense entrar en percentatges que caduquen:

  • Recerca: PyTorch domina amb claredat des de ~2020. A les grans conferències (NeurIPS, ICML, CVPR), la immensa majoria de les implementacions publicades són PyTorch. Si la teva feina consisteix a reproduir papers, PyTorch és gairebé obligatori.
  • Indústria: molt més repartit. TensorFlow té una base instal·lada enorme (especialment en empreses que van muntar la seva infraestructura entre 2016 i 2020, i en mòbil/edge gràcies a TFLite), mentre que PyTorch creix amb força empès pel boom dels LLMs i Hugging Face.
  • Ofertes de feina: la majoria de llocs de deep learning citen tots dos o "algun dels dos". Saber-los tots dos —com tu ara— és la posició més còmoda.

Rendiment: l'empat pràctic

Quin entrena més ràpid? Resposta honesta: empat pràctic. Tots dos deleguen la feina pesada a les mateixes llibreries de NVIDIA (cuDNN) per a GPU; tots dos compilen grafs per optimitzar (TF amb tf.function, PyTorch amb torch.compile); i els benchmarks s'alternen segons model, maquinari i versió. Les diferències típiques (±10 %) són menors que l'efecte d'un bon pipeline de dades (el prefetch de 06-01) o d'un batch size adequat. Conclusió: no triïs framework per velocitat; tria per equip, ecosistema i destí del model.

Taula comparativa detallada

Criteri TensorFlow / Keras PyTorch
Creador i any Google, 2015 Meta, 2017
Filosofia Alt nivell per defecte, producció Explícit per defecte, recerca
Definició del model Sequential / funcional / subclassing Subclassing (nn.Module) com a norma
Bucle d'entrenament fit() automàtic (GradientTape si vols control) Sempre explícit (Lightning si vols estructura)
Corba inicial Molt suau (5 línies i entrenes) Més exigent (bucle de 5 passos)
Depuració Bona en eager; traces dures en mode graf Excel·lent: Python pur, depurador estàndard
Dades tf.data (map/shuffle/batch/prefetch) Dataset + DataLoader
Mòbil / navegador TFLite, TF.js (maduríssims) ExecuTorch (més recent)
Servir en producció TF Serving, TFX TorchServe, servidors genèrics (FastAPI)
Models preentrenats Keras Applications (MobileNetV2 de 05-03), TF Hub torchvision, Hugging Face (enorme)
Comunitat investigadora Minoritària avui Dominant
Base instal·lada a l'empresa Molt gran Gran i creixent
Rendiment Equivalent Equivalent
El que ja has fet al curs Mòduls 2–5 complets i 06-01 06-02 (MNIST reescrita)

El mateix model, costat a costat

Els fragments ja els vas veure a 06-01 i 06-02; aquí van condensats per veure'ls d'un cop d'ull. La xarxa 784-128-64-10 de 02-05:

# ---------- KERAS ----------
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])
model.fit(x_train, y_train, epochs=5, batch_size=32)
# ---------- PYTORCH ----------
import torch
from torch import nn

class XarxaMNIST(nn.Module):
    def __init__(self):
        super().__init__()
        self.xarxa = nn.Sequential(        # sí, PyTorch també té Sequential
            nn.Linear(784, 128), nn.ReLU(),
            nn.Linear(128, 64), nn.ReLU(),
            nn.Linear(64, 10))             # logits, sense softmax (vegeu 06-02)

    def forward(self, x):
        return self.xarxa(x)

model = XarxaMNIST()
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(5):
    for x, y in train_loader:
        logits = model(x.view(x.size(0), -1))
        loss = loss_fn(logits, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Lectura del costat a costat:

  • La definició del model és gairebé un calc (fixa't en nn.Sequential: per a piles lineals, PyTorch també ofereix drecera).
  • La diferència és a l'entrenament: 3 línies (compile + fit) contra ~10 (el bucle). Aquest és, en essència, tot el debat entre frameworks condensat en pantalla.
  • I les dues diferències "de detall" que ja coneixes: softmax a la sortida (Keras) vs. logits crus (PyTorch), i el flatten explícit.

Altres actors del panorama

El món no s'acaba amb TF i PyTorch. Tres noms que convé situar:

Actor Què és Quan te'l trobaràs
JAX Llibreria de Google: numpy + diferenciació automàtica + compilació XLA. Estil funcional pur Recerca puntera i models gegants; Keras 3 el pot fer servir com a backend
Hugging Face No competeix: és una capa superior amb milers de models preentrenats (transformers de 05-05) i datasets, sobre PyTorch (principalment) i TF Quan vulguis fer servir un BERT/GPT sense entrenar-lo tu (ho faràs a 07-05)
ONNX No és un framework: és un format d'intercanvi de models. Exportes de PyTorch, executes en qualsevol runtime compatible Com a pont entre frameworks i cap a producció; el farem servir a 06-05

Menció final: Keras 3 és avui multi-backend — el mateix codi Keras pot executar-se sobre TensorFlow, JAX o fins i tot PyTorch. La frontera entre frameworks es difumina any rere any: un altre motiu per no obsessionar-se amb la tria.

Guia de decisió: per a tu i per a TecnoMarket

Preguntes que sí que decideixen (en ordre de pes):

  1. Què fa servir el teu equip / la teva empresa? El millor framework és el que fan servir les persones que t'ajudaran i el codi que heretaràs.
  2. Partiràs de models preentrenats de recerca recent (LLMs, difusió, el més nou de Hugging Face)? → PyTorch et donarà menys fricció.
  3. El destí és mòbil, navegador o edge? → L'ecosistema TFLite/TF.js de TensorFlow continua sent el més madur.
  4. Prioritzes prototipar ràpid fluxos estàndard (classificació, regressió, transfer learning com el de 05-03)? → Keras és difícil de superar.
  5. Necessites bucles d'entrenament a mida (GANs com 05-01, pèrdues múltiples, recerca)? → L'estil explícit de PyTorch resulta més natural.

La decisió de TecnoMarket. L'equip de dades ho debat i decideix:

  • Keras/TensorFlow com a base de producció: els seus sistemes actuals (classificador de fotos amb MobileNetV2 de 05-03, classificador de ressenyes de 04-03, predicció de demanda de 04-04) ja estan escrits en Keras, funcionen, i el pla de portar el classificador de productes a l'app mòbil dels operaris del magatzem encaixa amb TFLite.
  • PyTorch com a eina d'exploració: el projecte de generació de descripcions i imatges promocionals (mòdul 7) partirà de models de Hugging Face, i aquí PyTorch és el camí curt.
  • Regla d'equip: tot model que passi a producció es valida contra el mateix conjunt de test congelat, sigui quin sigui el framework — i ONNX queda anotat com a pont si algun dia cal moure un model d'un món a l'altre (ho veurem a 06-05).

És una decisió pragmàtica, no religiosa. I és la mateixa que et recomanem a tu: aprofundeix en un, mantén-te funcional en l'altre.

Errors Comuns i Consells

  • Triar per titulars ("X és mort", "tothom fa servir Y"): tots dos frameworks tenen desenvolupament actiu, comunitats enormes i anys de futur. Decideix pel teu context, no per Twitter.
  • Canviar de framework a mig projecte: el cost de migrar (reescriure, revalidar, formar l'equip) gairebé mai no compensa un avantatge marginal. Acaba amb el que has començat; migra, si de cas, entre projectes.
  • Aprendre el framework en lloc dels conceptes: qui entén backprop (02-03), regularització (05-04) o atenció (05-05) migra de framework en dies; qui només ha memoritzat APIs comença de zero. Inverteix en conceptes.
  • Comparar rendiment amb benchmarks aliens: si de debò t'importa la velocitat, mesura el teu model amb les teves dades al teu maquinari. Els benchmarks genèrics no capturen el teu cas.
  • Consell: llegir codi de l'"altre" framework és un exercici boníssim. Amb les taules d'equivalències de 06-02 pots traduir mentalment gairebé qualsevol exemple, i això duplica la documentació i els tutorials al teu abast.

Exercicis

Exercici 1: traducció mental

Sense executar res, aparella cada element de Keras amb el seu equivalent PyTorch: (a) model.fit(...), (b) Dense(64, activation="relu"), (c) tf.data.Dataset amb shuffle().batch(), (d) model.evaluate(...), (e) compile(optimizer="adam", loss=...).

Exercici 2: recomanació raonada

Tres escenaris; per a cadascun, recomana framework i justifica-ho en 2-3 línies fent servir els criteris de la guia de decisió: (1) una startup vol detectar defectes de fabricació amb la càmera d'una tauleta Android a la mateixa fàbrica, sense connexió; (2) un grup universitari vol modificar el mecanisme d'atenció d'un transformer publicat el mes passat; (3) TecnoMarket vol un classificador estàndard de tiquets de suport en 2 setmanes, amb un equip que només ha fet aquest curs.

Exercici 3: llegir l'altre idioma

Aquest fragment PyTorch t'arriba en un paper. Descriu-lo en "idioma Keras": quin model és i com l'escriuries amb Sequential?

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 8)
        self.drop = nn.Dropout(0.3)
        self.fc2 = nn.Linear(8, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.drop(x)
        return self.fc2(x)

Solucions

Solució 1:

  • (a) fit() → el bucle explícit complet: for epoch → forward → loss → zero_grad → backward → step.
  • (b) Dense(64, activation="relu") → nn.Linear(entrada, 64) seguit de nn.ReLU() (a PyTorch l'entrada és explícita i l'activació va a part).
  • (c) tf.data amb shuffle().batch() → DataLoader(dataset, batch_size=..., shuffle=True).
  • (d) evaluate() → bucle amb model.eval() + torch.no_grad() calculant mètriques a mà.
  • (e) compile(...) → crear torch.optim.Adam(model.parameters()) i la funció de pèrdua (nn.CrossEntropyLoss(), etc.) com a objectes solts.

Solució 2:

  1. TensorFlow/Keras: destí edge/mòbil sense connexió → TFLite és l'ecosistema més madur per a Android (criteri 3). Entrenarien amb Keras (probablement transfer learning com a 05-03) i exportarien a TFLite.
  2. PyTorch: reproduir i modificar un paper recent → el codi publicat serà gairebé segur en PyTorch (criteri 2), i el bucle explícit facilita tocar l'interior del model (criteri 5).
  3. Keras: flux estàndard, termini curt, equip format en aquest curs on Keras és l'idioma principal (criteris 1 i 4). TextVectorization + xarxa densa com a 04-03 i cap a producció.

Solució 3: És un MLP binari amb dropout (com els de 05-04): entrada de 20 característiques, capa oculta de 8 amb ReLU, dropout del 30 % i sortida d'1 logit (la pèrdua seria BCEWithLogitsLoss). En Keras:

model = keras.Sequential([
    keras.layers.Dense(8, activation="relu", input_shape=(20,)),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(1, activation="sigmoid"),   # o sense sigmoide + from_logits=True
])

Únic matís: la versió Keras habitual posa sigmoid a la sortida i fa servir BinaryCrossentropy normal; l'equivalència exacta amb el fragment PyTorch (logit cru) seria sense activació final i from_logits=True.

Conclusió

Ja tens la comparació completa: Keras/TensorFlow brilla en productivitat i desplegament (TFLite, TF.js, TF Serving); PyTorch brilla en transparència, depuració i recerca (Hugging Face, papers); el rendiment és un empat pràctic; i al voltant hi orbiten JAX, Hugging Face com a capa superior i ONNX com a format pont. TecnoMarket va triar pragmàticament: Keras per a la seva producció existent, PyTorch per explorar models preentrenats, i validació comuna per a tot. La lliçó de fons és la que tanca el debat: els conceptes del curs —tensors, gradients, capes, regularització, atenció— són transferibles; el framework és una eina, i tu ja domines les dues principals.

Abans de portar res a producció, falta professionalitzar l'entorn on treballes: a la propera lliçó sortirem del notebook —GPUs locals i al núvol, estructura de projecte, reproduïbilitat, control de versions per a ML i monitoratge amb TensorBoard— perquè la feina de l'equip de TecnoMarket deixi de viure en pestanyes de Colab soltes.

◄ Anterior
◄
Següent ►
►

Curs de Deep Learning

Mòdul 1: Introducció al Deep Learning

Mòdul 2: Fonaments de Xarxes Neuronals

Mòdul 3: Xarxes Neuronals Convolucionals (CNN)

Mòdul 4: Xarxes Neuronals Recurrents (RNN)

Mòdul 5: Tècniques Avançades en Deep Learning

Mòdul 6: Eines i Frameworks

Mòdul 7: Projectes Pràctics

Mòdul 8: Consideracions Ètiques i Futur del Deep Learning

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2026. Tots els drets reservats