批量处理怎么做？fft npainting lama多图修复策略

批量处理怎么做？FFT NPainting LAMA多图修复策略

在实际工作中，我们经常需要处理几十甚至上百张图片的修复任务——比如电商团队要批量去除商品图上的水印，设计师要清理素材库中带logo的参考图，或者摄影师需要统一修复老照片中的划痕。手动一张张操作不仅耗时，还容易出错。今天我们就来聊聊如何用fft npainting lama重绘修复镜像（二次开发构建by科哥）实现真正高效的批量图像修复。

这不是一个“点几下就能跑”的黑盒工具，而是一套可定制、可扩展、能融入工作流的批量处理方案。我们将从单图精修逻辑出发，逐步升级到多图自动化流水线，最后给出三种实用的批量策略：轻量脚本驱动、WebUI批量增强、以及生产级API服务化。全程不讲抽象理论，只说你马上能用的方法。

1. 理解单图修复的核心逻辑：为什么标注方式决定批量成败

在开始批量之前，必须先搞懂这个镜像最底层的工作机制——它不是靠“智能识别物体”来修复，而是严格遵循“用户标注即指令”的原则。白色画笔涂抹的区域，就是模型唯一关注的修复目标；其余部分只是提供上下文信息。

这意味着：批量处理的成败，80%取决于你如何生成和管理这些标注（mask）。不是模型不够强，而是输入指令是否清晰、一致、可复用。

1.1 标注的本质：不是画画，是下指令

很多人第一次用时会下意识把画笔当Photoshop用，追求边缘精细。但其实，在fft npainting lama里：

• 白色区域 = 模型必须重绘的区域
• 未标注区域 = 模型必须原样保留的内容
• ❌灰色/半透明 = 无效指令（会被忽略）
• ❌标注过窄 = 修复后边缘生硬、有接缝
• ❌标注过宽 = 模型可能过度平滑，丢失细节

所以，真正的“精准标注”，不是描边准，而是范围合理、边界留有余量。这也是批量能成功的关键前提——因为机器生成的mask，永远做不到人眼描边那么细，但完全可以做到“范围合理”。

1.2 为什么不能直接拖100张图进去一键修复？

看一眼WebUI界面结构就明白了：

┌──────────────────────┬──────────────────────────────┐ │ 图像编辑区 │ 📷 修复结果 │ │ [图像上传/编辑] │ [修复后图像显示] │ │ [ 开始修复] │ 处理状态 │ └──────────────────────┴──────────────────────────────┘

它是一个交互式单任务系统：一次只处理一张图，依赖人工完成“上传→标注→点击→等待→下载”闭环。没有内置的队列、没有批量上传入口、也没有mask预设功能。想批量，就得绕过这个界面，直击它的能力内核。

而这个内核，就藏在启动命令里：

cd /root/cv_fft_inpainting_lama bash start_app.sh

start_app.sh启动的是一个基于Gradio的Web服务，其核心逻辑必然封装在一个Python脚本中（比如app.py）。只要找到它，我们就拿到了批量的钥匙。

2. 批量策略一：轻量脚本驱动——用命令行接管修复流程

这是最快上手、零额外依赖的方案。核心思路是：不碰WebUI，只调用它背后的实际修复函数，用Python脚本批量读取图片、自动生成mask、调用修复、保存结果。

2.1 定位核心修复函数

进入镜像工作目录：

cd /root/cv_fft_inpainting_lama ls -l

你大概率会看到类似这样的文件结构：

app.py # WebUI主程序 inference.py # 推理逻辑（关键！） models/ # 模型权重 inputs/ # 输入图片目录（可新建） outputs/ # 输出目录（已存在）

打开inference.py（或app.py中搜索def predict、def run_inpainting等关键词），你会找到类似这样的函数：

def run_inpainting(image_path: str, mask_path: str, output_path: str) -> None: """执行单张图像修复""" # 1. 加载图像和mask img = cv2.imread(image_path) mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE) # 2. 预处理（归一化、尺寸适配等） ... # 3. 加载模型并推理（这里调用LAMA核心） result = model.forward(img_tensor, mask_tensor) # 4. 保存结果 cv2.imwrite(output_path, result)

这就是我们要的“原子能力”。只要能调用这个函数，批量就成功了一半。

2.2 构建批量脚本：三步走

创建一个新文件batch_process.py：

#!/usr/bin/env python3 # -*- coding: utf-8 -*- import os import cv2 import numpy as np from datetime import datetime from inference import run_inpainting # 导入你找到的核心函数 # ===== 配置区（按需修改）===== INPUT_DIR = "/root/cv_fft_inpainting_lama/inputs" # 存放待修复原图 MASK_DIR = "/root/cv_fft_inpainting_lama/masks" # 存放对应mask图（同名.png） OUTPUT_DIR = "/root/cv_fft_inpainting_lama/batch_outputs" os.makedirs(OUTPUT_DIR, exist_ok=True) # ===== 生成简单mask的函数（示例：去除固定位置水印）===== def create_watermark_mask(img_path, mask_path, x=50, y=50, w=200, h=60): """ 为图片生成矩形mask：假设水印总在右上角(x,y)位置，宽w高h 实际中可替换为YOLO检测、OpenCV模板匹配等更智能方式 """ img = cv2.imread(img_path) h_img, w_img = img.shape[:2] # 创建全黑mask（0=不修复，255=修复） mask = np.zeros((h_img, w_img), dtype=np.uint8) # 在指定区域画白矩形 cv2.rectangle(mask, (x, y), (x+w, y+h), 255, -1) cv2.imwrite(mask_path, mask) # ===== 主批量流程 ===== if __name__ == "__main__": start_time = datetime.now() print(f"[{start_time}] 批量修复开始...") processed = 0 for filename in os.listdir(INPUT_DIR): if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')): continue image_path = os.path.join(INPUT_DIR, filename) name_no_ext = os.path.splitext(filename)[0] # 步骤1：生成mask（这里用简单矩形，你可替换成任何逻辑） mask_path = os.path.join(MASK_DIR, f"{name_no_ext}_mask.png") os.makedirs(MASK_DIR, exist_ok=True) create_watermark_mask(image_path, mask_path) # 步骤2：调用修复函数 output_path = os.path.join(OUTPUT_DIR, f"fixed_{filename}") try: run_inpainting(image_path, mask_path, output_path) print(f"✓ 已处理: {filename}") processed += 1 except Exception as e: print(f"✗ 处理失败 {filename}: {str(e)}") end_time = datetime.now() print(f"[{end_time}] 批量修复结束。共处理 {processed} 张，耗时 {(end_time - start_time).total_seconds():.1f} 秒") print(f"结果保存在: {OUTPUT_DIR}")

2.3 运行与验证

# 1. 准备图片：把10张待修复图放进 inputs/ 目录 # 2. 运行脚本 python3 batch_process.py # 3. 查看结果 ls -l /root/cv_fft_inpainting_lama/batch_outputs/

优势：完全复用镜像原有模型和逻辑，无需重新训练；代码透明，便于调试；适合一次性任务或小批量（<100张）。

注意点：

• create_watermark_mask是示例，实际中你需要根据业务定制mask生成逻辑（如：用OpenCV找文字区域、用YOLOv8检测logo、用SAM分割物体）。
• 确保inference.py中的run_inpainting函数能被直接导入调用（可能需要调整路径或添加if __name__ == "__main__":保护）。

3. 批量策略二：WebUI批量增强——给界面加个“上传文件夹”按钮

如果你习惯用WebUI操作，又不想写代码，这个方案最适合你。我们通过修改Gradio前端，给现有界面增加一个“上传整个文件夹”的功能，让批量变得和单图一样直观。

3.1 修改Gradio界面：一行代码解锁文件夹上传

Gradio原生支持文件夹上传，只需在app.py中找到图像上传组件（通常是gr.Image()），将其替换为gr.File(file_count="directory")。

打开app.py，找到类似这段代码：

with gr.Blocks() as demo: with gr.Row(): with gr.Column(): input_image = gr.Image(type="filepath", label="上传图像") # ... 其他组件

修改为：

with gr.Blocks() as demo: with gr.Row(): with gr.Column(): # 替换为文件夹上传 input_folder = gr.File(file_count="directory", label=" 上传整个文件夹（支持子目录）") # ... 其他组件（保持不变）

然后，在提交函数中，接收input_folder并遍历处理：

def process_folder(folder_path): if not folder_path: return "请先上传文件夹" # 获取所有图片文件 import glob import os supported_exts = ["*.png", "*.jpg", "*.jpeg", "*.webp"] image_files = [] for ext in supported_exts: image_files.extend(glob.glob(os.path.join(folder_path, "**", ext), recursive=True)) results = [] for img_path in image_files: try: # 为每张图生成mask（此处调用你的mask生成逻辑） mask_path = generate_mask_for_image(img_path) # 你实现的函数 output_path = os.path.join("/root/cv_fft_inpainting_lama/outputs", "batch_" + os.path.basename(img_path)) # 调用核心修复 run_inpainting(img_path, mask_path, output_path) results.append(f" {os.path.relpath(img_path, folder_path)} → {os.path.basename(output_path)}") except Exception as e: results.append(f"❌ {os.path.relpath(img_path, folder_path)}: {str(e)}") return "\n".join(results) # 将按钮点击事件绑定到新函数 submit_btn.click( fn=process_folder, inputs=[input_folder], outputs=[gr.Textbox(label="处理日志")] )

3.2 效果：就像这样操作

1. 启动修改后的WebUI：bash start_app.sh
2. 浏览器打开http://IP:7860
3. 点击 ** 上传整个文件夹**，选择包含50张商品图的文件夹
4. 点击 ** 开始修复** —— 系统自动逐张处理，实时显示日志
5. 刷新outputs/目录，所有修复图已就绪

优势：零学习成本，设计师、运营人员都能用；保留全部WebUI交互体验（如手动微调）；适合中等批量（100–1000张）。

🔧进阶提示：你还可以在界面上加一个“mask生成模式”下拉框（选项：自动去水印/移除人物/修复划痕），让不同任务一键切换。

4. 批量策略三：生产级API服务化——打造你的私有图像修复云

当批量需求变成常态化、高频次（比如每天处理2000+张图），或者需要集成到其他系统（ERP、CMS、小程序后台），就必须升级为API服务。这不再是“怎么批量”，而是“如何稳定、可监控、可伸缩地批量”。

4.1 架构设计：轻量但专业

我们不引入复杂框架，用最简方式构建一个健壮API：

[客户端] → HTTP POST → [FastAPI服务] → 调用 run_inpainting() → 返回JSON结果 ↳ 日志记录 + 错误捕获 + 耗时统计

创建api_server.py：

from fastapi import FastAPI, UploadFile, File, Form, HTTPException from fastapi.responses import JSONResponse import uvicorn import os import time from inference import run_inpainting app = FastAPI(title="FFT-LAMA 批量修复API", version="1.0") # 配置 OUTPUT_ROOT = "/root/cv_fft_inpainting_lama/api_outputs" os.makedirs(OUTPUT_ROOT, exist_ok=True) @app.post("/inpaint") async def inpaint_image( image: UploadFile = File(..., description="原始图像文件"), mask: UploadFile = File(None, description="掩码图像（可选，不传则自动生成）"), task_type: str = Form("watermark", description="任务类型: watermark|object|scratch") ): start_time = time.time() # 保存上传文件 image_path = os.path.join(OUTPUT_ROOT, f"input_{int(time.time())}_{image.filename}") with open(image_path, "wb") as f: f.write(await image.read()) if mask: mask_path = os.path.join(OUTPUT_ROOT, f"mask_{int(time.time())}_{mask.filename}") with open(mask_path, "wb") as f: f.write(await mask.read()) else: # 自动根据task_type生成mask（调用你的智能生成函数） from auto_mask import generate_mask # 你写的模块 mask_path = generate_mask(image_path, task_type) # 构建输出路径 output_filename = f"fixed_{os.path.splitext(image.filename)[0]}.png" output_path = os.path.join(OUTPUT_ROOT, output_filename) try: # 执行修复 run_inpainting(image_path, mask_path, output_path) process_time = time.time() - start_time return JSONResponse({ "status": "success", "output_url": f"http://your-server-ip:7860/outputs/{output_filename}", "process_time_sec": round(process_time, 2), "output_file": output_filename }) except Exception as e: raise HTTPException(status_code=500, detail=f"修复失败: {str(e)}") if __name__ == "__main__": uvicorn.run(app, host="0.0.0.0:8000", port=8000, workers=2)

4.2 如何使用这个API？

发送一个请求，就完成一次修复：

curl -X POST "http://localhost:8000/inpaint" \ -F "image=@/path/to/photo.jpg" \ -F "task_type=object"

响应：

{ "status": "success", "output_url": "http://your-server-ip:7860/outputs/fixed_photo.png", "process_time_sec": 12.34, "output_file": "fixed_photo.png" }

优势：可被任何语言调用（Python/Java/Node.js/PHP）；支持并发（workers=2）；自带错误处理和性能监控；可轻松接入Nginx做负载均衡、加HTTPS、限流。

规模化提示：

• 用supervisord管理API进程，崩溃自动重启
• 将OUTPUT_ROOT挂载到高性能SSD或NAS
• 用Redis做任务队列，避免大图阻塞（进阶）

5. 三种策略怎么选？一张表帮你决策

记住：没有“最好”的方案，只有“最合适”的方案。很多团队最终采用的是组合策略——用脚本处理历史数据迁移，用增强WebUI给设计师日常使用，用API对接核心业务系统。

6. 实战避坑指南：那些踩过的坑，你不必再踩

批量不是把单图流程复制100遍那么简单。以下是真实项目中高频出现的问题和解法：

6.1 坑：内存爆了！处理第10张图就OOM

现象：脚本运行到一半，Python报MemoryError或进程被系统kill。

根因：PyTorch默认不会释放GPU显存，每次run_inpainting都加载模型、缓存中间结果，显存持续增长。

解法：在每次修复后强制清空缓存：

import torch # 在 run_inpainting() 函数末尾添加 torch.cuda.empty_cache() # 如果用GPU # 或 import gc gc.collect() # 如果用CPU

6.2 坑：修复效果不一致，有的图很好，有的图糊成一片

现象：同一批图，参数完全一样，但结果质量差异大。

根因：镜像内部对图像做了自适应归一化（如：将长边缩放到1024px），但不同图的原始分辨率差异太大，导致小图被过度放大、大图被过度压缩。

解法：在批量前，统一预处理图像尺寸：

def resize_to_max(image_path, max_size=1024): img = cv2.imread(image_path) h, w = img.shape[:2] scale = min(max_size / w, max_size / h) if scale < 1.0: new_w = int(w * scale) new_h = int(h * scale) img = cv2.resize(img, (new_w, new_h)) cv2.imwrite(image_path, img)

6.3 坑：mask生成不准，水印没去干净，反而把商品主体删了

现象：自动mask把不该修的地方标白了。

根因：简单规则（如“右上角100x30矩形”）在复杂场景失效。

解法：升级mask策略，分层处理：

1. 第一层：粗定位（OpenCV模板匹配）——快速找常见水印位置
2. 第二层：精分割（轻量YOLOv5s）——对粗定位区域做精确框选
3. 第三层：后处理（形态学膨胀）——确保mask略大于目标，避免边缘残留

提示：科哥的镜像本身基于LAMA，而LAMA对mask容错性极强——宁可标大，不可标小。所以膨胀10像素，往往比追求1像素精准更重要。

6.4 坑：批量跑完，发现所有图都修复错了同一个位置

现象：所有输出图，都在左上角多了一块奇怪的色块。

根因：mask生成函数里，忘了重置变量，导致所有图共用同一个mask数组（浅拷贝陷阱）。

解法：在mask生成函数开头，强制深拷贝或新建数组：

# ❌ 错误：复用同一数组 mask = global_mask_template # 危险！ # 正确：每次都新建 mask = np.zeros((h, w), dtype=np.uint8)

总结：批量的本质，是把“人”的经验，翻译成“机器”能理解的指令

今天我们聊的不是某个按钮怎么点，而是一套完整的批量思维：

• 理解底层：知道镜像真正听谁的话（是你的标注，不是你的想象）
• 拆解流程：把“上传→标注→修复→下载”四步，变成可编程、可循环、可监控的原子操作
• 选择武器：脚本、界面、API，不是技术炫技，而是匹配你的团队能力和业务节奏
• 敬畏细节：内存、尺寸、mask容错性——这些看似琐碎的点，恰恰决定批量是提效还是添堵

最后送你一句实操口诀：“单图调通是基础，批量核心在mask，策略选择看规模，避坑关键在细节。”

现在，你可以打开终端，选一个策略，花15分钟，把今天学到的东西跑起来。批量处理，从来就不该是难题，而应该是你工作流里最顺手的一个环节。

获取更多AI镜像

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