设备层（Edge） → 边缘网关层（Gateway） → 云端LLM层（Cloud）
     ↓                    ↓                      ↓
  本地预处理         数据聚合压缩           最终违规判定

// 客户端帧筛选算法
function selectKeyFrames(videoStream) {
  const keyFrames = [];
  const motionThreshold = 0.3;
  const timeInterval = 2; // 每2秒最多选1帧
  
  for (let frame of videoStream) {
    // 1. 运动检测
    const motionScore = detectMotion(frame);
    
    // 2. 车辆密度检测
    const vehicleCount = countVehicles(frame);
    
    // 3. 场景复杂度评估
    const complexity = analyzeSceneComplexity(frame);
    
    // 4. 只保留可能有违规的帧
    if (motionScore > motionThreshold && 
        vehicleCount > 1 && 
        complexity > 0.5) {
      keyFrames.push({
        frame: compressFrame(frame, 0.3), // 压缩到30%质量
        timestamp: frame.timestamp,
        metadata: extractMetadata(frame)
      });
    }
  }
  
  return keyFrames.slice(0, 10); // 最多10个关键帧
}

# 客户端特征提取
def extract_features(frame):
    features = {
        # 车辆信息
        'vehicles': detect_vehicles_lightweight(frame),
        'traffic_lights': detect_traffic_lights(frame),
        'road_markings': detect_lane_markings(frame),
        
        # 运动特征
        'optical_flow': calculate_optical_flow(frame),
        'speed_estimation': estimate_vehicle_speed(frame),
        
        # 场景信息
        'weather': classify_weather(frame),
        'time_of_day': detect_time_of_day(frame),
        'road_type': classify_road_type(frame),
        
        # 压缩的图像特征向量
        'visual_features': extract_compact_features(frame)  # 512维向量
    }
    
    # 预判违规可能性
    violation_probability = lightweight_violation_detector(features)
    
    return {
        'features': features,
        'violation_score': violation_probability,
        'confidence': calculate_confidence(features)
    }

// 数据压缩上传策略
class DataCompressionUploader {
  
  async prepareUpload(processedFrames) {
    // 1. 只上传高违规可能性的帧
    const suspiciousFrames = processedFrames.filter(
      frame => frame.violation_score > 0.7
    );
    
    // 2. 图像压缩
    const compressedImages = await Promise.all(
      suspiciousFrames.map(frame => ({
        image: this.compressImage(frame.image, 'webp', 0.4), // WebP格式，40%质量
        thumbnail: this.generateThumbnail(frame.image, 200, 150), // 缩略图
        roi: this.extractROI(frame), // 感兴趣区域
        metadata: frame.metadata
      }))
    );
    
    // 3. 特征向量压缩
    const compressedFeatures = this.quantizeFeatures(
      suspiciousFrames.map(f => f.features)
    );
    
    // 4. 构建上传包
    const uploadPackage = {
      session_id: generateSessionId(),
      device_info: getDeviceInfo(),
      summary: this.generateSummary(suspiciousFrames), // 文字摘要
      compressed_data: {
        images: compressedImages.slice(0, 3), // 最多3张图
        features: compressedFeatures,
        timeline: this.extractTimeline(suspiciousFrames)
      },
      local_analysis: this.generateLocalReport(suspiciousFrames)
    };
    
    return uploadPackage;
  }
  
  generateSummary(frames) {
    // 生成简洁的文字描述，减少LLM输入Token
    return {
      scene_description: "城市道路，白天，多车道",
      potential_violations: ["可能超速", "疑似变道未打灯"],
      vehicle_count: frames.length,
      confidence_level: "中等"
    };
  }
}

# 优化后的LLM Prompt设计

## 输入格式标准化

#### Token优化技术
```/dev/null/token_optimization.py#L1-25
# Token使用优化策略
class TokenOptimizer:
    
    def optimize_prompt(self, upload_data):
        # 1. 使用结构化数据替代自然语言描述
        structured_input = {
            "scene_type": upload_data['scene_classification'],
            "violation_candidates": upload_data['local_analysis']['suspects'],
            "confidence_scores": upload_data['confidence_matrix'],
            "key_metrics": {
                "speed": upload_data['speed_analysis'],
                "distance": upload_data['distance_analysis'],
                "signals": upload_data['signal_status']
            }
        }
        
        # 2. 使用简化的问答格式
        prompt = f"""
        场景: {structured_input['scene_type']}
        疑似违规: {structured_input['violation_candidates']}
        数据: {structured_input['key_metrics']}
        
        判断结果:
        违规 (Y/N):
        类型:
        级别 (1-5):
        """
        
        return prompt
    
    def compress_response(self, llm_response):
        # 压缩LLM响应为标准化格式
        return {
            "violation": extract_yes_no(llm_response),
            "type": extract_violation_type(llm_response),
            "severity": extract_severity_level(llm_response),
            "reasoning": truncate_text(llm_response, 100)
        }

// 基于WebAssembly的浏览器端实现
class PWATrafficAnalyzer {
  
  async initialize() {
    // 加载WASM模型
    this.model = await tf.loadLayersModel('/models/traffic-detector.json');
    this.processor = new WebAssembly.instantiate(wasmModule);
  }
  
  async analyzeVideo(videoElement) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    
    // 每5秒采样一帧
    const frames = this.sampleFrames(videoElement, 5000);
    
    const results = [];
    for (let frame of frames) {
      // 本地AI推理
      const detection = await this.model.predict(frame);
      
      // 只保留高置信度结果
      if (detection.confidence > 0.8) {
        results.push({
          frame: this.compressFrame(frame),
          detection: detection,
          timestamp: frame.timestamp
        });
      }
    }
    
    return this.prepareForUpload(results);
  }
}

传统云端处理:
- 视频上传: 100MB
- LLM Token: 10,000 tokens
- 月成本: $500/用户

边缘计算方案:
- 数据上传: <1MB  
- LLM Token: <500 tokens
- 月成本: <$50/用户
- 成本降低: 90%+

这个设计方案的核心优势：
1. **90%+成本降低** - 通过本地预处理大幅减少上传数据和LLM Token使用
2. **更快响应** - 大部分处理在本地完成，用户体验更好
3. **隐私保护** - 原始视频不离开用户设备
4. **离线工作** - 基础功能可完全离线使用
5. **渐进增强** - 根据网络状况提供不同级别的服务

需要我进一步详细设计某个特定模块吗？