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

Preparació de l'entorn de treball

Següent ►
►

Ja tens la base conceptual del deep learning; ara toca preparar el taller. En aquesta lliçó muntaràs l'entorn on executaràs tot el codi del curs: veurem les dues opcions principals —Google Colab (recomanada per començar, amb GPU gratuïta) i la instal·lació local amb Python—, aprendràs el més bàsic dels Jupyter Notebooks, verificaràs que la instal·lació i la GPU funcionen amb un script concret, i crearàs l'estructura de carpetes del projecte TecnoMarket que farem servir a la resta del curs. Un entorn ben muntat des del principi t'estalviarà hores de frustració: la majoria dels problemes dels principiants no són de xarxes neuronals, sinó d'instal·lació.

Contingut

  1. Les dues opcions: Colab vs instal·lació local
  2. Opció A: Google Colab, pas a pas
  3. Opció B: instal·lació local amb Python
  4. Jupyter Notebooks: el més bàsic
  5. Script de verificació de l'entorn i la GPU
  6. Estructura de carpetes del projecte TecnoMarket
  7. Bones pràctiques: entorns aïllats i versions

Les dues opcions: Colab vs instal·lació local

Per entrenar xarxes neuronals necessites Python, unes quantes biblioteques i, si pot ser, una GPU (recorda de la lliçó 01-02: les GPU van ser una de les claus del ressorgiment del deep learning; acceleren l'entrenament de 10 a 50 vegades). Hi ha dues maneres d'aconseguir-ho:

Aspecte Google Colab (núvol) Instal·lació local
Cost inicial Gratis Gratis (però una GPU NVIDIA costa diners)
GPU Inclosa gratis (amb límits d'ús) Només si el teu equip en té
Instal·lació Cap: s'obre al navegador Python + biblioteques + (controladors de GPU)
Requereix internet Sí, sempre No
Persistència Les sessions es reinicien; cal desar a Google Drive Tot queda al teu disc
Privacitat de les dades Les dades pugen a Google Les dades no surten de la teva màquina
Ideal per a Aprendre, prototipar, aquest curs Treball continuat, dades sensibles, projectes seriosos

Recomanació per al curs: comença amb Google Colab. Zero instal·lació, GPU gratuïta i tots els notebooks del curs funcionaran tal qual. Munta l'entorn local a més (no en lloc de) quan vulguis: és l'escenari realista d'un lloc de treball, i a TecnoMarket, amb dades internes de clients i pagaments, l'equip treballaria en local o en servidors propis precisament per privacitat.

Opció A: Google Colab, pas a pas

Google Colab (colab.research.google.com) és un servei gratuït que executa notebooks de Python en servidors de Google.

  1. Entra a https://colab.research.google.com amb un compte de Google.
  2. Crea un notebook: menú Archivo → Nuevo notebook (o File → New notebook, segons l'idioma de la interfície). Ja pots executar Python: no cal instal·lar res, les biblioteques principals (TensorFlow, PyTorch, NumPy, pandas, matplotlib) venen preinstal·lades.
  3. Activa la GPU: menú Entorno de ejecución → Cambiar tipo de entorno de ejecución → Acelerador por hardware: GPU → Guardar. Aquest pas és fàcil d'oblidar i és la causa número 1 de "el meu entrenament va lentíssim" a Colab.
  4. Executa la teva primera cel·la: escriu el codi i prem Shift+Enter.
# Primera cel·la a Colab: comprovar que hi ha Python i quina GPU ens ha tocat
import sys
print("Versió de Python:", sys.version)

# Ordre del sistema (el signe ! executa ordres de terminal des del notebook)
!nvidia-smi

Si has activat la GPU, nvidia-smi mostrarà una taula amb el model de targeta assignada (T4, per exemple) i la seva memòria. Si dona error, revisa el pas 3.

Limitacions que cal conèixer: les sessions gratuïtes es desconnecten després d'un temps d'inactivitat (i tenen un màxim d'hores), i el disc de la sessió s'esborra en desconnectar. Desa sempre els teus notebooks (es desen sols a Google Drive) i munta Drive per conservar dades i models:

# Muntar Google Drive per desar dades i models de manera persistent
from google.colab import drive
drive.mount('/content/drive')
# A partir d'aquí, tot el que es desi a /content/drive/MyDrive/ sobreviu a la sessió

Opció B: instal·lació local amb Python

Per treballar a la teva pròpia màquina necessites quatre passos: Python, un entorn aïllat, les biblioteques i Jupyter.

Pas 1: instal·lar Python 3

Necessites Python 3.10 o superior (comprova la versió amb python3 --version).

  • Linux: acostuma a venir instal·lat. Si no: sudo apt install python3 python3-pip python3-venv (Debian/Ubuntu).
  • Windows: descarrega l'instal·lador de https://www.python.org/downloads/ i marca la casella "Add Python to PATH" durant la instal·lació.
  • macOS: brew install python3 (amb Homebrew) o l'instal·lador de python.org.

Pas 2: crear un entorn aïllat

No instal·lis mai biblioteques directament sobre el Python del sistema. Un entorn aïllat és una carpeta amb la seva pròpia còpia de Python i les seves pròpies biblioteques; si alguna cosa es trenca, esborres la carpeta i comences de nou sense afectar res més. Hi ha dues eines equivalents; fes servir l'una o l'altra:

Amb venv (inclòs a Python):

# Crear la carpeta del projecte i l'entorn
mkdir tecnomarket-dl
cd tecnomarket-dl
python3 -m venv .venv

# Activar l'entorn (cal fer-ho a cada sessió de terminal)
source .venv/bin/activate        # Linux / macOS
# .venv\Scripts\activate         # Windows (PowerShell o CMD)

# Veuràs (.venv) al principi del prompt: l'entorn està actiu

Amb conda (si prefereixes la distribució Miniconda/Anaconda):

conda create -n tecnomarket-dl python=3.11
conda activate tecnomarket-dl

Pas 3: instal·lar les biblioteques

Amb l'entorn activat:

# Actualitzar pip (el gestor de paquets de Python)
pip install --upgrade pip

# Frameworks de deep learning: instal·lem els dos que fa servir el curs
pip install tensorflow torch torchvision

# Eines d'acompanyament
pip install numpy pandas matplotlib scikit-learn jupyter

Què és cada cosa:

  • tensorflow: framework de deep learning de Google; el farem servir des de la seva API Keras (mòdul 6, lliçó 06-01).
  • torch / torchvision: PyTorch, el framework de Meta, i les seves utilitats de visió (lliçó 06-02). Instal·lem tots dos frameworks perquè el curs ensenya els dos; la comparació en profunditat arribarà a la lliçó 06-03.
  • numpy / pandas: càlcul numèric i maneig de taules de dades.
  • matplotlib: gràfiques (corbes d'entrenament, visualització d'imatges).
  • scikit-learn: utilitats de ML clàssic (divisions train/test, mètriques).
  • jupyter: els notebooks en local.

Nota sobre GPU en local: a Windows/Linux, PyTorch i TensorFlow només acceleren amb GPU NVIDIA (mitjançant CUDA); la instal·lació estàndard de dalt funciona en CPU en qualsevol màquina, que és suficient per als exemples petits del curs. Si tens GPU NVIDIA i la vols aprofitar, segueix la guia oficial d'instal·lació de cada framework per al teu sistema (les combinacions de controladors/CUDA canvien sovint i convé mirar la pàgina oficial: pytorch.org/get-started i tensorflow.org/install). Si no tens GPU, no et preocupis: per a això hi ha Colab.

Pas 4: engegar Jupyter

jupyter notebook
# S'obrirà el navegador a http://localhost:8888 mostrant les teves carpetes

Jupyter Notebooks: el més bàsic

Tant Colab com Jupyter local fan servir el mateix concepte: el notebook, un document interactiu que barreja cel·les de codi executables amb cel·les de text (Markdown). És el format estàndard per experimentar en deep learning perquè permet executar la feina per passos, veure resultats (taules, gràfiques) al costat del codi i documentar el que fas.

El mínim que has de saber:

Acció Com
Executar una cel·la Shift+Enter (executa i passa a la següent)
Inserir cel·la a sota Tecla B (amb la cel·la seleccionada, sense estar editant-la)
Inserir cel·la a sobre Tecla A
Esborrar cel·la D, D (dues vegades)
Convertir cel·la a text/Markdown Tecla M (i Y per tornar a codi)
Reiniciar el kernel Menú Kernel → Restart (esborra totes les variables)

Dos conceptes importants:

  • El kernel és el procés de Python que executa les teves cel·les. Les variables perviuen entre cel·les mentre el kernel visqui.
  • L'ordre d'execució importa: pots executar cel·les en qualsevol ordre, i això és una font clàssica d'errors (fer servir una variable definida en una cel·la que encara no has executat, o resultats "fantasma" d'execucions anteriors). Davant d'un comportament estrany, el remei universal és Kernel → Restart & Run All: reinicia i ho executa tot de dalt a baix. Si així funciona, el teu notebook és reproduïble.

Script de verificació de l'entorn i la GPU

Crea un notebook (a Colab o en local) anomenat 00_verificacio.ipynb i executa aquest script complet. És la "revisió mèdica" de l'entorn: comprova versions, frameworks i GPU.

# === Script de verificació de l'entorn TecnoMarket-DL ===
import sys
print(f"Python: {sys.version.split()[0]}")

# --- Biblioteques de dades ---
import numpy as np
import pandas as pd
import matplotlib
print(f"NumPy: {np.__version__} | pandas: {pd.__version__} | matplotlib: {matplotlib.__version__}")

# --- TensorFlow ---
import tensorflow as tf
print(f"\nTensorFlow: {tf.__version__}")
gpus_tf = tf.config.list_physical_devices('GPU')
print(f"GPU visible per a TensorFlow: {'SÍ -> ' + str(gpus_tf) if gpus_tf else 'NO (farà servir CPU)'}")

# --- PyTorch ---
import torch
print(f"\nPyTorch: {torch.__version__}")
if torch.cuda.is_available():
    print(f"GPU visible per a PyTorch: SÍ -> {torch.cuda.get_device_name(0)}")
else:
    print("GPU visible per a PyTorch: NO (farà servir CPU)")

# --- Miniprova de càlcul real ---
# Multipliquem dues matrius grans: si això funciona, l'entorn està operatiu
a = torch.rand(1000, 1000)   # matriu 1000x1000 de números aleatoris
b = torch.rand(1000, 1000)
device = "cuda" if torch.cuda.is_available() else "cpu"
resultat = (a.to(device) @ b.to(device))   # @ = multiplicació de matrius
print(f"\nMultiplicació de matrius 1000x1000 en '{device}': OK, suma = {resultat.sum():.2f}")

print("\n=== Entorn verificat: a punt per al curs ===")

Interpretació de la sortida:

  • Hi han d'aparèixer les versions de totes les biblioteques sense cap ImportError. Si alguna falla, revisa que l'entorn estigui activat i reinstal·la-la amb pip.
  • Les línies de GPU diran SÍ o NO. A Colab amb la GPU activada han de dir SÍ; en un portàtil sense NVIDIA diran NO, i és normal: el curs es pot seguir en CPU (els exemples estan dimensionats per a això) i fer servir Colab per als entrenaments pesats.
  • La miniprova executa una operació real del tipus que fan les xarxes neuronals (multiplicar matrius, exactament l'entrades × pesos de la lliçó 01-04, a l'engròs). Si imprimeix OK, tot funciona de debò, no només s'importa.

Estructura de carpetes del projecte TecnoMarket

Durant el curs anirem generant notebooks, dades i models del projecte TecnoMarket. Crear una estructura ordenada ara evitarà el caos després. Executa al terminal (o crea les carpetes a mà; a Colab, crea-les dins de MyDrive):

tecnomarket-dl/
├── .venv/                  # l'entorn virtual (només en local; no es toca)
├── dades/
│   ├── brutes/             # dades tal com arriben (fotos, CSV de ressenyes...)
│   └── processades/        # dades ja netes i a punt per entrenar
├── notebooks/              # un notebook per lliçó/experiment: 02-05-primera-xarxa.ipynb...
├── models/                 # models entrenats que desem (mòdul 6)
├── figures/                # gràfiques exportades (corbes d'entrenament, etc.)
└── requirements.txt        # les versions exactes de les biblioteques (vegeu més avall)
# Ordres per crear-la en local (Linux/macOS; a Windows, mkdir equivalents)
cd tecnomarket-dl
mkdir -p dades/brutes dades/processades notebooks models figures

Regles d'ús que seguirem tot el curs:

  • dades/brutes és només de lectura: no modifiquis mai les dades originals; tota transformació es desa a dades/processades. Així sempre pots tornar a començar.
  • Un notebook per lliçó o experiment, amb nom numerat (03-02-cnn-cifar10.ipynb): l'ordre del curs serà l'ordre dels teus fitxers.
  • Els models entrenats van a models/ amb nom i data: aprendrem a desar-los i carregar-los a la lliçó 06-05.

Bones pràctiques: entorns aïllats i versions

Tres hàbits professionals que t'evitaran problemes seriosos:

  1. Un entorn aïllat per projecte. El projecte TecnoMarket té el seu .venv; un altre projecte tindrà el seu. Així, actualitzar una biblioteca per a un projecte no trenca els altres. No instal·lis mai amb pip fora d'un entorn.

  2. Congela les versions. Les biblioteques de deep learning canvien de pressa i el codi que avui funciona pot fallar amb la versió de l'any que ve. Desa les versions exactes del teu entorn:

# Desar l'estat de l'entorn a requirements.txt
pip freeze > requirements.txt

# Recrear l'entorn en una altra màquina (o després de trencar-lo)
pip install -r requirements.txt

En el context de TecnoMarket això és crític: si el classificador de fotos passa a producció, l'equip ha de poder reconstruir l'entorn exacte on es va entrenar.

  1. Verifica abans de treballar. Quan alguna cosa falli a mig curs, torna al notebook 00_verificacio.ipynb i executa'l: distingiràs en segons si el problema és de l'entorn o del teu codi.

Més endavant, a la lliçó 06-04, veurem entorns i recursos més avançats (IDE, gestió d'experiments, alternatives de núvol); per ara, amb Colab o el teu entorn local verificat tens tot el que cal.

Errors Comuns i Consells

  • Error: entrenar a Colab sense activar la GPU. Colab arrenca per defecte sense accelerador. Si un entrenament va sospitosament lent, el primer que has de mirar és Entorno de ejecución → Cambiar tipo de entorno de ejecución.
  • Error: instal·lar paquets sense activar l'entorn. Si pip install funciona però després import falla al notebook, gairebé segur que has instal·lat en un Python diferent del que fa servir Jupyter. Activa l'entorn abans d'instal·lar i abans d'engegar Jupyter.
  • Error: perdre la feina a Colab. El disc de la sessió és efímer. Dades i models que vulguis conservar, sempre a Google Drive muntat.
  • Error: fer servir python quan el sistema té python3. A Linux/macOS l'ordre es pot dir python3; dins d'un entorn activat, python ja apunta a la versió correcta.
  • Error: executar les cel·les del notebook en desordre. Si apareixen resultats incoherents, Kernel → Restart & Run All i revisa-ho de dalt a baix.
  • Consell: no persegueixis l'última versió de cada biblioteca; persegueix un entorn estable i congelat a requirements.txt. La reproduïbilitat val més que la novetat.

Exercicis

Exercici 1: Posada en marxa a Colab

Crea un notebook a Google Colab anomenat 00_verificacio, activa la GPU, executa l'script de verificació complet d'aquesta lliçó i comprova que tots dos frameworks detecten la GPU. Després, desactiva la GPU (torna a CPU), reinicia l'entorn i executa'l una altra vegada. Compara les dues sortides: quines línies canvien?

Exercici 2: Entorn local reproduïble

A la teva màquina: crea la carpeta tecnomarket-dl amb l'estructura de carpetes de la lliçó, crea i activa un entorn virtual, instal·la les biblioteques del curs, genera el requirements.txt i executa l'script de verificació en un Jupyter local. Anota quina versió de Python, TensorFlow i PyTorch t'ha quedat instal·lada.

Exercici 3: Diagnòstic d'una fallada

Un company de l'equip de dades de TecnoMarket t'escriu: "He instal·lat torch amb pip i m'ha dit que tot correcte, però en fer import torch al meu notebook em dona ModuleNotFoundError". Enumera, per ordre de probabilitat, les causes possibles i quina ordre o comprovació faries per descartar cadascuna.

Solucions

Solució 1:

Amb la GPU activada, nvidia-smi mostra la targeta assignada, i les línies de verificació diuen GPU visible per a TensorFlow: SÍ i GPU visible per a PyTorch: SÍ -> Tesla T4 (o un altre model); la miniprova indica device 'cuda'. En tornar a CPU, totes dues línies passen a NO (farà servir CPU), la miniprova indica 'cpu' i nvidia-smi dona error ("command not found" o similar, perquè la màquina assignada no té GPU). Les versions de Python i biblioteques no canvien: només canvia el maquinari disponible, no el programari.

Solució 2:

Seqüència esperada (Linux/macOS):

mkdir tecnomarket-dl && cd tecnomarket-dl
mkdir -p dades/brutes dades/processades notebooks models figures
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install tensorflow torch torchvision numpy pandas matplotlib scikit-learn jupyter
pip freeze > requirements.txt
jupyter notebook

Les versions concretes dependran del moment de la instal·lació (per exemple, Python 3.11.x, TensorFlow 2.x, PyTorch 2.x); l'important és que l'script de verificació s'executi sense errors d'importació i que requirements.txt reculli les versions exactes per poder reproduir l'entorn.

Solució 3:

Per ordre de probabilitat:

  1. Va instal·lar en un Python diferent del que fa servir el notebook (el cas més comú): va instal·lar amb l'entorn desactivat, o Jupyter corre sobre un altre entorn. Comprovació: en una cel·la, import sys; print(sys.executable) i comparar amb la ruta on va instal·lar pip (which pip / pip -V al terminal). Solució: activar l'entorn correcte i instal·lar-hi, o engegar Jupyter des de l'entorn.
  2. El kernel del notebook no és el de l'entorn: a Jupyter hi pot haver diversos kernels registrats. Comprovació: menú Kernel → Change kernel.
  3. No va reiniciar el kernel després d'instal·lar: si el notebook ja estava obert en instal·lar, de vegades cal Kernel → Restart.
  4. La instal·lació va fallar en realitat (quedar-se sense espai, error de xarxa que no va veure). Comprovació: pip show torch al terminal amb l'entorn activat.

Conclusió

El teu taller està muntat: saps treballar amb Google Colab i la seva GPU gratuïta, tens (o saps crear) un entorn local aïllat amb TensorFlow i PyTorch, domines els moviments bàsics de Jupyter, comptes amb un script de verificació per diagnosticar l'entorn en qualsevol moment, i l'estructura de carpetes del projecte TecnoMarket està a punt per rebre els notebooks, les dades i els models de tot el curs. Recorda les tres regles d'or: entorns aïllats, versions congelades i dades brutes intocables.

Amb això s'acaba el mòdul d'introducció: saps què és el deep learning, d'on ve, per a què serveix, de què estan fetes les xarxes i on les construiràs. Al mòdul 2 comencem la part pràctica de debò: del perceptró al perceptró multicapa, funcions d'activació, propagació i optimització... fins a entrenar la teva primera xarxa neuronal completa amb dades reals.

◄ 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