第5课 上机实验

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# === Step 1: 加载蒸馏模型 ===
distill_model_name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
distill_model = AutoModelForCausalLM.from_pretrained(
    distill_model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
distill_tokenizer = AutoTokenizer.from_pretrained(distill_model_name)

print(f"蒸馏模型参数量: {sum(p.numel() for p in distill_model.parameters()) / 1e9:.2f}B")
print(f"显存占用: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")


# === Step 2: GSM8K 评估 ===
gsm8k_test = [
    {"question": "一个商店卖苹果，每斤5元。小明买了3斤苹果，付了20元，应找回多少钱？", "answer": 5},
    {"question": "一列火车有12节车厢，每节车厢坐60人。如果火车满员，共有多少乘客？", "answer": 720},
    {"question": "甲、乙两人合作完成一项工作，甲单独做需10天，乙单独做需15天。两人合作几天能完成？", "answer": 6},
    {"question": "一个正方形的周长是24厘米，它的面积是多少平方厘米？", "answer": 36},
    {"question": "小红有一些糖果，她给了小明8颗后还剩12颗。她原来有多少颗糖果？", "answer": 20},
    {"question": "3个箱子共有45个球，第一个箱子比第二个多5个，第二个比第三个多5个。每个箱子各有多少球？", "answer": "20,15,10"},
    {"question": "一本书共300页，小明第一天读了全书的1/5，第二天读了剩下的1/4。第二天读了多少页？", "answer": 60},
    {"question": "把一根绳子对折3次后剪一刀，绳子被剪成几段？", "answer": 9},
    {"question": "一个数的3倍减去7等于20，这个数是多少？", "answer": 9},
    {"question": "长方形花坛长8米，宽5米。沿花坛外侧修一条1米宽的小路，小路面积是多少？", "answer": 32},
]

correct = 0
for i, problem in enumerate(gsm8k_test):
    messages = [{"role": "user", "content": problem["question"]}]
    text = distill_tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    inputs = distill_tokenizer(text, return_tensors="pt").to(distill_model.device)

    with torch.no_grad():
        output = distill_model.generate(
            **inputs, max_new_tokens=1024, do_sample=False, temperature=1.0
        )
    response = distill_tokenizer.decode(
        output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
    )

    print(f"\n问题 {i+1}: {problem['question']}")
    print(f"回复: {response[:300]}...")
    print(f"标准答案: {problem['answer']}")

    # 简单检查答案是否正确
    if str(problem["answer"]) in response:
        correct += 1
        print("✓ 正确")
    else:
        print("✗ 可能错误（需人工验证）")

print(f"\n准确率: {correct}/{len(gsm8k_test)} = {correct/len(gsm8k_test)*100:.1f}%")


# === Step 3: 分析推理链风格 ===
print("\n" + "="*60)
print("推理链风格分析")
print("="*60)

analysis_prompt = "一个工厂第一天生产了120件产品，第二天比第一天多生产20%，第三天生产的数量是前两天总和的一半。三天共生产了多少件产品？"

messages = [{"role": "user", "content": analysis_prompt}]
text = distill_tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
inputs = distill_tokenizer(text, return_tensors="pt").to(distill_model.device)

with torch.no_grad():
    output = distill_model.generate(
        **inputs, max_new_tokens=2048, do_sample=False
    )
full_response = distill_tokenizer.decode(
    output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
)

print(f"完整推理链:\n{full_response}")
print(f"\n推理链长度: {len(full_response)} 字符")

# 检查推理链特征
features = {
    "有逐步计算": "步" in full_response or "step" in full_response.lower(),
    "有自我验证": "验证" in full_response or "检查" in full_response,
    "有think标签": "<think>" in full_response,
    "有回溯修正": "不对" in full_response or "重新" in full_response,
}
print("\n推理链特征:")
for feat, present in features.items():
    print(f"  {feat}: {'是' if present else '否'}")

import torch
from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
from PIL import Image
import requests
from io import BytesIO

# === Step 1: 加载 VLM 模型 ===
vl_model_name = "Qwen/Qwen3-VL-2B-Instruct"
vl_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    vl_model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
processor = AutoProcessor.from_pretrained(vl_model_name)

print(f"VLM 模型已加载，显存: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB")


# === Step 2: 准备测试图片 ===
# 使用公开的测试图片 URL
test_images = [
    {
        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png",
        "description": "带透明背景的骰子图片",
        "questions": [
            "请描述图片中的内容。",
            "图片中有几个骰子？",
            "图片中有猫吗？",  # 幻觉测试
        ]
    },
    # 可以添加更多测试图片...
]

# 也可以使用本地图片
def load_image(image_source):
    """加载图片，支持 URL 和本地路径"""
    if image_source.startswith("http"):
        response = requests.get(image_source)
        return Image.open(BytesIO(response.content)).convert("RGB")
    else:
        return Image.open(image_source).convert("RGB")


# === Step 3: 视觉问答测试 ===
def vqa_test(image, question):
    """对图片进行视觉问答"""
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image", "image": image},
                {"type": "text", "text": question},
            ],
        }
    ]

    text = processor.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    inputs = processor(
        text=[text], images=[image], return_tensors="pt"
    ).to(vl_model.device)

    with torch.no_grad():
        output = vl_model.generate(**inputs, max_new_tokens=256, do_sample=False)

    response = processor.decode(output[0], skip_special_tokens=True)
    # 提取助手回复部分
    if "assistant" in response:
        response = response.split("assistant")[-1].strip()
    return response


# === Step 4: 运行测试 ===
print("\n视觉问答测试结果：")
print("="*60)

for img_info in test_images:
    try:
        image = load_image(img_info["url"])
        print(f"\n图片: {img_info['description']}")

        for question in img_info["questions"]:
            response = vqa_test(image, question)
            print(f"\n  Q: {question}")
            print(f"  A: {response[:200]}")
    except Exception as e:
        print(f"加载图片失败: {e}")
        continue


# === Step 5: 幻觉测试 ===
print("\n" + "="*60)
print("幻觉测试")
print("="*60)

# 准备幻觉测试问题（对不存在的内容提问）
hallucination_questions = [
    "图片中的文字写了什么？",      # 如果图中没有文字
    "图片中的人在做什么？",        # 如果图中没有人
    "图片中有几辆汽车？",          # 如果图中没有汽车
    "图片背景中的建筑是什么风格？",  # 如果没有建筑
    "图片中动物的品种是什么？",      # 如果没有动物
]

hallucination_count = 0
total_tests = 0

for img_info in test_images:
    try:
        image = load_image(img_info["url"])
        for question in hallucination_questions:
            response = vqa_test(image, question)
            total_tests += 1

            # 检查是否产生幻觉（模型编造了不存在的内容）
            refusal_keywords = ["没有", "不存在", "看不到", "无法", "图中没有", "not"]
            is_refusal = any(kw in response for kw in refusal_keywords)

            if not is_refusal:
                hallucination_count += 1
                status = "⚠️ 可能幻觉"
            else:
                status = "✓ 正确拒绝"

            print(f"  Q: {question}")
            print(f"  A: {response[:150]}")
            print(f"  状态: {status}")
    except Exception as e:
        continue

if total_tests > 0:
    print(f"\n幻觉率: {hallucination_count}/{total_tests} "
          f"= {hallucination_count/total_tests*100:.1f}%")

import torch
import json
import re
from transformers import AutoModelForCausalLM, AutoTokenizer

# === Step 1: 加载模型 ===
model_name = "Qwen/Qwen3-1.7B"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)


# === Step 2: 定义工具 ===
tools = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "一个简单的计算器，可以执行数学运算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式，如 '2 + 3 * 4'"
                    }
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_knowledge",
            "description": "搜索知识库获取信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "搜索关键词"
                    }
                },
                "required": ["query"]
            }
        }
    },
]


# === Step 3: 模拟工具执行 ===
def execute_tool(name, arguments):
    """模拟工具执行"""
    if name == "calculator":
        try:
            expr = arguments.get("expression", "")
            # 安全地计算数学表达式
            result = eval(expr, {"__builtins__": {}}, {})
            return json.dumps({"result": result})
        except Exception as e:
            return json.dumps({"error": str(e)})

    elif name == "get_weather":
        city = arguments.get("city", "未知")
        # 模拟天气数据
        mock_weather = {
            "北京": {"temp": 22, "condition": "晴", "humidity": 35},
            "上海": {"temp": 26, "condition": "多云", "humidity": 65},
            "深圳": {"temp": 30, "condition": "阵雨", "humidity": 80},
        }
        weather = mock_weather.get(city, {"temp": 20, "condition": "晴", "humidity": 50})
        return json.dumps(weather, ensure_ascii=False)

    elif name == "search_knowledge":
        query = arguments.get("query", "")
        # 模拟知识库搜索
        knowledge = {
            "LoRA": "LoRA是一种参数高效微调方法，通过低秩分解减少可训练参数。",
            "量化": "量化将模型权重从高精度压缩到低精度，减少显存占用。",
            "DPO": "DPO是直接偏好优化方法，无需奖励模型即可进行偏好对齐。",
        }
        for key, value in knowledge.items():
            if key in query:
                return json.dumps({"result": value}, ensure_ascii=False)
        return json.dumps({"result": "未找到相关信息"}, ensure_ascii=False)

    return json.dumps({"error": "未知工具"})


# === Step 4: 智能体循环 ===
def agent_loop(user_query, max_turns=3):
    """完整的智能体循环"""
    messages = [
        {"role": "system", "content": "你是一个有用的助手，可以使用工具来回答问题。"},
        {"role": "user", "content": user_query},
    ]

    print(f"\n用户: {user_query}")

    for turn in range(max_turns):
        # 生成回复
        text = tokenizer.apply_chat_template(
            messages, tools=tools, tokenize=False, add_generation_prompt=True
        )
        inputs = tokenizer(text, return_tensors="pt").to(model.device)

        with torch.no_grad():
            output = model.generate(
                **inputs, max_new_tokens=512, do_sample=False
            )
        response_text = tokenizer.decode(
            output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
        )

        print(f"\n助手 (Turn {turn+1}): {response_text[:300]}")

        # 检查是否包含工具调用
        tool_call_match = re.search(
            r'<tool_call>\s*(\{.*?\})\s*</tool_call>',
            response_text, re.DOTALL
        )

        if tool_call_match:
            try:
                tool_call = json.loads(tool_call_match.group(1))
                tool_name = tool_call.get("name", "")
                tool_args = tool_call.get("arguments", {})

                print(f"  → 调用工具: {tool_name}({json.dumps(tool_args, ensure_ascii=False)})")

                # 执行工具
                result = execute_tool(tool_name, tool_args)
                print(f"  ← 工具返回: {result}")

                # 将工具调用和结果添加到消息中
                messages.append({"role": "assistant", "content": response_text})
                messages.append({
                    "role": "tool",
                    "name": tool_name,
                    "content": result
                })
            except json.JSONDecodeError:
                print("  ⚠️ 工具调用解析失败")
                break
        else:
            # 没有工具调用，直接返回
            print(f"\n最终回复: {response_text}")
            return response_text

    return "达到最大轮数"


# === Step 5: 测试场景 ===
test_queries = [
    "请帮我计算 (15 + 27) * 3 - 40 的结果。",
    "北京今天天气怎么样？",
    "帮我查一下 LoRA 是什么？",
    "上海的温度是多少？如果温度超过25度请提醒我带伞。",
    "请帮我计算一个圆的面积，半径是5厘米。（使用3.14159计算）",
]

correct = 0
total = len(test_queries)

for query in test_queries:
    print("\n" + "="*60)
    result = agent_loop(query)
    # 人工判断是否正确（可自动化）
    print(f"\n请评估此回复是否正确 (y/n): ", end="")
    # 在实际实验中可以记录结果


# === Step 6: 与小模型对比（可选）===
print("\n\n" + "="*60)
print("与 Qwen3-0.6B 对比测试")
print("="*60)

# 加载 0.6B 模型
small_model_name = "Qwen/Qwen3-0.6B"
small_model = AutoModelForCausalLM.from_pretrained(
    small_model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
small_tokenizer = AutoTokenizer.from_pretrained(small_model_name)

# 用相同的测试场景对比
for query in test_queries[:3]:  # 测试前3个
    print(f"\n查询: {query}")

    messages = [
        {"role": "system", "content": "你是一个有用的助手，可以使用工具来回答问题。"},
        {"role": "user", "content": query},
    ]
    text = small_tokenizer.apply_chat_template(
        messages, tools=tools, tokenize=False, add_generation_prompt=True
    )
    inputs = small_tokenizer(text, return_tensors="pt").to(small_model.device)

    with torch.no_grad():
        output = small_model.generate(
            **inputs, max_new_tokens=512, do_sample=False
        )
    response = small_tokenizer.decode(
        output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True
    )
    print(f"Qwen3-0.6B 回复: {response[:200]}")