Automatització Industrial i de Negoci amb IA

Introducció

L'automatització ha existit des de la Revolució Industrial. El que fa diferent l'automatització basada en IA es que, per primera vegada, podem automatitzar tasques que requereixen judici, comprensió del llenguatge i adaptació al context. Ja no estem automatitzant únicament línies de producció; estem automatitzant el treball del coneixement.

El 2025, la pregunta ja no es "pot l'IA automatitzar aquesta tasca?" sinó "hauria d'automatitzar-se, i com es fa de manera responsable?" Aquesta distinció es crítica per a professionals de l'IA.

1. Evolució de l'automatització

1.1 De l'automatització manual a l'IA nativa

L'automatització ha passat per quatre grans etapes:

flowchart LR
    Manual[Manual\n1900-1980] --> RPA[RPA\n2005-2018]
    RPA --> IPA[IPA\n2018-2022]
    IPA --> AINative[AI-Native\n2023-actualitat]

Automatització manual (1900-1980): maquines mecàniques i electromecàniques. Línies de producció de Ford (1913), controladors lògics programables (PLC, 1968). Alta eficiència en tasques repetitives físiques, zero flexibilitat.

RPA - Robotic Process Automation (2005-2018): bots de programari que imiten les accions d'un humà a la interfície d'usuari. Clicar botons, copiar dades entre sistemes, omplir formularis. Empreses com UiPath (fundada 2005) i Automation Anywhere demostren que es pot automatitzar el treball d'oficina sense canviar els sistemes existents.

IPA - Intelligent Process Automation (2018-2022): combinació de RPA amb IA (OCR, NLP, ML). Ja no es seguir regles fixes; el sistema pot "entendre" documents, classificar emails amb context, prendre decisions simples.

AI-Native Automation (2023-actualitat): LLMs i agents autònoms que planifiquen, executen i adapten workflows complets sense regles explícites. L'humà defineix l'objectiu, l'agent determina com aconseguir-lo.

2. RPA: Robotic Process Automation

2.1 Plataformes principals

UiPath es la plataforma RPA líder de mercat (quota ~30% el 2025). Ofereix un IDE visual (UiPath Studio) on els processos es construeixen arrossegant blocs:

Fluxe tipic UiPath:
1. Obrir navegador -> Navegar a portal ERP
2. Extreure llista de factures pendents (scraping)
3. Per a cada factura:
   a. Descarregar PDF
   b. Extreure camps (OCR)
   c. Introduir dades a sistema comptable
   d. Marcar com a processada
4. Enviar resum per email

En codi VB.NET (el llenguatge de UiPath):

' Exemple activitat UiPath - Processar factura
Dim nomFitxer As String = ""
Dim importTotal As Double = 0

' Llegir camps de la factura amb OCR
nomFitxer = DocumentUnderstanding.ExtractField("NomProveïdor")
importTotal = CDbl(DocumentUnderstanding.ExtractField("ImportTotal"))

' Introduir al sistema ERP via UI automation
UiPath.Core.Activities.TypeInto(
    selector := "<wnd app='sap.exe' title='Introduir Factura'/>",
    text := nomFitxer
)

Automation Anywhere se centra en el mercat enterprise. La seva plataforma Cloud-native (A360) permet desplegament en SaaS. Punt fort: bot analytics i auditoria de processos.

Microsoft Power Automate es la opció integrada a l'ecosistema Microsoft 365. Fortament integrada amb SharePoint, Teams, Outlook i Dynamics 365. Ideal per a empreses ja al stack Microsoft.

Blue Prism es la plataforma més orientada a IT i governança. Cada bot es un "treballador digital" amb identitat, credencials i auditoria completa.

2.2 Casos d'ús clàssics

Departament	Procés automatitzat	Estalvi típic
Comptabilitat	Reconciliació bancària	80% del temps manual
RRHH	Onboarding d'empleats (crear comptes, assignar equipament)	70% del temps
Compres	Processament de comandes de proveïdors	60% del temps
Atenció al client	Actualització d'estat de comandes	85% del temps
Legal	Extracció de clàusules de contractes	50% del temps

2.3 Limitacions del RPA clàssic

El RPA te limitacions fonamentals que moltes empreses han après a les males:

No aprèn: si canvia l'interfície del sistema (un botó es mou, un formulari canvia), el bot falla. Requereix manteniment constant.
Regles fixes: no pot gestionar excepcions no previstes. Un cas inusual para el procés.
Fràgil als canvis: actualitzacions del sistema ERP, canvis de navegador, proves A/B al web: tot trenca el bot.
Escalabilitat limitada: per a processar el doble de volum, necessites el doble de llicències de bot.
Sense comprensió: el bot veu píxels i coordenades, no "entén" el que fa.

El bot cemetery

Es calcula que entre el 30% i el 50% dels projectes RPA fracassen o no arriben a producció. Les causes principals: processos mal documentats, canvis freqüents als sistemes, subestimació del manteniment, i automatitzar processos que haurien de redissenyar-se primer.

3. IPA: Intelligent Process Automation

3.1 RPA + IA: el salt qualitatiu

L'IPA afegeix capacitats d'IA al RPA per a superar-ne les limitacions:

IPA = RPA (automatitzacio interficies)
    + OCR/ICR (reconeixement optic documents)
    + NLP (comprensio llenguatge natural)
    + ML (decisions basades en dades)
    + Process Mining (descobriment de processos)

3.2 Comprensió de documents (OCR + NLP)

AWS Textract

import boto3

textract = boto3.client("textract", region_name="eu-west-1")

# Analitzar factura en PDF
with open("factura.pdf", "rb") as f:
    document_bytes = f.read()

response = textract.analyze_document(
    Document={"Bytes": document_bytes},
    FeatureTypes=["FORMS", "TABLES"]
)

# Extreure camps clau (key-value pairs)
for block in response["Blocks"]:
    if block["BlockType"] == "KEY_VALUE_SET":
        if "KEY" in block["EntityTypes"]:
            key_text = extreure_text_bloc(block, response["Blocks"])
            value_text = extreure_valor(block, response["Blocks"])
            print(f"{key_text}: {value_text}")

# Output exemple:
# Número factura: FAC-2025-00123
# Data: 15/03/2025
# Proveïdor: TechSupplies SL
# Import total: 4.850,00 EUR
# IVA: 21%

Google Document AI

Google Document AI ofereix processadors especialitzats per tipus de document:

from google.cloud import documentai

client = documentai.DocumentProcessorServiceClient()
name = f"projects/{PROJECT_ID}/locations/eu/processors/{PROCESSOR_ID}"

with open("contracte.pdf", "rb") as f:
    raw_document = documentai.RawDocument(
        content=f.read(),
        mime_type="application/pdf"
    )

request = documentai.ProcessRequest(name=name, raw_document=raw_document)
result = client.process_document(request=request)

# Accedir a entitats extretes (processor especialitzat en contractes)
for entity in result.document.entities:
    print(f"Entitat: {entity.type_} | Valor: {entity.mention_text} | Confiança: {entity.confidence:.2%}")

# Output:
# Entitat: contract_date | Valor: 1 de gener de 2025 | Confiança: 98.50%
# Entitat: party_1_name | Valor: Acme Corporation SL | Confiança: 97.20%
# Entitat: contract_value | Valor: 120.000 EUR | Confiança: 99.10%

Azure Form Recognizer (Document Intelligence)

from azure.ai.formrecognizer import DocumentAnalysisClient
from azure.core.credentials import AzureKeyCredential

client = DocumentAnalysisClient(
    endpoint=AZURE_ENDPOINT,
    credential=AzureKeyCredential(AZURE_KEY)
)

with open("factura.pdf", "rb") as f:
    poller = client.begin_analyze_document("prebuilt-invoice", f)

result = poller.result()

for factura in result.documents:
    vendor = factura.fields.get("VendorName")
    total = factura.fields.get("InvoiceTotal")
    date = factura.fields.get("InvoiceDate")

    print(f"Proveïdor: {vendor.value if vendor else 'N/D'}")
    print(f"Total: {total.value if total else 'N/D'}")
    print(f"Data: {date.value if date else 'N/D'}")

3.3 Classificació automàtica de correus electrònics

Un cas d'us real i molt freqüent: una empresa rep 5.000 emails diaris al seu servei d'atenció al client. Classificar-los manualment consumeix 8 FTEs. Amb IPA:

from transformers import pipeline
import anthropic

# Model de classificació multilingüe (inclou català)
classificador = pipeline(
    "text-classification",
    model="joeddav/xlm-roberta-large-xnli",
    device=0  # GPU
)

CATEGORIES = [
    "consulta_producte",
    "queixa_servei",
    "devolucion",
    "factura",
    "urgencia",
    "spam"
]

def classificar_email(assumpte: str, cos: str) -> dict:
    text = f"Assumpte: {assumpte}\n\n{cos[:500]}"

    resultats = classificador(
        text,
        candidate_labels=CATEGORIES,
        hypothesis_template="Aquest email tracta sobre {}"
    )

    categoria = resultats["labels"][0]
    confianca = resultats["scores"][0]

    # Si confiança < 80%, escalona a humà
    if confianca < 0.80:
        return {"categoria": "revisio_humana", "confianca": confianca}

    return {
        "categoria": categoria,
        "confianca": confianca,
        "prioritat": calcular_prioritat(categoria, cos)
    }

def calcular_prioritat(categoria: str, text: str) -> str:
    paraules_urgencia = ["urgent", "crític", "no funciona", "pèrdua", "blocat"]
    if any(p in text.lower() for p in paraules_urgencia):
        return "ALTA"
    if categoria == "queixa_servei":
        return "MITJA"
    return "NORMAL"

4. AI-Powered Automation amb LLMs

4.1 GPT-4 Function Calling i Claude Tool Use

Els LLMs moderns tenen la capacitat de cridar funcions externes quan necessiten informació o han d'executar accions. Això transforma el LLM d'un generador de text en un orquestrador d'accions.

OpenAI Function Calling

from openai import OpenAI
import json

client = OpenAI()

# Definir funcions disponibles (eines)
tools = [
    {
        "type": "function",
        "function": {
            "name": "consultar_estoc",
            "description": "Consulta l'estoc disponible d'un producte",
            "parameters": {
                "type": "object",
                "properties": {
                    "codi_producte": {
                        "type": "string",
                        "description": "Codi SKU del producte"
                    },
                    "magatzem": {
                        "type": "string",
                        "enum": ["barcelona", "madrid", "valencia"],
                        "description": "Magatzem a consultar"
                    }
                },
                "required": ["codi_producte"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "crear_comanda",
            "description": "Crea una comanda de compra al proveïdor",
            "parameters": {
                "type": "object",
                "properties": {
                    "codi_producte": {"type": "string"},
                    "quantitat": {"type": "integer"},
                    "proveidor": {"type": "string"}
                },
                "required": ["codi_producte", "quantitat", "proveidor"]
            }
        }
    }
]

def executar_eina(nom_eina: str, arguments: dict) -> str:
    if nom_eina == "consultar_estoc":
        # Aquí cridaríem el sistema ERP real
        estoc = erp_client.get_stock(
            arguments["codi_producte"],
            arguments.get("magatzem", "barcelona")
        )
        return json.dumps({"estoc": estoc, "unitat": "unitats"})
    elif nom_eina == "crear_comanda":
        comanda_id = erp_client.create_order(**arguments)
        return json.dumps({"comanda_id": comanda_id, "estat": "creada"})

# Bucle agent: el LLM decideix quines eines usar
missatges = [
    {"role": "user",
     "content": "Necessito reposar el producte SKU-2024-PANTALLA. Comprova el stock a Barcelona i si hi ha menys de 10 unitats, crea una comanda de 50 unitats al proveïdor TechSupply."}
]

while True:
    resposta = client.chat.completions.create(
        model="gpt-4o",
        messages=missatges,
        tools=tools,
        tool_choice="auto"
    )

    missatge = resposta.choices[0].message

    if missatge.tool_calls:
        missatges.append(missatge)
        for crida in missatge.tool_calls:
            resultat = executar_eina(
                crida.function.name,
                json.loads(crida.function.arguments)
            )
            missatges.append({
                "role": "tool",
                "tool_call_id": crida.id,
                "content": resultat
            })
    else:
        print(missatge.content)
        break

4.2 Agents autònoms: CrewAI i LangGraph

CrewAI permet definir equips d'agents amb rols específics que col·laboren per a completar tasques complexes:

from crewai import Agent, Task, Crew, Process

# Definir agents amb rols especialitzats
agent_analista = Agent(
    role="Analista de Negoci",
    goal="Analitzar dades de vendes i identificar tendències",
    backstory="""Ets un analista expert amb 10 anys d'experiència en retail.
    Ets meticulós amb les dades i sempre bases les teves conclusions en evidència.""",
    verbose=True,
    allow_delegation=False,
    llm="gpt-4o"
)

agent_redactor = Agent(
    role="Redactor d'Informes",
    goal="Redactar informes clars i accionables en català",
    backstory="Especialista en comunicació empresarial, converteix anàlisis complexes en informes entenedors.",
    verbose=True,
    allow_delegation=False,
    llm="gpt-4o"
)

# Definir tasques
tasca_analisi = Task(
    description="""Analitza les dades de vendes del Q1 2025 i identifica:
    1. Top 5 productes per ingressos
    2. Categories amb creixement > 20%
    3. Zones geogràfiques amb baixada de vendes
    Dades: {dades_vendes}""",
    agent=agent_analista,
    expected_output="Llista estructurada amb les 3 anàlisis demanades"
)

tasca_informe = Task(
    description="Redacta un informe executiu de 500 paraules en català basat en l'anàlisi anterior.",
    agent=agent_redactor,
    expected_output="Informe en català, format Markdown, amb recomanacions accionables"
)

# Assemblar l'equip i executar
crew = Crew(
    agents=[agent_analista, agent_redactor],
    tasks=[tasca_analisi, tasca_informe],
    process=Process.sequential,
    verbose=True
)

resultat = crew.kickoff(inputs={"dades_vendes": dades_csv})
print(resultat.raw)

LangGraph es la solució de LangChain per a workflows d'agents amb estat i cicles:

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, List
import operator

class EstatAgent(TypedDict):
    missatges: Annotated[List[str], operator.add]
    documents: List[str]
    resposta_final: str
    iteracions: int

def node_cerca(estat: EstatAgent) -> EstatAgent:
    """Cerca informació rellevant."""
    query = estat["missatges"][-1]
    documents = retriever.invoke(query)
    return {"documents": documents}

def node_generacio(estat: EstatAgent) -> EstatAgent:
    """Genera resposta basada en documents."""
    resposta = llm.invoke(
        f"Contexte: {estat['documents']}\n\nPregunta: {estat['missatges'][-1]}"
    )
    return {
        "resposta_final": resposta.content,
        "iteracions": estat.get("iteracions", 0) + 1
    }

def condicio_revisar(estat: EstatAgent) -> str:
    """Decideix si la resposta es prou bona o cal cercar més."""
    if estat["iteracions"] >= 3:
        return "finalitzar"
    # Avaluador simple: si la resposta es curta, cercar més
    if len(estat["resposta_final"]) < 100:
        return "cercar_mes"
    return "finalitzar"

# Construir el graf
graf = StateGraph(EstatAgent)
graf.add_node("cerca", node_cerca)
graf.add_node("generacio", node_generacio)

graf.set_entry_point("cerca")
graf.add_edge("cerca", "generacio")
graf.add_conditional_edges(
    "generacio",
    condicio_revisar,
    {
        "cercar_mes": "cerca",
        "finalitzar": END
    }
)

agent = graf.compile()

4.3 Microsoft AutoGen

AutoGen (Microsoft Research) permet converses multi-agent on els agents es consulten entre ells per a resoldre problemes complexos:

import autogen

# Configuració LLM
config_llm = {
    "model": "gpt-4o",
    "api_key": OPENAI_API_KEY
}

# Agent assistent (pot escriure i executar codi)
assistent = autogen.AssistantAgent(
    name="Assistent_IA",
    system_message="""Ets un expert en anàlisi de dades.
    Escriu codi Python per a resoldre les tasques.
    Explica sempre el que fas en català.""",
    llm_config={"config_list": [config_llm]}
)

# Agent crític (revisa la feina de l'assistent)
critic = autogen.AssistantAgent(
    name="Critic_Qualitat",
    system_message="""Revises la feina de l'Assistent_IA.
    Comproves que el codi sigui correcte, eficient i llegible.
    Si hi ha errors o millores, les indiques clarament.""",
    llm_config={"config_list": [config_llm]}
)

# Agent humà (proxy per a l'usuari)
usuari = autogen.UserProxyAgent(
    name="Usuari",
    human_input_mode="TERMINATE",  # Demana input humà per a finalitzar
    max_consecutive_auto_reply=10,
    code_execution_config={"work_dir": "autogen_workspace"}
)

# Iniciar conversa de 3 agents
usuari.initiate_chat(
    assistent,
    message="""Analitza el fitxer vendes_2025.csv:
    1. Calcula les vendes totals per categoria
    2. Identifica el top 3 productes
    3. Genera un gràfic de barres
    Assegura't que el codi funciona i que el Critic l'aprova."""
)

4.4 n8n: workflow automation open source

n8n (llegit "n-eight-n") es una plataforma de workflow automation open source que permet integrar serveis i afegir nodes d'IA. Es l'alternativa open source a Zapier i Make.

# Arrancar n8n amb Docker
docker run -d \
  --name n8n-automatitzacio \
  -p 5678:5678 \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD=password123 \
  -v n8n_data:/home/node/.n8n \
  n8nio/n8n:latest

# Accés: http://localhost:5678

Exemple de workflow n8n per a classificació d'emails (configuració JSON):

{
  "nodes": [
    {
      "name": "Gmail Trigger",
      "type": "n8n-nodes-base.gmailTrigger",
      "parameters": {
        "pollTimes": {"item": [{"mode": "everyMinute"}]},
        "filters": {"labelIds": ["INBOX"]}
      }
    },
    {
      "name": "OpenAI Classificar",
      "type": "@n8n/n8n-nodes-langchain.openAi",
      "parameters": {
        "model": "gpt-4o-mini",
        "prompt": "Classifica aquest email en una de les categories: [consulta, queixa, comanda, spam]. Respon ÚNICAMENT amb la categoria.\n\nAssumpte: {{$json.subject}}\nCos: {{$json.snippet}}"
      }
    },
    {
      "name": "Switch per Categoria",
      "type": "n8n-nodes-base.switch",
      "parameters": {
        "dataType": "string",
        "value1": "={{$json.message.content}}",
        "rules": {
          "rules": [
            {"value2": "queixa", "output": 0},
            {"value2": "comanda", "output": 1},
            {"value2": "consulta", "output": 2}
          ]
        }
      }
    }
  ]
}

5. Copilots Empresarials 2025

5.1 Microsoft 365 Copilot

Microsoft 365 Copilot integra GPT-4 directament a les aplicacions d'Office:

Word: redacta, resumeix i reformula documents basant-se en instruccions en llenguatge natural
Excel: genera fórmules complexes, analitza dades i crea gràfics des d'una descripció
PowerPoint: crea presentacions completes a partir d'un document Word o un breu resum
Teams: resumeix reunions, genera accions i respon preguntes sobre el que s'ha dit
Outlook: redacta respostes, resumeix fils llargs, prioritza emails

Impacte en productivitat (Microsoft Work Trend Index 2024): - 77% dels usuaris no vol perdre l'accés a Copilot - 70% es declara més productiu - Els usuaris recuperen 14 minuts per reunió en notes automàtiques - 29% d'increment de velocitat en tasques de redacció

Preu: $30 per usuari/mes (addicional a la llicència M365). Requereix M365 E3 o E5.

5.2 GitHub Copilot: impacte real en productivitat

GitHub Copilot (basat en Codex/GPT-4 Turbo) completa codi, genera tests, explica funcions i suggereix correccions. El 2024, GitHub reporta:

55% de velocitat en completar tasques de codi (GitHub study, 2024)
74% dels programadors diuen que estan més centrats en les tasques satisfactòries
Reducció del 46% en temps de debug per a errors comuns

Però l'estudi de GitClear (2024) aporta una perspectiva crítica: - Increment del 54% en el "churn code" (codi que es reescriu en 2 setmanes) - Reducció de la densitat de codi reutilitzable - Augment del codi duplicat

La conclusió: Copilot incrementa la velocitat de producció de codi, però requereix revisió humana per a mantenir la qualitat de l'arquitectura.

5.3 Salesforce Einstein i SAP Joule

Salesforce Einstein integra IA a tot el CRM: - Predicció de probabilitat de tancament d'oportunitats (win rate scoring) - Suggeriments d'acció next best action per a venedors - Generació automàtica d'emails de seguiment personalitzats - Anàlisi de sentiment de casos de suport

# Exemple d'us de l'API d'Einstein per a scoring
import requests

response = requests.post(
    "https://api.salesforce.com/einstein/platform/v2/predict",
    headers={"Authorization": f"Bearer {ACCESS_TOKEN}"},
    json={
        "modelId": "CommunitySentiment",
        "document": {
            "text": "El producte ha fallat tres vegades aquesta setmana. Estic molt decebut."
        }
    }
)

prediccio = response.json()
sentiment = prediccio["probabilities"][0]["label"]
confianca = prediccio["probabilities"][0]["probability"]
# Output: sentiment="negative", confianca=0.94

SAP Joule (llançat 2023) es el copilot d'IA de SAP per al seu ecosistema S/4HANA, SuccessFactors i Ariba. Permet consultes en llenguatge natural: "Mostra'm totes les comandes de proveïdors pendents per sobre de 50.000 EUR del darrer mes" genera automàticament la query SAP.

5.4 Mesura del ROI dels copilots

La mesura del ROI dels copilots requereix KPIs específics:

Mètrica	Com mesurar-la
Temps per tasca	A/B test: grup amb copilot vs sense
Qualitat de sortida	Avaluació humana cega dels outputs
Satisfacció usuari	NPS específic per a l'eina
Adopció	% d'usuaris actius / total llicències
Reducció de tiquet suport	Comparativa mes a mes

Càlcul ROI simplificat:

Cost mensual Copilot = llicències × $30 = 100 × $30 = $3.000/mes

Estalvi mensual:
- 100 usuaris × 14 min/dia × 22 dies × $0.50/min (cost laboral) = $15.400/mes

ROI mensual = ($15.400 - $3.000) / $3.000 = 413%
Payback period = <1 mes

Bones pràctiques d'adopció de copilots

No imposeu els copilots: formeu primer, deixeu explorar, compartiu casos d'us interns. Els early adopters entusiastes seran els millors advocates. Mesureu l'adopció setmanalment i identifiqueu els blockers (por, falta de formació, restriccions IT).

6. Automatització Industrial

6.1 Predictive Maintenance amb IoT + ML

El manteniment predictiu usa sensors IoT i models ML per a predir quan fallarà una màquina abans que falli, evitant aturades no planificades.

import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest, GradientBoostingClassifier
from sklearn.preprocessing import StandardScaler
import joblib

# 1. Ingesta de dades de sensors (temperatura, vibració, pressió, rpm)
def carregar_dades_sensors(equip_id: str, periode_dies: int = 30) -> pd.DataFrame:
    """Carrega dades de sensors de la base de dades InfluxDB."""
    from influxdb_client import InfluxDBClient

    client = InfluxDBClient(url=INFLUXDB_URL, token=TOKEN, org=ORG)
    query = f"""
    from(bucket: "sensors")
      |> range(start: -{periode_dies}d)
      |> filter(fn: (r) => r._measurement == "sensor_dades" and r.equip_id == "{equip_id}")
      |> pivot(rowKey:["_time"], columnKey:["_field"], valueColumn:"_value")
    """
    return client.query_api().query_data_frame(query)

# 2. Enginyeria de característiques
def crear_features(df: pd.DataFrame) -> pd.DataFrame:
    """Crea features estadístiques per finestra temporal."""
    finestres = [5, 15, 60]  # minuts

    for w in finestres:
        df[f"temp_mitja_{w}m"] = df["temperatura"].rolling(w).mean()
        df[f"temp_std_{w}m"] = df["temperatura"].rolling(w).std()
        df[f"vibracio_max_{w}m"] = df["vibracio"].rolling(w).max()
        df[f"rpm_cv_{w}m"] = df["rpm"].rolling(w).std() / df["rpm"].rolling(w).mean()

    df["hores_desde_manteniment"] = (df.index - df["data_manteniment"]).dt.total_seconds() / 3600
    df = df.dropna()
    return df

# 3. Detecció d'anomalies (unsupervised - no cal dades etiquetades)
detector_anomalies = IsolationForest(
    n_estimators=200,
    contamination=0.05,  # 5% de lectures son anomalies esperades
    random_state=42
)

# 4. Model de predicció de fallada (supervised - necessita historial de fallades)
model_fallada = GradientBoostingClassifier(
    n_estimators=300,
    max_depth=5,
    learning_rate=0.05
)

# 5. Pipeline d'inferència en temps real
def prediccio_temps_real(dades_sensor: dict, equip_id: str) -> dict:
    model = joblib.load(f"models/predictive_{equip_id}.pkl")
    scaler = joblib.load(f"models/scaler_{equip_id}.pkl")

    features = np.array([[
        dades_sensor["temperatura"],
        dades_sensor["vibracio"],
        dades_sensor["pressio"],
        dades_sensor["rpm"],
        dades_sensor["hores_operacio"]
    ]])

    features_norm = scaler.transform(features)
    probabilitat_fallada = model.predict_proba(features_norm)[0][1]

    if probabilitat_fallada > 0.85:
        nivell = "CRITICA"
        dies_estimats = 1
    elif probabilitat_fallada > 0.60:
        nivell = "ALTA"
        dies_estimats = 3
    elif probabilitat_fallada > 0.30:
        nivell = "MITJA"
        dies_estimats = 7
    else:
        nivell = "BAIXA"
        dies_estimats = 30

    return {
        "equip_id": equip_id,
        "probabilitat_fallada": float(probabilitat_fallada),
        "nivell_risc": nivell,
        "dies_estimats": dies_estimats,
        "accio_recomanada": f"Programar manteniment en {dies_estimats} dies"
    }

6.2 Quality Control amb Visió Artificial

import torch
import torchvision.transforms as transforms
from torchvision.models import efficientnet_b4
from PIL import Image
import time

# Carregar model de classificació de defectes (fine-tuned)
model_defectes = efficientnet_b4(weights=None)
model_defectes.classifier[1] = torch.nn.Linear(model_defectes.classifier[1].in_features, 5)
model_defectes.load_state_dict(torch.load("model_defectes_produccio.pth"))
model_defectes.eval()

CATEGORIES_DEFECTE = ["OK", "RASCADA", "DEFORMACIO", "IMPURESA", "COLOR_INCORRECTE"]

transform = transforms.Compose([
    transforms.Resize((380, 380)),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

def inspeccionar_peca(imatge_path: str) -> dict:
    t_inici = time.time()

    imatge = Image.open(imatge_path).convert("RGB")
    tensor = transform(imatge).unsqueeze(0)

    with torch.no_grad():
        sortida = model_defectes(tensor)
        probabilitats = torch.softmax(sortida, dim=1)[0]

    idx_classe = probabilitats.argmax().item()
    categoria = CATEGORIES_DEFECTE[idx_classe]
    confianca = probabilitats[idx_classe].item()

    latencia_ms = (time.time() - t_inici) * 1000

    return {
        "categoria": categoria,
        "es_defectuosa": categoria != "OK",
        "confianca": confianca,
        "latencia_ms": latencia_ms,
        "accio": "REBUTJAR" if categoria != "OK" else "CONTINUAR"
    }

6.3 AGVs (Autonomous Guided Vehicles)

Amazon Robotics (ex-Kiva Systems) opera 750.000+ robots AGV als seus centres logístics. El 2025:

Els AGVs porten les prestatgeries fins als treballadors (no al revés)
IA coordina el moviment de milers de robots simultàniament (pathfinding multi-agent)
Computer Vision permet evitar col·lisions en temps real
Predictive maintenance prediu quan un AGV necessita bateria o manteniment

BMW Group ha desplegat AGVs de nova generació que: - Naveguen sense marques al terra (vision-only navigation) - S'adapten dinàmicament a canvis en la planta - Aprenen rutes noves en minuts (few-shot learning)

7. Nous Models de Negoci

7.1 De SaaS a AaaS (AI as a Service)

L'evolució dels models de negoci tecnològics:

Model	Descripció	Exemple 2025
SaaS	Programari com a servei	Salesforce, Slack
PaaS	Plataforma com a servei	Heroku, Vercel
MLaaS	ML com a servei	AWS SageMaker, Vertex AI
AaaS	IA com a servei	OpenAI API, Anthropic API
AIgent-aaS	Agents IA com a servei	Cognition Devin, Adept

7.2 API Economy: monetitzar models

OpenAI ha demostrat que es pot construir un negoci multi-bilionari venent accés a models via API. El model de negoci:

Cost d'entrenament GPT-4: ~$100M (estimat)
Preu API:
  - Input: $2.50 per 1M tokens
  - Output: $10.00 per 1M tokens
  - Usuaris API: >2M developers
  - Peticions diàries: ~100M
  - Ingressos estimats: >$3B anuals (2025)

Per a empreses que volen monetitzar els seus models especialitzats:

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer
import stripe

app = FastAPI()

@app.post("/api/v1/analitzar-jurisprudencia")
async def analitzar(
    text: str,
    usuari = Depends(verificar_subscripcio)
):
    """
    API especialitzada en anàlisi jurídica catalana.
    Cobra per token processat via Stripe.
    """
    # Comptador de tokens
    tokens_usats = comptar_tokens(text)

    # Cobrar via Stripe (metered billing)
    stripe.billing.meter_events.create(
        event_name="tokens_ia",
        payload={"stripe_customer_id": usuari.stripe_id, "value": str(tokens_usats)}
    )

    # Executar model especialitzat (fine-tuned en jurisprudència)
    resultat = model_juridic.predict(text)

    return {"analisi": resultat, "tokens_usats": tokens_usats}

7.3 AI-augmented services

El model de negoci dominant per a serveis professionals el 2025:

Consultoria: consultors augmentats per IA poden atendre 3x més clients. McKinsey, BCG i Deloitte han invertit massivament en plataformes internes d'IA. McKinsey Lilli (LLM intern) esta disponible per als 30.000 consultors.

Legal: eines com Harvey AI (GPT-4 fine-tuned en dret) permeten a advocats redactar contractes en minuts, researchar jurisprudència en segons i revisar documents a escala. Allen & Overy (10.000 advocats) ha adoptat Harvey.

Mèdica: models de diagnòstic per imatge (Qure.ai, Aidoc) permeten que un radiòleg analitzi el doble de casos amb menys errors. La IA no substitueix el metge; amplia la seva capacitat.

8. Estratègies Corporatives 2025

8.1 AI-first companies

Una empresa "AI-first" dissenya tots els seus processos assumint que la IA es una eina disponible per a tothom:

Anthropic: la missatge central es IA segura i útil. Claude es el producte i la prova del concepte.
Mistral AI (francesa): aposta per models open-weight d'alta qualitat (Mistral 7B, Mixtral 8x7B, Mistral Large). El 2025 es la alternativa europea als models americans.
Cohere: se centra en IA empresarial amb focus en privadesa i control: models que s'executen al cloud propi del client.

8.2 AI adoption a empreses tradicionals: barreres i solucions

Barrera	Solució
Por al canvi i pèrdua de feina	Comunicació transparent, participació en el disseny
Dades de baixa qualitat	Programa de Data Governance abans de l'IA
Manca de talent	Formació interna + contractació selectiva
Silos departamentals	Centre d'Excel·lència IA cross-funcional
Regulació (RGPD, EU AI Act)	DPO involucrat des del disseny
ROI incert	Pilots ràpids i mesurables (3 mesos max)

8.3 Casos: JPMorgan COiN i McDonald's AI

JPMorgan COiN (Contract Intelligence)

JPMorgan va entrenar un model de NLP per a analitzar contractes de crèdit. Resultat: - 360.000 hores de feina legal analítica substituïdes anualment - Temps per revisió de contracte: de 360.000 hores/any a segundes/contracte - Taxa d'error: inferior a la revisió humana

McDonald's AI Drive-thru

McDonald's va desplegar IBM Watson per a automatitzar la presa de comandes al drive-thru: - 80% de les comandes processades sense intervenció humana - Increment de l'import mitjà de comanda (upselling automatitzat) - El projecte es va aturar el 2023 per errors (confusió d'accents, soroll) i reprès el 2024 amb models millorats

EU AI Act i automatització

L'EU AI Act (aplicable des d'agost 2024) classifica els sistemes d'IA per risc. Els sistemes que prenen decisions que afecten accés a serveis essencials, selecció de personal o accés al crèdit son "Alt Risc" i requereixen auditoria, transparència i supervisió humana. Tingueu-ho en compte al dissenyar sistemes d'automatització.

9. Gestió del Canvi Organitzacional

9.1 Resistència i por a la substitució laboral

L'estudi del World Economic Forum (Future of Jobs Report 2025) estima: - 85 milions de llocs de treball desplaçats per IA i automatització (2025-2030) - 97 milions de nous llocs de treball creats - Net positiu, però la transició es el repte

Les professions amb major risc de desplaçament parcial: - Entrada de dades i processos administratius repetitius - Atenció al client de primera línia (FAQs, processos estandarditzats) - Contabilitat i reconciliació - Revisió legal de documents estàndard

Les professions que creixen: - Enginyers d'IA, MLOps, Data Scientists - Gestors de projectes de transformació digital - AI trainers (persones que ensenyen i avaluen models) - Especialistes en ètica d'IA i compliance

9.2 Estratègia de comunicació interna

Un rollout d'IA mal comunicat crea resistència. El model recomanat:

Fase 1 (Mesos 1-2): Conscienciació
├── Tallers de sensibilització a tots els nivells
├── Demos de les eines (hands-on)
└── FAQ: "La IA no substituirà el vostre lloc, l'augmentarà"

Fase 2 (Mesos 3-4): Experimentació
├── Programa pilot amb 20-30 early adopters voluntaris
├── Recollida de feedback constant
└── Celebrar victòries ràpides (quick wins)

Fase 3 (Mesos 5-8): Escala
├── Formació obligatoria per a tots els usuaris
├── Champions network: 1 champion per departament
└── KPIs de transformació visibles a tothom

Fase 4 (Mesos 9+): Optimitzacio
├── Centres d'Excel·lència interns
├── Comunitats de pràctica
└── Continuous improvement loop

9.3 Upskilling i reskilling

Upskilling es incrementar les competències en el rol actual. Reskilling es adquirir competències per a un rol nou.

Plans de formació recomanats per al 2025:

Per a tots els empleats (Digital Literacy): - Introducció a la IA (conceptes, capacitats, limitacions) — 8 hores - Eines d'IA del seu departament (Copilot, Einstein...) — 16 hores - Privadesa, seguretat i ètica en l'ús de l'IA — 4 hores

Per a power users (AI Augmentation): - Prompt engineering avançat — 16 hores - Automatització de workflows (Power Automate, n8n) — 24 hores - Anàlisi de dades amb IA (Excel + Copilot, Python bàsic) — 32 hores

Per a professionals tècnics (AI Development): - Python per a IA (NumPy, Pandas, Scikit-learn) — 40 hores - LLMs i APIs d'IA — 24 hores - MLOps i desplegament en producció — 32 hores

9.4 Indicadors d'èxit de la transformació digital

# Dashboard de transformació digital (exemple de KPIs)

kpis_transformacio = {
    "adopcio": {
        "usuaris_actius_copilot": "% usuaris llicenciats que usen l'eina setmanalment",
        "processos_automatitzats": "Nombre de processos completament automatitzats",
        "accions_bot_rpa": "Nombre d'accions processades per bots/dia"
    },
    "eficiencia": {
        "reduccio_temps_proces": "% reducció del temps en processos automatitzats",
        "cost_per_transaccio": "€ per transaccio processada",
        "aturades_no_planificades": "Hores d'aturada no planificada per mes"
    },
    "qualitat": {
        "taxa_error_automatitzacio": "% errors en processos automatitzats vs manual",
        "satisfaccio_empleat": "NPS intern dels usuaris d'eines IA",
        "satisfaccio_client": "NPS extern (afectat per la millora del servei)"
    },
    "negoci": {
        "roi_automatitzacio": "Retorn de la inversió en automatitzacio",
        "revenue_per_empleat": "Ingressos generats per empleat (proxy d'eficiencia)",
        "time_to_market": "Temps d'arribada al mercat de nous productes/serveis"
    }
}

10. Miniactivitat i Exercici Pràctic

Miniactivitat AC5073/02: Analitzar el potencial d'automatització

Durada: 2 hores | Individual

Tria una empresa real que coneixes (pot ser on has fet pràctiques, on treballa algun familiar, o una empresa pública ben documentada).

Mapa de processos: identifica 10 processos de negoci de l'empresa (incloent back-office, operacions, atenció al client)
Anàlisi d'automatitzabilitat per a cada procés:
Quin percentatge es automatitzable? (0%, 25%, 50%, 75%, 100%)
Quina tecnologia s'usaria? (RPA, IPA, Agent IA, ML, combinació)
Quin es l'estalvi estimat en hores/any?
Quina es la complexitat d'implementació? (baixa, mitja, alta)
Roadmap prioritzat: ordena els processos per ROI potencial vs esforç d'implementació (matriu 2x2)
Business case simplificat per al top-1 procés: inversió estimada, estalvi anual, payback period

Lliura: document de 2-3 pàgines + matriu de priorització.

Exercici Pràctic PR5003: Workflow automatitzat amb n8n i IA

Durada: 4 hores | Prerequisit: Docker Desktop instal·lat

Objectiu: crear un workflow de classificació i resposta automàtica d'emails (simulat).

Pas 1: Arrancar n8n i Ollama amb Docker

docker compose up -d

Pas 2: Al panell n8n (http://localhost:5678), crear un workflow que: 1. Reba un email simulat via webhook 2. Cridi Ollama (llama3.1:8b) per classificar el tipus de consulta 3. Segons la categoria, generi una resposta en català personalitzada 4. Guardi el resultat en un fitxer JSON de log

Pas 3: Testejar amb 5 emails de tipus diferent

Pas 4: Documentar el workflow (captures de pantalla + explicació de cada node)

Personalització obligatoria: el nom de l'alumne ha d'apareixer al títol del workflow, als missatges de log i al JSON de sortida.

Resum

L'automatització industrial i de negoci amb IA el 2025 representa una oportunitat transformadora per a les organitzacions que sàpiguen gestionar-la correctament. Els punts clau:

RPA es maduresa, IA es el futur: el RPA clàssic ha demostrat el seu valor però te limitacions estructurals. La integració amb IA (IPA) i els agents autònoms (LLM-based) representen la propera onada.
Copilots primer, autopilots després: la majoria de casos d'us empresarials haurien de mantenir l'humà en el bucle (human-in-the-loop), especialment en decisions d'alt impacte.
La tecnologia es fàcil, el canvi humà es difícil: la barrera principal de l'automatització no es tècnica; es cultural i organitzacional. Invertiu tant en gestió del canvi com en tecnologia.
Mesureu, mesureu, mesureu: sense KPIs clars, no podreu demostrar el ROI ni prendre decisions informades sobre on invertir a continuació.
Regulació com a palanca: l'EU AI Act no es un obstacle; es una oportunitat per a crear sistemes d'IA fiables que generin confiança en clients i socis.