2025年本地AI部署完全指南：从Ollama到vLLM的全方位实践教程

如果安装成功，将会显示当前Ollama的版本信息。

#### macOS系统安装步骤

1. **使用Homebrew安装**（推荐）

```bash
brew install ollama

ollama serve

curl -fsSL https://ollama.com/install.sh | sh

sudo systemctl start ollama
sudo systemctl enable ollama  # 设置开机自启

ollama list available

ollama pull llama3

ollama run llama3

ollama list

ollama rm llama3

FROM llama3
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM "你是一位专业的AI助手。"

ollama create my-llama -f Modelfile

export OLLAMA_METAL_LAYERS=1  # 调整Metal层数量以优化性能

OLLAMA_CUDA=1 ollama serve

# 创建一个低内存消耗的模型配置
cat > Modelfile << 'EOF'
FROM llama3:7b-instruct-q4_K_M
PARAMETER num_ctx 2048  # 减少上下文窗口以降低内存使用
PARAMETER num_thread 4  # 根据CPU核心数调整
EOF

ollama create llama3-light -f Modelfile

# 发送请求到本地Ollama服务
curl http://localhost:11434/api/generate -d '{  
  "model": "llama3",
  "prompt": "解释量子计算的基本原理"
}'

import requests
import json

def generate_text(prompt, model="llama3"):
    url = "http://localhost:11434/api/generate"
    payload = {
        "model": model,
        "prompt": prompt,
        "stream": False
    }
    response = requests.post(url, json=payload)
    return response.json()

# 使用示例
result = generate_text("编写一个简单的Python函数来计算斐波那契数列")
print(result["response"])

# 使用多模态模型
ollama pull llava

# 通过API发送图像和文本
curl http://localhost:11434/api/generate -d '{  
  "model": "llava",
  "prompt": "描述这张图片中的内容",
  "images": ["base64编码的图像数据"]
}'

docker pull localai/localai:latest

mkdir -p models

docker run -p 8080:8080 \
  -v ./models:/models \
  --name localai \
  localai/localai:latest

version: '3.8'

services:
  localai:
    image: localai/localai:latest
    ports:
      - "8080:8080"
    volumes:
      - ./models:/models
      - ./config:/etc/localai
    environment:
      - DEBUG=true
      - MODELS_PATH=/models
      - CONTEXT_SIZE=512
      - THREADS=4
    restart: unless-stopped

docker-compose up -d

cd models
wget https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_0.gguf -O llama-2-7b-chat.gguf

name: llama-2-7b-chat
parameters:
  model: llama-2-7b-chat.gguf
  top_p: 0.9
  temperature: 0.7
template:
  completion: "llama-2"
  chat: "llama-2-chat"
tools:
  embeddings: true

docker restart localai

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "llama-2-7b-chat", "messages": [{"role": "user", "content": "写一个Python函数来计算阶乘"}], "temperature": 0.7}'

from openai import OpenAI

# 配置客户端指向本地服务
client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="sk-ignored"  # LocalAI不需要实际的API密钥
)

# 发送请求
response = client.chat.completions.create(
    model="llama-2-7b-chat",
    messages=[
        {"role": "system", "content": "你是一个有用的助手。"},
        {"role": "user", "content": "解释什么是机器学习"}
    ],
    temperature=0.7
)

print(response.choices[0].message.content)

# 在docker-compose.yml中添加
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - BACKEND_TYPE=ggml-gpu

# 模型配置示例
models:
  - name: "chat"
    model: "llama-2-7b-chat.gguf"
    parameters:
      temperature: 0.7
  - name: "embedding"
    model: "all-MiniLM-L6-v2.gguf"
    parameters:
      embedding: true

# 在docker-compose.yml中添加
    environment:
      - API_KEY=your-secret-key

server {
    listen 443 ssl;
    server_name ai.example.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    location / {
        proxy_pass http://localai:8080;
        proxy_set_header Authorization $http_authorization;
        
        # 添加访问控制
        allow 192.168.1.0/24;
        deny all;
    }
}

# 原OpenAI代码
from openai import OpenAI
client = OpenAI(api_key="your-api-key")

# 修改为LocalAI
client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="sk-ignored"  # 任意非空字符串即可
)

# 原代码
response = client.chat.completions.create(model="gpt-3.5-turbo", ...)

# 修改后
response = client.chat.completions.create(model="llama-2-7b-chat", ...)

pip install vllm

pip install vllm==0.4.0

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-7b-chat-hf --port 8000

from vllm import LLM
from vllm import SamplingParams

# 初始化LLM实例
sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=200)
llm = LLM(model="meta-llama/Llama-2-7b-chat-hf")

# 生成文本
prompts = [
    "写一个Python函数来查找列表中的最大值",
    "解释量子计算的基本原理",
    "总结2025年AI领域的主要突破"
]
outputs = llm.generate(prompts, sampling_params)

# 打印结果
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt!r}\nGenerated text: {generated_text!r}\n")

from vllm import LLM, SamplingParams

# 初始化LLM实例
sampling_params = SamplingParams(temperature=0.7, top_p=0.95)
llm = LLM(model="meta-llama/Llama-2-7b-chat-hf", tensor_parallel_size=1)

# 批量生成文本
prompts = [
    "写一个Python爬虫",
    "解释什么是深度学习",
    "如何提高编程效率",
    "推荐几本AI领域的书籍",
    "如何学习Python"
]
outputs = llm.generate(prompts, sampling_params)

# 处理结果
for i, output in enumerate(outputs):
    print(f"结果 {i+1}: {output.outputs[0].text}")

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-7b-chat-hf --port 8000 --host 0.0.0.0

curl http://localhost:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "meta-llama/Llama-2-7b-chat-hf", "prompt": "写一个Java函数来计算斐波那契数列", "max_tokens": 150}'

import requests

# 定义API端点和请求数据
url = "http://localhost:8000/v1/completions"
headers = {"Content-Type": "application/json"}

data = {
    "model": "meta-llama/Llama-2-7b-chat-hf",
    "prompt": "写一个Python脚本分析文本文件中的词频",
    "max_tokens": 200,
    "temperature": 0.7
}

# 发送请求
response = requests.post(url, headers=headers, json=data)

# 处理响应
if response.status_code == 200:
    result = response.json()
    print(result["choices"][0]["text"])
else:
    print(f"请求失败: {response.status_code}")
    print(response.text)

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-70b-chat-hf --tensor-parallel-size 4

from vllm import LLM
llm = LLM(model="meta-llama/Llama-2-70b-chat-hf", tensor_parallel_size=4)

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-70b-chat-hf --quantization awq

from vllm import LLM, SamplingParams

sampling_params = SamplingParams(temperature=0.7, max_tokens=200)
llm = LLM(model="meta-llama/Llama-2-7b-chat-hf")

# 流式生成
prompts = ["详细解释如何优化Python代码性能"]
for output in llm.generate_iterator(prompts, sampling_params):
    token = output.outputs[0].text[-len(output.outputs[0].token_ids):]
    print(token, end="", flush=True)

python -m vllm.entrypoints.api_server --model meta-llama/Llama-2-7b-chat-hf --max-num-seqs 256

docker pull vllm/vllm:latest

docker run --gpus all -p 8000:8000 \
  vllm/vllm:latest \
  python -m vllm.entrypoints.api_server \
  --model meta-llama/Llama-2-7b-chat-hf \
  --port 8000

version: '3.8'

services:
  vllm:
    image: vllm/vllm:latest
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    ports:
      - "8000:8000"
    volumes:
      - ./models:/models
    environment:
      - HF_HOME=/models
    command: >
      python -m vllm.entrypoints.api_server
      --model meta-llama/Llama-2-7b-chat-hf
      --port 8000
      --host 0.0.0.0
    restart: unless-stopped

docker-compose up -d

from vllm import LLM, SamplingParams
import json

# 初始化LLM实例
sampling_params = SamplingParams(temperature=0.3, max_tokens=500)
llm = LLM(model="meta-llama/Llama-2-7b-chat-hf")

# 创建一个简单的问答函数
def answer_question(question):
    # 构建提示模板
    prompt = f"""你是一个专业的AI助手，负责回答用户问题。
    
    用户问题: {question}
    
    请提供详细、准确的回答:
    """
    
    # 生成回答
    outputs = llm.generate([prompt], sampling_params)
    return outputs[0].outputs[0].text

# 测试问答系统
questions = [
    "什么是机器学习中的过拟合？如何避免？",
    "Docker容器和虚拟机有什么区别？",
    "如何优化Python程序的性能？"
]

for question in questions:
    print(f"\n问题: {question}")
    print(f"回答: {answer_question(question)}")

# 安装Python包
# pip install gpt4all

from gpt4all import GPT4All

# 加载模型
model = GPT4All("orca-mini-3b-gguf2-q4_0.gguf")

# 生成文本
with model.chat_session():
    response = model.generate("写一个Python函数来检查字符串是否为回文", max_tokens=200)
    print(response)

from gpt4all import GPT4All

# 微调模型
model = GPT4All("orca-mini-3b-gguf2-q4_0.gguf")
model.finetune(
    "training_data.jsonl",  # 训练数据文件
    lora_out_dir="./fine_tuned_model"
)

docker run -p 8080:80 \
  --gpus all \
  --shm-size 1g \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Llama-2-7b-chat-hf \
  --num-shard 1

import requests

# 发送请求
url = "http://localhost:8080/generate"
data = {
    "inputs": "解释什么是深度学习",
    "parameters": {
        "max_new_tokens": 200,
        "temperature": 0.7,
        "top_p": 0.95
    }
}

response = requests.post(url, json=data)
print(response.json()["generated_text"])

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j

# 转换模型
python convert.py /path/to/llama/model

# 量化模型
./quantize /path/to/model/ggml-model-f16.bin /path/to/model/ggml-model-q4_0.bin q4_0

./main -m /path/to/model/ggml-model-q4_0.bin -p "写一个Python脚本分析日志文件" -n 200

# 使用GPTQ量化
from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM

model_id = "meta-llama/Llama-2-7b-chat-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoGPTQForCausalLM.from_quantized(
    model_id,
    quantize_config={"bits": 4, "group_size": 128}
)

# PyTorch GPU加速示例
import torch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# 设置GPU内存使用策略
torch.cuda.set_per_process_memory_fraction(0.8)

# 使用torch.utils.checkpoint进行梯度检查点
from torch.utils.checkpoint import checkpoint

# 使用半精度浮点数
device = torch.device("cuda")
model.half().to(device)

# 使用梯度累积减少内存使用
for i, batch in enumerate(dataloader):
    outputs = model(**batch)
    loss = outputs.loss / accumulation_steps
    loss.backward()
    
    if (i + 1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

# 在Flask应用中添加基本认证
from flask import Flask, request, jsonify
from functools import wraps

app = Flask(__name__)

def require_api_key(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        api_key = request.headers.get('X-API-Key')
        if api_key and api_key == 'your-secret-key':
            return f(*args, **kwargs)
        return jsonify({"error": "Unauthorized"}), 401
    return decorated

@app.route('/api/generate', methods=['POST'])
@require_api_key
def generate_text():
    # 生成文本的代码
    pass

def validate_input(user_input):
    # 检查输入长度
    if len(user_input) > 1000:
        raise ValueError("输入长度过长")
    
    # 检查敏感内容（示例）
    sensitive_patterns = ["<script>", "DROP TABLE", "exec("]
    for pattern in sensitive_patterns:
        if pattern.lower() in user_input.lower():
            raise ValueError("输入包含潜在的不安全内容")
    
    return True

# 使用Windows Subsystem for Linux部署Linux容器
wsl --install
wsl docker run -p 8080:8080 ollama/ollama

# 使用Homebrew安装必要的依赖
brew install ollama
ollama run llama2

# 在Ubuntu上设置自动启动服务
sudo systemctl enable ollama
sudo systemctl start ollama

# 使用Prometheus客户端库进行监控
from prometheus_client import Counter, Histogram, start_http_server

REQUEST_COUNT = Counter('ai_requests_total', 'Total number of AI requests')
REQUEST_LATENCY = Histogram('ai_request_latency_seconds', 'Request latency in seconds')

# 在请求处理函数中
@REQUEST_LATENCY.time()
def process_request(request):
    REQUEST_COUNT.inc()
    # 处理请求的代码
    pass

# 启动监控服务器
start_http_server(8000)

import logging
from logging.handlers import RotatingFileHandler

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        RotatingFileHandler('ai_service.log', maxBytes=10485760, backupCount=5),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger('ai_service')

# 在代码中使用
logger.info('模型加载成功')
try:
    # 代码块
    pass
except Exception as e:
    logger.error(f'处理请求时出错: {str(e)}', exc_info=True)

import requests
import time
from concurrent.futures import ThreadPoolExecutor

# 模型服务端点配置
model_services = {
    "chat": "http://localhost:8080/v1/chat/completions",
    "embedding": "http://localhost:8081/v1/embeddings",
    "image": "http://localhost:8082/generate"
}

# 负载均衡函数
def get_service_endpoint(service_type):
    # 简单轮询负载均衡示例
    endpoints = model_services.get(service_type, [])
    if not isinstance(endpoints, list):
        return endpoints
    return endpoints[time.time() % len(endpoints)]

# 模型调用封装
def call_model(service_type, payload):
    endpoint = get_service_endpoint(service_type)
    headers = {"Content-Type": "application/json"}
    
    try:
        response = requests.post(endpoint, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        return response.json()
    except Exception as e:
        print(f"调用{service_type}服务失败: {str(e)}")
        return None

# 并发处理多个模型请求
def process_with_multiple_models(text):
    with ThreadPoolExecutor(max_workers=3) as executor:
        # 并发调用不同模型
        chat_future = executor.submit(call_model, "chat", {
            "model": "llama-2-7b-chat",
            "messages": [{"role": "user", "content": f"分析这段文本: {text}"}]
        })
        
        embedding_future = executor.submit(call_model, "embedding", {
            "model": "all-MiniLM-L6-v2",
            "input": text
        })
    
    # 获取结果
    chat_result = chat_future.result()
    embedding_result = embedding_future.result()
    
    return {
        "analysis": chat_result["choices"][0]["message"]["content"] if chat_result else None,
        "embedding": embedding_result["data"][0]["embedding"] if embedding_result else None
    }

def select_optimal_model(task_type, requirements):
    # 定义模型能力矩阵
    model_capabilities = {
        "llama-2-7b-chat": {"chat": True, "knowledge": "medium", "speed": "fast", "memory": "low"},
        "llama-2-13b-chat": {"chat": True, "knowledge": "high", "speed": "medium", "memory": "medium"},
        "llama-2-70b-chat": {"chat": True, "knowledge": "very_high", "speed": "slow", "memory": "high"},
        "mistral-7b-instruct": {"chat": True, "knowledge": "medium", "speed": "fast", "memory": "low"},
        "text-embedding-ada-002": {"embedding": True, "quality": "high", "speed": "medium"}
    }
    
    # 根据任务和要求筛选合适的模型
    suitable_models = []
    for model, capabilities in model_capabilities.items():
        # 基本任务类型匹配
        if task_type not in capabilities or not capabilities[task_type]:
            continue
            
        # 检查其他要求
        match = True
        for req, value in requirements.items():
            if req in capabilities and capabilities[req] != value:
                match = False
                break
        
        if match:
            suitable_models.append(model)
    
    # 根据优先级选择最终模型
    if task_type == "chat":
        # 对于聊天任务，根据速度和知识水平平衡选择
        if "llama-2-13b-chat" in suitable_models:
            return "llama-2-13b-chat"
        elif "mistral-7b-instruct" in suitable_models:
            return "mistral-7b-instruct"
    
    # 返回第一个合适的模型或默认模型
    return suitable_models[0] if suitable_models else "llama-2-7b-chat"

# 使用Hugging Face的optimum库进行模型量化
from optimum.onnxruntime import ORTQuantizer
from optimum.onnxruntime.configuration import AutoQuantizationConfig

# 加载模型并导出为ONNX格式
from transformers import AutoModelForCausalLM, AutoTokenizer
import onnx
from pathlib import Path

# 导出模型为ONNX
model_id = "meta-llama/Llama-2-7b-chat-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

# 导出为ONNX
onnx_path = Path("llama-2-7b-chat.onnx")
from transformers.onnx import export

# 定义导出配置
export(
    tokenizer=tokenizer,
    model=model,
    opset=14,
    output=onnx_path,
    input_shapes={"input_ids": [1, 128], "attention_mask": [1, 128]}
)

# 量化模型
quantizer = ORTQuantizer.from_pretrained(onnx_path)
quantization_config = AutoQuantizationConfig.avx512_vnni(is_static=False, per_channel=False)
quantizer.quantize(quantization_config=quantization_config, save_dir="./")

import psutil
import os
import torch

def adjust_batch_size(available_memory_percent=0.7):
    """根据可用内存动态调整批处理大小"""
    # 获取系统可用内存
    available_memory = psutil.virtual_memory().available
    total_memory = psutil.virtual_memory().total
    
    # 计算可用内存百分比
    memory_percent = available_memory / total_memory
    
    # 如果可用内存低于阈值，减少批处理大小
    if memory_percent < available_memory_percent:
        # 基础批处理大小
        base_batch_size = 32
        # 根据可用内存比例调整批处理大小
        adjusted_batch_size = max(1, int(base_batch_size * (memory_percent / available_memory_percent)))
        print(f"可用内存不足({memory_percent:.2%})，将批处理大小调整为: {adjusted_batch_size}")
        return adjusted_batch_size
    
    return 32  # 默认批处理大小

def configure_gpu_memory():
    """配置GPU内存使用"""
    if torch.cuda.is_available():
        # 获取GPU数量
        num_gpus = torch.cuda.device_count()
        print(f"检测到 {num_gpus} 个GPU")
        
        # 为每个GPU配置内存使用
        for i in range(num_gpus):
            gpu_memory = torch.cuda.get_device_properties(i).total_memory
            # 设置使用80%的GPU内存
            torch.cuda.set_per_process_memory_fraction(0.8, device=i)
            print(f"GPU {i} 内存总量: {gpu_memory / (1024**3):.2f} GB, 设置使用: 80%")

import subprocess
import time
import logging
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')

class ModelServiceMonitor:
    def __init__(self, service_name, start_command):
        self.service_name = service_name
        self.start_command = start_command
        self.is_running = False
    
    def check_service(self):
        """检查服务是否正在运行"""
        try:
            # 这里使用不同的方式检查服务是否运行
            if self.service_name == "ollama":
                result = subprocess.run(["ollama", "list"], capture_output=True, text=True)
                self.is_running = result.returncode == 0
            elif self.service_name == "localai":
                result = subprocess.run(["docker", "ps", "--filter", "name=localai"], capture_output=True, text=True)
                self.is_running = "localai" in result.stdout
            else:
                # 通用检查方式
                result = subprocess.run(["ps", "aux"], capture_output=True, text=True)
                self.is_running = self.service_name in result.stdout
            
            return self.is_running
        except Exception as e:
            logging.error(f"检查{self.service_name}服务状态时出错: {str(e)}")
            return False
    
    def start_service(self):
        """启动服务"""
        try:
            logging.info(f"正在启动{self.service_name}服务...")
            if isinstance(self.start_command, list):
                subprocess.Popen(self.start_command)
            else:
                subprocess.Popen(self.start_command, shell=True)
            time.sleep(5)  # 给服务一些启动时间
            logging.info(f"{self.service_name}服务启动完成")
        except Exception as e:
            logging.error(f"启动{self.service_name}服务时出错: {str(e)}")
    
    def monitor(self, interval=30):
        """监控服务并在必要时重启"""
        logging.info(f"开始监控{self.service_name}服务，检查间隔: {interval}秒")
        while True:
            try:
                if not self.check_service():
                    logging.warning(f"{self.service_name}服务未运行，正在重启...")
                    self.start_service()
                time.sleep(interval)
            except KeyboardInterrupt:
                logging.info("监控已停止")
                break
            except Exception as e:
                logging.error(f"监控过程中出错: {str(e)}")
                time.sleep(interval)

# 使用示例
if __name__ == "__main__":
    # 监控Ollama服务
    ollama_monitor = ModelServiceMonitor(
        "ollama", 
        "ollama serve"
    )
    
    # 监控LocalAI服务
    localai_monitor = ModelServiceMonitor(
        "localai", 
        "docker start localai"
    )
    
    # 启动监控（在实际应用中，应在不同线程中运行）
    # ollama_monitor.monitor()
    # localai_monitor.monitor()

import re
import matplotlib.pyplot as plt
import numpy as np
from collections import defaultdict, Counter

def analyze_inference_logs(log_file, time_window="1h"):
    """分析推理日志以监控性能和错误"""
    # 初始化统计数据
    request_times = []
    error_count = 0
    model_usage = Counter()
    status_codes = Counter()
    
    # 正则表达式模式
    time_pattern = r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3})\]'
    model_pattern = r'model=(\w+)'  
    time_taken_pattern = r'time_taken=(\d+\.\d+)s'
    status_pattern = r'status=(\d{3})'
    error_pattern = r'ERROR|error|Error'
    
    try:
        with open(log_file, 'r') as f:
            for line in f:
                # 提取时间戳
                time_match = re.search(time_pattern, line)
                if time_match:
                    # 可以在这里添加时间窗口过滤逻辑
                    pass
                
                # 统计错误
                if re.search(error_pattern, line):
                    error_count += 1
                
                # 提取模型使用情况
                model_match = re.search(model_pattern, line)
                if model_match:
                    model_usage[model_match.group(1)] += 1
                
                # 提取状态码
                status_match = re.search(status_pattern, line)
                if status_match:
                    status_codes[status_match.group(1)] += 1
                
                # 提取请求时间
                time_taken_match = re.search(time_taken_pattern, line)
                if time_taken_match:
                    request_times.append(float(time_taken_match.group(1)))
    
    except Exception as e:
        print(f"分析日志时出错: {str(e)}")
        return None
    
    # 计算性能指标
    if request_times:
        avg_time = np.mean(request_times)
        min_time = np.min(request_times)
        max_time = np.max(request_times)
        p95_time = np.percentile(request_times, 95)
        p99_time = np.percentile(request_times, 99)
    else:
        avg_time = min_time = max_time = p95_time = p99_time = 0
    
    # 生成报告
    report = {
        "total_requests": len(request_times),
        "error_count": error_count,
        "error_rate": error_count / len(request_times) if request_times else 0,
        "avg_response_time": avg_time,
        "min_response_time": min_time,
        "max_response_time": max_time,
        "p95_response_time": p95_time,
        "p99_response_time": p99_time,
        "model_usage": dict(model_usage),
        "status_codes": dict(status_codes)
    }
    
    # 可视化结果
    self.visualize_performance(report)
    
    return report

def visualize_performance(report):
    """可视化性能报告"""
    # 创建图表
    fig, axs = plt.subplots(2, 2, figsize=(15, 10))
    
    # 响应时间分布
    times = [report["min_response_time"], report["avg_response_time"], 
             report["p95_response_time"], report["p99_response_time"], report["max_response_time"]]
    labels = ["Min", "Avg", "p95", "p99", "Max"]
    axs[0, 0].bar(labels, times)
    axs[0, 0].set_title("Response Time Distribution (seconds)")
    axs[0, 0].set_ylabel("Time (s)")
    
    # 模型使用情况
    if report["model_usage"]:
        models = list(report["model_usage"].keys())
        counts = list(report["model_usage"].values())
        axs[0, 1].pie(counts, labels=models, autopct='%1.1f%%')
        axs[0, 1].set_title("Model Usage Distribution")
    
    # 状态码分布
    if report["status_codes"]:
        codes = list(report["status_codes"].keys())
        counts = list(report["status_codes"].values())
        axs[1, 0].bar(codes, counts)
        axs[1, 0].set_title("Status Code Distribution")
        axs[1, 0].set_xlabel("Status Code")
        axs[1, 0].set_ylabel("Count")
    
    # 错误率
    error_rate = report["error_rate"] * 100
    success_rate = 100 - error_rate
    axs[1, 1].pie([success_rate, error_rate], labels=["Success", "Error"], 
                  autopct='%1.1f%%', colors=['green', 'red'])
    axs[1, 1].set_title("Success vs Error Rate")
    
    plt.tight_layout()
    plt.savefig("performance_report.png")
    print("性能报告图表已保存为 performance_report.png")

开始
  ├── 您的主要需求是？
  │     ├── 简单易用，快速部署 → Ollama
  │     ├── 替代OpenAI API → LocalAI
  │     ├── 极致性能优化 → vLLM
  │     ├── 完全离线使用 → GPT4All
  │     └── 资源极其受限 → llama.cpp
  │
  ├── 您的硬件配置是？
  │     ├── 高端GPU服务器 → vLLM
  │     ├── 有GPU的开发者机器 → Ollama/LocalAI
  │     ├── 仅有CPU的机器 → llama.cpp/GPT4All
  │     └── 低配置设备 → llama.cpp
  │
  └── 您的应用场景是？
        ├── 生产环境服务 → LocalAI/vLLM
        ├── 开发测试 → Ollama
        ├── 个人使用 → GPT4All/Ollama
        └── 嵌入式设备 → llama.cpp

# 混合部署策略示例
class HybridDeploymentStrategy:
    def __init__(self):
        # 初始化不同的模型服务客户端
        self.services = {
            "chat_fast": OllamaClient(model="llama2:7b"),  # 快速响应的聊天模型
            "chat_high_quality": vLLMClient(model="llama2:13b"),  # 高质量聊天模型
            "embedding": LocalAIClient(model="text-embedding-ada-002"),  # 嵌入模型
            "code": OllamaClient(model="codellama:7b")  # 代码生成模型
        }
    
    def route_request(self, request_type, payload, priority="normal"):
        """根据请求类型和优先级路由到合适的服务"""
        # 基础路由逻辑
        if request_type == "chat":
            if priority == "high" and "complex" in payload.get("features", []):
                return self.services["chat_high_quality"].call(payload)
            else:
                return self.services["chat_fast"].call(payload)
        elif request_type == "embedding":
            return self.services["embedding"].call(payload)
        elif request_type == "code":
            return self.services["code"].call(payload)
        else:
            raise ValueError(f"不支持的请求类型: {request_type}")