llama-cpp-python Python绑定

from llama_cpp import Llama

# 检查是否支持 GPU
llama = Llama(model_path="model.gguf", n_gpu_layers=1)
print(f"GPU layers loaded: {llama.n_gpu_layers}")

from llama_cpp import Llama

llm = Llama(
    model_path="model.gguf",       # 模型文件路径（必填）
    n_ctx=512,                     # 上下文窗口大小
    n_batch=512,                   # 批次大小（prompt处理）
    n_ubatch=128,                  # 物理批次大小
    n_gpu_layers=0,                # 卸载到GPU的层数，-1为全部
    split_mode=LLAMA_SPLIT_MODE_LAYER,  # 多GPU分割模式
    main_gpu=0,                    # 主GPU编号
    tensor_split=None,             # 多GPU张量分割比例
    rope_freq_base=0.0,            # RoPE频率基数（0=使用模型默认）
    rope_freq_scale=1.0,           # RoPE频率缩放因子
    seed=LLAMA_DEFAULT_SEED,       # 随机种子
    f16_kv=True,                   # KV Cache使用FP16
    logits_all=False,              # 是否返回所有token的logits
    vocab_only=False,              # 仅加载词表（不加载权重）
    use_mmap=True,                 # 使用内存映射
    use_mlock=False,               # 锁定内存防止换页
    embedding=False,               # 是否启用嵌入模式
    numa=False,                    # NUMA优化
    chat_format=None,              # 聊天格式（chatml、llama-2等）
    chat_handler=None,             # 自定义聊天处理器
    lora_base=None,                # LoRA基础模型路径
    lora_path=None,                # LoRA适配器路径
    lora_scale=1.0,               # LoRA缩放因子
    verbose=True,                  # 打印详细日志
)

# 方法1：RoPE 频率缩放（简单但有质量损失）
llm = Llama(
    model_path="model.gguf",
    n_ctx=8192,              # 目标上下文长度
    rope_freq_scale=0.5,     # 缩放因子 = 原始长度 / 目标长度
)

# 方法2：YaRN 扩展（更高质量）
llm = Llama(
    model_path="model.gguf",
    n_ctx=8192,
    rope_freq_base=10000,    # 原始 RoPE 基数
    rope_freq_scale=0.5,
)

result = llm.create_completion(
    prompt="人工智能的未来是",          # 输入提示词
    max_tokens=128,                    # 最大生成 token 数
    temperature=0.7,                   # 采样温度（0=贪心）
    top_p=0.9,                         # Top-p 核采样
    top_k=40,                          # Top-k 采样
    min_p=0.05,                        # Min-p 采样
    typical_p=1.0,                     # 典型采样概率
    stop=["。", "\n"],                 # 停止词列表
    stream=False,                      # 是否流式输出
    seed=None,                         # 随机种子
    repeat_penalty=1.1,               # 重复惩罚
    frequency_penalty=0.0,            # 频率惩罚
    presence_penalty=0.0,             # 存在惩罚
    tfs_z=1.0,                        # 尾部自由采样参数
    mirostat_mode=0,                  # Mirostat 采样模式（0=禁用，1=Mirostat，2=Mirostat 2.0）
    mirostat_tau=5.0,                 # Mirostat 目标熵
    mirostat_eta=0.1,                 # Mirostat 学习率
    grammar=None,                      # LlamaGrammar 语法约束
    logprobs=None,                     # 返回 top-N logprobs
)

{
    "id": "cmpl-xxx",
    "object": "text_completion",
    "created": 1699999999,
    "model": "model.gguf",
    "choices": [{
        "text": "充满无限可能的。...",
        "index": 0,
        "logprobs": None,
        "finish_reason": "stop"  # "stop" | "length"
    }],
    "usage": {
        "prompt_tokens": 8,
        "completion_tokens": 20,
        "total_tokens": 28
    }
}

from llama_cpp import Llama

llm = Llama(model_path="llama-2-7b-chat.Q4_K_M.gguf", n_ctx=2048)

# 简单补全
result = llm.create_completion(
    prompt="量子计算的基本原理是",
    max_tokens=200,
    temperature=0.7,
    stop=["。"]
)
print(result["choices"][0]["text"])

result = llm.create_chat_completion(
    messages=[                         # 消息列表
        {"role": "system", "content": "你是一个有用的AI助手。"},
        {"role": "user", "content": "解释什么是机器学习"},
        {"role": "assistant", "content": "机器学习是..."},
        {"role": "user", "content": "它和深度学习有什么区别？"},
    ],
    max_tokens=256,
    temperature=0.7,
    top_p=0.9,
    stream=False,
    stop=None,
    response_format=None,              # JSON模式: {"type": "json_object"}
    tools=None,                        # 函数调用工具定义
    tool_choice=None,                  # "auto" | "none" | {"type": "function", "function": {"name": "..."}}
    grammar=None,
    logprobs=None,
)

{
    "id": "chatcmpl-xxx",
    "object": "chat.completion",
    "created": 1699999999,
    "model": "model.gguf",
    "choices": [{
        "index": 0,
        "message": {
            "role": "assistant",
            "content": "机器学习是一种...",
            "tool_calls": None
        },
        "finish_reason": "stop"
    }],
    "usage": {
        "prompt_tokens": 30,
        "completion_tokens": 50,
        "total_tokens": 80
    }
}

from llama_cpp import Llama

llm = Llama(
    model_path="llama-2-7b-chat.Q4_K_M.gguf",
    n_ctx=4096,
    chat_format="llama-2"  # 指定聊天格式
)

# 单轮对话
result = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "你是一个专业的Python编程助手。"},
        {"role": "user", "content": "如何读取CSV文件？"}
    ],
    max_tokens=300,
    temperature=0.7
)
print(result["choices"][0]["message"]["content"])

# 多轮对话
messages = [
    {"role": "system", "content": "你是一个有用的AI助手。"}
]

# 第一轮
messages.append({"role": "user", "content": "什么是RAG？"})
result1 = llm.create_chat_completion(messages=messages, max_tokens=200)
assistant_msg1 = result1["choices"][0]["message"]["content"]
messages.append({"role": "assistant", "content": assistant_msg1})

# 第二轮（模型会参考前文）
messages.append({"role": "user", "content": "它有哪些优势？"})
result2 = llm.create_chat_completion(messages=messages, max_tokens=200)
print(result2["choices"][0]["message"]["content"])

from llama_cpp import LlamaGrammar

# 从 GBNF 字符串创建
grammar = LlamaGrammar.from_string("""
    root ::= sentence
    sentence ::= noun verb object
    noun ::= "cat" | "dog" | "bird"
    verb ::= "chases" | "watches" | "ignores"
    object ::= "the mouse" | "the fish" | "the worm"
""")

# 从文件创建
grammar = LlamaGrammar.from_file("grammar.gbnf")

# 在推理中使用
result = llm.create_completion(
    prompt="Write a sentence: ",
    grammar=grammar,
    max_tokens=50,
    temperature=0.0
)

from llama_cpp import Llama, LlamaGrammar

llm = Llama(model_path="model.gguf", n_ctx=2048)

# 强制输出 JSON 数组
json_grammar = LlamaGrammar.from_string("""
    root ::= array
    array ::= "[" ws item ("," ws item)* ws "]"
    item ::= "{" ws "\\"name\\"" ":" ws string "," ws "\\"age\\"" ":" ws number ws "}"
    string ::= "\\"" [^"]* "\\""
    number ::= [0-9]+
    ws ::= [ \\t\\n]*
""")

result = llm.create_completion(
    prompt="Generate 3 person records: ",
    grammar=json_grammar,
    max_tokens=200,
    temperature=0.7
)
print(result["choices"][0]["text"])
# 输出类似: [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}, {"name": "Carol", "age": 35}]

# 使用 OpenAI 兼容的 JSON 模式（更简洁）
result = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "以JSON格式输出，包含name和age字段。"},
        {"role": "user", "content": "描述三个人"}
    ],
    response_format={"type": "json_object"},
    max_tokens=200
)

llm = Llama(model_path="model.gguf", embedding=True, n_ctx=512)

# 单文本嵌入
result = llm.create_embedding(
    input="这是一段测试文本",     # 输入文本
)

# 返回结构
# {
#     "object": "list",
#     "data": [{
#         "object": "embedding",
#         "embedding": [0.123, -0.456, 0.789, ...],  # 嵌入向量
#         "index": 0
#     }],
#     "model": "model.gguf",
#     "usage": {"prompt_tokens": 8, "total_tokens": 8}
# }

# 多文本嵌入
result = llm.create_embedding(
    input=["第一段文本", "第二段文本", "第三段文本"]
)

# 直接返回 numpy 数组，更方便后续处理
embeddings = llm.embed("这是一段测试文本")
# 返回: numpy.ndarray, shape=(n_embd,)

# 批量嵌入
embeddings = llm.embed(["文本1", "文本2", "文本3"])
# 返回: numpy.ndarray, shape=(n_texts, n_embd)

import numpy as np
from llama_cpp import Llama

llm = Llama(model_path="embed-model.gguf", embedding=True, n_ctx=512)

texts = [
    "机器学习是人工智能的一个分支",
    "深度学习使用神经网络进行学习",
    "今天天气真好，适合出去玩",
    "猫是一种常见的宠物动物"
]

embeddings = llm.embed(texts)

# 余弦相似度
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 计算文本间的相似度矩阵
n = len(texts)
sim_matrix = np.zeros((n, n))
for i in range(n):
    for j in range(n):
        sim_matrix[i][j] = cosine_similarity(embeddings[i], embeddings[j])

# 语义搜索
query = "什么是AI？"
query_emb = llm.embed(query)
scores = [cosine_similarity(query_emb, emb) for emb in embeddings]
best_idx = np.argmax(scores)
print(f"最相关的文本: {texts[best_idx]} (score: {scores[best_idx]:.4f})")

from llama_cpp import Llama

llm = Llama(model_path="model.gguf", n_ctx=2048)

# 流式文本补全
stream = llm.create_completion(
    prompt="请用中文介绍Python编程语言：",
    max_tokens=300,
    temperature=0.7,
    stream=True
)

for chunk in stream:
    text = chunk["choices"][0]["text"]
    print(text, end="", flush=True)
print()  # 换行

stream = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "你是一个有用的AI助手。"},
        {"role": "user", "content": "写一首关于编程的诗"}
    ],
    max_tokens=200,
    temperature=0.8,
    stream=True
)

for chunk in stream:
    delta = chunk["choices"][0].get("delta", {})
    if "content" in delta:
        print(delta["content"], end="", flush=True)
print()

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="sk-xxx"  # 如服务端设置了 --api_key 则需匹配
)

# Chat Completion
response = client.chat.completions.create(
    model="local-model",
    messages=[
        {"role": "system", "content": "你是一个有用的AI助手。"},
        {"role": "user", "content": "什么是量子计算？"}
    ],
    max_tokens=300,
    temperature=0.7
)
print(response.choices[0].message.content)

# 流式 Chat
stream = client.chat.completions.create(
    model="local-model",
    messages=[{"role": "user", "content": "写一个Python快速排序"}],
    max_tokens=300,
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

# Embeddings
embedding = client.embeddings.create(
    model="local-model",
    input="这是一段测试文本"
)
print(len(embedding.data[0].embedding))  # 嵌入维度

from llama_cpp import Llama

# 直接指定 HuggingFace 仓库和文件名（自动下载）
llm = Llama.from_pretrained(
    repo_id="TheBloke/Llama-2-7B-Chat-GGUF",      # HF 仓库ID
    filename="llama-2-7b-chat.Q4_K_M.gguf",        # 文件名
    n_ctx=2048,
    n_gpu_layers=0,
)

import os
from huggingface_hub import hf_hub_download

# 下载模型
model_path = hf_hub_download(
    repo_id="TheBloke/Llama-2-7B-Chat-GGUF",
    filename="llama-2-7b-chat.Q4_K_M.gguf",
    local_dir="./models"  # 本地存储目录
)

# 使用本地路径加载
llm = Llama(model_path=model_path, n_ctx=2048)

# 不同任务使用不同模型
chat_model = Llama(model_path="./models/chat.Q4_K_M.gguf", n_ctx=4096)
embed_model = Llama(model_path="./models/embed.gguf", embedding=True, n_ctx=512)
code_model = Llama(model_path="./models/coder.Q4_K_M.gguf", n_ctx=4096)

# 注意：同时加载多个模型会占用大量内存，建议按需加载

# 加载基础模型并应用 LoRA
llm = Llama(
    model_path="./models/base.Q4_K_M.gguf",
    lora_base="./models/base-f16.gguf",   # LoRA 基础模型（FP16）
    lora_path="./loras/chinese_lora.bin",  # LoRA 适配器路径
    lora_scale=1.0,                         # 缩放因子
    n_ctx=2048,
)

import numpy as np
from llama_cpp import Llama

# 加载嵌入模型和生成模型
embed_llm = Llama(model_path="./models/embed.gguf", embedding=True, n_ctx=512)
gen_llm = Llama(model_path="./models/chat.Q4_K_M.gguf", n_ctx=4096)

# 文档库
documents = [
    "Python是一种广泛使用的高级编程语言，由Guido van Rossum于1991年创建。",
    "机器学习是人工智能的一个子领域，它使计算机能够从数据中学习而无需显式编程。",
    "深度学习是机器学习的一个分支，使用多层神经网络来学习数据的层次表示。",
    "自然语言处理（NLP）是人工智能的一个领域，专注于计算机与人类语言之间的交互。",
    "计算机视觉是人工智能的一个领域，专注于让计算机理解和处理视觉信息。",
]

# 构建向量索引
doc_embeddings = embed_llm.embed(documents)

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def rag_query(query: str, top_k: int = 2) -> str:
    # 1. 检索相关文档
    query_emb = embed_llm.embed(query)
    scores = [cosine_similarity(query_emb, doc_emb) for doc_emb in doc_embeddings]
    top_indices = np.argsort(scores)[-top_k:][::-1]
    context = "\n".join([documents[i] for i in top_indices])

    # 2. 生成回答
    result = gen_llm.create_chat_completion(
        messages=[
            {"role": "system", "content": f"根据以下参考信息回答问题。如果参考信息中没有答案，请说明。\n\n参考信息：\n{context}"},
            {"role": "user", "content": query}
        ],
        max_tokens=300,
        temperature=0.5
    )
    return result["choices"][0]["message"]["content"]

# 测试
answer = rag_query("什么是深度学习？它和机器学习有什么关系？")
print(answer)

from llama_cpp import Llama, LlamaGrammar

llm = Llama(model_path="./models/chat.Q4_K_M.gguf", n_ctx=2048)

# 定义输出语法：提取人名、地点和事件
extract_grammar = LlamaGrammar.from_string("""
    root ::= "{" ws "\\"people\\"" ":" ws array "," ws "\\"locations\\"" ":" ws array "," ws "\\"events\\"" ":" ws array ws "}"
    array ::= "[" ws "]" | "[" ws string ("," ws string)* ws "]"
    string ::= "\\"" [^"\\\\]* "\\""
    ws ::= [ \\t\\n]*
""")

text = """
2023年5月，张伟和李明在北京参加了全球AI峰会。会议期间，王芳在上海举办了
一场关于大模型技术的研讨会。随后，张伟前往深圳参观了AI实验室。
"""

result = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "从文本中提取人名、地点和事件，以JSON格式输出。"},
        {"role": "user", "content": text}
    ],
    grammar=extract_grammar,
    max_tokens=200,
    temperature=0.0
)

import json
extracted = json.loads(result["choices"][0]["message"]["content"])
print(extracted)
# {"people": ["张伟", "李明", "王芳"], "locations": ["北京", "上海", "深圳"], "events": [...]}

from llama_cpp import Llama

llm = Llama(
    model_path="./models/chat.Q4_K_M.gguf",
    n_ctx=4096,
    n_gpu_layers=-1,  # 全部卸载到 GPU
    chat_format="chatml"
)

def chat():
    messages = [
        {"role": "system", "content": "你是一个友好、专业的AI助手，用中文回答问题。"}
    ]

    print("聊天机器人已启动（输入 'quit' 退出）\n")

    while True:
        user_input = input("你: ").strip()
        if user_input.lower() == "quit":
            break
        if not user_input:
            continue

        messages.append({"role": "user", "content": user_input})

        # 流式生成回复
        print("AI: ", end="", flush=True)
        full_response = ""

        stream = llm.create_chat_completion(
            messages=messages,
            max_tokens=512,
            temperature=0.7,
            stream=True
        )

        for chunk in stream:
            delta = chunk["choices"][0].get("delta", {})
            if "content" in delta:
                text = delta["content"]
                print(text, end="", flush=True)
                full_response += text

        print("\n")

        # 保存到对话历史
        messages.append({"role": "assistant", "content": full_response})

        # 简单的上下文管理：超过上下文长度时保留系统提示+最近对话
        if len(str(messages)) > 3500:
            messages = [messages[0]] + messages[-4:]  # 系统提示+最近2轮

if __name__ == "__main__":
    chat()

from llama_cpp import Llama
import json

llm = Llama(model_path="./models/chat.Q4_K_M.gguf", n_ctx=2048)

def classify_text(text: str, categories: list[str]) -> str:
    """文本分类"""
    result = llm.create_chat_completion(
        messages=[
            {"role": "system", "content": f"将以下文本分类到这些类别之一：{', '.join(categories)}。只输出类别名称。"},
            {"role": "user", "content": text}
        ],
        max_tokens=10,
        temperature=0.0
    )
    return result["choices"][0]["message"]["content"].strip()

def summarize_text(text: str, max_length: int = 100) -> str:
    """文本摘要"""
    result = llm.create_chat_completion(
        messages=[
            {"role": "system", "content": f"用不超过{max_length}字总结以下文本。"},
            {"role": "user", "content": text}
        ],
        max_tokens=max_length,
        temperature=0.3
    )
    return result["choices"][0]["message"]["content"].strip()

def translate_text(text: str, target_lang: str = "English") -> str:
    """文本翻译"""
    result = llm.create_chat_completion(
        messages=[
            {"role": "system", "content": f"将以下文本翻译为{target_lang}。只输出翻译结果。"},
            {"role": "user", "content": text}
        ],
        max_tokens=300,
        temperature=0.3
    )
    return result["choices"][0]["message"]["content"].strip()

# 批量处理
articles = [
    "苹果公司发布了最新一代iPhone，搭载了更强大的AI芯片...",
    "研究团队在《自然》杂志发表论文，发现了一种新型超导材料...",
    "中国国家足球队在世界杯预选赛中以2:1战胜对手...",
]

categories = ["科技", "科学", "体育", "政治", "经济"]

for article in articles:
    category = classify_text(article, categories)
    summary = summarize_text(article)
    translation = translate_text(article, "English")
    print(f"分类: {category}")
    print(f"摘要: {summary}")
    print(f"英文: {translation}")
    print("---")

# ChatML 格式（如 Qwen、Mistral 等）
# messages → prompt 转换
"""
<|im_start|>system
你是一个有用的AI助手。<|im_end|>
<|im_start|>user
你好<|im_end|>
<|im_start|>assistant
"""

# LLaMA-2 格式
"""
[INST] <<SYS>>
你是一个有用的AI助手。
<</SYS>>

你好 [/INST]
"""

# 自动检测格式：根据 GGUF 元数据中的 tokenizer.chat_template

# 推荐模式：全局单例
_model = None

def get_model():
    global _model
    if _model is None:
        _model = Llama(model_path="model.gguf", n_ctx=4096, n_gpu_layers=-1)
    return _model

# 使用多 worker 处理并发（需要 gunicorn 等部署工具）
# 注意：多 worker 模式下每个 worker 会加载一份模型，内存消耗翻倍
# 推荐使用单 worker + 连续批处理模式