【2026年04月20日】Ollama 的 5 个隐藏用法 🔥

import requests
import concurrent.futures
import subprocess

# Step 1: 确保两个模型都已拉取
models = ["llama3", "nomic-embed-text"]
for model in models:
    print(f"Pulling {model}...")
    subprocess.run(["ollama", "pull", model], check=True)

# Step 2: 同时调用两个模型（并发请求）
def query_model(model_name, prompt):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model_name, "prompt": prompt, "stream": False},
        timeout=60
    )
    return response.json().get("response", "")

with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
    future_llama = executor.submit(query_model, "llama3", "用一句话解释量子计算")
    future_nomic = executor.submit(query_model, "nomic-embed-text", "What is vector embedding?")
    print("LLAMA3:", future_llama.result())
    print("NOMIC:", future_nomic.result())

# Step 3: 用 nomic-embed-text 生成向量
def get_embedding(text):
    response = requests.post(
        "http://localhost:11434/api/embeddings",
        json={"model": "nomic-embed-text", "prompt": text},
        timeout=30
    )
    return response.json().get("embedding")

emb = get_embedding("Ollama is awesome")
print(f"Embedding dimension: {len(emb)}")

FROM llama3

# 设置默认参数（高精度任务）
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

# SYSTEM 提示词模板
SYSTEM """
你是一位数学导师。请遵循以下步骤：
1. 理解问题
2. 写出解题思路（中文）
3. 给出最终答案
4. 如果可以，提供 Python 验证代码
请始终用 <step> 标签包裹每个步骤。
"""

# 对话模板（支持多轮对话）
TEMPLATE """
<|im_start|>system
{{.System}}<|im_end|>
<|im_start|>user
{{.Prompt}}<|im_end|>
<|im_start|>assistant
"""

# 创建自定义模型
ollama create mathtutor -f Modelfile

# 测试使用
ollama run mathtutor "求 x^2 - 5x + 6 = 0 的解"

# Python API 调用自定义模型
import requests

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "mathtutor",
        "prompt": "求 x^2 - 5x + 6 = 0 的解",
        "stream": False,
        "options": {"temperature": 0.3}
    },
    timeout=60
)
print(response.json()["response"])

import requests
import numpy as np

OLLAMA_URL = "http://localhost:11434"

def get_embedding(text: str, model: str = "nomic-embed-text") -> list:
    resp = requests.post(
        f"{OLLAMA_URL}/api/embeddings",
        json={"model": model, "prompt": text},
        timeout=30
    )
    resp.raise_for_status()
    return resp.json()["embedding"]

def cosine_sim(a: list, b: list) -> float:
    a, b = np.array(a), np.array(b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

# 构建本地知识库
documents = [
    "Ollama 支持 llama3、mistral、codellama 等 100+ 模型",
    "Ollama 可以通过 Modelfile 自定义模型行为",
    "Ollama 的 API 服务端口是 11434",
    "Ollama 支持 GPU 加速推理（CUDA 和 Metal）",
    "Ollama 可以通过 ollama pull 快速下载模型",
]

# 为每个文档生成向量
doc_embeddings = [get_embedding(doc) for doc in documents]

# RAG 查询
query = "Ollama 支持哪些模型？"
query_emb = get_embedding(query)

# 找最相关的文档
similarities = [cosine_sim(query_emb, de) for de in doc_embeddings]
top_idx = np.argmax(similarities)

print(f"Query: {query}")
print(f"Top match (similarity={similarities[top_idx]:.3f}): {documents[top_idx]}")

# 用最相关的文档作为上下文，让模型回答
context_docs = [documents[i] for i in np.argsort(similarities)[-2:]]
context = "\n".join(context_docs)

response = requests.post(
    f"{OLLAMA_URL}/api/generate",
    json={
        "model": "llama3",
        "prompt": f"基于以下上下文回答：\n{context}\n\n问题：{query}",
        "stream": False
    },
    timeout=60
)
print(f"\nModel answer: {response.json()['response']}")

# 方法1: 直接用 Ollama 拉取已量化的模型（推荐）
ollama pull llama3:70b-instruct-q4_K_M

# 方法2: 手动量化现有模型
# 安装 llama.cpp
brew install llama.cpp

# 使用 llama.cpp 量化 GGUF 文件
llama-quantize model.bin model-q4.bin Q4_K_M

# 在 Ollama 中使用量化模型
ollama create my-q4-model -f <<'EOF'
FROM ./model-q4.bin
PARAMETER num_ctx 2048
PARAMETER temperature 0.7
EOF

ollama run my-q4-model "Hello, explain quantum entanglement in one sentence"

# Python: 量化前后资源对比
import subprocess

# 量化模型体积参考
quantization_comparison = {
    "Llama3 8B FP16": "~16GB",
    "Llama3 8B Q4_K_M": "~5GB (节省 68%)",
    "Llama3 70B FP16": "~140GB",
    "Llama3 70B Q4_K_M": "~41GB (节省 71%)",
    "Mistral 7B Q5_K_M": "~5.5GB (高精度)",
}

print("=== 模型量化体积对比 ===")
for model, size in quantization_comparison.items():
    print(f"  {model}: {size}")

print("\n推荐量化级别：")
print("  Q4_K_M: 最佳精度/体积比（适合大多数场景）")
print("  Q5_K_M: 更高精度，略大")
print("  Q8_0: 接近 FP16，推荐用于 13B+ 模型")

# pip install transformers peft bitsandbytes accelerate

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

MODEL_PATH = "./llama3.gguf"  # Ollama 导出: ollama export llama3 -o ./llama3.gguf
OUTPUT_DIR = "./my-finetuned-llama3"

# Step 1: 加载 Ollama 导出的模型（4-bit 量化）
model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    model_type="llama",
    device_map="auto",
    load_in_4bit=True,
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")
model = prepare_model_for_kbit_training(model)

# Step 2: 配置 QLoRA（可训练参数仅占总量 0.052%）
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 预期输出: "trainable params: 4,194,304 || all params: 8,072,068,608 || trainable%: 0.052%"

# Step 3: 开始微调
training_args = TrainingArguments(
    output_dir=OUTPUT_DIR,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
)
# trainer = SFTTrainer(model, args, train_dataset=dataset, tokenizer=tokenizer)
# trainer.train()
print("QLoRA 微调配置完成！微调后模型保存至:", OUTPUT_DIR)