Scegli il tuo piano
Blog deepseek v4
Come eseguire localmente DeepSeek-V4.1-Flash?
Di seguito trovi un percorso pratico per eseguire localmente DeepSeek‑V4.1‑Flash con vLLM, con indicazioni su requisiti GPU, checkpoint da 511 GB, comandi di setup, alternative con SGLang e Ollama, oltre a opzioni API. Panoramica e requisiti - Dimensione checkpoint: ~511 GB su disco (BF16/FP16). Prevedi spazio NVMe ≥ 1 TB per margine di sicurezza (cache, shard temporanei e quantizzati). - RAM: consigliati ≥ 128 GB per download/estrazione e caching. - GPU: inferenza in BF16 tipicamente richiede 8×80 GB (A100/H100) con tensor parallel (TP=8). Stima VRAM per GPU ≈ 511/TP + overhead (KV cache, attivazioni, frammentazione). Con quantizzazione potresti ridurre il fabbisogno (vedi sotto). - Driver/toolchain: NVIDIA driver recente, CUDA 12.x compatibile, NCCL, Python 3.10+. - Rete: consigliata connessione stabile e veloce; per Hugging Face attiva trasferimento ottimizzato. Setup di base 1) Ambiente pip install --upgrade "vllm>=0.5.0" "torch>=2.2" huggingface_hub 2) Accesso/trasferimento (opzionale ma consigliato) huggingface-cli login export HF_HUB_ENABLE_HF_TRANSFER=1 3) Pre‑download (facoltativo; vLLM scarica anche “on demand”) huggingface-cli download --local-dir /models/ --local-dir-use-symlinks False Avvio con vLLM (serving OpenAI‑compatible) - Esecuzione BF16 su 8×80 GB (esempio): vllm serve \ --tensor-parallel-size 8 \ --dtype bfloat16 \ --max-model-len 32768 \ --gpu-memory-utilization 0.90 \ --host 0.0.0.0 --port 8000 \ --download-dir /models - Note: - Sostituisci con l’ID effettivo del checkpoint. - Adatta --tensor-parallel-size al numero di GPU disponibili. - --gpu-memory-utilization controlla quanto VRAM usare; riduci se incontri OOM. - Se disponi di una variante quantizzata supportata da vLLM (es. AWQ/GPTQ), aggiungi: --quantization awq oppure --quantization gptq. In tal caso la VRAM richiesta si riduce sensibilmente. - Per contesti molto lunghi aumenta --max-model-len ma ricorda che la KV cache cresce in modo quasi lineare con la lunghezza di contesto. Client verso vLLM - cURL (OpenAI‑compatible): curl -X POST http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" -H "Authorization: Bearer dummy" \ -d '{ "model": "", "messages": [{"role": "user", "content": "Ciao!"}], "temperature": 0.7 }' - Python (SDK OpenAI puntato al tuo endpoint): pip install openai python -c ' from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy") resp = client.chat.completions.create( model="", messages=[{"role":"user","content":"Ciao!"}] ) print(resp.choices[0].message.content) ' SGLang (alternativa di serving ad alte prestazioni) 1) Installazione pip install "sglang>=0.2" 2) Avvio server (TP=8 su 8 GPU, BF16) python -m sglang.launch_server \ --model \ --tp 8 \ --dtype bf16 \ --port 30000 \ --host 0.0.0.0 3) Chiamata API (OpenAI‑compatible) curl -X POST http://localhost:30000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "", "messages": [{"role":"user","content":"Ciao!"}], "temperature": 0.7 }' Ollama (quando ha senso e limiti) - Ollama si basa su formati GGUF (runtime llama.cpp). Per modelli di dimensioni ~511 GB BF16, l’uso pratico via Ollama è improbabile a meno di disporre di una conversione GGUF fortemente quantizzata che rientri nei tuoi limiti di VRAM/RAM. Verifica prima l’esistenza di una build GGUF affidabile del modello. - Se esiste una GGUF adatta: - Crea un Modelfile che punti al .gguf e ai metadati richiesti da Ollama. - Crea e avvia: ollama create deepseek-v4.1-flash -f Modelfile ollama run deepseek-v4.1-flash - In assenza di una GGUF ufficiale/ottimizzata, preferisci vLLM o SGLang. Pianificazione memoria e quantizzazione - Stima VRAM per GPU: circa (511 GB / TP) + overhead. Con TP=8: ~64 GB per i pesi/gpu + 5‑15 GB tipici per KV cache/overhead a contesto moderato; 8×80 GB è una configurazione realistica. - KV cache cresce con max context, batch e numero layer. Se incontri OOM: - riduci --max-model-len - riduci batch/concurrency - aumenta TP - attiva una variante quantizzata supportata. - Varianti quantizzate (se disponibili): - AWQ/GPTQ: riducono VRAM e spesso permettono TP più basso o GPU meno capienti. - FP8/Half‑NR (se supportate dalla release): possono dimezzare circa il footprint dei pesi su H100, mantenendo buona qualità. Prestazioni e sistema - Disco: usa NVMe PCIe 4/5; imposta --download-dir su NVMe locale. - Multi‑GPU: preferisci nodi con NVLink/NVSwitch. Per multi‑nodo servono interconnessioni ad alta banda e configurazione NCCL adeguata. - Driver/CUDA/NCCL coerenti su tutte le GPU. Mantieni il raffreddamento adeguato. Alternative API gestite - Se non vuoi gestire 511 GB localmente: - API ufficiale di DeepSeek (se disponibile per V4.1‑Flash). - Provider terzi con endpoint OpenAI‑compatible (es. Together AI, Fireworks, Replicate). Verifica disponibilità del modello specifico e la politica di pricing/limiti. - Esempio generico (OpenAI SDK con provider esterno): from openai import OpenAI client = OpenAI(base_url="/v1", api_key="") resp = client.chat.completions.create( model="", messages=[{"role":"user","content":"Ciao!"}] ) Checklist rapida - Conferma l’ID esatto del repository del modello e il formato (BF16/FP16/quantizzato). - Assicurati di avere ≥ 1 TB NVMe, ≥ 128 GB RAM, e almeno 8×80 GB GPU per BF16. - Installa vLLM e avvia con --tensor-parallel-size adeguato; testa con contesti corti, poi aumenta. - Se possibile, usa una variante quantizzata supportata per ridurre i requisiti. - In alternativa, valuta SGLang per il serving o provider API esterni.
DeepSeek V4.1 Flash vs V4 Pro: prestazioni, prezzi e guida alla migrazione
请提供需要翻译的原文，或确认是否需要我直接用意大利语撰写“DeepSeek V4.1 Flash 与 V4 Pro 在架构、官方基准、API 价格、视觉、并发与迁移选择方面的比较”。
Prezzi dell'API DeepSeek: V4 Pro vs. V4.1 Flash
I don’t have live access to DeepSeek’s current pricing. If you paste the latest pricing table or link (and your region/tenant), I’ll produce a precise side‑by‑side with totals for your workloads. In the meantime, use this checklist and cost formula to plug in the numbers. What to collect for each model - Model name - Model ID (exact string from console) - Context window and output limits - Peak input price per 1K tokens - Peak output price per 1K tokens - Off‑peak input price per 1K tokens - Off‑peak output price per 1K tokens - Cache write price per 1K tokens - Cache read/reuse price or discount (or percentage saving) - Off‑peak window definition and multiplier (e.g., 0.5×) - Minimum billable unit and rounding rules (per 1K tokens, per request, etc.) - Any caps, burst limits, or dedicated lane pricing Cost model (drop in your rates) - Let: - Tin = prompt tokens per request - Tout = completion tokens per request - cw = cacheable prompt tokens per request - h = cache hit rate (0–1) - fop = fraction of calls in off‑peak (0–1) - Pin_peak, Pout_peak = peak prices per 1K (input/output) - Pin_off, Pout_off = off‑peak prices per 1K (input/output) - Pcw = cache write price per 1K - Pcr = cache read price per 1K (or compute via discount) - Billable token blocks (apply your provider’s rounding): - kin = ceil(Tin/1000) - kout = ceil(Tout/1000) - kcw = ceil(cw/1000) - kcr = ceil((h·cw)/1000) - Split traffic by peak/off‑peak: - Peak share = (1 − fop), Off‑peak share = fop - Per‑request expected cost: - Input cost = [(1 − fop)·kin·Pin_peak + fop·kin·Pin_off] - Output cost = [(1 − fop)·kout·Pout_peak + fop·kout·Pout_off] - Cache write cost = kcw·Pcw on first use (or amortize over N reuses) - Cache read cost (on hits) = kcr·Pcr - Cache savings versus no cache = kcr·(Pin_effective − Pcr), where Pin_effective is the weighted input price across peak/off‑peak - Total per request = Input cost + Output cost + Cache write cost + Cache read cost - Amortizing cache writes: - If a cached segment is reused R times, amortized cache write per use = (kcw·Pcw)/R - Replace Cache write cost with this amortized term for steady‑state workloads Example worksheet (fill in your numbers) - Workload: Tin=1,500; Tout=900; cw=1,000; h=0.6; fop=0.35 - Prices: Pin_peak=?, Pout_peak=?, Pin_off=?, Pout_off=?, Pcw=?, Pcr=? - Compute kin=2, kout=1, kcw=1, kcr=1 - Plug into formulas to get per‑request cost; multiply by QPS×duration for monthly totals Real‑world considerations - Token drift: measure Tin/Tout from real logs; don’t rely on averages alone - Rounding: per‑1K rounding can materially change totals on small prompts - Cache eviction: apply an effective hit rate after TTL/eviction - Retries/timeouts: include retry factor in Tin/Tout and cache hits - Off‑peak definition: confirm exact windows and whether weekend rules differ Share your current V4 Pro and V4.1 Flash pricing (including peak/off‑peak and cache rates) and a sample workload, and I’ll return a concrete comparison with total and per‑request costs.
DeepSeek V4 Flash Vision: che cos'è e come usarlo
Scopri che cos'è DeepSeek V4 Flash Vision, comprendi le attuali limitazioni per le immagini e le tariffe e utilizza l'endpoint di DeepSeek o CometAPI tramite codice.
I migliori LLM a pesi aperti e cinesi per la programmazione e il ragionamento
Confronta DeepSeek V4.1 Flash, Kimi K3, Qwen3.8-Max e GLM 5.3 utilizzando benchmark di programmazione, ragionamento e per agenti, quindi testali tramite un'unica integrazione con CometAPI.
Come utilizzare l'API DeepSeek V4.1 Flash
Come utilizzare l'API DeepSeek V4.1 Flash con CometAPI utilizzando cURL, Python e JavaScript. Esplorare la modalità di ragionamento, l'input, lo streaming e le pratiche di produzione.
Che cos'è DeepSeek V4.1 Flash? Architettura, funzionalità e prezzi
DeepSeek V4.1 Flash spiegato: MoE da 552B con Encoder-Decoder Causale, risparmi della cache KV, benchmark, prezzi dell'API, visione nativa e confronto tra V4 Flash e V4 Pro.
DeepSeek-V4-Flash vs GLM-5.3-Flash: Qual è il migliore
Utilizza DeepSeek-V4-Flash per l'automazione testuale rapida. Scegli GLM-5.3-Flash per agenti multimodali e hosting privato. Entrambi i modelli sono con licenza MIT.