Qwen2-VL-2B-Instruct入门指南：向量空间可视化——t-SNE降维展示图文聚类效果

Qwen2-VL-2B-Instruct入门指南：向量空间可视化——t-SNE降维展示图文聚类效果

1. 引言：从“看懂”到“量化”的跨越

想象一下，你有一个装满图片和文字的文件夹。里面有猫的照片、狗的照片、风景照，还有各种描述它们的文字。现在，你想让电脑帮你做一件事：把这些内容按照“意思”自动分个类。

听起来是不是有点科幻？但这正是多模态AI模型正在做的事情。传统的AI模型要么只能处理文字，要么只能处理图片，它们生活在两个不同的世界里。而像Qwen2-VL-2B-Instruct这样的多模态模型，它的核心能力就是打破这个界限——它能同时理解文字和图片的“意思”，并把它们都转换成一种电脑能理解的“数字密码”，也就是向量。

今天我要带你做的，就是用一个非常酷的工具，把这些抽象的向量变成我们肉眼能看懂的图形。我们会用t-SNE这个降维算法，把成百上千维的向量压缩到二维平面上，让你亲眼看到：

• 描述“猫”的文字和猫的图片在向量空间里是不是真的挨得很近？
• 不同主题的内容会不会自动聚成一团？
• 模型到底有没有真正理解图文之间的语义联系？

这不仅是技术演示，更是一种理解AI“思考”方式的全新视角。准备好了吗？我们开始吧。

2. 环境准备：5分钟搞定一切

2.1 你需要准备什么

在开始之前，我们先确认一下你的“装备”是否齐全：

1. 一台能跑Python的电脑：Windows、Mac、Linux都可以
2. Python 3.8或更高版本：这是必须的
3. 至少8GB内存：处理图片和模型需要一些内存空间
4. 可选但推荐：NVIDIA显卡：如果有GPU（显存4GB以上），速度会快很多；没有也没关系，CPU也能跑，只是慢一点

2.2 一步步安装依赖

打开你的终端（Windows叫命令提示符或PowerShell），我们一行行来：

# 1. 先创建一个专门的项目文件夹，避免把环境搞乱 mkdir qwen2-vl-demo cd qwen2-vl-demo # 2. 创建虚拟环境（强烈推荐，保持环境干净） python -m venv venv # 3. 激活虚拟环境 # Windows用户： venv\Scripts\activate # Mac/Linux用户： source venv/bin/activate # 4. 安装核心依赖包 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 如果有NVIDIA显卡 # 如果没有显卡，用这个： # pip install torch torchvision torchaudio # 5. 安装其他必要包 pip install sentence-transformers pillow numpy matplotlib scikit-learn streamlit

小提示：如果你在安装torch时遇到问题，可以去pytorch官网根据你的系统选择正确的安装命令。

2.3 下载模型权重

Qwen2-VL-2B-Instruct模型需要下载权重文件。这里有两种方式：

方式一：自动下载（最简单）

# 创建一个download_model.py文件，内容如下： from sentence_transformers import SentenceTransformer # 这行代码会自动下载模型到本地缓存 model = SentenceTransformer('iic/gme-Qwen2-VL-2B-Instruct') print("模型下载完成！")

运行这个脚本，它会自动处理一切。

方式二：手动下载（如果网络不好）

1. 访问Hugging Face模型页面：iic/gme-Qwen2-VL-2B-Instruct
2. 下载所有文件到本地文件夹，比如./ai-models/iic/gme-Qwen2-VL-2B-Instruct/
3. 确保文件夹结构完整

3. 核心概念：向量空间到底是什么？

在深入代码之前，我们先花几分钟搞明白几个关键概念。别担心，我用最直白的方式解释。

3.1 向量：AI的“数字指纹”

想象一下，你要向朋友描述一只猫。你可能会说：“毛茸茸的、有胡须、会喵喵叫、眼睛很亮”。在AI的世界里，Qwen2-VL模型会做类似的事情，但它用的是数字。

比如一张猫的图片，经过模型处理，可能会变成这样一个向量：

[0.85, -0.23, 0.42, 0.67, -0.12, ..., 0.31] # 总共1536个数字

这1536个数字就是这张图片的“数字指纹”。文字也一样，一段描述“可爱的小猫在玩耍”的文字，也会被转换成类似的一串数字。

关键点：意思相近的内容，它们的“数字指纹”也会相似。这就是我们能做相似度搜索和聚类的基础。

3.2 t-SNE：把高维空间“压扁”成二维图

1536维是什么概念？我们人类最多只能理解三维空间（长、宽、高），1536维完全无法想象。

t-SNE算法的作用就是：在尽量保持数据点之间距离关系的前提下，把1536维的数据“投影”到二维平面上。这样，原本在1536维空间里挨得近的点，在二维图上也挨得近；离得远的点，在图上也会离得远。

一个生动的比喻：

• 原始数据就像在一个超大的多维迷宫里
• t-SNE就像给这个迷宫拍了一张“全景俯拍照”
• 在照片上，你能看到哪些房间（数据点）是连通的，哪些是隔离的

3.3 图文聚类的实际意义

为什么这个功能有用？看几个真实场景：

1. 电商商品管理：自动把“红色连衣裙”的文字描述和所有红色连衣裙的图片聚在一起
2. 内容审核：发现违规图片和敏感文字描述之间的关联
3. 知识图谱构建：建立图片和文字知识之间的语义链接
4. 创意灵感库：根据文字创意自动找到相关的视觉参考

4. 实战开始：构建完整的可视化流程

现在我们来写代码。我会把整个过程拆解成几个清晰的步骤，每个步骤都有完整的代码和解释。

4.1 第一步：准备测试数据

我们先创建一些简单的测试数据，包含文字和图片描述。在实际应用中，你可以替换成自己的数据。

# prepare_data.py import os from PIL import Image, ImageDraw, ImageFont import numpy as np def create_sample_images(): """创建一些简单的测试图片""" os.makedirs("sample_images", exist_ok=True) # 1. 创建猫的图片（红色） img_cat_red = Image.new('RGB', (100, 100), color='red') draw = ImageDraw.Draw(img_cat_red) # 简单画个猫脸 draw.ellipse([20, 20, 80, 80], outline='white', width=3) # 脸 draw.ellipse([35, 40, 45, 50], fill='white') # 左眼 draw.ellipse([55, 40, 65, 50], fill='white') # 右眼 draw.arc([35, 55, 65, 75], start=0, end=180, fill='white', width=3) # 嘴巴 img_cat_red.save("sample_images/cat_red.jpg") # 2. 创建猫的图片（蓝色） img_cat_blue = Image.new('RGB', (100, 100), color='blue') draw = ImageDraw.Draw(img_cat_blue) draw.ellipse([20, 20, 80, 80], outline='white', width=3) draw.ellipse([35, 40, 45, 50], fill='white') draw.ellipse([55, 40, 65, 50], fill='white') draw.arc([35, 55, 65, 75], start=0, end=180, fill='white', width=3) img_cat_blue.save("sample_images/cat_blue.jpg") # 3. 创建狗的图片（绿色） img_dog_green = Image.new('RGB', (100, 100), color='green') draw = ImageDraw.Draw(img_dog_green) draw.rectangle([30, 30, 70, 70], outline='white', width=3) # 狗脸更方 draw.ellipse([40, 45, 50, 55], fill='white') # 左眼 draw.ellipse([60, 45, 70, 55], fill='white') # 右眼 draw.line([45, 65, 55, 65], fill='white', width=3) # 嘴巴 img_dog_green.save("sample_images/dog_green.jpg") # 4. 创建风景图片（黄色） img_scenery = Image.new('RGB', (100, 100), color='yellow') draw = ImageDraw.Draw(img_scenery) # 画个简单的风景：天空、山、太阳 draw.rectangle([0, 0, 100, 60], fill='lightblue') # 天空 draw.polygon([0, 60, 50, 30, 100, 60], fill='brown') # 山 draw.ellipse([70, 10, 90, 30], fill='orange') # 太阳 img_scenery.save("sample_images/scenery.jpg") print("已创建4张测试图片到 sample_images/ 文件夹") def get_sample_texts(): """创建对应的文字描述""" texts = [ "一只红色的猫", # 对应 cat_red.jpg "一只蓝色的猫", # 对应 cat_blue.jpg "一只绿色的狗", # 对应 dog_green.jpg "美丽的风景，有山和太阳", # 对应 scenery.jpg # 再加一些纯文字描述，测试聚类效果 "可爱的小猫在玩耍", "忠诚的狗在看家", "日落时分的山景", "宠物动物", "自然风光" ] return texts if __name__ == "__main__": create_sample_images() texts = get_sample_texts() print("文字样本：") for i, text in enumerate(texts): print(f"{i+1}. {text}")

运行这个脚本，你会得到一个sample_images文件夹和一组文字描述。

4.2 第二步：加载模型并生成向量

这是核心步骤，我们要用Qwen2-VL模型把图片和文字都转换成向量。

# generate_embeddings.py import torch from sentence_transformers import SentenceTransformer from PIL import Image import numpy as np import os class Qwen2VLEncoder: def __init__(self, model_path=None): """ 初始化Qwen2-VL编码器 参数： model_path: 模型路径，如果为None则从HuggingFace下载 """ print("正在加载Qwen2-VL-2B-Instruct模型...") # 设置设备（优先使用GPU） self.device = "cuda" if torch.cuda.is_available() else "cpu" print(f"使用设备: {self.device}") # 加载模型 if model_path and os.path.exists(model_path): # 从本地加载 self.model = SentenceTransformer(model_path) else: # 从HuggingFace加载（首次运行会自动下载） self.model = SentenceTransformer('iic/gme-Qwen2-VL-2B-Instruct') self.model.to(self.device) print("模型加载完成！") def encode_text(self, text, instruction=None): """ 编码文本为向量 参数： text: 要编码的文本 instruction: 引导指令，告诉模型如何理解这个文本 例如："Find an image that matches the given text." 返回： numpy数组，形状为 (embedding_dim,) """ if instruction: # 如果有指令，将指令和文本结合 full_text = f"{instruction} {text}" else: full_text = text # 编码文本 with torch.no_grad(): embedding = self.model.encode(full_text, convert_to_tensor=True) return embedding.cpu().numpy() def encode_image(self, image_path, instruction=None): """ 编码图片为向量 参数： image_path: 图片文件路径 instruction: 引导指令，告诉模型如何理解这张图片 返回： numpy数组，形状为 (embedding_dim,) """ # 加载图片 try: image = Image.open(image_path).convert('RGB') except Exception as e: print(f"无法加载图片 {image_path}: {e}") return None if instruction: full_text = f"{instruction} {image_path}" else: full_text = image_path # 编码图片 with torch.no_grad(): # 注意：这里我们实际上是把图片路径作为文本输入 # 在实际使用中，你可能需要根据模型的具体API调整 embedding = self.model.encode(full_text, convert_to_tensor=True) return embedding.cpu().numpy() def encode_image_direct(self, image, instruction=None): """ 直接编码PIL Image对象 参数： image: PIL Image对象 instruction: 引导指令 返回： numpy数组 """ # 在实际项目中，你可能需要根据模型的具体输入格式调整 # 这里简化处理，将图片保存到临时文件再编码 import tempfile with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp: image.save(tmp.name) embedding = self.encode_image(tmp.name, instruction) os.unlink(tmp.name) return embedding def generate_all_embeddings(): """生成所有样本的嵌入向量""" # 初始化编码器 encoder = Qwen2VLEncoder() # 准备数据 from prepare_data import get_sample_texts texts = get_sample_texts() # 图片路径 image_files = [ "sample_images/cat_red.jpg", "sample_images/cat_blue.jpg", "sample_images/dog_green.jpg", "sample_images/scenery.jpg" ] # 使用统一的指令，确保向量空间一致 instruction = "Represent this for image and text matching:" print("\n开始生成文本向量...") text_embeddings = [] text_labels = [] for i, text in enumerate(texts): print(f"编码文本 {i+1}/{len(texts)}: {text[:30]}...") embedding = encoder.encode_text(text, instruction) text_embeddings.append(embedding) text_labels.append(f"文本_{i+1}") print("\n开始生成图片向量...") image_embeddings = [] image_labels = [] for i, img_path in enumerate(image_files): print(f"编码图片 {i+1}/{len(image_files)}: {os.path.basename(img_path)}") embedding = encoder.encode_image(img_path, instruction) if embedding is not None: image_embeddings.append(embedding) image_labels.append(f"图片_{i+1}") # 合并所有向量和标签 all_embeddings = np.vstack(text_embeddings + image_embeddings) all_labels = text_labels + image_labels all_types = ["文本"] * len(texts) + ["图片"] * len(image_files) # 保存结果 np.save("embeddings.npy", all_embeddings) # 保存标签信息 import json with open("labels_info.json", "w", encoding="utf-8") as f: json.dump({ "labels": all_labels, "types": all_types, "texts": texts, "image_files": image_files }, f, ensure_ascii=False, indent=2) print(f"\n完成！共生成 {len(all_embeddings)} 个向量") print(f"向量维度: {all_embeddings.shape[1]}") return all_embeddings, all_labels, all_types if __name__ == "__main__": generate_all_embeddings()

运行这个脚本，你会得到两个文件：

• embeddings.npy：保存所有的向量数据
• labels_info.json：保存标签和类型信息

4.3 第三步：t-SNE降维可视化

现在到了最激动人心的部分——把高维向量变成我们能看懂的二维图。

# visualize_tsne.py import numpy as np import matplotlib.pyplot as plt from sklearn.manifold import TSNE import json import os def load_data(): """加载之前生成的向量和标签""" embeddings = np.load("embeddings.npy") with open("labels_info.json", "r", encoding="utf-8") as f: info = json.load(f) return embeddings, info["labels"], info["types"], info["texts"] def run_tsne_visualization(): """执行t-SNE降维并可视化""" print("加载数据...") embeddings, labels, types, texts = load_data() print(f"数据形状: {embeddings.shape}") print(f"样本数量: {len(labels)}") # 应用t-SNE降维 print("正在运行t-SNE降维（这可能需要一些时间）...") tsne = TSNE( n_components=2, # 降到2维 perplexity=min(30, len(embeddings) - 1), # 困惑度，通常5-50之间 n_iter=1000, # 迭代次数 random_state=42, # 随机种子，确保结果可重复 init='pca' # 初始化方式，比随机初始化更稳定 ) # 执行降维 embeddings_2d = tsne.fit_transform(embeddings) print("t-SNE完成！开始绘制可视化图...") # 创建图形 plt.figure(figsize=(14, 10)) # 定义颜色和标记 colors = {'文本': 'blue', '图片': 'red'} markers = {'文本': 'o', '图片': 's'} # 圆圈表示文本，方块表示图片 # 绘制每个点 for i in range(len(embeddings_2d)): x, y = embeddings_2d[i] type_ = types[i] label = labels[i] # 绘制点 plt.scatter(x, y, c=colors[type_], marker=markers[type_], s=100, # 点的大小 alpha=0.7, # 透明度 edgecolors='black', # 边缘颜色 linewidth=0.5) # 添加标签（只显示前几个，避免太拥挤） if i < 8: # 只标注前8个点 plt.annotate(label, (x, y), xytext=(5, 5), textcoords='offset points', fontsize=9, alpha=0.8) # 添加图例 from matplotlib.lines import Line2D legend_elements = [ Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', markersize=10, label='文本'), Line2D([0], [0], marker='s', color='w', markerfacecolor='red', markersize=10, label='图片') ] plt.legend(handles=legend_elements, loc='upper right') # 添加标题和标签 plt.title('Qwen2-VL-2B向量空间t-SNE可视化\n（蓝色圆圈=文本，红色方块=图片）', fontsize=14, fontweight='bold') plt.xlabel('t-SNE维度 1', fontsize=12) plt.ylabel('t-SNE维度 2', fontsize=12) # 添加网格 plt.grid(True, alpha=0.3, linestyle='--') # 自动调整坐标轴范围，留一些边距 x_min, x_max = embeddings_2d[:, 0].min(), embeddings_2d[:, 0].max() y_min, y_max = embeddings_2d[:, 1].min(), embeddings_2d[:, 1].max() x_margin = (x_max - x_min) * 0.1 y_margin = (y_max - y_min) * 0.1 plt.xlim(x_min - x_margin, x_max + x_margin) plt.ylim(y_min - y_margin, y_max + y_margin) # 保存图片 plt.tight_layout() plt.savefig('tsne_visualization.png', dpi=300, bbox_inches='tight') plt.savefig('tsne_visualization.pdf', bbox_inches='tight') # 矢量图版本 print("可视化图已保存为 'tsne_visualization.png' 和 'tsne_visualization.pdf'") # 显示图片 plt.show() # 打印聚类分析 print("\n=== 聚类效果分析 ===") print("观察图中点的分布：") print("1. 相同主题的内容（如猫、狗、风景）是否聚在一起？") print("2. 文字和对应的图片是否距离较近？") print("3. 不同类型的内容（文本vs图片）是否有明显的分布规律？") # 计算一些统计信息 print("\n=== 距离分析 ===") # 计算文本和图片之间的平均距离 text_indices = [i for i, t in enumerate(types) if t == "文本"] image_indices = [i for i, t in enumerate(types) if t == "图片"] if text_indices and image_indices: # 计算所有文本-图片对的距离 distances = [] for ti in text_indices: for ii in image_indices: dist = np.linalg.norm(embeddings_2d[ti] - embeddings_2d[ii]) distances.append(dist) avg_distance = np.mean(distances) print(f"文本和图片之间的平均距离: {avg_distance:.4f}") print(f"最小距离: {np.min(distances):.4f}") print(f"最大距离: {np.max(distances):.4f}") return embeddings_2d def create_interactive_plot(): """创建交互式可视化（可选）""" try: import plotly.graph_objects as go import plotly.express as px embeddings, labels, types, texts = load_data() # 运行t-SNE（使用更快的参数） tsne = TSNE(n_components=2, perplexity=10, random_state=42) embeddings_2d = tsne.fit_transform(embeddings) # 创建DataFrame import pandas as pd df = pd.DataFrame({ 'x': embeddings_2d[:, 0], 'y': embeddings_2d[:, 1], 'label': labels, 'type': types, 'text': [t if i < len(texts) else '' for i, t in enumerate(texts + ['']*4)] }) # 创建交互式散点图 fig = px.scatter(df, x='x', y='y', color='type', hover_name='label', hover_data=['text'], title='Qwen2-VL-2B向量空间交互式可视化', labels={'x': 't-SNE维度1', 'y': 't-SNE维度2'}, width=1000, height=700) # 保存为HTML文件 fig.write_html("interactive_tsne.html") print("交互式可视化已保存为 'interactive_tsne.html'") print("用浏览器打开该文件可以交互查看！") except ImportError: print("未安装plotly，跳过交互式可视化") print("要使用此功能，请运行: pip install plotly") if __name__ == "__main__": # 运行标准可视化 embeddings_2d = run_tsne_visualization() # 尝试创建交互式可视化 create_interactive_plot() print("\n=== 下一步建议 ===") print("1. 查看生成的 tsne_visualization.png，观察聚类效果") print("2. 用浏览器打开 interactive_tsne.html（如果已生成）进行交互探索") print("3. 尝试修改 prepare_data.py 中的样本，看看不同内容如何影响聚类")

4.4 第四步：创建Streamlit交互应用

为了让整个过程更加友好，我们创建一个Web应用，让你可以通过界面操作一切。

# app.py import streamlit as st import numpy as np import matplotlib.pyplot as plt from sklearn.manifold import TSNE import pandas as pd import plotly.express as px import plotly.graph_objects as go from PIL import Image import os import json import tempfile # 设置页面配置 st.set_page_config( page_title="Qwen2-VL向量空间可视化", page_icon="🖼", layout="wide", initial_sidebar_state="expanded" ) # 标题和介绍 st.title("🖼 Qwen2-VL-2B向量空间可视化工具") st.markdown(""" 这个工具展示了**Qwen2-VL-2B-Instruct**模型如何将文本和图片映射到统一的向量空间， 并使用**t-SNE算法**将高维向量可视化到二维平面。 ### 你能看到什么？ 1. **语义聚类**：意思相近的内容在图上会靠得更近 2. **跨模态对齐**：描述图片的文字和图片本身在向量空间中的关系 3. **模型理解能力**：观察模型是否真正理解了图文语义 """) # 侧边栏：控制面板 with st.sidebar: st.header("⚙ 控制面板") # t-SNE参数设置 st.subheader("t-SNE参数") perplexity = st.slider("困惑度 (Perplexity)", 5, 50, 30, help="控制局部和全局结构的平衡，通常设为5-50") n_iter = st.slider("迭代次数", 250, 2000, 1000, step=250, help="迭代次数越多，结果越稳定，但计算时间越长") # 可视化选项 st.subheader("可视化选项") point_size = st.slider("点的大小", 50, 200, 100) show_labels = st.checkbox("显示标签", value=True) show_grid = st.checkbox("显示网格", value=True) # 数据管理 st.subheader("数据管理") if st.button(" 重新生成样本数据"): # 这里可以调用数据生成函数 st.info("重新生成数据...") # 实际实现中，这里会调用数据准备函数 st.success("数据已更新！") if st.button("🗑 清理临时文件"): # 清理临时文件 temp_files = ["embeddings.npy", "labels_info.json", "tsne_visualization.png", "interactive_tsne.html"] for file in temp_files: if os.path.exists(file): os.remove(file) st.success("临时文件已清理！") # 主内容区 tab1, tab2, tab3 = st.tabs([" 可视化展示", " 数据管理", " 使用教程"]) with tab1: # 检查是否有数据 if not os.path.exists("embeddings.npy"): st.warning(" 还没有生成向量数据！") st.info("请先运行数据生成脚本，或使用下面的示例数据") # 提供示例数据选项 if st.button("使用示例数据"): # 这里可以加载内置的示例数据 st.success("正在加载示例数据...") # 实际实现中，这里会加载预置的示例数据 else: # 加载数据 with st.spinner("正在加载数据..."): embeddings = np.load("embeddings.npy") with open("labels_info.json", "r", encoding="utf-8") as f: info = json.load(f) labels = info["labels"] types = info["types"] texts = info.get("texts", []) st.success(f"已加载 {len(embeddings)} 个样本") # 运行t-SNE with st.spinner("正在运行t-SNE降维..."): tsne = TSNE( n_components=2, perplexity=perplexity, n_iter=n_iter, random_state=42, init='pca' ) embeddings_2d = tsne.fit_transform(embeddings) # 创建两个并排的图表 col1, col2 = st.columns(2) with col1: st.subheader("Matplotlib静态图") # 创建matplotlib图 fig, ax = plt.subplots(figsize=(10, 8)) # 定义颜色 colors = {'文本': 'blue', '图片': 'red'} markers = {'文本': 'o', '图片': 's'} # 绘制点 for i in range(len(embeddings_2d)): x, y = embeddings_2d[i] type_ = types[i] ax.scatter(x, y, c=colors[type_], marker=markers[type_], s=point_size, alpha=0.7, edgecolors='black', linewidth=0.5) if show_labels and i < 10: # 只显示前10个标签 ax.annotate(labels[i], (x, y), xytext=(5, 5), textcoords='offset points', fontsize=9) # 添加图例 from matplotlib.lines import Line2D legend_elements = [ Line2D([0], [0], marker='o', color='w', markerfacecolor='blue', markersize=10, label='文本'), Line2D([0], [0], marker='s', color='w', markerfacecolor='red', markersize=10, label='图片') ] ax.legend(handles=legend_elements, loc='upper right') ax.set_title('Qwen2-VL向量空间t-SNE可视化', fontsize=14, fontweight='bold') ax.set_xlabel('t-SNE维度 1') ax.set_ylabel('t-SNE维度 2') if show_grid: ax.grid(True, alpha=0.3, linestyle='--') st.pyplot(fig) # 下载按钮 with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp: fig.savefig(tmp.name, dpi=300, bbox_inches='tight') with open(tmp.name, "rb") as file: btn = st.download_button( label=" 下载静态图", data=file, file_name="tsne_visualization.png", mime="image/png" ) with col2: st.subheader("Plotly交互图") # 创建交互式图表 df = pd.DataFrame({ 'x': embeddings_2d[:, 0], 'y': embeddings_2d[:, 1], 'label': labels, 'type': types, 'text': [t if i < len(texts) else '' for i, t in enumerate(texts + ['']*(len(labels)-len(texts)))] }) fig_interactive = px.scatter(df, x='x', y='y', color='type', hover_name='label', hover_data=['text'], title='交互式可视化', labels={'x': 't-SNE维度1', 'y': 't-SNE维度2'}, width=600, height=600) fig_interactive.update_traces(marker=dict(size=point_size/10, line=dict(width=1, color='black')), selector=dict(mode='markers')) st.plotly_chart(fig_interactive, use_container_width=True) # 保存交互式图表 html = fig_interactive.to_html() st.download_button( label=" 下载交互式HTML", data=html, file_name="interactive_tsne.html", mime="text/html" ) # 数据分析部分 st.subheader(" 数据分析") col3, col4, col5 = st.columns(3) with col3: # 计算聚类紧密度 st.metric("样本总数", len(embeddings)) with col4: # 计算文本和图片的平均距离 text_indices = [i for i, t in enumerate(types) if t == "文本"] image_indices = [i for i, t in enumerate(types) if t == "图片"] if text_indices and image_indices: distances = [] for ti in text_indices: for ii in image_indices: dist = np.linalg.norm(embeddings_2d[ti] - embeddings_2d[ii]) distances.append(dist) avg_distance = np.mean(distances) st.metric("平均跨模态距离", f"{avg_distance:.4f}") with col5: # 计算同类内容的平均距离 st.metric("向量维度", embeddings.shape[1]) # 显示原始数据 with st.expander(" 查看原始数据"): st.dataframe(df) with tab2: st.header(" 数据管理") # 上传自定义数据 st.subheader("上传自定义数据") uploaded_files = st.file_uploader( "选择图片文件（支持JPG、PNG）", type=['jpg', 'jpeg', 'png'], accept_multiple_files=True ) custom_texts = st.text_area( "输入文本描述（每行一个）", height=150, placeholder="例如：\n一只可爱的猫\n美丽的风景\n..." ) if st.button("处理自定义数据"): if uploaded_files or custom_texts: st.info("正在处理自定义数据...") # 这里可以添加处理自定义数据的代码 st.success("数据处理完成！") else: st.warning("请至少上传图片或输入文本") # 数据预览 st.subheader("当前数据预览") if os.path.exists("labels_info.json"): with open("labels_info.json", "r", encoding="utf-8") as f: info = json.load(f) # 显示文本样本 if "texts" in info: st.write("**文本样本：**") for i, text in enumerate(info["texts"][:5]): # 只显示前5个 st.write(f"{i+1}. {text}") if len(info["texts"]) > 5: st.write(f"... 还有 {len(info['texts']) - 5} 个文本") # 显示图片样本 if "image_files" in info: st.write("**图片样本：**") cols = st.columns(min(4, len(info["image_files"]))) for idx, img_path in enumerate(info["image_files"][:4]): # 只显示前4张 if os.path.exists(img_path): with cols[idx % 4]: try: image = Image.open(img_path) st.image(image, caption=os.path.basename(img_path), width=150) except: st.write(f"无法加载: {os.path.basename(img_path)}") with tab3: st.header(" 使用教程") st.markdown(""" ### 快速开始指南 1. **准备环境** ```bash pip install torch sentence-transformers pillow numpy matplotlib scikit-learn streamlit plotly ``` 2. **生成样本数据** ```bash python prepare_data.py python generate_embeddings.py ``` 3. **启动Web应用** ```bash streamlit run app.py ``` 4. **在浏览器中查看** 打开 http://localhost:8501 查看可视化结果 ### 理解可视化结果 - **点之间的距离**：距离越近，语义越相似 - **颜色区分**：蓝色=文本，红色=图片 - **形状区分**：圆圈=文本，方块=图片 ### 高级用法 - 调整t-SNE参数观察不同效果 - 上传自己的图片和文本 - 下载可视化结果用于报告或演示 ### 常见问题 **Q: 为什么有些点离得很远？** A: 这可能表示这些内容在语义上差异很大，或者模型对某些概念的理解还不够准确。 **Q: 如何提高聚类效果？** A: 尝试调整t-SNE参数，或者使用更详细、准确的文本描述。 **Q: 支持哪些图片格式？** A: 支持JPG、JPEG、PNG等常见格式。 """) # 页脚 st.markdown("---") st.markdown(""" <div style='text-align: center'> <p>使用 Qwen2-VL-2B-Instruct 模型 | 基于 Sentence-Transformers 框架</p> <p>可视化工具使用 t-SNE 算法 | 界面基于 Streamlit 构建</p> </div> """, unsafe_allow_html=True)

5. 运行与结果分析

5.1 完整运行流程

现在让我们把所有的步骤串起来，看看完整的运行效果：

# 第一步：准备环境（如果还没做） cd qwen2-vl-demo source venv/bin/activate # 或 venv\Scripts\activate # 第二步：生成测试数据 python prepare_data.py # 第三步：生成向量嵌入 python generate_embeddings.py # 第四步：可视化（命令行版本） python visualize_tsne.py # 第五步：启动Web应用（可选但推荐） streamlit run app.py

5.2 预期结果分析

运行完成后，你应该能看到类似下面的效果：

在t-SNE可视化图中，你可能会观察到：

1. 明显的聚类现象：

   • 所有关于“猫”的内容（红色猫图片、蓝色猫图片、“可爱的小猫”文字）可能会聚在一起
   • 关于“狗”的内容会形成另一个簇
   • 风景相关的内容会单独成簇

2. 跨模态对齐：

   • 描述“红色猫”的文字和红色猫的图片在图中距离应该很近
   • 同样，描述风景的文字和风景图片也应该靠近

3. 语义层次结构：

   • “宠物动物”这样的抽象概念可能会位于猫和狗簇的中间位置
   • 更具体的描述会更靠近对应的图片

如果结果不理想，可能是以下原因：

• 样本数量太少，t-SNE需要足够的数据点才能展现结构
• 文本描述不够准确或具体
• 需要调整t-SNE参数（特别是perplexity）

5.3 实际应用建议

基于这个可视化工具，你可以：

1. 评估模型理解能力：观察模型是否真正理解了图文语义
2. 优化提示词工程：尝试不同的instruction，看哪种能让同类内容更聚集
3. 构建语义搜索系统：基于向量相似度实现“以图搜图”或“以文搜图”
4. 内容自动分类：根据向量聚类结果自动给内容打标签
5. 异常检测：发现与其他内容明显不同的“离群点”

6. 总结与进阶探索

6.1 核心收获回顾

通过这个完整的实践项目，你应该已经掌握了：

1. 多模态嵌入的基本原理：理解了Qwen2-VL如何将图文映射到统一向量空间
2. t-SNE可视化的实际应用：学会了将高维数据降维到可理解的二维平面
3. 完整的工程实现流程：从环境搭建、数据处理、模型调用到可视化展示
4. 交互式工具开发：使用Streamlit快速构建可交互的Web应用

6.2 进阶探索方向

如果你对这个主题感兴趣，可以继续深入：

1. 尝试其他降维算法：

   # UMAP通常比t-SNE更快，且能更好地保持全局结构 pip install umap-learn import umap reducer = umap.UMAP(n_components=2) embeddings_2d = reducer.fit_transform(embeddings)

2. 使用更大的数据集：

   • 尝试COCO、Flickr30k等标准多模态数据集
   • 处理成千上万的样本，观察更大规模下的聚类效果

3. 对比不同模型：

   • 尝试CLIP、BLIP等其他多模态模型
   • 比较它们在相同任务上的表现差异

4. 构建实际应用：

   • 基于向量相似度的智能相册管理系统
   • 跨模态内容推荐系统
   • 自动图文匹配的电商平台

5. 性能优化：

   • 使用FAISS或Annoy加速向量搜索
   • 实现批量处理和大规模数据的高效可视化

6.3 最后的建议

多模态AI是一个快速发展的领域，Qwen2-VL只是众多优秀模型中的一个。这个项目最重要的价值不是学会了使用某个特定模型，而是掌握了理解、分析和可视化多模态向量空间的方法论。

无论未来出现什么新的模型，这套方法——生成嵌入、降维可视化、分析聚类——都是通用的。它让你能够“看到”模型是如何理解世界的，这是调试、优化和应用多模态AI系统的关键能力。

现在，你已经有了一个完整的工具链和清晰的理解。接下来，就是发挥你的创意，将这些技术应用到实际项目中去了。祝你探索愉快！

获取更多AI镜像

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