DeepSeek-V3.1 er en hybrid Mixture-of-Experts (MoE) chatmodell utgitt av DeepSeek i august 2025 som støtter to inferensmoduser — en rask «ikke-tenkende»-modus og en bevisst «tenkende»-modus — fra samme sjekkpunkt. Modellen er tilgjengelig på Hugging Face og kan kjøres lokalt via flere stier (vLLM, Ollama/llama.cpp, Ollama-stil GGUF-er eller storskala multi-GPU-oppsett). Nedenfor går jeg gjennom krav, hvordan tenkemodusen fungerer, flere lokale kjørealternativer (med kjørbare kodestykker) og en trinnvis «Tenkemodusdistribusjon»-oppskrift med eksempler på verktøykall og tokenmaler.
Hva er DeepSeek-V3.1, og hvorfor er det viktig?
DeepSeek-V3.1 er v3-familieoppdateringen fra DeepSeek som introduserer en hybrid inferensdesignden samme modellen kan kjøres i tenker (bevisst, flertrinns) eller ikke-tenkende (direkte svar, raskere) moduser ved å endre chatmalen. Arkitektonisk sett er det en stor MoE-familie (basissjekkpunkt rundt 671 milliarder totale parametere, ~37 milliarder aktivert per token) med langkonteksttrening utvidet til 128 8 tokener og støtte for FP3.1-mikroskalering. DeepSeek posisjonerte V1 som en agentklar utgivelse: bedre verktøykall, forbedrede agentferdigheter og høyere tenkeeffektivitet sammenlignet med tidligere R2025-utgivelser. Utgivelsen ble annonsert i august XNUMX og har blitt integrert i Hugging Face, CFD/OSS-verktøy og skydistribusjonsveiledninger.
Hvordan hybridmodellen fungerer (kortfattet)
- Ett kontrollpunkt, to maler: Tenknings- vs. ikke-tenkningsmoduser styres av chatmal og en
<think>/</think>tokenkonvensjonen i ledeteksten. Modellkortet dokumenterer de nøyaktige prefiksene. - Forbedringer av agenter/verktøy: Boosts etter trening muliggjør smartere verktøykall – modellen forventer et strengt JSON-format for verktøykall for sikker, deterministisk verktøyutførelse.
- Ytelsesavveininger: Tenkemodus bruker tokens på intern tankekjede-lignende resonnering og kan være tregere/mer tokenintensiv; ikke-tenking er raskere og billigere. Referanseverdier i modellkortet viser betydelige forbedringer på tvers av resonnering og kodereferanseverdier for V3.1.
Hvordan modellen er strukturert
- MoE-ryggrad: stort totalt antall parametere med et mindre aktivert delsett per token (økonomisk inferens).
- LangkonteksttreningV3.1 utvider langkontekstfaser betydelig (32k → større trening på lange dokumenter) for å støtte 128K+ vinduer i noen bygg.
- FP8 innebygd arbeidsflytDeepSeek bruker FP8-formater i stor grad (w8a8 / UE8M0) for vekt-/aktiveringseffektivitet; konverteringsskript fra fellesskapet finnes hvis du foretrekker BF16/FP16.
Hva er kravene for å kjøre DeepSeek-V3.1 lokalt? (Maskinvare, lagring og programvare)
Kjører fullt V3.1-modellen (ukvantisert) er et stort prosjekt. Nedenfor finner du realistiske kategorier av oppsett og hva de vanligvis krever.
Praktiske bøtter
- **Klynge / forskningslaboratorium (full modell)**flere GPU-er med høyt minne (H100/H800-klassen eller mange Ada/Hopper-GPU-er), multinode med titalls GPU-er, mye NVMe-lagring (hundrevis av GB) og spesialiserte inferensrammeverk (SGLang, vLLM, LMDeploy, TRT-LLM).
- **Enkeltserver-high-end (kvantisert)**mulig med kraftig kvantisering (INT4/AWQ/AWQ2/gguf) og rammeverk som Ollama (forhåndspakket) eller fellesskaps-GGUF-er – krever fortsatt ~titalls til hundrevis av GB GPU-RAM eller smart CPU+GPU-avlastning.
- Utvikler-laptop / utviklerboksikke gjennomførbart for full modell; bruk små destillerte/finjusterte varianter eller koble til lokal server/Ollama-instans.
Sjekkliste for maskinvare (praktisk)
- GPUFor reell inferensgjennomstrømning av full V3.1: multi-GPU-klynger (H100 / H800 / Ada Lovelace+). For FP8-kjøring trengs GPU-er med beregningskapasitet og driverstøtte.
- RAM og lagringForvent hundrevis av GB ledig diskplass for modellfilene (modellsidene viser noen hundre GB avhengig av format/kvantisering), pluss arbeidsplass for konverterte formater. Ollama-metadata viser et fotavtrykk på ~400 GB for en DeepSeek V3.1 Ollama-pakke i biblioteket.
- NetworkFor inferens med flere noder trenger du sammenkoblinger med lav latens (NVLink / InfiniBand) og orkestreringsverktøy for tensor-parallelle oppsett.
Programvare sjekkliste
- OSLinux anbefales for verktøy for fellesskapsslutning (DeepSeek-Infer-demoen viser Linux/Python).
- Python: 3.10+ (i mange DeepSeek-eksempler). Typiske pakkeversjoner er festet i repositoriet
requirements.txt. - Rammeverk og verktøy (velg én eller flere): SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM eller Ollama for enklere lokale installasjoner. Hver har instruksjoner og ulik støtte for presisjon/kvantisering.
Praktisk merknad: Hvis du bare har én forbruker-GPU (f.eks. 24–48 GB), vil du sannsynligvis bruke kvantiserte GGUF-er eller ekstern inferens. Hvis du har en arbeidsstasjon med >128 GB RAM pluss en GPU-klynge i H100/H200-klassen, kan du sikte mot FP8/FP16-inferens med høyere kvalitet med vLLM.
Hvordan kjører jeg DeepSeek-V3.1 lokalt?
Nedenfor finner du flere praktiske veier du kan bruke, fra den mest manuelle/fleksible til den enkleste veien for en enkelt utviklerboks. Jeg vil gi trinnvise veiledninger og kodeeksempler.
Alternativ A – Offisiell DeepSeek-Infer-demo (utviklings-/klyngesti)
Dette er repoets eksempel/demo for FP8/BF16-inferens. Bruk det hvis du planlegger flernode- eller ønsker å eksperimentere med den offisielle inferenskoden.
- Klon, klargjør miljø
git clone https://github.com/deepseek-ai/DeepSeek-V3.git
cd DeepSeek-V3/inference
# Create a dedicated venv / conda env
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
(Depot inference/requirements.txt lister opp festede fakkel-/triton-/transformatorversjoner anbefalt av teamet.)
- Last ned modellvekter
- Last ned fra siden for klemmende ansikt-modellen (
deepseek-ai/DeepSeek-V3.1) og plasser dem under/path/to/DeepSeek-V3Modellkortet og depotet viser begge de offisielle lagringslenkene for Hugging Face.
- Konverter vekter for demo
# example conversion command shown in the repo
python convert.py --hf-ckpt-path /path/to/DeepSeek-V3 --save-path /path/to/DeepSeek-V3-Demo --n-experts 256 --model-parallel 16
- Kjør interaktiv generering (distribuert)
torchrun --nnodes 2 --nproc-per-node 8 --node-rank $RANK --master-addr $ADDR \
generate.py --ckpt-path /path/to/DeepSeek-V3-Demo --config configs/config_671B.json \
--interactive --temperature 0.7 --max-new-tokens 200
Dette er det kanoniske eksemplet fra DeepSeek-repoet for kjøringer i klyngestil.
Alternativ B – vLLM (anbefales for serverdistribusjoner og OpenAI-kompatibelt API)
vLLM støtter DeepSeek i FP8/BF16-moduser og gir deg en OpenAI-kompatibel server. Det er en populær produksjonsvei for store modeller på grunn av minneoptimaliseringer og API-kompatibilitet.
Start en vLLM-server som henter modellen fra Hugging Face (eksempelmønster):
# this will download/serve the model (replace with exact model id if needed)
vllm serve deepseek-ai/DeepSeek-V3.1 --host 0.0.0.0 --port 8000
Be deretter om fullføringer med curl eller en OpenAI-kompatibel klient:
curl -s -X POST "http://localhost:8000/v1/completions" \
-H "Content-Type: application/json" \
-d '{"model":"DeepSeek-V3.1","prompt":"Explain the QuickSort algorithm", "max_tokens":200}'
vLLM-oppskrifter og -dokumentasjon inkluderer DeepSeek-eksempler og notater om FP8-kompatibilitet og parallellisme mellom flere GPU-er/pipeline-enheter. For tunge modeller trenger du fortsatt flere GPU-er eller en kvantisert variant.
Alternativ C — LMDeploy / SGLang / LightLLM og TensorRT-LLM (høy ytelse)
DeepSeek-depotet anbefaler eksplisitt SGLang, LMDeployog TensorRT-LLM som optimaliserte motorer for DeepSeek V3. De gir forbedret inferensforsinkelse, gjennomstrømning og FP8-kjerner.
En typisk LMDeploy-påkalling (se LMDeploy-dokumentasjonen for nøyaktig CLI):
# pseudo-example; refer to LMDeploy docs for exact options
lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080
SGLang-benchmarks og lanseringsoppskrifter er tilgjengelige i repoet og i SGLang-prosjektets benchmark/deepseek_v3 mappe. Bruk disse stablene når du kontrollerer en GPU-klynge og ønsker produksjonsgjennomstrømning.
Alternativ D – Ollama (den enkleste lokale utviklingsruten, ofte én maskin)
Hvis du vil ha den lavest mulige friksjonsmåten for å kjøre DeepSeek lokalt (og du kan spare disken), Ollama tilbyr pakkede modeller og et enkelt CLI (ollama pull, ollama runDeepSeek-V3.1 finnes i Ollama-biblioteket og kan kjøres lokalt (Ollama kan kreve en nyere/forhåndsversjon for enkelte funksjoner).
Eksempel (Ollama CLI):
# Pull the model (downloads the model artifacts to your disk)
ollama pull deepseek-v3.1
# Start an interactive session:
ollama run deepseek-v3.1
# Or run as a local API server (Ollama supports a local API)
# Example: POSTing to Ollama's local API (adjust host/port to your setup)
curl -X POST http://localhost:11434/api/generate \
-H 'Content-Type: application/json' \
-d '{"model":"deepseek-v3.1","prompt":"Summarize the following paper: ..."}'
Ollama abstraherer mange distribusjons-/kvantiseringsdetaljer og kan være en fin måte å teste modelloppførsel på en enkelt vert. Merk: modellsiden viser en pakket størrelse på ~404 GB for Ollama-oppføringen, så planlegg disk og RAM deretter.
Hva er tenkemodus og hvordan bruker man den
DeepSeek-V3.1 implementerer en hybrid tenkningstoken tilnærming: samme kontrollpunkt kan kjøre inn tenker modus (interne «tankekjede»-tokens) eller ikke-tenkende modus ved å bytte chat-/ledetekstmal. Modellen bruker eksplisitte tokener som <think> (og lukking </think> (i noen maler) for å signalisere intern tankekjede kontra direkte svargenerering. Modellkortet dokumenterer prefikser for ikke-tenkning og tenkning og viser hvordan maler er forskjellige.
Eksempel: konstruere en melding i Python (tokenizer-hjelper)
Modellkortet for klemfjes inneholder et nyttig utdrag som viser hvordan du bruker chatmalen via tokenizeren. Dette er det anbefalte mønsteret for generering. tenker or ikke-tenkende formaterte ledetekster:
import transformers
tokenizer = transformers.AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")
messages = [
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "Who are you?"},
{"role": "assistant", "content": "<think>Hmm</think>I am DeepSeek"},
{"role": "user", "content": "1+1=?"}
]
# Thinking mode
tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)
# Non-thinking mode
tokenizer.apply_chat_template(messages, tokenize=False, thinking=False, add_generation_prompt=True)
Bytte om thinking=True å lage en ledetekst som bruker <think> prefiks; thinking=False produserer den ikke-tenkende malen. Modellen vil oppføre seg annerledes (intern overveielse kontra umiddelbar respons) avhengig av dette flagget.
Hurtigreferanse – liten feilsøking og beste praksis
Hvis du går tom for GPU-minne: Prøv kvantiserte bygg (AWQ/q4/INT4) eller fellesskaps-GGUF-er; mange fellesskapsområder publiserer kvantiseringer for lokal bruk. Ollama / vLLM kan også betjene mindre kvantiserte bygg.
Hvis du trenger at modellen skal kalle eksterne verktøy: Vedta Verktøyanrop skjemaet i chatmalen nøyaktig. Test verktøyets JSON-format offline og sjekk at orkestreringskoden din (delen som kjører verktøyet) returnerer renset, skrevet JSON tilbake til modellen.
Hvis du trenger lang kontekst: Bruk vLLM eller SGLang med plugins for lang kontekst; DeepSeek ble eksplisitt trent/utvidet for 32K/128K kontekster, og relatert verktøy støtter det vinduet. Forvent minneavveininger.
Kan jeg faktisk kjøre DeepSeek-V3.1 på en bærbar PC eller en liten server?
Kort svar: Ja, men med forbehold. Fellesskapskvantiseringer (AWQ/GGUF/1-bit dynamic) reduserer lagrings- og minneforbruket drastisk og har gjort det mulig for hobbybrukere å kjøre V3.1-varianter på avanserte stasjonære datamaskiner (påstander om ~170 GB arbeidssett). Imidlertid:
- Avveining mellom kvalitet og størrelse: Aggressiv kvantisering reduserer minne, men kan påvirke resonnement/kodeytelse. Test på arbeidsbelastningene dine.
- Juridisk og lisensiering: Modellen er MIT-lisensiert i henhold til modellkortet, men tredjeparts kvantiseringer kan ha sine egne lisenser; gjennomgå dem før produksjonsbruk.
Siste ord
DeepSeek-V3.1 er et betydelig skritt mot hybride «agent»-modeller med eksplisitt tenkende/ikke-tenkende atferd og forbedret verktøybruk. Hvis du vil kjøre det lokalt, velg en bane som samsvarer med maskinvaren og risikotoleransen din:
For forskning: transformers + kvantiserte sikkerhetstenors og akselerer.
For produksjon og gjennomstrømning: vLLM + multi-GPU (H100/H200).
For lokale eksperimenter: Ollama/llama.cpp + fellesskaps-GGUF-er (slå sammen + kjør).
Komme i gang
CometAPI er en enhetlig API-plattform som samler over 500 AI-modeller fra ledende leverandører – som OpenAIs GPT-serie, Googles Gemini, Anthropics Claude, Midjourney, Suno og flere – i ett enkelt, utviklervennlig grensesnitt. Ved å tilby konsistent autentisering, forespørselsformatering og svarhåndtering, forenkler CometAPI dramatisk integreringen av AI-funksjoner i applikasjonene dine. Enten du bygger chatboter, bildegeneratorer, musikkomponister eller datadrevne analysepipeliner, lar CometAPI deg iterere raskere, kontrollere kostnader og forbli leverandøruavhengig – alt samtidig som du utnytter de nyeste gjennombruddene på tvers av AI-økosystemet.
Utviklere har tilgang DeepSeek-V3.1 Gjennom CometAPI er de nyeste modellversjonene som er oppført per artikkelens publiseringsdato. For å begynne, utforsk modellens muligheter i lekeplass og konsulter API-veiledning for detaljerte instruksjoner. Før du får tilgang, må du sørge for at du har logget inn på CometAPI og fått API-nøkkelen. CometAPI tilby en pris som er langt lavere enn den offisielle prisen for å hjelpe deg med å integrere.