PaddleOCR-VL测评：0.9B参数的文档解析新王者

# 1. 创建并激活Conda环境
conda create -n paddle_env python=3.8
conda activate paddle_env

# 2. 安装PaddlePaddle基础框架（CPU版本）
pip install paddlepaddle==2.5.0 -i https://mirror.baidu.com/pypi/simple

# 3. 如需GPU加速，安装GPU版本（需提前配置CUDA和cuDNN）
pip install paddlepaddle-gpu==2.5.0.post117 -f https://www.paddlepaddle.org.cn/whl/windows/mkl/avx/stable.html

# 4. 安装PaddleOCR-VL
pip install paddleocr -f https://www.paddlepaddle.org.cn/whl/windows/mkl/avx/stable.html

# 5. 验证安装
python -c "import paddle; paddle.utils.run_check()"

# 自动下载默认模型（推荐新手）
from paddleocr import PaddleOCR
ocr = PaddleOCR(use_angle_cls=True, lang="ch")  # 首次运行会自动下载模型

# 或手动下载模型（推荐生产环境）
# 从PaddleOCR官方模型库下载检测、识别和分类模型
# 将模型文件放入./inference目录，结构如下：
# inference/
# ├── det/
# │   ├── ch_PP-OCRv4_det_infer/
# │   │   ├── inference.pdmodel
# │   │   └── inference.pdiparams
# ├── rec/
# └── cls/

# 1. 安装系统依赖
sudo apt update
sudo apt install -y python3-pip python3-dev build-essential libgl1-mesa-glx

# 2. 创建虚拟环境（可选但推荐）
python3 -m venv ocr_env
source ocr_env/bin/activate

# 3. 安装PaddlePaddle GPU版本（CUDA 11.2+）
pip3 install paddlepaddle-gpu==2.4.2.post117 -f https://www.paddlepaddle.org.cn/whl/linux/mkl/avx/stable.html

# 4. 安装PaddleOCR
pip3 install paddleocr==2.7.0.3

# 5. 配置权限（GPU场景）
sudo chmod a+rw /dev/dri/renderD128  # 根据实际设备节点调整

# 1. 使用Homebrew安装依赖
brew install opencv

# 2. 创建Python虚拟环境
python3 -m venv paddle_venv
source paddle_venv/bin/activate

# 3. 安装CPU版本PaddlePaddle
pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple

# 4. 安装PaddleOCR
pip install paddleocr

# 使用官方预构建镜像
docker run -it --gpus all -p 5000:5000 paddlepaddle/paddleocr:latest

FROM python:3.8-slim

# 安装系统依赖
RUN apt-get update && apt-get install -y python3-opencv
RUN pip install paddleocr flask -i https://mirror.baidu.com/pypi/simple

COPY app.py /app/
WORKDIR /app

CMD ["python", "app.py"]

from flask import Flask, request, jsonify
from paddleocr import PaddleOCR
import cv2
import numpy as np

app = Flask(__name__)
ocr = PaddleOCR(use_angle_cls=True, lang="ch", use_gpu=True)

@app.route("/ocr", methods=["POST"])
def ocr_api():
    file = request.files["image"]
    img_array = np.frombuffer(file.read(), np.uint8)
    img = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
    
    result = ocr.ocr(img, cls=True)
    
    # 结构化处理结果
    formatted_result = []
    for line in result:
        coordinates = line[0]
        text = line[1][0]
        confidence = line[1][1]
        formatted_result.append({
            "coordinates": coordinates,
            "text": text,
            "confidence": float(confidence)
        })
    
    return jsonify({"data": formatted_result})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

curl -X POST -F "image=@test.jpg" http://localhost:5000/ocr

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk
from paddleocr import PaddleOCR

class PaddleOCRClient:
    def __init__(self, root):
        self.root = root
        self.ocr = PaddleOCR(use_angle_cls=True, lang="ch")
        self.setup_ui()
    
    def setup_ui(self):
        self.root.title("PaddleOCR-VL客户端")
        self.root.geometry("800x600")
        
        # 上传按钮
        self.upload_btn = tk.Button(self.root, text="选择图片", command=self.upload_image)
        self.upload_btn.pack(pady=10)
        
        # 图片显示
        self.image_label = tk.Label(self.root)
        self.image_label.pack(pady=10)
        
        # 识别结果
        self.result_text = tk.Text(self.root, height=20)
        self.result_text.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
    
    def upload_image(self):
        file_path = filedialog.askopenfilename(filetypes=[("Image files", "*.jpg *.jpeg *.png")])
        if file_path:
            # 显示图片
            image = Image.open(file_path)
            image.thumbnail((400, 400))
            photo = ImageTk.PhotoImage(image)
            self.image_label.config(image=photo)
            self.image_label.image = photo
            
            # 执行OCR
            result = self.ocr.ocr(file_path, cls=True)
            
            # 显示结果
            self.result_text.delete(1.0, tk.END)
            for line in result:
                text = line[1][0]
                confidence = line[1][1]
                self.result_text.insert(tk.END, f"{text} ({confidence:.2f})\n")

if __name__ == "__main__":
    root = tk.Tk()
    client = PaddleOCRClient(root)
    root.mainloop()

import os
import json
from paddleocr import PaddleOCR
import cv2
from concurrent.futures import ThreadPoolExecutor

class FinancialDocumentProcessor:
    def __init__(self):
        self.ocr = PaddleOCR(
            use_angle_cls=True,
            lang="ch",
            use_gpu=True,
            det_db_thresh=0.3,  # 调整检测阈值适应复杂背景
            det_db_box_thresh=0.5,
            rec_batch_num=6,    # 批量推理提升速度
            enable_memory_optim=True  # 内存优化
        )
    
    def process_document(self, img_path):
        """处理单张财务文档"""
        try:
            # 执行OCR识别
            result = self.ocr.ocr(img_path, cls=True)
            
            # 提取结构化信息
            structured_data = self.extract_financial_info(result, img_path)
            
            # 生成Markdown格式报告
            markdown_report = self.generate_markdown(result, structured_data)
            
            return {
                "original_result": result,
                "structured_data": structured_data,
                "markdown_report": markdown_report
            }
        except Exception as e:
            print(f"处理文档 {img_path} 时出错: {str(e)}")
            return None
    
    def extract_financial_info(self, result, img_path):
        """提取财务关键信息"""
        financial_data = {
            "invoice_code": "",
            "invoice_number": "", 
            "date": "",
            "amount": "",
            "taxpayer_id": "",
            "handwritten_notes": [],
            "table_data": []
        }
        
        all_text = [line[1][0] for line in result]
        
        # 关键字段匹配规则
        for text in all_text:
            text_clean = text.replace(" ", "").replace("：", ":")
            
            # 匹配发票代码
            if "发票代码" in text_clean or "代码" in text_clean:
                financial_data["invoice_code"] = self.extract_value(text_clean)
            
            # 匹配发票号码
            elif "发票号码" in text_clean or "号码" in text_clean:
                financial_data["invoice_number"] = self.extract_value(text_clean)
            
            # 匹配金额
            elif "金额" in text_clean or "小写" in text_clean:
                amount = self.extract_amount(text_clean)
                if amount:
                    financial_data["amount"] = amount
            
            # 匹配纳税人识别号
            elif "纳税人识别号" in text_clean or "识别号" in text_clean:
                financial_data["taxpayer_id"] = self.extract_value(text_clean)
            
            # 识别手写文本（基于置信度判断）
            elif self.is_handwritten(text, result):
                financial_data["handwritten_notes"].append(text)
        
        return financial_data
    
    def extract_value(self, text):
        """提取冒号后的值"""
        if ":" in text:
            return text.split(":")[-1].strip()
        return text
    
    def extract_amount(self, text):
        """提取金额信息"""
        import re
        # 匹配金额模式 ￥1,250.00 或 ¥1250.00
        amount_pattern = r'[￥¥]([0-9,]+\.?[0-9]*)'
        match = re.search(amount_pattern, text)
        if match:
            return match.group(0)
        return ""
    
    def is_handwritten(self, text, result):
        """基于置信度判断是否为手写文本"""
        for line in result:
            if line[1][0] == text and line[1][1] < 0.7:  # 手写文本置信度通常较低
                return True
        return False
    
    def generate_markdown(self, result, financial_data):
        """生成Markdown格式报告"""
        markdown = "# 财务文档解析报告\n\n"
        
        markdown += "## 关键信息提取\n"
        markdown += f"- **发票代码**: {financial_data['invoice_code']}\n"
        markdown += f"- **发票号码**: {financial_data['invoice_number']}\n"
        markdown += f"- **金额**: {financial_data['amount']}\n"
        markdown += f"- **纳税人识别号**: {financial_data['taxpayer_id']}\n"
        
        if financial_data['handwritten_notes']:
            markdown += "\n## 手写批注\n"
            for note in financial_data['handwritten_notes']:
                markdown += f"- {note}\n"
        
        markdown += "\n## 完整识别文本\n"
        for line in result:
            text = line[1][0]
            confidence = line[1][1]
            markdown += f"- {text} ({confidence:.2f})\n"
        
        return markdown
    
    def batch_process(self, input_dir, output_dir):
        """批量处理文档"""
        os.makedirs(output_dir, exist_ok=True)
        image_files = [f for f in os.listdir(input_dir) 
                      if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
        
        with ThreadPoolExecutor(max_workers=4) as executor:
            results = list(executor.map(
                lambda f: self.process_single_file(f, input_dir, output_dir), 
                image_files
            ))
        
        return results
    
    def process_single_file(self, filename, input_dir, output_dir):
        """处理单个文件"""
        img_path = os.path.join(input_dir, filename)
        result = self.process_document(img_path)
        
        if result:
            # 保存JSON结果
            json_path = os.path.join(output_dir, f"{os.path.splitext(filename)[0]}.json")
            with open(json_path, 'w', encoding='utf-8') as f:
                json.dump(result['structured_data'], f, ensure_ascii=False, indent=2)
            
            # 保存Markdown报告
            md_path = os.path.join(output_dir, f"{os.path.splitext(filename)[0]}.md")
            with open(md_path, 'w', encoding='utf-8') as f:
                f.write(result['markdown_report'])
        
        return result

# 使用示例
if __name__ == "__main__":
    processor = FinancialDocumentProcessor()
    
    # 单文档处理
    result = processor.process_document("invoice.jpg")
    print("识别结果:", result['structured_data'])
    
    # 批量处理
    results = processor.batch_process("./input_docs", "./output_reports")
    print(f"批量处理完成，共处理 {len(results)} 个文档")