DAMO-YOLO手机检测模型可复现性保障：Docker+MLflow实验追踪实践

1. 引言

在计算机视觉项目中，尤其是像手机检测这样的工业级应用，我们常常面临一个棘手的问题：如何确保今天的实验结果，明天还能一模一样地复现出来？

想象一下这个场景：你基于阿里巴巴的DAMO-YOLO模型，成功训练出一个AP@0.5达到88.8%、推理速度仅3.83ms的高性能手机检测模型。性能数据很漂亮，你也准备把项目交付给团队。但一个月后，当同事需要基于你的工作继续优化时，却发现怎么也跑不出你当初的结果——依赖版本变了、环境配置不同、训练参数记不清了……

这就是可复现性危机，它让很多优秀的AI项目最终只能停留在“一次性实验”的阶段。

本文将带你解决这个问题。我将分享如何通过Docker容器化和MLflow实验追踪这两个工具，为DAMO-YOLO手机检测模型构建一个完整的可复现性保障体系。读完本文，你将掌握：

• 如何用Docker打包整个手机检测项目的运行环境
• 如何用MLflow记录每一次实验的完整“快照”
• 如何确保任何人、在任何时间都能复现你的实验结果
• 如何将这个体系应用到实际的模型部署和服务中

无论你是独立研究者、团队负责人，还是需要交付稳定AI产品的工程师，这套方法都能让你的工作更加可靠、协作更加顺畅。

2. 为什么可复现性对手机检测项目如此重要？

2.1 手机检测项目的特殊性

手机检测看似是一个简单的单类目标检测任务，但在实际应用中却面临着独特的挑战：

数据层面的复杂性：

• 手机形态多样：直板机、折叠机、不同品牌、不同颜色
• 使用场景多变：手持、桌面、包装盒内、广告海报中
• 拍摄条件差异：光照变化、角度变化、遮挡情况

模型层面的敏感性：

• DAMO-YOLO这类轻量级模型对超参数非常敏感
• 微小的学习率变化可能导致mAP波动1-2个百分点
• 数据增强策略直接影响模型在复杂场景下的泛化能力

2.2 传统工作流的痛点

在没有系统化可复现性保障的情况下，手机检测项目通常会遇到这些问题：

环境依赖的“隐形炸弹”：

# 看似简单的依赖，实则暗藏玄机
torch==1.9.0  # 升级到1.10.0可能导致精度下降
opencv-python==4.5.3.56  # 不同版本图像解码结果可能不同
modelscope==1.34.0  # 框架版本直接影响模型加载

实验记录的“记忆碎片”：

• 训练日志分散在各个终端窗口
• 最佳模型对应的超参数记在某个txt文件里
• 验证集结果截图存在本地，没有系统关联

协作时的“沟通成本”：

• “你用的Python是3.8还是3.9？”
• “CUDA版本是多少？我这边跑不起来”
• “这个88.8%的AP是在什么配置下测的？”

2.3 可复现性带来的实际价值

建立可复现性体系后，你将获得这些实实在在的好处：

对个人研究者：

• 随时回溯到任意历史实验状态
• 精确对比不同超参数配置的效果
• 避免“我上周是怎么调出这个结果的？”的困惑

对团队协作：

• 新成员能快速复现基线结果
• 多人实验对比有了统一基准
• 代码评审时能准确验证实验结果

对项目交付：

• 客户要求复现某个版本时，能快速响应
• 模型上线后出现问题，能追溯到训练时的具体配置
• 为论文发表提供完整的实验证据链

3. Docker容器化：冻结你的实验环境

3.1 Docker基础概念快速理解

如果你对Docker还不熟悉，可以这样理解：Docker就像是一个“环境打包箱”。

传统方式部署项目时，你需要告诉同事：“先装Python 3.8，然后装PyTorch 1.9，记得CUDA要11.1版本，还有opencv-python要4.5.3……”这一长串要求，就是所谓的“环境配置”。

而Docker的做法是：你直接把这个配置好的环境，连同你的代码一起，打包成一个“镜像”。同事拿到这个镜像后，一键就能运行，完全不需要关心底层环境。

3.2 为DAMO-YOLO手机检测创建Docker镜像

让我们从零开始，为手机检测项目创建一个完整的Docker环境。

第一步：编写Dockerfile

Dockerfile就像是环境的“配方”，告诉Docker如何构建你的运行环境。

# 使用官方PyTorch镜像作为基础
FROM pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    libgl1-mesa-glx \
    libglib2.0-0 \
    libsm6 \
    libxext6 \
    libxrender-dev \
    libgomp1 \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt \
    && pip install mlflow==2.8.1 \
    && pip install boto3==1.34.0  # 如果需要远程存储

# 复制项目代码
COPY . .

# 设置环境变量
ENV PYTHONPATH=/app
ENV MODEL_CACHE_DIR=/app/models
ENV MLFLOW_TRACKING_URI=file:/app/mlruns

# 创建必要的目录
RUN mkdir -p /app/mlruns /app/models /app/data

# 暴露服务端口
EXPOSE 7860 5000

# 设置默认命令
CMD ["python", "app.py"]

第二步：创建requirements.txt

这是Python依赖的清单，确保每次安装的版本完全一致。

# 核心框架
torch==2.0.1
torchvision==0.15.2

# 模型相关
modelscope==1.34.0
easydict==1.10

# 图像处理
opencv-python==4.8.1.78
Pillow==10.0.1

# Web服务
gradio==4.0.0
flask==3.0.0

# 工具库
numpy==1.24.3
pandas==2.0.3
tqdm==4.65.0

第三步：构建和测试镜像

有了Dockerfile和requirements.txt，就可以构建镜像了。

# 构建镜像（注意最后的点号）
docker build -t damoyolo-phone-detection:1.0 .

# 查看构建的镜像
docker images

# 运行测试
docker run -it --rm \
  -p 7860:7860 \
  -p 5000:5000 \
  -v $(pwd)/data:/app/data \
  damoyolo-phone-detection:1.0 \
  python test_environment.py

3.3 Docker Compose编排多服务

在实际的手机检测项目中，我们通常需要多个服务协同工作：模型服务、实验追踪服务、数据存储服务等。Docker Compose可以帮我们一键启动所有服务。

创建docker-compose.yml：

version: '3.8'

services:
  # 手机检测模型服务
  detection-service:
    build: .
    image: damoyolo-phone-detection:1.0
    container_name: phone-detection
    ports:
      - "7860:7860"  # Gradio Web界面
    volumes:
      - ./models:/app/models  # 模型缓存
      - ./data:/app/data      # 数据目录
      - ./experiments:/app/experiments  # 实验数据
    environment:
      - MLFLOW_TRACKING_URI=http://mlflow:5000
    depends_on:
      - mlflow
    command: python app.py

  # MLflow实验追踪服务
  mlflow:
    image: ghcr.io/mlflow/mlflow:latest
    container_name: mlflow-server
    ports:
      - "5001:5000"
    volumes:
      - ./mlruns:/mlflow
      - ./mlflow-artifacts:/mlflow-artifacts
    environment:
      - MLFLOW_TRACKING_URI=http://mlflow:5000
      - MLFLOW_S3_ENDPOINT_URL=http://minio:9000  # 如果使用MinIO
    command: >
      mlflow server
      --backend-store-uri /mlflow
      --default-artifact-root /mlflow-artifacts
      --host 0.0.0.0

  # 对象存储服务（用于存储模型和数据集）
  minio:
    image: minio/minio:latest
    container_name: minio
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes:
      - ./minio-data:/data
    environment:
      - MINIO_ROOT_USER=admin
      - MINIO_ROOT_PASSWORD=password123
    command: server /data --console-address ":9001"

volumes:
  models:
  data:
  mlruns:
  mlflow-artifacts:
  minio-data:

一键启动所有服务：

# 启动所有服务
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看日志
docker-compose logs -f detection-service

# 停止所有服务
docker-compose down

3.4 实际应用：团队协作场景

假设你的团队有3个成员都在做手机检测模型的优化，使用Docker后的协作流程是这样的：

新成员加入时：

# 1. 克隆代码
git clone https://github.com/your-team/phone-detection.git

# 2. 一键启动环境
cd phone-detection
docker-compose up -d

# 3. 立即开始工作
# 环境完全一致，无需任何配置

分享实验环境时：

# 导出镜像
docker save -o damoyolo-env.tar damoyolo-phone-detection:1.0

# 同事导入镜像
docker load -i damoyolo-env.tar

# 或者推送到镜像仓库
docker tag damoyolo-phone-detection:1.0 your-registry/phone-detection:1.0
docker push your-registry/phone-detection:1.0

更新环境时：

# 修改Dockerfile或requirements.txt后
docker-compose build --no-cache  # 重新构建
docker-compose up -d  # 重启服务

# 团队其他成员同步更新
git pull
docker-compose pull
docker-compose up -d

4. MLflow实验追踪：记录每一次实验的完整快照

4.1 MLflow是什么？为什么需要它？

MLflow可以理解为实验的“黑匣子”。每次你做实验（训练模型、调参、测试），MLflow都会自动记录：

1. 代码版本：你用的是哪个版本的代码
2. 参数配置：学习率、批量大小等所有超参数
3. 评估指标：AP@0.5、推理速度、loss曲线等
4. 输出文件：训练好的模型、日志文件、可视化结果
5. 环境信息：Python版本、依赖包、系统环境

这样，当你三个月后回顾“那个AP达到88.8%的实验是怎么做的”时，MLflow能告诉你一切细节。

4.2 集成MLflow到手机检测训练流程

让我们看看如何在实际的手机检测训练代码中集成MLflow。

基础集成示例：

import mlflow
import mlflow.pytorch
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks
import torch
import yaml

def train_phone_detector(config_path):
    """训练手机检测模型并记录实验"""
    
    # 1. 加载配置
    with open(config_path, 'r') as f:
        config = yaml.safe_load(f)
    
    # 2. 设置MLflow实验
    mlflow.set_experiment("phone-detection-experiments")
    
    # 3. 开始记录实验
    with mlflow.start_run(run_name=config['run_name']):
        
        # 记录超参数
        mlflow.log_params({
            'learning_rate': config['lr'],
            'batch_size': config['batch_size'],
            'epochs': config['epochs'],
            'img_size': config['img_size'],
            'model_name': 'damo/cv_tinynas_object-detection_damoyolo_phone'
        })
        
        # 记录代码版本
        mlflow.log_artifact(config_path, "configs")
        
        # 4. 初始化模型
        detector = pipeline(
            Tasks.domain_specific_object_detection,
            model='damo/cv_tinynas_object-detection_damoyolo_phone',
            cache_dir=config['cache_dir'],
            trust_remote_code=True
        )
        
        # 5. 训练循环
        best_map = 0
        for epoch in range(config['epochs']):
            # 训练代码...
            train_loss = train_one_epoch(detector, train_loader)
            
            # 验证
            val_metrics = evaluate(detector, val_loader)
            
            # 记录指标
            mlflow.log_metrics({
                'train_loss': train_loss,
                'val_map': val_metrics['mAP'],
                'val_map50': val_metrics['mAP50'],
                'epoch': epoch
            }, step=epoch)
            
            # 保存最佳模型
            if val_metrics['mAP50'] > best_map:
                best_map = val_metrics['mAP50']
                model_path = f"./models/best_model_epoch{epoch}.pt"
                torch.save(detector.model.state_dict(), model_path)
                
                # 记录模型到MLflow
                mlflow.pytorch.log_model(
                    detector.model,
                    "best_model",
                    registered_model_name="damoyolo-phone-detection"
                )
        
        # 6. 记录最终评估结果
        final_metrics = evaluate_on_testset(detector, test_loader)
        mlflow.log_metrics({
            'final_ap50': final_metrics['AP50'],
            'final_ap': final_metrics['AP'],
            'inference_speed_ms': final_metrics['speed_ms']
        })
        
        # 7. 记录可视化结果
        plot_results(final_metrics, save_path="./results/curves.png")
        mlflow.log_artifact("./results/", "evaluation_results")
        
        print(f"实验完成！最佳AP@0.5: {best_map:.1%}")
        print(f"MLflow运行ID: {mlflow.active_run().info.run_id}")

if __name__ == "__main__":
    train_phone_detector("configs/train_config.yaml")

4.3 记录手机检测特有的实验数据

手机检测项目有一些特殊的指标和可视化需求，我们需要专门记录：

记录检测性能指标：

def log_detection_metrics(detector, test_dataset, mlflow_run):
    """记录手机检测的详细评估指标"""
    
    results = evaluate_detector(detector, test_dataset)
    
    # 基础指标
    metrics = {
        'AP@0.5': results['AP50'],
        'AP@0.5:0.95': results['AP'],
        'AP_small': results['AP_small'],  # 小目标检测性能
        'AP_medium': results['AP_medium'],
        'AP_large': results['AP_large'],
        'AR_max1': results['AR1'],  # 每张图最多检测1个
        'AR_max10': results['AR10'],  # 每张图最多检测10个
        'inference_speed_fps': 1000 / results['inference_time_ms']
    }
    
    mlflow.log_metrics(metrics)
    
    # 记录混淆矩阵
    cm_fig = plot_confusion_matrix(results['confusion_matrix'])
    cm_fig.savefig('./results/confusion_matrix.png')
    mlflow.log_artifact('./results/confusion_matrix.png', "visualizations")
    
    # 记录PR曲线
    pr_fig = plot_pr_curve(results['precision'], results['recall'])
    pr_fig.savefig('./results/pr_curve.png')
    mlflow.log_artifact('./results/pr_curve.png', "visualizations")
    
    # 记录检测示例
    sample_detections = visualize_detections(
        detector, 
        test_dataset.sample_images,
        save_dir='./results/samples/'
    )
    mlflow.log_artifact('./results/samples/', "detection_examples")

记录模型部署信息：

def log_deployment_info(model_info, mlflow_run):
    """记录模型部署相关的信息"""
    
    deployment_metrics = {
        'model_size_mb': model_info['size_mb'],
        'parameters_millions': model_info['params_m'],
        'flops_g': model_info['flops_g'],
        'latency_cpu_ms': model_info['latency_cpu'],
        'latency_gpu_ms': model_info['latency_gpu'],
        'memory_usage_mb': model_info['memory_mb'],
        'supported_batch_sizes': str(model_info['batch_sizes'])
    }
    
    mlflow.log_metrics(deployment_metrics)
    
    # 记录性能测试结果
    perf_report = generate_performance_report(model_info)
    with open('./results/performance_report.md', 'w') as f:
        f.write(perf_report)
    mlflow.log_artifact('./results/performance_report.md', "deployment")

4.4 MLflow UI：可视化查看所有实验

MLflow提供了一个Web界面，让你可以直观地查看和管理所有实验。

启动MLflow UI：

# 在Docker环境中
docker-compose exec mlflow mlflow ui --host 0.0.0.0 --port 5000

# 或者直接访问
# http://localhost:5001

在UI中你可以：

1. 比较不同实验：并列查看多个实验的超参数和指标
2. 筛选和排序：按AP@0.5排序，快速找到最佳模型
3. 查看详细记录：点击任意实验，查看完整的参数、指标、代码版本
4. 下载模型和结果：直接下载训练好的模型文件
5. 注册模型：将最佳模型标记为生产版本

实验对比示例： 假设你尝试了不同的学习率，MLflow UI会显示这样的对比表格：

实验名称	学习率	批量大小	AP@0.5	推理速度	训练时间
lr-0.01-bs16	0.01	16	87.2%	3.92ms	2.5h
lr-0.001-bs32	0.001	32	88.8%	3.83ms	3.1h
lr-0.005-bs24	0.005	24	88.1%	3.87ms	2.8h

这样一眼就能看出，学习率0.001、批量大小32的配置效果最好。

5. 完整实践：从训练到部署的可复现流水线

5.1 项目结构设计

一个完整的可复现手机检测项目应该有这样的结构：

phone-detection-project/
├── docker/
│   ├── Dockerfile              # 基础环境定义
│   ├── docker-compose.yml      # 服务编排
│   └── requirements.txt        # Python依赖
├── src/
│   ├── train.py               # 训练脚本（集成MLflow）
│   ├── evaluate.py            # 评估脚本
│   ├── deploy.py              # 部署脚本
│   └── utils/
│       ├── data_loader.py     # 数据加载
│       ├── metrics.py         # 指标计算
│       └── visualization.py   # 可视化工具
├── configs/
│   ├── train_config.yaml      # 训练配置
│   ├── eval_config.yaml       # 评估配置
│   └── deploy_config.yaml     # 部署配置
├── data/
│   ├── raw/                   # 原始数据
│   ├── processed/             # 处理后的数据
│   └── splits/               # 训练/验证/测试划分
├── experiments/               # 实验输出
│   ├── runs/                 # MLflow运行记录
│   └── models/               # 保存的模型
├── scripts/
│   ├── setup_environment.sh  # 环境设置脚本
│   ├── run_training.sh       # 训练启动脚本
│   └── run_evaluation.sh     # 评估脚本
└── docs/
    ├── experiment_protocol.md # 实验协议
    └── reproduction_guide.md  # 复现指南

5.2 训练阶段的可复现保障

训练配置管理：

# configs/train_config.yaml
experiment:
  name: "damoyolo-phone-v1.0"
  description: "DAMO-YOLO手机检测模型v1.0训练"
  tags: ["phone-detection", "damo-yolo", "production"]

data:
  dataset_path: "/app/data/phone_detection"
  train_split: "train.txt"
  val_split: "val.txt"
  image_size: 640
  batch_size: 32
  num_workers: 4
  augmentations:
    hflip_prob: 0.5
    scale_range: [0.5, 1.5]
    color_jitter: true

model:
  backbone: "tinynas"
  neck: "cspnext"
  head: "damoyolo"
  pretrained: true
  num_classes: 1  # 只检测手机
  checkpoint: "/app/models/pretrained/damoyolo_phone.pt"

training:
  epochs: 100
  learning_rate: 0.001
  weight_decay: 0.0005
  warmup_epochs: 5
  optimizer: "AdamW"
  scheduler: "CosineAnnealingLR"
  save_frequency: 10  # 每10个epoch保存一次

evaluation:
  metrics: ["AP", "AP50", "AP75", "APs", "APm", "APl"]
  iou_thresholds: [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
  confidence_threshold: 0.25
  nms_threshold: 0.45

mlflow:
  tracking_uri: "http://mlflow:5000"
  experiment_name: "phone-detection"
  artifact_location: "/app/experiments"
  log_every: 10  # 每10个iteration记录一次

训练脚本：

# scripts/run_training.sh
#!/bin/bash

# 设置环境变量
export PYTHONPATH=/app/src
export MLFLOW_TRACKING_URI=http://mlflow:5000
export MODEL_CACHE_DIR=/app/models

# 创建实验目录
mkdir -p /app/experiments/runs
mkdir -p /app/experiments/models

# 记录实验开始时间
START_TIME=$(date +%Y%m%d_%H%M%S)
EXPERIMENT_DIR="/app/experiments/runs/$START_TIME"

# 复制当前代码版本
git rev-parse HEAD > "$EXPERIMENT_DIR/git_commit.txt"
git diff > "$EXPERIMENT_DIR/code_changes.diff"

# 复制配置文件
cp /app/configs/train_config.yaml "$EXPERIMENT_DIR/"

# 启动训练
python /app/src/train.py \
  --config /app/configs/train_config.yaml \
  --experiment-dir "$EXPERIMENT_DIR" \
  --mlflow-experiment "phone-detection-$START_TIME"

# 记录实验结束时间和状态
echo "Experiment completed at $(date)" >> "$EXPERIMENT_DIR/experiment_log.txt"
echo "Exit code: $?" >> "$EXPERIMENT_DIR/experiment_log.txt"

5.3 评估阶段的可复现保障

评估脚本：

# src/evaluate.py
import mlflow
import argparse
import yaml
from pathlib import Path

def reproduce_evaluation(run_id, config_path, output_dir):
    """
    复现指定实验的评估结果
    
    Args:
        run_id: MLflow运行ID
        config_path: 实验配置路径
        output_dir: 输出目录
    """
    
    # 1. 从MLflow获取实验信息
    client = mlflow.tracking.MlflowClient()
    run = client.get_run(run_id)
    
    # 2. 恢复实验环境
    print("恢复实验环境...")
    env_info = run.data.tags.get('environment', '{}')
    
    # 3. 加载原始配置
    with open(config_path, 'r') as f:
        config = yaml.safe_load(f)
    
    # 4. 下载模型
    print("下载模型...")
    model_path = client.download_artifacts(run_id, "best_model")
    
    # 5. 加载数据（使用原始数据路径）
    data_path = config['data']['dataset_path']
    test_split = config['data'].get('test_split', 'test.txt')
    
    # 6. 运行评估
    print("运行评估...")
    results = evaluate_model(
        model_path=model_path,
        data_path=data_path,
        test_split=test_split,
        config=config
    )
    
    # 7. 对比结果
    original_metrics = {
        'AP@0.5': run.data.metrics.get('final_ap50', 0),
        'AP': run.data.metrics.get('final_ap', 0),
        'inference_speed': run.data.metrics.get('inference_speed_ms', 0)
    }
    
    print("\n" + "="*50)
    print("评估结果对比")
    print("="*50)
    print(f"{'指标':<20} {'原始结果':<15} {'复现结果':<15} {'差异':<10}")
    print("-"*50)
    
    for key in original_metrics:
        original = original_metrics[key]
        reproduced = results.get(key, 0)
        diff = abs(original - reproduced)
        
        status = "✅ 一致" if diff < 0.001 else "⚠️  有差异"
        print(f"{key:<20} {original:<15.4f} {reproduced:<15.4f} {diff:<10.4f} {status}")
    
    # 8. 保存复现报告
    report = generate_reproduction_report(run, results, config)
    report_path = Path(output_dir) / f"reproduction_report_{run_id}.md"
    report_path.write_text(report)
    
    print(f"\n复现报告已保存至: {report_path}")
    
    return results

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--run-id", required=True, help="MLflow运行ID")
    parser.add_argument("--config", required=True, help="配置文件路径")
    parser.add_argument("--output-dir", default="./reproduction_results")
    
    args = parser.parse_args()
    reproduce_evaluation(args.run_id, args.config, args.output_dir)

5.4 部署阶段的可复现保障

模型服务化部署：

# src/deploy.py
import mlflow
import gradio as gr
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks
import yaml
import json
from datetime import datetime

class PhoneDetectionService:
    """手机检测模型服务"""
    
    def __init__(self, model_version, config_path):
        # 从MLflow获取模型
        client = mlflow.tracking.MlflowClient()
        
        # 获取模型URI
        model_uri = f"models:/damoyolo-phone-detection/{model_version}"
        
        # 加载配置
        with open(config_path, 'r') as f:
            self.config = yaml.safe_load(f)
        
        # 记录部署信息
        self.deployment_info = {
            'model_version': model_version,
            'deployment_time': datetime.now().isoformat(),
            'config': self.config,
            'environment': self._get_environment_info()
        }
        
        # 加载模型
        print(f"加载模型版本: {model_version}")
        self.detector = mlflow.pyfunc.load_model(model_uri)
        
        # 或者使用ModelScope原生方式
        # self.detector = pipeline(
        #     Tasks.domain_specific_object_detection,
        #     model=model_uri,
        #     cache_dir=self.config['model']['cache_dir'],
        #     trust_remote_code=True
        # )
    
    def predict(self, image):
        """执行检测"""
        start_time = datetime.now()
        
        # 执行推理
        result = self.detector.predict(image)
        
        # 计算推理时间
        inference_time = (datetime.now() - start_time).total_seconds() * 1000
        
        # 记录本次推理
        self._log_inference({
            'timestamp': datetime.now().isoformat(),
            'inference_time_ms': inference_time,
            'image_size': image.shape,
            'detections_count': len(result['boxes']) if 'boxes' in result else 0
        })
        
        return result, inference_time
    
    def _get_environment_info(self):
        """获取环境信息"""
        import torch
        import sys
        
        return {
            'python_version': sys.version,
            'torch_version': torch.__version__,
            'cuda_available': torch.cuda.is_available(),
            'cuda_version': torch.version.cuda if torch.cuda.is_available() else None,
            'device_count': torch.cuda.device_count() if torch.cuda.is_available() else 0
        }
    
    def _log_inference(self, inference_data):
        """记录推理日志"""
        log_file = "./logs/inference_log.jsonl"
        with open(log_file, 'a') as f:
            f.write(json.dumps(inference_data) + '\n')
    
    def get_service_info(self):
        """获取服务信息"""
        return {
            'service': 'Phone Detection Service',
            'model': 'DAMO-YOLO Phone Detection',
            'version': self.deployment_info['model_version'],
            'performance': {
                'ap50': self.config['model'].get('ap50', 88.8),
                'inference_speed_ms': self.config['model'].get('inference_speed', 3.83)
            },
            'deployed_at': self.deployment_info['deployment_time'],
            'environment': self.deployment_info['environment']
        }

# 创建Gradio Web界面
def create_web_interface(service):
    """创建Web界面"""
    
    def process_image(image):
        result, inference_time = service.predict(image)
        
        # 可视化结果
        visualized_image = visualize_detections(image, result)
        
        # 生成结果文本
        result_text = f"""
        检测结果:
        - 检测到 {len(result['boxes'])} 部手机
        - 平均置信度: {sum(result['scores'])/len(result['scores']):.2%}
        - 推理时间: {inference_time:.2f}ms
        
        详细信息:
        {json.dumps(result, indent=2, ensure_ascii=False)}
        """
        
        return visualized_image, result_text
    
    # 创建界面
    with gr.Blocks(title="手机检测服务") as demo:
        gr.Markdown("# 📱 DAMO-YOLO 实时手机检测服务")
        gr.Markdown(f"模型版本: {service.deployment_info['model_version']}")
        
        with gr.Row():
            with gr.Column():
                input_image = gr.Image(label="上传图片", type="numpy")
                submit_btn = gr.Button("开始检测", variant="primary")
            
            with gr.Column():
                output_image = gr.Image(label="检测结果", type="numpy")
                output_text = gr.Textbox(label="检测详情", lines=10)
        
        # 服务信息
        with gr.Accordion("服务信息", open=False):
            service_info = service.get_service_info()
            gr.JSON(value=service_info, label="服务配置")
        
        submit_btn.click(
            fn=process_image,
            inputs=[input_image],
            outputs=[output_image, output_text]
        )
    
    return demo

if __name__ == "__main__":
    # 加载配置
    with open("configs/deploy_config.yaml", 'r') as f:
        config = yaml.safe_load(f)
    
    # 创建服务
    service = PhoneDetectionService(
        model_version=config['model_version'],
        config_path="configs/deploy_config.yaml"
    )
    
    # 启动Web服务
    demo = create_web_interface(service)
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=config.get('share', False)
    )

6. 实际案例：复现88.8% AP的手机检测模型

6.1 案例背景

假设我们要复现一个AP@0.5达到88.8%的手机检测模型，这个模型是在特定配置下训练得到的。现在新同事需要基于这个模型继续优化，我们需要确保他能完全复现原始结果。

6.2 复现步骤

第一步：获取实验信息

# 查看MLflow中的实验记录
mlflow experiments list

# 找到目标实验
mlflow runs list --experiment-id 1

# 获取具体运行信息
mlflow runs describe --run-id abc123def456

第二步：复现环境

# 使用Docker Compose启动完全相同的环境
docker-compose -f docker-compose.reproduction.yml up -d

# reproduction.yml专门用于复现
version: '3.8'
services:
  reproduction:
    build:
      context: .
      dockerfile: Dockerfile.reproduction  # 使用特定版本的Dockerfile
    environment:
      - REPRODUCTION_RUN_ID=abc123def456
      - MLFLOW_TRACKING_URI=http://mlflow:5000
    command: python reproduce_experiment.py

第三步：执行复现脚本

# reproduce_experiment.py
import mlflow
import subprocess
import yaml
from pathlib import Path

def reproduce_experiment(run_id):
    """完整复现实验流程"""
    
    print(f"开始复现实验: {run_id}")
    
    # 1. 从MLflow获取原始实验信息
    client = mlflow.tracking.MlflowClient()
    run = client.get_run(run_id)
    
    # 2. 恢复代码版本
    print("恢复代码版本...")
    code_version = run.data.tags.get('git_commit', 'main')
    subprocess.run(['git', 'checkout', code_version], check=True)
    
    # 3. 恢复依赖版本
    print("恢复依赖版本...")
    requirements = client.download_artifacts(run_id, "requirements.txt")
    subprocess.run(['pip', 'install', '-r', requirements], check=True)
    
    # 4. 恢复数据
    print("恢复数据...")
    data_config = yaml.safe_load(run.data.tags.get('data_config', '{}'))
    restore_data(data_config)
    
    # 5. 恢复训练配置
    print("恢复训练配置...")
    train_config = client.download_artifacts(run_id, "config/train_config.yaml")
    
    # 6. 重新训练（可选）或直接加载模型
    print("加载模型...")
    model_path = client.download_artifacts(run_id, "model")
    
    # 7. 重新评估
    print("重新评估...")
    eval_results = evaluate_model(
        model_path=model_path,
        config_path=train_config
    )
    
    # 8. 对比结果
    compare_results(run.data.metrics, eval_results)
    
    print("复现完成！")
    return eval_results

if __name__ == "__main__":
    import sys
    run_id = sys.argv[1] if len(sys.argv) > 1 else "abc123def456"
    reproduce_experiment(run_id)

第四步：验证复现结果

def verify_reproduction(original_run_id, reproduced_metrics, tolerance=0.001):
    """验证复现结果是否在允许误差范围内"""
    
    client = mlflow.tracking.MlflowClient()
    original_run = client.get_run(original_run_id)
    original_metrics = original_run.data.metrics
    
    print("="*60)
    print("复现结果验证")
    print("="*60)
    
    all_passed = True
    for key in ['AP@0.5', 'AP', 'inference_speed_ms']:
        if key in original_metrics and key in reproduced_metrics:
            original_val = original_metrics[key]
            reproduced_val = reproduced_metrics[key]
            diff = abs(original_val - reproduced_val)
            
            if diff <= tolerance:
                status = "✅ PASS"
            else:
                status = "❌ FAIL"
                all_passed = False
            
            print(f"{key:<20} | 原始: {original_val:.4f} | 复现: {reproduced_val:.4f} | "
                  f"差异: {diff:.4f} | {status}")
    
    print("="*60)
    
    if all_passed:
        print("🎉 所有指标复现成功！")
        return True
    else:
        print("⚠️  部分指标存在差异，请检查环境配置")
        return False

6.3 复现报告生成

复现完成后，自动生成详细的复现报告：

# 实验复现报告

## 实验信息
- **实验ID**: abc123def456
- **实验名称**: damoyolo-phone-v1.0-training
- **原始创建时间**: 2024-01-15 14:30:00
- **复现时间**: 2024-03-20 10:15:00
- **复现环境**: Docker容器 (pytorch:2.0.1-cuda11.7)

## 复现结果

### 性能指标对比
| 指标 | 原始结果 | 复现结果 | 差异 | 状态 |
|------|----------|----------|------|------|
| AP@0.5 | 88.8% | 88.7% | 0.1% | ✅ |
| AP | 76.5% | 76.4% | 0.1% | ✅ |
| 推理速度 | 3.83ms | 3.85ms | 0.02ms | ✅ |

### 环境一致性检查
| 组件 | 原始版本 | 复现版本 | 状态 |
|------|----------|----------|------|
| Python | 3.9.18 | 3.9.18 | ✅ |
| PyTorch | 2.0.1 | 2.0.1 | ✅ |
| CUDA | 11.7 | 11.7 | ✅ |
| ModelScope | 1.34.0 | 1.34.0 | ✅ |

### 数据一致性验证
- 训练集样本数: 10,000 (一致)
- 验证集样本数: 2,000 (一致)
- 测试集样本数: 2,000 (一致)
- 数据校验和: MD5匹配 ✅

## 复现结论
✅ **完全可复现**：所有关键指标均在允许误差范围内（<0.5%差异）

## 后续建议
1. 模型已成功复现，可用于进一步优化
2. 建议将此次复现记录为新的MLflow运行
3. 可基于此环境进行新的实验迭代

7. 总结

7.1 关键要点回顾

通过本文的实践，我们建立了一个完整的DAMO-YOLO手机检测模型可复现性保障体系：

Docker容器化确保了环境一致性：

• 将Python版本、依赖包、系统库全部打包
• 使用Docker Compose编排多服务环境
• 实现"一次构建，处处运行"的部署体验

MLflow实验追踪记录了完整上下文：

• 自动记录代码版本、超参数、评估指标
• 保存模型文件、日志、可视化结果
• 提供Web界面方便实验比较和管理

完整流水线保障了端到端可复现：

• 从数据准备到模型训练，再到评估部署
• 每个环节都有版本控制和环境记录
• 支持随时回溯和精确复现

7.2 实际收益

采用这套方案后，你的手机检测项目将获得这些实实在在的好处：

对个人开发者：

• 不再担心"这个结果是怎么来的"
• 轻松比较不同实验配置的效果
• 实验记录系统化，查找方便

对团队协作：

• 新成员能快速上手，复现基线结果
• 多人并行实验，结果可比性强
• 代码和模型版本清晰，减少沟通成本

对项目交付：

• 客户要求复现时，能快速响应
• 模型上线问题可追溯到训练阶段
• 为技术论文提供完整的实验证据

7.3 下一步建议

如果你已经开始使用这套方案，这里有一些进阶建议：

持续优化方向：

1. 自动化测试：在CI/CD流水线中加入复现性测试
2. 模型注册表：使用MLflow Model Registry管理模型版本
3. 数据版本控制：集成DVC（Data Version Control）管理数据集
4. 监控告警：设置关键指标阈值，自动检测复现偏差

扩展应用场景：

1. 多模型对比：同时追踪多个手机检测模型的实验
2. A/B测试：在生产环境对比不同模型版本的效果
3. 自动超参优化：集成Optuna等工具进行自动调参
4. 模型蒸馏：记录大模型到小模型的蒸馏过程

7.4 开始行动

现在就开始为你的手机检测项目添加可复现性保障：

1. 从简单的Dockerfile开始：先确保基础环境可复现
2. 集成MLflow记录关键实验：不必记录所有，先记录最重要的
3. 建立团队规范：统一实验记录和版本管理流程
4. 定期验证复现性：每月抽检历史实验的可复现性

记住，可复现性不是一次性的工作，而是一个持续的过程。每当你改进一点，项目的可靠性和协作效率就会提升一点。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。