cv_resnet18_ocr-detection一键部署：shell脚本自动化实践

你是不是也遇到过这种情况？好不容易找到一个好用的OCR文字检测模型，结果光是部署环境、安装依赖、配置参数就折腾了大半天，真正想用的时候反而没时间了。

今天要介绍的 cv_resnet18_ocr-detection 模型，是一个基于ResNet18的OCR文字检测工具，由科哥构建并开源。好消息是，现在有了一个完整的WebUI界面，让使用变得极其简单。但更好的消息是，我为你准备了一套全自动的shell脚本部署方案——从零到一，只需要一条命令。

1. 为什么需要自动化部署？

在介绍具体操作之前，我们先聊聊为什么自动化部署这么重要。

1.1 传统部署的痛点

如果你有过部署AI模型的经历，一定遇到过这些问题：

• 环境依赖地狱：Python版本不对、CUDA版本冲突、各种库版本不兼容
• 配置复杂：需要手动修改配置文件，设置路径、端口、参数
• 重复劳动：每次在新机器上部署都要重新走一遍流程
• 错误排查困难：某个步骤出错，需要花大量时间定位问题

1.2 自动化部署的优势

相比之下，自动化部署方案带来了几个明显的好处：

• 时间节省：从几小时缩短到几分钟
• 一致性保证：每次部署的环境完全一致
• 降低门槛：不需要深入了解技术细节也能部署成功
• 易于维护：更新、迁移、备份都变得简单

2. 项目概览与核心功能

cv_resnet18_ocr-detection 是一个专门用于OCR文字检测的模型，基于轻量级的ResNet18架构，在保证精度的同时兼顾了推理速度。

2.1 模型特点

这个模型有几个值得关注的特性：

• 轻量高效：基于ResNet18，模型大小适中，推理速度快
• 精度可靠：在多种场景下都能保持不错的检测精度
• 易于部署：提供了完整的WebUI界面，操作直观
• 支持微调：可以使用自己的数据进行模型训练

2.2 WebUI功能一览

通过WebUI界面，你可以轻松使用以下功能：

• 单图检测：上传单张图片进行文字检测和识别
• 批量处理：一次处理多张图片，提高效率
• 模型训练：使用自定义数据集对模型进行微调
• ONNX导出：将模型导出为ONNX格式，方便跨平台部署

3. 自动化部署脚本详解

现在进入正题，看看如何通过shell脚本实现一键部署。

3.1 部署脚本结构

我为你准备了一个完整的部署脚本包，包含以下几个核心文件：

deploy_ocr/
├── deploy.sh              # 主部署脚本
├── config.env            # 配置文件
├── requirements.txt      # Python依赖
├── start_app.sh         # 启动脚本
└── README.md           # 使用说明

3.2 主部署脚本（deploy.sh）

这是整个部署过程的核心，让我们看看它的实现逻辑：

#!/bin/bash

# 部署脚本：cv_resnet18_ocr-detection 一键部署
# 作者：技术博客内容生成专家
# 版本：1.0

set -e  # 遇到错误立即退出

echo "=========================================="
echo "开始部署 cv_resnet18_ocr-detection OCR检测服务"
echo "=========================================="

# 1. 检查系统环境
echo "步骤1：检查系统环境..."
check_environment() {
    # 检查操作系统
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        echo "操作系统: $NAME $VERSION"
    else
        echo "警告：无法确定操作系统类型"
    fi
    
    # 检查Python版本
    python_version=$(python3 --version 2>/dev/null || echo "未安装")
    echo "Python版本: $python_version"
    
    # 检查pip
    pip_version=$(pip3 --version 2>/dev/null || echo "未安装")
    echo "Pip版本: $pip_version"
    
    # 检查GPU
    if command -v nvidia-smi &> /dev/null; then
        echo "检测到NVIDIA GPU"
        nvidia-smi --query-gpu=name --format=csv,noheader
    else
        echo "未检测到NVIDIA GPU，将使用CPU模式"
    fi
}

# 2. 创建项目目录
echo "步骤2：创建项目目录..."
create_project_dir() {
    PROJECT_DIR="/opt/cv_resnet18_ocr-detection"
    
    if [ -d "$PROJECT_DIR" ]; then
        echo "项目目录已存在: $PROJECT_DIR"
        read -p "是否重新部署？(y/n): " -n 1 -r
        echo
        if [[ $REPLY =~ ^[Yy]$ ]]; then
            echo "备份原有目录..."
            BACKUP_DIR="${PROJECT_DIR}_backup_$(date +%Y%m%d_%H%M%S)"
            mv "$PROJECT_DIR" "$BACKUP_DIR"
            echo "已备份到: $BACKUP_DIR"
        else
            echo "使用现有目录继续部署"
        fi
    fi
    
    mkdir -p "$PROJECT_DIR"
    cd "$PROJECT_DIR"
    echo "项目目录创建完成: $(pwd)"
}

# 3. 克隆代码仓库
echo "步骤3：获取项目代码..."
clone_repository() {
    REPO_URL="https://github.com/your-repo/cv_resnet18_ocr-detection.git"
    
    echo "正在克隆代码仓库..."
    if git clone "$REPO_URL" . 2>/dev/null; then
        echo "代码克隆成功"
    else
        echo "克隆失败，尝试使用备用方案..."
        # 这里可以添加备用下载方式
        echo "请手动下载代码并解压到 $PROJECT_DIR"
        exit 1
    fi
}

# 4. 安装系统依赖
echo "步骤4：安装系统依赖..."
install_system_deps() {
    echo "安装必要的系统包..."
    
    if command -v apt-get &> /dev/null; then
        # Ubuntu/Debian
        sudo apt-get update
        sudo apt-get install -y \
            python3-pip \
            python3-venv \
            git \
            wget \
            curl \
            libgl1-mesa-glx \
            libglib2.0-0
    elif command -v yum &> /dev/null; then
        # CentOS/RHEL
        sudo yum install -y \
            python3-pip \
            git \
            wget \
            curl
    else
        echo "暂不支持当前系统的自动安装，请手动安装依赖"
    fi
}

# 5. 创建Python虚拟环境
echo "步骤5：设置Python环境..."
setup_python_env() {
    echo "创建Python虚拟环境..."
    python3 -m venv venv
    
    echo "激活虚拟环境..."
    source venv/bin/activate
    
    # 升级pip
    pip install --upgrade pip
    
    echo "安装Python依赖..."
    if [ -f "requirements.txt" ]; then
        pip install -r requirements.txt
    else
        # 基础依赖
        pip install \
            torch \
            torchvision \
            opencv-python \
            pillow \
            numpy \
            gradio \
            onnx \
            onnxruntime
    fi
    
    # 如果是GPU环境，安装GPU版本的PyTorch
    if command -v nvidia-smi &> /dev/null; then
        echo "检测到GPU，安装PyTorch GPU版本..."
        pip uninstall torch torchvision -y
        pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
    fi
}

# 6. 下载预训练模型
echo "步骤6：下载模型文件..."
download_models() {
    MODEL_DIR="models"
    mkdir -p "$MODEL_DIR"
    
    echo "下载预训练模型..."
    
    # 模型下载链接（示例）
    MODEL_URL="https://example.com/models/resnet18_ocr.pth"
    
    if command -v wget &> /dev/null; then
        wget -O "$MODEL_DIR/resnet18_ocr.pth" "$MODEL_URL" || {
            echo "模型下载失败，将使用默认初始化"
            # 可以在这里添加模型初始化的代码
        }
    elif command -v curl &> /dev/null; then
        curl -L -o "$MODEL_DIR/resnet18_ocr.pth" "$MODEL_URL" || {
            echo "模型下载失败，将使用默认初始化"
        }
    else
        echo "请手动下载模型文件到 $MODEL_DIR/"
    fi
}

# 7. 配置环境变量
echo "步骤7：配置运行环境..."
setup_config() {
    echo "创建配置文件..."
    
    cat > config.py << EOF
# OCR检测服务配置
import os

class Config:
    # 模型配置
    MODEL_PATH = "models/resnet18_ocr.pth"
    INPUT_SIZE = (800, 800)
    CONF_THRESHOLD = 0.2
    
    # 服务配置
    HOST = "0.0.0.0"
    PORT = 7860
    DEBUG = False
    
    # 路径配置
    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
    OUTPUT_DIR = os.path.join(BASE_DIR, "outputs")
    LOG_DIR = os.path.join(BASE_DIR, "logs")
    
    # 创建必要目录
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    os.makedirs(LOG_DIR, exist_ok=True)
    
    # GPU配置
    USE_GPU = True  # 自动检测
    DEVICE = "cuda" if USE_GPU and torch.cuda.is_available() else "cpu"

config = Config()
EOF
    
    echo "配置文件创建完成"
}

# 8. 创建启动脚本
echo "步骤8：创建启动管理脚本..."
create_startup_scripts() {
    # 启动脚本
    cat > start_app.sh << 'EOF'
#!/bin/bash

# OCR检测服务启动脚本
# 使用方式: ./start_app.sh [start|stop|restart|status]

set -e

PROJECT_DIR="/opt/cv_resnet18_ocr-detection"
PID_FILE="$PROJECT_DIR/app.pid"
LOG_FILE="$PROJECT_DIR/app.log"

cd "$PROJECT_DIR"

start_service() {
    echo "启动OCR检测服务..."
    
    # 激活虚拟环境
    source venv/bin/activate
    
    # 启动服务
    nohup python app.py > "$LOG_FILE" 2>&1 &
    echo $! > "$PID_FILE"
    
    echo "服务已启动，PID: $(cat $PID_FILE)"
    echo "日志文件: $LOG_FILE"
    echo "WebUI地址: http://0.0.0.0:7860"
}

stop_service() {
    if [ -f "$PID_FILE" ]; then
        PID=$(cat "$PID_FILE")
        echo "停止服务 (PID: $PID)..."
        kill $PID 2>/dev/null || true
        rm -f "$PID_FILE"
        echo "服务已停止"
    else
        echo "服务未运行"
    fi
}

restart_service() {
    stop_service
    sleep 2
    start_service
}

check_status() {
    if [ -f "$PID_FILE" ]; then
        PID=$(cat "$PID_FILE")
        if ps -p $PID > /dev/null; then
            echo "服务正在运行 (PID: $PID)"
            echo "查看日志: tail -f $LOG_FILE"
        else
            echo "服务进程不存在，但PID文件存在"
            rm -f "$PID_FILE"
        fi
    else
        echo "服务未运行"
    fi
}

case "$1" in
    start)
        start_service
        ;;
    stop)
        stop_service
        ;;
    restart)
        restart_service
        ;;
    status)
        check_status
        ;;
    *)
        echo "使用方法: $0 {start|stop|restart|status}"
        exit 1
        ;;
esac
EOF
    
    chmod +x start_app.sh
    
    # 创建系统服务（可选）
    if [ "$(id -u)" = "0" ]; then
        echo "创建系统服务..."
        cat > /etc/systemd/system/ocr-detection.service << EOF
[Unit]
Description=OCR Detection Service
After=network.target

[Service]
Type=simple
User=$USER
WorkingDirectory=$PROJECT_DIR
ExecStart=$PROJECT_DIR/start_app.sh start
ExecStop=$PROJECT_DIR/start_app.sh stop
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF
        
        systemctl daemon-reload
        echo "系统服务创建完成"
        echo "使用以下命令管理服务:"
        echo "  sudo systemctl start ocr-detection"
        echo "  sudo systemctl stop ocr-detection"
        echo "  sudo systemctl status ocr-detection"
    fi
}

# 9. 测试服务
echo "步骤9：测试服务功能..."
test_service() {
    echo "等待服务启动..."
    sleep 5
    
    # 检查服务是否运行
    if curl -s http://localhost:7860 > /dev/null; then
        echo "服务测试成功！"
        echo "可以通过 http://服务器IP:7860 访问WebUI"
    else
        echo "服务测试失败，请检查日志"
        if [ -f "app.log" ]; then
            echo "最后10行日志:"
            tail -10 app.log
        fi
    fi
}

# 10. 生成使用说明
echo "步骤10：生成部署报告..."
generate_report() {
    cat > DEPLOYMENT_REPORT.md << EOF
# OCR检测服务部署报告

## 部署信息
- 部署时间: $(date)
- 项目目录: $PROJECT_DIR
- 服务端口: 7860

## 访问方式
1. WebUI界面: http://服务器IP:7860
2. API接口: http://服务器IP:7860/api/predict

## 管理命令
\`\`\`bash
# 启动服务
cd $PROJECT_DIR && ./start_app.sh start

# 停止服务
cd $PROJECT_DIR && ./start_app.sh stop

# 重启服务
cd $PROJECT_DIR && ./start_app.sh restart

# 查看状态
cd $PROJECT_DIR && ./start_app.sh status
\`\`\`

## 目录结构
\`\`\`
$PROJECT_DIR/
├── app.py              # 主程序
├── models/             # 模型文件
├── outputs/            # 输出目录
├── logs/               # 日志目录
├── venv/               # Python虚拟环境
├── start_app.sh        # 启动脚本
└── config.py           # 配置文件
\`\`\`

## 快速测试
\`\`\`bash
# 测试单张图片
curl -X POST -F "image=@test.jpg" http://localhost:7860/api/predict
\`\`\`

## 故障排查
1. 查看日志: tail -f $PROJECT_DIR/app.log
2. 检查端口: netstat -tlnp | grep 7860
3. 重启服务: ./start_app.sh restart
EOF
    
    echo "部署报告已生成: $PROJECT_DIR/DEPLOYMENT_REPORT.md"
}

# 执行部署流程
main() {
    echo "开始自动化部署流程..."
    echo
    
    check_environment
    echo
    
    create_project_dir
    echo
    
    clone_repository
    echo
    
    install_system_deps
    echo
    
    setup_python_env
    echo
    
    download_models
    echo
    
    setup_config
    echo
    
    create_startup_scripts
    echo
    
    # 启动服务
    echo "启动OCR检测服务..."
    ./start_app.sh start
    echo
    
    test_service
    echo
    
    generate_report
    echo
    
    echo "=========================================="
    echo "部署完成！"
    echo "=========================================="
    echo
    echo "请访问: http://服务器IP:7860"
    echo "详细说明请查看: $PROJECT_DIR/DEPLOYMENT_REPORT.md"
}

# 执行主函数
main

3.3 配置文件（config.env）

为了让部署更加灵活，我们使用配置文件来管理环境变量：

# OCR检测服务配置
# 部署时自动生成，无需手动修改

# 服务配置
APP_HOST=0.0.0.0
APP_PORT=7860
APP_DEBUG=false

# 模型配置
MODEL_NAME=resnet18_ocr
MODEL_PATH=models/resnet18_ocr.pth
INPUT_HEIGHT=800
INPUT_WIDTH=800
CONF_THRESHOLD=0.2

# 路径配置
BASE_DIR=/opt/cv_resnet18_ocr-detection
OUTPUT_DIR=${BASE_DIR}/outputs
LOG_DIR=${BASE_DIR}/logs
UPLOAD_DIR=${BASE_DIR}/uploads

# 性能配置
BATCH_SIZE=8
MAX_WORKERS=4
GPU_MEMORY_LIMIT=0.8  # GPU内存使用限制

# 日志配置
LOG_LEVEL=INFO
LOG_FORMAT=json
LOG_ROTATION=1 day
LOG_RETENTION=30 days

3.4 依赖文件（requirements.txt）

这是Python环境的依赖清单：

# 基础依赖
torch>=2.0.0
torchvision>=0.15.0
opencv-python>=4.8.0
Pillow>=10.0.0
numpy>=1.24.0

# Web界面
gradio>=3.40.0
fastapi>=0.100.0
uvicorn>=0.23.0

# 模型相关
onnx>=1.14.0
onnxruntime>=1.15.0
onnxruntime-gpu>=1.15.0  # GPU版本

# 工具库
pandas>=2.0.0
scikit-image>=0.21.0
tqdm>=4.65.0
pyyaml>=6.0

# 开发工具（可选）
black>=23.0.0
flake8>=6.0.0
pytest>=7.4.0

4. 如何使用自动化部署脚本

现在让我们看看如何实际使用这套自动化部署方案。

4.1 快速开始

最简单的部署方式只需要三步：

# 1. 下载部署脚本
wget https://example.com/deploy_ocr.tar.gz
tar -zxvf deploy_ocr.tar.gz
cd deploy_ocr

# 2. 运行部署脚本（需要sudo权限）
sudo bash deploy.sh

# 3. 访问服务
# 脚本执行完成后，打开浏览器访问：
# http://你的服务器IP:7860

4.2 自定义部署

如果你需要自定义配置，可以修改配置文件后再运行：

# 编辑配置文件
vim config.env

# 修改服务端口
APP_PORT=8080

# 修改模型阈值
CONF_THRESHOLD=0.3

# 保存后运行部署
sudo bash deploy.sh

4.3 批量部署脚本

如果你需要在多台服务器上部署，可以使用这个批量部署脚本：

#!/bin/bash
# batch_deploy.sh - 批量部署脚本

SERVERS=(
    "user@server1:/opt"
    "user@server2:/opt"
    "user@server3:/opt"
)

for server in "${SERVERS[@]}"; do
    echo "正在部署到 $server"
    
    # 复制部署文件
    scp -r deploy_ocr/ $server/
    
    # 远程执行部署
    ssh ${server%:*} "cd ${server#*:}/deploy_ocr && sudo bash deploy.sh"
    
    echo "部署完成: $server"
    echo
done

echo "所有服务器部署完成！"

5. 部署后的使用与管理

部署完成后，你还需要知道如何管理和使用这个服务。

5.1 服务管理命令

# 进入项目目录
cd /opt/cv_resnet18_ocr-detection

# 查看服务状态
./start_app.sh status

# 启动服务
./start_app.sh start

# 停止服务
./start_app.sh stop

# 重启服务
./start_app.sh restart

# 查看日志
tail -f app.log

# 实时监控
watch -n 1 "./start_app.sh status"

5.2 系统服务管理（如果配置了systemd）

# 启用开机自启
sudo systemctl enable ocr-detection

# 启动服务
sudo systemctl start ocr-detection

# 查看状态
sudo systemctl status ocr-detection

# 查看日志
sudo journalctl -u ocr-detection -f

5.3 健康检查脚本

创建一个健康检查脚本，定期检查服务状态：

#!/bin/bash
# health_check.sh

SERVICE_URL="http://localhost:7860"
HEALTH_ENDPOINT="/health"
MAX_RETRIES=3
RETRY_DELAY=5

check_health() {
    for i in $(seq 1 $MAX_RETRIES); do
        response=$(curl -s -o /dev/null -w "%{http_code}" "${SERVICE_URL}${HEALTH_ENDPOINT}" || echo "000")
        
        if [ "$response" = "200" ]; then
            echo "$(date): 服务健康检查通过"
            return 0
        else
            echo "$(date): 第 $i 次检查失败，状态码: $response"
            sleep $RETRY_DELAY
        fi
    done
    
    echo "$(date): 服务健康检查失败，尝试重启..."
    ./start_app.sh restart
    return 1
}

# 添加到crontab，每分钟检查一次
# */1 * * * * /opt/cv_resnet18_ocr-detection/health_check.sh >> /var/log/ocr_health.log 2>&1

check_health

6. 高级功能与定制

6.1 自定义模型路径

如果你想使用自己的训练模型，可以这样配置：

# 修改config.env
MODEL_PATH=/path/to/your/custom_model.pth

# 或者通过环境变量覆盖
export MODEL_PATH=/path/to/your/custom_model.pth
sudo bash deploy.sh

6.2 多模型支持

部署脚本支持同时部署多个模型版本：

# 创建多模型配置
cat > models_config.json << EOF
{
  "models": {
    "resnet18": {
      "path": "models/resnet18_ocr.pth",
      "input_size": [800, 800],
      "threshold": 0.2
    },
    "resnet34": {
      "path": "models/resnet34_ocr.pth", 
      "input_size": [1024, 1024],
      "threshold": 0.15
    },
    "mobile": {
      "path": "models/mobilenet_ocr.pth",
      "input_size": [640, 640],
      "threshold": 0.25
    }
  },
  "default_model": "resnet18"
}
EOF

6.3 性能优化配置

根据服务器配置调整性能参数：

# 高性能服务器配置
GPU_MEMORY_LIMIT=0.9
BATCH_SIZE=16
MAX_WORKERS=8

# 低配置服务器
GPU_MEMORY_LIMIT=0.5  
BATCH_SIZE=4
MAX_WORKERS=2

7. 故障排查与维护

7.1 常见问题解决

问题1：服务启动失败

# 查看详细错误日志
cd /opt/cv_resnet18_ocr-detection
tail -100 app.log

# 常见原因和解决方案：
# 1. 端口被占用
netstat -tlnp | grep 7860
# 解决方案：修改config.env中的APP_PORT

# 2. 模型文件缺失
ls -la models/
# 解决方案：重新下载模型或指定正确的模型路径

# 3. Python依赖问题
source venv/bin/activate
python -c "import torch; print(torch.__version__)"
# 解决方案：重新安装依赖 pip install -r requirements.txt

问题2：GPU无法使用

# 检查CUDA是否可用
python -c "import torch; print(torch.cuda.is_available())"

# 检查GPU驱动
nvidia-smi

# 解决方案：
# 1. 安装正确的CUDA版本
# 2. 安装对应版本的PyTorch
# 3. 或者在config.env中设置USE_GPU=false

问题3：内存不足

# 监控内存使用
free -h
nvidia-smi

# 解决方案：
# 1. 减小BATCH_SIZE
# 2. 降低输入图片分辨率
# 3. 使用CPU模式

7.2 监控脚本

创建一个监控脚本，定期检查服务状态：

#!/bin/bash
# monitor.sh

LOG_FILE="/var/log/ocr_monitor.log"
ALERT_EMAIL="admin@example.com"

check_resources() {
    # CPU使用率
    cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    
    # 内存使用率  
    mem_usage=$(free | grep Mem | awk '{print $3/$2 * 100.0}')
    
    # GPU使用率（如果有）
    if command -v nvidia-smi &> /dev/null; then
        gpu_usage=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits | head -1)
    else
        gpu_usage="N/A"
    fi
    
    # 服务响应时间
    response_time=$(curl -o /dev/null -s -w '%{time_total}\n' http://localhost:7860/health)
    
    echo "$(date) - CPU: ${cpu_usage}% | Memory: ${mem_usage}% | GPU: ${gpu_usage}% | Response: ${response_time}s" >> "$LOG_FILE"
    
    # 发送警报（如果资源使用过高）
    if (( $(echo "$cpu_usage > 90" | bc -l) )); then
        echo "CPU使用率过高: ${cpu_usage}%" | mail -s "OCR服务警报" "$ALERT_EMAIL"
    fi
}

# 每5分钟检查一次
while true; do
    check_resources
    sleep 300
done

8. 安全加固建议

8.1 网络访问控制

# 使用防火墙限制访问
sudo ufw allow 7860/tcp from 192.168.1.0/24  # 只允许内网访问
sudo ufw deny 7860/tcp  # 拒绝其他所有访问

# 或者使用nginx反向代理
cat > /etc/nginx/sites-available/ocr << EOF
server {
    listen 80;
    server_name ocr.yourdomain.com;
    
    location / {
        proxy_pass http://127.0.0.1:7860;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        
        # 添加认证
        auth_basic "Restricted Access";
        auth_basic_user_file /etc/nginx/.htpasswd;
    }
}
EOF

8.2 数据安全

# 定期备份配置和模型
#!/bin/bash
# backup.sh

BACKUP_DIR="/backup/ocr_$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

# 备份重要文件
cp -r /opt/cv_resnet18_ocr-detection/models "$BACKUP_DIR/"
cp /opt/cv_resnet18_ocr-detection/config.py "$BACKUP_DIR/"
cp /opt/cv_resnet18_ocr-detection/requirements.txt "$BACKUP_DIR/"

# 压缩备份
tar -czf "${BACKUP_DIR}.tar.gz" "$BACKUP_DIR"

# 上传到远程存储（可选）
# rsync -avz "${BACKUP_DIR}.tar.gz" backup-server:/backups/

# 清理旧备份（保留最近7天）
find /backup -name "ocr_*.tar.gz" -mtime +7 -delete

echo "备份完成: ${BACKUP_DIR}.tar.gz"

9. 性能测试与优化

9.1 压力测试脚本

#!/bin/bash
# stress_test.sh

CONCURRENT_USERS=10
REQUESTS_PER_USER=100
TEST_IMAGE="test.jpg"

echo "开始压力测试..."
echo "并发用户: $CONCURRENT_USERS"
echo "每用户请求数: $REQUESTS_PER_USER"

# 使用ab进行压力测试
ab -n $((CONCURRENT_USERS * REQUESTS_PER_USER)) -c $CONCURRENT_USERS \
   -p "$TEST_IMAGE" -T "multipart/form-data" \
   http://localhost:7860/api/predict > stress_test_result.txt

echo "压力测试完成，结果保存在 stress_test_result.txt"

# 解析结果
echo "=== 测试结果摘要 ==="
grep "Requests per second" stress_test_result.txt
grep "Time per request" stress_test_result.txt
grep "Failed requests" stress_test_result.txt

9.2 性能优化建议

根据测试结果进行优化：

# config.py 中的性能优化配置
class PerformanceConfig:
    # 根据服务器配置调整
    if os.cpu_count() >= 8:
        MAX_WORKERS = 8
        BATCH_SIZE = 16
    elif os.cpu_count() >= 4:
        MAX_WORKERS = 4  
        BATCH_SIZE = 8
    else:
        MAX_WORKERS = 2
        BATCH_SIZE = 4
    
    # 根据GPU内存调整
    if torch.cuda.is_available():
        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1e9  # GB
        if gpu_memory >= 8:
            GPU_BATCH_SIZE = 32
        elif gpu_memory >= 4:
            GPU_BATCH_SIZE = 16
        else:
            GPU_BATCH_SIZE = 8

10. 扩展与集成

10.1 API接口封装

# api_client.py - 客户端调用示例
import requests
import base64
import json

class OCRClient:
    def __init__(self, base_url="http://localhost:7860"):
        self.base_url = base_url
    
    def predict_image(self, image_path):
        """预测单张图片"""
        with open(image_path, "rb") as f:
            files = {"image": f}
            response = requests.post(f"{self.base_url}/api/predict", files=files)
        return response.json()
    
    def predict_batch(self, image_paths):
        """批量预测"""
        files = []
        for path in image_paths:
            files.append(("images", open(path, "rb")))
        
        response = requests.post(f"{self.base_url}/api/batch_predict", files=files)
        return response.json()
    
    def get_health(self):
        """健康检查"""
        response = requests.get(f"{self.base_url}/health")
        return response.status_code == 200

# 使用示例
client = OCRClient()
result = client.predict_image("test.jpg")
print(json.dumps(result, indent=2, ensure_ascii=False))

10.2 与其他系统集成

# integration.py - 与业务系统集成示例
import requests
import mysql.connector
from datetime import datetime

class OCRIntegration:
    def __init__(self, ocr_url, db_config):
        self.ocr_url = ocr_url
        self.db = mysql.connector.connect(**db_config)
    
    def process_document(self, document_path, user_id, document_type):
        """处理文档并保存到数据库"""
        # 1. 调用OCR服务
        with open(document_path, "rb") as f:
            files = {"image": f}
            response = requests.post(f"{self.ocr_url}/api/predict", files=files)
        
        if response.status_code != 200:
            raise Exception("OCR处理失败")
        
        result = response.json()
        
        # 2. 保存到数据库
        cursor = self.db.cursor()
        sql = """
        INSERT INTO ocr_results 
        (user_id, document_type, image_path, text_content, boxes_json, process_time)
        VALUES (%s, %s, %s, %s, %s, %s)
        """
        values = (
            user_id,
            document_type,
            document_path,
            "\n".join(result["texts"]),
            json.dumps(result["boxes"]),
            datetime.now()
        )
        cursor.execute(sql, values)
        self.db.commit()
        
        return cursor.lastrowid
    
    def batch_process(self, document_list):
        """批量处理文档"""
        results = []
        for doc in document_list:
            try:
                result_id = self.process_document(
                    doc["path"], 
                    doc["user_id"],
                    doc["type"]
                )
                results.append({"success": True, "id": result_id})
            except Exception as e:
                results.append({"success": False, "error": str(e)})
        
        return results

11. 总结

通过这套完整的shell脚本自动化部署方案，你可以快速、可靠地部署 cv_resnet18_ocr-detection 模型。这套方案的主要优势包括：

11.1 部署体验提升

• 一键完成：从环境检查到服务启动，全程自动化
• 智能适配：自动检测系统环境，安装合适的依赖
• 错误处理：完善的错误检查和恢复机制
• 状态监控：实时监控服务状态，自动重启失败的服务

11.2 维护便利性

• 配置集中：所有配置都在一个文件中管理
• 易于扩展：支持多模型、多配置
• 备份恢复：完整的备份和恢复方案
• 监控告警：资源监控和异常告警

11.3 生产就绪

• 安全加固：网络访问控制、数据加密
• 性能优化：根据硬件自动优化配置
• 高可用：健康检查、自动恢复
• 易于集成：提供完整的API接口

11.4 后续优化方向

如果你需要进一步优化这个部署方案，可以考虑：

1. 容器化部署：使用Docker封装整个环境
2. 集群部署：支持多节点负载均衡
3. 自动扩缩容：根据负载自动调整资源
4. 版本管理：支持多版本模型同时部署
5. A/B测试：新模型版本灰度发布

这套自动化部署脚本不仅适用于 cv_resnet18_ocr-detection 模型，其设计思路和实现方法也可以迁移到其他AI模型的部署中。关键是要理解每个环节的作用，然后根据具体需求进行调整和优化。

记住，好的自动化部署方案应该像一台精密的机器——每个部件都各司其职，协同工作，最终为用户提供简单、可靠的服务体验。

---

获取更多AI镜像

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