Qwen3.8-27B med Unsloth: Kör, kvantisera eller finjustera den lokalt

Ja — Unsloth kör Qwen3.8 27B, och det är det snabbaste sättet att få Ali​babas nya Apache-2.0-modell till din egen GPU. Hela svaret på en rad: öppna Unsloth Studio, sök på "Qwen3.8 27B", välj UD-Q4_K_XL (17,9 GB) på ett 24 GB-kort och chatta på under en minut. Bakom det klicket släppte Unsloth tre saker samma vecka som vikterna kom ut (13–14 augusti 2026): unsloth/Qwen3.8-27B-GGUF-paketet byggt på Unsloth Dynamic V3.0 (förhandsversion) kvantisering, fullt stöd i Unsloth Studio och Desktop, samt v0.1.800-beta-versionen med GGUF-export, imatrix-detektering och förbättrad VRAM-anpassning. Den finjusterar också modellen — Unsloths påstående är 2× snabbare träning med 70 % mindre VRAM. Qwen3.8 27B är en tät vision-språkmodell med 27 miljarder parametrar vars hybriduppmärksamhet bara behåller 16 av 64 lager i full uppmärksamhet, vilket är anledningen till att en 4-bitars fil får plats på kort där de flesta 27B-modeller inte gör det.

Angående källor: modellfakta är officiella, hämtade från modellkortet för Qwen3.8 27B på Hugging Face, verifierade den 15 augusti 2026. Unsloth-stödet, kvantiseringsstorlekarna, VRAM-kraven och installationskommandona kommer från Unsloths versionsanteckningar och dokumentation, samma dag. API-priset hämtas live från OrcaRouters katalog, samma dag. Unsloths "2× snabbare, 70 % mindre VRAM" och "den överlägset starkaste modellen för sin storlek" är leverantörspåståenden, inte oberoende verifierade.

Vad "Qwen3.8 + Unsloth" betyder: fyra olika saker

Unsloth är fyra separata saker, och nyckelordssökresultaten blandar ihop dem. Att veta vilken du behöver är halva installationen:

• unsloth/Qwen3.8-27B-GGUF — de kvantiserade viktfilerna på Hugging Face, 21 kvantiseringar plus en visionsprojektor. Byggd med Dynamic V3.0 (förhandsversion), inte den äldre Dynamic 2.0 (som tillkännagavs den 24 april 2025 och föregår denna modell). Detta är "ladda ner en fil"-vägen, användbar från vilket llama.cpp-bygge som helst.

• Unsloth Studio — webbläsarappen som du installerar eller kör från en Hugging Face Space. Sök i modellhubben, klicka på en kvant, chatta med verktyg. Ingen manuell mall- eller inferensparameterkonfiguration.

• Unsloth Desktop — den lokala GUI-appen för macOS, Windows och Linux som kombinerar Studio och träning. Det är här som fine-tuning med "2× snabbare med 70% mindre VRAM" sker.

• Python-biblioteket unsloth — från unsloth import FastLanguageModel, QLoRA-fine-tuning-API:t som används i notebooks och skript.

Unsloths versionsinformation för v0.1.800-beta, med titeln "Release Qwen3.8 27B", säger att Qwen3.8 27B och den 2,4 biljoner parametrar stora Qwen3.8-2.4T-A95B "nu kan köras lokalt i Unsloth", att 27B "körs på 17 GB RAM via Unsloth Dynamic GGUFs" och att "du också kan finjustera Qwen3.8 27B i Unsloth." Samma version lägger till NVFP4-kvantiseringar, kontrollerar diskutrymme före GGUF-exporter, upptäcker riktigt GGUF-imatrix-stöd i Studio och gör inferens upp till 10 % snabbare på GGUF med en justerbar VRAM-gräns.

Välj din quant utifrån VRAM, inte utifrån vibbar.

Unsloths minnestabell är i totalt RAM plus VRAM (eller enhetligt minne), och det är den officiella vägledningen. En 4-bitars Qwen3.8 27B behöver 17–19GB; ett 24GB RTX 4090, RTX 5080, eller en 24GB Mac med enhetligt minne är det realistiska golvet för en bekväm 4-bitars installation. De tre val som täcker nästan alla:

• 12GB → UD-IQ2_XXS vid 9.0GB — den enda filen som får plats i sin helhet; förvänta dig synlig kvalitetsförlust. Gör detta val medvetet.

• 16GB → UD-Q3_K_XL på 13,4GB — den bästa 3-bitarsfilen, enligt Unsloths egen väljare.

• 24GB → UD-Q4_K_XL at 17.9GB — den rekommenderade 4-bitarsfilen och standardsvaret i den här artikeln.

• 48–64GB → UD-Q8_K_XL vid 31.5GB — nära förlustfritt på en arbetsstation eller i en dubbel-GPU-installation.

Hela stegen, från unsloth/Qwen3.8-27B-GGUF-fillistan och Unsloths dokumentation, båda verifierade den 15 augusti 2026: UD-Q8_K_XL 31,5 GB, UD-Q6_K_XL 25,9 GB, UD-Q5_K_XL 20,2 GB, UD-Q4_K_XL 17,9 GB, UD-Q3_K_XL 13,4 GB, UD-Q2_K_XL 10,7 GB, UD-IQ3_XXS 11,9 GB, UD-IQ2_M 10,3 GB, UD-IQ2_XXS 9,0 GB. Vanliga K-quants (Q4_K_M 17,1 GB, Q8_0 29,0 GB) finns också där, och paketet levereras med en vision-projektor (mmproj-BF16, 931 MB) så att bilder och video fungerar om du laddar in den. Unsloth kallar hela stegen för "Dynamic V3.0 (preview)" — nyare än Dynamic 2.0 som du kommer att se i äldre skrifter, vilken byggdes för modeller som släpptes över ett år tidigare.

Kör det med Unsloth på tre minuter.

Ett klick-rutt: på macOS eller Linux, curl -fsSL https://unsloth.ai/install.sh | sh, sedan unsloth studio -p 8888 och öppna http://127.0.0.1:8888. På Windows, irm https://unsloth.ai/install.ps1 | iex. Om du vill slippa installation helt och hållet är Unsloths Studio också publicerat som en Hugging Face Space — öppna den i en webbläsare, sök efter "Qwen3.8 27B" och välj en kvantisering utifrån hur mycket minne du har. Studio justerar automatiskt samplingsparametrar och chattmall, lastar över till RAM när VRAM tar slut och upptäcker multi-GPU-konfigurationer — "ingen konfiguration"-delen är på riktigt, och det är det snabbaste sättet att köra veckans modell.

Fil-först-vägen, om du redan använder llama.cpp: ladda ner en quant och kör den direkt. Det här är Unsloths egna kommandon, verifierade mot deras dokumentation:

hf download unsloth/Qwen3.8-27B-GGUF --local-dir unsloth/Qwen3.8-27B-GGUF --include "*UD-Q4_K_XL*"

./llama.cpp/llama-cli --model unsloth/Qwen3.8-27B-GGUF/Qwen3.8-27B-UD-Q4_K_XL.gguf --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0.0

Dessa samplingsvärden är modellkortets rekommenderade inställningar för tankeläge. Byt ut --include-globen mot *UD-Q3_K_XL* på ett 16GB-kort, och lägg till --mmproj som pekar på paketets mmproj-BF16.gguf om du behöver bildigenkänning. En fallgrop: llama.cpp måste vara en aktuell build — filen registrerar den nya qwen35-arkitekturen, och allt från före releaseveckan vägrar att ladda den.

Finjustera den med Unsloth

Fine-tuning är där Unsloth förtjänar sitt rykte: biblioteket hävdar 2× snabbare träning med 70% mindre VRAM jämfört med standard Transformers + PEFT, vilket är det som gör QLoRA på en 27B genomförbart på ett enda konsumentgrafikkort. Ingångspunkten för fine-tuning är det vanliga unsloth/Qwen3.8-27Brepositoryt (safetensors, 28B-filsidan) snarare än GGUF-paketet. Standardmönstret för Unsloth QLoRA, tillämpat på denna modell:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained("unsloth/Qwen3.8-27B", max_seq_length=8192, load_in_4bit=True)

model = FastLanguageModel.get_peft_model(model, r=16)

Sedan en standard trl.SFTTrainer-loop på ditt dataset. Det utdraget är det vanliga QLoRA-mönstret från Unsloths dokumentation — påståendena om träningsprestanda är Unsloths egna och inte något jag har reproducerat — och två varningar gäller: Unsloths kärnor modifierar text-transformatorlagren, så planera att hantera vision-encodern separat, och håll unsloth-paketet på den aktuella versionen eftersom arkitekturen bara är några dagar gammal och versionsskillnader misslyckas högljutt.

Vad Unsloth Studio hanterar åt dig

Att köra en GGUF manuellt innebär att balansera kontextstorlek, RAM-avlastning och verktygsanrop. Studio förenklar detta till standardinställningar: det anpassar kontextstorleken efter det minne som faktiskt är fritt, avlastar inaktiva visionsmodeller för att frigöra VRAM för chatt eller träning, identifierar multi-GPU-konfigurationer och kopplar upp webbsökning, kodkörning och agentanslutningar (Claude Code, Codex, MCP) direkt ur lådan. v0.1.800-beta-versionen skärpte också de delar som svider i praktiken: GGUF-exporter kontrollerar nu diskutrymme innan en lång sammanslagning påbörjas, istället för att misslyckas halvvägs, Studio identifierar om den GGUF som exporteras faktiskt stöder imatrix (så att du inte slösar en körning), och minnesskydden överreserverar inte längre GPU-minne. För en modell som bara är tre dagar gammal gör "no-config" ett verkligt jobb.

Gratis lokalt vs betalt API: den ärliga ekonomin

Kärnskillnaden mellan Unsloth och ett API är inte kvalitet – det är vem som äger hårdvaran. Unsloth är den kostnadsfria vägen: noll marginalkostnad per token, ingenting lämnar din maskin, inga hastighetsbegränsningar och full kontroll över vikterna. Det är inte gratis i absoluta tal: du står för GPU:n och elen, och en 2-bitars fil på ett 12 GB-kort är en kompromissad upplevelse. Qwen3.8 27B är tät och bildkapabel, så vid 4-bitars blir det 17,9 GB vikter innan kontexten; maskinen är inträdespriset.

API-vägen finns eftersom vikterna är Apache-2.0, så vem som helst kan vara värd för dem till en marginalkostnad nära noll. Qwen3.8 27B finns i OrcaRouters katalog idag till $0.33 per miljon input-tokens och $2.40 per miljon output, modellen är självhostad på vår egen infrastruktur — inget leverantörspris att lägga på — med ett kontextfönster på 262K tokens och stöd för text-, bild- och videoinmatning. Eftersom vikterna är öppna finns det också en hastighetsbegränsad gratisnivå som kostar $0 per förfrågan. En representativ månad med 10 miljoner tokens och en inmatningsandel på 70 % landar på ungefär $9.51 på den betalda nivån. Om du redan äger ett 24GB-kort är lokalt billigare; om du inte gör det, är det bättre att hyra tokens till det priset än att köpa ett kort för ett sidoprojekt, och gratisnivån är det ärliga sättet att testa modellen innan du bestämmer dig för någon hårdvara.

När Unsloth är fel svar

Unsloth Studio och GGUF-paketet är rätt val för en enskild maskin. De är fel val när:

• Du äger ett Blackwell RTX 50-serie-kort. De kvantiserade versionerna av unsloth/Qwen3.8-27B-NVFP4 är ungefär 1,5× snabbare än BF16 i samma VRAM och använder en FP8 KV-cache för längre kontext. Den vägen går genom vLLM eller SGLang, inte en GGUF och inte Studio.

• Du behöver det fulla nativa 262K-fönstret eller 1M YaRN-tillägget i produktion. En tät visionmodell med lång kontext är tung; Unsloths kontextstorlek kör gärna kortare för dig, men en serveringsstack med ordentlig KV-hantering slår en lokal app.

• Du betjänar många användare. Unsloth är en lokal app och ett finjusteringsbibliotek, inte en multi-tenant-server. För samtidighet, autoskalning och upptidsgarantier vill du ha en värdbaserad slutpunkt.

• Du har ingen GPU alls. Ett ärligt svar: en 2-bitars 27B på ett 12GB-kort är märkbart sämre än samma modell som serveras korrekt. Använd den kostnadsfria API-nivån först; om den är tillräckligt bra, köp hårdvara när användningsfallet är bevisat.

• Du vill finjustera visionssidan. Unsloths snabbningar riktar sig mot texttransformatorlagren; en fullständig multimodal finjustering kräver en annan stack.

Slutsats

Qwen3.8 27B med Unsloth är ett löst problem från och med den här veckan: installera Studio, välj UD-Q4_K_XL för ett 24GB-kort (UD-Q3_K_XL för 16GB, UD-IQ2_XXS för 12GB), och modellen körs utan konfiguration och utan kostnad per token. Fine-tuning-vägen är verklig och Unsloths hastighetspåståenden är anledningen till att 27B QLoRA är praktiskt på ett enda kort. Tänk på att kvantiseringsstegen är Dynamic V3.0 (förhandsversion), inte Dynamic 2.0 som äldre artiklar beskriver; håll llama.cpp uppdaterat; och om du inte äger hårdvaran är samma vikter ett API för $0.33/$2.40 med en gratis hastighetsbegränsad nivå — så det finns ingen anledning att köra en 2-bitars fil du inte är nöjd med. Lokalt är den gratis vägen, och för första gången i den här viktklassen är det också den enkla vägen.