Introducció a la inferència amb IA: guia pràctica en local

En aquest article farem una breu incursió a l’àmbit de la Intel·ligència Artificial (IA) i el seu ús en inferència amb algunes aplicacions.

Índex de continguts

• Introducció
• • Definició de Intel·ligència Artificial (IA)
  • Tipus d’aplicacions de la IA
  • Motius per a l’execució de la IA en local (Edge AI)
  • Requeriments per a l’execució d’inferència en IA en local
• Hands on
• • LM Studio
  • • Configuració bàsica i prova
    • Configuració en mode headless
  • Ollama
  • • Prova amb Linux
    • Prova amb Windows 
      
  • Altres eines

Introduc​ció

Definició de Intel·ligència Artificial (IA)

Abans de res, què és la intel·ligència artificial (IA)? És l’àrea que busca desenvolupar sistemes capaços de realitzar tasques que normalment requereixen intel·ligència humana, com raonar, aprendre, reconèixer patrons, comprendre llenguatge o prendre decisions. En termes més tècnics: és la capacitat d’un sistema computacional de processar dades, aprendre’n i generar prediccions, respostes o accions basades en aquest aprenentatge.

En informàtica, la IA funciona en dues fases principals:

1. Entrenament: El model aprèn a partir de dades històriques. Exemple: un model de correu electrònic aprèn quins missatges són spam i quins no.
2. Inferència: És la fase en què el model ja entrenat s’aplica sobre dades noves per generar una sortida. Exemple: en arribar un correu nou, la IA fa inferència per classificar-lo com a spam o no.

En aquest sentit, la IA és el conjunt de mètodes i tècniques que permeten crear models intel·ligents. La inferència és el mecanisme mitjançant el qual aquests models “raonen” sobre dades noves, aplicant el que han après. En informàtica, la IA podria definir-se com l’ús d’algoritmes i models capaços d’aprendre de dades i aplicar inferència per resoldre problemes, automatitzar processos i prendre decisions en contextos nous.

Els models podrien definir-se com a programes informàtics que s’han entrenat amb un gran conjunt de dades per aprendre el que es pretengui (tot, si parlem de models generalistes). Com funcionen? Imagina que vols ensenyar a un ordinador a reconèixer gats en fotos. En lloc d’escriure regles específiques (com ara “un gat té orelles punxegudes, bigotis, etc.”), li mostres milers de fotos de gats i milers de fotos que no són de gats. El model de IA, a través d’algoritmes, analitza les dades i troba patrons i relacions que li permeten diferenciar entre un gat i altres objectes. Un cop el model ha “après” (és a dir, ha estat entrenat), pots donar-li una foto nova i el model, basant-se en els patrons identificats, predirà si hi ha un gat a la imatge o no.

Tipus d’aplicacions de la IA

La intel·ligència artificial (IA) s’aplica de moltes maneres. A continuació, els principals tipus d’ús:

• Processament de llenguatge natural (PLN): Chatbots, assistents virtuals, traducció automàtica, anàlisi de sentiments, generació de text.
• • Exemple: ChatGPT, traductors de Google, assistents com Alexa o Siri.
• Visió per computador: Reconeixement d’imatges, detecció d’objectes, anàlisi de vídeo, biometria (empremtes, rostres).
• • Exemple: sistemes de càmeres intel·ligents, filtres de fotos, seguretat amb reconeixement facial.
• Aprenentatge automàtic (Machine Learning, ML): Prediccions i classificació a partir de dades (spam vs. no spam, diagnòstics, predicció de preus).
• • Exemple: sistemes de recomanació (Netflix, YouTube, Amazon).
• Aprenentatge profund (Deep Learning): Xarxes neuronals per a tasques complexes: conducció autònoma, generació d’imatges, veu sintètica.
• • Exemple: cotxes Tesla, DALL·E, eines de clonació de veu.
• Automatització i agents intel·ligents: Robòtica, processos automàtics en servidors, optimització de xarxes.
• • Exemple: RPA (Robotic Process Automation) en empreses, bots de trading.
• Ciberseguretat amb IA: Detecció d’anomalies, prevenció de fraus, anàlisi de malware.
• • Exemple: antivirus amb IA, detecció d’intrusos en sistemes.
• Sistemes experts i suport en decisions: Programes que simulen el raonament humà en àrees específiques.
• • Exemple: software mèdic per a diagnòstics, assistents de programació.
• Generació de contingut: Text, imatges, música, codi, vídeos.
• • Exemple: generació automàtica de notícies, disseny de videojocs, IA creativa.

La inferència per IA és un procés intern que utilitzen tots els sistemes de IA basats en models entrenats, que consta de les dues fases comentades anteriorment: entrenament (entrada o aprenentatge) i inferència (sortida o predicció/resposta).

Motius per a l’execució de IA en local (Edge AI)

Tots coneixem la IA pel servei que ofereix ChatGPT, i que altres han seguit. Així que si tenim la IA al Cloud (ChatGPT, Gemini, Claude...),  quin sentit o benefici té fer-ho en local?

• Per privacitat i seguretat de les dades, ja que la informació no s’envia a servidors externs.
• Per costos:
• • Menor cost a llarg termini (comptant amb l’amortització del hardware que s’adquireixi).
  • Costos operatius previsibles (en no basar-se en un model pay-per-use).
• Per límits. Relacionat amb el punt anterior, les IA estableixen uns límits en els seus modes gratuïts.
• Per permetre l’operació sense connexió a Internet.
• Encara que en menor mesura, per oferir una menor latència (si bé això pot ser una minúcia depenent de temps de processament de la IA local usada).

De totes maneres, no sempre és una bona idea pel cost de computació, inversió en hardware i manteniment que pot suposar, pel poc rendiment o valor aportat, etc. (caldria fer una avaluació segons el cas).

Requeriments per a l’execució d’inferència en IA en local

Per a la inferència de IA, les GPU (Unitats de Processament Gràfic o, més comúment, targetes gràfiques) són crucials perquè la seva arquitectura paral·lela permet gestionar eficientment les grans quantitats de càlculs matricials que requereixen els models d’aprenentatge automàtic. Tot i que la inferència és menys exigent que l’entrenament, una GPU optimitzada per a aquesta tasca redueix la latència i millora el rendiment.

En seleccionar una GPU per a inferència, s’han de considerar aquests factors principals:

• Memòria de vídeo (VRAM): La VRAM és un dels factors més importants per a la inferència de models grans, com els LLMs (Grans Models de Llenguatge). Una VRAM suficient permet carregar tot el model a la memòria de la GPU, eliminant la necessitat de recórrer a la memòria del sistema (RAM), cosa que accelera dràsticament la velocitat de processament i resposta.
• Velocitat de rellotge i amplada de banda: Encara que la VRAM és vital per a la capacitat, la velocitat de rellotge i l’amplada de banda de la memòria determinen la velocitat a què es processen les dades. Una GPU amb una alta amplada de banda de memòria pot moure les dades necessàries per a la inferència de manera més ràpida.
• Nombre de cores i generació de la GPU: Com en altres àmbits, tenir una GPU amb un nombre més gran de cores i de generació més nova serà desitjable per obtenir un millor rendiment.
• Optimització del software: El suport del fabricant per:
• • Les aplicacions que executen la inferència (en veurem algunes més endavant).
  • Els frameworks com PyTorch i TensorFlow, així com les biblioteques especialitzades, és fonamental. NVIDIA, per exemple, té un ecosistema molt madur amb CUDA i TensorRT, cosa que li dona un avantatge significatiu al mercat de la IA.

L’elecció d’una GPU per a inferència dependrà del pressupost i del tipus de model que es vulgui executar:

1. Gamma alta i professional: Per a aplicacions d’inferència exigents o a nivell de centre de dades.
2. • GPUs de NVIDIA: les sèries H100, L40S i RTX 6000 Ada estan dissenyades per a càrregues de treball professionals, arribant fins als 80GB de memòria.
   • GPUs d’AMD: AMD també té la seva gamma amb la Instinct MI300X, MI325X i MI355X arribant fins als 288GB amb memòria de tipus HBM.
3. Gamma mitjana i de consum: Per a ús personal o per a models de mida més petita.
4. • Sèrie NVIDIA GeForce RTX: 5090 (amb 32GB de VRAM DDR7) i 4090 (amb 24GB) són les millors en rendiment per a ús personal, mentre que altres com la RTX 4060Ti de 16GB (gamma d’entrada) són molt populars per executar models de llenguatge mitjans localment.
   • Sèrie Radeon RX: RX 7900 XTX (24GB VRAM DDR6 gen RDNA 3) i RX 9000 (16GB VRAM DDR6 i de generació més nova, RDNA 4). De nova generació i amb una quantitat de VRAM més generosa/apta, també hi ha la versió per a workstations, Radeon AI PRO R9700, amb 32GB.

Vol dir això que no puc executar inferència IA en CPU? No, en realitat és possible, però en general serà un procés molt lent. Això també depèn del model de IA a executar, la seva mida i la seva parametrització (models MOE i amb quantificació),  però per simplificar, en general sempre voldràs fer servir la CPU i la RAM del sistema com a fallback per quan la/les GPU/s (sí, pots tenir-ne diverses en un mateix host per aprofitar-les sempre que el software ho suporti) no donin prou de si (bàsicament per poder seguir operant quan aquestes no tinguin prou VRAM i hagin de descarregar —offloading— a la RAM del sistema).

Com ja hem descrit anteriorment els models, ara coneixerem alguns detalls més sobre aquests. Els models es poden distingir per les seves diferents característiques:

• El seu objectiu/orientació/especialització. Com veuràs, alguns models tenen etiquetes com instruct, code o chat... aquestes es refereixen a l’especialització o el procés d’entrenament posterior (fine-tuning) que s’aplica als models de llenguatge a gran escala (LLM) perquè puguin fer tasques específiques de manera més efectiva. Alguns tipus segons el seu objectiu:
• • Models Base (o Foundation Models): Són el punt de partida. Han estat entrenats amb una quantitat massiva de dades de text i codi d’Internet per aprendre a predir la següent paraula en una seqüència. El seu objectiu principal és comprendre el llenguatge i els seus patrons. Per si sols, no estan optimitzats per interactuar amb els usuaris de manera conversacional, i les seves respostes poden ser genèriques o confuses.
  • Models Instruct (d’“instruccions”): Són models base que han estat afinats (fine-tuned) per seguir instruccions amb precisió. Aquest procés implica entrenar-los amb un conjunt de dades de parells de “pregunta-resposta” on la resposta és l’ideal. L’objectiu és que el model no només completi text, sinó que respongui directament el que se li demana. Exemple: a un model base se li pregunta “El significat d’IA és...”, i podria completar la frase. A un model instruct se li dona la mateixa pregunta i respondrà amb “La IA (Intel·ligència Artificial) és la simulació de processos d’intel·ligència humana...”.
  • Models Code: Són models base o instruct que han estat entrenats específicament amb codi informàtic. El seu objectiu és entendre, generar, completar o depurar codi en un o diversos llenguatges de programació. Poden ser una subcategoria dels models instruct si estan optimitzats per seguir instruccions com ara “escriu una funció per...”. Exemple: generar un fragment de codi Python per classificar una llista o explicar com funciona un algoritme.
  • Models Chat: Són una evolució dels models instruct. Han estat optimitzats específicament per a interaccions conversacionals, és a dir, per mantenir un diàleg de diverses voltes. Sovint s’entrenen utilitzant Aprenentatge per Reforç a partir de Retroalimentació Humana (RLHF), on avaluadors humans valoren les respostes per ensenyar al model a ser més útil, honest i segur en un context de conversa. Exemple: un model chat com ChatGPT està dissenyat per recordar el context de la conversa, respondre preguntes de seguiment i comportar-se com un assistent conversacional.

• La seva mida. Aquesta es mesura pel nombre de paràmetres (les variables internes que el model ajusta durant l’entrenament).
• • Models petits: Tenen menys paràmetres i són més ràpids, però el seu rendiment és generalment inferior. Són ideals per a aplicacions que s’executen en dispositius amb recursos limitats, com ara telèfons mòbils (IA al marge o "on-device AI").
  • Models grans: Tenen milers de milions o fins i tot bilions de paràmetres. Ofereixen un rendiment superior, són més versàtils i capaços de gestionar tasques complexes. No obstant això, requereixen una gran quantitat de memòria i potència de càlcul, per la qual cosa solen executar-se en centres de dades o al núvol.

• La seva quantificació (i quanta). La quantificació és el procés de reduir la precisió numèrica dels paràmetres d’un model, per exemple, d’un format de punt flotant de 32 bits (FP32) a un de 8 bits (INT8).
• • Models sense quantificar: Usen una alta precisió (com FP32). Són més precisos, però consumeixen més memòria i requereixen més temps per a la inferència, cosa que els fa menys eficients.
  • Models quantificats: Usen una precisió menor (com INT8 o fins i tot 4 bits). Això redueix dràsticament la mida del model i accelera la inferència. Encara que hi pot haver una lleu pèrdua de precisió, sovint és insignificant i el benefici en velocitat i consum de recursos és considerable, permetent desplegar-los en dispositius de menor potència.

• El seu format. Es refereix a l’estructura de fitxer específica que s’utilitza per emmagatzemar els pesos i l’arquitectura del model d’una manera optimitzada per a un tipus d’inferència. Això és especialment rellevant a l’ecosistema dels LLM de codi obert i el seu ús en hardware de consum. Els formats més comuns per a inferència local de LLMs, que sovint inclouen algun tipus de quantificació, són:
• • GGUF (GPT-Generated Unified Format). El format GGUF (originalment una evolució de GGML) és un format de fitxer binari dissenyat específicament per ser utilitzat per llama.cpp, un motor d’inferència optimitzat per a CPU. El seu principal avantatge és que permet carregar-ho tot en un sol fitxer (pesos, arquitectura, tokenitzador, etc.), cosa que en simplifica l’ús. A més, admet una àmplia gamma de quantificacions (de 2 a 8 bits), la qual cosa permet als usuaris triar l’equilibri entre mida, velocitat i impacte en el rendiment. GGUF és molt popular perquè habilita la inferència de LLMs fins i tot en ordinadors sense una GPU potent. Si vols la màxima compatibilitat i flexibilitat per utilitzar un model a la CPU (o a la CPU i GPU alhora), és l’opció ideal.
  • GPTQ (GPT for Quantization). El format GPTQ és un mètode de quantificació dissenyat específicament per a GPU. Redueix la mida del model i accelera la inferència de manera significativa, però els models en aquest format requereixen una GPU per funcionar. A diferència de GGUF, que pot usar CPU, GPTQ aprofita les capacitats de les targetes gràfiques per executar la inferència de manera molt eficient.
  • Safetensors.  És una alternativa als fitxers de model tradicionals de PyTorch (.pt o .bin). La seva principal característica és que és segur, cosa que significa que no pot executar codi maliciós en carregar-se. S’utilitza molt com a format base per als models, que després es poden convertir a altres formats (com GGUF) per a una inferència optimitzada en diferents tipus de hardware. A diferència de GGUF o GPTQ, safetensors no aplica per si mateix una quantificació. Si descarregues un model directament d’un repositori per al seu processament posterior, és probable que vingui en aquest format.

• La seva arquitectura. És el “plànol” del model, és a dir, el disseny de les seves capes i la manera com es connecten. És una característica fonamental que defineix la capacitat i l’especialització del model. Es distingeixen segons si estan basats en:
• • Transformadors:  Són l’arquitectura dominant en els models de llenguatge (LLM) i visió. El seu mecanisme d’atenció els permet processar seqüències de dades (com text) de manera eficient i comprendre el context a llarg termini.
  • Xarxes neuronals convolucionals (CNN): Molt efectives per a l’anàlisi d’imatges, ja que les seves capes estan dissenyades per detectar patrons espacials (com vores i textures).
  • Xarxes neuronals recurrents (RNN): Solien ser l’arquitectura principal per al processament de seqüències, com text, però han estat àmpliament superades pels transformers.

Hands on

Vista la teoria, posem-nos mans a l’obra. Partim de les següents premisses, que coincideixen amb el meu cas d’ús:

• La meva preferència sempre és Linux per sobre de Windows.
• Però en aquest cas, tinc un PC d’ús exclusiu per a gaming amb una GPU AMD Radeon RX 9070XT.

Així que veurem exemples en els dos sistemes, però amb preferència sobre l’host Windows per disposar de hardware preferible per a l’execució d’inferència en IA.

LM Studio

Configuració bàsica i prova

La primera incursió en el tema la farem amb l’eina LM Studio, una aplicació d’escriptori que permet als usuaris descarregar, configurar i executar models de llenguatge grans (LLMs) localment al teu PC, sense necessitat d’una connexió a Internet ni de dependre de serveis al núvol.

Avantatges d’aquesta eina:

• És un “tot en un”, en el sentit que executa inferència basant-se en models, té una interfície gràfica per interactuar i també pot treballar en mode servei.
• Disposa d’una interfície gràfica, de manera que redueix la corba inicial d’aprenentatge en facilitar centrar-se en la temàtica: la cerca, descàrrega i ús dels models.
• Permet compatibilitat amb models de Hugging Face (una coneguda plataforma oberta que permet accedir a una àmplia varietat de models preentrenats).
• També permet disposar d’un servidor API local compatible amb OpenAI, la qual cosa pot resultar interessant per a desenvolupadors en permetre integrar els models locals en aplicacions i projectes personalitzats.
• Facilita l’ajust de paràmetres dels models com la temperatura (p. ex. top-K i top-P per controlar l’aleatorietat i la qualitat de les respostes).
• Suport multiplataforma: l’aplicació està disponible per als sistemes operatius més comuns: Windows, Mac i Linux (en forma d’AppImage —executable autocontingut— en aquest últim cas).
• Suport per a GPU: van afegint amb certa assiduïtat suport per a GPU, fins i tot les integrades (iGPU).
• A nivell de llicència, des de fa poc la podem fer servir lliurement sense adquirir una llicència comercial ni omplir formularis.
• Així doncs, comencem. Ens baixem i instal·lem l’última versió. En el primer inici, ens demana que triem el nostre nivell de coneixements sobre IA (User, Power User o Developer), així que començarem amb “User”:

Això ens suggereix descarregar directament el model gpt-oss20b (d’uns ~12GB) d’OpenAI (un bon model sens dubte), encara que podem fer skip si no volem descarregar aquest model en aquell moment:

Ara ja som a la pantalla principal de l’aplicació, que s’assembla a la de ChatGPT o qualsevol altra eina de xat amb IA (Gemini, etc.):

• A la banda esquerra tenim la llista de xats/consultes que anirem fent.
• A la dreta, a la part central, hi ha la zona de xat on tindrem les respostes.
• A baix, el giny d’introducció de text (les nostres consultes) i, a la part superior, el carregador de models (“Select a model to load”).

Si hem baixat el model, podem seleccionar les opcions i carregar-lo:

A la lupa de dalt a la dreta (amb el tooltip “Discover”) podem cercar directament per noms de models per descarregar:

Com a prova, descarreguem i carreguem a l’eina un model petit (qwen2-micro-0.5b-multilingual) i li fem una consulta senzilla que resol ràpidament:

Si ens hi fixem —i això també és molt comú en altres eines de xat amb IA—, al final de la resposta tenim (icona del rellotge) una breu informació del rendiment: tokens/s, quants tokens ha suposat la nostra consulta i el time to first token (quant ha trigat a començar a respondre).

Aquesta informació ens serà útil per a conèixer en rendiment de la nostra plataforma en cada cas (que variaran segons el hardware i el software utilitzat).

Altres aplicacions tenen diferents indicadors, però al final sempre parlarem de “tokens”. I què és això? Doncs en IA, un token és la unitat bàsica de text utilitzada pels models de llenguatge per processar informació. Cal pensar en ells com les “paraules” o “fragments de paraules” que el model entén i manipula.

I com funcionen? Els models de llenguatge, com els que generen text o responen preguntes, no processen el text lletra per lletra o paraula per paraula com ho fem els humans. En el seu lloc, el text d’entrada es divideix en aquests tokens mitjançant un procés anomenat tokenització, que fa subdivisions:

• Paraules completes: sovint, una paraula és un sol token (per exemple, “gos”).
• Subparaules: les paraules llargues o poc comunes es poden dividir en tokens més petits. Per exemple, la paraula “tokenització” es podria dividir en “token” i “ització”.
• Puntuació i símbols: els signes de puntuació com comes (,), punts (.) o signes d’exclamació (!) també són tokens individuals.

Cada token es converteix en un número (un ID de token) que el model pot processar matemàticament. El model utilitza aquests números per predir la seqüència de tokens següents, construint així una resposta coherent. Aquest procés de tokenització és crucial en la inferència (l’ús d’un model entrenat per generar una resposta) per eficiència (permet als models gestionar grans quantitats de text de manera eficient), i per context (els tokens anteriors permeten predir el següent).

Fins aquí hem conegut les bases de l’eina i ens ha servit per anar introduint conceptes. Pots provar de treballar amb altres models i decidir quins et semblen millors per al teu hardware, software i si el resultat et satisfà per a les teves necessitats. Cal dir que hi ha models millors i pitjors, i alguns orientats a tasques més concretes (p. ex. redactar un article, generar codi de programació, mantenir una conversa de xat...).

Això és molt interessant, però si tinc un PC de gaming o un servidor amb una o diverses GPU, ¿no pot tenir un impacte a la factura elèctrica? Doncs tot depèn de si faràs servir molt la IA (perquè farà que el consum es dispari quan estigui treballant) o només puntualment. Un equip en idle no sol consumir gaire, però tenir-lo 24x7 sí que farà que ho notem a la factura. Una opció intermèdia podria ser encendre l’equip a demanda (p. ex. deixant-lo suspès/en estat latent, despertar-lo quan sigui necessari via Wake On Lan, i instruir-lo perquè torni a suspendre’s quan no s’utilitzi).

Configuració en mode headless

Si t’interessa la idea anterior, a continuació pots veure com configurar LM Studio perquè funcioni en mode headless, estigui disponible per xarxa i no sigui necessari iniciar sessió a Windows.

Primer anirem a la Configuració general de l’aplicació:

Després anirem a Settings (icona verda de l’esquerra) i habilitarem les 2 opcions següents:

Fet això, podem comprovar amb netstat que el servei està escoltant pel port per defecte (1234):

Amb això, ja ens podem connectar al servei que exposa LM Studio fent ús d’algun client OpenAI API compatible a través de la URL a http://IP_HOST_LMSTUDIO:1234/. Per exemple, amb Chatbox (vegeu l’últim punt “Altres eines”).

Ollama

La primera incursió en el tema la vam fer amb l’eina LM Studio, una aplicació d’escriptori que permet als usuaris descarregar, configurar i executar models de llenguatge grans (LLMs) localment al teu PC, sense necessitat de connexió a Internet ni de dependre de serveis al núvol.

Ollama és una altra eina semblant a LM Studio, però amb algunes diferències:

• És Open Source.
• Està més orientada a desenvolupadors i proporciona interfície gràfica de consulta (tot i que també pot usar-se via CLI o via API, compatible amb la d’OpenAI).

Prova amb Linux

Com que ens agrada treballar amb contenidors perquè agilitzen el desplegament, farem servir la imatge Docker d’aquesta aplicació.

Creem un directori i llancem ollama:

$ mkdir ollama
$ docker run -d -v ./ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Li carreguem algun model:

$ docker exec -it ollama ollama run --verbose gpt-oss  # Modelo https://ollama.com/library/gpt-oss
ó
$ docker exec -it ollama ollama run --verbose llama3   # Modelo https://ollama.com/library/llama3

I li fem una consulta:

Havent comprovat el seu funcionament, el podem organitzar millor (per facilitar futurs desplegaments) afegint-lo en un docker-compose.yaml, i de pas li afegirem una interfície web per facilitar-ne l’accés i l’operativa:

# docker-compose-ollama.yml
services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - 11434:11434
    volumes:
      - /home/XXX/ollama:/root/.ollama
    tty: true
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    volumes:
      - /home/XXX/open-webui:/app/backend/data
    depends_on:
      - ollama
    ports:
      - 3000:8080
    environment:
      - OLLAMA_BASE_URL: http://ollama:11434
      - WEBUI_SECRET_KEY: YYY
    # It allows the container to access services running on your host machine.
    # host.docker.internal is a special hostname that resolves to your host's internal IP address.
    # This is useful if, for example, you have another service running directly on your computer 
    # (not inside a container) that Open WebUI needs to access.
    extra_hosts:
      - host.docker.internal:host-gateway
    restart: unless-stopped

Aturem i eliminem el contenidor previ amb què havíem fet les proves, i aixequem el compose:

$ docker stop ollama
$ docker rm ollama
$ docker compose up -d

Amb això, ja ens podem connectar amb un navegador web a http://localhost:3000/ i accedirem a Openweb-UI per poder interactuar amb Ollama. Ens demanarà unes dades, entre les quals hi ha la contrasenya establerta al servei Openweb-UI:

I a continuació, tindrem accés a la interfície web de consulta:

Us resulta familiar? Veureu que s’assembla a ChatGPT, Gemini, LM Studio...

Com a curiositat, a continuació unes estadístiques de rendiment amb diferents models i en hardware diferent:

# Stats
# Model: llama3
# Query: What minipc CPU would you recommend to run local AI inference?

# Intel i5-1135G7 + 16GB DDR4 3200MT/s + NVME Kioxia KBG40ZNV256G
total duration:       2m20.204321315s
load duration:        77.129285ms
prompt eval count:    23 token(s)
prompt eval duration: 1.33939865s
prompt eval rate:     17.17 tokens/s
eval count:           706 token(s)
eval duration:        2m18.787155647s
eval rate:            5.09 tokens/s

# VM with half the cores (14) of an Intel Xeon E5-2680 v4 (host cpu) + 16GB DDR4 2400 MT/s + NVME SAMSUNG MZVLB256HBHQ (virtio)
total duration:       1m16.622600166s
load duration:        106.754701ms
prompt eval count:    23 token(s)
prompt eval duration: 861.563097ms
prompt eval rate:     26.70 tokens/s
eval count:           518 token(s)
eval duration:        1m15.653366355s
eval rate:            6.85 tokens/s

# Model: gpt-oss
# Query: What minipc CPU would you recommend to run local AI inference?

# VM with half cores (14) of Intel Xeon E5-2680 v4 (host cpu) + 16GB DDR4 2400 MT/s + NVME SAMSUNG MZVLB256HBHQ (virtio)
total duration:       5m1.996240966s
load duration:        209.642746ms
prompt eval count:    80 token(s)
prompt eval duration: 1.918822419s
prompt eval rate:     41.69 tokens/s
eval count:           2275 token(s)
eval duration:        4m59.864109854s
eval rate:            7.59 tokens/s

Prova amb Windows

També hem volgut provar-ho a Windows pel mateix motiu que vam començar el post a la secció de LM Studio: perquè té hardware dedicat (GPU) i volem veure si funciona.

En aquest cas, la meva GPU és relativament nova i encara no està oficialment suportada, però ja hi ha qui ha trobat workarounds per poder-ne fer ús mentre el projecte no es posa les piles amb el tema.

En resum, en aquest cas cal instal·lar l’última release del fork d’Ollama per AMD (ollama-for-amd) i després substituir l’arxiu rocblas.dll i el directori rocblas/library amb els arxius d’aquí (específicament els de l’arxiu rocm.gfx1201.for.hip.skd.6.2.4-no-optimized.7z). Si estem en el supòsit d’una GPU ja suportada, només cal instal·lar la versió normal d’Ollama:

Un cop fet això, Ollama s’executarà com a servei (ho podem veure amb netstat escoltant pel port 11434, o bé amb la seva icona a la safata del sistema —tray icon—):

Si de pas també volem que estigui disponible perquè hi accedeixin els hosts de la nostra xarxa (igual que en l’exemple previ que vam fer amb LM Studio), creem la variable d’entorn següent (des de Windows → Configuració → Editar les variables d’entorn del sistema):

OLLAMA_HOST=0.0.0.0

També el podem provar abans via CLI per veure que realment queda escoltant per aquest port (situa’t al directori on s’instal·la per poder llançar aquests comandaments):

C:\Users\XXX\AppData\Local\Programs\Ollama> set OLLAMA_HOST=0.0.0.0
C:\Users\XXX\AppData\Local\Programs\Ollama> ollama.exe serve

I a continuació, provarem d’executar un prompt en local descarregant el model petit de gpt-oss via cmd:

C:\Users\XXX\AppData\Local\Programs\Ollama>ollama.exe run --verbose gpt-oss:20b

Amb això podrem interactuar per consola, fer ús d’algun client com el previ Openweb-UI o bé descarregar-nos-en algun per al nostre sistema:

• SMuflhi
• JHubi1

Cal destacar que per utilitzar aquests clients serà necessari indicar la URL on Ollama està servint. En el meu cas és http://IP_HOST_OLLAMA:11434.

Altres eines

La IA és un camp emergent i sovint surten noves alternatives que val la pena conèixer i explorar. A continuació, unes quantes d’interessants:

• Llama.cpp,  inferència LLM amb ampli suport de hardware.
• koboldcpp,  aplicació de generació de text IA per a models GGML i GGUF.
• vLLM, llibreria per a inferència LLM.
• Jan, alternativa a LM Studio 100% offline.
• LocalAI, eina per a IA local centrada en la inferència per CPU.
• Chatbox  un servei d’IA com ChatGPT, però també una app interessant que permet connectar a molts altres backends, tant remots com a instàncies locals (LM Studio, Ollama...).
• PocketPal  un assistent IA que executa models petits directament al teu smartphone (offline), igual que Private LLM, Llamao i Layla.
• ChatterUI permet el mateix, però també connectar a APIs remotes.
• Maid és una barreja dels dos anteriors.