Si t'estàs preguntant com executar Qwen 2.5-27B en un portàtil sense morir a l'intent, ets al lloc adequat. Qwen és dels pocs models grans que avui dia pots fer córrer en local amb un portàtil decent, però hi ha força lletra petita que convé entendre abans de posar-te a descarregar gigues com si no hi hagués un demà.
A veure, pas a pas, què és realment Qwen 2.5-27B, quin maquinari necessites, quines opcions tens (AMD, Apple Silicon, CPU pura, VPS, GPU llogada…) i com integrar-ho amb eines com Ollama, truca.cpp o LM Studio, sense oblidar-nos dels detalls que tothom passa per alt: quant.
Què és Qwen 2.5-27B i en què es diferencia d'altres models
Qwen 2.5 és un model de llenguatge de propòsit general desenvolupat per Alibaba Cloud , dissenyat per competir de tu a tu amb altres bèsties del sector com DeepSeek R1. La variant de 27B (27.000 milions de paràmetres) apunta a un equilibri interessant: prou gran per fer treball seriós de raonament i codi, però encara executable en un portàtil ben equipat o en un servidor amb CPU i molta RAM.
Dins la família Qwen 2.5 trobaràs versions especialitzades com Qwen 2.5-Coder i Qwen 2.5-Math . La primera està optimitzada per a programació (autocompletat, refactorització, depuració en múltiples llenguatges) i la segona per a matemàtiques avançades i problemes tècnics, cosa molt útil en entorns educatius, investigació o anàlisi de dades.
Una de les claus de Qwen 2.5 és el seu ampli suport d'idiomes . No es queda en anglès i xinès: suporta més de 29 idiomes, entre ells espanyol, francès, alemany, portuguès, italià, rus, japonès, coreà, vietnamita, tailandès o àrab. Això fa que sigui viable fer-lo servir com a assistent multilingüe en empreses amb operacions internacionals o en projectes on calgui barrejar documentació de diverses llengües.
Un altre punt fort és la gestió del context. A la documentació es parla que el model pot manejar finestres de context ampliades , amb la capacitat de processar i generar grans quantitats de text en una sola conversa. Això us permet seguir el fil en documents llargs, xats tècnics extensos o bases de codi complexes sense perdre's al segon missatge.
Arquitectura, dades i per què Qwen 2.5 destaca
A nivell intern, Qwen 2.5 es beneficia d'una millora important en la qualitat de les dades d'entrenament . Alibaba ha afinat els filtres per netejar soroll, ha integrat corpus de codi i matemàtiques més extenses i utilitza dades sintètiques d'alta qualitat per reforçar capacitats concretes. Això es nota sobretot en tasques de raonament estructurat, resolució de problemes i programació.
També incorpora indicacions de sistema adaptatives , la qual cosa us permet ajustar-se millor a diferents rols: assistent de suport, tutor, agent de terminal, redactor de contingut, etc. A la pràctica, això significa que reacciona amb més precisió a prompts de sistema complexos (per exemple, plantilles d'agents) sense trencar tant el personatge ni desviar-se de l'objectiu.
Quan es compara amb models com DeepSeek R1, els benchmarks disponibles apunten que Qwen 2.5 sol anar un pas endavant en preferències d'usuari . En proves com Arena-Hard, Qwen 2.5 obté al voltant de 89,4 davant de 85,5 de DeepSeek R1, cosa que suggereix que, a igualtat de condicions, la gent prefereix les seves respostes. A MMLU-Pro i GPQA-Diamond ambdós models estan molt semblants, amb Qwen 2.5 lleugerament per sobre, cosa que reflecteix un bon domini de coneixement general i sentit comú.
La gran diferència pràctica, i la que t'interessa si penses executar-lo al teu portàtil, és que Qwen 2.5 està pensat per cobrir molts casos d'ús amb un únic model : conversa, anàlisi de documents, generació de codi, tasques matemàtiques, automatització interna i agents que s'executen a la teva màquina.
Llicència, pesos oberts i on aconseguir Qwen 2.5-27B
Qwen 2.5-27B forma part de la línia de models de pesos oberts amb llicències permissives (com Apache 2.0 en moltes variants recents de Qwen). Això, a efectes pràctics, vol dir que pots descarregar els pesos, executar-los en local, afinar-los amb les teves pròpies dades i fer-los servir en productes comercials sense les restriccions habituals d'alguns models tancats.
Això sí, cal entendre la diferència entre open source segons l'OSI i “pesos oberts” . A Qwen 2.5 no es publiquen les dades d'entrenament completes, així que no entra en la definició estricta de programari lliure, però a nivell de negoci el més rellevant és que tens marge de maniobra legal per desplegar-lo i monetitzar-lo sense ficar-te en un jardí de llicències.
Per aconseguir el model teniu dues grans vies: el núvol i l'execució local. Al núvol, Alibaba Cloud ofereix Qwen 2.5 com a servei d'IA al qual accedeixes via API. Aquí només necessites un compte, credencials i fer peticions HTTP amb la teva clau. Per a execució local, el model està publicat a Hugging Face dins de l'organització Qwen, des d'on pots descarregar els checkpoints i fer-los servir amb Transformers, vLLM, truca.cpp, LM Studio, Ollama o altres runtimes compatibles.
Com accedir a Qwen 2.5 des d'API i des del teu portàtil
Si només busques utilitzar Qwen 2.5 sense embolicar-te amb instal·lar res al teu portàtil, l'opció d'API al núvol és la més directa . Et registres a Alibaba Cloud, et subscrius al servei de models d'IA, obtens el teu API key i comences a fer trucades HTTP amb el model qwen-max o variants similars.
Des de Python, només cal enviar una petició POST amb un JSON que contingui el prompt i els paràmetres que vulguis (màxim de tokens, temperatura, etc.). El servidor d'Alibaba s'encarrega de la inferència i et torna la resposta en uns segons. És la forma més còmoda per a prototips, integracions ràpides o projectes on no vulguis ocupar-te del maquinari.
Una altra alternativa són proveïdors tercers com CometAPI , que ofereixen accés a l'API de Qwen amb tarifes diferents de les oficials i actuen com a hub de diversos models. Des del punt de vista d'integració, utilitzeu un endpoint unificat i canvieu el nom del model al payload (per exemple, qwen-max), cosa que simplifica jugar amb diferents LLM sense reescriure mitja aplicació.
Si el que vols és executar Qwen 2.5 localment al teu portàtil , la ruta habitual avui dia passa per Hugging Face i la llibreria Transformers. Carregues el tokenizer i el model amb AutoTokenizer i AutoModelForCausalLM, generes text amb model.generate i controles la resta de paràmetres des del teu propi codi. Això sí, per a la versió 27B necessites tenir molt clar quanta memòria tens i quin tipus de quantització utilitzaràs.
Requisits de maquinari per a un portàtil amb Qwen 2.5-27B
Tot i que el títol daquest article parla de portàtils, la realitat és que no tots els portàtils valen per a un 27B . Necessitaràs memòria de sobres i, si vols una experiència fluida, algun tipus d'acceleració (GPU dedicada o NPU potent). Si no, el model funcionarà, però a velocitat de tortuga.
A l'entorn AMD, Qwen 3.8-27B (molt comparable en mida a la línia 2.5-27B) s'ha provat amb Ryzen AI Max+ i targetes Radeon AI PRO R9700 de 32 GB . Amb aquesta combinació, usant truca.cpp i versions optimitzades del model, s'han vist xifres d'uns 24,5 tokens per segon al Ryzen AI Max+ i al voltant de 51,8 tok/s a la Radeon AI PRO R9700. Això dóna una idea del que pots esperar dun portàtil o estació de treball amb maquinari similar.
Si la teva màquina és un MacBook amb Apple Silicon (M-series) , la jugada típica és fer servir LM Studio o Ollama amb backends optimitzats sobre MLX. Amb un MacBook Pro M5 Max ben configurat ja hi ha gent executant models 27B en quantitzacions GGUF d'uns 17-18 GB i obtenint rendiment més que acceptable per a treball de desenvolupament i agents lleugers, sempre que la memòria unificada sigui abundant.
Per a ordinadors Windows o Linux amb GPU dedicada NVIDIA, la clau és la VRAM disponible i la quantització . Amb una RTX amb 24-32 GB de memòria pots executar un 27B en formats com Q4_K_M o NVFP4, deixant marge per al context i la memòria cau KV. En targetes de 32 GB, configuracions com NVFP4 ocupen al voltant de 16,5 GB només per a pesos, i FP8 pot pujar prop de 28,5 GB, deixant poc marge per a context llarg.
Quant ocupa realment Qwen 27B: pesos, quantització i context
Aquí ve un dels errors més comuns: veure que larxiu GGUF pesa 17 GB i pensar que amb 17 GB de RAM vas servit . No. Aquesta mida només correspon als pesos del model. Després cal sumar la memòria cau KV, l'estat intern de les capes, l'encoder de visió si és multimodal i la sobrecàrrega del runtime.
En un 27B quantitzat a Q4_K_M (molt habitual a llama.cpp i Ollama), els pesos ocupen al voltant de 17 GB, equivalents a uns 4,9 bits per pes efectius . Això és perquè els formats K-quant no usen el mateix nombre de bits per a tots els tensors: alguns es guarden a 5 o 6 bits i les capes d'embeddings i sortida solen anar a Q6_K o Q8_0, la qual cosa puja la mitjana.
La memòria cau KV, per la seva banda, creix de forma lineal amb el nombre de tokens de context . Per a un model dens típic de 64 capes amb GQA (8 caps KV, dimensió de cap 128), podeu estar parlant d'uns 256 KiB per token en f16. Això són uns 8 GB extra per a 32k tokens i 32 GB per a 128k. En altres paraules: el context gegant que veus a la fitxa del model (256K, 262K, 1M…) és un màxim teòric, no el que utilitzaràs en un portàtil sense despentinar-te.
Per això, quan es parla d' executar un 27B en un VPS sense GPU , s'insisteix molt en les xifres de RAM. Amb 32 GB de memòria total, un GGUF Q4 de 17 GB deixa marge per al sistema operatiu (aprox. 1,5 GB) i per a un context raonable (al voltant de 32k tokens en f16 o més si la memòria cau es manté en 8 bits). En 16 GB, directament no hi caben els pesos; i tirar de swap no soluciona res, perquè l'arxiu del model està mapejat en memòria i el nucli acabarà rellegint gigues del disc a cada token.
CPU pura, VPS i velocitat d'inferència
Si el teu portàtil no té GPU decent però sí molts gigues de RAM, pots intentar executar Qwen 2.5-27B només amb CPU . És el mateix que es planteja en parlar de Qwen 3.6/3.8:27B en un VPS, i els números són extrapolables.
La velocitat màxima teòrica la marca l' amplada de banda de memòria dividida per la mida dels pesos . Amb un fitxer de 17 GB en Q4, això significa que per cada token cal llegir 17 GB des de la RAM. En un VPS típic amb DDR4-3200 de doble canal, el sostre ronda els 3 tokens per segon, ia la pràctica et quedaràs a 2 tok/s. Amb DDR5-4800 de doble canal, el límit puja a uns 4,5 tok/s, quedant-te habitualment al voltant de 3 tok/s.
Això implica que una resposta de 500 tokens pot trigar entre dos i quatre minuts a CPU , sense comptar tokens de raonament ocults si el model “pensa en veu baixa”. Per a casos interactius tipus xat l'experiència és fluixa, però per a cues de treball (resumir documents durant la nit, etiquetar lots d'arxius, revisar codi en segon pla) pot ser més que suficient, sobretot si prioritzes privadesa i cost zero per token.
En un portàtil, la situació és semblant: si no hi ha GPU dedicada, el límit no és el nombre de nuclis sinó la rapidesa amb què la memòria pot alimentar el model . Afegir més fils de CPU arriba a un punt en què no ajuda, perquè els nuclis passen més temps esperant que arribi la informació de la RAM que processant. Per això, en runtimes com Ollama o llama.cpp és bona idea provar amb un nombre de fils igual als nuclis físics i després fins i tot la meitat, mesurant l'eval rate per veure on surt millor.
Quan té sentit estirar GPU en lloc de portàtil o VPS
Si necessites que Qwen 2.5-27B respongui amb facilitat en mode interactiu, llogar una GPU pot sortir més a compte que forçar un portàtil o un VPS de CPU gran. Una GPU de consum amb 24 GB de VRAM té, en teoria, un sostre proper a 59 tokens per segon per a un 27B a Q4. Les GPU de centre de dades actuals es poden anar cap als 197 tok/s.
A nivell de costos, un VPS amb 64 GB de RAM es factura totes les hores del mes , estigui o no el model carregat, mentre que una instància amb GPU al núvol només es paga per les hores que està encesa. Si el vostre ús real ronda un parell d'hores diàries, la GPU pot ser més ràpida i també més barata. On guanya clarament la CPU és en processos continus de baixa prioritat (per exemple, un servidor que està tot el dia resumint documents sense pressa).
Una estratègia mixta molt raonable és mantenir Qwen 27B en CPU per a treballs per lots al teu propi equip o VPS i, per a la part interactiva amb usuaris finals, fer servir un model allotjat via API (ja sigui Qwen a Alibaba Cloud, CometAPI o un altre proveïdor). Així no renuncies ni a privadesa ni a velocitat on importa.
Ollama, truca.cpp, LM Studio i execució de Qwen 27B en local
Si el que vols és tenir Qwen 2.5-27B “a mà” al teu portàtil per a proves, el més còmode és fer servir runtimes amb interfície senzilla com LM Studio (en escriptori) o Ollama (en terminal amb servidor HTTP inclòs) per a ús intern segur i eficient . La lògica amb qualsevol d'ells és semblant: instal·les l'eina, descarregues el model o crees la teva pròpia etiqueta i comences a enviar prompts.
A l'ecosistema Ollama, ara com ara no hi ha una etiqueta oficial qwen2.5:27b exactament amb aquest nom, però sí que hi ha variants molt properes com qwen3.5:27b o qwen3.6:27b , totes dues en Q4_K_M amb al voltant de 27,8B paràmetres. Per comprovar quina etiqueta tens, pots fer servir ollama show i revisar que la línia de paràmetres marqui 27.8B i la de quantització Q4_K_M. Si intenteu descarregar una etiqueta inexistent, veureu errors del tipus “pull model manifest: file does not exist”.
Un cop carregat el model, convé vigilar amb ordres com ollama ps i free -g quant ocupa en memòria (columna SIZE) i quin marge et queda per al context. Ajustar variables com OLLAMA_CONTEXT_LENGTH (context per defecte del servidor), num_ctx (context per petició), OLLAMA_KV_CACHE_TYPE=q8_0 (caché a 8 bits) i OLLAMA_NUM_PARALLEL=1 és clau perquè el teu portàtil.
Amb llama.cpp, la història és semblant, però amb més control fi a la línia d'ordres. Pots triar quantitzacions específiques (Q4_K_M, Q5_K_M, Q8_0, NF4, NVFP4, etc.) , jugar amb el nombre de fils, l'offload parcial a GPU, l'ús de flash attention i la mida de la memòria cau. LM Studio, per la seva banda, funciona com una capa més amigable sobre aquests motors: tries el model des d'una llista, es descarrega el GGUF adequat i defineix paràmetres des d'una interfície gràfica.
Quantització: per què Q4_K_M sol ser el punt dolç
La quantització és un dels punts on més embolic s'arma i més diferències reals hi ha entre setups. Comparar experiències sense dir quina quantització s'ha fet servir és, bàsicament, comparar models diferents. Per Qwen 27B en portàtils, Q4_K_M sol ser el compromís raonable entre qualitat, mida i velocitat.
En formats Q4_K_M, els pesos baixen a aquests ~17 GB per a un 27.8B, mentre que Q8_0 se'n va prop de 30 GB . En un entorn només CPU, això gairebé duplica el trànsit de memòria per token i redueix la velocitat a la meitat aproximadament. La millora de qualitat existeix, però per a la majoria de tasques habituals (xat tècnic, documentació, refactor de codi, resums) no compensa perdre la meitat del rendiment.
Estudis independents, per exemple comparacions de divergència KL (KLD) a Hugging Face, mostren diferències clares fins i tot entre dues quantitzacions sub‑2‑bit del mateix model , cosa que reforça la idea que l'elecció de format importa molt. Per això, quan llegeixis “a mi Qwen em va fatal” o “a mi em vola”, les preguntes obligades siguin: què quant ha fet servir, de quin repositori ha baixat el fitxer, amb quin runtime i amb quin context màxim.
Ús de Qwen 2.5-27B com a motor per a agents i programació
Un dels punts més interessants de Qwen 2.5 i els seus cosins de 27B és la seva capacitat per servir com a “cervell” dagents de codi i assistents avançats que corren directament al teu portàtil. Combinant-ho amb runtimes moderns (vLLM, SGLang, truca.cpp, Ollama) pots endollar-ho a agents com OpenCode, Pi, Claude Code o Hermes Agent.
Aquest tipus d'integracions permet fer coses com automatitzar tasques de programació (generar commits, crear suites de tests, aplicar refactors), executar ordres de terminal guiades pel model o coordinar fluxos de treball llargs en què el LLM ha de prendre decisions, trucar a eines externes i fer servir memòria a llarg termini.
A la pràctica, Qwen 27B brilla sobretot en tasques llargues i estructurades , on disposa de suficient context per anar iterant: muntar una aplicació des de zero, migrar un mòdul complex, revisar una base de codi àmplia o depurar bugs difícils amb accés a diverses rutes de codi i logs. Per als suggeriments dautocomplet en temps real, però, el límit de velocitat en CPU o en GPU modesta es nota molt més.
Si vols avaluar tu mateix si Qwen 2.5-27B val la pena davant d'una versió més petita o davant d'un altre model, una bona estratègia és seleccionar diverses tasques reals del teu propi repositori : una funcionalitat que toqui diversos fitxers, un bug especialment punyeter, una petita migració amb tests i una tasca que inclogui documentació o captures. Després, mesura quantes voltes de diàleg necessita, quants tokens totals consumeix i quant “soroll convincent” genera (respostes que semblen bones però estan malament).
Quan utilitzar Qwen 2.5-27B en un portàtil i quan no
Amb tot això, es pot dir que Qwen 2.5-27B val la pena en un portàtil si la teva màquina té memòria i/o GPU suficients i la teva prioritat és mantenir el control local del model. Si treballes amb codi sensible, dades regulades o documentació interna que no vols pujar al núvol, tenir un 27B multimodal de pesos oberts al teu equip és un salt enorme d'autonomia.
També té sentit si vols experimentar amb agents avançats sense dependre del temps de vida d'una API externa, o si t'interessa ajustar el model amb les dades (fine-tuning, LoRA, adaptadors) i reutilitzar-lo a les teves eines sense pagar per cada token. Per a usos educatius, recerca i projectes personals seriosos, disposar dun model daquesta mida en un portàtil obre moltes portes.
En canvi, potser no és la millor opció si el teu portàtil és modest, tens pressa o necessites resultats ultra reproduïbles . Els benchmarks grans de Qwen 2.5 segueixen sent, en bona part, avaluacions de proveïdor i la comunitat triga setmanes a estabilitzar plantilles, parsers i runtimes. Si el teu flux depèn de temps molt predictibles per tasca o de mètriques auditades al mil·límetre, potser et convingui esperar que hi hagi més comparatives independents o delegar la inferència al núvol.
Al final, executar Qwen 2.5-27B en un portàtil va d'equilibrar privadesa, cost i paciència . Amb el maquinari adequat, una quantització ben triada i un runtime configurat amb cap, es converteix en un assistent molt seriós per a programació, anàlisi de documents i agents complexos sense sortir de la teva màquina. Amb maquinari just o mala configuració, es transforma en un experiment lent i frustrant. La bona notícia és que avui ja tens totes les peces necessàries per muntar aquest escenari local potent, sempre que ajustaments expectatives i recursos a la realitat del que implica moure 27.000 milions de paràmetres des del teu escriptori.
