# 部署Phi-3 Mini模型
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载模型
model_name = "microsoft/Phi-3-mini-4k-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# 对话函数
def chat_with_phi3(message, system_prompt="You are a helpful AI assistant."):
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": message}
    ]

    # 应用聊天模板
    input_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)

    # 生成回答
    with torch.no_grad():
        outputs = model.generate(
            input_ids,
            max_new_tokens=1000,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id
        )

    response = tokenizer.decode(
        outputs[0][input_ids.shape[-1]:],
        skip_special_tokens=True
    )

    return response

# 使用示例
response = chat_with_phi3("请解释量子计算的基本原理")
print(response)

# 部署Phi-3 Mini 128K长上下文版本
model_name = "microsoft/Phi-3-mini-128k-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# 长文档处理函数
def process_long_document(document, question):
    messages = [
        {
            "role": "system",
            "content": "你是一个专业的文档分析助手，能够处理长文档并回答相关问题。"
        },
        {
            "role": "user",
            "content": f"文档内容：\n{document}\n\n问题：{question}"
        }
    ]

    input_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)

    # 检查输入长度
    if input_ids.shape[1] > 128000:
        print(f"警告：输入长度 {input_ids.shape[1]} 超过128K限制")
        return "文档过长，请分段处理"

    with torch.no_grad():
        outputs = model.generate(
            input_ids,
            max_new_tokens=2000,
            do_sample=True,
            temperature=0.3,
            top_p=0.9
        )

    response = tokenizer.decode(
        outputs[0][input_ids.shape[-1]:],
        skip_special_tokens=True
    )

    return response

# 使用示例
long_doc = """这里是一个很长的文档内容..."""
question = "请总结文档的主要观点"
response = process_long_document(long_doc, question)
print(response)

# 使用ONNX Runtime进行移动端优化
import onnxruntime as ort
import numpy as np

class MobilePhi3:
    def __init__(self, model_path):
        # 配置ONNX Runtime
        self.session = ort.InferenceSession(
            model_path,
            providers=[
                'CPUExecutionProvider',
                # 'CoreMLExecutionProvider',  # iOS
                # 'NNAPIExecutionProvider',   # Android
            ]
        )

    def generate(self, input_ids, max_length=512):
        # 移动端推理
        outputs = self.session.run(
            None,
            {'input_ids': input_ids.astype(np.int64)}
        )
        return outputs[0]

# 量化优化
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4"
)

# 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3-mini-4k-instruct",
    quantization_config=quantization_config,
    device_map="auto",
    trust_remote_code=True
)

# 使用Hugging Face Transformers部署Mistral 7B
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载模型和分词器
model_name = "mistralai/Mistral-7B-Instruct-v0.1"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 对话函数
def chat_with_mistral(message, system_prompt="You are a helpful assistant."):
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": message}
    ]

    # 应用聊天模板
    input_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)

    # 生成回答
    with torch.no_grad():
        outputs = model.generate(
            input_ids,
            max_new_tokens=1000,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id
        )

    response = tokenizer.decode(
        outputs[0][input_ids.shape[-1]:],
        skip_special_tokens=True
    )

    return response

# 使用示例
response = chat_with_mistral("请解释什么是机器学习？")
print(response)

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

# 下载并运行Mistral 7B
ollama pull mistral
ollama run mistral

# 在Python中使用Ollama API
import requests
import json

def ollama_chat(message):
    url = "http://localhost:11434/api/generate"
    data = {
        "model": "mistral",
        "prompt": message,
        "stream": False
    }

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

# 使用示例
response = ollama_chat("写一个Python快速排序算法")
print(response)

# Mistral 7B函数调用示例
import json

# 定义工具函数
def get_weather(location):
    """获取指定地点的天气信息"""
    # 模拟天气API调用
    return f"{location}的天气：晴天，温度25°C"

def calculate(expression):
    """计算数学表达式"""
    try:
        result = eval(expression)
        return f"计算结果：{result}"
    except:
        return "计算错误"

# 工具描述
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "地点名称"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "计算数学表达式",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# 函数调用处理
def process_function_call(message):
    # 构建包含工具信息的提示
    system_prompt = f"""
    你是一个有用的助手，可以调用以下工具：
    {json.dumps(tools, ensure_ascii=False, indent=2)}

    当需要使用工具时，请按以下格式回答：
    <function_call>
    {{"name": "function_name", "arguments": {{"param": "value"}}}}
    </function_call>
    """

    response = chat_with_mistral(message, system_prompt)

    # 检查是否包含函数调用
    if "<function_call>" in response:
        # 提取函数调用信息
        start = response.find("<function_call>") + len("<function_call>")
        end = response.find("</function_call>")
        function_call_str = response[start:end].strip()

        try:
            function_call = json.loads(function_call_str)
            function_name = function_call["name"]
            arguments = function_call["arguments"]

            # 执行函数
            if function_name == "get_weather":
                result = get_weather(arguments["location"])
            elif function_name == "calculate":
                result = calculate(arguments["expression"])
            else:
                result = "未知函数"

            return result
        except:
            return "函数调用格式错误"

    return response

# 使用示例
print(process_function_call("北京的天气怎么样？"))
print(process_function_call("计算 15 * 23 + 7"))

# 部署Llama 3.2-3B文本模型
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载模型
model_name = "meta-llama/Llama-3.2-3B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 对话示例
def chat_with_llama(message, history=[]):
    messages = history + [{"role": "user", "content": message}]

    input_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            input_ids,
            max_new_tokens=512,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id
        )

    response = tokenizer.decode(
        outputs[0][input_ids.shape[-1]:],
        skip_special_tokens=True
    )

    return response

# 使用示例
response = chat_with_llama("请解释什么是边缘计算？")
print(response)

# 部署Llama 3.2-11B-Vision多模态模型
from transformers import MllamaForConditionalGeneration, AutoProcessor
from PIL import Image
import torch

# 加载视觉模型
model_name = "meta-llama/Llama-3.2-11B-Vision-Instruct"
processor = AutoProcessor.from_pretrained(model_name)
model = MllamaForConditionalGeneration.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 图像分析函数
def analyze_image(image_path, question):
    # 加载图像
    image = Image.open(image_path)

    # 准备输入
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image"},
                {"type": "text", "text": question}
            ]
        }
    ]

    # 处理输入
    input_text = processor.apply_chat_template(
        messages,
        add_generation_prompt=True
    )
    inputs = processor(
        image,
        input_text,
        return_tensors="pt"
    ).to(model.device)

    # 生成回答
    with torch.no_grad():
        output = model.generate(
            **inputs,
            max_new_tokens=1000,
            do_sample=True,
            temperature=0.7
        )

    response = processor.decode(
        output[0][inputs['input_ids'].shape[-1]:],
        skip_special_tokens=True
    )

    return response

# 使用示例
response = analyze_image(
    "document.jpg",
    "请提取这个文档中的关键信息"
)
print(response)

# 使用ONNX Runtime进行移动端部署
import onnxruntime as ort
import numpy as np

class MobileLlama:
    def __init__(self, model_path):
        # 加载ONNX模型
        self.session = ort.InferenceSession(
            model_path,
            providers=['CPUExecutionProvider']
        )

    def generate(self, input_ids, max_length=512):
        # 移动端推理逻辑
        outputs = self.session.run(
            None,
            {'input_ids': input_ids.astype(np.int64)}
        )
        return outputs[0]

# 部署到移动设备
mobile_model = MobileLlama("llama-3.2-1b-mobile.onnx")