Processament del Llenguatge Natural

Introducció

El Processament del Llenguatge Natural (PLN, o NLP de l'anglès Natural Language Processing) és la branca de la IA que s'ocupa de la interacció entre ordinadors i llenguatge humà. L'any 2025, el PLN ha viscut la revolució més gran de la seva història: els Large Language Models (LLMs) com GPT-4o, Claude 3.5 i Gemini 1.5 han demostrat capacitats que fa uns pocs anys semblaven impossibles — escriure codi, analitzar documents complexos, traduir entre idiomes, raona pas a pas o mantenir converses naturals durant hores.

Però per comprendre per què els LLMs funcionen tan bé (i per què fallen de les maneres que fallen), cal entendre l'evolució completa del camp: des dels primers models estadístics fins a l'arquitectura Transformer que ho ha canviat tot.

Per quin motiu el PLN és fonamental per al perfil IABD?

El 80% de les dades empresarials existents és text no estructurat: emails, informes, contractes, comentaris de clients, posts a xarxes socials, manuals tècnics. Saber processar, analitzar i extreure valor d'aquest text és una competència diferencial clau per a qualsevol professional de dades.

1. Evolució del PLN: de Bag of Words als LLMs

1.1. Era estadística (1990-2010)

Bag of Words (BoW) El model més simple: representa un document com un vector de freqüències de paraules, ignorant l'ordre i el context. "El gat menja el ratolí" i "El ratolí menja el gat" produirien el mateix vector.

Limitació fonamental: perd tot el context i la semàntica.

TF-IDF (Term Frequency – Inverse Document Frequency) Millora el BoW pondero les paraules que apareixen sovint en un document (TF alta) però rarament en la col·lecció (IDF alta). Segueix ignorant el context però captura la "importància" de cada terme.

Aplicació típica: cerca de documents, classificació de spam, anàlisi de sentiment bàsica.

N-grames i Models de Markov En comptes de paraules individuals, es consideren seqüències de N paraules consecutives (bigrames, trigrames, etc.) per capturar una mica de context local. Base dels primers sistemes de reconeixement de veu i traducció automàtica estadística.

1.2. Era dels embeddings (2013-2017)

Word2Vec (Mikolov et al., Google, 2013) El salt qualitatiu: paraules similars semànticament ocupen posicions properes en un espai vectorial de alta dimensió (típicament 100-300 dimensions). L'entrenament és no supervisat sobre grans corpus de text.

La propietat més famosa:

vec("rei") - vec("home") + vec("dona") ≈ vec("reina")

Cada paraula és un punt en un espai de 300 dimensions. La distància (cosinus) entre punts reflexa similitud semàntica.

GloVe (Stanford, 2014): Similar a Word2Vec però entrenada sobre estadística global de co-ocurrències. Lleugerament millor en tasques analògiques.

fastText (Facebook AI, 2016): Embeddings de subparaules. Pot generar vectors per a paraules mai vistes durant l'entrenament. Molt millor per a idiomes morfològicament rics (català, alemany, turc).

Limitació fonamental: un embedding per paraula, independentment del context. La paraula "banc" té el mateix vector en "el banc del parc" que en "el banc m'ha denegat el crèdit".

1.3. Era dels models contextuals (2018-2019)

ELMo (Embeddings from Language Models, Allen Institute, 2018) Primer model que genera embeddings contextuals: el vector d'una paraula canvia depenent de les paraules que l'envolten. Usat com a capa d'embeddings en altres models.

BERT (Bidirectional Encoder Representations from Transformers, Google, 2018) Un punt d'inflexió. BERT entrena un Transformer bidireccional (llegeix el text en les dues direccions simultàniament) sobre dos objectius: 1. Masked Language Modeling (MLM): predir paraules ocultes (com omplir buits) 2. Next Sentence Prediction (NSP): predir si dos fragments de text són consecutius

El resultat: representacions contextuals riquíssimes. BERT va superar l'estat de l'art en 11 tasques NLP simultàniament en el moment de la seva publicació.

Variants de BERT: RoBERTa (Facebook, millors hiperparàmetres), DistilBERT (50% més petit, 97% del rendiment), ALBERT, DeBERTa, XLM-RoBERTa (multilingüe).

1.4. Era dels LLMs (2020-actualitat)

GPT-3 (OpenAI, 2020) — 175 mil milions de paràmetres El primer LLM a demostrar capacitats emergents de few-shot learning: podia realitzar tasques noves amb només 3-5 exemples en el prompt, sense reentrenament.

ChatGPT (OpenAI, novembre 2022) — basat en GPT-3.5 L'aplicació que va portar el PLN a les masses. Clau: entrenament amb RLHF (Reinforcement Learning from Human Feedback) per fer el model més útil, honest i inofensiu.

GPT-4 (OpenAI, març 2023) — multimodal, habilitats de raonament molt superiors.

Claude 3 / 3.5 (Anthropic, 2024): especial èmfasi en seguretat, instruccions llargues i raonament.

Gemini 1.5 Pro (Google DeepMind, 2024): context window d'1 milió de tokens, multimodal nativament.

LLaMA 3.1 (Meta, juliol 2024): fins a 405B paràmetres, obert per a recerca i ús comercial.

graph LR
    BOW[Bag of Words 1990] --> TFIDF[TF-IDF 2000]
    TFIDF --> W2V[Word2Vec 2013]
    W2V --> ELM[ELMo 2018]
    ELM --> BERT[BERT 2018]
    BERT --> GPT2[GPT-2 2019]
    GPT2 --> GPT3[GPT-3 2020]
    GPT3 --> CHAT[ChatGPT 2022]
    CHAT --> GPT4[GPT-4 2023]
    GPT4 --> NOW[GPT-4o Claude Gemini 2024]

2. Arquitectura Transformer

2.1. El paper que ho va canviar tot

El 2017, un equip de Google Brain va publicar el paper "Attention Is All You Need" (Vaswani et al., 2017). En ell s'introduïa l'arquitectura Transformer, que elimina la recurrència (LSTM, GRU) i la convolució, substituint-les per mecanismes d'atenció pura. El resultat: un model molt més paralel·litzable, que entrena ordres de magnitud més ràpid i captura dependències de llarg abast en el text de forma molt més efectiva.

2.2. Components principals del Transformer

Tokenització Abans de processar el text, cal convertir-lo en tokens (fragments de text, aproximadament una paraula o subparaula). El tokenitzador més usat pels LLMs moderns és BPE (Byte Pair Encoding): comença amb caràcters individuals i fusiona iterativament els parells més freqüents.

Exemple de tokenització (GPT-4 tiktoken):
"intel·ligència artificial" → ["intel", "·", "lig", "ència", " art", "ificial"]
"ChatGPT" → ["Chat", "GPT"]
"tokenitzar" → ["token", "itz", "ar"]

Embeddings de posició A diferència de les RNN, el Transformer processa tots els tokens simultàniament (en paral·lel). Per preservar l'ordre del text, s'afegeix una codificació posicional (posicional encoding) a cada embedding de token.

Multi-Head Self-Attention El mecanisme d'atenció és el cor del Transformer. Per a cada token, calcula quanta "atenció" ha de prestar a cada altre token de la seqüència.

Formalment:

Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) · V

On:
  Q = matriu de Queries (preguntes)
  K = matriu de Keys (claus)
  V = matriu de Values (valors)
  d_k = dimensió de les keys (per normalitzar)

De forma intuitiva: cada token "pregunta" quins altres tokens són rellevants per a ell (Q), els altres tokens "ofereixen" una clau identificativa (K), i es calculen les similituds. Els tokens amb similituds altes contribueixen més al seu valor de sortida (V).

El Multi-Head significa que es fan N atencions en paral·lel, cadascuna aprenent a atendre aspectes diferentes del text (sintàctic, semàntic, correferencial, etc.).

graph TD
    INPUT[Tokens d-entrada] --> EMB[Embeddings + Positional Encoding]
    EMB --> MHA[Multi-Head Self-Attention]
    MHA --> ADD1[Add and Norm]
    ADD1 --> FFN[Feed-Forward Network]
    FFN --> ADD2[Add and Norm]
    ADD2 --> NEXT[Capa seguent o sortida]

    subgraph Bloc Transformer x N
        MHA
        ADD1
        FFN
        ADD2
    end

Feed-Forward Network Després de l'atenció, cada token passa per una xarxa neuronal densa (idèntica per a cada posició però independent). Aplica transformacions no lineals que permeten al model "processar" la informació capturada per l'atenció.

Encoder vs. Decoder

Arquitectura	Exemples	Ús principal
Encoder only	BERT, RoBERTa	Classificació, NER, similitud semàntica
Decoder only	GPT, LLaMA, Claude	Generació de text, Q&A, chatbots
Encoder-Decoder	T5, BART, mT5	Traducció, resum, generació condicionada

2.3. Com funciona la generació de text (autoregressive decoding)

Els models de la família GPT/LLaMA/Claude funcionen com a models autoregressius: generen el text token a token, condicionant cada token als anteriors.

Prompt: "La capital de Catalunya és"

Pas 1: El model calcula la probabilitat de cada token possible com a continuació
        - "Barcelona" → 95%
        - "Girona" → 2%
        - "Madrid" → 1%
        - ... (tot el vocabulari)

Pas 2: Es selecciona "Barcelona" (amb temperature=0) o amb mostreig (temperature>0)

Pas 3: El model calcula la probabilitat de cada token possible com a continuació de
        "La capital de Catalunya és Barcelona"
        - "." → 40%
        - "," → 30%
        - " i" → 15%
        - ...

Pas 4: Es continua fins a generar un token de fi (<|endoftext|>) o arribar al límit

Temperatura: controla l'aleatorietat. Temperature=0 és determinista (sempre el token més probable). Temperature=1 mostreix de la distribució tal com és. Temperature>1 fa el model més creatiu i imprevisible.

3. Tasques NLP i models actuals

3.1. Classificació de text

Assignar una etiqueta a un fragment de text: anàlisi de sentiment, detecció de spam, categorització de tickets de suport, detecció de toxicitat.

# Pipeline de classificació de sentiment amb Hugging Face
from transformers import pipeline

# Descarrega automàticament el model si no el tens (primera vegada triga una mica)
# Usem un model multilingüe que suporta català
sentiment = pipeline(
    "sentiment-analysis",
    model="nlptown/bert-base-multilingual-uncased-sentiment"
)

# Proves en català
resultats = sentiment([
    "Aquest producte és fantàstic, el recomano a tothom!",
    "Pèssima experiència, mai més tornaré a comprar aquí.",
    "El servei és acceptable però podria millorar.",
    "No m'ha deceput gens, molt satisfet amb la compra."
])

for text, resultat in zip(
    ["Fantàstic", "Pèssim", "Acceptable", "Satisfet"],
    resultats
):
    print(f"{text}: {resultat['label']} (confiança: {resultat['score']:.2%})")

3.2. Reconeixement d'Entitats Nombrades (NER)

Identificar i classificar entitats en el text: persones (PER), organitzacions (ORG), llocs (LOC), dates (DATE), quantitats monetàries (MONEY), etc.

Aplicació empresarial: extreure automàticament noms de clients, empreses, adreces i dates d'emails o contractes.

from transformers import pipeline

ner = pipeline("ner", model="dslim/bert-base-NER", aggregation_strategy="simple")

text = """
El conseller delegat d'Apple, Tim Cook, va visitar Barcelona el març de 2024
per reunir-se amb el CEO de Seat, Wayne Griffiths, i representants
del Parc Tecnològic del Vallès. L'acord valorat en 500 milions d'euros
inclou la instal·lació d'un centre de dades a Catalunya.
"""

entitats = ner(text)
for e in entitats:
    print(f"{e['word']:25} → {e['entity_group']:6} (confiança: {e['score']:.2%})")

3.3. Traducció automàtica neuronal

La traducció automàtica neuronal (NMT) usa models encoder-decoder per traduir entre idiomes. Models com NLLB-200 (Meta, 2022) suporten 200 idiomes, incloent el català.

Helsinki-NLP a Hugging Face proporciona models específics per a parells d'idiomes.

3.4. Generació de text i Q&A

La generació de text (completions, Q&A, resum, etc.) és el cas d'ús estrella dels LLMs moderns. En un entorn empresarial, es poden usar via:

API d'OpenAI (GPT-4o): per a prototypes i producció quan es tolera el cost i la dependència
API d'Anthropic (Claude 3.5): similar, amb especial focus en documents llargs i seguretat
Models locals (Ollama + LLaMA 3.1): per a entorns on la privadesa és crítica

# Exemple amb OpenAI API (GPT-4o)
from openai import OpenAI

client = OpenAI(api_key="la-teva-clau-api")

resposta = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": (
                "Ets un assistent especialista en tecnologia que respon "
                "sempre en català i de forma concisa i precisa."
            )
        },
        {
            "role": "user",
            "content": "Explica en 3 punts les diferències principals entre BERT i GPT."
        }
    ],
    max_tokens=400,
    temperature=0.3  # Baixa temperatura per respostes més precises i consistents
)

print(resposta.choices[0].message.content)

3.5. Resum automàtic (Summarization)

Generar un resum d'un document llarg. Dos tipus: - Extractiu: selecciona les frases més representatives del document original - Abstractiu: genera un resum nou que pot contenir frases que no apareixen al document original

Els LLMs moderns fan resum abstractiu de qualitat molt alta. Models com BART o T5 s'usen quan es vol un model lleuger i especialitzat.

4. Tokenització i embeddings en detall

4.1. Tokenitzadors BPE

El Byte Pair Encoding (BPE) és l'algorisme de tokenització més usat en LLMs moderns. Funciona:

Comença amb el vocabulari de caràcters individuals
Calcula la freqüència de tots els parells de tokens adjacents
Fusiona el parell més freqüent en un nou token
Repeteix N vegades fins arribar a la mida del vocabulari desitjada

GPT-4 usa cl100k_base: vocabulari de 100.000 tokens. En anglès, un token correspon aproximadament a 0,75 paraules. En català, la relació és similar.

Implicació pràctica del cost: Les APIs d'OpenAI i Anthropic cobren per token. Saber estimar el nombre de tokens d'un text és crucial per controlar els costos.

import tiktoken

# Comptador de tokens per GPT-4
enc = tiktoken.get_encoding("cl100k_base")

text_catala = """
La intel·ligència artificial és una disciplina de la informàtica
que busca crear sistemes capaços de realitzar tasques que normalment
requeririen intel·ligència humana.
"""

tokens = enc.encode(text_catala)
print(f"Text: {len(text_catala)} caràcters")
print(f"Tokens: {len(tokens)}")
print(f"Tokens decodificats: {[enc.decode([t]) for t in tokens[:20]]}")

# Cost estimat (juny 2025: GPT-4o input = $0.005 per 1K tokens)
cost_per_1k = 0.005
cost = (len(tokens) / 1000) * cost_per_1k
print(f"Cost estimat: ${cost:.6f}")

4.2. Vector stores i cerca semàntica

Un vector store (o base de dades vectorial) emmagatzema embeddings de documents i permet cercar de forma eficient per similitud semàntica (cerca del veí més proper).

Bases de dades vectorials populars el 2025: - Chroma: local, senzill, ideal per a prototips - Pinecone: cloud, gestionat, molt escalable - Weaviate: obert, suporta vector + text search - Qdrant: alta rendiment, Rust, self-hosted - pgvector: extensió de PostgreSQL per a vectors

# Exemple amb ChromaDB i embeddings locals
# pip install chromadb sentence-transformers

import chromadb
from sentence_transformers import SentenceTransformer

# Model d'embeddings multilingüe (suporta català)
model = SentenceTransformer('paraphrase-multilingual-mpnet-base-v2')

# Crear client ChromaDB en memòria
client = chromadb.Client()
col = client.create_collection("documents_empresa")

# Documents d'exemple
documents = [
    "La política de vacances és de 23 dies laborables l'any.",
    "El teletreball és possible fins a 3 dies per setmana.",
    "El servei mèdic de l'empresa atén els dimecres de 9 a 14h.",
    "La cantina ofereix menú diari per 5,50 euros.",
    "Les formacions internes es realitzen els divendres a la tarda."
]

# Generar embeddings i afegir a la col·lecció
embeddings = model.encode(documents).tolist()
col.add(
    documents=documents,
    embeddings=embeddings,
    ids=[f"doc_{i}" for i in range(len(documents))]
)

# Cerca semàntica
consulta = "Quants dies de vacances tinc?"
emb_consulta = model.encode([consulta]).tolist()
resultats = col.query(query_embeddings=emb_consulta, n_results=2)

print(f"Consulta: {consulta}")
for doc, dist in zip(resultats['documents'][0], resultats['distances'][0]):
    print(f"Similitud: {1-dist:.2%} | Document: {doc}")

5. RAG — Retrieval-Augmented Generation

5.1. Per quin motiu es necessita RAG?

Els LLMs tenen dues limitacions fonamentals per a molts casos d'ús empresarials:

Coneixement congelat: El model sap el que ha vist durant l'entrenament (fins a la seva data de tall). No coneix les últimes notícies, els teus documents interns, els canvis de preus d'avui.
Al·lucinació: El model pot generar informació plausible però falsa, especialment sobre dades específiques, numèriques o molt especialitzades.

La solució: RAG (Retrieval-Augmented Generation) combina la capacitat de recuperació precisa d'informació (de documents reals) amb la capacitat de generar text fluid dels LLMs.

5.2. Arquitectura RAG

graph TD
    USER[Usuari: pregunta] --> RET[Motor de Recuperacio]
    RET --> VS[(Vector Store\ndocuments empresa)]
    VS --> DOCS[Documents rellevants recuperats]
    DOCS --> CONTEXT[Context augmentat\npregunta + documents]
    CONTEXT --> LLM[LLM GPT-4o Claude Gemini]
    LLM --> ANS[Resposta fonamentada\namb citacions]
    ANS --> USER

Fase 1 — Indexació (offline): 1. Dividir els documents en fragments (chunks) de 200-500 tokens amb solapament 2. Generar un embedding per a cada chunk 3. Emmagatzemar els chunks i els seus embeddings en un vector store

Fase 2 — Recuperació i generació (online): 1. Rebre la consulta de l'usuari 2. Generar l'embedding de la consulta 3. Cercar els k chunks més similars al vector store (k=3-5 típicament) 4. Construir un prompt que inclou la consulta + els documents recuperats 5. Enviar el prompt al LLM 6. El LLM genera una resposta fonamentada en els documents, cita les fonts

5.3. Exemple de RAG simplificat

# pip install langchain langchain-openai chromadb sentence-transformers
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

# 1. Carreguem els documents
documents_text = """
MANUAL DE RECURSOS HUMANS — Institut Sa Palomera

Article 15 — Vacances
Els treballadors tenen dret a 23 dies laborables de vacances anuals.
Les vacances han de sol·licitar-se amb un mínim de 15 dies d'antelació.

Article 16 — Teletreball
S'autoritzen fins a 3 dies de teletreball setmanal per a llocs administratius.
Els docents no poden fer teletreball durant les hores de classe.

Article 20 — Formació contínua
L'empresa cofinança fins al 80% del cost de formacions relacionades amb el lloc
de treball, amb un màxim de 1.500 euros per persona i any.
"""

# 2. Dividim el text en fragments (chunks)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=300,
    chunk_overlap=50,
    separators=["\n\n", "\n", ". ", " "]
)
chunks = splitter.create_documents([documents_text])
print(f"Documents dividits en {len(chunks)} fragments")

# 3. Generem embeddings i creem el vector store
embeddings = HuggingFaceEmbeddings(
    model_name="paraphrase-multilingual-mpnet-base-v2"
)
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. Creem la cadena RAG
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 5. Fem una pregunta
pregunta = "Quants dies de teletreball puc fer a la setmana?"
resultat = qa_chain.invoke({"query": pregunta})

print(f"\nPregunta: {pregunta}")
print(f"Resposta: {resultat['result']}")

Miniactivitat CA3.7 — Sistema RAG bàsic

Implementa un sistema RAG mínim sobre un document de la teva elecció (pot ser el manual de convivència de l'escola, un article de Wikipedia, les instruccions d'un producte, etc.). Ha de poder respondre 5 preguntes sobre el document. Documenta el resultat indicant: quines preguntes ha respost bé, quines ha fallat i per quin motiu creus que ha fallat.

6. Models actuals: GPT-4o, Claude 3.5, Gemini, LLaMA

6.1. Comparativa de models el 2025

Model	Empresa	Paràmetres	Context	Open Source	Punt fort
GPT-4o	OpenAI	~200B (estim.)	128K tokens	No	Equilibri general, multimodal
GPT-4o mini	OpenAI	~8B (estim.)	128K tokens	No	Cost-efectivitat
o3	OpenAI	Desconegut	200K tokens	No	Raonament matemàtic
Claude 3.5 Sonnet	Anthropic	Desconegut	200K tokens	No	Documents llargs, codi
Claude 3.5 Haiku	Anthropic	Desconegut	200K tokens	No	Velocitat, cost
Gemini 1.5 Pro	Google	~500B (estim.)	1M tokens	No	Context ultra-llarg, multimodal
Gemini 1.5 Flash	Google	~70B (estim.)	1M tokens	No	Velocitat, cost
LLaMA 3.1 405B	Meta	405B	128K tokens	Sí	Open source, privadesa
LLaMA 3.1 70B	Meta	70B	128K tokens	Sí	Rendiment/cost local
Mistral Large 2	Mistral	~70B (estim.)	128K tokens	Parcialment	Multilingüe, europeu
Phi-3 Medium	Microsoft	14B	128K tokens	Sí	Model petit d'alta qualitat
Gemma 2 27B	Google	27B	8K tokens	Sí	Accés obert de qualitat

6.2. Executar LLMs localment amb Ollama

Ollama és la forma més senzilla de córrer models oberts localment (privadesa total, sense cost d'API):

# Instal·lar Ollama (Linux/macOS)
curl -fsSL https://ollama.ai/install.sh | sh

# Descarregar i córrer LLaMA 3.1 (8B, ~5GB)
ollama pull llama3.1:8b
ollama run llama3.1:8b

# O directament amb Docker
docker run -d --name ollama \
  -p 11434:11434 \
  -v ollama:/root/.ollama \
  ollama/ollama

# Descarregar el model dins del contenidor
docker exec -it ollama ollama pull llama3.1:8b

# Provar via API REST
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Explica en català que és la intel·ligència artificial",
  "stream": false
}'

7. Limitacions del PLN

7.1. Al·lucinació

L'al·lucinació és el fenomen pel qual un LLM genera text que és plausible, fluid i confident però factual ment incorrecte. El model no "sap" quan no sap: genera la resposta que estadísticament és la continuació més probable del prompt, independentment de la seva veracitat.

Exemples coneguts: - Inventar referències bibliogràfiques que semblen reals però no existeixen (títol plausible, autors plausibles, revista plausible, any plausible, DOI inventat) - Atribuir cites a persones que mai les van fer - Donar dades numèriques específiques i incorrectes amb gran seguretat

Tècniques per mitigar l'al·lucinació: - RAG (fonamentar les respostes en documents verificats) - Temperature baixa (respostes menys creatives però més conservadores) - Prompts que demanen explícitament "si no saps la resposta, digues-ho" - Chain-of-Thought prompting: demanar al model que "pensi en veu alta" - Verificació cruzada entre models

7.2. Biaixos algorítmics

Els LLMs aprenen de corpus de text generats per humans, i per tant hereten tots els biaixos humans presents en aquell text: biaixos de gènere, racials, culturals, polítics.

Exemples documentats: - Associació "home" amb professions STEM i "dona" amb professions de cura - Representació desproporcionada de la perspectiva anglosaxona en temes culturals - Millor rendiment en anglès que en altres idiomes - Biaixos polítics derivats del desequilibri ideològic del corpus d'entrenament

7.3. Context window i limitacions de memòria

Tots els LLMs tenen un límit de tokens que poden processar simultàniament (context window). Quan la conversa supera aquest límit, el model "oblida" la part més antiga.

GPT-4o: 128K tokens (~96.000 paraules)
Gemini 1.5 Pro: 1M tokens (~750.000 paraules, equivalent a 5 novel·les llargues)
LLaMA 3.1: 128K tokens

Però atenció: una context window gran no implica que el model usi tota la informació de forma igual de bé. Estudis mostren que els LLMs tendeixen a pesar més la informació al principi i al final del context ("lost in the middle").

7.4. Cost computacional i sostenibilitat

Entrenar un LLM gran té un cost mediambiental significatiu: - GPT-3 (entrenament): s'estima en 552 tones de CO₂ equivalent (Strubell et al., 2019), equivalent a ~300 vols transatlàntics - GPT-4 (entrenament): estimat en l'ordre de magnitud de 10-100x GPT-3 - Inferència: cada consulta a GPT-4o consumeix ~10x l'energia d'una cerca web a Google

Iniciatives per reduir l'impacte: - Models més petits i destil·lats (DistilBERT, Phi-3, Gemma 2) - Quantització (reduir de 32 bits a 4-8 bits sense perdre gaire qualitat) - Hardware especialitzat (TPUs, chips d'IA de baixa potència) - Servidors alimentats amb energies renovables

7.5. El rol del lingüista en IA

Un dels errors comuns en projectes d'IA de PLN és subestimar la importància del lingüista en l'equip. El lingüista aporta:

Anotació de dades: Les dades d'entrenament supervisat (p. ex. per a NER o classificació) han de ser anotades per humans. El lingüista dissenya les guies d'anotació, forma als anotadors i controla la qualitat (inter-annotator agreement).

Avaluació de qualitat: Mètriques automàtiques com BLEU (traducció) o F1 (classificació) no capturen tots els matisos de qualitat lingüística. El lingüista avalua la fluïdesa, la coherència i la naturalitat de les sortides del model.

Prompt engineering: Saber formular les instruccions als LLMs és una habilitat lingüística. La manera de frasejar un prompt pot canviar dràsticament la qualitat de la resposta.

Detecció de biaixos lingüístics: El lingüista identifica biaixos de gènere en el lèxic, problemes de representació de dialectes o varietats lingüístiques, etc.

Tractament de varietats lingüístiques: Gestionar dialectes, registres (formal/informal), argot especialitzat, multilingüisme.

Miniactivitat CA3.5 — Treball cooperatiu lingüista-informàtic

En parelles (un membre fa de lingüista, l'altre d'informàtic), feu el següent:

El lingüista: escriu 20 frases en català d'anàlisi de sentiment (10 positives, 10 negatives), que incloguin expressions col·loquials, sarcasme i idomes.

L'informàtic: passa les 20 frases per un model de sentiment de Hugging Face i recull els resultats.

Junts: analitzeu quines frases ha classificat malament el model i per quin motiu. Proposa com milloraria el lingüista les dades per corregir els errors del model.

8. Exercici pràctic del tema

AC5075 — Anàlisi de text amb Hugging Face

Desenvolupa un script Python complet que:

Descarregui i usi un model de Hugging Face per a dues tasques NLP de la teva elecció (entre: sentiment, NER, traducció, resum, Q&A)
Provi cada model amb 5 textos en català rellevants per a un context professional
Analitzi les limitacions observades (mínima 3 exemples on el model falla)
Calculi el temps d'inferència de cada model
Elabori un breu informe (300 paraules) comparant les dues tasques en termes de qualitat, velocitat i casos d'ús adequats

Format d'entrega: notebook Jupyter .ipynb + informe .pdf a l'aula virtual.

Nom del fitxer: ac5075_nlp_nom_cognom.ipynb

Models recomanats per al català

Sentiment: nlptown/bert-base-multilingual-uncased-sentiment (suporta català)
NER: PlanTL-GOB-ES/roberta-base-ca-cased-ner (específic per al català)
Traducció: Helsinki-NLP/opus-mt-ca-en (català a anglès)
Embeddings: paraphrase-multilingual-mpnet-base-v2 (multilingüe, inclou català)