开源大模型本地部署实战：从Qwen3.8到14MB微型模型的完整部署指南

# 安装Ollama（Linux/macOS）
curl -fsSL https://ollama.com/install.sh | sh

# Windows用户从官网下载安装包
# https://ollama.com/download/windows

# 验证安装
ollama --version
# Ollama version 0.5.x

# 拉取Qwen3.8-27B（自动选择合适的量化版本）
ollama pull qwen3.8:27b

# 查看已下载的模型
ollama list

# 交互式运行
ollama run qwen3.8:27b
>>> 你好，请介绍一下你自己

import requests

# Ollama兼容OpenAI API格式
url = "http://localhost:11434/v1/chat/completions"
headers = {"Content-Type": "application/json"}
payload = {
    "model": "qwen3.8:27b",
    "messages": [
        {"role": "system", "content": "你是一个专业的Python开发者。"},
        {"role": "user", "content": "写一个异步爬虫，抓取网页标题和meta描述"}
    ],
    "temperature": 0.7,
    "max_tokens": 2000,
    "stream": False
}

response = requests.post(url, json=payload, headers=headers)
result = response.json()
print(result["choices"][0]["message"]["content"])

# Modelfile — 自定义Qwen3.8配置
FROM qwen3.8:27b

# 系统提示词
SYSTEM '''你是一个专业的全栈开发助手，擅长Python、TypeScript和Rust。
请提供简洁、准确、包含代码示例的回答。'''

# 调整生成参数
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 32768
PARAMETER num_gpu 99

# 停止词
PARAMETER stop "</s>"
PARAMETER stop "<|im_end|>"

# 构建自定义模型
ollama create my-qwen38 -f Modelfile

# 运行自定义模型
ollama run my-qwen38

# 创建Python虚拟环境
python -m venv vllm_env
source vllm_env/bin/activate

# 安装vLLM（需要CUDA 12.0+）
pip install vllm

# 验证GPU
python -c "import torch; print(torch.cuda.get_device_properties(0))"

# 启动vLLM服务器
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen3.8-27B \
  --quantization awq \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.9 \
  --max-model-len 32768 \
  --port 8000

from openai import OpenAI

# 连接本地vLLM服务器
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM默认不验证API key
)

# 对话补全
response = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=[
        {"role": "system", "content": "你是一个技术写作专家。"},
        {"role": "user", "content": "写一篇关于Rust在前端工具链中应用的技术博客大纲"}
    ],
    temperature=0.7,
    max_tokens=3000,
)
print(response.choices[0].message.content)

# 流式输出
print("
--- 流式输出 ---")
stream = client.chat.completions.create(
    model="Qwen/Qwen3.8-27B",
    messages=[{"role": "user", "content": "用Rust写一个简单的HTTP服务器"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import asyncio
from vllm import LLM, SamplingParams

async def batch_inference():
    llm = LLM(
        model="Qwen/Qwen3.8-27B",
        quantization="awq",
        gpu_memory_utilization=0.9,
    )

    # 批量提示词
    prompts = [
        "解释React Compiler的工作原理",
        "比较Rust和Go在系统编程中的优劣",
        "写一个Cloudflare Workers的API示例",
        "分析Transformer架构的注意力机制",
        "设计一个分布式缓存的架构方案",
    ] * 20  # 100个请求

    sampling_params = SamplingParams(
        temperature=0.7,
        max_tokens=1024,
    )

    # vLLM会自动批处理这些请求
    outputs = llm.generate(prompts, sampling_params)

    total_tokens = sum(len(o.outputs[0].token_ids) for o in outputs)
    print(f"生成 {len(outputs)} 条回复，共 {total_tokens} tokens")

# 运行
asyncio.run(batch_inference())

pip install "unsloth[cu121-torch240] @ git+https://github.com/unslothai/unsloth.git"

from unsloth import FastLanguageModel
import torch

# 加载Qwen3.8-27B（4-bit量化）
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen3.8-27B",
    max_seq_length=32768,
    dtype=None,  # 自动选择
    load_in_4bit=True,  # 4-bit量化
)

# 启用快速推理
FastLanguageModel.for_inference(model)

# 对话推理
messages = [
    {"role": "system", "content": "你是一个代码审查专家。"},
    {"role": "user", "content": '''审查以下Python代码的问题:
def get_user(id):
    conn = sqlite3.connect('db.sqlite')
    cursor = conn.cursor()
    cursor.execute(f'SELECT * FROM users WHERE id = {id}')
    return cursor.fetchone()
'''},
]

inputs = tokenizer.apply_chat_template(
    messages, tokenize=True, add_generation_prompt=True, return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids=inputs,
    max_new_tokens=1024,
    temperature=0.7,
    use_cache=True,
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments

# 加载模型
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen3.8-27B",
    max_seq_length=4096,
    load_in_4bit=True,
)

# 添加LoRA适配器
model = FastLanguageModel.get_peft_model(
    model,
    r=16,  # LoRA秩
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # 节省显存
)

# 准备训练数据
train_dataset = ...  # 你的训练数据

# 配置训练参数
training_args = TrainingArguments(
    output_dir="./outputs",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=not torch.cuda.is_bf16_supported(),
    bf16=torch.cuda.is_bf16_supported(),
    save_steps=200,
    logging_steps=10,
)

# 创建训练器
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=train_dataset,
    args=training_args,
)

# 开始训练
trainer.train()

# 保存模型
model.save_pretrained("./my-qwen38-lora")
tokenizer.save_pretrained("./my-qwen38-lora")

# 安装needle
# pip install needle-ai onnxruntime

from needle import NeedleModel
import time

# 加载14MB模型
start = time.time()
model = NeedleModel.load("needle-base-14m")
print(f"模型加载耗时: {time.time()-start:.2f}s")
print(f"模型大小: {model.size_mb}MB")

# CPU推理
start = time.time()
response = model.generate(
    prompt="总结以下文本的要点：人工智能正在改变软件开发的方式...",
    max_tokens=50
)
print(f"推理耗时: {time.time()-start:.3f}s")
print(f"回复: {response}")

# 导出为TFLite格式（Android/iOS）
model.export_tflite("needle_mobile.tflite")

# 导出为CoreML格式（macOS/iOS）
model.export_coreml("needle_mobile.mlmodel")

# 在Android应用中使用
'''
// Android Kotlin示例
val interpreter = Interpreter(loadModelFile("needle_mobile.tflite"))
val input = Array(1) { IntArray(seqLen) }
val output = Array(1) { FloatArray(vocabSize) }
interpreter.run(input, output)
'''

# 技巧1: 使用量化降低显存占用
# 4-bit量化: 显存减少约75%
# 8-bit量化: 显存减少约50%

# 技巧2: 梯度检查点（Gradient Checkpointing）
model.gradient_checkpointing_enable()  # 用计算时间换显存

# 技巧3: Flash Attention 2
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    attn_implementation="flash_attention_2",  # 更高效的注意力实现
    torch_dtype=torch.bfloat16,
)

# 技巧4: KV Cache量化
# 在vLLM中启用KV Cache量化
# --kv-cache-dtype fp8  # 将KV缓存量化为8位浮点

# 技巧1: 使用vLLM的PagedAttention
# vLLM自动启用，比HuggingFace快3-5倍

# 技巧2: 使用TensorRT-LLM
# pip install tensorrt-llm
# 对NVIDIA GPU有极致优化

# 技巧3: 批处理推理
# 避免逐条推理，使用批处理提高吞吐量
prompts = ["问题1", "问题2", "问题3", ...]
outputs = llm.generate(prompts, sampling_params)  # 一次性处理

# 技巧4: 使用推测解码（Speculative Decoding）
# 用小模型生成候选token，大模型验证
# vLLM: --speculative-model "Qwen/Qwen3.8-1.5B" --num-speculative-tokens 5

你的硬件条件？
│
├─ 24GB+ GPU (如RTX 4090)
│   └─ vLLM + Qwen3.8-27B (AWQ量化)
│      └─ 需要微调？ → unsloth
│
├─ 8-16GB GPU (如RTX 3060/4060)
│   └─ Ollama + Qwen3.8-27B (4-bit量化)
│      └─ 需要微调？ → unsloth + LoRA
│
├─ 4GB GPU (如笔记本显卡)
│   └─ Ollama + 小参数模型 (7B/14B)
│      └─ 或 unsloth + 层流式训练
│
├─ 仅CPU
│   └─ llama.cpp + GGUF格式模型
│      └─ 或 needle (14MB微型模型)
│
└─ 移动设备/IoT
    └─ needle + ONNX/TFLite