Claude Opus 4.7 深度解析：Tokenizer 革命、视觉能力跃升与推理增强

import requests
import json

class OpusTokenCounter:
    """对比 Opus 4.6 和 4.7 的 token 数量差异"""
    
    API_URL = "https://api.anthropic.com/v1/messages/count_tokens"
    
    def __init__(self, api_key: str):
        self.headers = {
            "x-api-key": api_key,
            "anthropic-version": "2026-04-01",
            "content-type": "application/json"
        }
    
    def count_tokens(self, text: str, model: str = "claude-opus-4.7") -> int:
        """调用 Anthropic API 计算 token 数"""
        payload = {
            "model": model,
            "messages": [
                {"role": "user", "content": text}
            ]
        }
        response = requests.post(self.API_URL, headers=self.headers, json=payload)
        response.raise_for_status()
        return response.json()["input_tokens"]
    
    def compare_models(self, text: str) -> dict:
        """对比多个模型的 token 计数"""
        models = [
            "claude-opus-4.6",
            "claude-opus-4.7",
            "claude-sonnet-4.6",
            "claude-haiku-4.5"
        ]
        results = {}
        for model in models:
            try:
                tokens = self.count_tokens(text, model)
                results[model] = tokens
                print(f"{model}: {tokens:,} tokens")
            except Exception as e:
                print(f"{model}: 错误 - {e}")
        
        # 计算相对于 4.6 的增长率
        if "claude-opus-4.6" in results:
            base = results["claude-opus-4.6"]
            if "claude-opus-4.7" in results:
                ratio = results["claude-opus-4.7"] / base
                print(f"\nOpus 4.7 vs 4.6 增长率: {ratio:.2f}x")
        
        return results

# 使用示例
counter = OpusTokenCounter("your-api-key")

# 测试不同类型的文本
test_texts = {
    "系统提示词": "你是一个专业的AI助手，擅长...",
    "代码片段": "def fibonacci(n): return fibonacci(n-1) + fibonacci(n-2)",
    "技术文档": "本文档描述了API的使用方法和最佳实践..."
}

for name, text in test_texts.items():
    print(f"\n=== {name} ===")
    counter.compare_models(text)

import base64
import requests
from PIL import Image
import io

class OpusVisionTester:
    """测试 Opus 4.7 的视觉理解能力"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "x-api-key": api_key,
            "anthropic-version": "2026-04-01",
            "content-type": "application/json"
        }
    
    def encode_image(self, image_path: str) -> str:
        """将图片编码为 base64"""
        with open(image_path, "rb") as f:
            return base64.b64encode(f.read()).decode("utf-8")
    
    def analyze_image(self, image_path: str, prompt: str, 
                      model: str = "claude-opus-4.7") -> str:
        """分析图片内容"""
        image_data = self.encode_image(image_path)
        
        # 获取图片尺寸
        img = Image.open(image_path)
        width, height = img.size
        print(f"图片尺寸: {width}x{height} ({width*height:,} 像素)")
        
        payload = {
            "model": model,
            "max_tokens": 2048,
            "messages": [{
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "base64",
                            "media_type": "image/png",
                            "data": image_data
                        }
                    },
                    {
                        "type": "text",
                        "text": prompt
                    }
                ]
            }]
        }
        
        response = requests.post(
            "https://api.anthropic.com/v1/messages",
            headers=self.headers,
            json=payload
        )
        response.raise_for_status()
        result = response.json()
        
        print(f"消耗 tokens: 输入={result.get('usage', {}).get('input_tokens')}, "
              f"输出={result.get('usage', {}).get('output_tokens')}")
        
        return result["content"][0]["text"]

# 使用示例
tester = OpusVisionTester("your-api-key")

# 测试不同分辨率的图片
test_images = [
    "small_screenshot.png",      # ~682x318
    "hd_diagram.png",            # ~1920x1080  
    "high_res_photo.png",        # ~3456x2234
]

for img in test_images:
    print(f"\n=== 分析: {img} ===")
    result = tester.analyze_image(img, "请详细描述这张图片的内容")
    print(f"分析结果: {result[:200]}...")

import os
import io
from anthropic import Anthropic
from PIL import Image
import base64

# 初始化客户端
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def smart_chat(prompt: str, image_path: str = None, 
               complexity: str = "medium") -> str:
    """
    根据问题复杂度智能选择 thinking 级别和图片处理策略
    
    Args:
        prompt: 用户问题
        image_path: 可选的图片路径
        complexity: 问题复杂度 (simple/medium/hard/extreme)
    
    Returns:
        模型回复
    """
    # 映射复杂度到 thinking 级别
    thinking_map = {
        "simple": "low",
        "medium": "medium", 
        "hard": "high",
        "extreme": "xhigh"
    }
    thinking_effort = thinking_map.get(complexity, "medium")
    
    # 构建消息内容
    content = [{"type": "text", "text": prompt}]
    
    if image_path:
        img = Image.open(image_path)
        width, height = img.size
        max_pixels = width * height
        
        # 根据 thinking 级别决定是否降采样
        if thinking_effort in ("low", "medium") and max_pixels > 1_000_000:
            # 中等复杂度不需要原图分辨率
            ratio = (1_000_000 / max_pixels) ** 0.5
            new_size = (int(width * ratio), int(height * ratio))
            img = img.resize(new_size, Image.LANCZOS)
            print(f"降采样: {width}x{height} -> {new_size[0]}x{new_size[1]}")
        
        # 编码处理后的图片
        img_byte_arr = io.BytesIO()
        img.save(img_byte_arr, format="PNG")
        img_base64 = base64.b64encode(img_byte_arr.getvalue()).decode()
        
        content.append({
            "type": "image",
            "source": {
                "type": "base64",
                "media_type": "image/png",
                "data": img_base64
            }
        })
    
    # 调用 API
    response = client.messages.create(
        model="claude-opus-4.7",
        max_tokens=4096,
        thinking={
            "type": "enabled",
            "effort": thinking_effort,
        },
        messages=[{"role": "user", "content": content}]
    )
    
    # 输出统计信息
    usage = response.usage
    print(f"Token 使用: 输入={usage.input_tokens}, 输出={usage.output_tokens}")
    
    return response.content[0].text

# 使用示例
# 简单问答 - 用 low thinking，节省成本
result1 = smart_chat("Python 中列表和元组的区别是什么？", complexity="simple")

# 图片分析 - 用 high thinking，保持原图质量
result2 = smart_chat(
    "请分析这张架构图并提出改进建议", 
    image_path="architecture.png",
    complexity="hard"
)

# 复杂推理 - 用 xhigh thinking
result3 = smart_chat(
    "证明费马大定理在 n=3 的情况下的特殊情况...", 
    complexity="extreme"
)