Qwen2-VL-2B-Instruct保姆级教程：多线程图片上传与异步向量计算实现

新职语

172人浏览 · 2026-03-21 00:16:11

新职语 · 2026-03-21 00:16:11 发布

Qwen2-VL-2B-Instruct保姆级教程：多线程图片上传与异步向量计算实现

1. 教程目标与价值

你是不是遇到过这样的场景？手里有一堆图片，想快速找到和某段文字描述最匹配的那一张，或者想在海量图片库里找出风格相似的照片。传统方法要么靠人工一张张看，效率极低；要么用简单的文件名或标签搜索，结果往往不准确。

今天要介绍的 GME-Qwen2-VL-2B-Instruct 工具，就是来解决这个痛点的。它不是一个普通的聊天AI，而是一个专业的“多模态语义理解引擎”。简单说，它能同时看懂文字和图片的“意思”，然后把它们都转换成数学向量，通过计算向量之间的相似度，告诉你文字和图片、图片和图片之间到底有多匹配。

本教程将手把手教你如何部署和使用这个工具，并重点分享两个高级技巧：多线程图片上传和异步向量计算。学完之后，你将能：

在本地快速搭建一个图文语义搜索系统
理解多模态向量计算的基本原理
掌握提升处理效率的实用编程技巧
构建自己的图片语义检索应用

无论你是开发者、设计师，还是内容管理者，这个工具都能帮你大幅提升工作效率。

2. 环境准备与快速部署

2.1 系统要求与依赖安装

首先确认你的电脑环境。这个工具对硬件有一定要求，主要是显卡：

操作系统：Windows 10/11， macOS，或 Linux（推荐Ubuntu）
Python版本：Python 3.8 或更高版本
显卡：强烈推荐NVIDIA显卡，显存至少6GB（8GB以上体验更佳）。如果没有独立显卡，也可以用CPU运行，但速度会慢很多。
内存：建议16GB或以上
磁盘空间：至少10GB可用空间（主要用于存放模型文件）

打开你的命令行终端（Windows用CMD或PowerShell，macOS/Linux用Terminal），依次执行以下命令来安装必要的软件包：

# 创建并激活一个虚拟环境（可选但推荐）
python -m venv gme_env
# Windows
gme_env\Scripts\activate
# macOS/Linux
source gme_env/bin/activate

# 安装核心依赖
pip install streamlit torch sentence-transformers Pillow numpy

# 如果你有NVIDIA显卡，建议安装带CUDA支持的PyTorch以获得GPU加速
# 访问 https://pytorch.org/get-started/locally/ 获取适合你系统的安装命令
# 例如，对于CUDA 11.8：
# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

安装过程可能需要几分钟，取决于你的网速。如果遇到网络问题，可以考虑使用国内的镜像源，比如清华源或阿里云源。

2.2 获取模型与项目文件

这个工具的核心是 GME-Qwen2-VL-2B-Instruct 模型。你需要准备模型文件：

下载模型：从官方渠道或可信源下载模型权重文件。通常模型会包含多个文件（如pytorch_model.bin, config.json, tokenizer.json等）。
组织目录：在你的项目文件夹里，创建一个专门的目录来存放模型。按照工具的默认要求，结构应该是这样的：

你的项目文件夹/
├── ai-models/
│   └── iic/
│       └── gme-Qwen2-VL-2B-Instruct/  （这里放所有模型文件）
│           ├── pytorch_model.bin
│           ├── config.json
│           ├── tokenizer.json
│           └── ... (其他模型文件)
├── app.py  （主程序文件，稍后提供）
└── temp_images/  （工具运行时会自动创建，用于缓存图片）

重要提示：模型文件比较大（约几个GB），下载时需要耐心等待。确保模型文件完整，没有损坏。

2.3 编写主程序文件 (app.py)

接下来，创建一个名为 app.py 的Python文件，这是工具的核心。将以下代码复制进去：

import streamlit as st
import torch
from sentence_transformers import SentenceTransformer
from PIL import Image
import os
import numpy as np
from pathlib import Path
import time
import threading
import queue
import asyncio
import aiofiles
from concurrent.futures import ThreadPoolExecutor

# -------------------- 工具核心：带指令的多模态模型加载 --------------------
@st.cache_resource
def load_model():
    """
    加载GME-Qwen2-VL多模态嵌入模型。
    使用缓存装饰器，避免重复加载消耗时间。
    """
    model_path = "./ai-models/iic/gme-Qwen2-VL-2B-Instruct"
    if not os.path.exists(model_path):
        st.error(f"❌ 模型路径不存在: {model_path}")
        st.stop()
    
    try:
        # 自动检测CUDA，如果可用则使用GPU，否则使用CPU
        device = "cuda" if torch.cuda.is_available() else "cpu"
        st.sidebar.success(f"✅ 模型将运行在: {device.upper()}")
        
        # 加载模型，指定trust_remote_code以兼容特定架构
        model = SentenceTransformer(
            model_path, 
            device=device,
            trust_remote_code=True
        )
        return model
    except Exception as e:
        st.error(f"❌ 模型加载失败: {e}")
        st.stop()

# -------------------- 多线程图片处理工具 --------------------
class ImageProcessor:
    """处理图片上传、保存和路径管理的工具类，支持多线程"""
    
    def __init__(self, temp_dir="temp_images"):
        self.temp_dir = temp_dir
        self._ensure_temp_dir()
        self.executor = ThreadPoolExecutor(max_workers=4)  # 最大4个线程
        self.processing_queue = queue.Queue()
        
    def _ensure_temp_dir(self):
        """确保临时图片目录存在"""
        os.makedirs(self.temp_dir, exist_ok=True)
    
    def save_uploaded_file(self, uploaded_file):
        """
        多线程保存上传的文件
        返回保存后的文件路径
        """
        if uploaded_file is None:
            return None
            
        # 生成唯一文件名，避免冲突
        file_extension = Path(uploaded_file.name).suffix
        unique_filename = f"{int(time.time())}_{uploaded_file.name}"
        save_path = os.path.join(self.temp_dir, unique_filename)
        
        # 使用线程池异步保存文件
        future = self.executor.submit(self._save_file, uploaded_file, save_path)
        future.result()  # 等待保存完成
        
        return save_path
    
    def _save_file(self, uploaded_file, save_path):
        """实际保存文件的内部方法"""
        try:
            with open(save_path, "wb") as f:
                f.write(uploaded_file.getbuffer())
            return save_path
        except Exception as e:
            st.error(f"文件保存失败: {e}")
            return None
    
    def cleanup_old_files(self, max_age_hours=24):
        """清理超过指定时间的临时文件"""
        try:
            current_time = time.time()
            for filename in os.listdir(self.temp_dir):
                filepath = os.path.join(self.temp_dir, filename)
                if os.path.isfile(filepath):
                    file_age = current_time - os.path.getmtime(filepath)
                    if file_age > max_age_hours * 3600:  # 转换为秒
                        os.remove(filepath)
            st.sidebar.success("✅ 临时文件清理完成")
        except Exception as e:
            st.sidebar.warning(f"清理文件时出错: {e}")

# -------------------- 异步向量计算工具 --------------------
class AsyncVectorCalculator:
    """异步计算文本和图片向量的工具类"""
    
    def __init__(self, model):
        self.model = model
        self.loop = asyncio.new_event_loop()
        
    async def encode_text_async(self, text, instruction=None):
        """异步编码文本为向量"""
        # 如果有指令，将指令和文本组合
        if instruction and instruction.strip():
            full_text = f"{instruction} {text}"
        else:
            full_text = text
            
        # 在单独的线程中运行编码任务，避免阻塞主线程
        loop = asyncio.get_event_loop()
        result = await loop.run_in_executor(
            None, 
            lambda: self.model.encode(full_text, convert_to_tensor=True)
        )
        return result
    
    async def encode_image_async(self, image_path):
        """异步编码图片为向量"""
        if not image_path or not os.path.exists(image_path):
            return None
            
        loop = asyncio.get_event_loop()
        result = await loop.run_in_executor(
            None, 
            lambda: self.model.encode(Image.open(image_path), convert_to_tensor=True)
        )
        return result
    
    async def calculate_similarity_async(self, vec_a, vec_b):
        """异步计算两个向量的余弦相似度"""
        if vec_a is None or vec_b is None:
            return 0.0
            
        loop = asyncio.get_event_loop()
        # 余弦相似度计算：向量点积 / (向量模长的乘积)
        similarity = await loop.run_in_executor(
            None,
            lambda: torch.nn.functional.cosine_similarity(
                vec_a.unsqueeze(0), 
                vec_b.unsqueeze(0)
            ).item()
        )
        return similarity

# -------------------- Streamlit 应用主界面 --------------------
def main():
    st.set_page_config(
        page_title="GME-Qwen2-VL 多模态相似度计算器",
        page_icon="🖼️",
        layout="wide"
    )
    
    st.title("🖼️ GME-Qwen2-VL 多模态相似度计算工具")
    st.markdown("---")
    
    # 初始化工具
    with st.spinner("🚀 正在加载多模态模型，请稍候..."):
        model = load_model()
    
    image_processor = ImageProcessor()
    vector_calculator = AsyncVectorCalculator(model)
    
    # 侧边栏：配置和工具
    with st.sidebar:
        st.header("⚙️ 设置与工具")
        
        # 清理临时文件按钮
        if st.button("🧹 清理临时文件", help="删除24小时前的临时图片文件"):
            image_processor.cleanup_old_files()
        
        st.markdown("---")
        st.subheader("ℹ️ 使用提示")
        st.info("""
        1. **指令(Instruction)** 能显著提升匹配精度
        2. 图片支持: JPG, PNG, WEBP 等格式
        3. 相似度范围: 0.0 (不相关) ~ 1.0 (完全匹配)
        4. 首次运行模型加载需要一些时间
        """)
    
    # 主界面分为两列
    col1, col2 = st.columns(2)
    
    with col1:
        st.subheader("📝 输入 A (查询/Query)")
        
        # 文本输入
        query_text = st.text_area(
            "输入查询文本",
            placeholder="例如：一只在草地上玩耍的棕色小狗",
            height=100
        )
        
        # 指令输入（提升精度关键）
        instruction = st.text_input(
            "指令 (Instruction)",
            value="Find an image that matches the given text.",
            help="明确的指令能引导模型生成更准确的向量"
        )
        
        st.markdown("**示例指令:**")
        st.code("""
        - 寻找与文字描述匹配的图片
        - 计算文本和图片的语义相似度
        - 识别具有相似视觉风格的图片
        """, language="text")
    
    with col2:
        st.subheader("🖼️ 输入 B (目标/Target)")
        
        # 选择输入类型：图片或文本
        input_type = st.radio(
            "选择目标类型",
            ["图片", "文本"],
            horizontal=True
        )
        
        if input_type == "图片":
            target_file = st.file_uploader(
                "上传图片",
                type=["jpg", "jpeg", "png", "webp", "bmp"],
                help="支持常见图片格式"
            )
            
            if target_file:
                # 多线程保存图片
                with st.spinner("🔄 正在处理图片..."):
                    target_path = image_processor.save_uploaded_file(target_file)
                
                if target_path:
                    st.image(target_file, caption="上传的图片", use_column_width=True)
                    st.success(f"✅ 图片已保存: {os.path.basename(target_path)}")
                target_text = None
            else:
                target_path = None
                target_text = None
                
        else:  # 文本模式
            target_text = st.text_area(
                "输入目标文本",
                placeholder="例如：阳光明媚的海滩风景",
                height=100
            )
            target_path = None
    
    # 计算按钮和结果显示
    st.markdown("---")
    
    if st.button("🔍 计算相似度", type="primary", use_container_width=True):
        if not query_text:
            st.warning("⚠️ 请输入查询文本")
            return
            
        if input_type == "图片" and not target_path:
            st.warning("⚠️ 请上传图片")
            return
        elif input_type == "文本" and not target_text:
            st.warning("⚠️ 请输入目标文本")
            return
        
        # 异步计算相似度
        with st.spinner("🧮 正在计算语义相似度..."):
            try:
                # 创建异步任务
                async def compute_similarity():
                    # 并行编码两个输入
                    encode_query = vector_calculator.encode_text_async(query_text, instruction)
                    
                    if input_type == "图片":
                        encode_target = vector_calculator.encode_image_async(target_path)
                    else:
                        encode_target = vector_calculator.encode_text_async(target_text)
                    
                    # 等待两个编码任务完成
                    vec_a, vec_b = await asyncio.gather(encode_query, encode_target)
                    
                    # 计算相似度
                    similarity = await vector_calculator.calculate_similarity_async(vec_a, vec_b)
                    return similarity, vec_a, vec_b
                
                # 运行异步任务
                similarity, vec_a, vec_b = asyncio.run(compute_similarity())
                
                # 显示结果
                st.subheader("📊 相似度结果")
                
                # 进度条可视化
                similarity_percent = similarity * 100
                st.progress(similarity, text=f"相似度: {similarity:.4f} ({similarity_percent:.1f}%)")
                
                # 语义解读
                if similarity >= 0.8:
                    st.success(f"🎯 极高匹配 ({similarity:.4f}) - 语义高度相关")
                elif similarity >= 0.6:
                    st.info(f"👍 良好匹配 ({similarity:.4f}) - 语义相关")
                elif similarity >= 0.4:
                    st.warning(f"🤔 一般匹配 ({similarity:.4f}) - 语义部分相关")
                else:
                    st.error(f"❌ 低匹配 ({similarity:.4f}) - 语义不相关")
                
                # 调试信息（可折叠）
                with st.expander("🔧 查看调试信息"):
                    if vec_a is not None and vec_b is not None:
                        st.write(f"**向量A形状:** {vec_a.shape}")
                        st.write(f"**向量B形状:** {vec_b.shape}")
                        st.write(f"**向量维度:** {vec_a.shape[-1]}")  # 通常是1536或3584
                        st.write(f"**计算设备:** {vec_a.device}")
                    
                    st.write("**计算原理:**")
                    st.latex(r"\text{相似度} = \frac{\vec{A} \cdot \vec{B}}{\|\vec{A}\| \|\vec{B}\|}")
                    st.caption("余弦相似度：值越接近1，语义越相似")
                    
            except Exception as e:
                st.error(f"❌ 计算过程中出错: {e}")
    
    # 使用示例
    st.markdown("---")
    with st.expander("📚 点击查看使用示例"):
        st.write("""
        **示例1：图文匹配**
        - 查询文本：`"现代简约风格的客厅，有大窗户和木质地板"`
        - 指令：`"Find an image that matches the given text."`
        - 目标：上传一张现代客厅的图片
        - 预期结果：相似度 > 0.7
        
        **示例2：文本相似度**
        - 查询文本：`"人工智能改变世界"`
        - 指令：`"Calculate semantic similarity between texts."`
        - 目标文本：`"AI技术正在重塑未来"`
        - 预期结果：相似度 > 0.6
        
        **示例3：图图匹配**
        - 查询：上传一张日落的图片
        - 指令：`"Identify images with similar visual styles."`
        - 目标：上传另一张日落图片
        - 预期结果：相似度 > 0.8
        """)
    
    # 页脚信息
    st.markdown("---")
    st.caption("💡 提示：模型首次运行需要加载时间，后续计算会更快。确保有足够的GPU显存以获得最佳性能。")

if __name__ == "__main__":
    main()

这个文件包含了完整的功能：模型加载、图片处理、向量计算和用户界面。特别注意的是，我们实现了两个高级功能：

多线程图片上传：使用ThreadPoolExecutor并行处理文件保存，避免界面卡顿
异步向量计算：使用asyncio实现编码和计算的异步执行，提升响应速度

2.4 启动应用

保存好app.py文件后，确保你的目录结构正确，然后在命令行中运行：

streamlit run app.py

Streamlit会自动在浏览器中打开应用界面（通常是 http://localhost:8501）。第一次运行需要加载模型，可能需要1-2分钟，请耐心等待。

3. 核心功能详解与实战操作

3.1 理解多模态向量计算

在深入使用之前，先简单了解一下背后的原理。传统的搜索只能匹配关键词，比如搜索“苹果”，它无法区分是水果苹果还是苹果公司。而多模态向量计算完全不同：

向量化：模型把文字和图片都转换成高维数学向量（比如1536维的数字列表）
语义理解：这个向量不是随机的，它包含了输入内容的“语义信息”。语义相近的内容，它们的向量在空间中的位置也相近
相似度计算：通过计算两个向量之间的夹角余弦值，得到相似度分数（0到1之间）

举个例子：

“一只猫在沙发上睡觉” → 向量A
一张猫在沙发上睡觉的图片 → 向量B
向量A和向量B的相似度会很高（可能0.85）
而“一辆红色汽车”的向量C，与向量A的相似度就会很低（可能0.15）

3.2 分步操作指南

现在让我们实际操作一下，看看每个功能怎么用：

第一步：输入查询内容 在左侧的“输入A”区域，写下你想搜索的内容。比如你想找一张“夕阳下的海滩”图片，就在这里输入。越详细的描述，结果越准确。

第二步：设置引导指令（关键步骤） 这是提升精度的秘诀！默认指令是“Find an image that matches the given text.”，但你可以根据任务调整：

图片搜索：用默认指令就好
风格匹配：改为“Find images with similar artistic style.”
物体识别：改为“Identify objects in the image that match the text.”
情感匹配：改为“Find images that convey similar emotions as the text.”

第三步：选择目标类型并输入 在右侧，你可以选择：

图片模式：上传一张图片，系统会计算你的文字描述和这张图片的匹配度
文本模式：输入另一段文字，系统会计算两段文字的语义相似度

第四步：执行计算 点击大大的“🔍 计算相似度”按钮。你会看到：

进度提示（“正在计算语义相似度...”）
相似度分数（0.0000到1.0000之间）
彩色进度条直观展示
语义解读（告诉你这个分数意味着什么）

第五步：解读结果

0.8以上：高度匹配，内容和描述高度相关
0.6-0.8：良好匹配，内容相关但可能有细节差异
0.4-0.6：一般匹配，部分相关但不够精确
0.4以下：低匹配，基本不相关

3.3 多线程与异步技术的实际效果

你可能注意到，在上传图片和计算相似度时，界面没有卡住，这就是多线程和异步技术的作用：

传统方式的问题：

# 同步方式：一步一步执行，用户要等待每一步完成
def traditional_way():
    save_image()      # 等待保存完成
    encode_text()     # 等待编码完成
    encode_image()    # 等待编码完成
    calculate()       # 等待计算完成
    # 用户在这期间只能干等着

我们的改进方式：

# 异步方式：多个任务同时进行
async def our_way():
    # 同时开始多个任务
    task1 = save_image_async()      # 在后台保存图片
    task2 = encode_text_async()     # 同时编码文本
    task3 = encode_image_async()    # 同时编码图片
    
    # 等待所有任务完成
    await asyncio.gather(task1, task2, task3)
    
    # 然后计算相似度
    result = calculate_async()
    # 用户在这期间可以看到进度，界面不会卡住

实际体验中，这意味着：

上传多张图片时，不会一张一张慢慢处理
计算相似度时，编码和计算可以并行
即使模型正在处理，你仍然可以操作界面的其他部分

4. 高级技巧与实用建议

4.1 如何获得更准确的结果

经过多次测试，我总结了一些提升准确性的经验：

1. 描述要具体

❌ 不好：“一张风景照”
✅ 好：“秋天的枫叶林，阳光透过树叶，地面有落叶，远处有山”

2. 指令要匹配任务

找匹配图片：“Find an image that matches the given text.”
找相似风格：“Find images with similar visual style.”
找相同物体：“Identify images containing the same object.”

3. 图片质量很重要

清晰、光线好的图片效果更好
避免过于复杂或模糊的图片
主体明确的图片更容易匹配

4. 理解分数含义

0.9+：几乎完美匹配
0.7-0.9：高度相关
0.5-0.7：中等相关
0.3-0.5：略有相关
<0.3：基本不相关

4.2 性能优化建议

如果你的电脑配置一般，或者处理大量图片时速度较慢，可以试试这些方法：

1. 调整线程数 在ImageProcessor类中，可以修改max_workers参数：

# 根据你的CPU核心数调整
self.executor = ThreadPoolExecutor(max_workers=2)  # 保守一点
# 或者
self.executor = ThreadPoolExecutor(max_workers=8)  # 如果CPU很强

2. 批量处理技巧 如果需要处理大量图片，可以：

# 批量上传和计算
image_paths = ["img1.jpg", "img2.jpg", "img3.jpg"]
query = "寻找有猫的图片"

# 使用列表推导式批量处理
results = []
for img_path in image_paths:
    similarity = calculate_similarity(query, img_path)
    results.append((img_path, similarity))

# 按相似度排序
sorted_results = sorted(results, key=lambda x: x[1], reverse=True)

3. 缓存优化 Streamlit有内置的缓存机制，对于重复的计算可以添加缓存：

@st.cache_data
def load_image(image_path):
    """缓存加载的图片"""
    return Image.open(image_path)

@st.cache_data
def encode_text_cached(text, instruction):
    """缓存文本编码结果"""
    return model.encode(f"{instruction} {text}")

4.3 常见问题解决

问题1：模型加载失败

检查：模型路径是否正确，文件是否完整
解决：确认ai-models/iic/gme-Qwen2-VL-2B-Instruct目录存在且包含所有必要文件

问题2：显存不足

现象：程序崩溃或报CUDA内存错误
解决：
1. 关闭其他占用显存的程序
2. 在代码中强制使用CPU（性能会下降）：
```
device = "cpu"  # 强制使用CPU
```
1. 减少同时处理的任务数

问题3：图片上传失败

检查：图片格式是否支持，文件是否损坏
解决：确保图片是JPG、PNG等常见格式，尝试用PIL打开测试：

from PIL import Image
try:
    img = Image.open("your_image.jpg")
    img.verify()  # 验证图片完整性
    print("图片正常")
except Exception as e:
    print(f"图片损坏: {e}")

问题4：相似度分数一直很低

可能原因：指令设置不当，或描述太模糊
解决：尝试更具体的描述，调整指令，确保查询和目标确实是相关的

5. 实际应用场景扩展

学会了基本用法，你可能会问：这工具到底能用在什么地方？其实应用场景非常多：

5.1 电商商品管理

假设你有一个服装电商网站，用户搜索“蓝色条纹衬衫”，传统搜索只能匹配标题中的关键词。用我们的工具，你可以：

将商品图片全部转换为向量存入数据库
用户搜索时，将搜索词也转换为向量
快速找到最匹配的商品图片
甚至可以实现“以图搜图”：用户上传一张衣服图片，找到相似款式

5.2 内容管理系统

如果你是自媒体运营者，有成千上万的图片素材：

输入“春节主题”，快速找到所有相关图片
输入“科技感背景”，找到适合科技文章配图
管理图片库时，自动识别和分组相似图片

5.3 设计素材检索

设计师经常需要找特定风格的图片：

描述“极简主义，留白，几何形状”，找到设计灵感图
上传一张喜欢的配色方案，找到色彩相似的图片
根据文字描述生成 mood board（情绪板）

5.4 教育资料整理

老师整理教学资料时：

输入“细胞结构示意图”，快速找到生物课图片
输入“历史地图”，找到相关地理图片
根据课文内容自动推荐配图

5.5 代码示例：批量处理图片库

如果你有一个图片文件夹，想快速找到所有和某个描述匹配的图片，可以这样写：

import os
from PIL import Image
from sentence_transformers import SentenceTransformer
import torch

class BatchImageSearcher:
    def __init__(self, model_path):
        self.model = SentenceTransformer(model_path, device="cuda")
        
    def search_similar_images(self, query_text, image_folder, top_k=10):
        """
        在文件夹中搜索与描述最匹配的图片
        
        参数：
        - query_text: 搜索描述
        - image_folder: 图片文件夹路径
        - top_k: 返回最匹配的前K张图片
        """
        # 编码查询文本
        query_vector = self.model.encode(query_text, convert_to_tensor=True)
        
        results = []
        
        # 遍历文件夹中的所有图片
        for filename in os.listdir(image_folder):
            if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.webp')):
                image_path = os.path.join(image_folder, filename)
                
                try:
                    # 编码图片
                    image = Image.open(image_path)
                    image_vector = self.model.encode(image, convert_to_tensor=True)
                    
                    # 计算相似度
                    similarity = torch.nn.functional.cosine_similarity(
                        query_vector.unsqueeze(0),
                        image_vector.unsqueeze(0)
                    ).item()
                    
                    results.append({
                        'filename': filename,
                        'path': image_path,
                        'similarity': similarity
                    })
                    
                except Exception as e:
                    print(f"处理图片 {filename} 时出错: {e}")
        
        # 按相似度排序
        results.sort(key=lambda x: x['similarity'], reverse=True)
        
        # 返回前K个结果
        return results[:top_k]

# 使用示例
if __name__ == "__main__":
    searcher = BatchImageSearcher("./ai-models/iic/gme-Qwen2-VL-2B-Instruct")
    
    # 搜索“海滩日落”相关的图片
    matches = searcher.search_similar_images(
        query_text="海滩日落，天空有橙色和紫色的云彩",
        image_folder="./my_photos",
        top_k=5
    )
    
    print("最匹配的5张图片：")
    for i, match in enumerate(matches, 1):
        print(f"{i}. {match['filename']} - 相似度: {match['similarity']:.4f}")

这个脚本可以批量处理整个文件夹的图片，帮你快速找到最相关的内容。