# 3D资产检索机制分析

## 概述

本项目使用 **OpenShape** 框架来根据文本描述检索3D资产。OpenShape是一个基于CLIP的多模态3D模型检索系统。

---

## 核心技术栈

### 1. **OpenShape Embeddings**
- **模型**: CLIP-ViT-bigG-14-laion2B-39B-b160k
- **数据源**: Objaverse数据集 (大规模3D模型数据库)
- **预计算embeddings**: 存储在HuggingFace
  - `objaverse_meta.json` - 元数据 (模型名称、标签、面数等)
  - `objaverse.pt` - 预计算的特征向量

### 2. **文本编码器**
- 使用 CLIP 的文本编码器将物体描述转换为embedding向量
- 支持详细的多属性描述 (材质、风格、质量等)

---

## 检索流程

### 核心文件: `tools/retrive_3d.py`

```
┌─────────────────────┐
│  物体文本描述       │
│  (Object Description)│
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  CLIP文本编码器     │
│  (Text Encoder)      │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  文本Embedding      │
│  (512维向量)        │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  余弦相似度计算     │
│  与所有3D模型比较   │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  相似度排序+过滤    │
│  (Top-K + 阈值)     │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│  返回最佳匹配模型   │
│  (Objaverse UID)     │
└─────────────────────┘
```

---

## 详细代码分析

### 1. **加载预计算的Embeddings**

```python
# 从HuggingFace下载元数据
meta = json.load(
    open(hf_hub_download(
        "OpenShape/openshape-objaverse-embeddings", 
        "objaverse_meta.json", 
        token=True, 
        repo_type='dataset', 
        local_dir="OpenShape-Embeddings"
    ))
)

# 加载预计算的特征向量 (所有Objaverse模型的embeddings)
deser = torch.load(
    hf_hub_download(
        "OpenShape/openshape-objaverse-embeddings", 
        "objaverse.pt", 
        token=True, 
        repo_type='dataset', 
        local_dir="OpenShape-Embeddings"
    ), 
    map_location='cpu'
)

us = deser['us']        # 模型UIDs列表
feats = deser['feats']  # 对应的特征向量
```

**数据结构**:
- `meta`: 字典，包含每个3D模型的元数据
  - `u`: 唯一标识符 (UID)
  - `name`: 模型名称
  - `tags`: 标签列表
  - `cats`: 类别
  - `faces`: 面数
  - `anims`: 动画数量
  - `desc`: 描述
  - `glb`: GLB文件路径
  - 等等...

### 2. **文本编码**

```python
# 加载CLIP模型
clip_model, clip_prep = transformers.CLIPModel.from_pretrained(
    "laion/CLIP-ViT-bigG-14-laion2B-39B-b160k",
    low_cpu_mem_usage=True, 
    torch_dtype=half,
    offload_state_dict=True
)

# 文本预处理
text = preprocess(obj["description"])  # 清理数字、下划线

# 编码文本
tn = clip_prep(
    text=[text], 
    return_tensors='pt', 
    truncation=True, 
    max_length=76
).to(device)

# 获取文本特征
enc = clip_model.get_text_features(**tn).float().cpu()
```

### 3. **相似度检索** (核心算法)

```python
def retrieve(embedding, top, sim_th=0.0, filter_fn=None):
    """
    Args:
        embedding: 文本的embedding向量
        top: 返回top-K个结果
        sim_th: 相似度阈值 (0.0-1.0)
        filter_fn: 过滤函数 (面数、动画数限制等)
    
    Returns:
        匹配的3D模型列表
    """
    sims = []
    
    # 归一化查询向量
    embedding = F.normalize(embedding.detach().cpu(), dim=-1).squeeze()
    
    # 分块计算相似度 (避免显存溢出)
    for chunk in torch.split(feats, 10240):
        sims.append(embedding @ F.normalize(chunk.float(), dim=-1).T)
    
    # 合并并排序
    sims = torch.cat(sims)
    sims, idx = torch.sort(sims, descending=True)
    
    # 应用相似度阈值
    sim_mask = sims > sim_th
    sims = sims[sim_mask]
    idx = idx[sim_mask]
    
    # 收集结果
    results = []
    for i, sim in zip(idx, sims):
        if us[i] in meta:
            # 应用过滤器
            if filter_fn is None or filter_fn(meta[us[i]]):
                results.append(dict(meta[us[i]], sim=sim))
                if len(results) >= top:
                    break
    
    return results
```

**算法解析**:
1. **向量归一化**: L2归一化确保余弦相似度计算
2. **批量计算**: 分块处理避免内存问题
3. **余弦相似度**: `embedding @ chunk.T` 计算点积
4. **Top-K选择**: 排序后取前K个
5. **阈值过滤**: 只保留相似度 > sim_th 的结果
6. **元数据过滤**: 根据面数、动画数等过滤

### 4. **过滤器**

```python
def get_filter_fn():
    """创建过滤函数，限制模型的面数和动画数"""
    face_min = 0
    face_max = 34985808  # 允许的最大面数
    anim_min = 0
    anim_max = 563        # 允许的最大动画数
    
    anim_n = not (anim_min > 0 or anim_max < 563)
    face_n = not (face_min > 0 or face_max < 34985808)
    
    filter_fn = lambda x: (
        (anim_n or anim_min <= x['anims'] <= anim_max)
        and (face_n or face_min <= x['faces'] <= face_max)
    )
    return filter_fn
```

**过滤条件**:
- 面数范围 (避免过于复杂或简单的模型)
- 动画数量 (某些场景不需要动画模型)

---

## 在端到端流程中的集成

### 当前状态 (`end_to_end_pipeline.py`)

```python
def retrieve_3d_assets(object_list: Dict, asset_dir: str, max_scan: int = 1000) -> Dict:
    """
    为每个物体检索对应的3D asset
    """
    # TODO: 这里应该集成OpenShape的检索逻辑
    # 现在简化处理: 随机从asset_dir中选择assets
    
    # ... 简化版实现 (随机选择)
```

**现状**: 
- ⚠️ 端到端流程中**尚未集成OpenShape检索**
- 当前使用**随机选择**策略从本地asset目录选择模型
- `tools/retrive_3d.py` 是独立的检索脚本

---

## 完整检索示例

### 输入
```json
{
    "description": "A modern wooden dining chair with cushioned seat and backrest, 
                    mid-century style, high quality"
}
```

### 处理步骤

1. **文本预处理**
   ```python
   text = "A modern wooden dining chair with cushioned seat and backrest, 
           mid-century style, high quality"
   ```

2. **CLIP编码**
   ```
   text → [512维向量]
   ```

3. **相似度计算**
   ```
   与Objaverse数据库中所有模型的embeddings比较
   计算余弦相似度
   ```

4. **排序与过滤**
   ```
   - 相似度降序排列
   - 应用阈值 (sim_th=0.1)
   - 应用面数/动画数过滤
   ```

5. **返回结果**
   ```json
   {
       "u": "abc123def456...",
       "name": "Mid-Century Dining Chair",
       "sim": 0.87,
       "faces": 5280,
       "tags": ["furniture", "chair", "dining", "modern"],
       "glb": "glbs/001-234/abc123def456.glb"
   }
   ```

---

## 关键参数

| 参数 | 默认值 | 说明 |
|------|--------|------|
| `top` | 1 | 返回Top-K个结果 |
| `sim_th` | 0.1 | 相似度阈值 (0.0-1.0) |
| `face_min` | 0 | 最小面数 |
| `face_max` | 34985808 | 最大面数 |
| `anim_min` | 0 | 最小动画数 |
| `anim_max` | 563 | 最大动画数 |
| `max_length` | 76 | 文本最大token数 |

---

## 优缺点分析

### ✅ 优点

1. **语义理解**: CLIP能理解复杂的文本描述
2. **预计算**: embeddings预先计算，检索速度快
3. **大规模**: 支持Objaverse海量3D模型库
4. **灵活过滤**: 可根据面数、动画等属性过滤
5. **多属性**: 支持材质、风格、质量等多维度描述

### ⚠️ 局限性

1. **未集成**: 端到端流程中尚未集成OpenShape
2. **计算资源**: 需要GPU和较大内存
3. **HuggingFace依赖**: 需要token下载embeddings
4. **CLIP局限**: 对于细微差异可能不够精确
5. **单一匹配**: 每次只返回最佳匹配，可能不是最优选择

---

## 改进建议

### 1. **集成到端到端流程**

```python
def retrieve_3d_assets(object_list: Dict, asset_dir: str) -> Dict:
    """集成OpenShape检索"""
    
    # 加载CLIP模型和Objaverse embeddings
    clip_model, clip_prep = load_openclip()
    
    assets = {}
    for obj_name, obj_info in object_list.items():
        description = obj_info.get("description", obj_name)
        
        # CLIP编码
        enc = encode_text(clip_model, clip_prep, description)
        
        # 检索
        results = retrieve(enc, top=5, sim_th=0.1)
        
        # 选择最佳匹配
        best_match = results[0]
        assets[obj_name] = best_match
    
    return assets
```

### 2. **多样性选择**

- 返回Top-5而非Top-1
- 根据场景风格一致性进行二次筛选
- 避免重复选择相同模型

### 3. **缓存机制**

```python
# 缓存常见物体的检索结果
retrieval_cache = {}

def retrieve_with_cache(description):
    if description in retrieval_cache:
        return retrieval_cache[description]
    
    result = retrieve(...)
    retrieval_cache[description] = result
    return result
```

### 4. **本地索引**

- 为本地asset目录建立索引
- 预计算本地assets的embeddings
- 避免每次都从HuggingFace下载

---

## 相关文件

- **核心检索**: `tools/retrive_3d.py`
- **端到端流程**: `end_to_end_pipeline.py`
- **物体描述生成**: `tools/object_list_gen*.py`
- **Embeddings**: `OpenShape-Embeddings/objaverse.pt`
- **元数据**: `OpenShape-Embeddings/objaverse_meta.json`

---

## 参考资源

- **OpenShape论文**: https://arxiv.org/abs/2305.10764
- **OpenShape GitHub**: https://github.com/Colin97/OpenShape
- **Objaverse**: https://objaverse.allenai.org/
- **CLIP模型**: https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k

---

## 总结

本项目的3D资产检索采用了**基于CLIP的语义检索**方法:

1. 使用大规模预训练的CLIP模型理解文本描述
2. 通过余弦相似度在Objaverse embeddings中检索最相似的3D模型
3. 应用多种过滤器确保模型质量
4. 支持复杂的多属性描述 (材质、风格、质量等)

当前在 `tools/retrive_3d.py` 中实现完整，但**尚未集成到端到端流程**中。端到端流程目前使用简化的随机选择策略。