中小学试卷手写体识别系统基础环境搭建实战指南

1. 系统环境总览

1.1 硬件要求

组件	最低配置	推荐配置	生产环境配置
CPU	Intel i5 8代/AMD Ryzen 5	Intel i7 10代/AMD Ryzen 7	Intel Xeon/AMD EPYC
GPU	GTX 1660 (6GB)	RTX 3060 (12GB)	RTX 3090/A100 (24GB+)
内存	16GB DDR4	32GB DDR4	64GB+ DDR4
存储	256GB SSD	512GB NVMe SSD	1TB NVMe SSD
系统	Ubuntu 20.04 LTS	Ubuntu 22.04 LTS	Ubuntu 22.04 LTS

1.2 软件版本矩阵

操作系统: Ubuntu 22.04 LTS (推荐)
Python: 3.8.10 (必须)
CUDA: 11.8 (GPU必需)
cuDNN: 8.6.0
PyTorch: 2.0.0+cu118

2. 从零开始：完整安装步骤

2.1 操作系统安装与基本配置

步骤1：Ubuntu 22.04 全新安装

# 1. 下载Ubuntu 22.04镜像
# 官方地址：https://releases.ubuntu.com/22.04/

# 2. 创建启动U盘（使用Rufus或Etcher）

# 3. 安装时分区建议：
# /      : 50GB (ext4)
# /home  : 剩余空间 (ext4)
# swap   : 32GB (内存<32GB时)
# 选择安装OpenSSH Server和NVIDIA驱动（如果检测到）

# 4. 安装后更新系统
sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential cmake git curl wget

步骤2：基础开发环境配置

# 设置时区
sudo timedatectl set-timezone Asia/Shanghai

# 创建开发用户
sudo adduser deeplearning
sudo usermod -aG sudo deeplearning

# 配置SSH（可选）
sudo apt install -y openssh-server
sudo systemctl enable ssh
sudo systemctl start ssh

# 安装中文输入法（可选）
sudo apt install -y fcitx fcitx-googlepinyin

2.2 NVIDIA驱动安装（GPU用户）

方法A：自动安装（推荐）

# 检测可用驱动版本
ubuntu-drivers devices

# 自动安装推荐驱动
sudo ubuntu-drivers autoinstall

# 重启系统
sudo reboot

# 验证安装
nvidia-smi

方法B：手动安装

# 1. 禁用Nouveau驱动
sudo bash -c "echo blacklist nouveau > /etc/modprobe.d/blacklist-nvidia-nouveau.conf"
sudo bash -c "echo options nouveau modeset=0 >> /etc/modprobe.d/blacklist-nvidia-nouveau.conf"
sudo update-initramfs -u
sudo reboot

# 2. 下载驱动
# 访问：https://www.nvidia.cn/Download/index.aspx
# 选择合适驱动，例如：NVIDIA-Linux-x86_64-525.105.17.run

# 3. 安装依赖
sudo apt install -y gcc make libglvnd-dev pkg-config

# 4. 安装驱动
chmod +x NVIDIA-Linux-x86_64-*.run
sudo ./NVIDIA-Linux-x86_64-*.run

2.3 CUDA Toolkit 11.8 安装

# 1. 下载CUDA 11.8
wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run

# 2. 安装（选择不安装驱动）
sudo sh cuda_11.8.0_520.61.05_linux.run --toolkit --silent --override

# 3. 配置环境变量
echo 'export PATH=/usr/local/cuda-11.8/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

# 4. 验证安装
nvcc --version

2.4 cuDNN 8.6.0 安装

# 1. 注册NVIDIA开发者账号
# 访问：https://developer.nvidia.com/cudnn

# 2. 下载cuDNN 8.6.0 for CUDA 11.x
# 选择 Local Installer for Linux (x86_64)

# 3. 安装
sudo dpkg -i cudnn-local-repo-ubuntu2204-8.6.0.163_1.0-1_amd64.deb
sudo cp /var/cudnn-local-repo-ubuntu2204-8.6.0.163/cudnn-local-*-keyring.gpg /usr/share/keyrings/
sudo apt update
sudo apt install -y libcudnn8 libcudnn8-dev

# 4. 验证安装
cat /usr/include/x86_64-linux-gnu/cudnn_version_v8.h | grep CUDNN_MAJOR -A 2

2.5 Python环境配置

# 1. 安装Python 3.8
sudo apt install -y python3.8 python3.8-dev python3.8-venv python3.8-distutils

# 2. 设置Python 3.8为默认
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.8 1
sudo update-alternatives --config python3

# 3. 安装pip
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
python3.8 get-pip.py

# 4. 验证
python3 --version  # 应显示3.8.x
pip3 --version

2.6 创建虚拟环境

# 1. 创建项目目录
mkdir -p ~/projects/handwriting_ocr_system
cd ~/projects/handwriting_ocr_system

# 2. 创建虚拟环境
python3.8 -m venv hwocr_env

# 3. 激活虚拟环境
source hwocr_env/bin/activate

# 4. 升级pip和setuptools
pip install --upgrade pip setuptools wheel

# 5. 创建环境管理脚本
cat > manage_env.sh << 'EOF'
#!/bin/bash

case "$1" in
    start)
        source ~/projects/handwriting_ocr_system/hwocr_env/bin/activate
        echo "Environment activated"
        ;;
    stop)
        deactivate
        echo "Environment deactivated"
        ;;
    install)
        pip install -r requirements.txt
        ;;
    update)
        pip install --upgrade -r requirements.txt
        ;;
    *)
        echo "Usage: $0 {start|stop|install|update}"
        exit 1
        ;;
esac
EOF

chmod +x manage_env.sh

2.7 安装PyTorch及核心依赖

# 激活虚拟环境
source hwocr_env/bin/activate

# 1. 创建requirements.txt
cat > requirements.txt << 'EOF'
# PyTorch核心
torch==2.0.0+cu118
torchvision==0.15.1+cu118
torchaudio==2.0.1+cu118
--extra-index-url https://download.pytorch.org/whl/cu118

# 图像处理
opencv-python==4.7.0.72
Pillow==9.5.0
scikit-image==0.20.0
albumentations==1.3.0

# 数据处理
numpy==1.24.3
pandas==2.0.1
scipy==1.10.1
scikit-learn==1.2.2

# OCR工具
editdistance==0.6.2
shapely==2.0.1
pyclipper==1.3.0.post5

# 训练辅助
tensorboard==2.13.0
tqdm==4.65.0
matplotlib==3.7.1
seaborn==0.12.2

# Web服务
fastapi==0.98.0
uvicorn[standard]==0.22.0
python-multipart==0.0.6

# 模型优化
onnx==1.14.0
onnxruntime-gpu==1.15.0

# 其他工具
jupyter==1.0.0
ipywidgets==8.0.6
wandb==0.15.3
python-dotenv==1.0.0
pyyaml==6.0
EOF

# 2. 安装所有依赖（耗时较长）
pip install -r requirements.txt

# 3. 验证PyTorch安装
python -c "import torch; print(f'PyTorch版本: {torch.__version__}')"
python -c "import torch; print(f'CUDA可用: {torch.cuda.is_available()}')"
python -c "import torch; print(f'GPU数量: {torch.cuda.device_count()}')"
python -c "import torch; print(f'当前GPU: {torch.cuda.get_device_name(0)}')"

2.8 安装OCR专用库

# 1. 安装MMOCR（可选，如果使用其实现）
pip install openmim
mim install mmengine
mim install "mmcv>=2.0.0"
mim install mmdet

# 2. 克隆OCR相关仓库
mkdir -p ~/projects/ocr_models
cd ~/projects/ocr_models

# DBNet
git clone https://github.com/MhLiao/DB.git dbnet_original
cd dbnet_original
pip install -e .
cd ..

# PaddleOCR（备用方案）
git clone https://github.com/PaddlePaddle/PaddleOCR.git
cd PaddleOCR
pip install -r requirements.txt
cd ..

# EasyOCR（快速原型）
pip install easyocr

# 3. 返回项目目录
cd ~/projects/handwriting_ocr_system

2.9 项目结构初始化

# 创建完整的项目结构
mkdir -p {models/{detection,recognition,hybrid},preprocessing,postprocessing,training/{datasets,augmentations,configs},evaluation,inference,deployment/{docker,api,monitoring},docs,notebooks,data/{raw,processed,train,val,test},logs,scripts,utils}

# 创建初始化文件
touch models/__init__.py
touch models/detection/__init__.py
touch models/recognition/__init__.py
touch preprocessing/__init__.py
touch utils/__init__.py

# 创建配置文件
cat > training/configs/default.yaml << 'EOF'
# 训练配置
model:
  detection:
    name: "DBNet"
    backbone: "resnet50"
    pretrained: true
    
  recognition:
    name: "CRNN"
    num_classes: 5000
    img_height: 32
    
training:
  batch_size: 16
  epochs: 100
  learning_rate: 0.001
  optimizer: "Adam"
  
data:
  input_size: [640, 640]
  augmentation: true
  
hardware:
  gpu_ids: [0]
  num_workers: 4
  pin_memory: true
EOF

# 创建环境配置
cat > .env.example << 'EOF'
# 项目配置
PROJECT_NAME=handwriting_ocr_system
PROJECT_VERSION=1.0.0

# 路径配置
DATA_DIR=./data
LOG_DIR=./logs
MODEL_DIR=./models/saved

# 训练配置
BATCH_SIZE=16
NUM_EPOCHS=100
LEARNING_RATE=0.001

# API配置
API_HOST=0.0.0.0
API_PORT=8000
API_WORKERS=4

# 模型配置
DETECTION_MODEL=dbnet
RECOGNITION_MODEL=crnn
CONFIDENCE_THRESHOLD=0.5

# 外部API（可选）
BAIDU_OCR_API_KEY=
BAIDU_OCR_SECRET_KEY=
EOF

cp .env.example .env

2.10 编写验证脚本

# 创建验证脚本 verification.py
cat > verification.py << 'EOF'
#!/usr/bin/env python3
"""
环境验证脚本
验证所有依赖是否正确安装
"""

import sys
import subprocess
import importlib

def check_python_version():
    """检查Python版本"""
    print("=" * 50)
    print("1. 检查Python版本")
    print("-" * 30)
    
    version = sys.version_info
    print(f"Python版本: {sys.version}")
    
    if version.major == 3 and version.minor >= 8:
        print("✓ Python版本符合要求 (>=3.8)")
        return True
    else:
        print("✗ Python版本过低，需要3.8+")
        return False

def check_gpu():
    """检查GPU"""
    print("\n2. 检查GPU和CUDA")
    print("-" * 30)
    
    try:
        import torch
        cuda_available = torch.cuda.is_available()
        
        if cuda_available:
            print(f"✓ CUDA可用")
            print(f"  GPU数量: {torch.cuda.device_count()}")
            print(f"  当前GPU: {torch.cuda.get_device_name(0)}")
            print(f"  CUDA版本: {torch.version.cuda}")
            
            # 测试CUDA运算
            x = torch.tensor([1.0, 2.0]).cuda()
            y = torch.tensor([3.0, 4.0]).cuda()
            z = x + y
            print(f"  CUDA计算测试: {z.cpu().numpy()}")
            
            return True
        else:
            print("✗ CUDA不可用，将使用CPU")
            return False
    except Exception as e:
        print(f"✗ GPU检查失败: {e}")
        return False

def check_packages():
    """检查关键包"""
    print("\n3. 检查Python包")
    print("-" * 30)
    
    packages = [
        ("torch", "2.0.0"),
        ("torchvision", "0.15.0"),
        ("opencv-python", "4.7.0"),
        ("numpy", "1.24.0"),
        ("Pillow", "9.0.0"),
        ("scikit-learn", "1.2.0"),
        ("pandas", "2.0.0"),
    ]
    
    all_ok = True
    for package, min_version in packages:
        try:
            module = importlib.import_module(package)
            version = getattr(module, "__version__", "未知")
            
            # 简单版本检查
            if version >= min_version:
                print(f"✓ {package:20} {version:15} (>= {min_version})")
            else:
                print(f"⚠ {package:20} {version:15} (需要 >= {min_version})")
                all_ok = False
                
        except ImportError:
            print(f"✗ {package:20} 未安装")
            all_ok = False
    
    return all_ok

def check_system_tools():
    """检查系统工具"""
    print("\n4. 检查系统工具")
    print("-" * 30)
    
    tools = [
        ("git", "--version"),
        ("nvcc", "--version"),
        ("nvidia-smi", "--version"),
        ("cmake", "--version"),
    ]
    
    all_ok = True
    for tool, version_arg in tools:
        try:
            result = subprocess.run(
                [tool, version_arg],
                capture_output=True,
                text=True,
                timeout=5
            )
            
            if result.returncode == 0:
                version_line = result.stdout.split('\n')[0]
                print(f"✓ {tool:15} {version_line}")
            else:
                print(f"✗ {tool:15} 未安装或不可用")
                all_ok = False
                
        except FileNotFoundError:
            print(f"✗ {tool:15} 未安装")
            all_ok = False
        except Exception as e:
            print(f"✗ {tool:15} 检查失败: {e}")
            all_ok = False
    
    return all_ok

def check_disk_space():
    """检查磁盘空间"""
    print("\n5. 检查磁盘空间")
    print("-" * 30)
    
    try:
        import shutil
        total, used, free = shutil.disk_usage("/")
        
        free_gb = free // (2**30)
        total_gb = total // (2**30)
        
        print(f"总空间: {total_gb} GB")
        print(f"已用空间: {used // (2**30)} GB")
        print(f"可用空间: {free_gb} GB")
        
        if free_gb >= 20:
            print("✓ 磁盘空间充足")
            return True
        else:
            print("⚠ 磁盘空间不足，建议至少20GB可用空间")
            return False
    except Exception as e:
        print(f"✗ 磁盘空间检查失败: {e}")
        return False

def run_basic_test():
    """运行基础测试"""
    print("\n6. 运行基础功能测试")
    print("-" * 30)
    
    tests = []
    
    try:
        import cv2
        import numpy as np
        
        # 创建测试图像
        img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)
        
        # 测试OpenCV
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 50, 150)
        
        tests.append(("OpenCV图像处理", True))
    except Exception as e:
        tests.append(("OpenCV图像处理", False, str(e)))
    
    try:
        from PIL import Image
        
        # 测试PIL
        pil_img = Image.fromarray(img)
        pil_img = pil_img.resize((50, 50))
        
        tests.append(("PIL图像处理", True))
    except Exception as e:
        tests.append(("PIL图像处理", False, str(e)))
    
    try:
        import torch
        
        # 测试PyTorch
        x = torch.randn(2, 3)
        y = torch.randn(2, 3)
        z = x + y
        
        tests.append(("PyTorch张量计算", True))
    except Exception as e:
        tests.append(("PyTorch张量计算", False, str(e)))
    
    # 输出测试结果
    all_passed = True
    for test in tests:
        if len(test) == 2:
            name, passed = test
            if passed:
                print(f"✓ {name}")
            else:
                print(f"✗ {name}")
                all_passed = False
        else:
            name, passed, error = test
            print(f"✗ {name}: {error}")
            all_passed = False
    
    return all_passed

def main():
    """主验证函数"""
    print("手写OCR系统环境验证")
    print("=" * 50)
    
    results = []
    
    results.append(("Python版本", check_python_version()))
    results.append(("GPU/CUDA", check_gpu()))
    results.append(("Python包", check_packages()))
    results.append(("系统工具", check_system_tools()))
    results.append(("磁盘空间", check_disk_space()))
    results.append(("功能测试", run_basic_test()))
    
    # 总结
    print("\n" + "=" * 50)
    print("验证总结:")
    print("-" * 30)
    
    passed = 0
    total = len(results)
    
    for name, success in results:
        status = "✓" if success else "✗"
        print(f"{status} {name}")
        if success:
            passed += 1
    
    print("-" * 30)
    print(f"通过: {passed}/{total}")
    
    if passed == total:
        print("\n🎉 所有检查通过！环境配置成功。")
        print("可以开始进行模型训练和开发。")
        return 0
    else:
        print(f"\n⚠ 有 {total - passed} 项检查未通过")
        print("请根据上述提示解决问题后重新验证。")
        return 1

if __name__ == "__main__":
    sys.exit(main())
EOF

# 运行验证脚本
python verification.py

2.11 安装Jupyter Notebook配置

# 1. 生成Jupyter配置
jupyter notebook --generate-config

# 2. 创建Jupyter内核
python -m ipykernel install --user --name=hwocr --display-name="Handwriting OCR"

# 3. 配置Jupyter
cat >> ~/.jupyter/jupyter_notebook_config.py << 'EOF'
# 允许远程访问
c.NotebookApp.ip = '0.0.0.0'
c.NotebookApp.open_browser = False
c.NotebookApp.port = 8888
c.NotebookApp.allow_origin = '*'
c.NotebookApp.allow_root = True
c.NotebookApp.allow_remote_access = True

# 密码保护（可选）
# 生成密码：jupyter notebook password
EOF

# 4. 创建notebook示例
cat > notebooks/01_environment_test.ipynb << 'EOF'
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 手写OCR环境测试Notebook\n",
    "\n",
    "这个notebook用于测试环境是否配置正确。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 检查环境\n",
    "import sys\n",
    "print(\"Python版本:\", sys.version)\n",
    "print(\"Python路径:\", sys.executable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 检查PyTorch\n",
    "import torch\n",
    "print(\"PyTorch版本:\", torch.__version__)\n",
    "print(\"CUDA可用:\", torch.cuda.is_available())\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    print(\"GPU名称:\", torch.cuda.get_device_name(0))\n",
    "    print(\"CUDA版本:\", torch.version.cuda)\n",
    "    \n",
    "    # 测试CUDA计算\n",
    "    x = torch.randn(3, 3).cuda()\n",
    "    y = torch.randn(3, 3).cuda()\n",
    "    z = torch.matmul(x, y)\n",
    "    print(\"CUDA计算测试通过!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 测试图像处理库\n",
    "import cv2\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "print(\"OpenCV版本:\", cv2.__version__)\n",
    "print(\"NumPy版本:\", np.__version__)\n",
    "\n",
    "# 创建测试图像\n",
    "img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)\n",
    "\n",
    "# 显示图像\n",
    "plt.figure(figsize=(10, 5))\n",
    "\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.imshow(img)\n",
    "plt.title(\"原始图像\")\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n",
    "plt.imshow(gray, cmap='gray')\n",
    "plt.title(\"灰度图\")\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "edges = cv2.Canny(gray, 50, 150)\n",
    "plt.imshow(edges, cmap='gray')\n",
    "plt.title(\"边缘检测\")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "print(\"图像处理测试通过!\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Handwriting OCR",
   "language": "python",
   "name": "hwocr"
  },
  "language_info": {
   "name": "python",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
EOF

2.12 Docker容器化（可选但推荐）

# 创建Dockerfile
cat > deployment/docker/Dockerfile << 'EOF'
# 基础镜像
FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04

# 设置环境变量
ENV DEBIAN_FRONTEND=noninteractive \
    PYTHONUNBUFFERED=1 \
    PYTHONIOENCODING=UTF-8 \
    LANG=C.UTF-8

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

# 设置工作目录
WORKDIR /app

# 复制项目文件
COPY requirements.txt .
COPY . .

# 安装Python依赖
RUN pip3 install --no-cache-dir --upgrade pip && \
    pip3 install --no-cache-dir -r requirements.txt

# 创建非root用户
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["uvicorn", "deployment.api.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]
EOF

# 创建docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  ocr-api:
    build:
      context: .
      dockerfile: deployment/docker/Dockerfile
    container_name: handwriting-ocr-api
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - ./data:/app/data
      - ./models/saved:/app/models/saved
      - ./logs:/app/logs
    environment:
      - CUDA_VISIBLE_DEVICES=0
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    networks:
      - ocr-network

  jupyter:
    image: jupyter/tensorflow-notebook:latest
    container_name: ocr-jupyter
    restart: unless-stopped
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
      - ./data:/home/jovyan/data
    environment:
      - JUPYTER_ENABLE_LAB=yes
    networks:
      - ocr-network

  monitoring:
    image: grafana/grafana:latest
    container_name: ocr-monitoring
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - ./deployment/monitoring/grafana:/var/lib/grafana
    networks:
      - ocr-network

networks:
  ocr-network:
    driver: bridge
EOF

2.13 自动化部署脚本

# 创建部署脚本
cat > scripts/setup.sh << 'EOF'
#!/bin/bash
# 手写OCR系统自动化部署脚本

set -e  # 遇到错误退出

echo "========================================="
echo "手写OCR系统自动化部署脚本"
echo "========================================="

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# 日志函数
log_info() {
    echo -e "${GREEN}[INFO]${NC} $1"
}

log_warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 检查命令是否存在
check_command() {
    if ! command -v $1 &> /dev/null; then
        log_error "命令 $1 未安装"
        exit 1
    fi
}

# 步骤1：检查系统
log_info "步骤1: 检查系统环境"
check_command python3
check_command pip3
check_command git

# 检查Python版本
PYTHON_VERSION=$(python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
if [[ "$PYTHON_VERSION" < "3.8" ]]; then
    log_error "Python版本需要 >= 3.8，当前版本: $PYTHON_VERSION"
    exit 1
fi
log_info "Python版本: $PYTHON_VERSION"

# 步骤2：创建虚拟环境
log_info "步骤2: 创建虚拟环境"
if [ ! -d "hwocr_env" ]; then
    python3 -m venv hwocr_env
    log_info "虚拟环境创建成功"
else
    log_warn "虚拟环境已存在，跳过创建"
fi

# 步骤3：激活虚拟环境
log_info "步骤3: 激活虚拟环境"
source hwocr_env/bin/activate

# 步骤4：安装依赖
log_info "步骤4: 安装Python依赖"
pip install --upgrade pip

if [ -f "requirements.txt" ]; then
    pip install -r requirements.txt
    log_info "依赖安装完成"
else
    log_error "requirements.txt 文件不存在"
    exit 1
fi

# 步骤5：验证安装
log_info "步骤5: 验证安装"
python verification.py

if [ $? -eq 0 ]; then
    log_info "验证成功"
else
    log_error "验证失败"
    exit 1
fi

# 步骤6：下载预训练模型（可选）
log_info "步骤6: 下载预训练模型"
mkdir -p models/pretrained
cd models/pretrained

# 下载DBNet预训练模型
if [ ! -f "dbnet_resnet50.pth" ]; then
    log_info "下载DBNet模型..."
    wget https://github.com/MhLiao/DB/releases/download/1.0/dbnet_resnet50.pth
fi

# 下载CRNN预训练模型
if [ ! -f "crnn_synth90k.pth" ]; then
    log_info "下载CRNN模型..."
    wget https://github.com/meijieru/crnn.pytorch/releases/download/1.0/crnn_synth90k.pth
fi

cd ../..

# 步骤7：创建必要目录
log_info "步骤7: 创建项目目录结构"
mkdir -p data/{raw,processed,train,val,test}
mkdir -p logs/{training,inference}
mkdir -p models/saved/{detection,recognition}

# 步骤8：初始化配置文件
log_info "步骤8: 初始化配置文件"
if [ ! -f ".env" ]; then
    cp .env.example .env
    log_warn "请编辑 .env 文件配置环境变量"
fi

echo "========================================="
echo "部署完成！"
echo "========================================="
echo ""
echo "下一步操作："
echo "1. 激活虚拟环境: source hwocr_env/bin/activate"
echo "2. 编辑配置文件: nano .env"
echo "3. 启动Jupyter: jupyter notebook"
echo "4. 运行训练: python training/train.py"
echo "5. 启动API: python deployment/api/main.py"
echo ""
echo "Docker部署: docker-compose up -d"
echo "========================================="
EOF

chmod +x scripts/setup.sh

3. 常见问题与解决方案

问题1：CUDA版本不匹配

# 查看当前CUDA版本
nvcc --version

# 如果版本不匹配，重新安装正确版本的PyTorch
pip uninstall torch torchvision torchaudio
pip install torch==2.0.0+cu117 --extra-index-url https://download.pytorch.org/whl/cu117

问题2：内存不足

# 创建交换空间
sudo fallocate -l 16G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# 永久生效
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

问题3：权限问题

# 修复权限
sudo chown -R $USER:$USER ~/projects/handwriting_ocr_system
sudo chmod -R 755 ~/projects/handwriting_ocr_system

问题4：网络超时

# 使用国内镜像源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

# 设置CUDA镜像
export PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple

4. 快速验证环境

# 运行快速测试
cat > quick_test.py << 'EOF'
import torch
import cv2
import numpy as np
from PIL import Image

print("=" * 50)
print("快速环境测试")
print("=" * 50)

# 1. PyTorch测试
print("\n1. PyTorch测试:")
print(f"   版本: {torch.__version__}")
print(f"   CUDA可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"   GPU: {torch.cuda.get_device_name(0)}")
    print(f"   CUDA版本: {torch.version.cuda}")

# 2. 图像库测试
print("\n2. 图像库测试:")
print(f"   OpenCV版本: {cv2.__version__}")
print(f"   PIL版本: {Image.__version__}")

# 3. 创建测试图像
img = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)

# 4. OpenCV操作
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
print(f"   OpenCV转换: {gray.shape}")

# 5. PyTorch GPU测试
if torch.cuda.is_available():
    print("\n3. GPU计算测试:")
    x = torch.randn(1000, 1000).cuda()
    y = torch.randn(1000, 1000).cuda()
    z = torch.matmul(x, y)
    print(f"   GPU矩阵乘法: {z.shape}")

print("\n" + "=" * 50)
print("测试完成！")
print("=" * 50)
EOF

python quick_test.py

5. 维护与更新

定期更新依赖

# 更新所有包
pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1 | xargs -n1 pip install -U

# 更新PyTorch（谨慎操作）
pip install --upgrade torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu118

环境备份

# 备份环境配置
pip freeze > requirements_backup.txt

# 备份关键文件
tar -czf env_backup_$(date +%Y%m%d).tar.gz \
    hwocr_env/ \
    requirements.txt \
    training/configs/ \
    .env \
    verification.py

总结

通过以上详细步骤，您已经成功搭建了一个完整的手写OCR深度学习开发环境。这个环境包含了：

1. 完整的GPU支持：NVIDIA驱动 + CUDA + cuDNN
2. Python开发环境：Python 3.8 + 虚拟环境 + 所有必要依赖
3. 项目结构：标准化目录和配置文件
4. 验证工具：确保所有组件正常工作
5. 部署选项：支持本地开发和Docker容器化