平台选型指南：Ollama、LM Studio 与 AnythingLLM

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 安装Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 拉取模型
ollama pull llama3.1:8b
ollama pull mistral:7b
ollama pull qwen2.5:32b

# 运行模型
ollama run llama3.1:8b

# API调用示例
curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama3.1:8b",
    "prompt": "为什么天空是蓝色的？",
    "stream": false
  }'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# LM Studio Python SDK示例
from lm_studio import LMStudio

# 初始化客户端
client = LMStudio()

# 列出可用模型
models = client.list_models()
print(f"可用模型: {models}")

# 加载模型
model = client.load_model("mistral-7b-instruct")

# 生成文本
response = model.generate(
    prompt="解释机器学习的基本概念",
    max_tokens=500,
    temperature=0.7
)

print(response.text)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# AnythingLLM使用示例
from anythingllm import AnythingLLM
from anythingllm.models import load_model
from anythingllm.utils import quantize_model

# 加载和量化模型
model = load_model(
    model_path="./models/llama-7b.gguf",
    device="cuda",
    quantization="int4"
)

# 创建AnythingLLM实例
llm = AnythingLLM(
    model=model,
    max_tokens=2048,
    temperature=0.8
)

# RAG集成示例
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings

# 创建向量存储
embeddings = HuggingFaceEmbeddings()
vectorstore = Chroma(
    embedding_function=embeddings,
    persist_directory="./chroma_db"
)

# 检索增强生成
def rag_query(question):
    # 检索相关文档
    docs = vectorstore.similarity_search(question, k=3)
    context = "\n".join([doc.page_content for doc in docs])

    # 生成回答
    prompt = f"基于以下上下文回答问题：\n{context}\n\n问题：{question}"
    response = llm.generate(prompt)

    return response

# 使用RAG系统
answer = rag_query("什么是深度学习？")
print(answer)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# Docker部署Ollama
docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v ollama:/root/.ollama \
  ollama/ollama

# 拉取企业常用模型
docker exec ollama ollama pull llama3.1:8b
docker exec ollama ollama pull qwen2.5:32b
docker exec ollama ollama pull mistral:7b

# 配置负载均衡
# nginx.conf
upstream ollama_backend {
    server 127.0.0.1:11434;
    server 127.0.0.1:11435;
    server 127.0.0.1:11436;
}

server {
    listen 80;
    location /api/ {
        proxy_pass http://ollama_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# LM Studio团队配置脚本
import json
import os

# 团队模型配置
team_config = {
    "models": [
        {
            "name": "llama3.1-8b-instruct",
            "path": "./models/llama3.1-8b-instruct.gguf",
            "description": "通用对话模型",
            "tags": ["general", "chat"]
        },
        {
            "name": "mistral-7b-code",
            "path": "./models/mistral-7b-code.gguf",
            "description": "代码生成专用",
            "tags": ["code", "programming"]
        }
    ],
    "settings": {
        "max_tokens": 2048,
        "temperature": 0.7,
        "gpu_layers": 32
    }
}

# 保存配置
with open("team_config.json", "w") as f:
    json.dump(team_config, f, indent=2)

print("团队配置已保存")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

# AnythingLLM研究环境配置
from anythingllm import AnythingLLM
from anythingllm.experiments import ExperimentTracker
from anythingllm.utils import ModelBenchmark

class ResearchEnvironment:
    def __init__(self):
        self.models = {}
        self.tracker = ExperimentTracker()
        self.benchmark = ModelBenchmark()

    def load_model(self, name, path, config=None):
        """加载研究模型"""
        model = AnythingLLM.load(
            path=path,
            config=config or {}
        )
        self.models[name] = model
        return model

    def run_experiment(self, experiment_name, model_name, test_data):
        """运行实验"""
        model = self.models[model_name]
        results = []

        for data in test_data:
            response = model.generate(data["prompt"])
            result = {
                "input": data["prompt"],
                "output": response,
                "expected": data.get("expected"),
                "metrics": self.benchmark.evaluate(response, data.get("expected"))
            }
            results.append(result)

        # 记录实验结果
        self.tracker.log_experiment(
            name=experiment_name,
            model=model_name,
            results=results
        )

        return results

    def compare_models(self, model_names, test_data):
        """模型对比实验"""
        comparison = {}

        for model_name in model_names:
            results = self.run_experiment(
                f"comparison_{model_name}",
                model_name,
                test_data
            )
            comparison[model_name] = results

        return comparison

# 使用示例
env = ResearchEnvironment()

# 加载多个模型进行对比
env.load_model("llama", "./models/llama-7b.gguf")
env.load_model("mistral", "./models/mistral-7b.gguf")
env.load_model("qwen", "./models/qwen-7b.gguf")

# 运行对比实验
test_data = [
    {"prompt": "解释量子计算的基本原理", "expected": "量子计算利用量子力学原理..."},
    {"prompt": "写一个Python快速排序算法", "expected": "def quicksort(arr)..."}
]

results = env.compare_models(["llama", "mistral", "qwen"], test_data)
print("实验结果:", results)