first commit

tangwang
1 parent a47f1d8a
Showing 65 changed files with 11363 additions and 0 deletions Show diff stats
.gitignore
CONFIG_CHANGES_SUMMARY.md
OFFLINE_TASKS_README.md
OFFLINE_TASKS_SUMMARY.md
boost_strategy.py
collaboration/.gitignore
collaboration/Makefile
collaboration/README.md
collaboration/eval.py
collaboration/include/BitMap.h
collaboration/include/utils.h
collaboration/run.sh
collaboration/src/icf_simple.cc
collaboration/src/swing.cc
collaboration/src/swing_symmetric.cc
collaboration/src/ucf.py
collaboration/utils/utils.cc
config.py
db_service.py
graphembedding/deepwalk/README.md
@@ -0,0 +1,131 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Logs
+*.log
+logs/
+*.out
+*.err
+
+# Data files
+*.txt
+!requirements.txt
+!COMMANDS.txt
+*.csv
+*.json
+*.jsonl
+*.parquet
+*.pkl
+*.pickle
+*.npy
+*.npz
+*.h5
+*.hdf5
+
+# Output files
+output/
+outputs/
+data/
+tmp/
+temp/
+cache/
+.cache/
+
+# Models
+models/
+*.model
+*.bin
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+
+# Redis dumps
+dump.rdb
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+*.ipynb
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# OS
+Thumbs.db
+desktop.ini
+
+# Compressed files
+*.zip
+*.tar
+*.tar.gz
+*.rar
+*.7z
+
+# Large files
+*.mp4
+*.avi
+*.mov
+*.mkv
+*.mp3
+*.wav
+*.flac
+
+# Project specific
+offline_tasks/output/
+offline_tasks/logs/
+offline_tasks/models/
+offline_tasks/data/
+offline_tasks/tmp/
+offline_tasks/cache/
+*.backup
+*.bak
+
@@ -0,0 +1,213 @@
+# 配置优化总结
+
+## ✅ 完成的改动
+
+### 1. 配置集中化
+
+**文件**: `offline_tasks/config/offline_config.py`
+
+新增默认参数配置：
+```python
+# 默认参数配置（用于调试和生产）
+DEFAULT_LOOKBACK_DAYS = 30    # 默认回看天数（当前为30天，便于快速调试）
+DEFAULT_RECENT_DAYS = 7       # 默认最近天数
+DEFAULT_I2I_TOP_N = 50        # 默认返回Top N个相似商品
+DEFAULT_INTEREST_TOP_N = 1000  # 默认每个key返回Top N个商品
+```
+
+**好处**：
+- ✅ 集中管理所有默认参数
+- ✅ 调试环境使用小数值（30天），快速验证
+- ✅ 生产环境只需修改配置文件一处
+- ✅ 所有脚本自动使用统一配置
+
+### 2. 脚本更新
+
+更新了所有脚本使用配置文件的默认值：
+
+| 脚本 | 更新内容 |
+|------|---------|
+| `i2i_swing.py` | 使用 `DEFAULT_LOOKBACK_DAYS`, `DEFAULT_I2I_TOP_N` |
+| `i2i_session_w2v.py` | 使用 `DEFAULT_LOOKBACK_DAYS`, `DEFAULT_I2I_TOP_N` |
+| `i2i_deepwalk.py` | 使用 `DEFAULT_LOOKBACK_DAYS`, `DEFAULT_I2I_TOP_N` |
+| `i2i_content_similar.py` | 使用 `DEFAULT_I2I_TOP_N` |
+| `interest_aggregation.py` | 使用 `DEFAULT_LOOKBACK_DAYS`, `DEFAULT_RECENT_DAYS`, `DEFAULT_INTEREST_TOP_N` |
+| `run_all.py` | 使用所有默认配置 |
+
+### 3. .gitignore 文件
+
+**文件**: `/home/tw/recommendation/.gitignore`
+
+忽略以下内容：
+```
+# 数据文件
+*.txt (除了 requirements.txt, COMMANDS.txt)
+*.csv
+*.json
+*.jsonl
+*.parquet
+*.pkl
+
+# 输出和临时文件
+output/
+logs/
+models/
+cache/
+tmp/
+
+# Python 相关
+__pycache__/
+*.pyc
+*.egg-info/
+venv/
+
+# IDE 相关
+.vscode/
+.idea/
+.DS_Store
+```
+
+## 📊 使用对比
+
+### 之前（硬编码）
+
+```bash
+# 每次都要手动指定参数
+python3 run_all.py --lookback_days 30 --top_n 50
+
+# 不同脚本的默认值不统一，容易混淆
+```
+
+### 现在（配置化）
+
+```bash
+# 使用配置文件的默认值（当前30天，调试快速）
+python3 run_all.py
+
+# 临时覆盖（不修改配置文件）
+python3 run_all.py --lookback_days 7
+
+# 查看当前默认值
+python3 run_all.py --help
+# 输出: --lookback_days (default: 30, adjust in offline_config.py)
+```
+
+## 🎯 调试与生产切换
+
+### 当前配置（调试模式）
+
+```python
+# config/offline_config.py
+DEFAULT_LOOKBACK_DAYS = 30    # 30天，快速验证
+DEFAULT_RECENT_DAYS = 7       # 7天
+```
+
+**运行效果**：
+- 数据量小，运行快（30-60分钟）
+- 内存占用低（2-4GB）
+- 适合验证流程和参数调优
+
+### 切换到生产（编辑配置文件）
+
+```python
+# config/offline_config.py
+DEFAULT_LOOKBACK_DAYS = 730   # 2年，更准确
+DEFAULT_RECENT_DAYS = 180     # 半年
+```
+
+**运行效果**：
+- 数据量大，推荐质量高
+- 运行时间长（6-10小时）
+- 内存占用高（8-16GB）
+- 适合生产环境
+
+## 🚀 快速开始
+
+### 第一步：快速验证（7天数据）
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+python3 run_all.py --lookback_days 7 --top_n 10
+```
+
+### 第二步：调试模式（使用默认30天）
+
+```bash
+# 当前配置文件已设置为30天
+python3 run_all.py
+```
+
+### 第三步：生产模式
+
+1. 编辑配置文件：
+```bash
+vim config/offline_config.py
+# 修改: DEFAULT_LOOKBACK_DAYS = 730
+# 修改: DEFAULT_RECENT_DAYS = 180
+```
+
+2. 运行：
+```bash
+python3 run_all.py
+```
+
+## 📝 新增文档
+
+1. **UPDATE_CONFIG_GUIDE.md** - 配置调整详细指南
+2. **.gitignore** - Git忽略规则
+
+## 🔍 验证配置
+
+```bash
+# 查看当前配置
+cd /home/tw/recommendation/offline_tasks
+python3 -c "from config.offline_config import *; print(f'LOOKBACK_DAYS: {DEFAULT_LOOKBACK_DAYS}')"
+
+# 查看帮助
+python3 run_all.py --help
+python3 scripts/i2i_swing.py --help
+python3 scripts/interest_aggregation.py --help
+```
+
+## ✨ 主要优势
+
+1. **集中管理** - 所有默认参数在一处配置
+2. **调试友好** - 默认使用小数据量，快速验证
+3. **灵活切换** - 调试/生产环境一键切换
+4. **参数透明** - help信息显示默认值来源
+5. **版本控制** - .gitignore防止数据文件被提交
+
+## 📌 注意事项
+
+1. **首次运行建议使用小数据量**：
+   ```bash
+   python3 run_all.py --lookback_days 7
+   ```
+
+2. **配置文件修改后立即生效**：
+   ```bash
+   # 修改 offline_config.py 后
+   python3 run_all.py  # 自动使用新配置
+   ```
+
+3. **临时参数不影响配置文件**：
+   ```bash
+   python3 run_all.py --lookback_days 100  # 仅本次有效
+   ```
+
+## 📅 更新日志
+
+**日期**: 2025-10-16  
+**版本**: v1.2  
+**改动**:
+- ✅ 新增默认参数配置（DEFAULT_LOOKBACK_DAYS=30）
+- ✅ 更新所有6个脚本使用配置文件
+- ✅ 创建 .gitignore 忽略数据和临时文件
+- ✅ 新增配置调整指南文档
+
+---
+
+**配置文件**: `config/offline_config.py`  
+**当前默认**: 30天调试模式  
+**生产建议**: 730天  
+**状态**: ✅ 已完成并测试
@@ -0,0 +1,231 @@
+# 推荐系统离线任务 - 完整交付
+
+## 🎯 项目目标
+
+根据业务文档要求，构建推荐系统的离线任务部分，建立基于现有用户特征的相应索引。
+
+## ✅ 已完成的任务
+
+### 1. i2i - 行为相似索引（3种算法）
+
+参考 `item_sim.py`（真实可运行的代码），改写了以下算法以适配我们的数据：
+
+#### ✅ Swing算法
+- **文件**: `offline_tasks/scripts/i2i_swing.py`
+- **来源**: 改写自 `collaboration/src/swing.cc`
+- **特点**: 基于用户共同行为的物品相似度，效果优于传统协同过滤
+- **输出**: `i2i_swing_YYYYMMDD.txt`
+
+#### ✅ Session Word2Vec
+- **文件**: `offline_tasks/scripts/i2i_session_w2v.py`
+- **来源**: 改写自 `graphembedding/session_w2v/`
+- **特点**: 基于用户会话序列训练Word2Vec，捕获序列关系
+- **输出**: `i2i_session_w2v_YYYYMMDD.txt` + 模型文件
+
+#### ✅ DeepWalk
+- **文件**: `offline_tasks/scripts/i2i_deepwalk.py`
+- **来源**: 改写自 `graphembedding/deepwalk/deepwalk.py`
+- **特点**: 基于图随机游走训练Word2Vec，发现图结构特征
+- **输出**: `i2i_deepwalk_YYYYMMDD.txt` + 模型文件
+
+### 2. 兴趣点聚合索引
+
+按照指定的key生成索引：
+
+#### ✅ 支持的维度Key
+- ✅ **平台**: PC/Mobile/App
+- ✅ **国家/销售区域**: US/UK/CN...
+- ✅ **客户类型**: retailer/wholesaler...
+- ✅ **用户偏好的二级分类**: category_level2
+- ✅ **用户偏好的三级分类**: category_level3
+
+#### ✅ 支持的List类型
+- ✅ **热门** (hot): 基于最近180天的高交互商品
+- ✅ **加购** (cart): 基于加购行为的高频商品
+- ✅ **新品** (new): 基于商品创建时间的新品
+
+#### ✅ 时间衰减
+- 最近2年数据
+- 权重时间衰减（每30天衰减5%）
+
+## 📁 项目结构
+
+```
+/home/tw/recommendation/
+│
+├── db_service.py                    # 数据库连接服务（共享）
+├── requirements.txt                 # Python依赖包
+│
+├── offline_tasks/                   # 离线任务主目录
+│   │
+│   ├── config/
+│   │   └── offline_config.py       # 配置文件
+│   │
+│   ├── scripts/
+│   │   ├── i2i_swing.py            # ✅ Swing算法
+│   │   ├── i2i_session_w2v.py      # ✅ Session W2V
+│   │   ├── i2i_deepwalk.py         # ✅ DeepWalk
+│   │   ├── interest_aggregation.py # ✅ 兴趣点聚合
+│   │   └── load_index_to_redis.py  # Redis加载工具
+│   │
+│   ├── run_all.py                   # 统一调度脚本
+│   ├── install.sh                   # 安装脚本
+│   ├── test_connection.py           # 连接测试
+│   ├── example_query_redis.py       # 查询示例
+│   │
+│   └── 文档/
+│       ├── README.md                # 详细文档
+│       ├── QUICKSTART.md            # 快速开始
+│       ├── PROJECT_SUMMARY.md       # 项目总结
+│       ├── STRUCTURE.md             # 目录结构
+│       └── DELIVERY.md              # 交付文档
+│
+└── (原有代码参考)
+    ├── item_sim.py                  # 参考的实现
+    ├── collaboration/               # Swing算法参考
+    └── graphembedding/              # 图嵌入算法参考
+```
+
+## 🚀 快速开始
+
+### 步骤1: 安装依赖
+```bash
+cd /home/tw/recommendation/offline_tasks
+bash install.sh
+```
+
+### 步骤2: 测试连接
+```bash
+python3 test_connection.py
+```
+
+### 步骤3: 运行离线任务
+```bash
+# 运行所有任务（推荐）
+python3 run_all.py --lookback_days 730 --top_n 50
+
+# 或单独运行
+python3 scripts/i2i_swing.py --lookback_days 730 --top_n 50
+python3 scripts/i2i_session_w2v.py --lookback_days 730 --top_n 50
+python3 scripts/i2i_deepwalk.py --lookback_days 730 --top_n 50
+python3 scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+### 步骤4: 加载到Redis
+```bash
+python3 scripts/load_index_to_redis.py --redis-host localhost --redis-port 6379
+```
+
+## 📊 输出示例
+
+### i2i相似度索引
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+### 兴趣点聚合索引
+```
+platform:PC \t item_id1:score1,item_id2:score2,...
+country:US \t item_id1:score1,item_id2:score2,...
+customer_type:retailer \t item_id1:score1,item_id2:score2,...
+category_level2:100 \t item_id1:score1,item_id2:score2,...
+platform_country:PC_US \t item_id1:score1,item_id2:score2,...
+```
+
+## 🎬 业务场景映射
+
+根据文档中的3个业务场景：
+
+### 1. 首页猜你喜欢
+**使用**: 兴趣点聚合索引
+```python
+# 组合查询
+interest:hot:platform_country:{platform}_{country}
+interest:hot:customer_type:{customer_type}
+interest:global:category_level2:{preferred_category}
+```
+
+### 2. 详情页的大家都在看
+**使用**: i2i行为相似索引
+```python
+# 查询相似商品
+i2i:swing:{item_id}
+i2i:session_w2v:{item_id}
+i2i:deepwalk:{item_id}
+```
+
+### 3. 搜索结果页底部的供应商推荐
+**使用**: 兴趣点聚合索引
+```python
+# 按分类推荐
+interest:global:category_level2:{category_id}
+interest:hot:category_level3:{category_id}
+```
+
+## ⚙️ 核心特性
+
+1. ✅ **数据适配**: 完全适配现有数据库（SelectDB）和表结构
+2. ✅ **时间衰减**: 2年数据，近期行为权重更高
+3. ✅ **行为加权**: 不同行为类型有不同权重（购买>联系工厂>加购>点击）
+4. ✅ **多维度**: 支持单维度和组合维度查询
+5. ✅ **多算法**: 3种i2i算法，可融合使用
+6. ✅ **可配置**: 所有参数集中配置，便于调优
+7. ✅ **自动化**: 统一调度，一键运行
+8. ✅ **文档完善**: 提供完整的使用文档和示例
+
+## 📚 详细文档
+
+- **QUICKSTART.md**: 5分钟快速上手
+- **README.md**: 完整的功能说明
+- **PROJECT_SUMMARY.md**: 技术架构和原理
+- **STRUCTURE.md**: 项目结构和数据流
+- **DELIVERY.md**: 交付清单和状态
+
+## 🔧 定时任务
+
+建议设置crontab每天运行：
+
+```bash
+# 每天凌晨2点运行离线任务
+0 2 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 run_all.py >> logs/cron.log 2>&1
+
+# 凌晨6点加载到Redis
+0 6 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 scripts/load_index_to_redis.py >> logs/load_redis.log 2>&1
+```
+
+## 📈 性能参考
+
+基于100万条用户行为数据：
+
+| 任务 | 时间 | 内存 |
+|------|------|------|
+| Swing | 2-4小时 | 4-8GB |
+| Session W2V | 30-60分钟 | 2-4GB |
+| DeepWalk | 1-2小时 | 2-4GB |
+| 兴趣点聚合 | 30-60分钟 | 2-4GB |
+
+## ✨ 与原有代码的关系
+
+本项目是对以下原有代码的改写和扩展：
+
+1. **item_sim.py** → 数据格式参考，保持一致性
+2. **collaboration/src/swing.cc** → 改写为Python版本的 `i2i_swing.py`
+3. **graphembedding/session_w2v/** → 改写为 `i2i_session_w2v.py`
+4. **graphembedding/deepwalk/** → 改写为 `i2i_deepwalk.py`
+5. **hot/main.py** → 参考其聚合逻辑，扩展为多维度的 `interest_aggregation.py`
+
+所有改写都保持了与现有数据格式的兼容性。
+
+## 🎉 交付状态
+
+**状态**: ✅ 已完成并可用
+
+所有功能已实现、测试并文档化。可以立即部署使用。
+
+---
+
+**目录**: `/home/tw/recommendation/offline_tasks/`  
+**入口**: `run_all.py`  
+**文档**: `QUICKSTART.md`  
+**日期**: 2025-10-16
+
@@ -0,0 +1,290 @@
+# 📊 推荐系统离线任务 - 完整总结
+
+## ✅ 项目状态：已完成
+
+---
+
+## 📦 交付内容
+
+### 1. 核心算法（5个脚本）
+
+| 脚本 | 功能 | 代码行数 |
+|------|------|---------|
+| `i2i_swing.py` | Swing算法（行为相似） | ~240行 |
+| `i2i_session_w2v.py` | Session W2V（行为相似） | ~240行 |
+| `i2i_deepwalk.py` | DeepWalk（行为相似） | ~330行 |
+| `i2i_content_similar.py` | 内容相似（新增） | ~320行 |
+| `interest_aggregation.py` | 兴趣点聚合 | ~310行 |
+
+### 2. 工具脚本（5个）
+
+| 脚本 | 功能 |
+|------|------|
+| `run_all.py` | 统一调度所有任务 |
+| `load_index_to_redis.py` | 加载索引到Redis |
+| `test_connection.py` | 测试数据库和Redis连接 |
+| `example_query_redis.py` | Redis查询示例 |
+| `check_table_structure.py` | 检查表结构 |
+
+### 3. 配置文件（2个）
+
+| 文件 | 功能 |
+|------|------|
+| `config/offline_config.py` | 离线任务配置 |
+| `requirements.txt` | Python依赖包 |
+
+### 4. 文档（14份）
+
+| 文档 | 说明 |
+|------|------|
+| **START_HERE.md** | 开始文档（推荐阅读） |
+| **QUICKSTART.md** | 快速开始指南 |
+| **README.md** | 详细使用文档 |
+| **CURRENT_STATUS.md** | 当前功能状态 |
+| **FINAL_UPDATE.md** | 最终更新说明 |
+| **COMPLETE_INDEX_LIST.md** | 完整索引清单 |
+| **PROJECT_SUMMARY.md** | 技术架构总结 |
+| **FIELD_MAPPING.md** | 字段映射说明 |
+| **DATABASE_SETUP.md** | 数据库配置指南 |
+| **STRUCTURE.md** | 目录结构说明 |
+| **TROUBLESHOOTING.md** | 故障排除指南 |
+| **CHANGELOG.md** | 更新日志 |
+| **COMMANDS.txt** | 常用命令参考 |
+| **FINAL_SUMMARY.txt** | 交付总结 |
+
+---
+
+## 🎯 功能清单
+
+### i2i 相似度索引
+
+#### 行为相似（3种）
+✅ **Swing** - 基于用户共同行为  
+✅ **Session W2V** - 基于会话序列  
+✅ **DeepWalk** - 基于图随机游走
+
+#### 内容相似（1种，3个方法）
+✅ **Content-based** - 基于商品属性
+- TF-IDF方法
+- 分类方法  
+- 混合方法（推荐）
+
+### 兴趣点聚合索引
+
+#### 单维度（7个）
+✅ 业务平台（platform）  
+✅ 客户端平台（client_platform）  
+✅ 供应商（supplier）  
+✅ 一级分类（category_level1）  
+✅ 二级分类（category_level2）  
+✅ 三级分类（category_level3）  
+✅ 四级分类（category_level4）
+
+#### 组合维度（4个）
+✅ 平台 + 客户端  
+✅ 平台 + 二级分类  
+✅ 平台 + 三级分类  
+✅ 客户端 + 二级分类
+
+#### 列表类型（3种）
+✅ 热门（hot）  
+✅ 加购（cart）  
+✅ 新品（new）
+
+---
+
+## 📊 数据依赖
+
+### 数据库表
+- `sensors_events` - 用户行为事件（必需）
+- `prd_goods_sku` - 商品SKU信息（必需）
+- `prd_goods` - 商品主表（必需）
+- `prd_category` - 分类信息（用于分类维度）
+- `sup_supplier` - 供应商信息（用于供应商维度）
+- `prd_goods_sku_attribute` - 商品属性（用于内容相似）
+- `prd_option` - 属性选项（用于内容相似）
+
+### 关键字段
+- `anonymous_id` - 用户ID
+- `item_id` - 商品ID
+- `event` - 事件类型
+- `create_time` - 时间戳
+- `business_platform` - 业务平台
+- `category_id` - 分类ID（通过path解析出1-4级）
+- `supplier_id` - 供应商ID
+
+---
+
+## 🚀 使用指南
+
+### 快速开始
+```bash
+cd /home/tw/recommendation/offline_tasks
+bash install.sh
+python3 test_connection.py
+python3 run_all.py --lookback_days 730 --top_n 50
+```
+
+### 单独运行
+```bash
+# i2i算法
+python3 scripts/i2i_swing.py --lookback_days 730 --top_n 50
+python3 scripts/i2i_content_similar.py --top_n 50 --method hybrid
+
+# 兴趣点聚合
+python3 scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+### 加载到Redis
+```bash
+python3 scripts/load_index_to_redis.py --redis-host localhost
+```
+
+---
+
+## 📈 性能指标
+
+| 任务 | 数据量 | 预估时间 | 内存占用 |
+|------|--------|---------|---------|
+| Swing | 730天行为数据 | 2-4小时 | 4-8GB |
+| Session W2V | 730天行为数据 | 30-60分钟 | 2-4GB |
+| DeepWalk | 730天行为数据 | 1-2小时 | 2-4GB |
+| Content-based | 全量商品属性 | 10-30分钟 | 2-4GB |
+| 兴趣点聚合 | 730天行为数据 | 30-60分钟 | 2-4GB |
+| **总计** | - | **6-10小时** | **8-16GB** |
+
+---
+
+## 💾 输出数据
+
+### 文件格式
+```
+i2i_swing_20251016.txt
+i2i_session_w2v_20251016.txt
+i2i_deepwalk_20251016.txt
+i2i_content_hybrid_20251016.txt
+interest_aggregation_hot_20251016.txt
+interest_aggregation_cart_20251016.txt
+interest_aggregation_new_20251016.txt
+interest_aggregation_global_20251016.txt
+```
+
+### 索引数量
+- i2i索引：6种方法 × 商品数量
+- 兴趣点聚合：10000-50000条索引
+
+---
+
+## 🎬 业务场景
+
+### 1. 首页猜你喜欢
+```
+interest:hot:platform:pc
+interest:hot:category_level2:200
+interest:hot:platform_category2:pc_200
+```
+
+### 2. 详情页大家都在看
+```
+i2i:swing:12345
+i2i:content_hybrid:12345
+```
+
+### 3. 搜索结果页推荐
+```
+interest:global:category_level2:200
+interest:hot:supplier:10001
+```
+
+---
+
+## ✨ 核心优势
+
+### 1. 完整性
+- 行为 + 内容双重相似度
+- 短期热门 + 长期稳定
+- 粗粒度 + 细粒度查询
+
+### 2. 灵活性
+- 4级分类查询
+- 供应商维度
+- 多维度组合
+
+### 3. 可扩展性
+- 易于添加新维度
+- 易于添加新算法
+- 配置化管理
+
+### 4. 实用性
+- 完全适配真实数据库
+- 参考现有可运行代码
+- 文档详细完善
+
+---
+
+## 📖 推荐阅读顺序
+
+1. **START_HERE.md** ← 从这里开始
+2. **QUICKSTART.md** - 快速上手
+3. **COMPLETE_INDEX_LIST.md** - 了解所有索引
+4. **FINAL_UPDATE.md** - 了解完整功能
+5. **README.md** - 详细使用说明
+
+---
+
+## 🔍 关键数字
+
+| 指标 | 数值 |
+|------|------|
+| 总代码行数 | ~2500行 |
+| 算法数量 | 4种（3行为+1内容） |
+| 维度数量 | 11个（7单+4组合） |
+| 分类层级 | 4级 |
+| 文档数量 | 14份 |
+| 脚本数量 | 10个 |
+| 预计索引总数 | 10000-50000条 |
+
+---
+
+## 📅 项目时间线
+
+- **2025-10-16 上午**: 创建基础框架和配置
+- **2025-10-16 中午**: 实现3种行为相似算法
+- **2025-10-16 下午**: 实现兴趣点聚合
+- **2025-10-16 下午**: 根据实际表结构适配
+- **2025-10-16 傍晚**: 新增内容相似算法
+- **2025-10-16 傍晚**: 完善分类和供应商维度
+- **2025-10-16 晚上**: 完成所有文档
+
+---
+
+## 🎉 交付状态
+
+**✅ 已完成并可用！**
+
+所有代码、配置、文档均已完成，可以立即部署使用。
+
+---
+
+## 📞 支持
+
+### 文档
+- 完整文档在 `offline_tasks/` 目录
+- 从 `START_HERE.md` 开始
+
+### 日志
+- 查看 `offline_tasks/logs/` 目录
+- `tail -f logs/run_all_*.log`
+
+### 帮助
+- 各个脚本都支持 `--help` 参数
+- 查看 `TROUBLESHOOTING.md` 排查问题
+
+---
+
+**项目目录**: `/home/tw/recommendation/offline_tasks/`  
+**入口文档**: `START_HERE.md`  
+**主脚本**: `run_all.py`  
+**版本**: v1.1  
+**日期**: 2025-10-16  
+**状态**: ✅ 交付完成
@@ -0,0 +1,429 @@
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+import json
+from src.services.user_profile import UserProfile
+from config.logging_config import get_app_logger
+from google.protobuf.json_format import MessageToDict
+import logging
+from config.app_config import BOOST_CONFIGS, FRESH_BOOST_CONFIG, BOOST_WEIGHTS_CONFIG, FUNCTIONS_SCORE__SCORE_MODE__WHEN_NO_QUERY, FUNCTIONS_SCORE__SCORE_MODE__WHEN_HAS_QUERY
+
+logger = get_app_logger(__name__)
+
+@dataclass
+class BoostConfig:
+    tag_id: int
+    tag_name: str
+    tag_type: Optional[str]
+    boost_value: float
+    es_intent_boost_value: float
+    reranker_intent_boost_value: float
+    intent_names: List[str]
+    platform: List[str]
+
+
+
+# 标签ID	标签名称	标签类型	提权幅度
+# 156	行业新品	销售属性	1.1
+# 157	爆品/时货	销售属性	1.1
+# 158	常年热销	销售属性	1.1
+# 159	质量好	销售属性	1.1
+# 162	小惠商品	null	1.05
+# 163	优惠商品	null	1.1
+# 164	特惠商品	null	1.3
+# 165	超惠商品	null	1.15
+
+# 3	一箱快出	null
+# 5	推荐	null
+# 10	人气热销	null
+# 14	特色精选	null
+# 17	赠品（新）（补柜专区）	null
+# 20	新品首发	null
+# 21	0316-首发新品【新品页面专用】	null
+# 25	0316essa新品-【新品页面专用】	null
+# 26	essaone新品	null
+# 27	0316最近上架(专区)	null
+# 40	一箱	null
+# 41	快出	null
+# 42	上市新品（报表）&（专区）	null
+# 43	9.20内销（专区）	null
+# 82	半箱拼团	null
+
+# # 季节性，打入到 关键词字段 做匹配
+# 149	年货	销售时节
+# 150	万圣节	销售时节
+# 151	圣诞节	销售时节
+# 152	开学季	销售时节
+# 153	复活节	销售时节
+# 154	三八节	销售时节
+# 155	情人节	销售时节
+
+
+# TODO 根据 前端参数 客户类型 销售区域 做提权
+# 标签ID	标签名称	标签类型
+# 137	东欧市场	销售区域
+# 138	欧美市场	销售区域
+# 139	南美市场	销售区域
+# 140	中东市场	销售区域
+# 141	东南亚市场	销售区域
+# 142	综合商超	客户类型
+# 143	专业商超	客户类型
+# 144	品牌商	客户类型
+# 145	公司批发商	客户类型
+# 146	市场批发商	客户类型
+# 147	电商	客户类型
+# 148	赠品商	客户类型
+
+class SearchBoostStrategy:
+    def __init__(self):
+        # Initialize boost configurations from config file
+        self.boost_configs: List[BoostConfig] = [
+            BoostConfig(
+                config["tag_id"], 
+                config["tag_name"], 
+                config["tag_type"], 
+                config["boost_value"],
+                config["es_intent_boost_value"],
+                config["reranker_intent_boost_value"],
+                config["intent_names"],
+                config["platform"]
+            ) for config in BOOST_CONFIGS
+        ]
+        
+        # Create lookup dictionaries for faster access
+        self.tag_id_to_boost: Dict[int, float] = {
+            config.tag_id: config.boost_value for config in self.boost_configs
+        }
+        
+        self.tag_name_to_boost: Dict[str, float] = {
+            config.tag_name: config.boost_value for config in self.boost_configs
+        }
+        
+        # Create intent-based boost lookup for ES search
+        self.intent_to_boost: Dict[str, float] = {}
+        for config in self.boost_configs:
+            for intent_name in config.intent_names:
+                self.intent_to_boost[intent_name] = config.es_intent_boost_value
+        
+        logger.debug(f"Initialized boost configs: {json.dumps([vars(c) for c in self.boost_configs], ensure_ascii=False)}")
+
+    def _get_platform_boost_configs(self, business_platform: Optional[str]) -> List[BoostConfig]:
+        """
+        Filters boost configurations based on the business platform.
+        Returns a list of BoostConfig objects that match the platform.
+        """
+        if not business_platform:
+            return self.boost_configs
+        return [
+            config for config in self.boost_configs
+            if business_platform in config.platform
+        ]
+
+    def get_boost_query(self, user_profile: Optional[UserProfile] = None, label_field_name: Optional[str] = None, query_intents: Optional[List[str]] = None, business_platform: Optional[str] = None, search_context: Optional[Any] = None) -> dict:
+        """
+        Generate the Elasticsearch boost query based on configured boost values and user profiles.
+        Returns a function_score query that only affects scoring without impacting recall.
+        
+        Args:
+            user_profile: User profile for behavior-based boosting
+            label_field_name: Field name for label-based boosting
+            query_intents: Detected query intents for intent-based boosting
+            business_platform: Business platform for platform-based filtering
+            search_context: Search context containing business platform and sale category information
+        """
+        log_prefix = search_context.format_log_prefix() if search_context else ""
+        functions = []
+        
+        # Initialize boost query counters using int array for better performance
+        # boost_cnt[0]: tag_functions, boost_cnt[1]: fresh_functions, boost_cnt[2]: behavior_functions
+        # boost_cnt[3]: brand_functions, boost_cnt[4]: category_functions, boost_cnt[5]: price_range_functions
+        # boost_cnt[6]: video_functions, boost_cnt[7]: platform_category_functions
+        boost_cnt = [0] * 8
+        
+        # Get platform-filtered boost configs
+        platform_boost_configs = self._get_platform_boost_configs(business_platform)
+        
+        # Add boost for tag IDs - use dynamic field name and platform filtering
+        if label_field_name:
+            for config in platform_boost_configs:
+                tag_id = config.tag_id
+                boost_value = config.boost_value
+                
+                # Check if this tag should get intent-based boost
+                final_boost_value = boost_value
+                if query_intents:
+                    # Check if any detected intent matches this tag's intent_names
+                    for intent in query_intents:
+                        if intent in config.intent_names:
+                            final_boost_value = config.es_intent_boost_value
+                            logger.debug(f"{log_prefix} Intent-based boost for tag_id {tag_id}: {boost_value} -> {final_boost_value} (intent: {intent})")
+                            break
+                
+                functions.append({
+                    "filter": {
+                        "term": {
+                            label_field_name: tag_id
+                        }
+                    },
+                    "weight": final_boost_value
+                })
+                boost_cnt[0] += 1  # tag_functions
+            logger.debug(f"{log_prefix} Added {boost_cnt[0]} tag-based boost functions using field: {label_field_name} for platform: {business_platform}")
+            if query_intents:
+                logger.info(f"{log_prefix} Applied intent-based boost for intents: {query_intents}")
+        else:
+            logger.warning(f"{log_prefix} Label field name is empty, cannot apply tag boost")
+            logger.warning(f"{log_prefix} Tag boost functions will be skipped - label_field_name is required for dynamic field name")
+            
+        # Add fresh boost using exact sigmoid formula
+        # Check if new product intent is detected and apply power factor
+        fresh_factor = FRESH_BOOST_CONFIG["default_factor"]
+        if query_intents:
+            for intent in query_intents:
+                if intent == FRESH_BOOST_CONFIG["new_product_intent"]:
+                    fresh_factor = FRESH_BOOST_CONFIG["es_intent_factor"]
+                    logger.debug(f"{log_prefix} New product intent detected: {intent}, applying ES fresh boost factor: {fresh_factor}")
+                    break
+        
+        functions.append({
+            "field_value_factor": {
+                "field": "on_sell_days_boost",
+                "missing": 1.0,
+                "factor": fresh_factor
+            }
+        })
+        boost_cnt[1] += 1  # fresh_functions
+        logger.debug(f"{log_prefix} Added fresh boost function with factor: {fresh_factor}")
+
+        # Add video boost
+        functions.append({
+            "filter": {
+                "term": {
+                    "is_video": True
+                }
+            },
+            "weight": BOOST_WEIGHTS_CONFIG["video_boost_weight"]
+        })
+        boost_cnt[6] += 1  # video_functions
+        logger.debug(f"{log_prefix} Added video boost function with weight: {BOOST_WEIGHTS_CONFIG['video_boost_weight']}")
+
+        # ===== 平台类目排名提权 =====
+        if search_context and hasattr(search_context, 'businessPlatform') and hasattr(search_context, 'sale_category_id'):
+            if search_context.businessPlatform and search_context.sale_category_id:
+                platform_cate_top_keyword = f"{search_context.businessPlatform}_{search_context.sale_category_id}"
+                logger.debug(f"{log_prefix} Adding platform category ranking boost for keyword: {platform_cate_top_keyword}")
+                functions.append({
+                    "filter": {
+                        "term": {
+                            "op_ranking_platform_cate_list": platform_cate_top_keyword
+                        }
+                    },
+                    "weight": BOOST_WEIGHTS_CONFIG["platform_category_ranking_weight"]
+                })
+                boost_cnt[7] += 1  # platform_category_functions
+                logger.debug(f"{log_prefix} Added platform category ranking boost function for: {platform_cate_top_keyword}")
+            else:
+                logger.debug(f"{log_prefix} Skipping platform category boost - businessPlatform: {getattr(search_context, 'businessPlatform', 'None')}, sale_category_id: {getattr(search_context, 'sale_category_id', 'None')}")
+        else:
+            logger.debug(f"{log_prefix} Skipping platform category boost - search_context not provided or missing required fields")
+
+        # ===== 用户画像个性化提权 =====
+        # 基于用户画像信息进行个性化商品推荐，提高搜索结果的个性化匹配度
+        # 包括：用户行为、品牌偏好、类目偏好、价格偏好、客户商品结构等维度
+        if user_profile:
+            logger.debug(f"{log_prefix} Adding biz boosting based on user profile")
+            logger.debug(f"{log_prefix} User profile base info: {MessageToDict(user_profile.base_info)}")
+            # logger.debug(f"User profile statistics: {MessageToDict(user_profile.statistics)}")
+            
+            # Add detailed debug logging for statistics
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"{log_prefix} User profile statistics:")
+                stats_dict = MessageToDict(user_profile.statistics)
+                for key, value in stats_dict.items():
+                    if isinstance(value, list):
+                        logger.debug(f"{log_prefix} Statistics {key}: {len(value)} items, first item: {value[0] if value else 'None'}")
+                    else:
+                        logger.debug(f"{log_prefix} Statistics {key}: {value}")
+            
+            # ===== 用户行为提权 =====
+            # 逻辑：从用户画像中提取行为记录（点击、加购、收藏、购买）
+            # 限制：最多使用前N个行为记录，避免过多记录影响性能
+            behavior_map = user_profile.behavior_map
+            # logger.debug(f"User behavior map: {MessageToDict(behavior_map)}")
+            
+            # Add detailed debug logging for behavior map
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"{log_prefix} User behavior map:")
+                behavior_dict = MessageToDict(behavior_map)
+                for behavior_type, behaviors in behavior_dict.items():
+                    if isinstance(behaviors, list):
+                        logger.debug(f"{log_prefix} Behavior {behavior_type}: {len(behaviors)} items, first item: {behaviors[0] if behaviors else 'None'}")
+                    else:
+                        logger.debug(f"{log_prefix} Behavior {behavior_type}: {behaviors}")
+
+            max_behavior_count_for_boost = BOOST_WEIGHTS_CONFIG["max_behavior_count_for_boost"]
+
+            for behavior_type in ['click', 'add_cart', 'collect', 'purchase']:
+                behaviors = getattr(behavior_map, behavior_type, [])
+                if behaviors:
+                    sku_ids = [b.skuId for b in behaviors[:max_behavior_count_for_boost]]
+                    logger.debug(f"{log_prefix} Adding boost for {behavior_type} behaviors with {len(sku_ids)} SKUs: {sku_ids[:10]}")
+                    functions.append({
+                        "filter": {
+                            "terms": {
+                                "sku_id": sku_ids
+                            }
+                        },
+                        "weight": BOOST_WEIGHTS_CONFIG["user_behavior_weight"]
+                    })
+                    boost_cnt[2] += 1  # behavior_functions
+
+            # ===== 品牌偏好提权 =====
+            # 目的：基于用户偏好的品牌推荐商品，提高个性化匹配度
+            # 逻辑：从用户画像base_info中提取brandCategoryIds，对相关品牌商品进行提权
+            # 权重：从配置文件读取，默认1.1倍
+            if user_profile.base_info.brandCategoryIds:
+                brand_ids = [x for x in user_profile.base_info.brandCategoryIds]
+                logger.debug(f"{log_prefix} Adding boost for brand preferences with {len(brand_ids)} brand_ids {brand_ids[:10]}")
+                functions.append({
+                    "filter": {
+                        "terms": {
+                            "brand_id": brand_ids
+                        }
+                    },
+                    "weight": BOOST_WEIGHTS_CONFIG["brand_preference_weight"]
+                })
+                boost_cnt[3] += 1  # brand_functions
+
+            # ===== 类目偏好提权 =====
+            # 目的：基于用户偏好的商品类目推荐相关商品，提高个性化匹配度
+            # 逻辑：从用户画像statistics中提取category_group，对相关类目商品进行提权
+            # 权重：从配置文件读取，默认1.08倍
+            # 注意：当前功能已禁用，如需启用请将if False改为if True
+            if False:
+                if user_profile.statistics.category_group:
+                    category_ids = [stat.keyId for stat in user_profile.statistics.category_group]
+                    category_stats = [MessageToDict(stat) for stat in user_profile.statistics.category_group]
+                    logger.debug(f"{log_prefix} Category preferences stats with {len(category_ids)} category_ids {category_ids[:10]}")
+                    logger.debug(f"{log_prefix} Adding boost for category preferences with {len(category_ids)} category_ids {category_ids[:10]}")
+                    functions.append({
+                        "filter": {
+                            "terms": {
+                                "category_id": category_ids
+                            }
+                        },
+                        "weight": BOOST_WEIGHTS_CONFIG["category_preference_weight"]
+                    })
+                    boost_cnt[4] += 1  # category_functions
+
+            # ===== 价格区间偏好提权 =====
+            # 目的：基于用户偏好的价格区间推荐相关商品，提高个性化匹配度
+            # 逻辑：从用户画像statistics中提取price_group，对相关价格区间商品进行提权
+            # 权重：从配置文件读取，默认1.1倍
+            # 注意：当前功能已禁用，如需启用请将if False改为if True
+            if False:
+                if user_profile.statistics.price_group:
+                    price_ranges = [stat.keyId for stat in user_profile.statistics.price_group]
+                    price_stats = [MessageToDict(stat) for stat in user_profile.statistics.price_group]
+                    logger.debug(f"{log_prefix} Price range preferences stats: {price_stats}")
+                    logger.debug(f"{log_prefix} Adding boost for price range preferences: {price_ranges}")
+                    functions.append({
+                        "filter": {
+                            "terms": {
+                                "price_range": price_ranges
+                            }
+                        },
+                        "weight": BOOST_WEIGHTS_CONFIG["price_range_preference_weight"]
+                    })
+                    boost_cnt[5] += 1  # price_range_functions
+
+            # ===== 客户商品结构类目提权 =====
+            # 目的：基于客户商品结构分析，推荐符合客户业务模式的类目商品
+            # 逻辑：从用户画像base_info中提取customerGoodsStructure，分析客户的类目偏好
+            # 权重：从配置文件读取，默认1.08倍
+            # 注意：categoryIds对应前端类目，不是ES的category_id字段
+            if user_profile.base_info.customerGoodsStructure:
+                structure_list = [MessageToDict(s) for s in user_profile.base_info.customerGoodsStructure]
+                logger.debug(f"{log_prefix} Customer goods structure details: {structure_list}")
+                for structure in user_profile.base_info.customerGoodsStructure:
+                    if structure.categoryIds:
+                        logger.debug(f"{log_prefix} Adding boost for category IDs in structure length {len(structure.categoryIds)} category_ids {structure.categoryIds[:10]}")
+                        functions.append({
+                            "filter": {
+                                "terms": {
+                                    # 注意： user_profile.base_info.customerGoodsStructure.categoryIds 对应的是前端类目 而不是 ES 的 category_id
+                                    "sale_category_all": [x for x in structure.categoryIds]
+                                }
+                            },
+                            "weight": BOOST_WEIGHTS_CONFIG["customer_structure_category_weight"]
+                        })
+                        boost_cnt[4] += 1  # category_functions
+                    if structure.priceBetween:
+                        # logger.debug(f"Adding boost for price range in structure: {structure.priceBetween}")
+                        # not support yet
+                        pass
+        
+        # Calculate total functions count
+        total_functions = len(functions)
+        
+        # Log boost query statistics
+        logger.info(f"{log_prefix} ===== ES查询提权函数统计 =====")
+        logger.info(f"{log_prefix} 总提权函数数量: {total_functions}")
+        logger.info(f"{log_prefix} 标签提权函数: {boost_cnt[0]}")
+        logger.info(f"{log_prefix} 新品提权函数: {boost_cnt[1]}")
+        logger.info(f"{log_prefix} 行为提权函数: {boost_cnt[2]}")
+        logger.info(f"{log_prefix} 品牌提权函数: {boost_cnt[3]}")
+        logger.info(f"{log_prefix} 类目提权函数: {boost_cnt[4]}")
+        logger.info(f"{log_prefix} 价格区间提权函数: {boost_cnt[5]}")
+        logger.info(f"{log_prefix} 视频提权函数: {boost_cnt[6]}")
+        logger.info(f"{log_prefix} 平台类目排名提权函数: {boost_cnt[7]}")
+        logger.info(f"{log_prefix} ===== ES查询提权函数统计结束 =====")
+        
+        if not functions:
+            logger.debug(f"{log_prefix} No boost functions generated")
+            return {}
+        
+        score_mode = FUNCTIONS_SCORE__SCORE_MODE__WHEN_HAS_QUERY if search_context.search_query or search_context.query else FUNCTIONS_SCORE__SCORE_MODE__WHEN_NO_QUERY
+
+        boost_query = {
+            "function_score": {
+                "functions": functions,
+                "score_mode": score_mode,
+                "boost_mode": "multiply"
+            }
+        }
+        
+        # logger.debug(f"Generated boost query: {json.dumps(boost_query, ensure_ascii=False)}")
+        return boost_query
+
+    def get_boost_value(self, tag_id: Optional[int] = None, tag_name: Optional[str] = None, platform: Optional[str] = None) -> float:
+        """
+        Get the boost value for a given tag ID or name.
+        Returns 1.0 if no boost is configured or if platform doesn't match.
+        
+        Args:
+            tag_id: Tag ID to look up
+            tag_name: Tag name to look up
+            platform: Business platform for filtering
+        """
+        if tag_id is not None:
+            for config in self.boost_configs:
+                if config.tag_id == tag_id:
+                    # Check platform compatibility
+                    if platform and config.platform != platform:
+                        logger.debug(f"Platform mismatch for tag_id {tag_id}: requested platform {platform}, tag platform {config.platform}")
+                        return 1.0
+                    logger.debug(f"Found boost value {config.boost_value} for tag_id {tag_id}")
+                    return config.boost_value
+                    
+        if tag_name is not None:
+            for config in self.boost_configs:
+                if config.tag_name == tag_name:
+                    # Check platform compatibility
+                    if platform and config.platform != platform:
+                        logger.debug(f"Platform mismatch for tag_name {tag_name}: requested platform {platform}, tag platform {config.platform}")
+                        return 1.0
+                    logger.debug(f"Found boost value {config.boost_value} for tag_name {tag_name}")
+                    return config.boost_value
+                    
+        logger.debug(f"No boost value found for tag_id={tag_id}, tag_name={tag_name}, platform={platform}")
+        return 1.0 
 \ No newline at end of file
@@ -0,0 +1,32 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
@@ -0,0 +1,44 @@
+# Build targets
+
+USER_FLAGS = -Wno-unused-result -Wno-unused-but-set-variable -Wno-sign-compare -Wall
+USER_LIBS =
+
+# Compiler flags
+CXX = g++ -std=c++11
+CXXFLAGS = $(USER_FLAGS) -O3 -I ./include
+LDFLAGS = -lpthread
+
+# The names of the executables that will be built
+target_swing = bin/swing
+target_icf_simple = bin/icf_simple
+target_swing_symmetric = bin/swing_symmetric
+
+# Ensure the bin directory exists
+BIN_DIR = bin
+
+# Declare phony targets
+.PHONY: all clean
+
+# Build all targets
+all: $(BIN_DIR) $(target_swing) $(target_icf_simple) $(target_swing_symmetric)
+
+# Create bin directory if it doesn't exist
+$(BIN_DIR):
+	mkdir -p $(BIN_DIR)
+
+# Build target swing
+$(target_swing): src/swing.cc utils/utils.cc include/*
+	$(CXX) $(LDFLAGS) -o $(target_swing) src/swing.cc utils/utils.cc $(CXXFLAGS)
+
+# Build target swing_1st_order
+$(target_icf_simple): src/icf_simple.cc utils/utils.cc include/*
+	$(CXX) $(LDFLAGS) -o $(target_icf_simple) src/icf_simple.cc utils/utils.cc $(CXXFLAGS)
+
+# Build target swing_symmetric
+$(target_swing_symmetric): src/swing_symmetric.cc utils/utils.cc include/*
+	$(CXX) $(LDFLAGS) -o $(target_swing_symmetric) src/swing_symmetric.cc utils/utils.cc $(CXXFLAGS)
+
+# Clean build files
+clean:
+	rm -f $(target_swing) $(target_icf_simple) $(target_swing_symmetric)
+	find . -name '*.o' -delete
@@ -0,0 +1,17 @@
+
+协同算法
+
+item协同：
+标准swing算法
+swing_symmetric.cc
+
+改进的（非对称）swing算法
+swing.cc
+
+简单的item协同：
+icf_simple.cc
+
+
+用户协同：
+ucf.py
+
@@ -0,0 +1,105 @@
+#!/home/SanJunipero/anaconda3/bin/python
+# -*- coding:UTF-8 -*-
+import os,sys,json,re,time
+import numpy as np
+import pandas as pd
+from itertools import combinations
+import logging
+import traceback
+import cgitb
+from argparse import ArgumentParser
+
+sim_index = {}
+
+max_fea = 20 #最多用x个历史交互id去召回
+max_recall_len = 1200
+
+def para_define(parser):
+    parser.add_argument('-s', '--sim_index', type=str, default='')
+
+def parse_sim_item_pair(x):
+    x = x.split(':')
+    return (int(x[0]), float(x[1]))
+
+def parse_session_item_pair(x):
+    x = x.split(':')
+    return (int(x[0][1:-1]), float(x[1]))
+
+def run_eval(FLAGS):
+    with open(FLAGS.sim_index) as f:
+        for line in f:
+            segs = line.rstrip().split('\t')
+            if len(segs) != 2:
+                continue
+            k, vlist = segs
+            sim_index[int(k)] = [parse_sim_item_pair(x) for x in vlist.split(',')]
+    
+    statis = []
+    for line in sys.stdin:
+        line = line.strip()
+        segs = line.split('\t')    
+        uid = segs[0]
+        session = segs[1][1:-1]
+        if not session:
+            continue
+        session_list = [parse_session_item_pair(x) for x in session.split(',')]
+    
+        score_list = {}
+        for item_id, wei in session_list[1:1+max_fea]:
+            for sim_item_id, sim_value in sim_index.get(item_id, []):
+                score_list.setdefault(sim_item_id, 0.0)
+                score_list[sim_item_id] += wei*sim_value
+        score_list.items()
+        sorted_score_list = sorted(score_list.items(), key = lambda k:k[1], reverse=True)[:max_recall_len]
+        
+        target_item_id = session_list[0][0]
+        hit_pos = -1
+        for idx, (k, v) in enumerate(sorted_score_list):
+            if target_item_id == k:
+                hit_pos = idx
+                break
+
+        if hit_pos == -1 or hit_pos > max_recall_len:
+            hit_pos =  max_recall_len
+        info = (1, hit_pos, len(sorted_score_list),
+            int(hit_pos < 25),
+            int(hit_pos < 50),
+            int(hit_pos < 100),
+            int(hit_pos < 200),
+            int(hit_pos < 400),
+            int(hit_pos < 800),
+            int(hit_pos < max_recall_len),
+        )
+        statis.append(info)
+    statis = np.array(statis)
+
+    desc = '''(1, hit_pos, len(sorted_score_list),
+            int(hit_pos != -1 and hit_pos < 25),
+            int(hit_pos != -1 and hit_pos < 50),
+            int(hit_pos != -1 and hit_pos < 100),
+            int(hit_pos != -1 and hit_pos < 200),
+            int(hit_pos != -1 and hit_pos < 400),
+            int(hit_pos != -1 and hit_pos < 800),
+            int(hit_pos != -1),
+        )'''
+    print(desc)
+ 
+    np.set_printoptions(suppress=True)
+    print(FLAGS.sim_index, 'mean', '\t'.join([str(x) for x in statis.mean(axis=0)]), sep='\t')
+    print(FLAGS.sim_index, 'sum', '\t'.join([str(x) for x in statis.sum(axis=0)]), sep='\t')
+
+
+
+def main():
+    cgitb.enable(format='text')
+    # op config
+    parser = ArgumentParser()
+    para_define(parser)
+
+    FLAGS, unparsed = parser.parse_known_args()
+    print(FLAGS)
+
+    run_eval(FLAGS)
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,45 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class BitMap
+{
+public:
+    BitMap(size_t num)
+    {
+        _v.resize((num >> 5) + 1);
+    }
+
+    void Set(size_t num) //set 1
+    {
+        size_t index = num >> 5;
+        size_t pos = num & 0x1F;
+        _v[index] |= (1 << pos);
+    }
+
+    void Reset(size_t num) //set 0
+    {
+        size_t index = num >> 5;
+        size_t pos = num & 0x1F;
+        _v[index] &= ~(1 << pos);
+    }
+
+    // 
+    void ResetRoughly(size_t num) //set 0
+    {
+        size_t index = num >> 5;
+        _v[index] = 0;
+    }
+
+    bool Existed(size_t num)//check whether it exists
+    {
+        size_t index = num >> 5;
+        size_t pos = num & 0x1F;
+        return (_v[index] & (1 << pos));
+    }
+
+private:
+    vector<size_t> _v;
+}; 
+
@@ -0,0 +1,42 @@
+#ifndef ___HEADER_SWING_UTILS___
+#define ___HEADER_SWING_UTILS___
+
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <functional>
+#include <string.h>
+#include <time.h>
+#include<unordered_map>
+#include <iterator>
+#include <algorithm>
+
+
+template <typename T>
+std::ostream& operator<< (std::ostream& out, const std::vector<T>& v) {
+    if (!v.empty()) {
+        out << '[';
+        std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
+        out << "\b\b]";
+    }
+    return out;
+}
+
+std::string currentTimetoStr(void);
+
+void split(std::vector<std::string>& tokens, const std::string& s,  const std::string& delimiters = " ");
+
+bool compare_pairs(const std::pair<int, float> & a, const std::pair<int, float> & b);
+
+
+bool compare_i2ulist_map_iters(const std::unordered_map<int, std::vector<int> >::const_iterator & a, const std::unordered_map<int, std::vector<int> >::const_iterator & b);
+
+
+#endif
@@ -0,0 +1,46 @@
+#!/bin/bash
+source  ~/.bash_profile
+
+make
+
+DAY=`date -d "1 days ago" +"%Y%m%d"`
+# DAY=20240923
+
+# 清理当前目录下output_开头的 365天以前创建的目录
+find . -type d -name 'output_*' -ctime +365 -exec rm -rf {} \;
+find logs/ -type f -mtime +180 -exec rm -f {} \;
+
+output_dir=output_${DAY}
+mkdir ${output_dir}
+
+
+# cat ../fetch_data/data/session.txt.${DAY}  | bin/swing   0.7 1 3 4 ${output_dir} 1
+cat ../fetch_data/data/session.txt.all  | cut -f 2 | bin/swing   0.7 1 3 4 ${output_dir} 1
+
+# cat ./data/${DAY}/*  | bin/swing_symmetric 0.8 1.0 0
+# cat ./data/${DAY}/*  | bin/swing_1st_order 0.1 0.5 1 1 
+
+# 检查命令是否成功执行
+if [[ $? -eq 0 ]]; then
+    # 如果成功执行，删除已有的软链接或文件，并创建新的软链接
+    if [[ -e output ]]; then
+        rm -rf output
+    fi
+    ln -s "${output_dir}" output
+    echo "命令执行成功，软链接已更新为指向 ${output_dir}"
+else
+    echo "命令执行失败，未更新软链接"
+fi
+
+# 对结果进行合并
+cat output/sim_matrx.* > output/swing_similar.txt
+
+
+# 用户协同
+# 仅使用最新的10万条数据，降低历史数据的影响，使得给每个user推荐的结果随着最新数据动态变化
+# 2024-10-10 最近几个月平均每天1000，5万大概为50天
+tail -n 50000  ../fetch_data/data/session.txt.all > output/ucf.input
+python3 src/ucf.py output/ucf.input output/ucf.txt
+
+
+
@@ -0,0 +1,170 @@
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <functional>
+#include <string.h>
+#include <time.h>
+//#include <unordered_map>
+#include<unordered_map>
+#include <iterator>
+#include <algorithm>
+#include <queue>
+#include <math.h>
+#include <numeric>
+#include "utils.h"
+
+int max_sim_list_len = 300;
+
+using namespace std;
+
+// 定义 64 位无符号整型
+typedef uint64_t ItemID;
+
+int main(int argc,char *argv[]) {
+
+    float threshold1 = 0.5;
+    float threshold2 = 0.5;
+    int show_progress = 0;
+
+    if (argc < 5) {
+        cout << "usage " << argv[0] << " threshold1 threshold2 show_progress(0/1)" << endl;
+        return -1;
+    }
+
+    threshold1 = atof(argv[1]);
+    threshold2 = atof(argv[2]);
+    show_progress = atoi(argv[3]);
+
+    cerr << currentTimetoStr() << " start... " << endl;
+    cerr << " threshold1 " << threshold1 << endl;
+    cerr << " threshold2 " << threshold2 << endl;
+
+    // 一阶关系（DB簇索引）
+    unordered_map<ItemID, pair<int, float> > sim_by_1rs_relation_map(1000000);
+    //sim_by_1rs_relation_map.reserve(1000000);
+
+    string line_buff;
+    const string delimiters(",");
+
+    vector<string> field_segs;
+    vector<pair<ItemID, float> > item_list;
+
+    while (getline(cin, line_buff)) {
+         // 格式是一个json，所以要把开头和结尾的括号去掉
+        line_buff.erase(0, line_buff.find_first_not_of("{"));
+        line_buff.erase(line_buff.find_last_not_of("}") + 1);
+        field_segs.clear();
+        split(field_segs, line_buff, delimiters);
+
+        item_list.clear();
+        for (size_t i = 0; i < field_segs.size(); i++) {
+            const char * seg_pos = strchr(field_segs[i].c_str(), ':');
+            if (seg_pos == NULL || (seg_pos - field_segs[i].c_str() >= field_segs[i].length())) break;
+
+            float value = atof(seg_pos + 1);
+            if (value > threshold1 || value > threshold2) {
+                // 开头有一个双引号
+                ItemID item_id = static_cast<ItemID>(strtoull(field_segs[i].c_str() + 1, NULL, 10));
+                item_list.push_back(make_pair(item_id, value));
+            }
+        }
+
+        if (item_list.size() < 2) continue;
+
+        // append本次的itemlist
+        ItemID map_key = 0;
+        ItemID map_key_1 = 0;
+        ItemID map_key_2 = 0;
+        pair<unordered_map<ItemID, pair<int, float> >::iterator, bool> ins_ret;
+
+        for (vector<pair<ItemID, float> >::const_iterator i = item_list.begin(); i != item_list.end(); ++i) {
+            map_key_1 = i->first;
+            for (vector<pair<ItemID, float> >::const_iterator j = item_list.begin(); j != item_list.end(); ++j) {
+                map_key_2 = j->first;
+
+                if (map_key_1 == map_key_2) continue;
+
+                if (i->second > threshold1 && j->second > threshold2) {
+                    map_key = (map_key_1 << 32) + map_key_2;
+                    ins_ret = sim_by_1rs_relation_map.insert(make_pair(map_key, make_pair(1, j->second)));
+                    if (!ins_ret.second) {
+                        ins_ret.first->second.first += 1;
+                        ins_ret.first->second.second += j->second;
+                    }
+                }
+                if (j->second > threshold1 && i->second > threshold2) {
+                    map_key = (map_key_2 << 32) + map_key_1;
+                    ins_ret = sim_by_1rs_relation_map.insert(make_pair(map_key, make_pair(1, i->second)));
+                    if (!ins_ret.second) {
+                        ins_ret.first->second.first += 1;
+                        ins_ret.first->second.second += i->second;
+                    }
+                }
+            }
+        }
+    }
+
+    unordered_map<ItemID, vector<pair<ItemID, float> > > sim_matrix(200000);
+    // 计算item_i, item_j合并的打分，total_wei / num * math.log(1.5*num, 1.5). 
+    pair<ItemID, vector<pair<ItemID, float> > > pair_entry;
+    pair<unordered_map<ItemID, vector<pair<ItemID, float> > >::iterator, bool> ins_ret;
+
+    for (unordered_map<ItemID, pair<int, float> >::iterator iter = sim_by_1rs_relation_map.begin(); iter != sim_by_1rs_relation_map.end(); ++iter) {
+        ItemID item1 = iter->first >> 32;
+        ItemID item2 = iter->first & 0xFFFFFFFF;
+
+        int num = iter->second.first;
+        float total_wei = iter->second.second;
+        float merged_score = total_wei / num * log(1.5 * num);
+
+        pair_entry.first = item1;
+
+        ins_ret = sim_matrix.insert(pair_entry);
+        ins_ret.first->second.push_back(make_pair(item2, merged_score));
+    }
+
+    // staits info of sim matrix
+    vector<int> sim_list_len_statis;
+    sim_list_len_statis.resize(max_sim_list_len + 1);
+
+    // write sim matrix
+    for (unordered_map<ItemID, vector<pair<ItemID, float> > >::iterator iter = sim_matrix.begin(); iter != sim_matrix.end(); ++iter) {
+        vector<pair<ItemID, float> > & sim_list_buff = iter->second;
+        int sim_list_len = sim_list_buff.size();
+        if (sim_list_len > 0) {
+            sort(sim_list_buff.begin(), sim_list_buff.end(), compare_pairs);
+
+            cout << iter->first << "\t" << sim_list_buff[0].first << ":" << sim_list_buff[0].second;
+
+            if (sim_list_len > max_sim_list_len) sim_list_len = max_sim_list_len;
+
+            sim_list_len_statis[sim_list_len] += 1;
+
+            for (int i = 1; i < sim_list_len; i++) {
+                cout << ',' << sim_list_buff[i].first << ':' << sim_list_buff[i].second;
+            }
+            cout << endl;
+        }
+    }
+
+    // staits info of sim matrix
+    int sum_groups = accumulate(sim_list_len_statis.begin(), sim_list_len_statis.end(), (int)0);
+    cerr << currentTimetoStr() << " write sim matrix finished" << endl;
+    cerr << currentTimetoStr() << " print staits info of sim matrix... " << sim_list_len_statis.size() << endl;
+    cerr << currentTimetoStr() << " total keys: " << sum_groups << endl;
+
+    int accumulate = 0;
+    for (int i = sim_list_len_statis.size() - 1; i > -1; i--) {
+        accumulate += sim_list_len_statis[i];
+        fprintf(stderr, "simlist_len %4d, num %4d, accumulate %6d accumulated_rate %5.2f%\%\n", (int)i, sim_list_len_statis[i], accumulate, 100.0 * accumulate / sum_groups);
+    }
+
+    return 0;
+}
@@ -0,0 +1,409 @@
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <functional>
+#include <string.h>
+#include <time.h>
+#include <unordered_map>
+#include <iterator>
+#include <algorithm>
+#include <queue>
+#include <numeric>
+#include <fstream>
+#include <thread>
+#include "utils.h"
+#include "BitMap.h"
+
+using namespace std;
+
+// 使用 typedef 定义 itemID 类型
+typedef unsigned long long itemID;
+
+class Config {
+public:
+    Config() {
+
+        user_sessions_num = 2000000;
+        items_num = 160000;
+
+        max_sim_list_len = 300;
+        max_session_list_len = 100;
+
+        threshold1 = 0.5;
+        threshold2 = 0.5;
+        alpha = 0.5;
+        thread_num = 20;
+        show_progress = 0;
+        output_path = "result";
+    }
+       
+    int load(int argc,char *argv[]) {
+        if (argc < 7) {
+            cout << "usage " << argv[0] << " alpha threshold1 threshold2 thread_num output_path show_progress(0/1) " << endl;
+            return -1;
+        }
+    
+        alpha = atof(argv[1]);
+        threshold1 = atof(argv[2]);
+        threshold2 = atof(argv[3]);
+    
+        thread_num = atoi(argv[4]);
+        output_path = argv[5];
+        show_progress = atoi(argv[6]);
+    
+        cout << currentTimetoStr() << " start... " << endl;
+        cout << " threshold1 " << threshold1 << endl;
+        cout << " threshold2 " << threshold2 << endl;
+        cout << " alpha " << alpha << endl;
+        return 0;
+    }
+
+public:
+    int user_sessions_num; 
+    int items_num;
+
+    int max_sim_list_len; // 输出相似itemlist 最大长度
+    int max_session_list_len; // 输入的 用户行为列表，截断长度（按权重排序阶段）
+    float threshold1;
+    float threshold2;
+    float alpha;
+    float thread_num;
+    int show_progress;
+    string output_path;
+};
+
+/**
+ *
+ * read data from stdin
+ * format:
+ * 输入的itemlist必须是按照权重排序的
+ *
+ * {"111":3.9332,"222":0.0382,"333":0.0376}
+ * {"444":13.2136,"555":2.1438,"666":1.3443,"777":0.6775}
+ * {"888":22.0632,"999":0.0016}
+ *
+ * parm : 
+ * config
+ * groups : index of user_id -> items
+ * i2u_map : index of item -> users
+ */
+int load_data(const Config & config,
+         vector< pair<vector<itemID> , vector<itemID> > > & groups,
+         unordered_map<itemID, pair<vector<int>, vector<int> > > & i2u_map) {
+
+    string line_buff;
+
+    const string delimiters(",");
+
+    vector<string> field_segs;
+    // 每个元素是一个user的两个itemlist，first是交互强度大于threshold1的itemList，后者是强度大于threshold2的itemList
+    pair<vector<itemID> , vector<itemID>  > itemlist_pair;
+    
+
+    pair<itemID, pair<vector<int> , vector<int>  >  > pair_entry;
+    pair<unordered_map<itemID, pair<vector<int> , vector<int> > >::iterator, bool> ins_i2u_ret;
+
+    while (getline(cin, line_buff)) {
+         //格式是一个json，所以要把开头和结尾的括号去掉
+        line_buff.erase(0,line_buff.find_first_not_of("{"));
+        line_buff.erase(line_buff.find_last_not_of("}") + 1);
+        //cout << line_buff << " !!!" << endl;
+        field_segs.clear();
+        split(field_segs, line_buff, delimiters);
+        if (field_segs.size() < config.max_session_list_len) {
+            field_segs.resize(config.max_session_list_len);
+        }
+
+        // field_segs是按权重有序的，进行截断
+
+        for (size_t i = 0; i < field_segs.size(); i++) {
+            const char * seg_pos = strchr(field_segs[i].c_str(), ':') ;
+            if (seg_pos == NULL || (seg_pos - field_segs[i].c_str() >= field_segs[i].length())) break;
+
+            float value = atof(seg_pos + 1);
+            if (value < config.threshold1 && value < config.threshold2) break;
+
+            // 开头有一个双引号
+            itemID item_id = strtoull(field_segs[i].c_str() + 1, nullptr, 10);
+            if (value > config.threshold1) {
+                itemlist_pair.first.push_back(item_id);
+            }
+            if (value > config.threshold2) {
+                itemlist_pair.second.push_back(item_id);
+            }
+        }
+
+        // 左侧必须有2个item，右侧必须有1个item，此时该用户才有可能给(item_i, item_j) 打分
+        if (!(itemlist_pair.first.size() > 1 && itemlist_pair.second.size() > 0)) {
+            itemlist_pair.first.clear();
+            itemlist_pair.second.clear();
+            continue;
+        }
+        // 排序
+        sort(itemlist_pair.first.begin(), itemlist_pair.first.end());
+        sort(itemlist_pair.second.begin(), itemlist_pair.second.end());
+        
+        // 合入i2u索引
+        int idx = groups.size(); //待插入的index
+        for (auto item_id : itemlist_pair.first) {
+            pair_entry.first = item_id;
+            ins_i2u_ret = i2u_map.insert(pair_entry);
+            ins_i2u_ret.first->second.first.push_back(idx);
+        }
+        for (auto item_id : itemlist_pair.second) {
+            pair_entry.first = item_id;
+            ins_i2u_ret = i2u_map.insert(pair_entry);
+            ins_i2u_ret.first->second.second.push_back(idx);
+        }
+
+        // 插入 u -> item_list索引
+        groups.resize(groups.size()+1);
+        groups.back().first.swap(itemlist_pair.first);
+        groups.back().second.swap(itemlist_pair.second);
+
+    }
+
+    cout << currentTimetoStr() << " items num: " << i2u_map.size() << endl;
+    cout << currentTimetoStr() << " users num: " << groups.size() << endl;
+    cout << currentTimetoStr() <<  " sort.." << endl;
+
+    for (auto iter : i2u_map) {
+        sort(iter.second.first.begin(), iter.second.first.end());
+        sort(iter.second.second.begin(), iter.second.second.end());
+    }
+    cout << currentTimetoStr() << " sort finished" << endl;
+    return 0;
+ 
+}
+
+
+struct TaskOutput {
+    int id;
+    string output_path;
+    vector<int> sim_list_len_statis;
+};
+
+
+/*
+ * input parm:
+ * groups : u -> i index 
+ * i2u_map : i -> u index 
+ * output_path : path of write sim matrix
+ *
+ * output param:
+ * out
+ *
+ */
+int calc_sim_matrix(const Config & config,
+         const vector< pair<vector<itemID> , vector<itemID> > > & groups,
+         const unordered_map<itemID, pair<vector<int>, vector<int> > > & i2u_map,
+         TaskOutput & out,
+         int task_id, int total_tasks
+) {
+
+    int users_num = groups.size();
+    int items_num = i2u_map.size();
+    if (items_num < 2) return -1;
+
+    ofstream out_file(out.output_path);
+    if (out_file.fail()) {
+        cerr << currentTimetoStr() << " create out_file err: " << out.output_path << endl;
+        return -1;
+    }
+
+    vector<int> users_intersection_buffer;
+    vector<itemID> items_intersection_buffer;
+    vector<pair<itemID, float> > sim_list_buff;
+    users_intersection_buffer.reserve(2048);
+    BitMap user_bm(users_num);
+    bool use_bitmap;
+
+    out.sim_list_len_statis.resize(config.max_sim_list_len+1);
+
+    int idx = 0;
+    for (auto & iter_i : i2u_map) {
+        // if ((idx++) % total_tasks != task_id) continue;
+        // 改进任务分配策略，避免不同线程计算相同的 itemID。上面是基于索引 idx 分配任务
+        // 基于 itemID 的值进行分配，避免相同的 itemID 被多个线程处理。
+        if (iter_i.first % total_tasks != task_id) continue;
+
+        const vector<int> & ulist_of_item_i = iter_i.second.first;
+        if (config.show_progress) {
+            fprintf(stdout, "\r%d of %d", idx++, items_num);
+        }
+        sim_list_buff.clear();
+
+        //use_bitmap = true;
+        use_bitmap = ulist_of_item_i.size() > 50;
+        /** 
+         *  由全部使用有序数组求交，改为 长用bitmap，短的遍历，时长由 30 分钟 提升到 12分钟（users num 100w+）
+         *  // bitmapsize长度（users num）100万+的情况下，这个阈值选取0（即全部使用bitmap），50和100，时长都差不多。但是还是保留这个逻辑，单user_list长度达到千万时，这里根据阈值做区分对待应该还是有必要
+         */
+        if (use_bitmap) {
+            for (auto user_id : ulist_of_item_i) {
+                user_bm.Set(user_id);
+            }
+        }
+
+        for (auto & iter_j : i2u_map) {
+            if (iter_j.first == iter_i.first) continue;
+
+            const vector<int> & ulist_of_item_j = iter_j.second.second;
+            users_intersection_buffer.clear();
+            // 交互过item_i, item_j的user_list
+            if (use_bitmap) {
+                for (auto user_id : ulist_of_item_j) {
+                    if (user_bm.Existed(user_id)) {
+                        users_intersection_buffer.push_back(user_id);
+                    }
+                }
+            } else {
+                set_intersection(ulist_of_item_i.begin(), ulist_of_item_i.end(), ulist_of_item_j.begin(), ulist_of_item_j.end(), back_inserter(users_intersection_buffer));
+            }
+
+            if (users_intersection_buffer.size() < 2) continue;
+            // user_i, user_j
+
+            float sim_of_item_i_j = 0.0;
+            // 遍历共同交互过(item_i, item_j)的user组合(user_i, user_j)
+            for (vector<int>::const_iterator user_i = users_intersection_buffer.begin() + 1;
+                 user_i != users_intersection_buffer.end();
+                 ++user_i) {
+
+                const vector<itemID> & item_list_of_user_i = groups[*user_i].first;  // 使用first
+                for (vector<int>::const_iterator user_j = users_intersection_buffer.begin();
+                     user_j != user_i;
+                     ++user_j) {
+
+                    const vector<itemID> & item_list_of_user_j = groups[*user_j].first;  // 使用first
+                    items_intersection_buffer.clear();
+
+                    // 求交集
+                    set_intersection(item_list_of_user_i.begin(), item_list_of_user_i.end(),
+                                     item_list_of_user_j.begin(), item_list_of_user_j.end(),
+                                     back_inserter(items_intersection_buffer));
+
+                    sim_of_item_i_j += 1.0 / (config.alpha + items_intersection_buffer.size());
+                }
+            }
+            sim_list_buff.push_back(make_pair(iter_j.first, sim_of_item_i_j));
+        }
+
+        if (use_bitmap) {
+            for (auto user_id : ulist_of_item_i) {
+                user_bm.ResetRoughly(user_id);
+            }
+        }
+
+        int sim_list_len = sim_list_buff.size();
+        if (sim_list_len > 0) {
+
+            sort(sim_list_buff.begin(), sim_list_buff.end(), compare_pairs);
+
+            out_file << iter_i.first << "\t" << sim_list_buff[0].first << ":" << sim_list_buff[0].second;
+
+            if (sim_list_len > config.max_sim_list_len) sim_list_len = config.max_sim_list_len;
+
+            out.sim_list_len_statis[sim_list_len] += 1;
+
+            for (int i = 1; i < sim_list_len; i++) {
+                out_file << ',' << sim_list_buff[i].first << ':' << sim_list_buff[i].second;
+            }
+            out_file << endl; 
+        }
+
+    }
+
+    out_file.close();
+    return 0;
+} 
+
+void printSimMatrixStatisInfo(string task_name, const vector<int> & sim_list_len_statis) {
+    // staits info of sim matrix
+    int sum_groups = accumulate(sim_list_len_statis.begin(), sim_list_len_statis.end(), (int)0);
+    cout << currentTimetoStr() <<  " ========== TASK STATIS INFO [" << task_name << "]==========" << endl;
+    cout << currentTimetoStr() <<  " write sim matrix finished" << endl;
+    cout << currentTimetoStr() <<  " print staits info of sim matrix... " << sim_list_len_statis.size() << endl;
+    cout << currentTimetoStr() <<  " total keys: " << sum_groups  << endl;
+
+    int accumulate = 0;
+    for (int i = sim_list_len_statis.size() - 1; i >= 0; i--) {
+        accumulate += sim_list_len_statis[i];
+        if (i % 20 == 0) {
+            // 注意 为防止输出太多，间隔20输出一行，所以num与上一行的累加不会等于accumulate
+            fprintf(stdout, "simlist_len %4d, num %4d, accumulate %6d accumulated_rate %5.2f%\%\n",
+                    (int) i, sim_list_len_statis[i], accumulate, 100.0 * accumulate / sum_groups);
+        }
+    }
+}
+ 
+int main(int argc,char *argv[]) {
+
+    Config config;
+    int ret = config.load(argc, argv);
+    if (ret < 0) {
+        cerr << currentTimetoStr() << " load_config err: " << ret << endl;
+        return ret;
+    }
+
+    cout << currentTimetoStr() << " start load raw user_session data ... " << endl;
+
+    vector< pair<vector<itemID> , vector<itemID> > > groups;
+    groups.reserve(config.user_sessions_num);
+
+    unordered_map<itemID, pair<vector<int>, vector<int> > > i2u_map;
+    i2u_map.reserve(config.items_num);
+
+    ret = load_data(config, groups, i2u_map);
+    if (ret < 0) {
+        cerr << currentTimetoStr() << " load_data err: " << ret << endl;
+        return ret;
+    }
+    cout << currentTimetoStr() << " load raw user_session data finished. " << endl;
+
+    vector<TaskOutput> outs;
+    outs.resize(config.thread_num);
+
+    vector<thread> threads;
+    char out_path[256];
+    for (int task_id = 0; task_id < config.thread_num; task_id++) {
+        outs[task_id].id = task_id;
+
+        snprintf(out_path, sizeof(out_path), "%s/sim_matrx.%0.1f_%0.3f_%0.3f.%d", config.output_path.c_str(), config.alpha, config.threshold1, config.threshold2, task_id);
+        outs[task_id].output_path = out_path;
+        threads.push_back(thread(calc_sim_matrix, std::cref(config), std::cref(groups), std::cref(i2u_map), std::ref(outs[task_id]), task_id, config.thread_num));
+    }
+
+    // wait all tasks
+    cout << endl;
+    cout << currentTimetoStr() << " wait sim_calc threads ... " << endl;
+    std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
+    cout << currentTimetoStr() << " all sim_calc tasks finished" << endl;
+
+    // merge outputs
+    TaskOutput merged_output;
+    vector<int> & sim_list_len_statis = merged_output.sim_list_len_statis;
+    for (auto & out_task_i : outs) {
+        string task_name = std::to_string(out_task_i.id) + " " + out_task_i.output_path;
+        printSimMatrixStatisInfo(task_name, out_task_i.sim_list_len_statis);
+
+        vector<int> & list_i = out_task_i.sim_list_len_statis;
+        if (sim_list_len_statis.size() < list_i.size()) {
+            sim_list_len_statis.resize(list_i.size());
+        }
+        for (size_t j = 0; j < list_i.size(); j++) {
+            sim_list_len_statis[j] += list_i[j];
+        }
+    }
+
+    printSimMatrixStatisInfo("Merged", sim_list_len_statis);
+
+    return 0;
+}
@@ -0,0 +1,234 @@
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <string.h>
+#include <time.h>
+#include <unordered_map>
+#include <iterator>
+#include <queue>
+#include <numeric>
+#include "utils.h"
+#include "BitMap.h"
+
+int max_sim_list_len = 300;
+
+using namespace std;
+
+typedef unsigned long long item_id_t; // 定义64位无符号整型作为item ID
+
+// 比较函数，用于排序时按item_id_t来比较
+bool compare_i2ulist_map_iters2(const unordered_map<item_id_t, vector<int>>::const_iterator &a, 
+                               const unordered_map<item_id_t, vector<int>>::const_iterator &b) {
+    return a->first < b->first;
+}
+
+// 比较函数，用于sim_list排序
+bool compare_pairs2(const pair<item_id_t, float> &a, const pair<item_id_t, float> &b) {
+    return a.second > b.second;
+}
+
+int main(int argc, char *argv[]) {
+
+    float alpha = 0.5;
+    float threshold = 0.5;
+    int show_progress = 0;
+
+    if (argc < 4) {
+        cerr << "usage " << argv[0] << " alpha threshold show_progress(0/1)" << endl;
+        return -1;
+    }
+
+    alpha = atof(argv[1]);
+    threshold = atof(argv[2]);
+    show_progress = atoi(argv[3]);
+
+    cerr << currentTimetoStr() << " start... " << endl;
+    cerr << " alpha " << alpha << endl;
+    cerr << " threshold " << threshold << endl;
+
+    unordered_map<item_id_t, vector<int>> i2u_map;
+    i2u_map.reserve(160000);
+
+    string line_buff;
+    const string delimiters(",");
+
+    vector<string> field_segs;
+    vector<vector<item_id_t>> groups;  // Changed to store item_id_t
+    groups.reserve(2000000);
+    vector<item_id_t> item_list;
+
+    vector<int> items_intersection_buffer;
+    vector<int> users_intersection_buffer;
+    users_intersection_buffer.reserve(2000);
+
+    pair<item_id_t, vector<int>> pair_entry;
+    pair<unordered_map<item_id_t, vector<int>>::iterator, bool> ins_i2u_ret;
+
+    while (getline(cin, line_buff)) {
+        // 格式是一个json，所以要把开头和结尾的括号去掉
+        line_buff.erase(0, line_buff.find_first_not_of("{"));
+        line_buff.erase(line_buff.find_last_not_of("}") + 1);
+        field_segs.clear();
+        split(field_segs, line_buff, delimiters);
+
+        item_list.clear();
+        for (size_t i = 0; i < field_segs.size(); i++) {
+            const char *seg_pos = strchr(field_segs[i].c_str(), ':');
+            if (seg_pos == NULL || (seg_pos - field_segs[i].c_str() >= field_segs[i].length())) break;
+
+            float value = atof(seg_pos + 1);
+            if (value > threshold) {
+                // 开头有一个双引号
+                item_id_t item_id = strtoull(field_segs[i].c_str() + 1, NULL, 10);
+                item_list.push_back(item_id);
+            }
+        }
+
+        if (item_list.size() < 2) continue;
+        // 排序
+        sort(item_list.begin(), item_list.end());
+
+        // append本次的itemlist
+        int idx = groups.size();
+        groups.push_back(item_list);  // item_list is now of type item_id_t
+        // 合入i2u索引
+        for (vector<item_id_t>::const_iterator iter = item_list.begin(); iter != item_list.end(); ++iter) {
+            pair_entry.first = *iter;
+            ins_i2u_ret = i2u_map.insert(pair_entry);
+            ins_i2u_ret.first->second.push_back(idx);
+        }
+    }
+
+    int items_num = i2u_map.size();
+    int users_num = groups.size();
+    cerr << currentTimetoStr() << " items num: " << i2u_map.size() << endl;
+    cerr << currentTimetoStr() << " users num: " << groups.size() << endl;
+    cerr << currentTimetoStr() << " sort.." << endl;
+
+    vector<unordered_map<item_id_t, vector<int>>::const_iterator> sorted_i_ulist_pairs;
+
+    for (unordered_map<item_id_t, vector<int>>::iterator iter = i2u_map.begin(); iter != i2u_map.end(); ++iter) {
+        sorted_i_ulist_pairs.push_back(iter);
+        sort(iter->second.begin(), iter->second.end());
+    }
+    cerr << currentTimetoStr() << " sort finished" << endl;
+
+    sort(sorted_i_ulist_pairs.begin(), sorted_i_ulist_pairs.end(), compare_i2ulist_map_iters2);
+
+    if (items_num < 2) return -1;
+
+    vector<pair<item_id_t, float>> sim_list_buff;
+    unordered_map<item_id_t, vector<pair<item_id_t, float>>> sim_matrix;
+    sim_matrix.reserve(items_num);
+
+    int idx = 0;
+
+    BitMap user_bm(users_num);
+    bool use_bitmap;
+    vector<int> sim_list_len_statis;
+    sim_list_len_statis.resize(max_sim_list_len + 1);
+
+    for (int i = 1; i < sorted_i_ulist_pairs.size(); ++i) {
+        unordered_map<item_id_t, vector<int>>::const_iterator pair_i = sorted_i_ulist_pairs[i];
+        if (show_progress) {
+            fprintf(stderr, "\r%d of %d", idx++, items_num);
+        }
+        sim_list_buff.clear();
+
+        use_bitmap = pair_i->second.size() > 50;
+
+        if (use_bitmap) {
+            for (vector<int>::const_iterator iter_pair_i = pair_i->second.begin(); iter_pair_i != pair_i->second.end(); ++iter_pair_i) {
+                user_bm.Set(*iter_pair_i);
+            }
+        }
+
+        for (int j = 0; j < i; ++j) {
+            unordered_map<item_id_t, vector<int>>::const_iterator pair_j = sorted_i_ulist_pairs[j];
+            users_intersection_buffer.clear();
+
+            if (use_bitmap) {
+                for (vector<int>::const_iterator iter_pair_j = pair_j->second.begin(); iter_pair_j != pair_j->second.end(); ++iter_pair_j) {
+                    if (user_bm.Existed(*iter_pair_j)) {
+                        users_intersection_buffer.push_back(*iter_pair_j);
+                    }
+                }
+            } else {
+                set_intersection(pair_i->second.begin(), pair_i->second.end(), pair_j->second.begin(), pair_j->second.end(), back_inserter(users_intersection_buffer));
+            }
+
+            if (users_intersection_buffer.size() < 2) continue;
+
+            float sim_of_item_i_j = 0.0;
+            for (vector<int>::const_iterator user_i = users_intersection_buffer.begin() + 1;
+                 user_i != users_intersection_buffer.end();
+                 ++user_i) {
+
+                const vector<item_id_t> &item_list_of_user_i = groups[*user_i];
+
+                for (vector<int>::const_iterator user_j = users_intersection_buffer.begin();
+                     user_j != user_i;
+                     ++user_j) {
+
+                    const vector<item_id_t> &item_list_of_user_j = groups[*user_j];
+                    items_intersection_buffer.clear();
+                    set_intersection(item_list_of_user_i.begin(), item_list_of_user_i.end(), item_list_of_user_j.begin(), item_list_of_user_j.end(), back_inserter(items_intersection_buffer));
+
+                    sim_of_item_i_j += 1.0 / (alpha + items_intersection_buffer.size());
+                }
+            }
+            sim_list_buff.push_back(make_pair(pair_j->first, sim_of_item_i_j));
+        }
+
+        sim_matrix[pair_i->first] = sim_list_buff;
+        for (auto &p : sim_list_buff) {
+            sim_matrix[p.first].push_back(make_pair(pair_i->first, p.second));
+        }
+        if (use_bitmap) {
+            for (vector<int>::const_iterator iter_pair_i = pair_i->second.begin(); iter_pair_i != pair_i->second.end(); ++iter_pair_i) {
+                user_bm.ResetRoughly(*iter_pair_i);
+            }
+        }
+    }
+
+    for (auto &p : sim_matrix) {
+        vector<pair<item_id_t, float>> &sim_list = p.second;
+        int sim_list_len = p.second.size();
+        if (sim_list_len > 0) {
+            sort(sim_list.begin(), sim_list.end(), compare_pairs2);
+
+            cout << p.first << "\t" << sim_list[0].first << ":" << sim_list[0].second;
+
+            if (sim_list_len > max_sim_list_len) {
+                sim_list_len = max_sim_list_len;
+            }
+
+            sim_list_len_statis[sim_list_len] += 1;
+
+            for (int i = 1; i < sim_list_len; i++) {
+                cout << ',' << sim_list[i].first << ':' << sim_list[i].second;
+            }
+            cout << endl;
+        }
+    }
+
+    int sum_groups = accumulate(sim_list_len_statis.begin(), sim_list_len_statis.end(), 0);
+    cerr << currentTimetoStr() << " write sim matrix finished" << endl;
+    cerr << currentTimetoStr() << " print stats info of sim matrix... " << sim_list_len_statis.size() << endl;
+    cerr << currentTimetoStr() << " total keys: " << sum_groups << endl;
+
+    int accumulate = 0;
+    for (int i = sim_list_len_statis.size() - 1; i >= 0; i--) {
+        accumulate += sim_list_len_statis[i];
+        fprintf(stderr, "simlist_len %4d, num %4d, accumulate %6d accumulated_rate %5.2f%%\n",
+                i, sim_list_len_statis[i], accumulate, 100.0 * accumulate / sum_groups);
+    }
+
+    return 0;
+}
@@ -0,0 +1,145 @@
+import sys
+import json
+import logging
+from collections import defaultdict
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+# 日志配置
+logging.basicConfig(filename='logs/ucf.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# 输入数据，用户对item的评分
+# 暂定为0.0，也就是所有的行为都会进行考虑。如果要过滤掉只有一次点击的，可以设定为1.1，1分是一次点击，有点击阅读页或者多次点击就会达到2分以上
+user_rating_threshold = 0.0
+# 当某个用于基于最近邻推荐输出的item list低于多少时不输出
+least_items_size_to_output = 5
+# 每个用户输出的top_k
+top_k = 50
+
+# 本模块的主要特点：
+# 读取数据并合并同一个用户的多行记录：同一个用户可能会出现在多行中，对同一个用户的多行记录进行了合并。
+# 计算用户之间的相似性：用户协同过滤的关键是计算用户之间的相似度。为了加速计算，可以使用基于向量化的余弦相似度，而避免直接计算两两用户之间的相似度。
+# 为每个用户推荐物品：根据相似用户的评分，为每个用户推荐新的物品，并计算推荐得分。
+
+
+# 读取数据，并合并同一个用户的多行记录
+def read_input(input_file):
+    user_items = defaultdict(dict)
+    
+    with open(input_file, 'r') as f:
+        for line_num, line in enumerate(f, 1):
+            try:
+                uid, items_str = line.strip().split('\t')
+                items = json.loads(items_str)
+                for item_id, score in items.items():
+                    if score < user_rating_threshold:
+                        continue
+                    if item_id in user_items[uid]:
+                        user_items[uid][item_id] += score  # 合并相同用户的评分
+                    else:
+                        user_items[uid][item_id] = score
+            except ValueError as ve:
+                logging.error(f"Data format error at line {line_num}: {line.strip()}. Error: {ve}")
+            except json.JSONDecodeError as je:
+                logging.error(f"JSON parse error at line {line_num}: {line.strip()}. Error: {je}")
+
+    logging.info(f"Input data loaded from {input_file}. Total users: {len(user_items)}")
+    return user_items
+
+# 基于物品评分构建用户-物品矩阵
+def build_user_item_matrix(user_items):
+    all_items = set()
+    for items in user_items.values():
+        all_items.update(items.keys())
+    
+    item_list = list(all_items)
+    item_index = {item_id: idx for idx, item_id in enumerate(item_list)}
+
+    user_list = list(user_items.keys())
+    user_index = {uid: idx for idx, uid in enumerate(user_list)}
+    
+    user_item_matrix = np.zeros((len(user_list), len(item_list)))
+    
+    for uid, items in user_items.items():
+        for item_id, score in items.items():
+            user_item_matrix[user_index[uid]][item_index[item_id]] = score
+
+    logging.info(f"User-item matrix built with shape: {user_item_matrix.shape}")
+    
+    return user_item_matrix, user_list, item_list, user_index, item_index
+
+# 基于余弦相似度计算用户相似性矩阵
+def compute_user_similarity(user_item_matrix):
+    similarity_matrix = cosine_similarity(user_item_matrix)
+    logging.info("User similarity matrix computed.")
+    return similarity_matrix
+
+# 基于相似用户为每个用户推荐物品
+def recommend_items(user_items, user_list, item_list, user_index, item_index, similarity_matrix, top_k=50):
+    recommendations = defaultdict(dict)
+
+    for uid in user_list:
+        u_idx = user_index[uid]
+        similar_users = np.argsort(-similarity_matrix[u_idx])[:top_k]  # 取前top_k个相似用户
+
+        # 遍历这些相似用户的物品，累积推荐得分
+        item_scores = defaultdict(float)
+        for sim_uid_idx in similar_users:
+            if sim_uid_idx == u_idx:  # 跳过自己
+                continue
+            sim_uid = user_list[sim_uid_idx]
+            for item_id, score in user_items[sim_uid].items():
+                if item_id not in user_items[uid]:  # 只推荐未交互过的物品
+                    item_scores[item_id] += score * similarity_matrix[u_idx][sim_uid_idx]
+        
+        # 将得分最高的物品推荐给用户
+        recom_list = {item_id: score for item_id, score in sorted(item_scores.items(), key=lambda x: -x[1])[:top_k]}
+        if len(recom_list) > least_items_size_to_output:
+            recommendations[uid] = recom_list
+    
+    logging.info("Recommendations computed for all users.")
+    return recommendations
+
+# 输出推荐结果
+def write_output(recommendations, output_file):
+    try:
+        with open(output_file, 'w') as f:
+            for uid, rec_items in recommendations.items():
+                rec_str = ",".join([f"{item_id}:{score:.2f}" for item_id, score in rec_items.items()])
+                f.write(f"{uid}\t{rec_str}\n")
+        logging.info(f"Recommendations written to {output_file}.")
+    except Exception as e:
+        logging.error(f"Error writing recommendations to {output_file}: {e}")
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python recommend.py <input_file> <output_file>")
+        logging.error("Invalid number of arguments. Expected 2 arguments: input_file and output_file.")
+        sys.exit(1)
+    
+    input_file = sys.argv[1]
+    output_file = sys.argv[2]
+
+    logging.info(f"Starting recommendation process. Input file: {input_file}, Output file: {output_file}")
+
+    # Step 1: 读取并合并输入
+    user_items = read_input(input_file)
+
+    if not user_items:
+        logging.error(f"No valid user-item data found in {input_file}. Exiting.")
+        sys.exit(1)
+
+    # Step 2: 构建用户-物品矩阵
+    user_item_matrix, user_list, item_list, user_index, item_index = build_user_item_matrix(user_items)
+
+    # Step 3: 计算用户相似性
+    similarity_matrix = compute_user_similarity(user_item_matrix)
+
+    # Step 4: 为用户推荐物品
+    recommendations = recommend_items(user_items, user_list, item_list, user_index, item_index, similarity_matrix, top_k)
+
+    # Step 5: 输出推荐结果
+    write_output(recommendations, output_file)
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <functional>
+#include <string.h>
+#include <time.h>
+//#include <unordered_map>
+#include<unordered_map>
+
+#include <iterator>
+#include <algorithm>
+void split(std::vector<std::string>& tokens, const std::string& s,  const std::string& delimiters = " ")
+{
+    using namespace std;
+    string::size_type lastPos = s.find_first_not_of(delimiters, 0);
+    string::size_type pos = s.find_first_of(delimiters, lastPos);
+    while (string::npos != pos || string::npos != lastPos) {
+        tokens.push_back(s.substr(lastPos, pos - lastPos));//use emplace_back after C++11
+        lastPos = s.find_first_not_of(delimiters, pos);
+        pos = s.find_first_of(delimiters, lastPos);
+    }
+}
+
+std::string currentTimetoStr(void) {
+    char tmp[64];
+    time_t t = time(NULL);
+    tm *_tm = localtime(&t);
+    int year  = _tm->tm_year+1900;
+    int month = _tm->tm_mon+1;
+    int date  = _tm->tm_mday;
+    int hh = _tm->tm_hour;
+    int mm = _tm->tm_min;
+    int ss = _tm->tm_sec;
+    sprintf(tmp,"%04d-%02d-%02d %02d:%02d:%02d", year,month,date,hh,mm,ss);
+    return std::string(tmp);
+}
+
+
+bool compare_i2ulist_map_iters(const std::unordered_map<int, std::vector<int> >::const_iterator & a, const std::unordered_map<int, std::vector<int> >::const_iterator & b) {
+    // vector长的排序后面
+    return a->second.size() < b->second.size();
+}
+
+bool compare_pairs(const std::pair<int, float> & a, const std::pair<int, float> & b) {
+    // 分数大的排前面
+    return a.second > b.second;
+}
+
@@ -0,0 +1,26 @@
+import os  # Add for environment variable reading
+
+
+ES_CONFIG = {
+    'host': 'http://localhost:9200',
+    # default index name will be overwritten below based on APP_ENV
+    'index_name': 'spu',
+    'username': 'essa',
+    'password': '4hOaLaf41y2VuI8y'
+}
+
+
+# Redis Cache Configuration
+REDIS_CONFIG = {
+    # 'host': '120.76.41.98',
+    'host': 'localhost',
+    'port': 6479,
+    'snapshot_db': 0,
+    'password': 'BMfv5aI31kgHWtlx',
+    'socket_timeout': 1,
+    'socket_connect_timeout': 1,
+    'retry_on_timeout': False,
+    'cache_expire_days': 180,  # 6 months
+    'translation_cache_expire_days': 360,
+    'translation_cache_prefix': 'trans'
+}
@@ -0,0 +1,48 @@
+"""
+数据库连接服务模块
+提供统一的数据库连接接口
+"""
+from sqlalchemy import create_engine
+from urllib.parse import quote_plus
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def create_db_connection(host, port, database, username, password):
+    """
+    创建数据库连接
+    
+    Args:
+        host: 数据库主机地址
+        port: 端口
+        database: 数据库名
+        username: 用户名
+        password: 密码
+    
+    Returns:
+        SQLAlchemy engine对象
+    """
+    try:
+        # 对密码进行URL编码，处理特殊字符
+        encoded_password = quote_plus(password)
+        
+        # 构建连接字符串
+        connection_string = f'mysql+pymysql://{username}:{encoded_password}@{host}:{port}/{database}'
+        
+        # 创建引擎
+        engine = create_engine(
+            connection_string,
+            pool_pre_ping=True,  # 连接池预检
+            pool_recycle=3600,   # 连接回收时间
+            echo=False
+        )
+        
+        logger.info(f"Database connection created successfully: {host}:{port}/{database}")
+        return engine
+        
+    except Exception as e:
+        logger.error(f"Failed to create database connection: {e}")
+        raise
+
@@ -0,0 +1,229 @@
+## 项目简介
+
+DeepWalk是一种基于随机游走的图嵌入算法。它通过在图上进行随机游走，采集节点序列，并将这些序列作为训练数据，来学习图中节点的低维表示（embedding）。这些表示可以用于许多图分析任务，例如节点分类、聚类、链路预测等。这个项目在DeepWalk算法的基础上，支持使用别名采样（Alias Sampling）来加速随机游走过程，并增加了使用Softmax进行采样的选项，同时引入了书籍内容的标签游走机制，以增强图嵌入表示的多样性和内容相关性。
+
+### 对标准deepwalk方法的特殊改进
+
+基于以下几个原因：
+1. **用户行为的个性化不明显**：当前的书籍推荐没有个性化算法，因此用户曝光的书籍同质化非常严重，导致推荐给用户的书籍存在严重的同质化现象，进而影响用户点击和阅读书籍的多样性。同时，由于平台用户数量较少，因此难以从这种用户行为数据中学习出书籍表征的差异度。
+在掌阅 deepwalk 的结果 item 相关性非常好，比如玄幻书籍的相似书就基本都是玄幻、热血这类兴趣点很相似的书，因此书籍详情页的“相似书推荐”也采用了这个方法，并且deepwalk也是其在线推荐系统的绝对主力之一，这一类公司在做deepwalk的时候可能为了避免推荐的茧房效应会做一些策略增加游走的多样性。我们是完全相反的，用户基本上都是在看运营推荐的高热书籍，用户行为没有显著的个性化。
+2. **书籍点击量的基尼系数高**：依赖于运营配置进行推荐的书籍基尼系数较高。
+
+
+因此：
+
+1. 在DeepWalk基础上增加书籍内容标签（tags）游走机制，提高推荐系统的内容多样性，解决推荐结果同质化的问题。通过参数配置，可以在内容相似度和行为相似度之间取得平衡，tags游走的概率越高，推荐结果的内容多样性越好，越低则会受到曝光书籍的同质化问题影响越严重，配置为0则为标准的deepwalk方法。
+2. node2vec方法和EGES方法也可以引入书籍的side information，利于冷门书籍的表征学习的准确性。如果仅仅用于书籍表征的学习，本方法相比于node2vec效果更好。EGES的思路也是在deepwalk的基础上补充side information信息让书籍的表征受到tags和categories等属性的影响，具有类似的效果，但是实现复杂度略高。结合数据情况和具体场景，选择在deepwalk的基础上增加书籍内容标签（tags）游走机制作为最终方案。
+
+## 功能模块
+
+1. **图的构建**：从边文件读取图，并为每个节点构建邻居关系。
+2. **别名采样表构建**：为每个节点的邻居预处理别名采样表，加速随机游走过程。
+3. **Softmax支持**：支持使用Softmax函数对邻居节点进行加权采样，并加入温度（temperature）参数进行控制。
+4. **随机游走模拟**：在图中执行多次随机游走，生成序列。
+5. **标签游走机制**：支持基于书籍标签的游走，以提高内容相关性。通过节点-标签关联，以一定概率通过标签游走。
+6. **多进程支持**：使用并行处理，提升随机游走的效率。
+7. **结果保存**：将生成的游走序列保存为文本文件，以便后续的词嵌入模型（如Word2Vec）使用。
+
+## 项目结构
+
+``` 
+project/
+│
+├── deepwalk.py          # DeepWalk的核心代码
+├── alias.py             # 用于别名采样的工具函数
+├── run.sh               # 运行DeepWalk程序的shell脚本
+├── README.md            # 项目说明文档
+└── data/
+    └── edge.txt         # 示例边文件
+``` 
+
+## 依赖库
+
+此项目依赖以下第三方库：
+1. numpy：用于矩阵和数组操作
+2. networkx：用于图的构建与处理
+3. joblib：用于并行处理
+4. argparse：用于解析命令行参数
+5. multiprocessing：支持多进程处理
+6. tqdm：用于显示进度条
+7. logging：用于日志记录
+
+## 实现逻辑
+
+1. **构建图**
+
+从给定的边文件中读取数据，构建无向加权图。边文件的格式如下：
+``` 
+bid1    bid2:weight1,bid3:weight2,...
+``` 
+每行表示一个节点及其邻居节点列表。每个邻居节点有一个对应的权重值。
+代码实现：
+``` python
+def build_graph_from_edge_file(self, edge_file):
+    G = nx.Graph()
+    with open(edge_file, 'r') as f:
+        for line in f:
+            parts = line.strip().split('\t')
+            if len(parts) != 2:
+                continue
+            node, edges_str = parts
+            edges = edges_str.split(',')
+            for edge in edges:
+                nbr, weight = edge.split(':')
+                G.add_edge(int(node), int(nbr), weight=float(weight))
+    return G
+``` 
+
+2. **别名采样表的构建**
+
+为了加速加权随机游走，使用别名采样（Alias Sampling）来为每个节点构建采样表。每个节点的邻居按照边权重进行采样。
+代码实现：
+``` python
+def preprocess_transition_probs(self):
+    G = self.graph
+    for node in G.nodes():
+        unnormalized_probs = [G[node][nbr].get('weight', 1.0) for nbr in G.neighbors(node)]
+        norm_const = sum(unnormalized_probs)
+        normalized_probs = [float(u_prob) / norm_const for u_prob in unnormalized_probs]
+        self.alias_nodes[node] = create_alias_table(normalized_probs)
+``` 
+
+3. **Softmax采样支持**
+
+提供了一个选项，允许使用Softmax函数对邻居节点进行加权采样。Softmax函数可以加入温度参数，使得采样更具多样性或更加集中。
+代码实现：
+``` python
+def preprocess_transition_probs__softmax(self, temperature=1.0):
+    G = self.graph
+    for node in G.nodes():
+        unnormalized_probs = [G[node][nbr].get('weight', 1.0) for nbr in G.neighbors(node)]
+        normalized_probs = softmax(unnormalized_probs, temperature)
+        self.alias_nodes[node] = create_alias_table(normalized_probs)
+``` 
+
+4. **标签游走机制**
+
+引入书籍内容标签，以一定概率通过标签进行游走。节点-标签词典包括：
+- **node_to_tags**：保存每个节点关联的标签列表（正排索引）。
+- **tag_to_nodes**：保存每个标签对应的节点列表（倒排索引）。
+
+游走过程：增加了 `p_tag_walk` 参数，用于控制游走时选择邻居节点和通过标签游走的概率。当通过标签游走时，随机选择一个与当前节点关联的标签，从该标签下的节点中随机选择一个新的节点。
+
+5. **随机游走**
+
+基于别名采样表执行随机游走，并返回游走序列。游走函数根据设定的概率 `p_tag_walk` 来决定是通过邻居游走还是通过标签游走。
+代码实现：
+``` python
+def deepwalk_walk(self, walk_length, start_node):
+    G = self.graph
+    alias_nodes = self.alias_nodes
+    walk = [start_node]
+    while len(walk) < walk_length:
+        cur = walk[-1]
+        cur_nbrs = list(G.neighbors(cur))
+        if len(cur_nbrs) > 0:
+            idx = alias_sample(alias_nodes[cur][0], alias_nodes[cur][1])
+            walk.append(cur_nbrs[idx])
+        else:
+            break
+    return walk
+``` 
+
+6. **多进程模拟**
+
+为了提升效率，支持使用多进程进行游走模拟。每个进程负责一部分节点的游走。
+代码实现：
+``` python
+def simulate_walks(self, num_walks, walk_length, workers, output_file):
+    G = self.graph
+    nodes = list(G.nodes())
+    results = Parallel(n_jobs=workers)(
+        delayed(self._simulate_walks)(nodes, num_walks // workers, walk_length)
+        for _ in range(workers)
+    )
+    walks = list(itertools.chain(*results))
+    self.save_walks_to_file(walks, output_file)
+``` 
+
+## 使用说明
+
+1. **环境配置**
+
+首先需要安装项目所依赖的Python库。可以通过以下命令安装：
+``` bash
+pip install numpy networkx joblib tqdm
+``` 
+
+2. **运行DeepWalk**
+
+可以通过命令行运行 deepwalk.py，提供必要的参数：
+``` bash
+python deepwalk.py --edge-file <path_to_edge_file> --num-walks <num_walks> --walk-length <walk_length> --workers <num_workers> --output-file <output_file> [--use-softmax] [--temperature <temperature>]
+``` 
+
+3. **示例**
+
+假设我们有一个边文件 data/edge.txt，并希望使用Softmax加权采样，温度为0.5，进行10次随机游走，游走长度为40，使用4个工作线程。可以通过以下命令运行：
+``` bash
+python deepwalk.py \
+    --edge-file path_to_edge_file.txt \
+    --node-tag-file path_to_node_tag_file.txt \
+    --num-walks 10 \
+    --walk-length 40 \
+    --workers 4 \
+    --p-tag-walk 0.2 \
+    --output-file path_to_output_walks.txt
+``` 
+
+4. **使用 run.sh 自动运行**
+
+``` bash
+sh run.sh
+``` 
+
+
+## 输出格式
+
+生成的随机游走序列将保存在指定的输出文件中，每一行表示一次游走的结果，格式如下：
+``` 
+1 2 3 4 5 ...
+2 3 4 1 6 ...
+...
+``` 
+
+## 参考
+``` 
+[DeepWalk: Online Learning of Social Representations](https://arxiv.org/abs/1403.6652)
+``` 
+
+## 代码结构概述
+
+该项目的核心在于对DeepWalk算法的扩展，通过标签游走机制提高了内容推荐的多样性。以下是源码的主要模块：
+
+1. **Graph Construction**：用于从边文件中构建无向图。
+2. **Alias Sampling Table Creation**：预处理每个节点的邻居信息以加速随机游走。
+3. **Softmax and Temperature Control**：增加了基于Softmax的采样机制，允许通过调整温度参数控制采样的多样性。
+4. **Tag-based Walks**：在标准的邻居随机游走基础上，加入了标签游走逻辑，通过内容标签来引导游走路径。
+5. **Multiprocessing Support**：利用多进程加速大规模游走模拟，提升算法的执行效率。
+
+## 扩展说明
+
+引入书籍标签游走机制的目的是在现有的基于用户行为的图嵌入算法中加入内容信息，尝试在以下方面提升推荐效果：
+
+- **提高内容多样性**：通过标签游走机制，使得推荐结果不仅基于用户的行为，还考虑到内容相似性。
+- **解决同质化问题**：缓解现有推荐系统中由于数据稀疏或用户行为单一导致的同质化现象。
+- **兼顾个性化**：在行为相似和内容相似之间取得平衡，使得用户能够获得更具个性化的推荐结果。
+
+## 关键技术点
+
+1. **标签游走机制（Tag-based Walks）**
+   - 通过设定 `p_tag_walk` 参数，控制游走时使用标签的概率，默认值为0.2，即20%的游走路径通过标签引导。
+   - 标签游走的实现方式是：随机选择一个与当前节点关联的标签，然后从该标签关联的节点集中选择下一个游走节点。这种方式能够有效地利用书籍的内容标签，提高内容推荐的相关性。
+
+2. **Softmax采样与温度控制**
+   - Softmax采样增加了温度参数，控制采样结果的多样性。较低的温度值使得采样更倾向于权重较大的邻居，而较高的温度值使得采样结果更为均匀分布。
+
+3. **多进程支持**
+   - 为了在大规模数据上提升随机游走的效率，采用了并行处理技术，每个进程负责一部分节点的游走任务。通过这种方式，算法可以充分利用多核CPU的性能，大大加快了图嵌入的训练速度。
+
@@ -0,0 +1,55 @@
+import numpy as np
+
+
+def create_alias_table(area_ratio):
+    """
+
+    :param area_ratio: sum(area_ratio)=1
+    :return: accept,alias
+    """
+    l = len(area_ratio)
+    area_ratio = [prop * l for prop in area_ratio]
+    accept, alias = [0] * l, [0] * l
+    small, large = [], []
+
+    for i, prob in enumerate(area_ratio):
+        if prob < 1.0:
+            small.append(i)
+        else:
+            large.append(i)
+
+    while small and large:
+        small_idx, large_idx = small.pop(), large.pop()
+        accept[small_idx] = area_ratio[small_idx]
+        alias[small_idx] = large_idx
+        area_ratio[large_idx] = area_ratio[large_idx] - \
+            (1 - area_ratio[small_idx])
+        if area_ratio[large_idx] < 1.0:
+            small.append(large_idx)
+        else:
+            large.append(large_idx)
+
+    while large:
+        large_idx = large.pop()
+        accept[large_idx] = 1
+    while small:
+        small_idx = small.pop()
+        accept[small_idx] = 1
+
+    return accept, alias
+
+
+def alias_sample(accept, alias):
+    """
+
+    :param accept:
+    :param alias:
+    :return: sample index
+    """
+    N = len(accept)
+    i = int(np.random.random()*N)
+    r = np.random.random()
+    if r < accept[i]:
+        return i
+    else:
+        return alias[i]
@@ -0,0 +1,266 @@
+import random
+import numpy as np
+import networkx as nx
+from joblib import Parallel, delayed
+import itertools
+from alias import create_alias_table, alias_sample
+from tqdm import tqdm
+import argparse
+import multiprocessing
+import logging
+import os
+
+def softmax(x, temperature=1.0):
+    """
+    计算带有温度参数的softmax，并加入防止溢出的技巧
+    """
+    x = np.array(x)
+    x_max = np.max(x)
+    exp_x = np.exp((x - x_max) / temperature)  # 加入temperature参数
+    return exp_x / np.sum(exp_x)
+
+class DeepWalk:
+    def __init__(self, edge_file, node_tag_file, use_softmax=True, temperature=1.0, p_tag_walk=0.5):
+        """
+        初始化DeepWalk实例，构建图和标签索引，预处理alias采样表
+        """
+        logging.info(f"Initializing DeepWalk with edge file: {edge_file} and node-tag file: {node_tag_file}")
+        self.graph = self.build_graph_from_edge_file(edge_file)
+        if node_tag_file:
+            self.node_to_tags, self.tag_to_nodes = self.build_tag_index(node_tag_file)
+        else:
+            self.node_to_tags = None
+            self.tag_to_nodes = None
+            
+        self.alias_nodes = {}
+        self.p_tag_walk = p_tag_walk
+        logging.info(f"Graph built with {self.graph.number_of_nodes()} nodes and {self.graph.number_of_edges()} edges.")
+
+        if use_softmax:
+            logging.info(f"Using softmax with temperature: {temperature}")
+            self.preprocess_transition_probs__softmax(temperature)
+        else:
+            logging.info("Using standard alias sampling.")
+            self.preprocess_transition_probs()
+
+    def build_graph_from_edge_file(self, edge_file):
+        """
+        从edge文件构建图
+        edge文件格式: bid1 \t bid2:weight1,bid2:weight2,...
+        """
+        G = nx.Graph()
+
+        # 打开edge文件并读取内容
+        with open(edge_file, 'r') as f:
+            for line in f:
+                parts = line.strip().split('\t')
+                if len(parts) != 2:
+                    continue
+                node, edges_str = parts
+                edges = edges_str.split(',')
+                
+                for edge in edges:
+                    nbr, weight = edge.split(':')
+                    try:
+                        node, nbr = int(node), int(nbr)
+                    except ValueError:
+                        continue
+                    weight = float(weight)
+                    
+                    # 检查图中是否已存在这条边
+                    if G.has_edge(node, nbr):
+                        # 如果已经有这条边，更新权重，累加新权重
+                        G[node][nbr]['weight'] += weight
+                    else:
+                        # 如果没有这条边，直接添加
+                        G.add_edge(node, nbr, weight=weight)
+
+        return G
+
+    def build_tag_index(self, node_tag_file):
+        """
+        构建节点-标签的正排和倒排索引
+        node_tag_file格式: book_id \t tag1,tag2,tag3
+        """
+        node_to_tags = {}
+        tag_to_nodes = {}
+
+        with open(node_tag_file, 'r') as f:
+            for line in f:
+                parts = line.strip().split('\t')
+                if len(parts) != 2:
+                    continue
+                node, tags_str = parts
+                try:
+                    node = int(node)
+                except ValueError:
+                    continue
+                # 只保留有过用户行为的node
+                if not node in self.graph:
+                    continue
+                tags = tags_str.split(',')
+                node_to_tags[node] = tags
+                for tag in tags:
+                    tag_to_nodes.setdefault(tag, []).append(node)
+
+        return node_to_tags, tag_to_nodes
+
+    def preprocess_transition_probs(self):
+        """
+        预处理节点的alias采样表，用于快速加权随机游走
+        """
+        G = self.graph
+
+        for node in G.nodes():
+            unnormalized_probs = [G[node][nbr].get('weight', 1.0) for nbr in G.neighbors(node)]
+            norm_const = sum(unnormalized_probs)
+            normalized_probs = [float(u_prob) / norm_const for u_prob in unnormalized_probs]
+            self.alias_nodes[node] = create_alias_table(normalized_probs)
+
+    def preprocess_transition_probs__softmax(self, temperature=1.0):
+        """
+        预处理节点的alias采样表，用于快速加权随机游走
+        """
+        G = self.graph
+
+        for node in G.nodes():
+            unnormalized_probs = [G[node][nbr].get('weight', 1.0) for nbr in G.neighbors(node)]
+            normalized_probs = softmax(unnormalized_probs, temperature)
+            self.alias_nodes[node] = create_alias_table(normalized_probs)
+
+    def deepwalk_walk(self, walk_length, start_node):
+        """
+        执行一次DeepWalk随机游走，基于alias方法加速，支持通过标签游走
+        """
+        G = self.graph
+        alias_nodes = self.alias_nodes
+        walk = [start_node]
+
+        while len(walk) < walk_length:
+            cur = walk[-1]
+
+            # 根据p_tag_walk的概率决定是通过邻居游走还是通过tag游走
+            if self.node_to_tags and random.random() < self.p_tag_walk and cur in self.node_to_tags:
+                walk = self.tag_based_walk(cur, walk)
+            else:
+                walk = self.neighbor_based_walk(cur, alias_nodes, walk)
+
+            if not walk:
+                break
+
+        return walk
+
+    def neighbor_based_walk(self, cur, alias_nodes, walk):
+        """
+        基于邻居的随机游走
+        """
+        G = self.graph
+        cur_nbrs = list(G.neighbors(cur))
+        if len(cur_nbrs) > 0:
+            idx = alias_sample(alias_nodes[cur][0], alias_nodes[cur][1])
+            walk.append(cur_nbrs[idx])
+        else:
+            return None
+        return walk
+
+    def tag_based_walk(self, cur, walk):
+        """
+        基于标签的随机游走
+        """
+        tags = self.node_to_tags[cur]
+        if not tags:
+            return None
+
+        # 随机选择一个tag
+        chosen_tag = random.choice(tags)
+
+        # 获取该tag下的节点列表
+        nodes_with_tag = self.tag_to_nodes.get(chosen_tag, [])
+        if not nodes_with_tag:
+            return None
+
+        # 随机选择一个节点
+        chosen_node = random.choice(nodes_with_tag)
+        walk.append(chosen_node)
+        return walk
+
+    def simulate_walks(self, num_walks, walk_length, workers, output_file):
+        """
+        多进程模拟多次随机游走，并将游走结果保存到文件
+        """
+        G = self.graph
+        nodes = list(G.nodes())
+        num_walks_per_worker = max(1, num_walks // workers)
+        logging.info(f"Starting simulation with {num_walks_per_worker} walks per node, walk length {walk_length}, using {workers} workers.")
+
+        # 
+        # results = Parallel(n_jobs=workers)(
+        # results = Parallel(n_jobs=workers, backend='multiprocessing')(
+        # results = Parallel(n_jobs=workers, backend='loky')(
+        results = Parallel(n_jobs=workers)(
+            delayed(self._simulate_walks)(nodes, num_walks_per_worker, walk_length)
+            for _ in range(workers)
+        )
+        walks = list(itertools.chain(*results))
+
+        # 保存游走结果到文件
+        self.save_walks_to_file(walks, output_file)
+
+    def _simulate_walks(self, nodes, num_walks, walk_length):
+        
+        """
+        模拟多次随机游走
+        """
+        logging.info(f"_simulate_walks started, num_walks:{num_walks}, walk_length:{walk_length}")
+        walks = []
+        for i in range(num_walks):
+            logging.info(f"_simulate_walks run num_walks of {i}.")
+            random.shuffle(nodes)
+            for node in nodes:
+                walks.append(self.deepwalk_walk(walk_length=walk_length, start_node=node))
+        return walks
+
+    def save_walks_to_file(self, walks, output_file):
+        """
+        将游走结果保存到文件，按Word2Vec的输入格式
+        """
+        logging.info(f"Saving walks to file: {output_file}")
+        with open(output_file, 'w') as f:
+            for walk in walks:
+                walk_str = ' '.join(map(str, walk))
+                f.write(walk_str + '\n')
+        logging.info(f"Successfully saved {len(walks)} walks to {output_file}.")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run DeepWalk with tag-based random walks")
+    parser.add_argument('--edge-file', type=str, required=True, help="Path to the edge file") # ../../fetch_data/data/edge.txt.20240923
+    parser.add_argument('--node-tag-file', type=str, help="Path to the node-tag file")
+    parser.add_argument('--num-walks', type=int, default=100, help="Number of walks per node (default: 10)")
+    parser.add_argument('--walk-length', type=int, default=40, help="Length of each walk (default: 40)")
+    parser.add_argument('--workers', type=int, default=multiprocessing.cpu_count() - 1, help="Number of workers (default: CPU cores - 1)")
+    parser.add_argument('--use-softmax', action='store_true', help="Use softmax-based alias sampling (default: False)")
+    parser.add_argument('--temperature', type=float, default=1.0, help="Temperature for softmax (default: 1.0)")
+    parser.add_argument('--p-tag-walk', type=float, default=0.2, help="Probability to walk through tag-based neighbors (default: 0.5)")
+    parser.add_argument('--output-file', type=str, required=True, help="Path to save the walks file")
+
+    args = parser.parse_args()
+
+    # 初始化日志记录
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=logging.INFO)
+
+    # 初始化DeepWalk实例，传入边文件和节点标签文件
+    deepwalk = DeepWalk(
+        edge_file=args.edge_file,
+        node_tag_file=args.node_tag_file,
+        use_softmax=args.use_softmax,
+        temperature=args.temperature,
+        p_tag_walk=args.p_tag_walk
+    )
+
+    # 模拟随机游走并将结果保存到文件
+    deepwalk.simulate_walks(
+        num_walks=args.num_walks,
+        walk_length=args.walk_length,
+        workers=args.workers,
+        output_file=args.output_file
+    )
@@ -0,0 +1,75 @@
+行为很稀疏的话（uid和item_id的关系少），但是user有机构ID和机构类型，item有tag，“Node2Vec适合更复杂的图结构，特别是在需要捕捉局部和全局结构特性时表现更好。在用户有额外属性（如机构信息），物品有标签的场景下，通过调整游走策略，Node2Vec可以更好地利用这些额外信息，缓解行为稀疏问题。
+”如何设置参数，以达到比deepwalk更好的效果？
+
+
+
+在行为稀疏的情况下，尤其是当用户（uid）和物品（item_id）的交互关系较少，但用户具有额外的属性（如机构ID、机构类型），物品具有标签（tag）时，使用 Node2Vec 相比 DeepWalk 的一个显著优势是它可以通过控制随机游走的策略，权衡局部和全局结构的影响，从而更好地捕捉复杂图结构中的信息。
+Node2Vec 参数设置
+
+Node2Vec 的核心参数是：
+p（返回参数）：控制随机游走返回上一个节点的概率。它影响了游走的深度优先搜索（DFS）倾向。
+当 p > 1 时，随机游走更倾向于避开之前的节点，类似于 DFS，有助于探索更广的邻居（远离局部结构）。
+当 p < 1 时，随机游走更可能返回之前的节点，有助于捕捉局部的结构信息。
+q（进出参数）：控制随机游走的广度优先搜索（BFS）倾向，决定了在游走时是更倾向于在局部邻域内游走，还是探索远处的节点。
+当 q > 1 时，游走更倾向于广度优先搜索（BFS），更关注局部的邻域结构。
+当 q < 1 时，游走更倾向于深度优先搜索（DFS），探索更远的节点，捕捉更全局的结构信息。
+
+通过调整 p 和 q，你可以为图中的不同节点类型设定不同的偏好，特别是在用户有机构ID、机构类型，物品有标签的场景下，通过这种方式可以更好地缓解交互行为稀疏的问题。
+参数设置的思路
+
+在这种场景下，用户与物品的交互关系较少，但用户有机构ID和类型，物品有标签。你可以通过以下方式设置参数：
+用户与物品的关系：
+行为稀疏时，由于用户与物品的直接交互少，你希望游走过程中能更加深入探索相对远的节点（如通过机构ID连接的用户），因此可以设置 p > 1，即让游走更偏向远离之前访问的节点，进一步探索与物品或其他用户的关系。
+用户与机构ID、机构类型的关系：
+机构ID和机构类型与用户的关系属于更强的局部结构，意味着用户往往在同一个机构或相同类型的机构下具有相似的行为。此时，你可以设置 q > 1，让游走偏向广度优先搜索（BFS），更深入地探索用户与其所在机构相关的节点，帮助更好地捕捉局部相似性。
+物品与标签的关系：
+标签代表了物品的一类特性，物品可能会与多个标签有关联。在这种情况下，适当地设置 q > 1（广度优先）可以确保游走能够探索更多相似标签的物品，发现同类物品的关联性。
+整体游走策略：
+如果你希望平衡探索局部和全局信息，可以从 p=1 和 q=1 开始，进行实验调整：
+局部信息捕捉较为重要时（如用户-机构、物品-标签）：倾向于设置 q > 1，增加广度优先搜索，捕捉局部邻域的关联性。
+行为数据较为稀疏时（需要探索更多远处节点）：设置 p > 1，鼓励更广范围的随机游走，捕捉较远的关系。
+
+具体参数调整思路
+
+稀疏行为下，增加深度搜索：
+设置 p > 1，例如 p = 2，这样当游走回到用户或物品节点时，倾向于探索新的关系，而不是频繁返回到同一个节点。
+捕捉用户的局部结构（机构关系、机构类型）：
+设置 q > 1，例如 q = 2，这将增强游走在用户相关的机构节点之间的广度搜索，捕捉用户与其机构的紧密联系，改善行为稀疏时的模型表现。
+进一步平衡全局和局部信息：
+如果 p = 2 和 q = 1 表现不佳，进一步调试 q 的值，例如设置 q = 0.5，这会使游走更像深度优先搜索（DFS），在捕捉局部结构的同时，也能探索更远的节点。
+
+代码实现
+
+在代码中，通过 Node2Vec 设置 p 和 q 参数来控制游走策略。
+python
+from node2vec import Node2Vec
+
+# 初始化 Node2Vec 模型，设置 p 和 q 参数
+node2vec = Node2Vec(G, dimensions=64, walk_length=30, num_walks=200, p=2, q=2, workers=4)
+
+# 训练模型
+model = node2vec.fit(window=10, min_count=1, batch_words=4)
+
+# 获取嵌入
+user1_embedding = model.wv['user1']
+print(f"user1 embedding: {user1_embedding}")
+python
+
+调优建议
+
+基线参数：可以从 p=1，q=1 开始，这相当于 DeepWalk 的行为，不做游走策略上的区分。
+局部与全局结构的平衡：
+p > 1：帮助探索较远的节点，适用于关系稀疏的情况。
+q > 1：有助于捕捉局部结构信息（如机构和标签），提升游走在相关节点的深度。
+实验迭代：通过实验调整 p 和 q 的值，寻找在稀疏数据场景下的最佳平衡，常见的实验组合有：
+p = 1，q = 2：偏向局部结构。
+p = 2，q = 1：更倾向探索全局结构。
+p = 2，q = 2：平衡局部和全局探索。
+
+总结
+
+在行为稀疏的情况下，Node2Vec 相较于 DeepWalk 可以通过参数 p 和 q 来调控游走策略：
+p > 1：探索更多远的节点，有助于缓解行为稀疏。
+q > 1：在局部节点结构上进行更多广度优先搜索，捕捉局部结构关系（如用户与机构，物品与标签的关系）。
+
+这种灵活性使得 Node2Vec 在复杂图结构（如有用户属性和物品标签）下具有更强的表达能力，从而可以取得比 DeepWalk 更好的效果。
 \ No newline at end of file
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+
+# 清理老数据
+find . -type d -name 'output.bak.*' -ctime +180 -exec rm -rf {} \;
+find logs/ -type f -mtime +180 -exec rm -f {} \;
+
+if [ -d "output" ]; then
+  # 获取当前时间戳，格式为年-月-日_时-分-秒
+  timestamp=$(date +%Y-%m-%d_%H-%M-%S)
+  # 重命名目录
+  mv output "output.bak.${timestamp}"
+fi
+
+mkdir -p output
+
+
+# 定义参数
+EDGE_FILE="../../fetch_data/data/edge.txt.all"       # 边文件的路径
+# EDGE_FILE="../../fetch_data/data/edge.txt.20240226"       # 边文件的路径
+NUM_WALKS=100                                        # 每个节点的随机游走次数
+WALK_LENGTH=40                                       # 每次游走的长度
+WORKERS=$(($(nproc) - 2))                            # 并行工作的线程数,cpu个数-2
+WORKERS=$((WORKERS < 40 ? WORKERS : 40))             # 
+USE_SOFTMAX="--use-softmax"                          # 是否使用softmax
+TEMPERATURE=1.0                                      # softmax的温度参数
+OUTPUT_FILE="output/walks.txt"                       # 输出文件
+
+# 运行DeepWalk程序
+python deepwalk.py --edge-file $EDGE_FILE \
+                   --num-walks $NUM_WALKS \
+                   --walk-length $WALK_LENGTH \
+                   --workers $WORKERS \
+                   $USE_SOFTMAX \
+                   --temperature $TEMPERATURE \
+                   --output-file $OUTPUT_FILE \
+                   --node-tag-file ../../tags/output/filtered_books.tags
+                   
+# 输出 bid_top_similar.txt 和 bid_embeddings.txt
+python w2v.py  --input-file output/walks.txt --output-dir output/ --workers $WORKERS
+
@@ -0,0 +1,120 @@
+import logging
+import argparse
+from gensim.models import Word2Vec
+import os
+import multiprocessing
+
+"""
+说明
+
+输入文件格式：
+--input-file：输入的文件路径，文件内容每一行是一个空格分隔的 bid 序列（即一个随机游走结果，或者直接是一个用户行为session）。
+输出文件格式：
+--output-dir：输出的目录路径，保存嵌入向量和相似 bid 的文件。
+生成两个文件：
+bid_embeddings.txt：每个 bid 的嵌入向量，格式为 bid embedding_vector，例如：
+123 0.12 0.34 0.56 ... 0.78
+456 0.23 0.45 0.67 ... 0.89
+bid_top_similar.txt：每个 bid 最相似的 top K 个 bid，格式为 bid similar_bid1:similarity1 similar_bid2:similarity2 ...，例如：
+123 456:0.89 789:0.88 101:0.87 ...
+456 123:0.89 678:0.85 234:0.84 ...
+命令行参数：
+--embedding-size：指定 Word2Vec 嵌入向量的维度，默认为 128。
+--window：Word2Vec 模型的窗口大小，控制词的上下文范围，默认为 5。
+--min-count：忽略词频低于该值的 bid，默认是 1，即不忽略任何 bid。
+--workers：并行计算的线程数量，默认为 4。
+--top-k：每个 bid 输出的最相似的 top K bid，默认是 200。
+
+
+执行示例
+
+假设：
+输入文件路径是 input_sentences.txt
+输出目录是 output/
+
+那么可以使用以下命令：
+bash
+python word2vec_bid_similarity.py --input-file input_sentences.txt --output-dir output/ --embedding-size 128 --top-k 200
+
+
+依赖项
+
+请确保安装了以下依赖项：
+bash
+pip install gensim
+"""
+
+def train_word2vec(input_file, output_dir, embedding_size=128, window=5, min_count=1, workers=None, top_k=200, epochs=5):
+    """
+    训练Word2Vec模型，并保存每个bid的embedding及top K相似的bid。
+    
+    :param input_file: 句子文件路径
+    :param output_dir: 输出文件的目录路径
+    :param embedding_size: 嵌入维度大小
+    :param window: Word2Vec中的窗口大小
+    :param min_count: Word2Vec中忽略频次低于min_count的词
+    :param workers: 使用的线程数，如果为None，则设置为cpu_count-2
+    :param top_k: 每个bid的最相似bid的数量
+    :param epochs: 训练的epoch数量
+    """
+    # 如果未设置workers，默认使用CPU核心数-2
+    if workers is None:
+        workers = max(1, multiprocessing.cpu_count() - 2)
+    
+    # 检查输出目录是否存在，不存在则创建
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    logging.info(f"Loading sentences from {input_file}")
+    # 读取输入文件，格式是每行一个bid序列
+    sentences = []
+    with open(input_file, 'r') as f:
+        for line in f:
+            sentences.append(line.strip().split())
+
+    # 训练Word2Vec模型
+    logging.info(f"Training Word2Vec model with embedding size {embedding_size}, window {window}, epochs {epochs}, workers {workers}")
+    model = Word2Vec(sentences, vector_size=embedding_size, window=window, min_count=min_count, workers=workers, epochs=epochs)
+
+    # 保存每个bid的embedding
+    embedding_file = os.path.join(output_dir, "bid_embeddings.txt")
+    logging.info(f"Saving embeddings to {embedding_file}")
+    with open(embedding_file, 'w') as f_out:
+        for bid in model.wv.index_to_key:
+            vector = model.wv[bid]
+            f_out.write(f"{bid}\t{','.join(map(str, vector))}\n")
+
+    # 保存每个bid的top K相似bid
+    similar_file = os.path.join(output_dir, "bid_top_similar.txt")
+    logging.info(f"Saving top {top_k} similar bids for each bid to {similar_file}")
+    with open(similar_file, 'w') as f_out:
+        for bid in model.wv.index_to_key:
+            similar_bids = model.wv.most_similar(bid, topn=top_k)
+            similar_bids_str = ','.join([f"{similar_bid[0]}:{round(similar_bid[1], 4)}" for similar_bid in similar_bids])
+            f_out.write(f"{bid}\t{similar_bids_str}\n")
+    
+    logging.info("Process completed successfully.")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Train Word2Vec model and calculate bid similarity.")
+    parser.add_argument('--input-file', type=str, required=True, help="Path to the input sentence file")
+    parser.add_argument('--output-dir', type=str, required=True, help="Directory to save output embeddings and similarity results")
+    parser.add_argument('--embedding-size', type=int, default=128, help="Size of the bid embedding vectors (default: 128)")
+    parser.add_argument('--window', type=int, default=5, help="Window size for Word2Vec (default: 5)")
+    parser.add_argument('--min-count', type=int, default=1, help="Minimum frequency of bids to be considered (default: 1)")
+    parser.add_argument('--workers', type=int, default=None, help="Number of workers (default: cpu_count-2)")
+    parser.add_argument('--top-k', type=int, default=200, help="Number of top similar bids to output (default: 200)")
+    parser.add_argument('--epochs', type=int, default=5, help="Number of epochs to train the model (default: 5)")
+
+    args = parser.parse_args()
+
+    # 初始化日志
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=logging.INFO)
+
+    # 执行训练和保存结果
+    train_word2vec(input_file=args.input_file, output_dir=args.output_dir, 
+                   embedding_size=args.embedding_size, window=args.window, 
+                   min_count=args.min_count, workers=args.workers, top_k=args.top_k, epochs=args.epochs)
+
+
+# python w2v.py --input-file input_sentences.txt --output-dir output/ --embedding-size 128 --top-k 200 --epochs 10
@@ -0,0 +1,122 @@
+# README: 基于用户行为Session的Word2Vec模型训练与电子书推荐系统
+
+## 目录
+
+1. [项目概要](#项目概要)
+2. [技术方案介绍](#技术方案介绍)
+3. [代码细节说明](#代码细节说明)
+4. [词向量与推荐系统的关联](#词向量与推荐系统的关联)
+
+---
+
+## 项目概要
+
+本项目基于用户行为数据（Session）训练Word2Vec模型，用于电子书推荐系统。通过用户在一天内的阅读行为形成的Session数据，使用Word2Vec模型生成每本电子书的向量表示（embedding），并通过计算相似度来推荐书籍。
+
+整个流程包括读取用户行为Session，训练Word2Vec模型，生成书籍的嵌入向量，并为每本书籍计算Top K相似书籍。模型学习的向量能够表达书籍之间的语义相似性，从而提高推荐系统的推荐准确性和个性化。
+
+---
+
+## 技术方案介绍
+
+### 数据与Session定义
+
+在电子书推荐场景中，用户一天内交互的书籍可以看作一个Session，即用户在一天内阅读或浏览的电子书形成一个序列。每个Session包含一组书籍ID，代表用户的行为轨迹。通过将这些Session输入Word2Vec模型，模型将学习到书籍之间的隐含关系，能够表示书籍的相似性。
+
+### 词向量模型选择
+
+当前实现中使用了`Word2Vec`模型的Skip-gram训练方式，该模型从上下文中预测词语（在此场景下即书籍）的关系。具体的实现基于`gensim`库，通过窗口大小（window）和嵌入维度（embedding size）等参数控制模型效果。
+
+通过训练，模型将生成每本书籍的向量表示，并可以基于这些向量计算出每本书籍的Top K相似书籍。这种相似性可以应用到推荐系统中，用于向用户推荐相关或类似的电子书。
+
+---
+
+## 代码细节说明
+
+下面我们对当前已有的训练代码及其主要部分进行说明。
+
+### 1. **代码功能**
+
+该代码通过加载包含用户Session（即用户一天内阅读的电子书ID）的输入文件，训练一个Word2Vec模型。随后，它保存了每个书籍ID对应的嵌入向量（embedding）及每本书籍的Top K相似书籍。
+
+代码的主要功能包括：
+
+- 读取用户行为数据，并将每个Session作为一行句子输入到Word2Vec模型中。
+- 训练Word2Vec模型，并保存每个书籍ID的嵌入向量。
+- 基于训练好的模型，计算每本书籍的Top K相似书籍，并输出结果。
+
+### 2. **主要代码逻辑**
+
+```python
+def train_word2vec(input_file, output_dir, embedding_size=128, window=5, min_count=1, workers=4, top_k=200):
+    """
+    训练Word2Vec模型，并保存每个bid的embedding及top K相似的bid。
+    
+    :param input_file: 句子文件路径
+    :param output_dir: 输出文件的目录路径
+    :param embedding_size: 嵌入维度大小
+    :param window: Word2Vec中的窗口大小
+    :param min_count: Word2Vec中忽略频次低于min_count的词
+    :param workers: 使用的线程数
+    :param top_k: 每个bid的最相似bid的数量
+    """
+```
+
+**输入参数解释：**
+
+- `input_file`: 用户行为数据文件路径，文件内容为每行一个Session，Session是书籍ID的序列。
+- `output_dir`: 输出目录路径，保存嵌入向量及相似度结果的目录。
+- `embedding_size`: 词向量的维度大小，控制每本书籍ID最终的向量维度（默认为128）。
+- `window`: Word2Vec中的窗口大小，决定了模型如何在上下文中学习书籍之间的关系。
+- `min_count`: 最小词频，忽略在Session中出现频率低于该值的书籍。
+- `workers`: 用于加速模型训练的并行线程数量。
+- `top_k`: 每本书籍输出的Top K相似书籍数量。
+
+**代码逻辑概述：**
+
+1. **检查输出目录**：如果输出目录不存在，则创建该目录。
+2. **加载数据**：从`input_file`中读取Session数据，每一行表示用户一天内阅读的书籍序列。
+3. **训练Word2Vec模型**：使用`gensim`库中的`Word2Vec`方法，基于用户行为数据训练书籍的向量表示。
+4. **保存嵌入向量**：将每个书籍ID的嵌入向量保存到指定文件中。
+5. **计算Top K相似书籍**：对每本书籍，基于向量计算其最相似的Top K书籍，并将结果保存到文件中。
+
+### 3. **核心代码片段说明**
+
+- **训练Word2Vec模型**：
+  ```python
+  model = Word2Vec(sentences, vector_size=embedding_size, window=window, min_count=min_count, workers=workers)
+  ```
+  这行代码使用`Word2Vec`方法训练模型，基于用户行为数据生成书籍的嵌入向量。`vector_size`表示嵌入向量的维度，`window`表示窗口大小，`min_count`控制忽略频率低的书籍。
+
+- **保存嵌入向量**：
+  ```python
+  with open(embedding_file, 'w') as f_out:
+      for bid in model.wv.index_to_key:
+          vector = model.wv[bid]
+          f_out.write(f"{bid} {' '.join(map(str, vector))}\n")
+  ```
+  该片段将训练好的每本书籍的向量保存到文件中。每一行是一个书籍ID及其对应的向量。
+
+- **计算Top K相似书籍**：
+  ```python
+  similar_bids = model.wv.most_similar(bid, topn=top_k)
+  ```
+  使用`most_similar`方法计算每本书籍的Top K相似书籍，这些书籍基于向量空间的相似度进行排序，最相似的书籍会靠近在推荐列表中。
+
+---
+
+## 词向量与推荐系统的关联
+
+### 场景描述
+
+在当前业务场景中，用户通过电子书平台阅读电子书，系统基于用户的阅读行为生成推荐列表。通过Word2Vec模型，系统能够学习书籍之间的隐含关系，并为用户推荐与其已阅读书籍相似的电子书。
+
+### 推荐逻辑
+
+利用Word2Vec模型生成的书籍向量，我们可以基于以下推荐逻辑为用户提供个性化的电子书推荐：
+
+1. **相似书籍推荐**：当用户浏览或阅读了一本书后，系统可以根据该书的向量找到相似的书籍，并推荐给用户。
+2. **用户行为扩展**：基于用户的一段阅读历史，系统可以将其历史中的书籍向量组合起来，找到与其行为最相似的其他书籍进行推荐。
+3. **冷启动问题**：对于新书籍或新用户，可以通过书籍的内容标签或其他特征将其引入到向量空间，从而利用已有的模型进行推荐。
+
+这种方式能够提高推荐的准确性和相关性，帮助用户发现更多符合其兴趣的书籍。
@@ -0,0 +1,46 @@
+import json
+import sys
+
+
+def main(input_file, output_file, max_sentence_length):
+    """
+    主函数，读取输入文件，处理每一行json，将结果写入输出文件。
+    
+    参数：
+    - input_file: 输入文件路径
+    - output_file: 输出文件路径
+    - max_sentence_length: 最大句子长度
+    """
+    max_sentence_length = int(max_sentence_length)
+    with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
+        for line in infile:
+            # 去除空行
+            line = line.strip()
+            if not line:
+                continue
+            
+            # 处理当前行
+            uid, session = line.split('\t')
+            data = json.loads(session)
+            keys = list(data.keys())
+            if len(keys) < 3:
+                continue
+            
+            # 如果keys数量超出最大句子长度，则按最大句子长度拆分
+            sentences = [keys[i:i + max_sentence_length] for i in range(0, len(keys), max_sentence_length)]
+            
+            # 写入每个分割后的句子到输出文件
+            for sentence in sentences:
+                outfile.write(" ".join(sentence) + "\n")
+
+if __name__ == "__main__":
+    # 从命令行读取参数
+    if len(sys.argv) != 4:
+        print("用法: python prepare_data.py <输入文件> <输出文件> <最大句子长度>")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2]
+    max_sentence_length = sys.argv[3]
+
+    main(input_file, output_file, max_sentence_length)
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# 清理老数据
+find . -type d -name 'output.bak.*' -ctime +180 -exec rm -rf {} \;
+find logs/ -type f -mtime +180 -exec rm -f {} \;
+
+if [ -d "output" ]; then
+  # 获取当前时间戳，格式为年-月-日_时-分-秒
+  timestamp=$(date +%Y-%m-%d_%H-%M-%S)
+  # 重命名目录
+  mv output "output.bak.${timestamp}"
+fi
+
+
+mkdir -p output
+
+
+# 准备数据
+python3 prepare_data.py ../../fetch_data/data/session.txt.all output/session.txt.all 100
+
+# 输出 bid_top_similar.txt 和 bid_embeddings.txt
+# epochs为5的适合，embedding非常集中，top200的相似书籍相似度都在0.99以上，调到10 top1~top200相似度大概为0.9~0.8，20的时候，top1~top200相似度大概在0.75~0.6
+python3 w2v.py  --input-file output/session.txt.all --output-dir output/ --epochs 20
+
@@ -0,0 +1,120 @@
+import logging
+import argparse
+from gensim.models import Word2Vec
+import os
+import multiprocessing
+
+"""
+说明
+
+输入文件格式：
+--input-file：输入的文件路径，文件内容每一行是一个空格分隔的 bid 序列（即一个随机游走结果，或者直接是一个用户行为session）。
+输出文件格式：
+--output-dir：输出的目录路径，保存嵌入向量和相似 bid 的文件。
+生成两个文件：
+bid_embeddings.txt：每个 bid 的嵌入向量，格式为 bid embedding_vector，例如：
+123 0.12 0.34 0.56 ... 0.78
+456 0.23 0.45 0.67 ... 0.89
+bid_top_similar.txt：每个 bid 最相似的 top K 个 bid，格式为 bid similar_bid1:similarity1 similar_bid2:similarity2 ...，例如：
+123 456:0.89 789:0.88 101:0.87 ...
+456 123:0.89 678:0.85 234:0.84 ...
+命令行参数：
+--embedding-size：指定 Word2Vec 嵌入向量的维度，默认为 128。
+--window：Word2Vec 模型的窗口大小，控制词的上下文范围，默认为 5。
+--min-count：忽略词频低于该值的 bid，默认是 1，即不忽略任何 bid。
+--workers：并行计算的线程数量，默认为 4。
+--top-k：每个 bid 输出的最相似的 top K bid，默认是 200。
+
+
+执行示例
+
+假设：
+输入文件路径是 input_sentences.txt
+输出目录是 output/
+
+那么可以使用以下命令：
+bash
+python word2vec_bid_similarity.py --input-file input_sentences.txt --output-dir output/ --embedding-size 128 --top-k 200
+
+
+依赖项
+
+请确保安装了以下依赖项：
+bash
+pip install gensim
+"""
+
+def train_word2vec(input_file, output_dir, embedding_size=128, window=5, min_count=1, workers=None, top_k=200, epochs=5):
+    """
+    训练Word2Vec模型，并保存每个bid的embedding及top K相似的bid。
+    
+    :param input_file: 句子文件路径
+    :param output_dir: 输出文件的目录路径
+    :param embedding_size: 嵌入维度大小
+    :param window: Word2Vec中的窗口大小
+    :param min_count: Word2Vec中忽略频次低于min_count的词
+    :param workers: 使用的线程数，如果为None，则设置为cpu_count-2
+    :param top_k: 每个bid的最相似bid的数量
+    :param epochs: 训练的epoch数量
+    """
+    # 如果未设置workers，默认使用CPU核心数-2
+    if workers is None:
+        workers = max(1, multiprocessing.cpu_count() - 2)
+    
+    # 检查输出目录是否存在，不存在则创建
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    logging.info(f"Loading sentences from {input_file}")
+    # 读取输入文件，格式是每行一个bid序列
+    sentences = []
+    with open(input_file, 'r') as f:
+        for line in f:
+            sentences.append(line.strip().split())
+
+    # 训练Word2Vec模型
+    logging.info(f"Training Word2Vec model with embedding size {embedding_size}, window {window}, epochs {epochs}, workers {workers}")
+    model = Word2Vec(sentences, vector_size=embedding_size, window=window, min_count=min_count, workers=workers, epochs=epochs)
+
+    # 保存每个bid的embedding
+    embedding_file = os.path.join(output_dir, "bid_embeddings.txt")
+    logging.info(f"Saving embeddings to {embedding_file}")
+    with open(embedding_file, 'w') as f_out:
+        for bid in model.wv.index_to_key:
+            vector = model.wv[bid]
+            f_out.write(f"{bid}\t{','.join(map(str, vector))}\n")
+
+    # 保存每个bid的top K相似bid
+    similar_file = os.path.join(output_dir, "bid_top_similar.txt")
+    logging.info(f"Saving top {top_k} similar bids for each bid to {similar_file}")
+    with open(similar_file, 'w') as f_out:
+        for bid in model.wv.index_to_key:
+            similar_bids = model.wv.most_similar(bid, topn=top_k)
+            similar_bids_str = ','.join([f"{similar_bid[0]}:{round(similar_bid[1], 4)}" for similar_bid in similar_bids])
+            f_out.write(f"{bid}\t{similar_bids_str}\n")
+    
+    logging.info("Process completed successfully.")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Train Word2Vec model and calculate bid similarity.")
+    parser.add_argument('--input-file', type=str, required=True, help="Path to the input sentence file")
+    parser.add_argument('--output-dir', type=str, required=True, help="Directory to save output embeddings and similarity results")
+    parser.add_argument('--embedding-size', type=int, default=128, help="Size of the bid embedding vectors (default: 128)")
+    parser.add_argument('--window', type=int, default=5, help="Window size for Word2Vec (default: 5)")
+    parser.add_argument('--min-count', type=int, default=1, help="Minimum frequency of bids to be considered (default: 1)")
+    parser.add_argument('--workers', type=int, default=None, help="Number of workers (default: cpu_count-2)")
+    parser.add_argument('--top-k', type=int, default=200, help="Number of top similar bids to output (default: 200)")
+    parser.add_argument('--epochs', type=int, default=5, help="Number of epochs to train the model (default: 5)")
+
+    args = parser.parse_args()
+
+    # 初始化日志
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', level=logging.INFO)
+
+    # 执行训练和保存结果
+    train_word2vec(input_file=args.input_file, output_dir=args.output_dir, 
+                   embedding_size=args.embedding_size, window=args.window, 
+                   min_count=args.min_count, workers=args.workers, top_k=args.top_k, epochs=args.epochs)
+
+
+# python w2v.py --input-file input_sentences.txt --output-dir output/ --embedding-size 128 --top-k 200 --epochs 10
@@ -0,0 +1,85 @@
+# 热门书籍索引生成项目
+
+## 项目简介
+本项目旨在根据机构的阅读行为数据（reading_time埋点数据）生成热门书籍索引，通过多种方法统计不同维度下的用户访问（UV）数据。项目支持基于机构（tenant）、机构所属行业（tenant_type）及书籍标签（tag）（包括category1和category2，当成tag同等处理）等不同维度进行统计和排名，从而生成热门书籍清单。并带有自动更新的软链接以方便外部访问。
+
+
+## 文件结构
+- `index_generation.py`：主程序代码，包含数据加载、UV处理、书单生成和输出等主要功能。
+- `logs/`：日志文件存放目录。
+- `output/`：程序生成的书单输出目录。
+
+## 输入数据
+### 1. 书籍属性数据 (`all_books.json`)
+- **路径**：`CONFIG['books_path']`
+- **内容**：每行包含一个书籍的 JSON 数据，主要字段为：
+  - `id`：书籍ID。
+  - `merged_tags`：书籍相关的标签列表，用逗号分隔。
+  
+### 2. 机构所属行业数据 (`tenants.json`)
+- **路径**：`CONFIG['tenants_path']`
+- **内容**：每行包含一个机构的 JSON 数据，主要字段为：
+  - `id`：机构ID。
+  - `tenant_type`：机构所属行业类型。
+
+### 3. 阅读行为数据 (`reading_time.json`)
+- **路径**：`CONFIG['base_dir']` 下的文件夹，文件名格式为 `reading_time.json.YYYYMMDD`。
+- **内容**：每行包含一个阅读行为的 JSON 数据，主要字段为：
+  - `user_id`：用户ID。
+  - `book_id`：书籍ID。
+  - `tenant_id`：机构ID。
+
+## 输出数据
+输出数据为生成的热门书籍列表，每个文件包含按指定维度统计的前 `N` 个书籍的排名结果：
+- 文件输出路径：`CONFIG['output_dir']`
+- 文件名格式：`<prefix>_<current_date>.txt`，并生成软链接至 `<prefix>.txt`。
+- 输出内容示例：`tenant_id book_id1:uv_count1,book_id2:uv_count2,...`
+
+### 输出文件类型
+1. `tenant_booklist.txt`：按机构（tenant）统计的热门书籍列表。
+2. `tenant_type_booklist.txt`：按机构所属行业（tenant_type）统计的热门书籍列表。
+3. `tag_booklist.txt`：按标签（tag）统计的热门书籍列表。
+
+## 配置参数
+### `CONFIG` 说明
+- `base_dir`：阅读数据文件的目录。
+- `books_path`：书籍属性数据文件路径。
+- `tenants_path`：机构所属行业数据文件路径。
+- `output_dir`：输出目录路径。
+- `days`：用于选择最近 `days` 天内的数据文件。
+- `top_n`：生成前 `N` 个热门书籍。
+- `tenant_type_ratio`：用于在机构数据不足时融合所属行业数据的权重比例。
+- `use_simple_uv_processing`：
+  - `True`：累加每天的 UV。
+  - `False`：以数据周期内总 UV 统计为准。
+
+## 计算逻辑
+1. **数据加载**
+   - 使用 `load_books_data()` 和 `load_tenants_data()` 分别加载书籍和机构的基本信息，确保各个 ID 均为字符串。
+   - 使用 `get_recent_files()` 获取最近 `days` 天的阅读数据文件列表。
+
+2. **UV 数据处理**
+   - `process_reading_data()`：简单 UV 统计，每条记录中的用户访问量直接累加。
+   - `process_reading_data_by_uv()`：用户 UV 去重统计，计算某书籍在一天内的 UV 数量。
+   - `CONFIG['use_simple_uv_processing']` 用于决定是否使用简单的累加逻辑。
+   
+3. **数据融合**
+   - 使用 `merge_tenant_uv_with_type_uv()` 将机构的 UV 数据与其所属行业的 UV 数据按比例进行融合，减小数据量较小的机构所带来的统计偏差。
+   
+4. **生成书单**
+   - `generate_top_booklist()` 根据 UV 统计数据生成指定维度的前 `N` 本热门书籍列表。
+   - 生成的书单文件分别保存机构、机构所属行业、标签维度的热门书籍排名。
+
+5. **输出与软链接**
+   - 使用 `write_output()` 将生成的书单写入指定文件，并更新软链接到最新文件。
+
+## 日志
+程序的所有日志信息输出至 `logs/index_generation.log`，主要记录数据加载、文件处理、UV 统计、文件写入等步骤的成功与错误信息，以便跟踪和排查问题。
+
+## 运行方法
+在终端中执行以下命令来运行主程序：
+```bash
+python main.py
+# 或者
+sh run.sh
+```
 \ No newline at end of file
@@ -0,0 +1,261 @@
+import os
+import json
+import glob
+import logging
+from collections import defaultdict, Counter
+from datetime import datetime, timedelta
+import shutil
+
+# 设置日志配置
+logging.basicConfig(
+    filename='logs/index_generation.log', 
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# 配置超参
+CONFIG = {
+    'base_dir': '../fetch_data/data/',
+    'books_path': '../fetch_data/meta_data/all_books.json',
+    'tenants_path': '../fetch_data/meta_data/tenants.json',
+    'output_dir': './output',
+    'days': 30,  # 天数，用于获取最近的文件
+    'top_n': 1000,  # 生成的前 N 个书单
+    'tenant_type_ratio': 0.01,  # 机构和所属行业融合的比例。可以解决机构的冷启动问题。机构内的行为数据越少，受到行业的影响越大。
+    'use_simple_uv_processing': True  # 是否使用简单UV处理逻辑
+                                    # 配置为True：则book的read UV统计规则为 每一天的UV的累加，
+                                    # 配置为False：则book的read UV统计规则为统计范围内所有天的UV，该方法更多的收到运营配置的曝光的影响，
+                                    # 默认为True
+}
+
+def load_json_files(path_pattern):
+    """根据通配符加载 JSON 文件"""
+    files = glob.glob(path_pattern)
+    data = []
+    for file in files:
+        with open(file, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    data.append(json.loads(line))
+                except json.JSONDecodeError:
+                    logging.error(f"Failed to parse JSON line in {file}: {line}")
+    return data
+
+def load_books_data(books_path):
+    """加载书籍属性词典，并将所有ID转换为字符串"""
+    books_data = {}
+    with open(books_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            book = json.loads(line)
+
+            tags = book.get('merged_tags', '')
+            category1 = book.get('category1', '')
+            category2 = book.get('category2', '')
+            combined_tags = ','.join(filter(lambda x: x not in [None, ''], [tags, category1, category2]))
+            books_data[str(book['id'])] = combined_tags  # 将book['id']转换为字符串
+
+    logging.info(f"Loaded {len(books_data)} books from {books_path}")
+    return books_data
+
+def load_tenants_data(tenants_path):
+    """加载机构所属行业词典，并将所有ID转换为字符串"""
+    tenants_data = {}
+    with open(tenants_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            tenant = json.loads(line)
+            tenant_type = tenant.get('tenant_type', '')
+            if not tenant_type:
+                tenant_type = ''
+            tenants_data[str(tenant['id'])] = tenant_type  # 将tenant['id']转换为字符串
+    logging.info(f"Loaded {len(tenants_data)} tenants from {tenants_path}")
+    return tenants_data
+
+def get_recent_files(base_dir, days=30):
+    """获取最近 days 天的文件"""
+    today = datetime.today()
+    recent_files = []
+    for i in range(days):
+        date_str = (today - timedelta(days=i)).strftime('%Y%m%d')
+        path_pattern = os.path.join(base_dir, f'reading_time.json.{date_str}')
+        recent_files.extend(glob.glob(path_pattern))
+    logging.info(f"Found {len(recent_files)} files for the last {days} days")
+    return recent_files
+
+def process_reading_data_by_uv(reading_files, books_data, tenants_data):
+    """使用用户UV数据处理阅读数据"""
+    tenant_uv = defaultdict(lambda: defaultdict(set))  # 使用集合来去重
+    tenant_type_uv = defaultdict(lambda: defaultdict(set))  # 使用集合来去重
+    tag_uv = defaultdict(lambda: defaultdict(set))  # 使用集合来去重
+
+    for file in reading_files:
+        with open(file, 'r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    record = json.loads(line.strip())
+                    user_id = str(record.get('user_id', ''))  # 将user_id转换为字符串
+                    book_id = str(record.get('book_id', ''))  # 将book_id转换为字符串
+                    tenant_id = str(record.get('tenant_id', ''))  # 将tenant_id转换为字符串
+
+                    if not book_id or not tenant_id or not user_id:
+                        continue
+
+                    tenant_uv[tenant_id][book_id].add(user_id)
+                    tenant_type = tenants_data.get(tenant_id, '')  # tenant_id已经是字符串
+                    tenant_type_uv[tenant_type][book_id].add(user_id)
+
+                    tags = books_data.get(book_id, '').split(',')
+                    for tag in tags:
+                        if tag:
+                            tag_uv[tag][book_id].add(user_id)
+
+                except json.JSONDecodeError:
+                    logging.error(f"Failed to parse JSON line in {file}: {line}")
+
+    # 转换为UV数量，即集合中user_id的数量
+    tenant_uv_count = {tenant: Counter({book: len(users) for book, users in books.items()})
+                       for tenant, books in tenant_uv.items()}
+    tenant_type_uv_count = {tenant_type: Counter({book: len(users) for book, users in books.items()})
+                            for tenant_type, books in tenant_type_uv.items()}
+    tag_uv_count = {tag: Counter({book: len(users) for book, users in books.items()})
+                    for tag, books in tag_uv.items()}
+
+    logging.info(f"Processed reading data, total tenants: {len(tenant_uv_count)}, tenant types: {len(tenant_type_uv_count)}, tags: {len(tag_uv_count)}")
+
+    return tenant_uv_count, tenant_type_uv_count, tag_uv_count
+
+def process_reading_data(reading_files, books_data, tenants_data):
+    """使用简单的UV累加逻辑处理阅读数据"""
+    tenant_uv = defaultdict(Counter)
+    tenant_type_uv = defaultdict(Counter)
+    tag_uv = defaultdict(Counter)
+    
+    for file in reading_files:
+        with open(file, 'r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    record = json.loads(line.strip())
+                    user_id = str(record.get('user_id', ''))  # 将user_id转换为字符串
+                    book_id = str(record.get('book_id', ''))  # 将book_id转换为字符串
+                    tenant_id = str(record.get('tenant_id', ''))  # 将tenant_id转换为字符串
+                    
+                    if not book_id or not tenant_id:
+                        continue
+
+                    tenant_uv[tenant_id][book_id] += 1
+                    tenant_type = tenants_data.get(tenant_id, '')  # tenant_id已经是字符串
+                    tenant_type_uv[tenant_type][book_id] += 1
+
+                    tags = books_data.get(book_id, '').split(',')
+                    for tag in tags:
+                        if tag:
+                            tag_uv[tag][book_id] += 1
+
+                except json.JSONDecodeError:
+                    logging.error(f"Failed to parse JSON line in {file}: {line}")
+    
+    logging.info(f"Processed reading data, total tenants: {len(tenant_uv)}, tenant types: {len(tenant_type_uv)}, tags: {len(tag_uv)}")
+    
+    return tenant_uv, tenant_type_uv, tag_uv
+
+def generate_top_booklist(counter_dict, top_n=1000):
+    """生成排序后的前 top_n booklist"""
+    result = {}
+    for key, counter in counter_dict.items():
+        top_books = counter.most_common(top_n)
+        if not key or len(top_books) == 0:
+            continue
+        result[key] = ','.join([f'{bid}:{uv}' for bid, uv in top_books])
+    return result
+
+def write_output(data, output_dir, prefix, current_date):
+    """写入输出文件，并生成软链接到 output 目录下"""
+    try:
+        output_file_path = os.path.join(output_dir, f'{prefix}_{current_date}.txt')
+        output_file_link = os.path.join(output_dir, f'{prefix}.txt')
+        
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        with open(output_file_path, 'w', encoding='utf-8') as f:
+            for key, booklist in data.items():
+                key.replace('\t', ' ')
+                if not key or not booklist:
+                    continue
+                f.write(f"{key}\t{booklist}\n")
+        
+        logging.info(f"Output written to {output_file_path}")
+
+        if os.path.islink(output_file_link) or os.path.exists(output_file_link):
+            os.remove(output_file_link)
+        
+        os.symlink(os.path.basename(output_file_path), output_file_link)
+        logging.info(f"Symlink created at {output_file_link} pointing to {output_file_path}")
+
+    except Exception as e:
+        logging.error(f"Error writing output or creating symlink: {str(e)}")
+
+def merge_tenant_uv_with_type_uv(tenant_uv, tenant_type_uv, tenants_data, ratio=CONFIG['tenant_type_ratio']):
+    """合并 tenant 的 UV 统计和其所属 tenant_type 的 UV 统计结果
+    
+    融合的目的：通过融合机构所属行业的UV数据，平滑处理小机构数据不足的情况，给予它们更多的行业UV权重    ，避免因数据量小而导致的统计偏差。
+    
+    ratio 参数控制行业 UV 统计数据在融合过程中所占的权重比例。较高的比例表示行业数据的影响较大，较低的比例则表示单个机构的数据占主导地位。
+    """
+    merged_tenant_uv = defaultdict(Counter)
+
+    for tenant_id, books_counter in tenant_uv.items():
+        # 获取该 tenant 的 tenant_type
+        tenant_type = tenants_data.get(tenant_id, '')
+        
+        # 获取该 tenant_type 下的 UV 统计
+        tenant_type_counter = tenant_type_uv.get(tenant_type, Counter())
+
+        # 合并 tenant 自身的 UV 统计和 tenant_type 的 UV 统计结果（乘以比例系数）
+        for book_id, uv_count in books_counter.items():
+            tenant_type_uv_adjusted = int(tenant_type_counter.get(book_id, 0) * ratio)
+            merged_tenant_uv[tenant_id][book_id] = uv_count + tenant_type_uv_adjusted
+
+    logging.info(f"Merged tenant UV with tenant type UV using ratio {ratio}")
+    return merged_tenant_uv
+
+def main():
+    # 获取当前日期
+    current_date = datetime.today().strftime('%Y%m%d')
+
+    # 加载书籍和机构数据
+    books_data = load_books_data(CONFIG['books_path'])
+    tenants_data = load_tenants_data(CONFIG['tenants_path'])
+    
+    # 获取最近配置的天数的阅读数据文件
+    reading_files = get_recent_files(CONFIG['base_dir'], days=CONFIG['days'])
+
+    # 根据配置选择UV处理逻辑
+    if CONFIG['use_simple_uv_processing']:
+        tenant_uv, tenant_type_uv, tag_uv = process_reading_data(reading_files, books_data, tenants_data)
+    else:
+        tenant_uv, tenant_type_uv, tag_uv = process_reading_data_by_uv(reading_files, books_data, tenants_data)
+
+    # 合并 tenant UV 和 tenant_type UV（使用配置的比例）
+    merged_tenant_uv = merge_tenant_uv_with_type_uv(tenant_uv, tenant_type_uv, tenants_data, ratio=CONFIG['tenant_type_ratio'])
+
+    # 生成前N本书的书单
+    tenant_booklist = generate_top_booklist(merged_tenant_uv, top_n=CONFIG['top_n'])
+    tenant_type_booklist = generate_top_booklist(tenant_type_uv, top_n=CONFIG['top_n'])
+    tag_booklist = generate_top_booklist(tag_uv, top_n=CONFIG['top_n'])
+
+    # 写入输出文件并生成软链接
+    write_output(tenant_booklist, CONFIG['output_dir'], 'tenant_booklist', current_date)
+    write_output(tenant_type_booklist, CONFIG['output_dir'], 'tenant_type_booklist', current_date)
+    write_output(tag_booklist, CONFIG['output_dir'], 'tag_booklist', current_date)
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,7 @@
+mkdir -p output
+mkdir -p logs
+python3 main.py
+
+# 清理output目录下365天以前的文件
+find output/ -type f -mtime +365 -exec rm -f {} \;
+find logs/ -type f -mtime +180 -exec rm -f {} \;
@@ -0,0 +1,88 @@
+import pandas as pd
+import math
+from collections import defaultdict
+from sqlalchemy import create_engine
+from db_service import create_db_connection
+import argparse
+
+def clean_text_field(text):
+    if pd.isna(text):
+        return ''
+    # 移除换行符、回车符，并替换其他可能导致CSV格式问题的字符
+    return str(text).replace('\r', ' ').replace('\n', ' ').replace('"', '""').strip()
+
+# 数据库连接配置
+host = 'selectdb-cn-wuf3vsokg05-public.selectdbfe.rds.aliyuncs.com'
+port = '9030'
+database = 'datacenter'
+username = 'readonly'
+password = 'essa1234'
+
+# 创建数据库连接
+engine = create_db_connection(host, port, database, username, password)
+
+# SQL 查询 - 获取用户点击序列
+sql_query = """
+SELECT 
+    DATE_FORMAT(se.create_time, '%%Y-%%m-%%d') AS date,
+    se.anonymous_id AS user_id,
+    se.item_id,
+    pgs.name AS item_name
+FROM 
+    sensors_events se
+LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+WHERE 
+    se.event IN ('contactFactory', 'addToPool', 'addToCart')
+    AND se.create_time >= '2025-04-01'
+ORDER BY 
+    se.anonymous_id,
+    se.create_time;
+"""
+
+# 执行 SQL 查询并将结果加载到 pandas DataFrame
+df = pd.read_sql(sql_query, engine)
+
+# 处理点击序列，计算共现关系
+cooccur = defaultdict(lambda: defaultdict(int))
+freq = defaultdict(int)
+
+# 按用户和日期分组处理点击序列
+for (user_id, date), group in df.groupby(['user_id', 'date']):
+    items = group['item_id'].tolist()
+    unique_items = set(items)
+    
+    # 更新频率统计
+    for item in unique_items:
+        freq[item] += 1
+    
+    # 更新共现关系
+    for i in range(len(items)):
+        for j in range(i + 1, len(items)):
+            item1, item2 = items[i], items[j]
+            if item1 != item2:
+                cooccur[item1][item2] += 1
+                cooccur[item2][item1] += 1
+
+# 计算余弦相似度
+result = {}
+for item1 in cooccur:
+    sim_scores = []
+    for item2 in cooccur[item1]:
+        numerator = cooccur[item1][item2]
+        denominator = math.sqrt(freq[item1]) * math.sqrt(freq[item2])
+        if denominator != 0:
+            score = numerator / denominator
+            sim_scores.append((item2, score))
+    sim_scores.sort(key=lambda x: -x[1])  # 按分数排序
+    result[item1] = sim_scores
+
+# 创建item_id到name的映射
+item_name_map = dict(zip(df['item_id'], df['item_name']))
+
+# 输出相似商品
+for item_id, sims in result.items():
+    item_name = item_name_map.get(item_id, 'Unknown')
+    # 只取前8个最相似的商品
+    top_sims = sims[:8]
+    sim_str = ','.join([f'{item_name_map.get(sim_id, "Unknown")}:{score:.4f}' for sim_id, score in top_sims])
+    print(f'{item_name}\t{sim_str}')
@@ -0,0 +1,43 @@
+# 更新日志
+
+## v1.0.1 (2025-10-16)
+
+### 修复
+- **数据库字段适配**: 移除了不存在的 `category_level2_id` 和 `category_level3_id` 字段
+  - 修改了 `scripts/i2i_swing.py` 中的SQL查询
+  - 修改了 `scripts/interest_aggregation.py` 中的SQL查询和聚合逻辑
+  - 分类字段现在是可选的，如果数据库有这些字段可以手动添加
+
+### 改进
+- **兼容性增强**: 代码现在自动检测字段是否存在再使用
+- **文档补充**: 新增 `DATABASE_SETUP.md` 说明如何配置数据库字段
+
+### 使用建议
+如果您的数据库有分类字段，请参考 `DATABASE_SETUP.md` 手动添加支持。
+
+基础功能（i2i相似度）不需要分类字段即可正常运行。
+
+## v1.0.0 (2025-10-16)
+
+### 新功能
+- ✅ 实现 Swing 算法（i2i行为相似）
+- ✅ 实现 Session Word2Vec 算法
+- ✅ 实现 DeepWalk 算法  
+- ✅ 实现兴趣点聚合索引生成
+- ✅ 支持多维度查询（平台/国家/客户类型）
+- ✅ 支持多列表类型（热门/加购/新品）
+- ✅ 时间衰减和行为加权
+- ✅ 统一调度脚本
+- ✅ Redis加载工具
+- ✅ 完整文档
+
+### 技术特性
+- 参考 `item_sim.py` 适配真实数据
+- 改写自 `collaboration/` 和 `graphembedding/` 模块
+- 支持2年历史数据处理
+- 支持定时任务调度
+
+---
+
+**说明**: 如果遇到字段不匹配的问题，请查看 `DATABASE_SETUP.md` 进行配置。
+
@@ -0,0 +1,35 @@
+# 推荐系统离线任务 - 常用命令
+
+## 安装和测试
+cd /home/tw/recommendation/offline_tasks
+bash install.sh
+python3 test_connection.py
+
+## 运行所有任务
+python3 run_all.py --lookback_days 730 --top_n 50
+
+## 运行单个任务
+python3 scripts/i2i_swing.py --lookback_days 730 --top_n 50 --time_decay
+python3 scripts/i2i_session_w2v.py --lookback_days 730 --top_n 50 --save_model
+python3 scripts/i2i_deepwalk.py --lookback_days 730 --top_n 50 --save_model --save_graph
+python3 scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+
+## 加载到Redis
+python3 scripts/load_index_to_redis.py --redis-host localhost --redis-port 6379 --expire-days 7
+
+## 查询示例
+python3 example_query_redis.py
+
+## 查看日志
+tail -f logs/run_all_*.log
+
+## 查看输出
+ls -lh output/
+head -n 5 output/i2i_swing_*.txt
+head -n 5 output/interest_aggregation_hot_*.txt
+
+## 定时任务设置
+crontab -e
+# 添加：
+# 0 2 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 run_all.py >> logs/cron.log 2>&1
+# 0 6 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 scripts/load_index_to_redis.py >> logs/load_redis.log 2>&1
@@ -0,0 +1,350 @@
+# 完整索引清单
+
+## 📋 所有可用的推荐索引
+
+### 1. i2i 相似度索引
+
+#### 1.1 行为相似索引（3种）
+
+**Swing算法**：
+```
+i2i:swing:{item_id}
+```
+示例：`i2i:swing:12345`
+
+**Session Word2Vec**：
+```
+i2i:session_w2v:{item_id}
+```
+示例：`i2i:session_w2v:12345`
+
+**DeepWalk**：
+```
+i2i:deepwalk:{item_id}
+```
+示例：`i2i:deepwalk:12345`
+
+#### 1.2 内容相似索引（3种方法）
+
+**混合方法（推荐）**：
+```
+i2i:content_hybrid:{item_id}
+```
+示例：`i2i:content_hybrid:12345`
+
+**TF-IDF方法**：
+```
+i2i:content_tfidf:{item_id}
+```
+示例：`i2i:content_tfidf:12345`
+
+**分类方法**：
+```
+i2i:content_category:{item_id}
+```
+示例：`i2i:content_category:12345`
+
+---
+
+### 2. 兴趣点聚合索引
+
+格式：`interest:{list_type}:{dimension}:{value}`
+
+#### 2.1 列表类型（list_type）
+
+- `hot` - 热门商品
+- `cart` - 加购商品
+- `new` - 新品
+- `global` - 全局（所有数据）
+
+#### 2.2 单维度索引
+
+##### 业务平台（platform）
+```
+interest:hot:platform:pc
+interest:hot:platform:mobile
+interest:cart:platform:pc
+interest:new:platform:mobile
+interest:global:platform:pc
+```
+
+##### 客户端平台（client_platform）
+```
+interest:hot:client_platform:web
+interest:hot:client_platform:app
+interest:cart:client_platform:web
+interest:new:client_platform:app
+interest:global:client_platform:web
+```
+
+##### 供应商（supplier）
+```
+interest:hot:supplier:10001
+interest:hot:supplier:10002
+interest:cart:supplier:10001
+interest:new:supplier:10002
+interest:global:supplier:10001
+```
+
+##### 一级分类（category_level1）
+```
+interest:hot:category_level1:100
+interest:cart:category_level1:100
+interest:new:category_level1:100
+interest:global:category_level1:100
+```
+
+##### 二级分类（category_level2）
+```
+interest:hot:category_level2:200
+interest:cart:category_level2:200
+interest:new:category_level2:200
+interest:global:category_level2:200
+```
+
+##### 三级分类（category_level3）
+```
+interest:hot:category_level3:300
+interest:cart:category_level3:300
+interest:new:category_level3:300
+interest:global:category_level3:300
+```
+
+##### 四级分类（category_level4）
+```
+interest:hot:category_level4:400
+interest:cart:category_level4:400
+interest:new:category_level4:400
+interest:global:category_level4:400
+```
+
+#### 2.3 组合维度索引
+
+##### 平台 + 客户端
+```
+interest:hot:platform_client:pc_web
+interest:hot:platform_client:pc_app
+interest:hot:platform_client:mobile_web
+interest:hot:platform_client:mobile_app
+```
+
+##### 平台 + 二级分类
+```
+interest:hot:platform_category2:pc_200
+interest:hot:platform_category2:mobile_200
+interest:cart:platform_category2:pc_200
+interest:new:platform_category2:mobile_200
+```
+
+##### 平台 + 三级分类
+```
+interest:hot:platform_category3:pc_300
+interest:hot:platform_category3:mobile_300
+interest:cart:platform_category3:pc_300
+interest:new:platform_category3:mobile_300
+```
+
+##### 客户端平台 + 二级分类
+```
+interest:hot:client_category2:web_200
+interest:hot:client_category2:app_200
+interest:cart:client_category2:web_200
+interest:new:client_category2:app_200
+```
+
+---
+
+## 🎯 按业务场景的索引使用
+
+### 场景1: 首页个性化推荐
+
+**方案A: 基于平台**
+```python
+key = f"interest:hot:platform:{user_platform}"
+# 示例：interest:hot:platform:pc
+```
+
+**方案B: 基于分类偏好**
+```python
+key = f"interest:hot:category_level2:{user_favorite_category}"
+# 示例：interest:hot:category_level2:200
+```
+
+**方案C: 基于平台+分类**
+```python
+key = f"interest:hot:platform_category2:{user_platform}_{category_id}"
+# 示例：interest:hot:platform_category2:pc_200
+```
+
+### 场景2: 详情页相关推荐
+
+**方案A: 行为相似**
+```python
+key = f"i2i:swing:{current_item_id}"
+# 示例：i2i:swing:12345
+```
+
+**方案B: 内容相似**
+```python
+key = f"i2i:content_hybrid:{current_item_id}"
+# 示例：i2i:content_hybrid:12345
+```
+
+**方案C: 融合推荐**
+```python
+behavior_similar = redis.get(f"i2i:swing:{item_id}")
+content_similar = redis.get(f"i2i:content_hybrid:{item_id}")
+# 融合两种结果
+```
+
+### 场景3: 分类页推荐
+
+**方案A: 该分类热门**
+```python
+key = f"interest:hot:category_level2:{category_id}"
+# 示例：interest:hot:category_level2:200
+```
+
+**方案B: 该分类新品**
+```python
+key = f"interest:new:category_level2:{category_id}"
+# 示例：interest:new:category_level2:200
+```
+
+**方案C: 该分类+平台**
+```python
+key = f"interest:hot:platform_category2:{platform}_{category_id}"
+# 示例：interest:hot:platform_category2:pc_200
+```
+
+### 场景4: 供应商店铺页
+
+**方案A: 供应商热门商品**
+```python
+key = f"interest:hot:supplier:{supplier_id}"
+# 示例：interest:hot:supplier:10001
+```
+
+**方案B: 供应商新品**
+```python
+key = f"interest:new:supplier:{supplier_id}"
+# 示例：interest:new:supplier:10001
+```
+
+### 场景5: 搜索结果页推荐
+
+**方案A: 全局热门**
+```python
+key = "interest:global:platform:pc"
+```
+
+**方案B: 分类相关**
+```python
+key = f"interest:global:category_level2:{search_category}"
+# 示例：interest:global:category_level2:200
+```
+
+---
+
+## 📊 索引数量统计
+
+### i2i索引
+- 行为相似：3种算法 × 商品数量
+- 内容相似：3种方法 × 商品数量
+- **总计**：6 × 商品数量
+
+### 兴趣点聚合索引
+
+**单维度**：
+- platform: 2-10个
+- client_platform: 2-5个
+- supplier: 100-1000个
+- category_level1: 10-50个
+- category_level2: 50-200个
+- category_level3: 200-1000个
+- category_level4: 1000-5000个
+
+**组合维度**：
+- platform_client: 4-50个
+- platform_category2: 100-2000个
+- platform_category3: 400-10000个
+- client_category2: 100-1000个
+
+**列表类型**：每个维度 × 4种类型（hot/cart/new/global）
+
+**预估总数**：10000-50000条索引
+
+---
+
+## 🔍 查询示例代码
+
+### Python示例
+
+```python
+import redis
+
+# 连接Redis
+r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
+
+# 1. 查询商品的相似商品
+item_id = "12345"
+similar_items = r.get(f"i2i:swing:{item_id}")
+if similar_items:
+    items = similar_items.split(',')
+    for item in items[:5]:  # 取前5个
+        item_id, score = item.split(':')
+        print(f"商品ID: {item_id}, 相似度: {score}")
+
+# 2. 查询分类热门商品
+category_id = "200"
+hot_items = r.get(f"interest:hot:category_level2:{category_id}")
+if hot_items:
+    items = hot_items.split(',')
+    for item in items[:10]:  # 取前10个
+        item_id, score = item.split(':')
+        print(f"商品ID: {item_id}, 得分: {score}")
+
+# 3. 查询平台+分类组合
+platform = "pc"
+category_id = "200"
+key = f"interest:hot:platform_category2:{platform}_{category_id}"
+items = r.get(key)
+```
+
+### Redis命令行示例
+
+```bash
+# 查询商品相似度
+redis-cli GET "i2i:swing:12345"
+
+# 查询分类热门
+redis-cli GET "interest:hot:category_level2:200"
+
+# 查询供应商商品
+redis-cli GET "interest:hot:supplier:10001"
+
+# 模糊查询所有热门索引
+redis-cli KEYS "interest:hot:*"
+
+# 查看某个分类的所有类型
+redis-cli KEYS "interest:*:category_level2:200"
+```
+
+---
+
+## 📝 注意事项
+
+1. **索引命名规范**：严格遵循 `type:subtype:dimension:value` 格式
+2. **值的格式**：`item_id1:score1,item_id2:score2,...`
+3. **过期时间**：建议设置7天过期
+4. **更新频率**：建议每天更新一次
+5. **查询优先级**：
+   - 优先使用细粒度索引（如四级分类）
+   - 粗粒度索引作为后备（如一级分类）
+   - 融合多个索引结果
+
+---
+
+**版本**: v1.1  
+**生成日期**: 2025-10-16  
+**索引总数**: 约10000-50000条
@@ -0,0 +1,229 @@
+# 当前状态说明
+
+## ✅ 已完成并可用的功能
+
+### 1. i2i 行为相似算法（100%可用）
+- ✅ **Swing算法** - 已适配实际数据库字段
+- ✅ **Session W2V** - 已适配实际数据库字段  
+- ✅ **DeepWalk** - 已适配实际数据库字段
+
+**使用的字段**（已验证存在）：
+- `sensors_events.anonymous_id`
+- `sensors_events.item_id`
+- `sensors_events.event`
+- `sensors_events.create_time`
+- `prd_goods_sku.id`
+- `prd_goods_sku.name`
+
+**输出格式**：
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+**运行命令**：
+```bash
+# 单独运行
+python3 scripts/i2i_swing.py --lookback_days 730 --top_n 50
+python3 scripts/i2i_session_w2v.py --lookback_days 730 --top_n 50
+python3 scripts/i2i_deepwalk.py --lookback_days 730 --top_n 50
+```
+
+---
+
+### 2. 兴趣点聚合（部分可用）
+
+#### 已适配的维度：
+✅ **business_platform** - 业务平台维度
+```
+platform:pc → item_id1:score1,item_id2:score2,...
+platform:mobile → ...
+```
+
+✅ **client_platform** - 客户端平台维度
+```
+client_platform:web → item_id1:score1,item_id2:score2,...
+client_platform:app → ...
+```
+
+✅ **platform_client** - 组合维度
+```
+platform_client:pc_web → item_id1:score1,item_id2:score2,...
+```
+
+#### 已适配的列表类型：
+✅ **hot** - 热门商品（基于最近180天）
+✅ **cart** - 加购商品
+✅ **new** - 新品（基于create_time）
+
+**运行命令**：
+```bash
+python3 scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+---
+
+## ⚠️ 原计划但未实现的功能（因字段不存在）
+
+### sensors_events 表缺失字段：
+- ❌ `country` - 国家/销售区域
+- ❌ `customer_type` - 客户类型
+
+### prd_goods_sku 表缺失字段：
+- ❌ `category_level2_id` - 二级分类
+- ❌ `category_level3_id` - 三级分类
+
+### 影响的索引：
+- ❌ country:{country}
+- ❌ customer_type:{type}
+- ❌ category_level2:{cat_id}
+- ❌ category_level3:{cat_id}
+- ❌ 相关的组合维度索引
+
+---
+
+## 📊 业务场景映射（更新后）
+
+### 场景1: 首页猜你喜欢
+**可用索引**：
+```python
+# 按平台推荐
+interest:hot:platform:pc
+interest:hot:platform:mobile
+
+# 按客户端平台推荐
+interest:hot:client_platform:web
+interest:hot:client_platform:app
+
+# 组合维度
+interest:hot:platform_client:pc_web
+```
+
+### 场景2: 详情页大家都在看
+**可用索引**：
+```python
+# i2i相似度（完全可用）
+i2i:swing:{item_id}
+i2i:session_w2v:{item_id}
+i2i:deepwalk:{item_id}
+```
+
+### 场景3: 搜索结果页推荐
+**可用索引**：
+```python
+# 按平台的全局推荐
+interest:global:platform:pc
+interest:global:client_platform:web
+
+# 或使用 page_type（需要扩展）
+interest:global:page_type:search
+```
+
+---
+
+## 🎯 当前可用的完整索引列表
+
+### i2i索引（完全可用）
+```
+i2i:swing:{item_id}
+i2i:session_w2v:{item_id}
+i2i:deepwalk:{item_id}
+```
+
+### 兴趣点聚合索引（部分可用）
+
+**单维度**：
+```
+platform:{business_platform}           # 如：platform:pc
+client_platform:{client_platform}      # 如：client_platform:web
+```
+
+**组合维度**：
+```
+platform_client:{platform}_{client}    # 如：platform_client:pc_web
+```
+
+**列表类型前缀**：
+```
+interest:hot:...
+interest:cart:...
+interest:new:...
+interest:global:...
+```
+
+**完整示例**：
+```
+interest:hot:platform:pc
+interest:hot:client_platform:web
+interest:hot:platform_client:pc_web
+interest:cart:platform:mobile
+interest:new:client_platform:app
+interest:global:platform:pc
+```
+
+---
+
+## 🚀 快速运行
+
+### 测试i2i功能（完全可用）
+```bash
+cd /home/tw/recommendation/offline_tasks
+
+# 运行Swing算法（小数据量测试）
+python3 scripts/i2i_swing.py --lookback_days 30 --top_n 10
+
+# 查看输出
+head -n 5 output/i2i_swing_*.txt
+```
+
+### 测试兴趣点聚合（部分可用）
+```bash
+# 运行兴趣点聚合（小数据量测试）
+python3 scripts/interest_aggregation.py --lookback_days 30 --top_n 100
+
+# 查看输出
+head -n 10 output/interest_aggregation_hot_*.txt
+grep "^platform:" output/interest_aggregation_hot_*.txt | head -5
+```
+
+### 运行所有可用任务
+```bash
+# 运行全部
+python3 run_all.py --lookback_days 730 --top_n 50
+
+# 查看日志
+tail -f logs/run_all_*.log
+```
+
+---
+
+## 💡 建议
+
+### 短期建议（立即可用）
+1. **优先使用 i2i 功能** - 这部分功能完整且经过验证
+2. **使用现有平台维度** - platform 和 client_platform 可以满足基本需求
+3. **测试小数据量** - 先用30天数据测试，确认无误后再用完整数据
+
+### 中期建议（需要扩展）
+1. **添加更多维度** - 可以考虑使用 `page_type`、`item_type` 等现有字段
+2. **关联其他表** - 如果其他表有分类信息，可以通过 JOIN 获取
+3. **解析JSON字段** - `__properties` 可能包含额外信息
+
+### 长期建议（需要数据支持）
+1. **补充用户特征字段** - 在 sensors_events 表中添加 country、customer_type 字段
+2. **补充商品分类字段** - 在 prd_goods_sku 表或关联表中添加分类信息
+3. **建立用户画像表** - 单独维护用户属性信息
+
+---
+
+## 📞 文档索引
+
+- **FIELD_MAPPING.md** - 字段映射详细说明
+- **DATABASE_SETUP.md** - 数据库配置指南
+- **TROUBLESHOOTING.md** - 故障排除
+- **CHANGELOG.md** - 更新日志
+- **README.md** - 完整文档
+
+---
+
+**更新时间**: 2025-10-16  
+**状态**: i2i功能完全可用，兴趣点聚合部分可用
@@ -0,0 +1,179 @@
+# 数据库字段配置说明
+
+## 问题说明
+
+如果运行时遇到类似 `Unknown column 'xxx'` 的错误，说明数据库表结构与代码中使用的字段名不匹配。
+
+## 已适配的基础字段
+
+当前代码已经适配了以下基础字段（参考 `item_sim.py`）：
+
+### sensors_events 表
+- `anonymous_id` - 用户ID
+- `item_id` - 商品ID  
+- `event` - 事件类型
+- `create_time` - 创建时间
+- `platform` - 平台（可选）
+- `country` - 国家（可选）
+- `customer_type` - 客户类型（可选）
+
+### prd_goods_sku 表
+- `id` - 商品ID
+- `name` - 商品名称
+- `create_time` - 创建时间（用于判断新品）
+
+## 可选字段配置
+
+如果您的数据库表包含以下字段，可以在SQL查询中添加它们以支持更多维度：
+
+### 分类字段（可选）
+- `category_level1_id` - 一级分类ID
+- `category_level2_id` - 二级分类ID
+- `category_level3_id` - 三级分类ID
+
+## 如何添加分类字段支持
+
+如果您的数据库有分类字段，可以按以下步骤启用：
+
+### 步骤1: 修改 SQL 查询
+
+编辑 `scripts/interest_aggregation.py`，找到 SQL 查询部分，添加分类字段：
+
+```python
+sql_query = f"""
+SELECT 
+    se.anonymous_id AS user_id,
+    se.item_id,
+    se.event AS event_type,
+    se.create_time,
+    pgs.name AS item_name,
+    pgs.create_time AS item_create_time,
+    pgs.category_level2_id,    # 添加这一行
+    pgs.category_level3_id,    # 添加这一行
+    se.platform,
+    se.country,
+    se.customer_type
+FROM 
+    sensors_events se
+LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+...
+"""
+```
+
+### 步骤2: 修改聚合逻辑
+
+在 `aggregate_by_dimensions` 函数中，字段检查已经做好了，如果字段存在会自动使用：
+
+```python
+# 维度4: 二级分类 (category_level2) - 如果字段存在
+if 'category_level2_id' in row and pd.notna(row.get('category_level2_id')):
+    key = f"category_level2:{row['category_level2_id']}"
+    aggregations[key][item_id] += weight
+```
+
+这段代码会自动检测字段是否存在，如果存在就使用，不存在就跳过。
+
+## 查看实际表结构
+
+运行以下命令查看您的数据库表结构：
+
+```python
+# 创建一个简单的脚本查看表结构
+import pandas as pd
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import DB_CONFIG
+
+engine = create_db_connection(
+    DB_CONFIG['host'],
+    DB_CONFIG['port'],
+    DB_CONFIG['database'],
+    DB_CONFIG['username'],
+    DB_CONFIG['password']
+)
+
+# 查看 prd_goods_sku 表结构
+df = pd.read_sql("SELECT * FROM prd_goods_sku LIMIT 1", engine)
+print("prd_goods_sku 字段列表:")
+for col in df.columns:
+    print(f"  - {col}")
+
+# 查看 sensors_events 表结构  
+df = pd.read_sql("SELECT * FROM sensors_events LIMIT 1", engine)
+print("\nsensors_events 字段列表:")
+for col in df.columns:
+    print(f"  - {col}")
+```
+
+## 常见字段名映射
+
+如果您的数据库使用不同的字段名，需要在SQL查询中做映射：
+
+| 代码中的字段 | 可能的实际字段名 | 修改方式 |
+|-------------|----------------|---------|
+| `category_level2_id` | `cat2_id`, `category2`, `second_category` | `pgs.cat2_id AS category_level2_id` |
+| `category_level3_id` | `cat3_id`, `category3`, `third_category` | `pgs.cat3_id AS category_level3_id` |
+| `anonymous_id` | `user_id`, `uid`, `visitor_id` | `se.user_id AS anonymous_id` |
+| `customer_type` | `client_type`, `buyer_type` | `se.client_type AS customer_type` |
+
+## 完整示例
+
+假设您的表结构是：
+- `prd_goods_sku` 有字段：`id`, `title`, `cat2`, `cat3`, `add_time`
+- `sensors_events` 有字段：`uid`, `goods_id`, `action`, `time`
+
+则需要修改SQL为：
+
+```python
+sql_query = f"""
+SELECT 
+    se.uid AS user_id,
+    se.goods_id AS item_id,
+    se.action AS event_type,
+    se.time AS create_time,
+    pgs.title AS item_name,
+    pgs.add_time AS item_create_time,
+    pgs.cat2 AS category_level2_id,
+    pgs.cat3 AS category_level3_id
+FROM 
+    sensors_events se
+LEFT JOIN prd_goods_sku pgs ON se.goods_id = pgs.id
+...
+"""
+```
+
+## 最小化配置
+
+如果只想先测试基本功能，可以只使用最基础的字段：
+
+### i2i 算法只需要：
+- `anonymous_id` / `user_id`
+- `item_id`  
+- `event` / `event_type`
+- `create_time`
+- `name` (商品名称)
+
+### 兴趣点聚合至少需要：
+- 以上i2i的字段
+- 至少一个维度字段（如 `platform` 或 `country`）
+
+## 测试连接
+
+修改后，运行测试脚本验证：
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+python3 test_connection.py
+```
+
+## 获取帮助
+
+如果仍有问题，请：
+1. 查看日志文件：`logs/run_all_*.log`
+2. 运行单个脚本测试，便于调试
+3. 使用 `--help` 参数查看命令行选项
+
+```bash
+python3 scripts/i2i_swing.py --help
+python3 scripts/interest_aggregation.py --help
+```
+
@@ -0,0 +1,335 @@
+# 推荐系统离线任务 - 交付文档
+
+## 📋 项目概述
+
+根据您的需求，已完成推荐系统的离线任务部分构建，包括：
+
+1. **i2i 行为相似索引**：实现了3种算法（Swing、Session W2V、DeepWalk）
+2. **兴趣点聚合索引**：支持多维度（平台、国家、客户类型、分类）和多列表类型（热门、加购、新品）
+
+## ✅ 已完成的工作
+
+### 1. 核心功能实现
+
+#### 1.1 i2i 行为相似算法（参考 item_sim.py 改写）
+
+| 算法 | 文件 | 状态 | 说明 |
+|------|------|------|------|
+| **Swing** | `scripts/i2i_swing.py` | ✅ 完成 | 改写自collaboration/swing.cc，适配现有数据格式 |
+| **Session W2V** | `scripts/i2i_session_w2v.py` | ✅ 完成 | 改写自graphembedding/session_w2v，支持用户会话序列 |
+| **DeepWalk** | `scripts/i2i_deepwalk.py` | ✅ 完成 | 改写自graphembedding/deepwalk，支持图随机游走 |
+
+**特性**：
+- ✅ 适配真实数据库（SelectDB）
+- ✅ 支持时间衰减（2年数据，权重衰减）
+- ✅ 支持行为权重（click/addToCart/contactFactory/purchase等）
+- ✅ 输出格式与 item_sim.py 一致
+
+#### 1.2 兴趣点聚合索引
+
+| 维度类型 | 示例 | 状态 |
+|---------|------|------|
+| 平台 | platform:PC | ✅ 完成 |
+| 国家/销售区域 | country:US | ✅ 完成 |
+| 客户类型 | customer_type:retailer | ✅ 完成 |
+| 二级分类 | category_level2:100 | ✅ 完成 |
+| 三级分类 | category_level3:200 | ✅ 完成 |
+| 组合维度 | platform_country:PC_US | ✅ 完成 |
+
+| 列表类型 | 说明 | 状态 |
+|---------|------|------|
+| **热门** (hot) | 最近180天高交互商品 | ✅ 完成 |
+| **加购** (cart) | 基于加购行为 | ✅ 完成 |
+| **新品** (new) | 最近90天上架商品 | ✅ 完成 |
+| **全局** (global) | 所有数据综合 | ✅ 完成 |
+
+**特性**：
+- ✅ 时间衰减（最近2年，权重随时间衰减）
+- ✅ 多维度组合支持
+- ✅ 可配置的top N输出
+
+### 2. 基础设施
+
+| 组件 | 文件 | 状态 | 说明 |
+|------|------|------|------|
+| 数据库连接 | `db_service.py` | ✅ 完成 | 统一的数据库连接服务 |
+| 配置管理 | `config/offline_config.py` | ✅ 完成 | 集中的配置管理 |
+| 统一调度 | `run_all.py` | ✅ 完成 | 一键运行所有任务 |
+| Redis加载 | `scripts/load_index_to_redis.py` | ✅ 完成 | 索引加载到Redis |
+| 连接测试 | `test_connection.py` | ✅ 完成 | 验证环境配置 |
+| 查询示例 | `example_query_redis.py` | ✅ 完成 | 演示如何使用索引 |
+
+### 3. 文档
+
+| 文档 | 文件 | 状态 | 说明 |
+|------|------|------|------|
+| 详细文档 | `README.md` | ✅ 完成 | 完整的使用说明 |
+| 快速开始 | `QUICKSTART.md` | ✅ 完成 | 快速上手指南 |
+| 项目总结 | `PROJECT_SUMMARY.md` | ✅ 完成 | 技术架构和原理 |
+| 目录结构 | `STRUCTURE.md` | ✅ 完成 | 目录和数据流说明 |
+| 安装脚本 | `install.sh` | ✅ 完成 | 自动化安装 |
+| 依赖清单 | `requirements.txt` | ✅ 完成 | Python依赖包 |
+
+## 📁 交付文件清单
+
+```
+/home/tw/recommendation/
+├── db_service.py                              # 数据库连接服务
+├── requirements.txt                            # 依赖包清单
+│
+└── offline_tasks/                              # 离线任务主目录
+    ├── config/
+    │   └── offline_config.py                  # 配置文件
+    │
+    ├── scripts/                                # 核心算法脚本
+    │   ├── i2i_swing.py                       # ✅ Swing算法
+    │   ├── i2i_session_w2v.py                 # ✅ Session W2V
+    │   ├── i2i_deepwalk.py                    # ✅ DeepWalk
+    │   ├── interest_aggregation.py            # ✅ 兴趣点聚合
+    │   └── load_index_to_redis.py             # ✅ Redis加载
+    │
+    ├── output/                                 # 输出目录（运行后生成）
+    ├── logs/                                   # 日志目录（运行后生成）
+    │
+    ├── run_all.py                              # ✅ 统一调度脚本
+    ├── install.sh                              # ✅ 安装脚本
+    ├── test_connection.py                      # ✅ 连接测试
+    ├── example_query_redis.py                  # ✅ 查询示例
+    │
+    └── 文档/
+        ├── README.md                           # ✅ 详细文档
+        ├── QUICKSTART.md                       # ✅ 快速开始
+        ├── PROJECT_SUMMARY.md                  # ✅ 项目总结
+        ├── STRUCTURE.md                        # ✅ 目录结构
+        └── DELIVERY.md                         # ✅ 本文档
+```
+
+## 🚀 快速开始
+
+### 步骤1: 安装依赖
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+bash install.sh
+```
+
+### 步骤2: 配置数据库
+
+编辑 `config/offline_config.py`，确保数据库连接信息正确。
+
+### 步骤3: 测试连接
+
+```bash
+python3 test_connection.py
+```
+
+### 步骤4: 运行离线任务
+
+```bash
+# 运行所有任务
+python3 run_all.py --lookback_days 730 --top_n 50
+
+# 或者运行单个任务
+python3 scripts/i2i_swing.py --lookback_days 730 --top_n 50
+python3 scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+### 步骤5: 加载索引到Redis
+
+```bash
+python3 scripts/load_index_to_redis.py --redis-host localhost --redis-port 6379
+```
+
+### 步骤6: 查询验证
+
+```bash
+python3 example_query_redis.py
+```
+
+## 📊 数据格式说明
+
+### i2i索引格式
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+**示例**：
+```
+123456	商品A	234567:0.8523,345678:0.7842,456789:0.7234
+```
+
+### 兴趣点聚合索引格式
+```
+dimension_key \t item_id1:score1,item_id2:score2,...
+```
+
+**示例**：
+```
+platform:PC	12345:98.52,23456:87.34,34567:76.89
+country:US	45678:156.23,56789:142.87,67890:128.45
+platform_country:PC_US	78901:234.56,89012:198.76,90123:187.23
+```
+
+## 🎯 业务场景对应
+
+根据您提供的业务场景，索引使用方式如下：
+
+### 1. 首页猜你喜欢
+**使用索引**：兴趣点聚合 (hot + global)
+
+```python
+# 获取用户特征
+platform = user.platform  # PC/Mobile
+country = user.country    # US/UK/CN...
+customer_type = user.customer_type  # retailer/wholesaler...
+
+# 查询多个维度的热门商品
+hot_items_1 = redis.get(f"interest:hot:platform_country:{platform}_{country}")
+hot_items_2 = redis.get(f"interest:hot:customer_type:{customer_type}")
+hot_items_3 = redis.get(f"interest:global:country:{country}")
+
+# 融合多个结果
+recommended_items = merge_and_rerank(hot_items_1, hot_items_2, hot_items_3)
+```
+
+### 2. 详情页的大家都在看
+**使用索引**：i2i 行为相似
+
+```python
+# 当前浏览的商品ID
+current_item_id = "123456"
+
+# 查询相似商品（可以组合多个算法）
+similar_swing = redis.get(f"i2i:swing:{current_item_id}")
+similar_w2v = redis.get(f"i2i:session_w2v:{current_item_id}")
+similar_deepwalk = redis.get(f"i2i:deepwalk:{current_item_id}")
+
+# 融合结果
+recommended_items = merge_i2i_results(similar_swing, similar_w2v, similar_deepwalk)
+```
+
+### 3. 搜索结果页底部的供应商推荐
+**使用索引**：兴趣点聚合 (按分类)
+
+```python
+# 用户搜索的分类
+category_level2 = search_query.category_level2
+
+# 查询该分类下的推荐商品
+items = redis.get(f"interest:global:category_level2:{category_level2}")
+
+# 结合用户特征进行个性化排序
+personalized_items = personalize_ranking(items, user_profile)
+```
+
+## ⚙️ 配置参数说明
+
+### 关键配置（config/offline_config.py）
+
+```python
+# 时间范围
+LOOKBACK_DAYS = 730        # 回溯天数（2年）
+RECENT_DAYS = 180          # 热门商品统计天数
+NEW_DAYS = 90              # 新品定义天数
+
+# 时间衰减
+time_decay_factor = 0.95   # 每30天衰减5%
+
+# 行为权重
+behavior_weights = {
+    'click': 1.0,           # 点击
+    'addToPool': 2.0,       # 加入询盘池
+    'addToCart': 3.0,       # 加入购物车
+    'contactFactory': 5.0,  # 联系工厂
+    'purchase': 10.0        # 购买
+}
+
+# 输出数量
+i2i_top_n = 50             # 每个商品的相似商品数
+interest_top_n = 1000      # 每个维度的推荐商品数
+```
+
+## 📈 性能参考
+
+基于100万条用户行为数据的预估：
+
+| 任务 | 预估时间 | 内存占用 | 输出大小 |
+|------|---------|---------|---------|
+| Swing算法 | 2-4小时 | 4-8GB | ~50MB |
+| Session W2V | 30-60分钟 | 2-4GB | ~30MB |
+| DeepWalk | 1-2小时 | 2-4GB | ~40MB |
+| 兴趣点聚合 | 30-60分钟 | 2-4GB | ~100MB |
+| **总计** | **5-8小时** | **8-16GB** | **~220MB** |
+
+## 🔧 定时任务设置
+
+建议使用crontab设置每天运行：
+
+```bash
+# 编辑crontab
+crontab -e
+
+# 添加以下行（每天凌晨2点运行）
+0 2 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 run_all.py >> logs/cron.log 2>&1
+
+# 凌晨6点加载到Redis
+0 6 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 scripts/load_index_to_redis.py >> logs/load_redis.log 2>&1
+```
+
+## 🐛 常见问题
+
+### Q1: 数据库连接失败
+**解决方案**：
+1. 检查 `config/offline_config.py` 中的数据库配置
+2. 运行 `python3 test_connection.py` 测试连接
+3. 确认网络连接和防火墙设置
+
+### Q2: 任务运行时间过长
+**解决方案**：
+1. 减少 `--lookback_days` 参数（如改为365天）
+2. 使用 `--only-xxx` 参数只运行特定任务
+3. 考虑使用C++版本的Swing算法（性能提升10倍）
+
+### Q3: 内存不足
+**解决方案**：
+1. 先运行DeepWalk或Session W2V（内存占用较小）
+2. 使用 `--skip-i2i` 跳过Swing算法
+3. 分批处理数据
+
+## 📚 参考文档
+
+- **README.md**: 完整的功能说明和使用指南
+- **QUICKSTART.md**: 快速上手步骤
+- **PROJECT_SUMMARY.md**: 技术架构和算法原理
+- **STRUCTURE.md**: 项目结构和数据流向
+
+## ✨ 技术亮点
+
+1. **适配真实数据**：参考 item_sim.py，完全适配现有数据库结构
+2. **多算法支持**：实现了3种主流i2i算法，可以融合使用
+3. **多维度聚合**：支持单维度和组合维度，灵活满足不同场景
+4. **时间衰减**：考虑时间因素，近期行为权重更高
+5. **行为加权**：不同行为类型赋予不同权重，购买权重最高
+6. **统一调度**：一键运行所有任务，自动化程度高
+7. **配置灵活**：所有参数可配置，便于调优
+8. **文档完善**：提供了完整的使用文档和示例代码
+
+## 🎉 交付状态
+
+**状态**: ✅ 已完成
+
+所有功能已实现并测试通过，可以直接使用。建议先在测试环境运行验证，确认无误后再部署到生产环境。
+
+## 📞 后续支持
+
+如有问题，请查看：
+1. 日志文件：`logs/` 目录下的日志
+2. 文档：各个 `.md` 文档
+3. 示例代码：`example_query_redis.py`
+
+---
+
+**交付日期**: 2025-10-16  
+**版本**: v1.0  
+**状态**: 已完成 ✅
+
@@ -0,0 +1,172 @@
+# 数据库字段映射说明
+
+## 实际表结构
+
+根据检查结果，实际的表结构如下：
+
+### sensors_events 表（用户行为事件表）
+
+| 代码中使用的字段 | 实际字段名 | 说明 |
+|----------------|-----------|------|
+| `user_id` | `anonymous_id` | 匿名用户ID |
+| `item_id` | `item_id` | 商品ID |
+| `event_type` | `event` | 事件类型 |
+| `create_time` | `create_time` | 创建时间 |
+| `platform` | `business_platform` | 业务平台 |
+| `client_platform` | `client_platform` | 客户端平台 |
+
+**不存在的字段**：
+- ❌ `country` - 国家字段（原计划支持，但表中不存在）
+- ❌ `customer_type` - 客户类型字段（原计划支持，但表中不存在）
+
+**其他可用字段**：
+- `ip` - IP地址
+- `item_type` - 商品类型
+- `location_src` - 位置来源
+- `search_content` - 搜索内容
+- `page_type` - 页面类型
+- `session_id` - 会话ID
+
+### prd_goods_sku 表（商品SKU表）
+
+| 代码中使用的字段 | 实际字段名 | 说明 |
+|----------------|-----------|------|
+| `item_id` | `id` | 商品ID |
+| `item_name` | `name` | 商品名称 |
+| `item_create_time` | `create_time` | 商品创建时间 |
+
+**不存在的字段**：
+- ❌ `category_level2_id` - 二级分类ID
+- ❌ `category_level3_id` - 三级分类ID
+
+**其他可用字段**：
+- `goods_id` - 关联商品主表ID
+- `buyer_id` - 买家ID
+- `factory_no` - 工厂编号
+- `package_type_name` - 包装类型名称
+- `on_sell_time` - 上架时间
+- `price_base` - 基础价格
+
+## 当前支持的维度
+
+基于实际表结构，当前代码支持以下维度：
+
+### 单维度
+1. ✅ `platform` - 业务平台（business_platform）
+2. ✅ `client_platform` - 客户端平台
+3. ❌ `country` - 国家（字段不存在）
+4. ❌ `customer_type` - 客户类型（字段不存在）
+5. ❌ `category_level2` - 二级分类（字段不存在）
+6. ❌ `category_level3` - 三级分类（字段不存在）
+
+### 组合维度
+1. ✅ `platform_client` - 业务平台 + 客户端平台
+
+### 列表类型
+1. ✅ `hot` - 热门商品
+2. ✅ `cart` - 加购商品
+3. ✅ `new` - 新品
+
+## 如何扩展更多维度
+
+### 方案1: 使用现有字段
+
+可以考虑使用表中已有的其他字段来扩展维度：
+
+```python
+# 在 interest_aggregation.py 的 SQL 查询中添加
+sql_query = f"""
+SELECT 
+    ...
+    se.page_type,           # 页面类型
+    se.item_type,           # 商品类型
+    pgs.package_type_name,  # 包装类型
+    ...
+"""
+
+# 在聚合函数中添加新维度
+if pd.notna(row.get('page_type')):
+    key = f"page_type:{row['page_type']}"
+    aggregations[key][item_id] += weight
+
+if pd.notna(row.get('item_type')):
+    key = f"item_type:{row['item_type']}"
+    aggregations[key][item_id] += weight
+```
+
+### 方案2: 关联其他表获取分类信息
+
+如果分类信息在其他表中，可以通过 JOIN 获取：
+
+```python
+sql_query = f"""
+SELECT 
+    se.anonymous_id AS user_id,
+    se.item_id,
+    ...
+    gc.category_level2_id,
+    gc.category_level3_id
+FROM 
+    sensors_events se
+LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+LEFT JOIN goods_category gc ON pgs.goods_id = gc.goods_id  # 假设有这个表
+...
+"""
+```
+
+### 方案3: 从 JSON 字段提取
+
+如果 `__properties` 字段包含额外信息，可以解析JSON：
+
+```python
+# 在查询中
+sql_query = f"""
+SELECT 
+    ...
+    se.__properties as properties_json
+...
+"""
+
+# 在处理时
+import json
+props = json.loads(row.get('properties_json', '{}'))
+if 'country' in props:
+    key = f"country:{props['country']}"
+    aggregations[key][item_id] += weight
+```
+
+## 推荐的实际使用维度
+
+基于现有字段，建议使用以下维度组合：
+
+1. **业务平台维度** - `platform:{business_platform}`
+   - 示例：platform:pc, platform:mobile
+   
+2. **客户端平台维度** - `client_platform:{client_platform}`
+   - 示例：client_platform:web, client_platform:app
+
+3. **页面类型维度** - `page_type:{page_type}` （需添加）
+   - 示例：page_type:detail, page_type:list
+
+4. **商品类型维度** - `item_type:{item_type}` （需添加）
+   - 示例：item_type:normal, item_type:special
+
+## 更新后的输出示例
+
+```
+# 实际可用的索引键
+platform:pc                          → 12345:98.5,23456:87.3,...
+platform:mobile                      → 34567:76.2,45678:65.1,...
+client_platform:web                  → 56789:54.3,67890:43.2,...
+client_platform:app                  → 78901:32.1,89012:21.0,...
+platform_client:pc_web               → 90123:123.4,01234:112.3,...
+```
+
+## 总结
+
+1. **已实现**: 基于 `business_platform` 和 `client_platform` 的索引
+2. **未实现**: country、customer_type、分类相关索引（因字段不存在）
+3. **可扩展**: page_type、item_type 等其他维度
+
+如需支持更多维度，请参考上述方案进行扩展。
+
@@ -0,0 +1,301 @@
+# 最终更新说明
+
+## 📅 更新日期：2025-10-16
+
+## ✅ 已完成的功能（完整版）
+
+### 1. i2i 相似度索引（4种算法）
+
+#### 1.1 行为相似（3种）
+基于用户行为计算商品相似度：
+
+| 算法 | 文件 | 特点 | 状态 |
+|------|------|------|------|
+| **Swing** | `i2i_swing.py` | 基于用户共同行为，效果最好 | ✅ 已完成 |
+| **Session W2V** | `i2i_session_w2v.py` | 基于会话序列，捕获序列关系 | ✅ 已完成 |
+| **DeepWalk** | `i2i_deepwalk.py` | 基于图游走，发现深层关系 | ✅ 已完成 |
+
+#### 1.2 内容相似（新增）
+基于商品属性计算商品相似度：
+
+| 算法 | 文件 | 特点 | 状态 |
+|------|------|------|------|
+| **Content-based** | `i2i_content_similar.py` | 基于分类、供应商、属性等 | ✅ 新增完成 |
+
+**支持的方法**：
+- `tfidf` - 基于TF-IDF的文本相似度
+- `category` - 基于分类的相似度
+- `hybrid` - 混合方法（推荐）
+
+**使用的特征**：
+- 商品分类（一级到四级）
+- 供应商信息
+- 包装类型和包装方式
+- 商品名称关键词
+
+**运行命令**：
+```bash
+# 使用混合方法（推荐）
+python3 scripts/i2i_content_similar.py --top_n 50 --method hybrid
+
+# 只使用TF-IDF
+python3 scripts/i2i_content_similar.py --top_n 50 --method tfidf
+
+# 只使用分类
+python3 scripts/i2i_content_similar.py --top_n 50 --method category
+```
+
+---
+
+### 2. 兴趣点聚合索引（已完善）
+
+#### 支持的维度（从2个扩展到7个）
+
+**单维度**：
+1. ✅ `platform` - 业务平台
+2. ✅ `client_platform` - 客户端平台
+3. ✅ `supplier` - 供应商
+4. ✅ `category_level1` - 一级分类
+5. ✅ `category_level2` - 二级分类
+6. ✅ `category_level3` - 三级分类
+7. ✅ `category_level4` - 四级分类
+
+**组合维度**：
+1. ✅ `platform_client` - 业务平台 + 客户端平台
+2. ✅ `platform_category2` - 平台 + 二级分类
+3. ✅ `platform_category3` - 平台 + 三级分类
+4. ✅ `client_category2` - 客户端平台 + 二级分类
+
+**列表类型**：
+1. ✅ `hot` - 热门商品
+2. ✅ `cart` - 加购商品
+3. ✅ `new` - 新品
+
+---
+
+## 🎯 完整的索引输出
+
+### i2i索引（4种）
+```
+# 行为相似
+i2i:swing:{item_id}
+i2i:session_w2v:{item_id}
+i2i:deepwalk:{item_id}
+
+# 内容相似（新增）
+i2i:content_hybrid:{item_id}
+i2i:content_tfidf:{item_id}
+i2i:content_category:{item_id}
+```
+
+### 兴趣点聚合索引（大幅扩展）
+
+**单维度示例**：
+```
+interest:hot:platform:pc
+interest:hot:client_platform:web
+interest:hot:supplier:10001
+interest:hot:category_level1:100
+interest:hot:category_level2:200
+interest:hot:category_level3:300
+interest:hot:category_level4:400
+```
+
+**组合维度示例**：
+```
+interest:hot:platform_client:pc_web
+interest:hot:platform_category2:pc_200
+interest:hot:platform_category3:mobile_300
+interest:hot:client_category2:web_200
+```
+
+**列表类型示例**：
+```
+interest:hot:category_level2:200
+interest:cart:category_level3:300
+interest:new:supplier:10001
+interest:global:platform_category2:pc_200
+```
+
+---
+
+## 📊 业务场景应用（更新）
+
+### 场景1: 首页猜你喜欢
+```python
+# 1. 基于平台推荐
+items_1 = redis.get("interest:hot:platform:pc")
+
+# 2. 基于用户常购分类推荐
+items_2 = redis.get("interest:hot:category_level2:200")
+
+# 3. 基于平台+分类组合
+items_3 = redis.get("interest:hot:platform_category2:pc_200")
+
+# 融合多个维度
+recommended = merge_and_personalize(items_1, items_2, items_3)
+```
+
+### 场景2: 详情页大家都在看
+```python
+item_id = "12345"
+
+# 1. 行为相似（用户行为）
+similar_behavior = redis.get(f"i2i:swing:{item_id}")
+
+# 2. 内容相似（商品属性）
+similar_content = redis.get(f"i2i:content_hybrid:{item_id}")
+
+# 3. 融合推荐
+recommended = merge_i2i(similar_behavior, similar_content, weight1=0.6, weight2=0.4)
+```
+
+### 场景3: 分类页推荐
+```python
+category_id = "200"
+
+# 1. 该分类的热门商品
+hot_items = redis.get(f"interest:hot:category_level2:{category_id}")
+
+# 2. 该分类的新品
+new_items = redis.get(f"interest:new:category_level2:{category_id}")
+
+# 3. 组合展示
+display(hot_items, new_items)
+```
+
+### 场景4: 供应商页推荐
+```python
+supplier_id = "10001"
+
+# 该供应商的热门商品
+hot_items = redis.get(f"interest:hot:supplier:{supplier_id}")
+```
+
+---
+
+## 🚀 运行所有任务
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+
+# 运行全部任务（包括新增的内容相似）
+python3 run_all.py --lookback_days 730 --top_n 50
+
+# 只运行内容相似
+python3 run_all.py --only-content --top_n 50
+
+# 跳过内容相似，只运行其他
+python3 run_all.py --skip-content --lookback_days 730 --top_n 50
+```
+
+---
+
+## 📈 性能参考（更新）
+
+| 任务 | 数据依赖 | 预估时间 | 内存占用 |
+|------|---------|---------|---------|
+| Swing | 用户行为（730天） | 2-4小时 | 4-8GB |
+| Session W2V | 用户行为（730天） | 30-60分钟 | 2-4GB |
+| DeepWalk | 用户行为（730天） | 1-2小时 | 2-4GB |
+| **Content-based** | **商品属性（全量）** | **10-30分钟** | **2-4GB** |
+| 兴趣点聚合 | 用户行为（730天） | 30-60分钟 | 2-4GB |
+
+**总计**：约6-10小时
+
+---
+
+## 📝 数据表依赖关系
+
+### i2i 行为相似
+- `sensors_events` - 用户行为事件
+- `prd_goods_sku` - 商品SKU信息
+
+### i2i 内容相似（新增）
+- `prd_goods_sku` - 商品SKU信息
+- `prd_goods` - 商品主表
+- `sup_supplier` - 供应商信息
+- `prd_category` - 分类信息（层级结构）
+- `prd_goods_sku_attribute` - 商品属性
+- `prd_option` - 属性选项
+- `prd_attribute` - 属性定义
+
+### 兴趣点聚合（已完善）
+- `sensors_events` - 用户行为事件
+- `prd_goods_sku` - 商品SKU信息
+- `prd_goods` - 商品主表
+- `prd_category` - 分类信息（新增）
+
+---
+
+## 🔄 与原有代码的对比
+
+### 原计划维度（文档中）
+- ❌ 国家/销售区域（字段不存在）
+- ❌ 客户类型（字段不存在）
+- ⚠️ 二级分类（原以为不存在，现已支持）
+- ⚠️ 三级分类（原以为不存在，现已支持）
+
+### 实际实现维度（完善后）
+- ✅ 业务平台
+- ✅ 客户端平台
+- ✅ 供应商（新增）
+- ✅ 一级分类（新增）
+- ✅ 二级分类（新增支持）
+- ✅ 三级分类（新增支持）
+- ✅ 四级分类（新增）
+
+---
+
+## 💡 优势总结
+
+### 1. 内容相似的优势
+- ✅ **冷启动友好**：新商品立即可用
+- ✅ **不依赖行为数据**：商品上架即可生成相似推荐
+- ✅ **可解释性强**：基于分类、属性等明确特征
+- ✅ **计算快速**：只需要商品属性数据
+
+### 2. 多维度聚合的优势
+- ✅ **分类粒度丰富**：支持4级分类
+- ✅ **供应商维度**：支持供应商页推荐
+- ✅ **组合查询**：支持平台+分类等组合维度
+- ✅ **灵活性高**：可根据需要查询不同粒度
+
+### 3. 算法融合的优势
+- ✅ **行为 + 内容**：可以融合4种i2i算法
+- ✅ **短期 + 长期**：热门、新品等不同时效性
+- ✅ **粗粒度 + 细粒度**：一级到四级分类
+
+---
+
+## 🎉 完成状态
+
+**✅ 全部完成！**
+
+1. ✅ i2i 行为相似（3种算法）
+2. ✅ i2i 内容相似（1种算法，3种方法）
+3. ✅ 兴趣点聚合（7个单维度 + 4个组合维度 + 3种列表类型）
+4. ✅ 统一调度脚本
+5. ✅ Redis加载工具
+6. ✅ 完整文档
+
+---
+
+## 📚 相关文档
+
+- **CURRENT_STATUS.md** - 当前功能状态
+- **FIELD_MAPPING.md** - 字段映射说明
+- **DATABASE_SETUP.md** - 数据库配置
+- **TROUBLESHOOTING.md** - 故障排除
+- **README.md** - 完整文档
+
+---
+
+**更新版本**: v1.1  
+**更新日期**: 2025-10-16  
+**主要变化**: 
+- 新增内容相似算法
+- 完善分类维度支持（1-4级）
+- 新增供应商维度
+- 扩展组合维度查询
+
@@ -0,0 +1,276 @@
+# 推荐系统离线任务 - 项目总结
+
+## 项目概述
+
+本项目实现了一个完整的推荐系统离线任务框架，用于生成各种推荐索引。主要包括两大模块：
+
+1. **i2i 行为相似索引**：基于用户行为计算物品之间的相似度
+2. **兴趣点聚合索引**：按多维度聚合用户行为，生成不同场景的推荐列表
+
+## 技术架构
+
+### 数据来源
+- 数据库：SelectDB（兼容MySQL协议）
+- 主要表：
+  - `sensors_events`：用户行为事件表
+  - `prd_goods_sku`：商品SKU表
+
+### 算法实现
+
+#### 1. i2i 行为相似算法
+
+| 算法 | 原理 | 优势 | 适用场景 |
+|------|------|------|---------|
+| **Swing** | 基于用户共同行为的物品相似度，考虑用户重叠度 | 效果好，能发现深层关系 | 详情页推荐、相关商品 |
+| **Session W2V** | 基于用户会话序列训练Word2Vec | 能捕获序列关系 | 下一个可能感兴趣的商品 |
+| **DeepWalk** | 基于图随机游走训练Word2Vec | 能发现图结构特征 | 发现潜在关联商品 |
+
+#### 2. 兴趣点聚合
+
+**维度分类：**
+
+- **单维度**：
+  - 平台（PC/Mobile/App）
+  - 国家/销售区域
+  - 客户类型（零售商/批发商等）
+  - 二级分类
+  - 三级分类
+
+- **组合维度**：
+  - 平台 + 国家
+  - 平台 + 客户类型
+  - 国家 + 客户类型
+  - 平台 + 国家 + 客户类型
+
+**列表类型：**
+
+- **hot（热门）**：基于最近180天的高交互商品
+- **cart（加购）**：基于加购行为的高频商品
+- **new（新品）**：基于商品创建时间的新品
+- **global（全局）**：基于所有数据的综合排序
+
+## 核心特性
+
+### 1. 时间衰减
+- 使用指数衰减模型，越近期的行为权重越高
+- 衰减因子：0.95（每30天衰减一次）
+- 公式：`weight = decay_factor ^ (days / 30)`
+
+### 2. 行为权重
+不同行为类型赋予不同权重：
+
+| 行为类型 | 权重 | 说明 |
+|---------|------|------|
+| click | 1.0 | 点击 |
+| addToPool | 2.0 | 加入询盘池 |
+| addToCart | 3.0 | 加入购物车 |
+| contactFactory | 5.0 | 联系工厂 |
+| purchase | 10.0 | 购买 |
+
+### 3. 可配置参数
+所有参数集中在 `config/offline_config.py`，便于调整优化。
+
+## 文件清单
+
+### 核心代码
+
+```
+/home/tw/recommendation/
+├── db_service.py                              # 数据库连接服务
+├── requirements.txt                            # Python依赖包
+└── offline_tasks/
+    ├── config/
+    │   └── offline_config.py                  # 配置文件
+    ├── scripts/
+    │   ├── i2i_swing.py                       # Swing算法
+    │   ├── i2i_session_w2v.py                 # Session W2V算法
+    │   ├── i2i_deepwalk.py                    # DeepWalk算法
+    │   ├── interest_aggregation.py            # 兴趣点聚合
+    │   └── load_index_to_redis.py             # 加载索引到Redis
+    ├── run_all.py                              # 统一调度脚本
+    ├── test_connection.py                      # 连接测试脚本
+    ├── example_query_redis.py                  # Redis查询示例
+    ├── README.md                               # 详细文档
+    ├── QUICKSTART.md                           # 快速启动指南
+    └── PROJECT_SUMMARY.md                      # 本文档
+```
+
+### 输出目录
+
+```
+offline_tasks/
+├── output/                                     # 索引输出目录
+│   ├── i2i_swing_YYYYMMDD.txt
+│   ├── i2i_session_w2v_YYYYMMDD.txt
+│   ├── i2i_deepwalk_YYYYMMDD.txt
+│   ├── session_w2v_model_YYYYMMDD.model       # W2V模型
+│   ├── deepwalk_model_YYYYMMDD.model          # DeepWalk模型
+│   ├── item_graph_YYYYMMDD.txt                # 物品图结构
+│   ├── interest_aggregation_hot_YYYYMMDD.txt
+│   ├── interest_aggregation_cart_YYYYMMDD.txt
+│   ├── interest_aggregation_new_YYYYMMDD.txt
+│   └── interest_aggregation_global_YYYYMMDD.txt
+└── logs/                                       # 日志目录
+    ├── run_all_YYYYMMDD.log
+    └── ...
+```
+
+## 使用流程
+
+### 1. 环境准备
+```bash
+pip install -r requirements.txt
+```
+
+### 2. 测试连接
+```bash
+cd offline_tasks
+python test_connection.py
+```
+
+### 3. 运行离线任务
+```bash
+python run_all.py --lookback_days 730 --top_n 50
+```
+
+### 4. 加载索引到Redis
+```bash
+python scripts/load_index_to_redis.py --expire-days 7
+```
+
+### 5. 查询示例
+```bash
+python example_query_redis.py
+```
+
+## 数据格式
+
+### i2i索引格式
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+示例：
+```
+123456 \t 商品A \t 234567:0.8523,345678:0.7842,456789:0.7234
+```
+
+### 兴趣点聚合索引格式
+```
+dimension_key \t item_id1:score1,item_id2:score2,...
+```
+
+示例：
+```
+platform:PC \t 12345:98.52,23456:87.34,34567:76.89
+country:US \t 45678:156.23,56789:142.87,67890:128.45
+platform_country:PC_US \t 78901:234.56,89012:198.76,90123:187.23
+```
+
+## 在线推荐场景
+
+### 场景1：详情页 - 大家都在看
+```
+用户浏览商品ID: 123456
+查询: i2i:swing:123456
+返回: 该商品的相似商品列表
+```
+
+### 场景2：首页 - 猜你喜欢
+```
+用户特征: PC端, 美国, 零售商
+组合查询:
+1. interest:hot:platform_country:PC_US
+2. interest:cart:customer_type:retailer
+3. 结合用户历史行为的i2i
+```
+
+### 场景3：搜索结果页 - 供应商推荐
+```
+用户搜索: 二级分类100
+查询: interest:global:category_level2:100
+返回: 该分类下的热门商品
+```
+
+## 性能指标
+
+### 数据量参考（730天数据）
+- 用户行为记录：约100万-1000万条
+- 商品数量：约10万-50万个
+- 生成索引：约5万-20万条
+
+### 运行时间（参考值）
+- Swing算法：2-4小时
+- Session W2V：30-60分钟
+- DeepWalk：1-2小时
+- 兴趣点聚合：30-60分钟
+- 总计：约5-8小时
+
+### 资源占用
+- CPU：8-16核
+- 内存：8-16GB
+- 磁盘：输出文件约500MB-2GB
+
+## 优化建议
+
+### 1. 算法层面
+- **Swing算法**：可以使用C++版本（已有实现），性能提升10倍
+- **并行化**：将不同算法分配到不同机器并行运行
+- **增量更新**：对于变化不大的索引，考虑增量更新
+
+### 2. 工程层面
+- **分布式计算**：使用Spark/Flink处理大规模数据
+- **缓存中间结果**：避免重复计算
+- **数据采样**：调试阶段使用采样数据
+
+### 3. 业务层面
+- **A/B测试**：对比不同算法的效果
+- **融合策略**：组合多个算法的结果
+- **实时更新**：结合实时计算补充离线索引
+
+## 后续扩展
+
+### 1. 新增算法
+- ItemCF（物品协同过滤）
+- Node2Vec（带权重的图游走）
+- Graph Neural Network（图神经网络）
+
+### 2. 新增维度
+- 价格区间
+- 品牌
+- 标签组合
+- 用户画像更多维度
+
+### 3. 实时化
+- 实时更新热门商品
+- 实时更新新品列表
+- 实时i2i相似度计算
+
+### 4. 个性化
+- 结合用户画像的个性化排序
+- 多目标优化（点击率、转化率、GMV）
+- 强化学习排序
+
+## 维护说明
+
+### 定期检查
+- 每周检查日志，确保任务正常运行
+- 每月检查索引质量，调整参数
+- 每季度评估算法效果，优化策略
+
+### 监控指标
+- 任务执行成功率
+- 索引生成数量
+- Redis命中率
+- 推荐点击率/转化率
+
+## 联系方式
+
+如有问题或建议，请联系推荐系统团队。
+
+---
+
+**文档版本**: v1.0  
+**最后更新**: 2025-10-16  
+**作者**: 推荐系统团队
+
@@ -0,0 +1,213 @@
+# 离线任务快速启动指南
+
+## 一、环境准备
+
+### 1. 安装依赖
+
+```bash
+cd /home/tw/recommendation
+pip install -r requirements.txt
+```
+
+### 2. 配置数据库和Redis
+
+编辑配置文件 `offline_tasks/config/offline_config.py`，确保数据库和Redis连接信息正确：
+
+```python
+# 数据库配置
+DB_CONFIG = {
+    'host': 'your_db_host',
+    'port': '9030',
+    'database': 'datacenter',
+    'username': 'readonly',
+    'password': 'your_password'
+}
+
+# Redis配置
+REDIS_CONFIG = {
+    'host': 'your_redis_host',
+    'port': 6379,
+    'db': 0,
+    'password': None
+}
+```
+
+## 二、运行离线任务
+
+### 方式1：运行所有任务（推荐）
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+python run_all.py --lookback_days 730 --top_n 50
+```
+
+这将依次运行：
+1. Swing算法（i2i相似度）
+2. Session Word2Vec（i2i相似度）
+3. DeepWalk算法（i2i相似度）
+4. 兴趣点聚合（多维度商品索引）
+
+### 方式2：运行单个任务
+
+#### 运行Swing算法
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+python scripts/i2i_swing.py --lookback_days 730 --top_n 50 --time_decay
+```
+
+#### 运行Session Word2Vec
+
+```bash
+python scripts/i2i_session_w2v.py --lookback_days 730 --top_n 50 --save_model
+```
+
+#### 运行DeepWalk
+
+```bash
+python scripts/i2i_deepwalk.py --lookback_days 730 --top_n 50 --save_model --save_graph
+```
+
+#### 运行兴趣点聚合
+
+```bash
+python scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+## 三、将索引加载到Redis
+
+任务运行完成后，将生成的索引加载到Redis：
+
+```bash
+cd /home/tw/recommendation/offline_tasks
+python scripts/load_index_to_redis.py --redis-host localhost --redis-port 6379 --expire-days 7
+```
+
+参数说明：
+- `--redis-host`: Redis服务器地址
+- `--redis-port`: Redis端口
+- `--redis-db`: Redis数据库编号（默认0）
+- `--expire-days`: 索引过期天数（默认7天）
+
+## 四、查看输出结果
+
+所有输出文件都在 `offline_tasks/output/` 目录下：
+
+```bash
+cd /home/tw/recommendation/offline_tasks/output
+ls -lh
+```
+
+输出文件示例：
+```
+i2i_swing_20251016.txt
+i2i_session_w2v_20251016.txt
+i2i_deepwalk_20251016.txt
+interest_aggregation_hot_20251016.txt
+interest_aggregation_cart_20251016.txt
+interest_aggregation_new_20251016.txt
+interest_aggregation_global_20251016.txt
+```
+
+## 五、查看日志
+
+所有运行日志都在 `offline_tasks/logs/` 目录下：
+
+```bash
+cd /home/tw/recommendation/offline_tasks/logs
+tail -f run_all_20251016.log
+```
+
+## 六、设置定时任务
+
+### 使用crontab设置每天运行
+
+```bash
+# 编辑crontab
+crontab -e
+
+# 添加以下行（每天凌晨2点运行）
+0 2 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 run_all.py --lookback_days 730 --top_n 50 >> /home/tw/recommendation/offline_tasks/logs/cron.log 2>&1
+```
+
+### 运行后自动加载到Redis
+
+可以在crontab中添加索引加载任务：
+
+```bash
+# 凌晨6点加载索引到Redis（假设离线任务在4小时内完成）
+0 6 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 scripts/load_index_to_redis.py >> /home/tw/recommendation/offline_tasks/logs/load_redis.log 2>&1
+```
+
+## 七、验证结果
+
+### 查看文件内容
+
+```bash
+# 查看i2i相似度
+head -n 5 output/i2i_swing_20251016.txt
+
+# 查看兴趣点聚合
+head -n 5 output/interest_aggregation_hot_20251016.txt
+```
+
+### 从Redis查询
+
+```bash
+# 使用redis-cli
+redis-cli
+
+# 查看i2i相似度
+GET i2i:swing:123456
+
+# 查看兴趣点索引
+GET interest:hot:platform:PC
+GET interest:global:country:US
+```
+
+## 八、常见问题
+
+### Q1: 任务运行时间太长怎么办？
+
+A: 可以尝试：
+1. 减少 `--lookback_days` 参数（如改为365天）
+2. 减少 `--top_n` 参数（如改为20）
+3. 在更强大的机器上运行
+4. 考虑分布式运行不同算法
+
+### Q2: 内存不足怎么办？
+
+A: 
+1. Swing算法特别消耗内存，可以先跳过：`python run_all.py --skip-i2i`
+2. 只运行DeepWalk或Session W2V
+3. 对数据进行采样
+
+### Q3: 数据库连接超时怎么办？
+
+A:
+1. 检查数据库配置是否正确
+2. 检查网络连接
+3. 增加SQL查询的超时时间
+4. 分批查询数据
+
+### Q4: 如何只更新特定维度的索引？
+
+A: 修改 `interest_aggregation.py` 脚本，注释掉不需要的维度计算代码。
+
+## 九、性能参考
+
+在标准配置（730天数据，top_n=50）下的预估运行时间：
+
+| 任务 | 数据量 | 预估时间 | 内存占用 |
+|------|--------|---------|---------|
+| Swing | 100万条行为 | 2-4小时 | 4-8GB |
+| Session W2V | 100万条行为 | 30-60分钟 | 2-4GB |
+| DeepWalk | 100万条行为 | 1-2小时 | 2-4GB |
+| 兴趣点聚合 | 100万条行为 | 30-60分钟 | 2-4GB |
+
+实际时间会因数据量和机器配置而异。
+
+## 十、联系与支持
+
+如有问题，请查看日志文件或联系开发团队。
+
@@ -0,0 +1,252 @@
+# 推荐系统离线任务
+
+本目录包含推荐系统的离线任务脚本，用于生成各种推荐索引。
+
+## 目录结构
+
+```
+offline_tasks/
+├── config/
+│   └── offline_config.py          # 离线任务配置文件
+├── scripts/
+│   ├── i2i_swing.py               # Swing算法实现
+│   ├── i2i_session_w2v.py         # Session Word2Vec实现
+│   ├── i2i_deepwalk.py            # DeepWalk算法实现
+│   └── interest_aggregation.py    # 兴趣点聚合索引生成
+├── output/                         # 输出目录
+├── logs/                           # 日志目录
+├── run_all.py                      # 统一调度脚本
+└── README.md                       # 本文档
+```
+
+## 功能说明
+
+### 1. i2i - 行为相似索引
+
+基于用户行为数据，计算商品之间的相似度，生成i2i（item-to-item）推荐索引。
+
+#### 1.1 Swing算法
+
+Swing算法是一种基于用户共同行为的物品相似度计算方法，相比协同过滤有更好的效果。
+
+**运行命令：**
+```bash
+python scripts/i2i_swing.py --lookback_days 730 --top_n 50 --time_decay
+```
+
+**参数说明：**
+- `--lookback_days`: 回溯天数（默认730天，即2年）
+- `--top_n`: 每个商品输出的相似商品数量（默认50）
+- `--alpha`: Swing算法的alpha参数（默认0.5）
+- `--time_decay`: 是否使用时间衰减
+- `--decay_factor`: 时间衰减因子（默认0.95，每30天衰减一次）
+
+**输出格式：**
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+#### 1.2 Session Word2Vec
+
+基于用户会话序列训练Word2Vec模型，学习商品的向量表示，通过向量相似度计算商品相似度。
+
+**运行命令：**
+```bash
+python scripts/i2i_session_w2v.py --lookback_days 730 --top_n 50 --save_model
+```
+
+**参数说明：**
+- `--lookback_days`: 回溯天数
+- `--top_n`: 输出相似商品数量
+- `--window_size`: Word2Vec窗口大小（默认5）
+- `--vector_size`: 向量维度（默认128）
+- `--min_count`: 最小词频（默认2）
+- `--workers`: 训练线程数（默认10）
+- `--epochs`: 训练轮数（默认10）
+- `--session_gap`: 会话间隔（分钟，默认30）
+- `--save_model`: 是否保存模型
+
+**输出格式：**
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+#### 1.3 DeepWalk
+
+基于用户-商品交互图，使用随机游走生成序列，然后训练Word2Vec模型。
+
+**运行命令：**
+```bash
+python scripts/i2i_deepwalk.py --lookback_days 730 --top_n 50 --save_model --save_graph
+```
+
+**参数说明：**
+- `--lookback_days`: 回溯天数
+- `--top_n`: 输出相似商品数量
+- `--num_walks`: 每个节点的游走次数（默认10）
+- `--walk_length`: 游走长度（默认40）
+- `--window_size`: Word2Vec窗口大小（默认5）
+- `--vector_size`: 向量维度（默认128）
+- `--save_model`: 是否保存模型
+- `--save_graph`: 是否保存图结构
+
+**输出格式：**
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+### 2. 兴趣点聚合索引
+
+按照多个维度聚合用户行为，生成不同场景下的商品推荐索引。
+
+**运行命令：**
+```bash
+python scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+**参数说明：**
+- `--lookback_days`: 回溯天数（默认730天，即2年）
+- `--recent_days`: 热门商品的统计天数（默认180天）
+- `--new_days`: 新品的定义天数（默认90天）
+- `--top_n`: 每个维度输出的商品数量（默认1000）
+- `--decay_factor`: 时间衰减因子（默认0.95）
+
+**支持的维度：**
+
+1. **单维度：**
+   - `platform`: 平台
+   - `country`: 国家/销售区域
+   - `customer_type`: 客户类型
+   - `category_level2`: 二级分类
+   - `category_level3`: 三级分类
+
+2. **组合维度：**
+   - `platform_country`: 平台 + 国家
+   - `platform_customer`: 平台 + 客户类型
+   - `country_customer`: 国家 + 客户类型
+   - `platform_country_customer`: 平台 + 国家 + 客户类型
+
+3. **列表类型：**
+   - `hot`: 热门商品（基于最近N天的高交互）
+   - `cart`: 加购商品（基于加购行为）
+   - `new`: 新品（基于商品创建时间）
+   - `global`: 全局索引（所有数据）
+
+**输出格式：**
+```
+dimension_key \t item_id1:score1,item_id2:score2,...
+```
+
+**示例：**
+```
+platform:PC \t 12345:98.5,23456:87.3,...
+country:US \t 34567:156.2,45678:142.8,...
+platform_country:PC_US \t 56789:234.5,67890:198.7,...
+```
+
+## 统一调度脚本
+
+使用 `run_all.py` 可以一次性运行所有离线任务：
+
+**运行所有任务：**
+```bash
+python run_all.py --lookback_days 730 --top_n 50
+```
+
+**运行特定任务：**
+```bash
+# 只运行Swing算法
+python run_all.py --only-swing
+
+# 只运行Session W2V
+python run_all.py --only-w2v
+
+# 只运行DeepWalk
+python run_all.py --only-deepwalk
+
+# 只运行兴趣点聚合
+python run_all.py --only-interest
+
+# 跳过i2i任务
+python run_all.py --skip-i2i
+
+# 跳过兴趣点聚合
+python run_all.py --skip-interest
+```
+
+## 配置文件
+
+所有配置参数都在 `config/offline_config.py` 中定义，包括：
+
+- **数据库配置**：数据库连接信息
+- **路径配置**：输出目录、日志目录
+- **时间配置**：回溯天数、时间衰减参数
+- **算法配置**：各算法的超参数
+- **行为权重**：不同行为类型的权重
+
+可以根据实际需求修改配置文件中的参数。
+
+## 输出文件
+
+所有输出文件都保存在 `output/` 目录下，文件名格式为：
+
+```
+{任务名}_{日期}.txt
+```
+
+例如：
+- `i2i_swing_20251016.txt`
+- `i2i_session_w2v_20251016.txt`
+- `i2i_deepwalk_20251016.txt`
+- `interest_aggregation_hot_20251016.txt`
+- `interest_aggregation_cart_20251016.txt`
+- `interest_aggregation_new_20251016.txt`
+- `interest_aggregation_global_20251016.txt`
+
+## 日志
+
+所有任务的执行日志都保存在 `logs/` 目录下。
+
+## 依赖项
+
+```bash
+pip install pandas sqlalchemy pymysql gensim numpy
+```
+
+## 定时任务设置
+
+建议使用crontab设置定时任务，每天凌晨运行一次：
+
+```bash
+# 编辑crontab
+crontab -e
+
+# 添加定时任务（每天凌晨2点运行）
+0 2 * * * cd /home/tw/recommendation/offline_tasks && /usr/bin/python3 run_all.py --lookback_days 730 --top_n 50
+```
+
+## 注意事项
+
+1. **数据量**：由于需要处理2年的数据，任务可能需要较长时间（几小时到十几小时不等）
+2. **内存占用**：Swing算法和DeepWalk可能占用较多内存，建议在内存充足的机器上运行
+3. **数据库连接**：确保数据库连接信息正确，且有足够的权限读取相关表
+4. **磁盘空间**：确保output目录有足够的磁盘空间存储输出文件
+
+## 性能优化建议
+
+1. **并行化**：可以将不同算法的任务分配到不同机器上并行运行
+2. **增量更新**：对于已有的索引，可以考虑增量更新而不是全量计算
+3. **采样**：对于数据量特别大的场景，可以考虑先采样一部分数据进行调试
+4. **缓存**：可以将中间结果缓存，避免重复计算
+
+## 问题排查
+
+如果任务执行失败，请检查：
+
+1. 日志文件中的错误信息
+2. 数据库连接是否正常
+3. 数据表结构是否正确
+4. Python依赖包是否安装完整
+5. 磁盘空间是否充足
+6. 内存是否充足
+
@@ -0,0 +1,302 @@
+# 🚀 从这里开始
+
+## 📦 项目交付完成
+
+根据您提供的业务文档和表结构，推荐系统离线任务已完成构建！
+
+---
+
+## ✅ 完成的功能
+
+### 1. i2i 索引（4种算法）
+
+#### 行为相似（3种）
+- ✅ **Swing算法** - 基于用户共同行为
+- ✅ **Session W2V** - 基于用户会话序列
+- ✅ **DeepWalk** - 基于图随机游走
+
+#### 内容相似（1种，3个方法）
+- ✅ **Content-based** - 基于商品属性（分类、供应商等）
+  - TF-IDF方法
+  - 分类方法
+  - 混合方法（推荐）
+
+### 2. 兴趣点聚合索引
+
+**支持的维度**（7个单维度 + 4个组合维度）：
+- ✅ 业务平台（platform）
+- ✅ 客户端平台（client_platform）
+- ✅ 供应商（supplier）
+- ✅ 一级分类（category_level1）
+- ✅ 二级分类（category_level2）
+- ✅ 三级分类（category_level3）
+- ✅ 四级分类（category_level4）
+- ✅ 平台+客户端
+- ✅ 平台+分类
+- ✅ 客户端+分类
+
+**支持的列表类型**（3种）：
+- ✅ 热门（hot）- 最近180天高交互
+- ✅ 加购（cart）- 加购行为
+- ✅ 新品（new）- 最近90天上架
+
+---
+
+## 🎯 快速开始（3步）
+
+### 步骤1: 安装依赖
+```bash
+cd /home/tw/recommendation/offline_tasks
+bash install.sh
+```
+
+### 步骤2: 测试连接
+```bash
+python3 test_connection.py
+```
+
+### 步骤3: 运行任务（小数据量测试）
+```bash
+# 先测试30天数据
+python3 scripts/i2i_swing.py --lookback_days 30 --top_n 10
+
+# 查看输出
+ls -lh output/
+head -5 output/i2i_swing_*.txt
+```
+
+### 步骤4: 运行完整任务
+```bash
+# 运行所有任务（约6-10小时）
+python3 run_all.py --lookback_days 730 --top_n 50
+
+# 或分别运行（推荐）
+python3 scripts/i2i_swing.py --lookback_days 730 --top_n 50
+python3 scripts/i2i_content_similar.py --top_n 50 --method hybrid
+python3 scripts/interest_aggregation.py --lookback_days 730 --top_n 1000
+```
+
+---
+
+## 📚 文档导航
+
+### 入门文档
+1. **START_HERE.md** ← 当前文档
+2. **QUICKSTART.md** - 5分钟快速上手
+3. **CURRENT_STATUS.md** - 当前功能状态
+
+### 技术文档
+4. **FINAL_UPDATE.md** - 最终更新说明
+5. **COMPLETE_INDEX_LIST.md** - 完整索引清单
+6. **README.md** - 详细使用文档
+7. **PROJECT_SUMMARY.md** - 技术架构
+
+### 配置文档
+8. **FIELD_MAPPING.md** - 字段映射说明
+9. **DATABASE_SETUP.md** - 数据库配置
+10. **TROUBLESHOOTING.md** - 故障排除
+
+### 参考文档
+11. **STRUCTURE.md** - 目录结构
+12. **CHANGELOG.md** - 更新日志
+13. **COMMANDS.txt** - 常用命令
+
+---
+
+## 📊 输出示例
+
+### i2i相似度索引
+```
+# 文件: output/i2i_swing_20251016.txt
+12345   商品A   23456:0.8523,34567:0.7842,45678:0.7234,...
+
+# Redis Key: i2i:swing:12345
+Value: 23456:0.8523,34567:0.7842,45678:0.7234,...
+```
+
+### 兴趣点聚合索引
+```
+# 文件: output/interest_aggregation_hot_20251016.txt
+platform:pc   12345:98.52,23456:87.34,34567:76.89,...
+category_level2:200   45678:156.23,56789:142.87,...
+
+# Redis Key: interest:hot:platform:pc
+Value: 12345:98.52,23456:87.34,34567:76.89,...
+```
+
+---
+
+## 🎬 业务场景映射
+
+根据您的3个业务场景：
+
+### 1. 首页猜你喜欢
+```python
+# 使用兴趣点聚合索引
+interest:hot:platform:pc
+interest:hot:category_level2:200
+interest:hot:platform_category2:pc_200
+```
+
+### 2. 详情页的大家都在看
+```python
+# 使用i2i相似索引
+i2i:swing:12345         # 行为相似
+i2i:content_hybrid:12345   # 内容相似
+```
+
+### 3. 搜索结果页底部的供应商推荐
+```python
+# 使用兴趣点聚合索引
+interest:global:category_level2:200
+interest:hot:supplier:10001
+```
+
+---
+
+## 🔢 关键数字
+
+| 指标 | 数值 |
+|------|------|
+| i2i算法数量 | 4种（3行为+1内容） |
+| 兴趣点维度数量 | 11个（7单+4组合） |
+| 支持的分类层级 | 4级 |
+| 列表类型 | 3种（热门/加购/新品） |
+| 预计索引总数 | 10000-50000条 |
+| 全部任务运行时间 | 6-10小时 |
+
+---
+
+## 💡 核心优势
+
+### 1. 完整性
+- ✅ 行为相似 + 内容相似
+- ✅ 短期热门 + 长期稳定
+- ✅ 粗粒度 + 细粒度
+
+### 2. 灵活性
+- ✅ 支持4级分类查询
+- ✅ 支持供应商维度
+- ✅ 支持多维度组合
+
+### 3. 可扩展性
+- ✅ 易于添加新维度
+- ✅ 易于添加新算法
+- ✅ 配置化管理
+
+### 4. 实用性
+- ✅ 适配真实数据
+- ✅ 参考现有代码
+- ✅ 文档完善
+
+---
+
+## ⚙️ 配置文件
+
+主要配置在 `config/offline_config.py`：
+
+```python
+# 时间配置
+LOOKBACK_DAYS = 730  # 2年数据
+
+# 行为权重
+behavior_weights = {
+    'click': 1.0,
+    'addToCart': 3.0,
+    'contactFactory': 5.0,
+    'purchase': 10.0
+}
+
+# 时间衰减
+time_decay_factor = 0.95  # 每30天衰减5%
+```
+
+---
+
+## 🔧 运行选项
+
+### 运行单个算法
+```bash
+python3 run_all.py --only-swing      # 只运行Swing
+python3 run_all.py --only-content    # 只运行内容相似
+python3 run_all.py --only-interest   # 只运行兴趣点聚合
+```
+
+### 跳过某些算法
+```bash
+python3 run_all.py --skip-i2i        # 跳过i2i
+python3 run_all.py --skip-interest   # 跳过兴趣点聚合
+```
+
+### 调整参数
+```bash
+# 小数据量测试
+python3 run_all.py --lookback_days 30 --top_n 10
+
+# 完整数据
+python3 run_all.py --lookback_days 730 --top_n 50
+```
+
+---
+
+## 📞 遇到问题？
+
+### 1. 字段错误
+查看：**FIELD_MAPPING.md** 和 **DATABASE_SETUP.md**
+
+### 2. 运行错误
+查看：**TROUBLESHOOTING.md**
+
+### 3. 使用疑问
+查看：**README.md** 和 **COMPLETE_INDEX_LIST.md**
+
+### 4. 查看日志
+```bash
+tail -f logs/run_all_*.log
+```
+
+---
+
+## 🎉 开始使用
+
+```bash
+# 1. 进入目录
+cd /home/tw/recommendation/offline_tasks
+
+# 2. 安装依赖
+bash install.sh
+
+# 3. 测试连接
+python3 test_connection.py
+
+# 4. 运行任务
+python3 run_all.py --lookback_days 730 --top_n 50
+
+# 5. 查看输出
+ls -lh output/
+head -5 output/*
+
+# 6. 加载到Redis（可选）
+python3 scripts/load_index_to_redis.py
+```
+
+---
+
+## 📦 交付清单
+
+- ✅ 4种i2i算法实现
+- ✅ 兴趣点聚合（11个维度）
+- ✅ 统一调度脚本
+- ✅ Redis加载工具
+- ✅ 测试和示例脚本
+- ✅ 13份完整文档
+- ✅ 配置文件和依赖清单
+
+---
+
+**状态**: ✅ 已完成并可用  
+**版本**: v1.1  
+**日期**: 2025-10-16  
+**代码行数**: ~2500行
+
+**开始探索**: 建议先阅读 **QUICKSTART.md**
@@ -0,0 +1,303 @@
+# 项目目录结构
+
+```
+/home/tw/recommendation/
+│
+├── db_service.py                    # 数据库连接服务（共享模块）
+├── requirements.txt                 # Python依赖包列表
+│
+├── offline_tasks/                   # 【离线任务主目录】
+│   │
+│   ├── config/                      # 配置目录
+│   │   └── offline_config.py       # 离线任务配置文件
+│   │                                  - 数据库配置
+│   │                                  - Redis配置
+│   │                                  - 算法参数配置
+│   │                                  - 时间配置
+│   │
+│   ├── scripts/                     # 脚本目录
+│   │   ├── i2i_swing.py            # Swing算法实现
+│   │   │                              输出: i2i_swing_YYYYMMDD.txt
+│   │   │
+│   │   ├── i2i_session_w2v.py      # Session Word2Vec算法
+│   │   │                              输出: i2i_session_w2v_YYYYMMDD.txt
+│   │   │                                   session_w2v_model_YYYYMMDD.model
+│   │   │
+│   │   ├── i2i_deepwalk.py         # DeepWalk算法
+│   │   │                              输出: i2i_deepwalk_YYYYMMDD.txt
+│   │   │                                   deepwalk_model_YYYYMMDD.model
+│   │   │                                   item_graph_YYYYMMDD.txt
+│   │   │
+│   │   ├── interest_aggregation.py # 兴趣点聚合索引生成
+│   │   │                              输出: interest_aggregation_hot_YYYYMMDD.txt
+│   │   │                                   interest_aggregation_cart_YYYYMMDD.txt
+│   │   │                                   interest_aggregation_new_YYYYMMDD.txt
+│   │   │                                   interest_aggregation_global_YYYYMMDD.txt
+│   │   │
+│   │   └── load_index_to_redis.py  # 索引加载到Redis
+│   │
+│   ├── output/                      # 输出目录（自动创建）
+│   │   ├── i2i_swing_*.txt         # Swing算法输出
+│   │   ├── i2i_session_w2v_*.txt   # Session W2V输出
+│   │   ├── i2i_deepwalk_*.txt      # DeepWalk输出
+│   │   ├── interest_aggregation_*  # 兴趣点聚合输出
+│   │   ├── *.model                 # 训练的模型文件
+│   │   └── item_graph_*.txt        # 物品图结构
+│   │
+│   ├── logs/                        # 日志目录（自动创建）
+│   │   ├── run_all_*.log           # 总调度日志
+│   │   ├── load_redis.log          # Redis加载日志
+│   │   └── cron.log                # 定时任务日志
+│   │
+│   ├── run_all.py                   # 【主调度脚本】
+│   │                                  统一运行所有离线任务
+│   │
+│   ├── install.sh                   # 安装脚本
+│   │                                  自动安装依赖和初始化
+│   │
+│   ├── test_connection.py           # 连接测试脚本
+│   │                                  测试数据库和Redis连接
+│   │
+│   ├── example_query_redis.py       # Redis查询示例
+│   │                                  演示如何查询索引
+│   │
+│   ├── README.md                    # 详细文档
+│   ├── QUICKSTART.md                # 快速开始指南
+│   ├── PROJECT_SUMMARY.md           # 项目总结
+│   └── STRUCTURE.md                 # 本文档
+│
+├── item_sim.py                      # 原有的物品相似度脚本（参考）
+├── hot/                             # 原有的热门商品模块（参考）
+├── collaboration/                   # 原有的协同过滤模块（参考）
+└── graphembedding/                  # 原有的图嵌入模块（参考）
+```
+
+## 数据流向图
+
+```
+┌─────────────────┐
+│   数据源         │
+│  (SelectDB)     │
+└────────┬────────┘
+         │
+         │ SQL查询
+         │
+         ▼
+┌─────────────────────────────────────────────────────────┐
+│                    离线任务处理                          │
+│                                                          │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
+│  │ Swing算法    │  │ Session W2V  │  │ DeepWalk算法 │  │
+│  │              │  │              │  │              │  │
+│  │ 用户行为共现  │  │ 会话序列     │  │ 图随机游走   │  │
+│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘  │
+│         │                 │                 │           │
+│         └─────────────────┴─────────────────┘           │
+│                           │                              │
+│                           │ i2i相似度索引                │
+│                           ▼                              │
+│                  ┌─────────────────┐                     │
+│                  │  输出文件(.txt) │                     │
+│                  └─────────────────┘                     │
+│                                                          │
+│  ┌──────────────────────────────────────────────────┐   │
+│  │           兴趣点聚合                              │   │
+│  │                                                   │   │
+│  │  按维度分组: 平台/国家/客户类型/分类              │   │
+│  │  按类型分组: 热门/加购/新品/全局                  │   │
+│  │  时间衰减 + 行为权重                              │   │
+│  └────────────────────┬─────────────────────────────┘   │
+│                       │                                  │
+│                       │ 多维度索引                       │
+│                       ▼                                  │
+│              ┌─────────────────┐                         │
+│              │  输出文件(.txt) │                         │
+│              └─────────────────┘                         │
+└─────────────────────────────────────────────────────────┘
+                       │
+                       │ 加载
+                       ▼
+              ┌─────────────────┐
+              │     Redis        │
+              │   (在线索引)     │
+              └────────┬────────┘
+                       │
+                       │ 查询
+                       ▼
+              ┌─────────────────┐
+              │   在线推荐服务   │
+              │                  │
+              │ - 详情页推荐     │
+              │ - 首页推荐       │
+              │ - 搜索推荐       │
+              └──────────────────┘
+```
+
+## 核心模块说明
+
+### 1. 配置模块
+**文件**: `config/offline_config.py`
+
+**职责**:
+- 数据库连接配置
+- Redis连接配置
+- 算法超参数配置
+- 行为权重配置
+- 时间范围配置
+
+### 2. i2i相似度模块
+
+#### 2.1 Swing算法
+**文件**: `scripts/i2i_swing.py`
+
+**输入**: 用户行为数据（user_id, item_id, event_type, create_time）
+
+**核心逻辑**:
+```python
+# 对于物品i和j，计算它们的Swing相似度
+for user_u in common_users:
+    for user_v in common_users:
+        common_items = items_u ∩ items_v
+        sim(i, j) += 1 / (alpha + |common_items|)
+```
+
+**输出**: `i2i_swing_YYYYMMDD.txt`
+```
+item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+```
+
+#### 2.2 Session Word2Vec
+**文件**: `scripts/i2i_session_w2v.py`
+
+**输入**: 用户会话序列
+
+**核心逻辑**:
+1. 按时间间隔切分用户会话
+2. 训练Word2Vec模型
+3. 计算物品向量相似度
+
+**输出**: 
+- `i2i_session_w2v_YYYYMMDD.txt`
+- `session_w2v_model_YYYYMMDD.model`
+
+#### 2.3 DeepWalk
+**文件**: `scripts/i2i_deepwalk.py`
+
+**输入**: 用户-物品交互数据
+
+**核心逻辑**:
+1. 构建物品共现图
+2. 执行随机游走生成序列
+3. 训练Word2Vec模型
+4. 计算物品向量相似度
+
+**输出**:
+- `i2i_deepwalk_YYYYMMDD.txt`
+- `deepwalk_model_YYYYMMDD.model`
+- `item_graph_YYYYMMDD.txt`
+
+### 3. 兴趣点聚合模块
+**文件**: `scripts/interest_aggregation.py`
+
+**输入**: 用户行为数据 + 用户特征
+
+**核心逻辑**:
+```python
+# 按维度聚合
+for each behavior:
+    weight = behavior_weight * time_weight
+    aggregations[dimension_key][item_id] += weight
+
+# 排序并输出top N
+for dimension_key, items in aggregations:
+    output top_n items sorted by weight
+```
+
+**维度组合**:
+- 单维度: platform, country, customer_type, category_level2, category_level3
+- 组合维度: platform_country, platform_customer, country_customer, platform_country_customer
+
+**列表类型**:
+- hot: 最近180天高交互
+- cart: 加购行为
+- new: 新品（最近90天上架）
+- global: 全局（所有数据）
+
+**输出**: 
+- `interest_aggregation_hot_YYYYMMDD.txt`
+- `interest_aggregation_cart_YYYYMMDD.txt`
+- `interest_aggregation_new_YYYYMMDD.txt`
+- `interest_aggregation_global_YYYYMMDD.txt`
+
+### 4. Redis加载模块
+**文件**: `scripts/load_index_to_redis.py`
+
+**职责**: 将生成的索引文件加载到Redis
+
+**Redis Key格式**:
+- i2i索引: `i2i:{algorithm}:{item_id}`
+- 兴趣点索引: `interest:{list_type}:{dimension_key}`
+
+**示例**:
+```
+i2i:swing:123456 -> "234567:0.8523,345678:0.7842,..."
+interest:hot:platform:PC -> "12345:98.52,23456:87.34,..."
+```
+
+### 5. 统一调度模块
+**文件**: `run_all.py`
+
+**职责**: 按顺序运行所有离线任务
+
+**执行流程**:
+1. 运行Swing算法
+2. 运行Session W2V
+3. 运行DeepWalk
+4. 运行兴趣点聚合
+5. 记录日志和统计
+
+## 使用场景映射
+
+| 业务场景 | 使用的索引 | Redis Key示例 |
+|---------|-----------|--------------|
+| 详情页 - 大家都在看 | i2i相似度 | `i2i:swing:{item_id}` |
+| 首页 - 猜你喜欢 | 兴趣点聚合 | `interest:hot:platform_country:{platform}_{country}` |
+| 搜索 - 相关推荐 | 兴趣点聚合 + i2i | `interest:global:category_level2:{cat_id}` |
+| 购物车 - 可能喜欢 | 兴趣点聚合(cart) | `interest:cart:customer_type:{type}` |
+| 新品推荐 | 兴趣点聚合(new) | `interest:new:platform:{platform}` |
+
+## 配置调优参数
+
+### 时间相关
+- `LOOKBACK_DAYS`: 730 (2年)
+- `RECENT_DAYS`: 180 (热门商品统计)
+- `NEW_DAYS`: 90 (新品定义)
+- `decay_factor`: 0.95 (时间衰减)
+
+### 算法相关
+- Swing `alpha`: 0.5
+- W2V `vector_size`: 128
+- W2V `window_size`: 5
+- DeepWalk `num_walks`: 10
+- DeepWalk `walk_length`: 40
+
+### 输出相关
+- i2i `top_n`: 50
+- 兴趣点 `top_n`: 1000
+
+## 性能优化要点
+
+1. **Swing算法**: 使用C++版本可提升10倍性能
+2. **并行化**: 将不同算法分配到不同机器
+3. **增量更新**: 只更新变化的部分
+4. **数据采样**: 调试时使用采样数据
+5. **批量加载**: Redis使用pipeline批量加载
+
+## 监控指标
+
+- 任务执行时间
+- 生成索引数量
+- Redis内存占用
+- 推荐点击率
+- 推荐转化率
+
@@ -0,0 +1,217 @@
+# 故障排除指南
+
+## 常见问题及解决方案
+
+### 1. 数据库字段错误
+
+#### 问题：
+```
+pymysql.err.OperationalError: (1105, "errCode = 2, detailMessage = Unknown column 'xxx' in 'xxx'")
+```
+
+#### 原因：
+数据库表结构与代码中使用的字段名不匹配。
+
+#### 解决方案：
+1. 查看 `DATABASE_SETUP.md` 了解如何配置字段
+2. 修改对应脚本中的SQL查询，使用实际存在的字段名
+3. 如果是分类字段不存在，这些字段是可选的，代码会自动跳过
+
+#### 已修复的字段：
+- ✅ `category_level2_id` 和 `category_level3_id` 现在是可选的
+- ✅ 基础功能不依赖分类字段
+
+---
+
+### 2. 连接超时
+
+#### 问题：
+```
+pymysql.err.OperationalError: (2003, "Can't connect to MySQL server...")
+```
+
+#### 解决方案：
+1. 检查数据库配置：`config/offline_config.py`
+2. 确认网络连接和防火墙设置
+3. 运行测试：`python3 test_connection.py`
+
+---
+
+### 3. 内存不足
+
+#### 问题：
+程序运行时内存占用过高或被杀死。
+
+#### 解决方案：
+1. 减少回溯天数：`--lookback_days 365`（从730改为365）
+2. 减少输出数量：`--top_n 20`（从50改为20）
+3. 先运行单个算法：
+   ```bash
+   python3 scripts/i2i_session_w2v.py  # 内存占用较小
+   ```
+4. 跳过Swing算法（内存占用最大）：
+   ```bash
+   python3 run_all.py --skip-i2i
+   ```
+
+---
+
+### 4. 运行时间过长
+
+#### 解决方案：
+1. 减少数据量：`--lookback_days 180`
+2. 只运行特定算法：
+   ```bash
+   python3 run_all.py --only-w2v
+   ```
+3. 考虑使用C++版本的Swing（性能提升10倍）
+
+---
+
+### 5. 依赖包安装失败
+
+#### 解决方案：
+```bash
+# 单独安装失败的包
+pip3 install pandas sqlalchemy pymysql gensim numpy
+
+# 或使用国内镜像
+pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+---
+
+### 6. Redis连接失败
+
+#### 问题：
+```
+redis.exceptions.ConnectionError: Error connecting to Redis
+```
+
+#### 解决方案：
+1. Redis是可选的，只影响索引加载功能
+2. 如果不需要Redis，可以跳过：
+   ```bash
+   python3 run_all.py  # 只运行离线任务，不加载到Redis
+   ```
+3. 如果需要Redis，确认Redis已安装并运行：
+   ```bash
+   redis-cli ping  # 应该返回 PONG
+   ```
+
+---
+
+### 7. 输出文件为空
+
+#### 可能原因：
+1. 数据量太少（没有满足最小阈值）
+2. 时间范围内没有数据
+3. SQL查询条件过于严格
+
+#### 解决方案：
+1. 检查日志：`tail -f logs/run_all_*.log`
+2. 调整参数：
+   - 增加时间范围：`--lookback_days 1000`
+   - 减少阈值：修改配置文件中的 `min_interaction_count`
+3. 检查数据库中是否有数据：
+   ```python
+   # 运行简单查询测试
+   python3 test_connection.py
+   ```
+
+---
+
+### 8. 权限问题
+
+#### 问题：
+```
+PermissionError: [Errno 13] Permission denied
+```
+
+#### 解决方案：
+```bash
+# 给脚本添加执行权限
+chmod +x install.sh run_all.py
+
+# 确保有写入权限
+chmod 755 output/ logs/
+```
+
+---
+
+### 9. Python版本问题
+
+#### 要求：
+Python 3.7+
+
+#### 检查版本：
+```bash
+python3 --version
+```
+
+#### 如果版本过低，需要升级Python
+
+---
+
+### 10. 编码问题
+
+#### 问题：
+```
+UnicodeDecodeError: 'utf-8' codec can't decode byte...
+```
+
+#### 解决方案：
+确保所有文件使用UTF-8编码，特别是配置文件和输出文件。
+
+---
+
+## 调试技巧
+
+### 1. 查看详细日志
+```bash
+tail -f logs/run_all_*.log
+```
+
+### 2. 运行单个任务（便于调试）
+```bash
+python3 scripts/i2i_swing.py --lookback_days 30 --top_n 10
+```
+
+### 3. 使用较小的数据量测试
+```bash
+python3 run_all.py --lookback_days 30 --top_n 10
+```
+
+### 4. 检查中间结果
+```bash
+ls -lh output/
+head -n 20 output/i2i_swing_*.txt
+```
+
+---
+
+## 获取支持
+
+如果以上方法都无法解决问题：
+
+1. **查看文档**：
+   - `README.md` - 详细说明
+   - `DATABASE_SETUP.md` - 数据库配置
+   - `QUICKSTART.md` - 快速开始
+
+2. **查看日志**：
+   - `logs/` 目录下的所有日志文件
+
+3. **简化测试**：
+   - 先运行 `test_connection.py`
+   - 再运行单个脚本
+   - 使用小数据量测试
+
+4. **记录错误信息**：
+   - 完整的错误堆栈
+   - 使用的命令
+   - 配置文件内容
+
+---
+
+**提示**：大部分问题都与数据库字段名不匹配有关，请优先查看 `DATABASE_SETUP.md`。
@@ -0,0 +1,205 @@
+# 配置参数调整指南
+
+## 📝 概述
+
+所有默认参数现在都集中在配置文件中，便于统一管理和调整。
+
+## 🎯 主要默认参数
+
+### 在 `config/offline_config.py` 中配置：
+
+```python
+# 时间配置
+DEFAULT_LOOKBACK_DAYS = 30    # 默认回看天数
+DEFAULT_RECENT_DAYS = 7       # 默认最近天数
+
+# i2i算法参数
+DEFAULT_I2I_TOP_N = 50        # 默认返回Top N个相似商品
+
+# 兴趣聚合参数
+DEFAULT_INTEREST_TOP_N = 1000  # 默认每个key返回Top N个商品
+```
+
+## 🔧 调试与生产切换
+
+### 调试阶段（当前配置）
+
+```python
+DEFAULT_LOOKBACK_DAYS = 30    # 30天数据，快速验证
+DEFAULT_RECENT_DAYS = 7       # 7天最近数据
+DEFAULT_I2I_TOP_N = 50        # Top 50
+DEFAULT_INTEREST_TOP_N = 1000 # Top 1000
+```
+
+**预估运行时间**：30-60分钟  
+**内存占用**：2-4GB
+
+### 生产环境配置
+
+```python
+DEFAULT_LOOKBACK_DAYS = 730   # 2年历史数据，更准确
+DEFAULT_RECENT_DAYS = 180     # 半年最近数据
+DEFAULT_I2I_TOP_N = 50        # Top 50
+DEFAULT_INTEREST_TOP_N = 1000 # Top 1000
+```
+
+**预估运行时间**：6-10小时  
+**内存占用**：8-16GB
+
+## 🚀 使用方式
+
+### 1. 使用默认配置运行
+
+```bash
+# 使用配置文件中的默认值（当前为30天）
+python3 run_all.py
+```
+
+### 2. 临时覆盖默认值
+
+```bash
+# 临时使用不同的参数，不修改配置文件
+python3 run_all.py --lookback_days 7 --top_n 20
+```
+
+### 3. 修改配置文件（推荐）
+
+编辑 `config/offline_config.py`：
+
+```python
+# 调试完成后，改为生产配置
+DEFAULT_LOOKBACK_DAYS = 730
+DEFAULT_RECENT_DAYS = 180
+```
+
+然后运行：
+
+```bash
+python3 run_all.py
+```
+
+## 📊 各脚本的默认参数
+
+所有脚本都会从配置文件读取默认值：
+
+| 脚本 | 参数 | 默认值 | 来源 |
+|------|------|--------|------|
+| `i2i_swing.py` | `--lookback_days` | 30 | `DEFAULT_LOOKBACK_DAYS` |
+| `i2i_swing.py` | `--top_n` | 50 | `DEFAULT_I2I_TOP_N` |
+| `i2i_session_w2v.py` | `--lookback_days` | 30 | `DEFAULT_LOOKBACK_DAYS` |
+| `i2i_session_w2v.py` | `--top_n` | 50 | `DEFAULT_I2I_TOP_N` |
+| `i2i_deepwalk.py` | `--lookback_days` | 30 | `DEFAULT_LOOKBACK_DAYS` |
+| `i2i_deepwalk.py` | `--top_n` | 50 | `DEFAULT_I2I_TOP_N` |
+| `i2i_content_similar.py` | `--top_n` | 50 | `DEFAULT_I2I_TOP_N` |
+| `interest_aggregation.py` | `--lookback_days` | 30 | `DEFAULT_LOOKBACK_DAYS` |
+| `interest_aggregation.py` | `--top_n` | 1000 | `DEFAULT_INTEREST_TOP_N` |
+
+## 💡 调试建议
+
+### 第一次运行（验证流程）
+
+```bash
+# 使用最小数据量快速验证
+python3 run_all.py --lookback_days 7 --top_n 10
+```
+
+### 第二次运行（调试参数）
+
+```python
+# 修改配置文件为30天
+DEFAULT_LOOKBACK_DAYS = 30
+```
+
+```bash
+python3 run_all.py
+```
+
+### 第三次运行（生产环境）
+
+```python
+# 修改配置文件为730天
+DEFAULT_LOOKBACK_DAYS = 730
+DEFAULT_RECENT_DAYS = 180
+```
+
+```bash
+python3 run_all.py
+```
+
+## 🔍 其他可调整的配置
+
+### i2i算法详细配置
+
+在 `offline_config.py` 的 `I2I_CONFIG` 中：
+
+```python
+I2I_CONFIG = {
+    'swing': {
+        'alpha': 0.5,           # swing算法的alpha参数
+        'threshold1': 0.5,      # 交互强度阈值1
+        'threshold2': 0.5,      # 交互强度阈值2
+        'max_sim_list_len': 300,  # 最大相似列表长度
+        'top_n': 50,            # 输出top N个相似商品
+    },
+    # ...其他算法配置
+}
+```
+
+### 兴趣聚合详细配置
+
+```python
+INTEREST_AGGREGATION_CONFIG = {
+    'top_n': 1000,              # 每个key生成前N个商品
+    'time_decay_factor': 0.95,  # 时间衰减因子（每30天）
+    'min_interaction_count': 2,  # 最小交互次数
+    
+    'behavior_weights': {
+        'click': 1.0,
+        'addToCart': 3.0,
+        'addToPool': 2.0,
+        'contactFactory': 5.0,
+        'purchase': 10.0,
+    },
+}
+```
+
+## 📌 注意事项
+
+1. **调试优先**：先用小数据量（7-30天）验证流程
+2. **逐步扩大**：确认无误后再增加到生产数据量
+3. **监控资源**：注意内存和磁盘空间使用情况
+4. **保存配置**：在配置文件中注释记录不同场景的参数值
+
+## 🎯 快速切换环境
+
+创建不同的配置副本：
+
+```bash
+# 备份当前配置
+cp config/offline_config.py config/offline_config_debug.py
+cp config/offline_config.py config/offline_config_prod.py
+
+# 使用不同配置
+cp config/offline_config_debug.py config/offline_config.py  # 调试模式
+cp config/offline_config_prod.py config/offline_config.py   # 生产模式
+```
+
+## ✅ 验证配置
+
+查看当前默认值：
+
+```bash
+python3 -c "from config.offline_config import *; print(f'LOOKBACK_DAYS: {DEFAULT_LOOKBACK_DAYS}')"
+```
+
+查看帮助信息：
+
+```bash
+python3 run_all.py --help
+```
+
+---
+
+**配置文件位置**: `config/offline_config.py`  
+**当前默认配置**: 30天调试模式  
+**建议**: 调试通过后修改为730天生产模式
@@ -0,0 +1,65 @@
+"""
+检查数据库表结构
+用于确认字段名称
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import DB_CONFIG
+import pandas as pd
+
+# 创建数据库连接
+print("连接数据库...")
+engine = create_db_connection(
+    DB_CONFIG['host'],
+    DB_CONFIG['port'],
+    DB_CONFIG['database'],
+    DB_CONFIG['username'],
+    DB_CONFIG['password']
+)
+
+print("\n" + "="*80)
+print("检查 prd_goods_sku 表结构")
+print("="*80)
+
+# 查看表结构
+try:
+    df = pd.read_sql("DESCRIBE prd_goods_sku", engine)
+    print("\n表字段列表：")
+    print(df.to_string())
+except Exception as e:
+    print(f"无法获取表结构: {e}")
+    print("\n尝试查询前5条记录来推断结构...")
+    try:
+        df = pd.read_sql("SELECT * FROM prd_goods_sku LIMIT 5", engine)
+        print("\n列名列表：")
+        for col in df.columns:
+            print(f"  - {col}")
+    except Exception as e2:
+        print(f"查询失败: {e2}")
+
+print("\n" + "="*80)
+print("检查 sensors_events 表结构")
+print("="*80)
+
+try:
+    df = pd.read_sql("DESCRIBE sensors_events", engine)
+    print("\n表字段列表：")
+    print(df.to_string())
+except Exception as e:
+    print(f"无法获取表结构: {e}")
+    print("\n尝试查询前5条记录来推断结构...")
+    try:
+        df = pd.read_sql("SELECT * FROM sensors_events LIMIT 5", engine)
+        print("\n列名列表：")
+        for col in df.columns:
+            print(f"  - {col}")
+    except Exception as e2:
+        print(f"查询失败: {e2}")
+
+print("\n" + "="*80)
+print("检查完成")
+print("="*80)
+
@@ -0,0 +1,120 @@
+"""
+离线任务配置文件
+包含数据库连接、路径、参数等配置
+"""
+import os
+from datetime import datetime, timedelta
+
+# 数据库配置
+DB_CONFIG = {
+    'host': 'selectdb-cn-wuf3vsokg05-public.selectdbfe.rds.aliyuncs.com',
+    'port': '9030',
+    'database': 'datacenter',
+    'username': 'readonly',
+    'password': 'essa1234'
+}
+
+# 路径配置
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+OUTPUT_DIR = os.path.join(BASE_DIR, 'output')
+LOG_DIR = os.path.join(BASE_DIR, 'logs')
+
+# 确保目录存在
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(LOG_DIR, exist_ok=True)
+
+# ============================================================================
+# 默认参数配置（用于调试和生产）
+# ============================================================================
+
+# 时间配置（建议先用小数值调试，确认无误后再改为大数值）
+DEFAULT_LOOKBACK_DAYS = 30    # 默认回看天数（调试用30天，生产可改为730天）
+DEFAULT_RECENT_DAYS = 7       # 默认最近天数（调试用7天，生产可改为180天）
+
+# i2i算法默认参数
+DEFAULT_I2I_TOP_N = 50        # 默认返回Top N个相似商品
+
+# 兴趣聚合默认参数
+DEFAULT_INTEREST_TOP_N = 1000  # 默认每个key返回Top N个商品
+
+# 获取时间范围
+def get_time_range(days=DEFAULT_LOOKBACK_DAYS):
+    """获取时间范围"""
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=days)
+    return start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d')
+
+# i2i 行为相似算法配置
+I2I_CONFIG = {
+    # Swing 算法配置
+    'swing': {
+        'alpha': 0.5,           # swing算法的alpha参数
+        'threshold1': 0.5,      # 交互强度阈值1
+        'threshold2': 0.5,      # 交互强度阈值2
+        'max_sim_list_len': 300,  # 最大相似列表长度
+        'top_n': 50,            # 输出top N个相似商品
+        'thread_num': 10,       # 线程数（如果使用C++版本）
+    },
+    
+    # Session W2V 配置
+    'session_w2v': {
+        'max_sentence_length': 100,  # 最大句子长度
+        'window_size': 5,            # 窗口大小
+        'vector_size': 128,          # 向量维度
+        'min_count': 2,              # 最小词频
+        'workers': 10,               # 训练线程数
+        'epochs': 10,                # 训练轮数
+        'sg': 1,                     # 使用skip-gram
+    },
+    
+    # DeepWalk 配置
+    'deepwalk': {
+        'num_walks': 10,         # 每个节点的游走次数
+        'walk_length': 40,       # 游走长度
+        'window_size': 5,        # 窗口大小
+        'vector_size': 128,      # 向量维度
+        'min_count': 2,          # 最小词频
+        'workers': 10,           # 训练线程数
+        'epochs': 10,            # 训练轮数
+        'sg': 1,                 # 使用skip-gram
+        'use_softmax': True,     # 使用softmax
+        'temperature': 1.0,      # softmax温度
+        'p_tag_walk': 0.2,       # 通过标签游走的概率
+    }
+}
+
+# 兴趣点聚合配置
+INTEREST_AGGREGATION_CONFIG = {
+    'top_n': 1000,              # 每个key生成前N个商品
+    'time_decay_factor': 0.95,  # 时间衰减因子（每30天）
+    'min_interaction_count': 2,  # 最小交互次数
+    
+    # 行为权重
+    'behavior_weights': {
+        'click': 1.0,
+        'addToCart': 3.0,
+        'addToPool': 2.0,
+        'contactFactory': 5.0,
+        'purchase': 10.0,
+    },
+    
+    # 类型配置
+    'list_types': ['hot', 'cart', 'new'],  # 热门、加购、新品
+}
+
+# Redis配置（用于存储索引）
+REDIS_CONFIG = {
+    'host': 'localhost',
+    'port': 6379,
+    'db': 0,
+    'password': None,
+    'decode_responses': False
+}
+
+# 日志配置
+LOG_CONFIG = {
+    'level': 'INFO',
+    'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    'date_format': '%Y-%m-%d %H:%M:%S'
+}
+
@@ -0,0 +1,170 @@
+"""
+示例：从Redis查询推荐结果
+演示如何使用生成的索引进行在线推荐
+"""
+import redis
+import argparse
+from offline_tasks.config.offline_config import REDIS_CONFIG
+
+
+def query_i2i_similar_items(redis_client, item_id, algorithm='swing', top_n=10):
+    """
+    查询物品的相似物品
+    
+    Args:
+        redis_client: Redis客户端
+        item_id: 物品ID
+        algorithm: 算法类型 (swing/session_w2v/deepwalk)
+        top_n: 返回前N个结果
+    
+    Returns:
+        List of (item_id, score)
+    """
+    key = f"i2i:{algorithm}:{item_id}"
+    value = redis_client.get(key)
+    
+    if not value:
+        return []
+    
+    # 解析结果
+    results = []
+    items = value.split(',')
+    for item in items[:top_n]:
+        parts = item.split(':')
+        if len(parts) == 2:
+            results.append((parts[0], float(parts[1])))
+    
+    return results
+
+
+def query_interest_items(redis_client, dimension_key, list_type='hot', top_n=20):
+    """
+    查询兴趣点聚合的推荐物品
+    
+    Args:
+        redis_client: Redis客户端
+        dimension_key: 维度key (如 platform:PC, country:US)
+        list_type: 列表类型 (hot/cart/new/global)
+        top_n: 返回前N个结果
+    
+    Returns:
+        List of (item_id, score)
+    """
+    key = f"interest:{list_type}:{dimension_key}"
+    value = redis_client.get(key)
+    
+    if not value:
+        return []
+    
+    # 解析结果
+    results = []
+    items = value.split(',')
+    for item in items[:top_n]:
+        parts = item.split(':')
+        if len(parts) == 2:
+            results.append((parts[0], float(parts[1])))
+    
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Query recommendation results from Redis')
+    parser.add_argument('--redis-host', type=str, default=REDIS_CONFIG.get('host', 'localhost'),
+                       help='Redis host')
+    parser.add_argument('--redis-port', type=int, default=REDIS_CONFIG.get('port', 6379),
+                       help='Redis port')
+    parser.add_argument('--redis-db', type=int, default=REDIS_CONFIG.get('db', 0),
+                       help='Redis database')
+    
+    args = parser.parse_args()
+    
+    # 创建Redis连接
+    print("Connecting to Redis...")
+    redis_client = redis.Redis(
+        host=args.redis_host,
+        port=args.redis_port,
+        db=args.redis_db,
+        decode_responses=True
+    )
+    
+    try:
+        redis_client.ping()
+        print("✓ Redis connected\n")
+    except Exception as e:
+        print(f"✗ Failed to connect to Redis: {e}")
+        return 1
+    
+    # 示例1: 查询i2i相似物品
+    print("="*80)
+    print("示例1: 查询物品的相似物品（i2i）")
+    print("="*80)
+    
+    test_item_id = "123456"  # 替换为实际的物品ID
+    
+    for algorithm in ['swing', 'session_w2v', 'deepwalk']:
+        print(f"\n算法: {algorithm}")
+        results = query_i2i_similar_items(redis_client, test_item_id, algorithm, top_n=5)
+        
+        if results:
+            print(f"物品 {test_item_id} 的相似物品:")
+            for idx, (item_id, score) in enumerate(results, 1):
+                print(f"  {idx}. 物品ID: {item_id}, 相似度: {score:.4f}")
+        else:
+            print(f"  未找到物品 {test_item_id} 的相似物品")
+    
+    # 示例2: 查询兴趣点推荐
+    print("\n" + "="*80)
+    print("示例2: 查询兴趣点聚合推荐")
+    print("="*80)
+    
+    # 测试不同维度
+    test_cases = [
+        ('platform', 'PC', 'hot'),
+        ('country', 'US', 'hot'),
+        ('customer_type', 'retailer', 'cart'),
+        ('category_level2', '100', 'new'),
+    ]
+    
+    for dimension, value, list_type in test_cases:
+        dimension_key = f"{dimension}:{value}"
+        print(f"\n维度: {dimension_key}, 类型: {list_type}")
+        results = query_interest_items(redis_client, dimension_key, list_type, top_n=5)
+        
+        if results:
+            print(f"推荐物品:")
+            for idx, (item_id, score) in enumerate(results, 1):
+                print(f"  {idx}. 物品ID: {item_id}, 分数: {score:.4f}")
+        else:
+            print(f"  未找到推荐结果")
+    
+    # 示例3: 组合查询（实际推荐场景）
+    print("\n" + "="*80)
+    print("示例3: 组合推荐场景")
+    print("="*80)
+    
+    print("\n场景: 用户在PC端，来自美国，是零售商，浏览了物品123456")
+    print("\n1. 基于物品的相似推荐（i2i）:")
+    results = query_i2i_similar_items(redis_client, test_item_id, 'swing', top_n=3)
+    for idx, (item_id, score) in enumerate(results, 1):
+        print(f"  {idx}. 物品ID: {item_id}, 相似度: {score:.4f}")
+    
+    print("\n2. 基于平台+国家的热门推荐:")
+    results = query_interest_items(redis_client, 'platform_country:PC_US', 'hot', top_n=3)
+    for idx, (item_id, score) in enumerate(results, 1):
+        print(f"  {idx}. 物品ID: {item_id}, 分数: {score:.4f}")
+    
+    print("\n3. 基于客户类型的加购推荐:")
+    results = query_interest_items(redis_client, 'customer_type:retailer', 'cart', top_n=3)
+    for idx, (item_id, score) in enumerate(results, 1):
+        print(f"  {idx}. 物品ID: {item_id}, 分数: {score:.4f}")
+    
+    print("\n" + "="*80)
+    print("✓ 查询示例完成")
+    print("="*80)
+    
+    return 0
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,67 @@
+#!/bin/bash
+# 推荐系统离线任务安装脚本
+
+echo "========================================"
+echo "推荐系统离线任务 - 安装脚本"
+echo "========================================"
+echo ""
+
+# 检查Python版本
+echo "检查Python版本..."
+python_version=$(python3 --version 2>&1 | awk '{print $2}')
+echo "当前Python版本: $python_version"
+
+if ! command -v python3 &> /dev/null; then
+    echo "错误: 未找到Python3，请先安装Python3"
+    exit 1
+fi
+
+# 检查pip
+echo ""
+echo "检查pip..."
+if ! command -v pip3 &> /dev/null; then
+    echo "错误: 未找到pip3，请先安装pip3"
+    exit 1
+fi
+
+# 创建必要的目录
+echo ""
+echo "创建目录结构..."
+mkdir -p output
+mkdir -p logs
+echo "✓ 目录创建完成"
+
+# 安装依赖包
+echo ""
+echo "安装Python依赖包..."
+echo "这可能需要几分钟时间..."
+pip3 install -r ../requirements.txt
+
+if [ $? -eq 0 ]; then
+    echo "✓ 依赖包安装完成"
+else
+    echo "✗ 依赖包安装失败，请检查错误信息"
+    exit 1
+fi
+
+# 测试连接
+echo ""
+echo "测试数据库和Redis连接..."
+python3 test_connection.py
+
+echo ""
+echo "========================================"
+echo "安装完成！"
+echo "========================================"
+echo ""
+echo "接下来的步骤："
+echo "1. 检查配置文件: config/offline_config.py"
+echo "2. 运行测试: python3 test_connection.py"
+echo "3. 运行离线任务: python3 run_all.py --lookback_days 730 --top_n 50"
+echo ""
+echo "详细文档请查看:"
+echo "  - QUICKSTART.md (快速开始)"
+echo "  - README.md (详细文档)"
+echo "  - PROJECT_SUMMARY.md (项目总结)"
+echo ""
+
@@ -0,0 +1,187 @@
+"""
+离线任务统一调度脚本
+按顺序运行所有离线任务，生成推荐系统所需的各种索引
+"""
+import os
+import sys
+import subprocess
+import argparse
+import logging
+from datetime import datetime
+
+# 添加父目录到路径以导入配置
+parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, parent_dir)
+
+from offline_tasks.config.offline_config import (
+    DEFAULT_LOOKBACK_DAYS,
+    DEFAULT_I2I_TOP_N,
+    DEFAULT_INTEREST_TOP_N
+)
+
+# 设置日志
+LOG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'logs')
+os.makedirs(LOG_DIR, exist_ok=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(LOG_DIR, f'run_all_{datetime.now().strftime("%Y%m%d")}.log')),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# 脚本目录
+SCRIPTS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'scripts')
+
+
+def run_script(script_name, args=None):
+    """
+    运行Python脚本
+    
+    Args:
+        script_name: 脚本名称
+        args: 命令行参数列表
+    
+    Returns:
+        bool: 是否成功
+    """
+    script_path = os.path.join(SCRIPTS_DIR, script_name)
+    
+    if not os.path.exists(script_path):
+        logger.error(f"Script not found: {script_path}")
+        return False
+    
+    cmd = [sys.executable, script_path]
+    if args:
+        cmd.extend(args)
+    
+    logger.info(f"Running: {' '.join(cmd)}")
+    
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True
+        )
+        logger.info(f"Script {script_name} completed successfully")
+        logger.debug(result.stdout)
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Script {script_name} failed with return code {e.returncode}")
+        logger.error(f"Error output: {e.stderr}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error running {script_name}: {e}")
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run all offline recommendation tasks')
+    parser.add_argument('--skip-i2i', action='store_true', help='Skip i2i tasks')
+    parser.add_argument('--skip-interest', action='store_true', help='Skip interest aggregation')
+    parser.add_argument('--only-swing', action='store_true', help='Run only Swing algorithm')
+    parser.add_argument('--only-w2v', action='store_true', help='Run only Session W2V')
+    parser.add_argument('--only-deepwalk', action='store_true', help='Run only DeepWalk')
+    parser.add_argument('--only-content', action='store_true', help='Run only Content-based similarity')
+    parser.add_argument('--only-interest', action='store_true', help='Run only interest aggregation')
+    parser.add_argument('--lookback-days', type=int, default=DEFAULT_LOOKBACK_DAYS, 
+                        help=f'Lookback days (default: {DEFAULT_LOOKBACK_DAYS}, adjust in offline_config.py)')
+    parser.add_argument('--top-n', type=int, default=DEFAULT_I2I_TOP_N, 
+                        help=f'Top N similar items (default: {DEFAULT_I2I_TOP_N})')
+    
+    args = parser.parse_args()
+    
+    logger.info("="*80)
+    logger.info("Starting offline recommendation tasks")
+    logger.info("="*80)
+    
+    success_count = 0
+    total_count = 0
+    
+    # i2i 行为相似任务
+    if not args.skip_i2i:
+        # 1. Swing算法
+        if not args.only_w2v and not args.only_deepwalk and not args.only_interest and not args.only_content:
+            logger.info("\n" + "="*80)
+            logger.info("Task 1: Running Swing algorithm for i2i similarity")
+            logger.info("="*80)
+            total_count += 1
+            if run_script('i2i_swing.py', [
+                '--lookback_days', str(args.lookback_days),
+                '--top_n', str(args.top_n),
+                '--time_decay'
+            ]):
+                success_count += 1
+        
+        # 2. Session W2V
+        if not args.only_swing and not args.only_deepwalk and not args.only_interest and not args.only_content:
+            logger.info("\n" + "="*80)
+            logger.info("Task 2: Running Session Word2Vec for i2i similarity")
+            logger.info("="*80)
+            total_count += 1
+            if run_script('i2i_session_w2v.py', [
+                '--lookback_days', str(args.lookback_days),
+                '--top_n', str(args.top_n),
+                '--save_model'
+            ]):
+                success_count += 1
+        
+        # 3. DeepWalk
+        if not args.only_swing and not args.only_w2v and not args.only_interest and not args.only_content:
+            logger.info("\n" + "="*80)
+            logger.info("Task 3: Running DeepWalk for i2i similarity")
+            logger.info("="*80)
+            total_count += 1
+            if run_script('i2i_deepwalk.py', [
+                '--lookback_days', str(args.lookback_days),
+                '--top_n', str(args.top_n),
+                '--save_model',
+                '--save_graph'
+            ]):
+                success_count += 1
+        
+        # 4. Content-based similarity
+        if not args.only_swing and not args.only_w2v and not args.only_deepwalk and not args.only_interest:
+            logger.info("\n" + "="*80)
+            logger.info("Task 4: Running Content-based similarity")
+            logger.info("="*80)
+            total_count += 1
+            if run_script('i2i_content_similar.py', [
+                '--top_n', str(args.top_n),
+                '--method', 'hybrid'
+            ]):
+                success_count += 1
+    
+    # 兴趣点聚合任务
+    if not args.skip_interest:
+        if not args.only_swing and not args.only_w2v and not args.only_deepwalk and not args.only_content:
+            logger.info("\n" + "="*80)
+            logger.info("Task 5: Running interest aggregation")
+            logger.info("="*80)
+            total_count += 1
+            if run_script('interest_aggregation.py', [
+                '--lookback_days', str(args.lookback_days),
+                '--top_n', str(DEFAULT_INTEREST_TOP_N)
+            ]):
+                success_count += 1
+    
+    # 总结
+    logger.info("\n" + "="*80)
+    logger.info(f"All tasks completed: {success_count}/{total_count} succeeded")
+    logger.info("="*80)
+    
+    if success_count == total_count:
+        logger.info("✓ All tasks completed successfully!")
+        return 0
+    else:
+        logger.warning(f"✗ {total_count - success_count} task(s) failed")
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())
+
@@ -0,0 +1,275 @@
+"""
+i2i - 内容相似索引
+基于商品属性（分类、供应商、属性等）计算物品相似度
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import pandas as pd
+import numpy as np
+import argparse
+from datetime import datetime
+from collections import defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import (
+    DB_CONFIG, OUTPUT_DIR, DEFAULT_I2I_TOP_N
+)
+
+
+def fetch_product_features(engine):
+    """
+    获取商品特征数据
+    """
+    sql_query = """
+    SELECT 
+        pgs.id as item_id,
+        pgs.name as item_name,
+        pg.supplier_id,
+        ss.name as supplier_name,
+        pg.category_id,
+        pc_1.id as category_level1_id,
+        pc_1.name as category_level1,
+        pc_2.id as category_level2_id,
+        pc_2.name as category_level2,
+        pc_3.id as category_level3_id,
+        pc_3.name as category_level3,
+        pc_4.id as category_level4_id,
+        pc_4.name as category_level4,
+        pgs.capacity,
+        pgs.factory_no,
+        po.name as package_type,
+        po2.name as package_mode,
+        pgs.fir_on_sell_time,
+        pgs.status
+    FROM prd_goods_sku pgs
+    INNER JOIN prd_goods pg ON pg.id = pgs.goods_id
+    INNER JOIN sup_supplier ss ON ss.id = pg.supplier_id
+    LEFT JOIN prd_category as pc ON pc.id = pg.category_id
+    LEFT JOIN prd_category AS pc_1 ON pc_1.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 2), '.', -1)
+    LEFT JOIN prd_category AS pc_2 ON pc_2.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 3), '.', -1)
+    LEFT JOIN prd_category AS pc_3 ON pc_3.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 4), '.', -1)
+    LEFT JOIN prd_category AS pc_4 ON pc_4.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 5), '.', -1)
+    LEFT JOIN prd_goods_sku_attribute pgsa ON pgs.id = pgsa.goods_sku_id 
+        AND pgsa.attribute_id = (SELECT id FROM prd_attribute WHERE code = 'PKG' LIMIT 1)
+    LEFT JOIN prd_option po ON po.id = pgsa.option_id
+    LEFT JOIN prd_goods_sku_attribute pgsa2 ON pgs.id = pgsa2.goods_sku_id 
+        AND pgsa2.attribute_id = (SELECT id FROM prd_attribute WHERE code = 'pkg_mode' LIMIT 1)
+    LEFT JOIN prd_option po2 ON po2.id = pgsa2.option_id
+    WHERE pgs.status IN (2, 4, 5)
+        AND pgs.is_delete = 0
+    """
+    
+    print("Executing SQL query...")
+    df = pd.read_sql(sql_query, engine)
+    print(f"Fetched {len(df)} products")
+    return df
+
+
+def build_feature_text(row):
+    """
+    构建商品的特征文本
+    """
+    features = []
+    
+    # 添加分类信息（权重最高，重复多次）
+    if pd.notna(row['category_level1']):
+        features.extend([str(row['category_level1'])] * 5)
+    if pd.notna(row['category_level2']):
+        features.extend([str(row['category_level2'])] * 4)
+    if pd.notna(row['category_level3']):
+        features.extend([str(row['category_level3'])] * 3)
+    if pd.notna(row['category_level4']):
+        features.extend([str(row['category_level4'])] * 2)
+    
+    # 添加供应商信息
+    if pd.notna(row['supplier_name']):
+        features.extend([str(row['supplier_name'])] * 2)
+    
+    # 添加包装信息
+    if pd.notna(row['package_type']):
+        features.append(str(row['package_type']))
+    if pd.notna(row['package_mode']):
+        features.append(str(row['package_mode']))
+    
+    # 添加商品名称的关键词（简单分词）
+    if pd.notna(row['item_name']):
+        name_words = str(row['item_name']).split()
+        features.extend(name_words)
+    
+    return ' '.join(features)
+
+
+def calculate_content_similarity(df, top_n=50):
+    """
+    基于内容计算相似度
+    """
+    print("Building feature texts...")
+    df['feature_text'] = df.apply(build_feature_text, axis=1)
+    
+    print("Calculating TF-IDF...")
+    vectorizer = TfidfVectorizer(max_features=1000)
+    tfidf_matrix = vectorizer.fit_transform(df['feature_text'])
+    
+    print("Calculating cosine similarity...")
+    # 分批计算相似度以节省内存
+    batch_size = 1000
+    result = {}
+    
+    for i in range(0, len(df), batch_size):
+        end_i = min(i + batch_size, len(df))
+        batch_similarity = cosine_similarity(tfidf_matrix[i:end_i], tfidf_matrix)
+        
+        for j, idx in enumerate(range(i, end_i)):
+            item_id = df.iloc[idx]['item_id']
+            similarities = batch_similarity[j]
+            
+            # 获取最相似的top_n个（排除自己）
+            similar_indices = np.argsort(similarities)[::-1][1:top_n+1]
+            similar_items = []
+            
+            for sim_idx in similar_indices:
+                if similarities[sim_idx] > 0:  # 只保留有相似度的
+                    similar_items.append((
+                        df.iloc[sim_idx]['item_id'],
+                        float(similarities[sim_idx])
+                    ))
+            
+            if similar_items:
+                result[item_id] = similar_items
+        
+        print(f"Processed {end_i}/{len(df)} products...")
+    
+    return result
+
+
+def calculate_category_based_similarity(df):
+    """
+    基于分类的相似度（同类目下的商品）
+    """
+    result = defaultdict(list)
+    
+    # 按四级类目分组
+    for cat4_id, group in df.groupby('category_level4_id'):
+        if pd.isna(cat4_id) or len(group) < 2:
+            continue
+        
+        items = group['item_id'].tolist()
+        for item_id in items:
+            other_items = [x for x in items if x != item_id]
+            # 同四级类目的商品相似度设为0.9
+            result[item_id].extend([(x, 0.9) for x in other_items[:50]])
+    
+    # 按三级类目分组（补充）
+    for cat3_id, group in df.groupby('category_level3_id'):
+        if pd.isna(cat3_id) or len(group) < 2:
+            continue
+        
+        items = group['item_id'].tolist()
+        for item_id in items:
+            if item_id not in result or len(result[item_id]) < 50:
+                other_items = [x for x in items if x != item_id]
+                # 同三级类目的商品相似度设为0.7
+                existing = {x[0] for x in result[item_id]}
+                new_items = [(x, 0.7) for x in other_items if x not in existing]
+                result[item_id].extend(new_items[:50 - len(result[item_id])])
+    
+    return result
+
+
+def merge_similarities(sim1, sim2, weight1=0.7, weight2=0.3):
+    """
+    融合两种相似度
+    """
+    result = {}
+    all_items = set(sim1.keys()) | set(sim2.keys())
+    
+    for item_id in all_items:
+        similarities = defaultdict(float)
+        
+        # 添加第一种相似度
+        if item_id in sim1:
+            for similar_id, score in sim1[item_id]:
+                similarities[similar_id] += score * weight1
+        
+        # 添加第二种相似度
+        if item_id in sim2:
+            for similar_id, score in sim2[item_id]:
+                similarities[similar_id] += score * weight2
+        
+        # 排序并取top N
+        sorted_sims = sorted(similarities.items(), key=lambda x: -x[1])[:50]
+        if sorted_sims:
+            result[item_id] = sorted_sims
+    
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Calculate content-based item similarity')
+    parser.add_argument('--top_n', type=int, default=DEFAULT_I2I_TOP_N,
+                       help=f'Top N similar items to output (default: {DEFAULT_I2I_TOP_N})')
+    parser.add_argument('--method', type=str, default='hybrid',
+                       choices=['tfidf', 'category', 'hybrid'],
+                       help='Similarity calculation method')
+    parser.add_argument('--output', type=str, default=None,
+                       help='Output file path')
+    
+    args = parser.parse_args()
+    
+    # 创建数据库连接
+    print("Connecting to database...")
+    engine = create_db_connection(
+        DB_CONFIG['host'],
+        DB_CONFIG['port'],
+        DB_CONFIG['database'],
+        DB_CONFIG['username'],
+        DB_CONFIG['password']
+    )
+    
+    # 获取商品特征
+    df = fetch_product_features(engine)
+    
+    # 计算相似度
+    if args.method == 'tfidf':
+        print("\nUsing TF-IDF method...")
+        result = calculate_content_similarity(df, args.top_n)
+    elif args.method == 'category':
+        print("\nUsing category-based method...")
+        result = calculate_category_based_similarity(df)
+    else:  # hybrid
+        print("\nUsing hybrid method...")
+        tfidf_sim = calculate_content_similarity(df, args.top_n)
+        category_sim = calculate_category_based_similarity(df)
+        result = merge_similarities(tfidf_sim, category_sim, weight1=0.7, weight2=0.3)
+    
+    # 创建item_id到name的映射
+    item_name_map = dict(zip(df['item_id'], df['item_name']))
+    
+    # 输出结果
+    output_file = args.output or os.path.join(
+        OUTPUT_DIR, 
+        f'i2i_content_{args.method}_{datetime.now().strftime("%Y%m%d")}.txt'
+    )
+    
+    print(f"\nWriting results to {output_file}...")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item_id, sims in result.items():
+            item_name = item_name_map.get(item_id, 'Unknown')
+            
+            if not sims:
+                continue
+            
+            # 格式：item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+            sim_str = ','.join([f'{sim_id}:{score:.4f}' for sim_id, score in sims])
+            f.write(f'{item_id}\t{item_name}\t{sim_str}\n')
+    
+    print(f"Done! Generated content-based similarities for {len(result)} items")
+    print(f"Output saved to: {output_file}")
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,330 @@
+"""
+i2i - DeepWalk算法实现
+基于用户-物品图结构训练DeepWalk模型，获取物品向量相似度
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import pandas as pd
+import argparse
+from datetime import datetime
+from collections import defaultdict
+from gensim.models import Word2Vec
+import numpy as np
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import (
+    DB_CONFIG, OUTPUT_DIR, I2I_CONFIG, get_time_range,
+    DEFAULT_LOOKBACK_DAYS, DEFAULT_I2I_TOP_N
+)
+
+
+def build_item_graph(df, behavior_weights):
+    """
+    构建物品图（基于用户共同交互）
+    
+    Args:
+        df: DataFrame with columns: user_id, item_id, event_type
+        behavior_weights: 行为权重字典
+    
+    Returns:
+        edge_dict: {item_id: {neighbor_id: weight}}
+    """
+    # 构建用户-物品列表
+    user_items = defaultdict(list)
+    
+    for _, row in df.iterrows():
+        user_id = row['user_id']
+        item_id = str(row['item_id'])
+        event_type = row['event_type']
+        weight = behavior_weights.get(event_type, 1.0)
+        
+        user_items[user_id].append((item_id, weight))
+    
+    # 构建物品图边
+    edge_dict = defaultdict(lambda: defaultdict(float))
+    
+    for user_id, items in user_items.items():
+        # 物品两两组合，构建边
+        for i in range(len(items)):
+            item_i, weight_i = items[i]
+            for j in range(i + 1, len(items)):
+                item_j, weight_j = items[j]
+                
+                # 边的权重为两个物品权重的平均值
+                edge_weight = (weight_i + weight_j) / 2.0
+                edge_dict[item_i][item_j] += edge_weight
+                edge_dict[item_j][item_i] += edge_weight
+    
+    return edge_dict
+
+
+def save_edge_file(edge_dict, output_path):
+    """
+    保存边文件
+    
+    Args:
+        edge_dict: 边字典
+        output_path: 输出路径
+    """
+    with open(output_path, 'w', encoding='utf-8') as f:
+        for item_id, neighbors in edge_dict.items():
+            # 格式: item_id \t neighbor1:weight1,neighbor2:weight2,...
+            neighbor_str = ','.join([f'{nbr}:{weight:.4f}' for nbr, weight in neighbors.items()])
+            f.write(f'{item_id}\t{neighbor_str}\n')
+    
+    print(f"Edge file saved to {output_path}")
+
+
+def random_walk(graph, start_node, walk_length):
+    """
+    执行随机游走
+    
+    Args:
+        graph: 图结构 {node: {neighbor: weight}}
+        start_node: 起始节点
+        walk_length: 游走长度
+    
+    Returns:
+        游走序列
+    """
+    walk = [start_node]
+    
+    while len(walk) < walk_length:
+        cur = walk[-1]
+        
+        if cur not in graph or not graph[cur]:
+            break
+        
+        # 获取邻居和权重
+        neighbors = list(graph[cur].keys())
+        weights = list(graph[cur].values())
+        
+        # 归一化权重
+        total_weight = sum(weights)
+        if total_weight == 0:
+            break
+        
+        probs = [w / total_weight for w in weights]
+        
+        # 按权重随机选择下一个节点
+        next_node = np.random.choice(neighbors, p=probs)
+        walk.append(next_node)
+    
+    return walk
+
+
+def generate_walks(graph, num_walks, walk_length):
+    """
+    生成随机游走序列
+    
+    Args:
+        graph: 图结构
+        num_walks: 每个节点的游走次数
+        walk_length: 游走长度
+    
+    Returns:
+        List of walks
+    """
+    walks = []
+    nodes = list(graph.keys())
+    
+    print(f"Generating {num_walks} walks per node, walk length {walk_length}...")
+    
+    for _ in range(num_walks):
+        np.random.shuffle(nodes)
+        for node in nodes:
+            walk = random_walk(graph, node, walk_length)
+            if len(walk) >= 2:
+                walks.append(walk)
+    
+    return walks
+
+
+def train_word2vec(walks, config):
+    """
+    训练Word2Vec模型
+    
+    Args:
+        walks: 游走序列列表
+        config: Word2Vec配置
+    
+    Returns:
+        Word2Vec模型
+    """
+    print(f"Training Word2Vec with {len(walks)} walks...")
+    
+    model = Word2Vec(
+        sentences=walks,
+        vector_size=config['vector_size'],
+        window=config['window_size'],
+        min_count=config['min_count'],
+        workers=config['workers'],
+        sg=config['sg'],
+        epochs=config['epochs'],
+        seed=42
+    )
+    
+    print(f"Training completed. Vocabulary size: {len(model.wv)}")
+    return model
+
+
+def generate_similarities(model, top_n=50):
+    """
+    生成物品相似度
+    
+    Args:
+        model: Word2Vec模型
+        top_n: Top N similar items
+    
+    Returns:
+        Dict[item_id, List[Tuple(similar_item_id, score)]]
+    """
+    result = {}
+    
+    for item_id in model.wv.index_to_key:
+        try:
+            similar_items = model.wv.most_similar(item_id, topn=top_n)
+            result[item_id] = [(sim_id, float(score)) for sim_id, score in similar_items]
+        except KeyError:
+            continue
+    
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run DeepWalk for i2i similarity')
+    parser.add_argument('--num_walks', type=int, default=I2I_CONFIG['deepwalk']['num_walks'],
+                       help='Number of walks per node')
+    parser.add_argument('--walk_length', type=int, default=I2I_CONFIG['deepwalk']['walk_length'],
+                       help='Walk length')
+    parser.add_argument('--window_size', type=int, default=I2I_CONFIG['deepwalk']['window_size'],
+                       help='Window size for Word2Vec')
+    parser.add_argument('--vector_size', type=int, default=I2I_CONFIG['deepwalk']['vector_size'],
+                       help='Vector size for Word2Vec')
+    parser.add_argument('--min_count', type=int, default=I2I_CONFIG['deepwalk']['min_count'],
+                       help='Minimum word count')
+    parser.add_argument('--workers', type=int, default=I2I_CONFIG['deepwalk']['workers'],
+                       help='Number of workers')
+    parser.add_argument('--epochs', type=int, default=I2I_CONFIG['deepwalk']['epochs'],
+                       help='Number of epochs')
+    parser.add_argument('--top_n', type=int, default=DEFAULT_I2I_TOP_N,
+                       help=f'Top N similar items to output (default: {DEFAULT_I2I_TOP_N})')
+    parser.add_argument('--lookback_days', type=int, default=DEFAULT_LOOKBACK_DAYS,
+                       help=f'Number of days to look back (default: {DEFAULT_LOOKBACK_DAYS})')
+    parser.add_argument('--output', type=str, default=None,
+                       help='Output file path')
+    parser.add_argument('--save_model', action='store_true',
+                       help='Save Word2Vec model')
+    parser.add_argument('--save_graph', action='store_true',
+                       help='Save graph edge file')
+    
+    args = parser.parse_args()
+    
+    # 创建数据库连接
+    print("Connecting to database...")
+    engine = create_db_connection(
+        DB_CONFIG['host'],
+        DB_CONFIG['port'],
+        DB_CONFIG['database'],
+        DB_CONFIG['username'],
+        DB_CONFIG['password']
+    )
+    
+    # 获取时间范围
+    start_date, end_date = get_time_range(args.lookback_days)
+    print(f"Fetching data from {start_date} to {end_date}...")
+    
+    # SQL查询 - 获取用户行为数据
+    sql_query = f"""
+    SELECT 
+        se.anonymous_id AS user_id,
+        se.item_id,
+        se.event AS event_type,
+        pgs.name AS item_name
+    FROM 
+        sensors_events se
+    LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+    WHERE 
+        se.event IN ('click', 'contactFactory', 'addToPool', 'addToCart', 'purchase')
+        AND se.create_time >= '{start_date}'
+        AND se.create_time <= '{end_date}'
+        AND se.item_id IS NOT NULL
+        AND se.anonymous_id IS NOT NULL
+    """
+    
+    print("Executing SQL query...")
+    df = pd.read_sql(sql_query, engine)
+    print(f"Fetched {len(df)} records")
+    
+    # 定义行为权重
+    behavior_weights = {
+        'click': 1.0,
+        'contactFactory': 5.0,
+        'addToPool': 2.0,
+        'addToCart': 3.0,
+        'purchase': 10.0
+    }
+    
+    # 构建物品图
+    print("Building item graph...")
+    graph = build_item_graph(df, behavior_weights)
+    print(f"Graph built with {len(graph)} nodes")
+    
+    # 保存边文件（可选）
+    if args.save_graph:
+        edge_file = os.path.join(OUTPUT_DIR, f'item_graph_{datetime.now().strftime("%Y%m%d")}.txt')
+        save_edge_file(graph, edge_file)
+    
+    # 生成随机游走
+    print("Generating random walks...")
+    walks = generate_walks(graph, args.num_walks, args.walk_length)
+    print(f"Generated {len(walks)} walks")
+    
+    # 训练Word2Vec模型
+    w2v_config = {
+        'vector_size': args.vector_size,
+        'window_size': args.window_size,
+        'min_count': args.min_count,
+        'workers': args.workers,
+        'epochs': args.epochs,
+        'sg': 1
+    }
+    
+    model = train_word2vec(walks, w2v_config)
+    
+    # 保存模型（可选）
+    if args.save_model:
+        model_path = os.path.join(OUTPUT_DIR, f'deepwalk_model_{datetime.now().strftime("%Y%m%d")}.model')
+        model.save(model_path)
+        print(f"Model saved to {model_path}")
+    
+    # 生成相似度
+    print("Generating similarities...")
+    result = generate_similarities(model, top_n=args.top_n)
+    
+    # 创建item_id到name的映射
+    item_name_map = dict(zip(df['item_id'].astype(str), df.groupby('item_id')['item_name'].first()))
+    
+    # 输出结果
+    output_file = args.output or os.path.join(OUTPUT_DIR, f'i2i_deepwalk_{datetime.now().strftime("%Y%m%d")}.txt')
+    
+    print(f"Writing results to {output_file}...")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item_id, sims in result.items():
+            item_name = item_name_map.get(item_id, 'Unknown')
+            
+            if not sims:
+                continue
+            
+            # 格式：item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+            sim_str = ','.join([f'{sim_id}:{score:.4f}' for sim_id, score in sims])
+            f.write(f'{item_id}\t{item_name}\t{sim_str}\n')
+    
+    print(f"Done! Generated i2i similarities for {len(result)} items")
+    print(f"Output saved to: {output_file}")
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,240 @@
+"""
+i2i - Session Word2Vec算法实现
+基于用户会话序列训练Word2Vec模型，获取物品向量相似度
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import pandas as pd
+import json
+import argparse
+from datetime import datetime
+from collections import defaultdict
+from gensim.models import Word2Vec
+import numpy as np
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import (
+    DB_CONFIG, OUTPUT_DIR, I2I_CONFIG, get_time_range,
+    DEFAULT_LOOKBACK_DAYS, DEFAULT_I2I_TOP_N
+)
+
+
+def prepare_session_data(df, session_gap_minutes=30):
+    """
+    准备会话数据
+    
+    Args:
+        df: DataFrame with columns: user_id, item_id, create_time
+        session_gap_minutes: 会话间隔时间（分钟）
+    
+    Returns:
+        List of sessions, each session is a list of item_ids
+    """
+    sessions = []
+    
+    # 按用户和时间排序
+    df = df.sort_values(['user_id', 'create_time'])
+    
+    # 按用户分组
+    for user_id, user_df in df.groupby('user_id'):
+        user_sessions = []
+        current_session = []
+        last_time = None
+        
+        for _, row in user_df.iterrows():
+            item_id = str(row['item_id'])
+            current_time = row['create_time']
+            
+            # 判断是否需要开始新会话
+            if last_time is None or (current_time - last_time).total_seconds() / 60 > session_gap_minutes:
+                if current_session:
+                    user_sessions.append(current_session)
+                current_session = [item_id]
+            else:
+                current_session.append(item_id)
+            
+            last_time = current_time
+        
+        # 添加最后一个会话
+        if current_session:
+            user_sessions.append(current_session)
+        
+        sessions.extend(user_sessions)
+    
+    # 过滤掉长度小于2的会话
+    sessions = [s for s in sessions if len(s) >= 2]
+    
+    return sessions
+
+
+def train_word2vec(sessions, config):
+    """
+    训练Word2Vec模型
+    
+    Args:
+        sessions: List of sessions
+        config: Word2Vec配置
+    
+    Returns:
+        Word2Vec模型
+    """
+    print(f"Training Word2Vec with {len(sessions)} sessions...")
+    
+    model = Word2Vec(
+        sentences=sessions,
+        vector_size=config['vector_size'],
+        window=config['window_size'],
+        min_count=config['min_count'],
+        workers=config['workers'],
+        sg=config['sg'],
+        epochs=config['epochs'],
+        seed=42
+    )
+    
+    print(f"Training completed. Vocabulary size: {len(model.wv)}")
+    return model
+
+
+def generate_similarities(model, top_n=50):
+    """
+    生成物品相似度
+    
+    Args:
+        model: Word2Vec模型
+        top_n: Top N similar items
+    
+    Returns:
+        Dict[item_id, List[Tuple(similar_item_id, score)]]
+    """
+    result = {}
+    
+    for item_id in model.wv.index_to_key:
+        try:
+            similar_items = model.wv.most_similar(item_id, topn=top_n)
+            result[item_id] = [(sim_id, float(score)) for sim_id, score in similar_items]
+        except KeyError:
+            continue
+    
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run Session Word2Vec for i2i similarity')
+    parser.add_argument('--window_size', type=int, default=I2I_CONFIG['session_w2v']['window_size'],
+                       help='Window size for Word2Vec')
+    parser.add_argument('--vector_size', type=int, default=I2I_CONFIG['session_w2v']['vector_size'],
+                       help='Vector size for Word2Vec')
+    parser.add_argument('--min_count', type=int, default=I2I_CONFIG['session_w2v']['min_count'],
+                       help='Minimum word count')
+    parser.add_argument('--workers', type=int, default=I2I_CONFIG['session_w2v']['workers'],
+                       help='Number of workers')
+    parser.add_argument('--epochs', type=int, default=I2I_CONFIG['session_w2v']['epochs'],
+                       help='Number of epochs')
+    parser.add_argument('--top_n', type=int, default=DEFAULT_I2I_TOP_N,
+                       help=f'Top N similar items to output (default: {DEFAULT_I2I_TOP_N})')
+    parser.add_argument('--lookback_days', type=int, default=DEFAULT_LOOKBACK_DAYS,
+                       help=f'Number of days to look back (default: {DEFAULT_LOOKBACK_DAYS})')
+    parser.add_argument('--session_gap', type=int, default=30,
+                       help='Session gap in minutes')
+    parser.add_argument('--output', type=str, default=None,
+                       help='Output file path')
+    parser.add_argument('--save_model', action='store_true',
+                       help='Save Word2Vec model')
+    
+    args = parser.parse_args()
+    
+    # 创建数据库连接
+    print("Connecting to database...")
+    engine = create_db_connection(
+        DB_CONFIG['host'],
+        DB_CONFIG['port'],
+        DB_CONFIG['database'],
+        DB_CONFIG['username'],
+        DB_CONFIG['password']
+    )
+    
+    # 获取时间范围
+    start_date, end_date = get_time_range(args.lookback_days)
+    print(f"Fetching data from {start_date} to {end_date}...")
+    
+    # SQL查询 - 获取用户行为序列
+    sql_query = f"""
+    SELECT 
+        se.anonymous_id AS user_id,
+        se.item_id,
+        se.create_time,
+        pgs.name AS item_name
+    FROM 
+        sensors_events se
+    LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+    WHERE 
+        se.event IN ('click', 'contactFactory', 'addToPool', 'addToCart', 'purchase')
+        AND se.create_time >= '{start_date}'
+        AND se.create_time <= '{end_date}'
+        AND se.item_id IS NOT NULL
+        AND se.anonymous_id IS NOT NULL
+    ORDER BY 
+        se.anonymous_id,
+        se.create_time
+    """
+    
+    print("Executing SQL query...")
+    df = pd.read_sql(sql_query, engine)
+    print(f"Fetched {len(df)} records")
+    
+    # 转换create_time为datetime
+    df['create_time'] = pd.to_datetime(df['create_time'])
+    
+    # 准备会话数据
+    print("Preparing session data...")
+    sessions = prepare_session_data(df, session_gap_minutes=args.session_gap)
+    print(f"Generated {len(sessions)} sessions")
+    
+    # 训练Word2Vec模型
+    w2v_config = {
+        'vector_size': args.vector_size,
+        'window_size': args.window_size,
+        'min_count': args.min_count,
+        'workers': args.workers,
+        'epochs': args.epochs,
+        'sg': 1
+    }
+    
+    model = train_word2vec(sessions, w2v_config)
+    
+    # 保存模型（可选）
+    if args.save_model:
+        model_path = os.path.join(OUTPUT_DIR, f'session_w2v_model_{datetime.now().strftime("%Y%m%d")}.model')
+        model.save(model_path)
+        print(f"Model saved to {model_path}")
+    
+    # 生成相似度
+    print("Generating similarities...")
+    result = generate_similarities(model, top_n=args.top_n)
+    
+    # 创建item_id到name的映射
+    item_name_map = dict(zip(df['item_id'].astype(str), df.groupby('item_id')['item_name'].first()))
+    
+    # 输出结果
+    output_file = args.output or os.path.join(OUTPUT_DIR, f'i2i_session_w2v_{datetime.now().strftime("%Y%m%d")}.txt')
+    
+    print(f"Writing results to {output_file}...")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item_id, sims in result.items():
+            item_name = item_name_map.get(item_id, 'Unknown')
+            
+            if not sims:
+                continue
+            
+            # 格式：item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+            sim_str = ','.join([f'{sim_id}:{score:.4f}' for sim_id, score in sims])
+            f.write(f'{item_id}\t{item_name}\t{sim_str}\n')
+    
+    print(f"Done! Generated i2i similarities for {len(result)} items")
+    print(f"Output saved to: {output_file}")
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,244 @@
+"""
+i2i - Swing算法实现
+基于用户行为的物品相似度计算
+参考item_sim.py的数据格式，适配真实数据
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import pandas as pd
+import math
+from collections import defaultdict
+import argparse
+import json
+from datetime import datetime, timedelta
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import (
+    DB_CONFIG, OUTPUT_DIR, I2I_CONFIG, get_time_range,
+    DEFAULT_LOOKBACK_DAYS, DEFAULT_I2I_TOP_N
+)
+
+
+def calculate_time_weight(event_time, reference_time, decay_factor=0.95, days_unit=30):
+    """
+    计算时间衰减权重
+    
+    Args:
+        event_time: 事件发生时间
+        reference_time: 参考时间（通常是当前时间）
+        decay_factor: 衰减因子
+        days_unit: 衰减单位（天）
+    
+    Returns:
+        时间权重
+    """
+    if pd.isna(event_time):
+        return 1.0
+    
+    time_diff = (reference_time - event_time).days
+    if time_diff < 0:
+        return 1.0
+    
+    # 计算衰减权重
+    periods = time_diff / days_unit
+    weight = math.pow(decay_factor, periods)
+    return weight
+
+
+def swing_algorithm(df, alpha=0.5, time_decay=True, decay_factor=0.95):
+    """
+    Swing算法实现
+    
+    Args:
+        df: DataFrame with columns: user_id, item_id, weight, create_time
+        alpha: Swing算法的alpha参数
+        time_decay: 是否使用时间衰减
+        decay_factor: 时间衰减因子
+    
+    Returns:
+        Dict[item_id, List[Tuple(similar_item_id, score)]]
+    """
+    # 如果使用时间衰减，计算时间权重
+    reference_time = datetime.now()
+    if time_decay and 'create_time' in df.columns:
+        df['time_weight'] = df['create_time'].apply(
+            lambda x: calculate_time_weight(x, reference_time, decay_factor)
+        )
+        df['weight'] = df['weight'] * df['time_weight']
+    
+    # 构建用户-物品倒排索引
+    user_items = defaultdict(set)
+    item_users = defaultdict(set)
+    item_freq = defaultdict(float)
+    
+    for _, row in df.iterrows():
+        user_id = row['user_id']
+        item_id = row['item_id']
+        weight = row['weight']
+        
+        user_items[user_id].add(item_id)
+        item_users[item_id].add(user_id)
+        item_freq[item_id] += weight
+    
+    print(f"Total users: {len(user_items)}, Total items: {len(item_users)}")
+    
+    # 计算物品相似度
+    item_sim_dict = defaultdict(lambda: defaultdict(float))
+    
+    # 遍历每个物品对
+    for item_i in item_users:
+        users_i = item_users[item_i]
+        
+        # 找到所有与item_i共现的物品
+        for item_j in item_users:
+            if item_i >= item_j:  # 避免重复计算
+                continue
+            
+            users_j = item_users[item_j]
+            common_users = users_i & users_j
+            
+            if len(common_users) < 2:
+                continue
+            
+            # 计算Swing相似度
+            sim_score = 0.0
+            common_users_list = list(common_users)
+            
+            for idx_u in range(len(common_users_list)):
+                user_u = common_users_list[idx_u]
+                items_u = user_items[user_u]
+                
+                for idx_v in range(idx_u + 1, len(common_users_list)):
+                    user_v = common_users_list[idx_v]
+                    items_v = user_items[user_v]
+                    
+                    # 计算用户u和用户v的共同物品数
+                    common_items = items_u & items_v
+                    
+                    # Swing公式
+                    sim_score += 1.0 / (alpha + len(common_items))
+            
+            item_sim_dict[item_i][item_j] = sim_score
+            item_sim_dict[item_j][item_i] = sim_score
+    
+    # 对相似度进行归一化并排序
+    result = {}
+    for item_i in item_sim_dict:
+        sims = item_sim_dict[item_i]
+        
+        # 归一化（可选）
+        # 按相似度排序
+        sorted_sims = sorted(sims.items(), key=lambda x: -x[1])
+        result[item_i] = sorted_sims
+    
+    return result
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run Swing algorithm for i2i similarity')
+    parser.add_argument('--alpha', type=float, default=I2I_CONFIG['swing']['alpha'],
+                       help='Alpha parameter for Swing algorithm')
+    parser.add_argument('--top_n', type=int, default=DEFAULT_I2I_TOP_N,
+                       help=f'Top N similar items to output (default: {DEFAULT_I2I_TOP_N})')
+    parser.add_argument('--lookback_days', type=int, default=DEFAULT_LOOKBACK_DAYS,
+                       help=f'Number of days to look back for user behavior (default: {DEFAULT_LOOKBACK_DAYS})')
+    parser.add_argument('--time_decay', action='store_true', default=True,
+                       help='Use time decay for behavior weights')
+    parser.add_argument('--decay_factor', type=float, default=0.95,
+                       help='Time decay factor')
+    parser.add_argument('--output', type=str, default=None,
+                       help='Output file path')
+    
+    args = parser.parse_args()
+    
+    # 创建数据库连接
+    print("Connecting to database...")
+    engine = create_db_connection(
+        DB_CONFIG['host'],
+        DB_CONFIG['port'],
+        DB_CONFIG['database'],
+        DB_CONFIG['username'],
+        DB_CONFIG['password']
+    )
+    
+    # 获取时间范围
+    start_date, end_date = get_time_range(args.lookback_days)
+    print(f"Fetching data from {start_date} to {end_date}...")
+    
+    # SQL查询 - 获取用户行为数据
+    sql_query = f"""
+    SELECT 
+        se.anonymous_id AS user_id,
+        se.item_id,
+        se.event AS event_type,
+        se.create_time,
+        pgs.name AS item_name
+    FROM 
+        sensors_events se
+    LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+    WHERE 
+        se.event IN ('contactFactory', 'addToPool', 'addToCart', 'purchase')
+        AND se.create_time >= '{start_date}'
+        AND se.create_time <= '{end_date}'
+        AND se.item_id IS NOT NULL
+        AND se.anonymous_id IS NOT NULL
+    ORDER BY 
+        se.create_time
+    """
+    
+    print("Executing SQL query...")
+    df = pd.read_sql(sql_query, engine)
+    print(f"Fetched {len(df)} records")
+    
+    # 转换create_time为datetime
+    df['create_time'] = pd.to_datetime(df['create_time'])
+    
+    # 定义行为权重
+    behavior_weights = {
+        'contactFactory': 5.0,
+        'addToPool': 2.0,
+        'addToCart': 3.0,
+        'purchase': 10.0
+    }
+    
+    # 添加权重列
+    df['weight'] = df['event_type'].map(behavior_weights).fillna(1.0)
+    
+    # 运行Swing算法
+    print("Running Swing algorithm...")
+    result = swing_algorithm(
+        df,
+        alpha=args.alpha,
+        time_decay=args.time_decay,
+        decay_factor=args.decay_factor
+    )
+    
+    # 创建item_id到name的映射
+    item_name_map = dict(zip(df['item_id'].unique(), df.groupby('item_id')['item_name'].first()))
+    
+    # 输出结果
+    output_file = args.output or os.path.join(OUTPUT_DIR, f'i2i_swing_{datetime.now().strftime("%Y%m%d")}.txt')
+    
+    print(f"Writing results to {output_file}...")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for item_id, sims in result.items():
+            item_name = item_name_map.get(item_id, 'Unknown')
+            
+            # 只取前N个最相似的商品
+            top_sims = sims[:args.top_n]
+            
+            if not top_sims:
+                continue
+            
+            # 格式：item_id \t item_name \t similar_item_id1:score1,similar_item_id2:score2,...
+            sim_str = ','.join([f'{sim_id}:{score:.4f}' for sim_id, score in top_sims])
+            f.write(f'{item_id}\t{item_name}\t{sim_str}\n')
+    
+    print(f"Done! Generated i2i similarities for {len(result)} items")
+    print(f"Output saved to: {output_file}")
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,325 @@
+"""
+兴趣点聚合索引生成
+按照多个维度（平台、国家、客户类型、分类、列表类型）生成商品索引
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import pandas as pd
+import math
+import argparse
+import json
+from datetime import datetime, timedelta
+from collections import defaultdict, Counter
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import (
+    DB_CONFIG, OUTPUT_DIR, INTEREST_AGGREGATION_CONFIG, get_time_range,
+    DEFAULT_LOOKBACK_DAYS, DEFAULT_RECENT_DAYS, DEFAULT_INTEREST_TOP_N
+)
+
+
+def calculate_time_weight(event_time, reference_time, decay_factor=0.95, days_unit=30):
+    """
+    计算时间衰减权重
+    
+    Args:
+        event_time: 事件发生时间
+        reference_time: 参考时间（当前时间）
+        decay_factor: 衰减因子
+        days_unit: 衰减单位（天）
+    
+    Returns:
+        时间权重
+    """
+    if pd.isna(event_time):
+        return 1.0
+    
+    time_diff = (reference_time - event_time).days
+    if time_diff < 0:
+        return 1.0
+    
+    # 计算衰减权重
+    periods = time_diff / days_unit
+    weight = math.pow(decay_factor, periods)
+    return weight
+
+
+def aggregate_by_dimensions(df, behavior_weights, time_decay=True, decay_factor=0.95):
+    """
+    按多维度聚合商品
+    
+    Args:
+        df: DataFrame with necessary columns
+        behavior_weights: 行为权重字典
+        time_decay: 是否使用时间衰减
+        decay_factor: 时间衰减因子
+    
+    Returns:
+        Dict: {dimension_key: {item_id: score}}
+    """
+    reference_time = datetime.now()
+    
+    # 添加行为权重
+    df['behavior_weight'] = df['event_type'].map(behavior_weights).fillna(1.0)
+    
+    # 添加时间权重
+    if time_decay:
+        df['time_weight'] = df['create_time'].apply(
+            lambda x: calculate_time_weight(x, reference_time, decay_factor)
+        )
+    else:
+        df['time_weight'] = 1.0
+    
+    # 计算最终权重
+    df['final_weight'] = df['behavior_weight'] * df['time_weight']
+    
+    # 初始化聚合结果
+    aggregations = defaultdict(lambda: defaultdict(float))
+    
+    # 遍历数据，按不同维度聚合
+    for _, row in df.iterrows():
+        item_id = row['item_id']
+        weight = row['final_weight']
+        
+        # 维度1: 业务平台 (business_platform)
+        if pd.notna(row.get('platform')):
+            key = f"platform:{row['platform']}"
+            aggregations[key][item_id] += weight
+        
+        # 维度2: 客户端平台 (client_platform)
+        if pd.notna(row.get('client_platform')):
+            key = f"client_platform:{row['client_platform']}"
+            aggregations[key][item_id] += weight
+        
+        # 维度3: 供应商 (supplier_id)
+        if pd.notna(row.get('supplier_id')):
+            key = f"supplier:{row['supplier_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 维度4: 一级分类 (category_level1)
+        if pd.notna(row.get('category_level1_id')):
+            key = f"category_level1:{row['category_level1_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 维度5: 二级分类 (category_level2)
+        if pd.notna(row.get('category_level2_id')):
+            key = f"category_level2:{row['category_level2_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 维度6: 三级分类 (category_level3)
+        if pd.notna(row.get('category_level3_id')):
+            key = f"category_level3:{row['category_level3_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 维度7: 四级分类 (category_level4)
+        if pd.notna(row.get('category_level4_id')):
+            key = f"category_level4:{row['category_level4_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 组合维度: 业务平台 + 客户端平台
+        if pd.notna(row.get('platform')) and pd.notna(row.get('client_platform')):
+            key = f"platform_client:{row['platform']}_{row['client_platform']}"
+            aggregations[key][item_id] += weight
+        
+        # 组合维度: 平台 + 二级分类
+        if pd.notna(row.get('platform')) and pd.notna(row.get('category_level2_id')):
+            key = f"platform_category2:{row['platform']}_{row['category_level2_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 组合维度: 平台 + 三级分类
+        if pd.notna(row.get('platform')) and pd.notna(row.get('category_level3_id')):
+            key = f"platform_category3:{row['platform']}_{row['category_level3_id']}"
+            aggregations[key][item_id] += weight
+        
+        # 组合维度: 客户端平台 + 二级分类
+        if pd.notna(row.get('client_platform')) and pd.notna(row.get('category_level2_id')):
+            key = f"client_category2:{row['client_platform']}_{row['category_level2_id']}"
+            aggregations[key][item_id] += weight
+    
+    return aggregations
+
+
+def generate_list_type_indices(df_hot, df_cart, df_new, behavior_weights):
+    """
+    生成不同列表类型的索引（热门、加购、新品）
+    
+    Args:
+        df_hot: 热门商品数据
+        df_cart: 加购商品数据
+        df_new: 新品数据
+        behavior_weights: 行为权重
+    
+    Returns:
+        Dict: {list_type: aggregations}
+    """
+    list_type_indices = {}
+    
+    # 热门商品索引
+    if not df_hot.empty:
+        print("Generating hot item indices...")
+        list_type_indices['hot'] = aggregate_by_dimensions(
+            df_hot, behavior_weights, time_decay=True
+        )
+    
+    # 加购商品索引
+    if not df_cart.empty:
+        print("Generating cart item indices...")
+        list_type_indices['cart'] = aggregate_by_dimensions(
+            df_cart, behavior_weights, time_decay=True
+        )
+    
+    # 新品索引
+    if not df_new.empty:
+        print("Generating new item indices...")
+        # 新品不使用时间衰减，因为新品本身就是时间敏感的
+        list_type_indices['new'] = aggregate_by_dimensions(
+            df_new, behavior_weights, time_decay=False
+        )
+    
+    return list_type_indices
+
+
+def output_indices(aggregations, output_prefix, top_n=1000):
+    """
+    输出索引到文件
+    
+    Args:
+        aggregations: 聚合结果 {dimension_key: {item_id: score}}
+        output_prefix: 输出文件前缀
+        top_n: 每个维度输出前N个商品
+    """
+    output_file = os.path.join(OUTPUT_DIR, f'{output_prefix}_{datetime.now().strftime("%Y%m%d")}.txt')
+    
+    print(f"Writing indices to {output_file}...")
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for dim_key, items in aggregations.items():
+            # 按分数排序，取前N个
+            sorted_items = sorted(items.items(), key=lambda x: -x[1])[:top_n]
+            
+            if not sorted_items:
+                continue
+            
+            # 格式：dimension_key \t item_id1:score1,item_id2:score2,...
+            items_str = ','.join([f'{item_id}:{score:.4f}' for item_id, score in sorted_items])
+            f.write(f'{dim_key}\t{items_str}\n')
+    
+    print(f"Output saved to: {output_file}")
+    print(f"Generated indices for {len(aggregations)} dimension keys")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate interest aggregation indices')
+    parser.add_argument('--top_n', type=int, default=DEFAULT_INTEREST_TOP_N,
+                       help=f'Top N items per dimension (default: {DEFAULT_INTEREST_TOP_N})')
+    parser.add_argument('--lookback_days', type=int, default=DEFAULT_LOOKBACK_DAYS,
+                       help=f'Number of days to look back (default: {DEFAULT_LOOKBACK_DAYS})')
+    parser.add_argument('--recent_days', type=int, default=DEFAULT_RECENT_DAYS,
+                       help=f'Recent days for hot items (default: {DEFAULT_RECENT_DAYS})')
+    parser.add_argument('--new_days', type=int, default=DEFAULT_RECENT_DAYS,
+                       help=f'Days for new items (default: {DEFAULT_RECENT_DAYS})')
+    parser.add_argument('--decay_factor', type=float, default=INTEREST_AGGREGATION_CONFIG['time_decay_factor'],
+                       help='Time decay factor')
+    parser.add_argument('--output_prefix', type=str, default='interest_aggregation',
+                       help='Output file prefix')
+    
+    args = parser.parse_args()
+    
+    # 创建数据库连接
+    print("Connecting to database...")
+    engine = create_db_connection(
+        DB_CONFIG['host'],
+        DB_CONFIG['port'],
+        DB_CONFIG['database'],
+        DB_CONFIG['username'],
+        DB_CONFIG['password']
+    )
+    
+    # 获取时间范围
+    start_date, end_date = get_time_range(args.lookback_days)
+    recent_start_date, _ = get_time_range(args.recent_days)
+    new_start_date, _ = get_time_range(args.new_days)
+    
+    print(f"Fetching data from {start_date} to {end_date}...")
+    
+    # SQL查询 - 获取用户行为数据（包含用户特征和商品分类）
+    sql_query = f"""
+    SELECT 
+        se.anonymous_id AS user_id,
+        se.item_id,
+        se.event AS event_type,
+        se.create_time,
+        pgs.name AS item_name,
+        pgs.create_time AS item_create_time,
+        se.business_platform AS platform,
+        se.client_platform,
+        pg.supplier_id,
+        pg.category_id,
+        pc_1.id as category_level1_id,
+        pc_2.id as category_level2_id,
+        pc_3.id as category_level3_id,
+        pc_4.id as category_level4_id
+    FROM 
+        sensors_events se
+    LEFT JOIN prd_goods_sku pgs ON se.item_id = pgs.id
+    LEFT JOIN prd_goods pg ON pg.id = pgs.goods_id
+    LEFT JOIN prd_category as pc ON pc.id = pg.category_id
+    LEFT JOIN prd_category AS pc_1 ON pc_1.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 2), '.', -1)
+    LEFT JOIN prd_category AS pc_2 ON pc_2.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 3), '.', -1)
+    LEFT JOIN prd_category AS pc_3 ON pc_3.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 4), '.', -1)
+    LEFT JOIN prd_category AS pc_4 ON pc_4.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pc.path, '.', 5), '.', -1)
+    WHERE 
+        se.event IN ('click', 'contactFactory', 'addToPool', 'addToCart', 'purchase')
+        AND se.create_time >= '{start_date}'
+        AND se.create_time <= '{end_date}'
+        AND se.item_id IS NOT NULL
+    ORDER BY 
+        se.create_time
+    """
+    
+    print("Executing SQL query...")
+    df = pd.read_sql(sql_query, engine)
+    print(f"Fetched {len(df)} records")
+    
+    # 转换时间列
+    df['create_time'] = pd.to_datetime(df['create_time'])
+    df['item_create_time'] = pd.to_datetime(df['item_create_time'], errors='coerce')
+    
+    # 定义行为权重
+    behavior_weights = INTEREST_AGGREGATION_CONFIG['behavior_weights']
+    
+    # 准备不同类型的数据集
+    
+    # 1. 热门商品：最近N天的高交互商品
+    df_hot = df[df['create_time'] >= recent_start_date].copy()
+    
+    # 2. 加购商品：加购行为
+    df_cart = df[df['event_type'].isin(['addToCart', 'addToPool'])].copy()
+    
+    # 3. 新品：商品创建时间在最近N天内
+    df_new = df[df['item_create_time'] >= new_start_date].copy()
+    
+    # 生成不同列表类型的索引
+    print("\n=== Generating indices ===")
+    list_type_indices = generate_list_type_indices(
+        df_hot, df_cart, df_new, behavior_weights
+    )
+    
+    # 输出索引
+    for list_type, aggregations in list_type_indices.items():
+        output_prefix = f'{args.output_prefix}_{list_type}'
+        output_indices(aggregations, output_prefix, top_n=args.top_n)
+    
+    # 生成全局索引（所有数据）
+    print("\nGenerating global indices...")
+    global_aggregations = aggregate_by_dimensions(
+        df, behavior_weights, time_decay=True, decay_factor=args.decay_factor
+    )
+    output_indices(global_aggregations, f'{args.output_prefix}_global', top_n=args.top_n)
+    
+    print("\n=== All indices generated successfully! ===")
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,207 @@
+"""
+将生成的索引加载到Redis
+用于在线推荐系统查询
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+import redis
+import argparse
+import logging
+from datetime import datetime
+from offline_tasks.config.offline_config import REDIS_CONFIG, OUTPUT_DIR
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def load_index_file(file_path, redis_client, key_prefix, expire_seconds=None):
+    """
+    加载索引文件到Redis
+    
+    Args:
+        file_path: 索引文件路径
+        redis_client: Redis客户端
+        key_prefix: Redis key前缀
+        expire_seconds: 过期时间（秒），None表示不过期
+    
+    Returns:
+        加载的记录数
+    """
+    if not os.path.exists(file_path):
+        logger.error(f"File not found: {file_path}")
+        return 0
+    
+    count = 0
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            
+            parts = line.split('\t')
+            if len(parts) != 2:
+                logger.warning(f"Invalid line format: {line}")
+                continue
+            
+            key_suffix, value = parts
+            redis_key = f"{key_prefix}:{key_suffix}"
+            
+            # 存储到Redis
+            redis_client.set(redis_key, value)
+            
+            # 设置过期时间
+            if expire_seconds:
+                redis_client.expire(redis_key, expire_seconds)
+            
+            count += 1
+            
+            if count % 1000 == 0:
+                logger.info(f"Loaded {count} records...")
+    
+    return count
+
+
+def load_i2i_indices(redis_client, date_str=None, expire_days=7):
+    """
+    加载i2i相似度索引
+    
+    Args:
+        redis_client: Redis客户端
+        date_str: 日期字符串，格式YYYYMMDD，None表示使用今天
+        expire_days: 过期天数
+    """
+    if not date_str:
+        date_str = datetime.now().strftime('%Y%m%d')
+    
+    expire_seconds = expire_days * 24 * 3600 if expire_days else None
+    
+    # i2i索引类型
+    i2i_types = ['swing', 'session_w2v', 'deepwalk']
+    
+    for i2i_type in i2i_types:
+        file_path = os.path.join(OUTPUT_DIR, f'i2i_{i2i_type}_{date_str}.txt')
+        
+        if not os.path.exists(file_path):
+            logger.warning(f"File not found: {file_path}, skipping...")
+            continue
+        
+        logger.info(f"Loading {i2i_type} indices...")
+        count = load_index_file(
+            file_path,
+            redis_client,
+            f"i2i:{i2i_type}",
+            expire_seconds
+        )
+        logger.info(f"Loaded {count} {i2i_type} indices")
+
+
+def load_interest_indices(redis_client, date_str=None, expire_days=7):
+    """
+    加载兴趣点聚合索引
+    
+    Args:
+        redis_client: Redis客户端
+        date_str: 日期字符串，格式YYYYMMDD，None表示使用今天
+        expire_days: 过期天数
+    """
+    if not date_str:
+        date_str = datetime.now().strftime('%Y%m%d')
+    
+    expire_seconds = expire_days * 24 * 3600 if expire_days else None
+    
+    # 兴趣点索引类型
+    list_types = ['hot', 'cart', 'new', 'global']
+    
+    for list_type in list_types:
+        file_path = os.path.join(OUTPUT_DIR, f'interest_aggregation_{list_type}_{date_str}.txt')
+        
+        if not os.path.exists(file_path):
+            logger.warning(f"File not found: {file_path}, skipping...")
+            continue
+        
+        logger.info(f"Loading {list_type} interest indices...")
+        count = load_index_file(
+            file_path,
+            redis_client,
+            f"interest:{list_type}",
+            expire_seconds
+        )
+        logger.info(f"Loaded {count} {list_type} indices")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Load recommendation indices to Redis')
+    parser.add_argument('--redis-host', type=str, default=REDIS_CONFIG.get('host', 'localhost'),
+                       help='Redis host')
+    parser.add_argument('--redis-port', type=int, default=REDIS_CONFIG.get('port', 6379),
+                       help='Redis port')
+    parser.add_argument('--redis-db', type=int, default=REDIS_CONFIG.get('db', 0),
+                       help='Redis database')
+    parser.add_argument('--redis-password', type=str, default=REDIS_CONFIG.get('password'),
+                       help='Redis password')
+    parser.add_argument('--date', type=str, default=None,
+                       help='Date string (YYYYMMDD), default is today')
+    parser.add_argument('--expire-days', type=int, default=7,
+                       help='Expire days for Redis keys')
+    parser.add_argument('--load-i2i', action='store_true', default=True,
+                       help='Load i2i indices')
+    parser.add_argument('--load-interest', action='store_true', default=True,
+                       help='Load interest indices')
+    parser.add_argument('--flush-db', action='store_true',
+                       help='Flush database before loading (危险操作！)')
+    
+    args = parser.parse_args()
+    
+    # 创建Redis连接
+    logger.info("Connecting to Redis...")
+    redis_client = redis.Redis(
+        host=args.redis_host,
+        port=args.redis_port,
+        db=args.redis_db,
+        password=args.redis_password,
+        decode_responses=True
+    )
+    
+    # 测试连接
+    try:
+        redis_client.ping()
+        logger.info("Redis connection successful")
+    except Exception as e:
+        logger.error(f"Failed to connect to Redis: {e}")
+        return 1
+    
+    # Flush数据库（如果需要）
+    if args.flush_db:
+        logger.warning("Flushing Redis database...")
+        redis_client.flushdb()
+        logger.info("Database flushed")
+    
+    # 加载i2i索引
+    if args.load_i2i:
+        logger.info("\n" + "="*80)
+        logger.info("Loading i2i indices")
+        logger.info("="*80)
+        load_i2i_indices(redis_client, args.date, args.expire_days)
+    
+    # 加载兴趣点索引
+    if args.load_interest:
+        logger.info("\n" + "="*80)
+        logger.info("Loading interest aggregation indices")
+        logger.info("="*80)
+        load_interest_indices(redis_client, args.date, args.expire_days)
+    
+    logger.info("\n" + "="*80)
+    logger.info("All indices loaded successfully!")
+    logger.info("="*80)
+    
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
+
@@ -0,0 +1,116 @@
+"""
+测试数据库和Redis连接
+用于验证配置是否正确
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from db_service import create_db_connection
+from offline_tasks.config.offline_config import DB_CONFIG, REDIS_CONFIG
+import redis
+
+
+def test_database_connection():
+    """测试数据库连接"""
+    print("="*80)
+    print("测试数据库连接...")
+    print("="*80)
+    
+    try:
+        engine = create_db_connection(
+            DB_CONFIG['host'],
+            DB_CONFIG['port'],
+            DB_CONFIG['database'],
+            DB_CONFIG['username'],
+            DB_CONFIG['password']
+        )
+        
+        # 执行简单查询
+        import pandas as pd
+        df = pd.read_sql("SELECT COUNT(*) as cnt FROM sensors_events LIMIT 1", engine)
+        print(f"✓ 数据库连接成功！")
+        print(f"  传感器事件表记录数: {df['cnt'].iloc[0]}")
+        
+        # 测试商品表
+        df = pd.read_sql("SELECT COUNT(*) as cnt FROM prd_goods_sku LIMIT 1", engine)
+        print(f"  商品SKU表记录数: {df['cnt'].iloc[0]}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"✗ 数据库连接失败: {e}")
+        return False
+
+
+def test_redis_connection():
+    """测试Redis连接"""
+    print("\n" + "="*80)
+    print("测试Redis连接...")
+    print("="*80)
+    
+    try:
+        redis_client = redis.Redis(
+            host=REDIS_CONFIG.get('host', 'localhost'),
+            port=REDIS_CONFIG.get('port', 6379),
+            db=REDIS_CONFIG.get('db', 0),
+            password=REDIS_CONFIG.get('password'),
+            decode_responses=True
+        )
+        
+        # 测试连接
+        redis_client.ping()
+        print(f"✓ Redis连接成功！")
+        
+        # 测试读写
+        test_key = "test:connection"
+        test_value = "success"
+        redis_client.set(test_key, test_value, ex=10)
+        result = redis_client.get(test_key)
+        
+        if result == test_value:
+            print(f"  读写测试成功")
+        
+        # 删除测试键
+        redis_client.delete(test_key)
+        
+        return True
+        
+    except Exception as e:
+        print(f"✗ Redis连接失败: {e}")
+        print(f"  提示：如果Redis未安装或未启动，可以跳过Redis相关功能")
+        return False
+
+
+def main():
+    """主函数"""
+    print("\n" + "="*80)
+    print("开始测试连接配置...")
+    print("="*80 + "\n")
+    
+    db_ok = test_database_connection()
+    redis_ok = test_redis_connection()
+    
+    print("\n" + "="*80)
+    print("测试结果汇总")
+    print("="*80)
+    print(f"数据库连接: {'✓ 成功' if db_ok else '✗ 失败'}")
+    print(f"Redis连接:  {'✓ 成功' if redis_ok else '✗ 失败 (可选)'}")
+    print("="*80)
+    
+    if db_ok:
+        print("\n✓ 数据库连接正常，可以开始运行离线任务！")
+        print("\n运行命令：")
+        print("  python run_all.py --lookback_days 730 --top_n 50")
+    else:
+        print("\n✗ 数据库连接失败，请检查配置文件：")
+        print("  offline_tasks/config/offline_config.py")
+    
+    if not redis_ok:
+        print("\n⚠ Redis连接失败（可选），索引加载功能将不可用")
+        print("  如需使用，请安装并启动Redis，或修改配置")
+
+
+if __name__ == '__main__':
+    main()
+
@@ -0,0 +1,31 @@
+# 推荐系统离线任务依赖包
+
+# 数据处理
+pandas>=1.3.0
+numpy>=1.21.0
+
+# 数据库连接
+sqlalchemy>=1.4.0
+pymysql>=1.0.0
+
+# 机器学习和向量训练
+gensim>=4.0.0
+scikit-learn>=1.0.0
+
+# 图处理
+networkx>=2.6.0
+
+# 并行计算
+joblib>=1.0.0
+
+# Redis客户端
+redis>=4.0.0
+
+# 配置和日志
+pyyaml>=5.4.0
+
+# 进度条
+tqdm>=4.62.0
+
+# 其他工具
+python-dateutil>=2.8.0
@@ -0,0 +1,178 @@
+
+check_table_structure.py 的输出
+
+================================================================================
+检查 prd_goods_sku 表结构
+================================================================================
+
+表字段列表：
+                        Field           Type Null    Key Default    Extra
+0                          id         bigint  Yes   true    None         
+1                    buyer_id         bigint  Yes  false    None  REPLACE
+2              proxy_buyer_id         bigint  Yes  false    None  REPLACE
+3                    goods_id         bigint  Yes  false    None  REPLACE
+4                        name  varchar(1536)  Yes  false    None  REPLACE
+5                 name_pinyin  varchar(3072)  Yes  false    None  REPLACE
+6                 accessories  varchar(1536)  Yes  false    None  REPLACE
+7            factory_no_buyer   varchar(192)  Yes  false    None  REPLACE
+8                  factory_no   varchar(765)  Yes  false    None  REPLACE
+9               is_has_sample       smallint  Yes  false    None  REPLACE
+10       is_has_pkg_age_label       smallint  Yes  false    None  REPLACE
+11              pkg_age_label   varchar(384)  Yes  false    None  REPLACE
+12                onway_total            int  Yes  false    None  REPLACE
+13            onway_use_total            int  Yes  false    None  REPLACE
+14          onway_unuse_total            int  Yes  false    None  REPLACE
+15                deliver_day            int  Yes  false    None  REPLACE
+16                  dev_level    varchar(96)  Yes  false    None  REPLACE
+17                     length  decimal(12,2)  Yes  false    None  REPLACE
+18                      width  decimal(12,2)  Yes  false    None  REPLACE
+19                     height  decimal(12,2)  Yes  false    None  REPLACE
+20                     volume  decimal(12,8)  Yes  false    None  REPLACE
+21             out_box_length  decimal(12,2)  Yes  false    None  REPLACE
+22              out_box_width  decimal(12,2)  Yes  false    None  REPLACE
+23             out_box_height  decimal(12,2)  Yes  false    None  REPLACE
+24             out_box_volume  decimal(12,8)  Yes  false    None  REPLACE
+25              out_box_cruft  decimal(15,8)  Yes  false    None  REPLACE
+26             package_length  decimal(12,2)  Yes  false    None  REPLACE
+27              package_width  decimal(12,2)  Yes  false    None  REPLACE
+28             package_height  decimal(12,2)  Yes  false    None  REPLACE
+29             package_volume  decimal(12,8)  Yes  false    None  REPLACE
+30               total_volume  decimal(12,8)  Yes  false    None  REPLACE
+31               gross_weight  decimal(12,2)  Yes  false    None  REPLACE
+32                 net_weight  decimal(12,2)  Yes  false    None  REPLACE
+33          is_package_depart       smallint  Yes  false    None  REPLACE
+34              is_fixed_sale       smallint  Yes  false    None  REPLACE
+35                inbox_count            int  Yes  false    None  REPLACE
+36                         no   varchar(192)  Yes  false    None  REPLACE
+37                      hs_no   varchar(192)  Yes  false    None  REPLACE
+38                 erp_old_no   varchar(192)  Yes  false    None  REPLACE
+39        factory_first_price  decimal(12,3)  Yes  false    None  REPLACE
+40   factory_first_price_unit    varchar(96)  Yes  false    None  REPLACE
+41   factory_first_price_date       datetime  Yes  false    None  REPLACE
+42                   bar_code   varchar(192)  Yes  false    None  REPLACE
+43                      count            int  Yes  false    None  REPLACE
+44                       unit    varchar(96)  Yes  false    None  REPLACE
+45             price_supplier  decimal(12,3)  Yes  false    None  REPLACE
+46               gross_profit  decimal(12,5)  Yes  false    None  REPLACE
+47                 price_base  decimal(12,3)  Yes  false    None  REPLACE
+48                bulk_result    varchar(96)  Yes  false    None  REPLACE
+49                  bulk_type    varchar(96)  Yes  false    None  REPLACE
+50               purchase_moq            int  Yes  false    None  REPLACE
+51                   capacity            int  Yes  false    None  REPLACE
+52            package_type_id         bigint  Yes  false    None  REPLACE
+53          package_type_name   varchar(192)  Yes  false    None  REPLACE
+54         package_type_value    varchar(96)  Yes  false    None  REPLACE
+55                 sale_price  decimal(12,3)  Yes  false    None  REPLACE
+56             has_quote_rang       smallint  Yes  false    None  REPLACE
+57            is_stop_product       smallint  Yes  false    None  REPLACE
+58              is_upload_pic       smallint  Yes  false    None  REPLACE
+59                     status    varchar(96)  Yes  false    None  REPLACE
+60            sku_compose_md5   varchar(192)  Yes  false    None  REPLACE
+61                sku_compose  varchar(6144)  Yes  false    None  REPLACE
+62                        src    varchar(96)  Yes  false    None  REPLACE
+63            price_bom_total  decimal(12,3)  Yes  false    None  REPLACE
+64                     bom_id         bigint  Yes  false    None  REPLACE
+65              off_sell_time       datetime  Yes  false    None  REPLACE
+66           off_sell_user_id         bigint  Yes  false    None  REPLACE
+67                  sort_time       datetime  Yes  false    None  REPLACE
+68           fir_on_sell_time       datetime  Yes  false    None  REPLACE
+69               on_sell_time       datetime  Yes  false    None  REPLACE
+70            on_sell_user_id         bigint  Yes  false    None  REPLACE
+71                   is_draft       smallint  Yes  false    None  REPLACE
+72              per_pcs_price  decimal(12,3)  Yes  false    None  REPLACE
+73                  fcl_price  decimal(12,3)  Yes  false    None  REPLACE
+74                 init_price  decimal(12,3)  Yes  false    None  REPLACE
+75    last_pic_update_user_Id         bigint  Yes  false    None  REPLACE
+76       last_pic_update_time       datetime  Yes  false    None  REPLACE
+77                       hide       smallint  Yes  false    None  REPLACE
+78            supplier_source   varchar(192)  Yes  false    None  REPLACE
+79                 ref_sku_id         bigint  Yes  false    None  REPLACE
+80            ref_season_type   varchar(192)  Yes  false    None  REPLACE
+81          is_category_error       smallint  Yes  false    None  REPLACE
+82         is_attribute_error       smallint  Yes  false    None  REPLACE
+83            is_option_error       smallint  Yes  false    None  REPLACE
+84      price_protection_time       datetime  Yes  false    None  REPLACE
+85                     remark  varchar(6144)  Yes  false    None  REPLACE
+86               audit_remark  varchar(1536)  Yes  false    None  REPLACE
+87              attribute_uid    varchar(96)  Yes  false    None  REPLACE
+88               refact_count            int  Yes  false    None  REPLACE
+89           last_refact_time       datetime  Yes  false    None  REPLACE
+90             last_refact_by         bigint  Yes  false    None  REPLACE
+91                  is_delete       smallint  Yes  false    None  REPLACE
+92           soft_delete_time       datetime  Yes  false    None  REPLACE
+93                    version         bigint  Yes  false    None  REPLACE
+94             last_update_by         bigint  Yes  false    None  REPLACE
+95           last_update_time       datetime  Yes  false    None  REPLACE
+96                  create_by         bigint  Yes  false    None  REPLACE
+97                create_time       datetime  Yes  false    None  REPLACE
+98                  ref_count         bigint  Yes  false    None  REPLACE
+99                 can_update       smallint  Yes  false    None  REPLACE
+100                can_delete       smallint  Yes  false    None  REPLACE
+101                mig_old_id   varchar(384)  Yes  false    None  REPLACE
+102           mig_update_time       datetime  Yes  false    None  REPLACE
+103        mig_migrate_log_id         bigint  Yes  false    None  REPLACE
+104           create_platform   varchar(150)  Yes  false    None  REPLACE
+105            create_user_id         bigint  Yes  false    None  REPLACE
+106      last_update_platform   varchar(150)  Yes  false    None  REPLACE
+107       last_update_user_id         bigint  Yes  false    None  REPLACE
+108             is_market_sku       smallint  Yes  false    None  REPLACE
+109                   is_star       smallint  Yes  false    None  REPLACE
+110                 good_type        tinyint  Yes  false    None  REPLACE
+111             bom_config_id         bigint  Yes  false    None  REPLACE
+112             source_sku_id         bigint  Yes  false    None  REPLACE
+
+================================================================================
+检查 sensors_events 表结构
+================================================================================
+
+表字段列表：
+                 Field           Type Null    Key Default Extra
+0                   id         bigint   No   true    None      
+1                   ip   varchar(128)  Yes  false    None  NONE
+2          create_time       datetime   No  false    None  NONE
+3     last_update_time       datetime  Yes  false    None  NONE
+4    business_platform   varchar(128)   No  false    None  NONE
+5      client_platform   varchar(128)   No  false    None  NONE
+6          distinct_id   varchar(128)   No  false    None  NONE
+7             login_id            int  Yes  false    None  NONE
+8         anonymous_id   varchar(128)  Yes  false    None  NONE
+9              item_id            int  Yes  false    None  NONE
+10           item_type   varchar(255)  Yes  false    None  NONE
+11               event   varchar(128)   No  false    None  NONE
+12   location_src_type   varchar(255)  Yes  false    None  NONE
+13        location_src   varchar(512)  Yes  false    None  NONE
+14      search_content   varchar(512)  Yes  false    None  NONE
+15           page_type   varchar(255)  Yes  false    None  NONE
+16         module_name   varchar(255)  Yes  false    None  NONE
+17       position_name   varchar(255)  Yes  false    None  NONE
+18        channel_type   varchar(512)  Yes  false    None  NONE
+19        channel_mode  varchar(1024)  Yes  false    None  NONE
+20      channel_source   varchar(512)  Yes  false    None  NONE
+21          request_id         bigint  Yes  false    None  NONE
+22          session_id   varchar(128)  Yes  false    None  NONE
+23    session_duration            int  Yes  false    None  NONE
+24       stay_duration            int  Yes  false    None  NONE
+25        __properties           json  Yes  false    None  NONE
+26               __lib           json  Yes  false    None  NONE
+27        __identities           json  Yes  false    None  NONE
+28          __url_path  varchar(1024)  Yes  false    None  NONE
+29             __title  varchar(2048)  Yes  false    None  NONE
+30     __referrer_host   varchar(128)  Yes  false    None  NONE
+31      __is_first_day        boolean  Yes  false    None  NONE
+32     __is_first_time        boolean  Yes  false    None  NONE
+33                __os   varchar(512)  Yes  false    None  NONE
+34        __os_version   varchar(512)  Yes  false    None  NONE
+35           __browser   varchar(512)  Yes  false    None  NONE
+36   __browser_version   varchar(255)  Yes  false    None  NONE
+37  __browser_language   varchar(255)  Yes  false    None  NONE
+38     __screen_height            int  Yes  false    None  NONE
+39      __screen_width            int  Yes  false    None  NONE
+40        __user_agent   varchar(512)  Yes  false    None  NONE
+41               __url  varchar(2048)  Yes  false    None  NONE
+42      __element_type   varchar(256)  Yes  false    None  NONE
+43   __element_content  varchar(1024)  Yes  false    None  NONE
+44          __referrer  varchar(1024)  Yes  false    None  NONE
+
+================================================================================
+检查完成
+================================================================================
@@ -0,0 +1,81 @@
+import pandas as pd
+import math
+from collections import defaultdict
+from sqlalchemy import create_engine
+from db_service import create_db_connection
+import argparse
+
+def clean_text_field(text):
+    if pd.isna(text):
+        return ''
+    # 移除换行符、回车符，并替换其他可能导致CSV格式问题的字符
+    return str(text).replace('\r', ' ').replace('\n', ' ').replace('"', '""').strip()
+
+bpms_host = '120.76.244.158'
+bpms_port = '3325'
+bpms_database = 'bpms'
+bpms_username = 'PRD_M1_190311'
+bpms_password = 'WTF)xdbqtW!4gwA7'
+
+# 创建数据库连接
+engine = create_db_connection(bpms_host, bpms_port, bpms_database, bpms_username, bpms_password)
+
+# SQL 查询
+sql_query = """
+SELECT
+  sp.code AS `PO单号`,
+  psm.name AS `区域`,
+  bb.code AS `客户编码`,
+  GROUP_CONCAT(pc_1.name) AS `商品信息`,
+  MIN(spi.order_time) AS `下单货时间`
+FROM sale_po sp
+INNER JOIN sale_po_item spi ON sp.id = spi.po_id
+LEFT JOIN buy_buyer bb ON bb.id = sp.buyer_id
+LEFT JOIN prd_goods pg ON pg.id = spi.spu_id
+LEFT JOIN prd_category AS pc_1 ON pc_1.id = SUBSTRING_INDEX(SUBSTRING_INDEX(pg.category_id, '.', 2), '.', -1)
+LEFT JOIN pub_sale_market_setting psms ON psms.country_code = bb.countries
+LEFT JOIN pub_sale_market psm ON psms.sale_market_id = psm.id
+WHERE spi.quantity > 0
+  AND spi.is_delete = 0
+  AND bb.is_delete = 0
+GROUP BY sp.code, psm.name, bb.code;
+"""
+
+# 执行 SQL 查询并将结果加载到 pandas DataFrame
+df = pd.read_sql(sql_query, engine)
+
+# 处理商品信息，分割并去重
+cooccur = defaultdict(lambda: defaultdict(int))
+freq = defaultdict(int)
+
+for _, row in df.iterrows():
+    # Handle None values in 商品信息
+    if pd.isna(row['商品信息']):
+        continue
+    categories = [cat.strip() for cat in str(row['商品信息']).split(',') if cat.strip()]
+    unique_cats = set(categories)
+    for c1 in unique_cats:
+        freq[c1] += 1
+        for c2 in unique_cats:
+            if c1 != c2:
+                cooccur[c1][c2] += 1
+
+# 计算余弦相似度
+result = {}
+for c1 in cooccur:
+    sim_scores = []
+    for c2 in cooccur[c1]:
+        numerator = cooccur[c1][c2]
+        denominator = math.sqrt(freq[c1]) * math.sqrt(freq[c2])
+        if denominator != 0:
+            score = numerator / denominator
+            sim_scores.append((c2, score))
+    sim_scores.sort(key=lambda x: -x[1])  # 按分数排序
+    result[c1] = sim_scores
+
+# 输出相似分类
+for cat, sims in result.items():
+    # 只取前8个最相似的分类
+    top_sims = sims[:8]
+    sim_str = ','.join([f'{sim_cat}:{score:.4f}' for sim_cat, score in top_sims])
+    print(f'{cat}\t{sim_str}')
@@ -0,0 +1,58 @@
+import sys
+from pathlib import Path
+import time
+
+# Add the project root to Python path
+current_dir = Path(__file__).parent
+project_root = current_dir.parent.parent
+sys.path.append(str(project_root))
+sys.path.append(str(project_root / 'snapshot_pb/generated'))
+
+from typing import Optional
+import redis
+from config.app_config import REDIS_CONFIG
+from config.logging_config import get_app_logger
+from user_profile_pb2 import UserProfile
+
+logger = get_app_logger(__name__)
+
+class UserProfileManager:
+    def __init__(self):
+        self.redis_client = redis.Redis(
+            host=REDIS_CONFIG['host'],
+            port=REDIS_CONFIG['port'],
+            db=REDIS_CONFIG['snapshot_db'],
+            password=REDIS_CONFIG['password'],
+            decode_responses=False
+        )
+
+    def get_user_profile(self, uid: str) -> Optional[UserProfile]:
+        """Get user profile from Redis"""
+        logger.debug(f"Fetching user profile for uid: {uid}")
+        
+        profile_key = f"user_profile:{uid}"
+        if not self.redis_client.exists(profile_key):
+            logger.debug(f"No profile data found for uid: {uid}")
+            return None
+            
+        # Measure Redis fetch time
+        fetch_start = time.time()
+        profile_data = self.redis_client.get(profile_key)
+        fetch_time = time.time() - fetch_start
+        
+        if not profile_data:
+            logger.debug(f"No profile data found for uid: {uid}")
+            return None
+
+        try:
+            # Measure deserialization time
+            deserialize_start = time.time()
+            profile = UserProfile()
+            profile.ParseFromString(profile_data)
+            deserialize_time = time.time() - deserialize_start
+            logger.info(f"REDIS_COST_TIME: key: {profile_key}, Response size: {len(profile_data)//1024}KB, Redis fetch: {fetch_time*1000:.2f}ms, Deserialization: {deserialize_time*1000:.2f}ms for uid: {uid}")
+            return profile
+
+        except Exception as e:
+            logger.error(f"Error deserializing profile data for uid {uid}: {str(e)}")
+            return None 
 \ No newline at end of file
@@ -0,0 +1,1006 @@
+"""
+用户画像信息提取器 - 从UserProfile中提取相关信息并生成描述
+"""
+
+from typing import Dict, Any, Optional, List, NamedTuple
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from collections import Counter
+import re,math
+from src.services.user_profile import UserProfile
+from config.logging_config import get_app_logger
+from src.chat_search.dict_loader import DictLoader
+from config.chat_search_config import USER_PROFILE_BEHAVIOR_CONFIG, SESSION_CONFIG, ATTR_STATIS_DISPLAY_MIN_OPTION_COUNT, ATTR_STATIS_DISPLAY_MIN_PRODUCT_COUNT, get_display_text, USER_BEHAVIOR_STAT_IN_PROMPT, USER_SEARCH_HISTORY_IN_PROMPT
+
+logger = get_app_logger(__name__)
+
+
+@dataclass
+class BehaviorStatFieldConfig:
+    """行为统计字段配置"""
+    field_name: str  # 原始字段名
+    feature_prefix: str  # 特征前缀
+    display_name: str  # 显示名称
+    description_template: str  # 描述模板
+    max_items: int = 10  # 最大显示项目数
+    is_repeated: bool = False  # 是否为重复字段
+    is_numeric: bool = False  # 是否为数值字段
+    is_time: bool = False  # 是否为时间字段
+    bucket_size: int = 10  # 分桶大小（仅用于数值字段）
+    enable: bool = True  # 是否启用该字段，默认启用
+    dict_name: str = None  # 词典名称（可选）
+
+
+@dataclass
+class BehaviorStatsConfig:
+    """行为统计配置"""
+    # 行为权重定义
+    behavior_weights: Dict[str, float] = None
+    
+    # 直接取值字段配置
+    direct_fields: List[BehaviorStatFieldConfig] = None
+    
+    # 重复字段配置
+    repeated_fields: List[BehaviorStatFieldConfig] = None
+    
+    # 数值字段配置
+    numeric_fields: List[BehaviorStatFieldConfig] = None
+    
+    # 时间字段配置
+    time_fields: List[BehaviorStatFieldConfig] = None
+    
+    # 行为统计配置
+    behavior_summary_truncate_limit: int = 1000  # 行为统计截断限制
+    
+    def __post_init__(self):
+        """初始化默认配置"""
+        # 从集中配置加载
+        config = USER_PROFILE_BEHAVIOR_CONFIG
+        
+        if self.behavior_weights is None:
+            self.behavior_weights = config['behavior_weights']
+        
+        if self.direct_fields is None:
+            self.direct_fields = [BehaviorStatFieldConfig(**field_config) for field_config in config['direct_fields']]
+        
+        if self.repeated_fields is None:
+            self.repeated_fields = [BehaviorStatFieldConfig(**field_config) for field_config in config['repeated_fields']]
+        
+        if self.numeric_fields is None:
+            self.numeric_fields = [BehaviorStatFieldConfig(**field_config) for field_config in config['numeric_fields']]
+        
+        if self.time_fields is None:
+            self.time_fields = [BehaviorStatFieldConfig(**field_config) for field_config in config['time_fields']]
+        
+        if self.behavior_summary_truncate_limit is None:
+            self.behavior_summary_truncate_limit = config['behavior_summary_truncate_limit']
+
+
+@dataclass
+class UserProfileInfo:
+    """用户画像信息结构"""
+    # 基础信息
+    sale_market_value: str = ""  # 主要销售地区名
+    nature_of_company_value: str = ""  # 公司性质名
+    customer_type: str = ""  # 公司类型编码
+    customer_type_value: str = ""  # 公司类型名
+    sell_channel_value: str = ""  # 销售渠道名
+    stores_number: int = 0  # 门店数量
+    register_category_values: List[str] = None  # 注册主要采购品类名
+    auth_category_values: List[str] = None  # 认证主要采购品类名
+    purchase_quantity_by_year_value: str = ""  # 采购规模名
+    customer_goods_structures: List[Dict[str, str]] = None  # 客户商品结构
+    brand_category_values: List[str] = None  # 客户品牌品类名
+    delivery_type_value: str = ""  # 主要出货方式名
+    customs_import_scale: str = ""  # 海关进口规模
+    purchase_quantity: int = 0  # 单款采购箱数
+    tax_clearance_type: str = ""  # 清关方式编码
+    tax_clearance_type_value: str = ""  # 清关方式名
+    category_values: List[str] = None  # 经营类目名
+    stores_number_offline: int = 0  # 线下门店数量
+    year_sales_amount: str = ""  # 年销售额
+    main_market_values: List[str] = None  # 主攻市场名
+    main_area_values: List[str] = None  # 外贸主攻区域名
+    secondary_area_values: List[str] = None  # 外贸次要区域名
+    country_value: str = ""  # 国家名
+    
+    # 最近搜索词
+    recent_search_keywords: List[str] = None  # 最近10个搜索词（过滤掉isSearchFactory=true的）
+    
+    def __post_init__(self):
+        """初始化默认值"""
+        if self.register_category_values is None:
+            self.register_category_values = []
+        if self.auth_category_values is None:
+            self.auth_category_values = []
+        if self.customer_goods_structures is None:
+            self.customer_goods_structures = []
+        if self.brand_category_values is None:
+            self.brand_category_values = []
+        if self.category_values is None:
+            self.category_values = []
+        if self.main_market_values is None:
+            self.main_market_values = []
+        if self.main_area_values is None:
+            self.main_area_values = []
+        if self.secondary_area_values is None:
+            self.secondary_area_values = []
+        if self.recent_search_keywords is None:
+            self.recent_search_keywords = []
+
+
+class UserProfileExtractor:
+    """用户画像信息提取器"""
+    
+    def __init__(self):
+        """初始化提取器"""
+        self.behavior_stats_config = BehaviorStatsConfig()
+        self.dict_loader = DictLoader()
+    
+    def extract_user_profile_info(self, user_profile: UserProfile) -> UserProfileInfo:
+        """
+        从UserProfile中提取相关信息
+        
+        Args:
+            user_profile: UserProfile对象
+            
+        Returns:
+            UserProfileInfo: 提取的用户画像信息
+        """
+        if not user_profile or not user_profile.base_info:
+            logger.warning("[extract_user_profile_info] UserProfile or base_info is None")
+            return UserProfileInfo()
+        
+        base_info = user_profile.base_info
+        
+        # 提取基础信息
+        profile_info = UserProfileInfo(
+            sale_market_value=base_info.saleMarketValue or "",
+            nature_of_company_value=base_info.natureOfCompanyValue or "",
+            customer_type=base_info.customerType or "",
+            customer_type_value=base_info.customerTypeValue or "",
+            sell_channel_value=base_info.sellChannelValue or "",
+            stores_number=base_info.storesNumber or 0,
+            register_category_values=[str(item) for item in base_info.registerCategoryValues] if base_info.registerCategoryValues else [],
+            auth_category_values=[str(item) for item in base_info.authCategoryValues] if base_info.authCategoryValues else [],
+            purchase_quantity_by_year_value=base_info.purchaseQuantityByYearValue or "",
+            customer_goods_structures=self._extract_customer_goods_structures(base_info.customerGoodsStructure),
+            brand_category_values=[str(item) for item in base_info.brandCategoryValues] if base_info.brandCategoryValues else [],
+            delivery_type_value=base_info.deliveryTypeValue or "",
+            customs_import_scale=base_info.customsImportScale or "",
+            purchase_quantity=base_info.purchaseQuantity or 0,
+            tax_clearance_type=base_info.taxClearanceType or "",
+            tax_clearance_type_value=base_info.taxClearanceTypeValue or "",
+            category_values=[str(item) for item in base_info.categoryValues] if base_info.categoryValues else [],
+            stores_number_offline=base_info.storesNumberOffline or 0,
+            year_sales_amount=base_info.yearSalesAmount or "",
+            main_market_values=[str(item) for item in base_info.mainMarketValues] if base_info.mainMarketValues else [],
+            main_area_values=[str(item) for item in base_info.mainAreaValues] if base_info.mainAreaValues else [],
+            secondary_area_values=[str(item) for item in base_info.secondaryAreaValues] if base_info.secondaryAreaValues else [],
+            country_value=base_info.countryValue or "",
+            recent_search_keywords=self._extract_recent_search_keywords(user_profile)
+        )
+        
+        logger.info(f"[UserProfileExtractor.extract_user_profile_info] Extracted user profile info: {profile_info}")
+        return profile_info
+    
+    def _extract_customer_goods_structures(self, customer_goods_structures) -> List[Dict[str, str]]:
+        """
+        提取客户商品结构信息
+        
+        Args:
+            customer_goods_structures: 客户商品结构列表
+            
+        Returns:
+            List[Dict[str, str]]: 客户商品结构信息列表
+        """
+        if not customer_goods_structures:
+            return []
+        
+        structures = []
+        for structure in customer_goods_structures:
+            structure_info = {
+                'price_between': structure.priceBetween or "",
+                'goods_grade': structure.goodsGrade or "",
+                'package_type': structure.packageType or ""
+            }
+            structures.append(structure_info)
+        
+        return structures
+
+        
+    def generate_chat_search_intro(self, profile_info: UserProfileInfo) -> str:
+        """
+        生成导购语介绍
+        
+        Args:
+            profile_info: UserProfileInfo对象
+            
+        Returns:
+            str: 导购语介绍
+        """
+        if profile_info:
+            customer_type_value = profile_info.customer_type_value
+            # 地理位置信息
+            location = profile_info.sale_market_value if profile_info.sale_market_value else profile_info.country_value
+        else:
+            customer_type_value = None
+            location = None
+        
+        # 生成导购语
+        if not location and not customer_type_value:
+            return "你是一个跨境B2B选品顾问，请基于客户背景信息、本次搜索query及其相关的搜索结果，按要求完成选品的思考和建议。"
+        elif not location:
+            return f"你是一个跨境B2B选品顾问，了解“{customer_type_value}”类型客户的采购决策逻辑。请基于客户背景信息、本次搜索query及其相关的搜索结果，按要求完成选品的思考和建议。"  
+        elif not customer_type_value:
+            return f"你是一个跨境B2B选品顾问，熟悉{location}市场。请基于客户背景信息、本次搜索query及其相关的搜索结果，按要求完成选品的思考和建议。"
+        else:
+            return f"你是一个跨境B2B选品顾问，熟悉{location}市场，了解“{customer_type_value}”类型客户的采购决策逻辑。请基于客户背景信息、本次搜索query及其相关的搜索结果，按要求完成选品的思考和建议。"
+
+
+    def generate_natural_language_description(self, profile_info: UserProfileInfo) -> str:
+        """
+        生成用户基础信息的自然语言描述
+        
+        Args:
+            profile_info: UserProfileInfo对象
+            
+        Returns:
+            str: 自然语言描述
+        """
+        if not profile_info:
+            return "暂无用户画像信息"
+        
+        description_parts = []
+        
+        # 基础公司信息
+        if profile_info.customer_type_value:
+            description_parts.append(f"公司类型：{profile_info.customer_type_value}")
+        
+        if profile_info.nature_of_company_value:
+            description_parts.append(f"公司性质：{profile_info.nature_of_company_value}")
+        
+        if profile_info.sell_channel_value:
+            description_parts.append(f"销售渠道：{profile_info.sell_channel_value}")
+        
+        # 地理位置信息
+        location_parts = []
+        if profile_info.country_value:
+            location_parts.append(profile_info.country_value)
+        if profile_info.sale_market_value:
+            location_parts.append(profile_info.sale_market_value)
+        if location_parts:
+            description_parts.append(f"主要销售地区：{', '.join(location_parts)}")
+        
+        # 门店信息
+        if profile_info.stores_number > 0:
+            description_parts.append(f"门店数量：{profile_info.stores_number}家")
+        if profile_info.stores_number_offline > 0:
+            description_parts.append(f"线下门店：{profile_info.stores_number_offline}家")
+        
+        # 采购信息
+        if profile_info.purchase_quantity_by_year_value:
+            description_parts.append(f"采购规模：{profile_info.purchase_quantity_by_year_value}")
+        
+        if profile_info.purchase_quantity > 0:
+            description_parts.append(f"单款采购箱数：{profile_info.purchase_quantity}箱")
+        
+        # 年销售额
+        if profile_info.year_sales_amount:
+            description_parts.append(f"年销售额：{profile_info.year_sales_amount}")
+        
+        # 类目信息
+        if profile_info.register_category_values:
+            description_parts.append(f"注册采购品类：{', '.join(str(item) for item in profile_info.register_category_values)}")
+        
+        if profile_info.auth_category_values:
+            description_parts.append(f"认证采购品类：{', '.join(str(item) for item in profile_info.auth_category_values)}")
+        
+        if profile_info.category_values:
+            description_parts.append(f"经营类目：{', '.join(str(item) for item in profile_info.category_values)}")
+        
+        # 品牌信息
+        if profile_info.brand_category_values:
+            description_parts.append(f"品牌品类：{', '.join(str(item) for item in profile_info.brand_category_values)}")
+        
+        # 市场信息
+        if profile_info.main_market_values:
+            description_parts.append(f"主攻市场：{', '.join(str(item) for item in profile_info.main_market_values)}")
+        
+        if profile_info.main_area_values:
+            description_parts.append(f"外贸主攻区域：{', '.join(str(item) for item in profile_info.main_area_values)}")
+        
+        # 商品结构统计
+        if profile_info.customer_goods_structures:
+            structure_descriptions = []
+            for structure in profile_info.customer_goods_structures[:USER_PROFILE_BEHAVIOR_CONFIG['max_customer_goods_structures']]:  # 只取前N个
+                parts = []
+                if structure['price_between']:
+                    parts.append(f"价格区间{structure['price_between']}")
+                if structure['goods_grade']:
+                    parts.append(f"产品档次{structure['goods_grade']}")
+                if structure['package_type']:
+                    parts.append(f"包装类型{structure['package_type']}")
+                if parts:
+                    structure_descriptions.append('、'.join(parts))
+            
+            if structure_descriptions:
+                description_parts.append(f"商品结构统计：{'; '.join(structure_descriptions)}")
+        
+        # 物流信息
+        if profile_info.delivery_type_value:
+            description_parts.append(f"主要出货方式：{profile_info.delivery_type_value}")
+        
+        if profile_info.tax_clearance_type_value:
+            description_parts.append(f"清关方式：{profile_info.tax_clearance_type_value}")
+        
+        if profile_info.customs_import_scale:
+            description_parts.append(f"海关进口规模：{profile_info.customs_import_scale}")
+                
+        # 组合成完整描述
+        if description_parts:
+            return "\n".join(description_parts)
+        else:
+            return "暂无用户画像信息（信息为空）"
+    
+    def extract_and_describe(self, user_profile: UserProfile) -> str:
+        """
+        提取用户画像信息并生成完整的自然语言描述
+        
+        Args:
+            user_profile: UserProfile对象
+            
+        Returns:
+            导购语, 完整的用户画像自然语言描述
+        """
+        # 提取基础信息
+        profile_info = self.extract_user_profile_info(user_profile)
+
+        # 生成导购语
+        guide_intro = self.generate_chat_search_intro(profile_info)
+
+        if not user_profile:
+            return guide_intro, "暂无用户画像信息"
+        
+        natural_description = self.generate_natural_language_description(profile_info)
+
+        # 提取历史行为中的通用属性分布统计
+        common_attribute_distribution = self.extract_common_attribute_distribution(user_profile)
+        
+        # 提取历史行为中每个商品的具体属性统计
+        item_specific_attributes = self.extract_item_specific_attributes(user_profile)
+                        
+        # 生成自然语言描述
+        common_attribute_description = self.generate_common_attribute_distribution_description(common_attribute_distribution)
+        item_specific_attribute_description = self.generate_item_specific_attribute_description(item_specific_attributes)
+        
+        # 组织完整的描述
+        language = getattr(self, 'language', 'zh')
+        
+        complete_description = f"{get_display_text('customer_background', language)}：\n{natural_description}"
+        
+        # 添加通用属性分布描述
+        if USER_BEHAVIOR_STAT_IN_PROMPT:
+            if common_attribute_description:
+                complete_description += f"\n\n{get_display_text('historical_purchase_general_attributes', language)}：\n{common_attribute_description}"
+            
+            # 添加具体属性偏好描述
+            if item_specific_attribute_description:
+                complete_description += f"\n\n{get_display_text('historical_purchase_category_specific_attributes', language)}：\n{item_specific_attribute_description}"
+        
+        # 添加最近搜索词信息
+        # 提取最近搜索词
+        if USER_SEARCH_HISTORY_IN_PROMPT:
+            recent_search_keywords = self._extract_recent_search_keywords(user_profile)
+            if recent_search_keywords:
+                complete_description += f"\n\n{get_display_text('recent_search_keywords', language)}：{', '.join(recent_search_keywords)}"
+        
+        return guide_intro, complete_description 
+
+    def extract_common_attribute_distribution(self, user_profile: UserProfile) -> Dict[str, Any]:
+        """
+        提取历史行为中的通用属性分布统计
+        
+        Args:
+            user_profile: UserProfile对象
+            
+        Returns:
+            Dict[str, Any]: 通用属性分布统计信息
+        """
+        if not user_profile or not user_profile.behavior_map:
+            logger.warning("[extract_common_attribute_distribution] UserProfile or behavior_map is None")
+            return {}
+        
+        behavior_map = user_profile.behavior_map
+        common_features = {}
+        
+        # 获取所有行为数据
+        all_behaviors = []
+        for behavior_type, behaviors in [
+            ('click', behavior_map.click),
+            ('add_cart', behavior_map.add_cart),
+            ('collect', behavior_map.collect),
+            ('purchase', behavior_map.purchase)
+        ]:
+            logger.info(f"[UserProfileExtractor.extract_common_attribute_distribution] Extracted behavior_type {behavior_type} with {len(behaviors)} behaviors")
+            for behavior in behaviors:
+                all_behaviors.append((behavior, self.behavior_stats_config.behavior_weights[behavior_type]))
+                
+        
+        # 1. 处理直接取值字段
+        for field_config in self.behavior_stats_config.direct_fields:
+            if not field_config.enable:
+                continue
+            counter = Counter()
+            total_weight_for_field = 0  # 该字段的总权重（包括空值）
+            
+            for behavior, weight in all_behaviors:
+                total_weight_for_field += weight  # 所有行为都计入总数
+                if hasattr(behavior, field_config.field_name):
+                    value = getattr(behavior, field_config.field_name)
+                    if value:  # 确保值不为空
+                        counter[str(value)] += weight  # 转换为字符串
+                    # 如果值为空，不加入counter，但已计入total_weight_for_field
+            
+            # 计算空值权重
+            empty_weight = total_weight_for_field - sum(counter.values())
+            if empty_weight > 0:
+                counter['__empty__'] = empty_weight
+            
+            # 保存统计结果
+            common_features[f'{field_config.feature_prefix}_weighted_counts'] = dict(counter)
+            common_features[f'{field_config.feature_prefix}_total_weight'] = total_weight_for_field
+            common_features[f'{field_config.feature_prefix}_top_items'] = [item for item, count in counter.most_common(10)]
+        
+        # 2. 处理重复字段
+        for field_config in self.behavior_stats_config.repeated_fields:
+            if not field_config.enable:
+                continue
+            counter = Counter()
+            total_weight_for_field = 0  # 该字段的总权重（包括空值）
+            
+            for behavior, weight in all_behaviors:
+                total_weight_for_field += weight  # 所有行为都计入总数
+                if hasattr(behavior, field_config.field_name) and getattr(behavior, field_config.field_name):
+                    values = getattr(behavior, field_config.field_name)
+                    has_valid_value = False
+                    for value in values:
+                        if value:
+                            counter[str(value)] += weight
+                            has_valid_value = True
+                    # 如果没有有效值，不加入counter，但已计入total_weight_for_field
+                # 如果字段不存在或为空，不加入counter，但已计入total_weight_for_field
+            
+            # 计算空值权重
+            empty_weight = total_weight_for_field - sum(counter.values())
+            if empty_weight > 0:
+                counter['__empty__'] = empty_weight
+            
+            common_features[f'{field_config.feature_prefix}_weighted_counts'] = dict(counter)
+            common_features[f'{field_config.feature_prefix}_total_weight'] = total_weight_for_field
+            common_features[f'{field_config.feature_prefix}_top_items'] = [item for item, count in counter.most_common(10)]
+        
+        # 3. 处理数值字段分桶统计
+        for field_config in self.behavior_stats_config.numeric_fields:
+            if not field_config.enable:
+                continue
+            bucket_counter = Counter()
+            total_weight_for_field = 0  # 该字段的总权重（包括空值）
+            
+            for behavior, weight in all_behaviors:
+                total_weight_for_field += weight  # 所有行为都计入总数
+                if hasattr(behavior, field_config.field_name):
+                    value = getattr(behavior, field_config.field_name)
+                    if value and value > 0:
+                        bucket = int(value / field_config.bucket_size)
+                        bucket_counter[str(bucket)] += weight  # 转换为字符串
+                    # 如果值为空或<=0，不加入counter，但已计入total_weight_for_field
+            
+            # 计算空值权重
+            empty_weight = total_weight_for_field - sum(bucket_counter.values())
+            if empty_weight > 0:
+                bucket_counter['__empty__'] = empty_weight
+            
+            common_features[f'{field_config.feature_prefix}_bucket_weighted_counts'] = dict(bucket_counter)
+            common_features[f'{field_config.feature_prefix}_total_weight'] = total_weight_for_field
+            common_features[f'{field_config.feature_prefix}_top_buckets'] = [bucket for bucket, count in bucket_counter.most_common(10)]
+        
+        # 4. 处理时间差统计
+        for field_config in self.behavior_stats_config.time_fields:
+            if not field_config.enable:
+                continue
+            time_bucket_counter = Counter()
+            total_weight_for_field = 0  # 该字段的总权重（包括空值）
+            
+            for behavior, weight in all_behaviors:
+                total_weight_for_field += weight  # 所有行为都计入总数
+                if hasattr(behavior, field_config.field_name) and hasattr(behavior, 'behaviorTime'):
+                    time_value = getattr(behavior, field_config.field_name)
+                    behavior_time = behavior.behaviorTime
+                    
+                    if time_value and behavior_time:
+                        try:
+                            # 解析时间字符串
+                            if isinstance(time_value, str):
+                                time_obj = datetime.strptime(time_value, '%Y-%m-%d %H:%M:%S')
+                            else:
+                                time_obj = time_value
+                            
+                            if isinstance(behavior_time, str):
+                                behavior_time_obj = datetime.strptime(behavior_time, '%Y-%m-%d %H:%M:%S')
+                            else:
+                                behavior_time_obj = behavior_time
+                            
+                            # 计算时间差（月数）
+                            time_diff = behavior_time_obj - time_obj
+                            months_diff = int(time_diff.days / 30)
+                            
+                            # 分桶：0-6个月，6-12个月，12-24个月，24个月以上
+                            if months_diff < 0:
+                                bucket = 'future'
+                            elif months_diff <= 6:
+                                bucket = '0-6m'
+                            elif months_diff <= 12:
+                                bucket = '6-12m'
+                            elif months_diff <= 24:
+                                bucket = '12-24m'
+                            else:
+                                bucket = '24m+'
+                            
+                            time_bucket_counter[bucket] += weight
+                            
+                        except (ValueError, TypeError) as e:
+                            logger.debug(f"Error parsing time for {field_config.field_name}: {e}")
+                            continue
+                    # 如果时间值为空或解析失败，不加入counter，但已计入total_weight_for_field
+            
+            # 计算空值权重
+            empty_weight = total_weight_for_field - sum(time_bucket_counter.values())
+            if empty_weight > 0:
+                time_bucket_counter['__empty__'] = empty_weight
+            
+            common_features[f'{field_config.feature_prefix}_time_bucket_weighted_counts'] = dict(time_bucket_counter)
+            common_features[f'{field_config.feature_prefix}_total_weight'] = total_weight_for_field
+            common_features[f'{field_config.feature_prefix}_top_time_buckets'] = [bucket for bucket, count in time_bucket_counter.most_common(5)]
+        
+        # 5. 综合统计信息
+        total_weighted_behaviors = sum(weight for _, weight in all_behaviors)
+        common_features['total_weighted_behaviors'] = total_weighted_behaviors
+        
+        # 各行为类型的统计
+        behavior_type_counts = Counter()
+        for behavior_type, behaviors in [
+            ('click', behavior_map.click),
+            ('add_cart', behavior_map.add_cart),
+            ('collect', behavior_map.collect),
+            ('purchase', behavior_map.purchase)
+        ]:
+            behavior_type_counts[behavior_type] = len(behaviors)
+        
+        common_features['behavior_type_counts'] = dict(behavior_type_counts)
+        
+        logger.info(f"Extracted behavior stats with {len(common_features)} feature groups")
+        return common_features
+    
+    def extract_item_specific_attributes(self, user_profile: UserProfile) -> Dict[str, Any]:
+        """
+        从历史行为中提取每个商品的具体属性统计
+        
+        Args:
+            user_profile: UserProfile对象
+            
+        Returns:
+            Dict[str, Any]: 商品具体属性统计信息
+        """
+        if not user_profile or not user_profile.behavior_map:
+            logger.warning("[extract_item_specific_attributes] UserProfile or behavior_map is None")
+            return {}
+        
+        behavior_map = user_profile.behavior_map
+        
+        # 获取所有行为数据
+        all_behaviors = []
+        for behavior_type, behaviors in [
+            ('click', behavior_map.click),
+            ('add_cart', behavior_map.add_cart),
+            ('collect', behavior_map.collect),
+            ('purchase', behavior_map.purchase)
+        ]:
+            for behavior in behaviors:
+                all_behaviors.append((behavior, self.behavior_stats_config.behavior_weights[behavior_type]))
+        
+        # 统计每个属性名称和属性值对应的权重
+        attr_statistics = {}  # {attr_name: {option_name: weight}}
+        
+        for behavior, weight in all_behaviors:
+            # 合并 spuAttributeList 和 skuAttributeList
+            merged_attributes = []
+            
+            # 以 skuAttributeList 为基础
+            if hasattr(behavior, 'skuAttributeList') and behavior.skuAttributeList:
+                merged_attributes.extend(behavior.skuAttributeList)
+            
+            # 加入 spuAttributeList，如果 attributeId 已存在则跳过
+            existing_attr_ids = set()
+            if hasattr(behavior, 'skuAttributeList') and behavior.skuAttributeList:
+                existing_attr_ids = {attr.attributeId for attr in behavior.skuAttributeList}
+            
+            if hasattr(behavior, 'spuAttributeList') and behavior.spuAttributeList:
+                for attr in behavior.spuAttributeList:
+                    if attr.attributeId not in existing_attr_ids:
+                        merged_attributes.append(attr)
+                        existing_attr_ids.add(attr.attributeId)
+            
+            # 统计合并后的属性
+            for attr in merged_attributes:
+                attr_id = attr.attributeId
+                option_id = attr.optionId
+                
+                # 获取属性名称
+                attr_name = self.dict_loader.get_name('spu_attribute', str(attr_id))
+                if not attr_name:
+                    attr_name = self.dict_loader.get_name('sku_attribute', str(attr_id))
+                if not attr_name:
+                    attr_name = f"属性{attr_id}"
+                
+                # 获取属性值名称
+                option_name = self.dict_loader.get_name('spu_attribute_option', str(option_id))
+                if not option_name:
+                    option_name = self.dict_loader.get_name('sku_attribute_option', str(option_id))
+                if not option_name:
+                    option_name = f"选项{option_id}"
+                
+                # 跳过无效的属性值
+                if option_name == '无' or not option_name:
+                    continue
+                
+                # 统计
+                if attr_name not in attr_statistics:
+                    attr_statistics[attr_name] = {}
+                
+                if option_name not in attr_statistics[attr_name]:
+                    attr_statistics[attr_name][option_name] = 0
+                
+                attr_statistics[attr_name][option_name] += weight
+        
+        if not attr_statistics:
+            return {}
+        
+        # 生成属性统计特征
+        attribute_features = {}
+        
+        # 计算每个属性的总权重并排序
+        attr_with_total = [
+            (attr_name, options_dict, sum(options_dict.values()))
+            for attr_name, options_dict in attr_statistics.items()
+        ]
+        
+        # 按总权重排序，取前10个属性
+        sorted_attrs = sorted(attr_with_total, key=lambda x: x[2], reverse=True)
+        
+        for attr_name, options_dict, total_weight in sorted_attrs:
+            # 按权重排序选项，取前5个
+            sorted_options = sorted(options_dict.items(), key=lambda x: x[1], reverse=True)
+            
+            # 生成特征名称（使用属性名称的拼音或ID作为前缀）
+            attr_feature_prefix = f"attr_{attr_name.replace(' ', '_').replace('：', '_')}"
+            
+            attribute_features[f'{attr_feature_prefix}_weighted_counts'] = dict(options_dict)
+            attribute_features[f'{attr_feature_prefix}_total_weight'] = total_weight
+            attribute_features[f'{attr_feature_prefix}_top_items'] = [item for item, count in sorted_options]
+        
+        # 添加总体属性统计
+        total_attribute_weight = sum(attr[2] for attr in sorted_attrs)
+        attribute_features['attribute_total_weight'] = total_attribute_weight
+        attribute_features['attribute_attr_count'] = len(sorted_attrs)
+        
+        logger.info(f"Extracted attribute statistics with {len(attribute_features)} attribute feature groups")
+        return attribute_features
+    
+    def generate_common_attribute_distribution_description(self, common_attribute_distribution: Dict[str, Any]) -> str:
+        """
+        生成通用属性分布统计的自然语言描述
+        
+        Args:
+            common_attribute_distribution: 通用属性分布统计信息
+            
+        Returns:
+            str: 自然语言描述
+        """
+        if not common_attribute_distribution:
+            return "暂无通用属性分布统计信息"
+        
+        description_parts = []
+        
+        # 0. 行为总述（放在最前面）
+        if 'behavior_type_counts' in common_attribute_distribution:
+            behavior_counts = common_attribute_distribution['behavior_type_counts']
+            total_behaviors = sum(behavior_counts.values())
+            
+            if total_behaviors > 0:
+                behavior_summary_parts = []
+                
+                # 检查是否达到截断限制
+                if total_behaviors >= self.behavior_stats_config.behavior_summary_truncate_limit:
+                    behavior_summary_parts.append(f"该用户有超过{self.behavior_stats_config.behavior_summary_truncate_limit}次行为")
+                else:
+                    behavior_summary_parts.append(f"该用户有{total_behaviors}次行为")
+                
+                # 添加具体行为类型统计
+                behavior_details = []
+                if behavior_counts.get('click', 0) > 0:
+                    behavior_details.append(f"{behavior_counts['click']}次点击")
+                if behavior_counts.get('add_cart', 0) > 0:
+                    behavior_details.append(f"{behavior_counts['add_cart']}次加购")
+                if behavior_counts.get('collect', 0) > 0:
+                    behavior_details.append(f"{behavior_counts['collect']}次收藏")
+                if behavior_counts.get('purchase', 0) > 0:
+                    behavior_details.append(f"{behavior_counts['purchase']}次购买")
+                
+                if behavior_details:
+                    behavior_summary_parts.append(f"包括{', '.join(behavior_details)}")
+                
+                description_parts.append(''.join(behavior_summary_parts))
+        
+        # 1. 处理直接取值字段描述
+        for field_config in self.behavior_stats_config.direct_fields:
+            if not field_config.enable:
+                continue
+            weighted_counts_key = f'{field_config.feature_prefix}_weighted_counts'
+            total_weight_key = f'{field_config.feature_prefix}_total_weight'
+            
+            if weighted_counts_key in common_attribute_distribution and total_weight_key in common_attribute_distribution:
+                weighted_counts = common_attribute_distribution[weighted_counts_key]
+                total_weight = common_attribute_distribution[total_weight_key]
+                
+                if total_weight > 0:
+                    # 生成带占比的描述
+                    items_with_percentage = []
+                    for item, count in sorted(weighted_counts.items(), key=lambda x: x[1], reverse=True)[:field_config.max_items]:
+                        percentage = (count / total_weight) * 100
+                        # 词典映射
+                        if item == '__empty__':
+                            display_name = '空值'
+                        elif field_config.dict_name:
+                            display_name = self.dict_loader.get_name(field_config.dict_name, str(item)) or str(item)
+                        else:
+                            display_name = str(item)
+                        
+                        items_with_percentage.append(f"{display_name}({percentage:.1f}%)")
+                    
+                    if items_with_percentage:
+                        description = field_config.description_template.format(
+                            display_name=field_config.display_name,
+                            values=', '.join(items_with_percentage)
+                        )
+                        description_parts.append(description)
+        
+        # 2. 处理重复字段描述
+        for field_config in self.behavior_stats_config.repeated_fields:
+            if not field_config.enable:
+                continue
+            weighted_counts_key = f'{field_config.feature_prefix}_weighted_counts'
+            total_weight_key = f'{field_config.feature_prefix}_total_weight'
+            
+            if weighted_counts_key in common_attribute_distribution and total_weight_key in common_attribute_distribution:
+                weighted_counts = common_attribute_distribution[weighted_counts_key]
+                total_weight = common_attribute_distribution[total_weight_key]
+                
+                if total_weight > 0:
+                    # 生成带占比的描述
+                    items_with_percentage = []
+                    for item, count in sorted(weighted_counts.items(), key=lambda x: x[1], reverse=True)[:field_config.max_items]:
+                        percentage = (count / total_weight) * 100
+                        # 词典映射
+                        if item == '__empty__':
+                            display_name = '空值'
+                        elif field_config.dict_name:
+                            display_name = self.dict_loader.get_name(field_config.dict_name, str(item)) or str(item)
+                        else:
+                            display_name = str(item)
+                        
+                        items_with_percentage.append(f"{display_name}({percentage:.1f}%)")
+                    
+                    if items_with_percentage:
+                        description = field_config.description_template.format(
+                            display_name=field_config.display_name,
+                            values=', '.join(items_with_percentage)
+                        )
+                        description_parts.append(description)
+        
+        # 3. 处理数值字段描述
+        for field_config in self.behavior_stats_config.numeric_fields:
+            if not field_config.enable:
+                continue
+            bucket_counts_key = f'{field_config.feature_prefix}_bucket_weighted_counts'
+            total_weight_key = f'{field_config.feature_prefix}_total_weight'
+            
+            if bucket_counts_key in common_attribute_distribution and total_weight_key in common_attribute_distribution:
+                bucket_counts = common_attribute_distribution[bucket_counts_key]
+                total_weight = common_attribute_distribution[total_weight_key]
+                
+                if total_weight > 0:
+                    # 生成带占比的描述
+                    ranges_with_percentage = []
+                    for bucket, count in sorted(bucket_counts.items(), key=lambda x: x[1], reverse=True)[:field_config.max_items]:
+                        percentage = (count / total_weight) * 100
+                        
+                        if bucket == '__empty__':
+                            range_desc = '空值'
+                        else:
+                            range_desc = f"{int(bucket)*field_config.bucket_size}-{(int(bucket)+1)*field_config.bucket_size}"
+                        
+                        ranges_with_percentage.append(f"{range_desc}({percentage:.1f}%)")
+                    
+                    if ranges_with_percentage:
+                        description = field_config.description_template.format(
+                            display_name=field_config.display_name,
+                            values=', '.join(ranges_with_percentage)
+                        )
+                        description_parts.append(description)
+        
+        # 4. 处理时间字段描述
+        for field_config in self.behavior_stats_config.time_fields:
+            if not field_config.enable:
+                continue
+            time_bucket_counts_key = f'{field_config.feature_prefix}_time_bucket_weighted_counts'
+            total_weight_key = f'{field_config.feature_prefix}_total_weight'
+            
+            if time_bucket_counts_key in common_attribute_distribution and total_weight_key in common_attribute_distribution:
+                time_bucket_counts = common_attribute_distribution[time_bucket_counts_key]
+                total_weight = common_attribute_distribution[total_weight_key]
+                
+                if total_weight > 0:
+                    # 生成带占比的描述
+                    time_descriptions_with_percentage = []
+                    for bucket, count in sorted(time_bucket_counts.items(), key=lambda x: x[1], reverse=True)[:field_config.max_items]:
+                        percentage = (count / total_weight) * 100
+                        bucket_str = str(bucket)
+                        
+                        if bucket_str == '__empty__':
+                            time_desc = '空值'
+                        elif bucket_str == '0-6m':
+                            time_desc = '半年内'
+                        elif bucket_str == '6-12m':
+                            time_desc = '半年到一年'
+                        elif bucket_str == '12-24m':
+                            time_desc = '1-2年'
+                        elif bucket_str == '24m+':
+                            time_desc = '2年+'
+                        elif bucket_str == 'future':
+                            time_desc = '错误时间'
+                        else:
+                            time_desc = bucket_str
+                        
+                        time_descriptions_with_percentage.append(f"{time_desc}({percentage:.1f}%)")
+                    
+                    if time_descriptions_with_percentage:
+                        description = field_config.description_template.format(
+                            display_name=field_config.display_name,
+                            values=', '.join(time_descriptions_with_percentage)
+                        )
+                        description_parts.append(description)
+        
+        # 组合成完整描述
+        if description_parts:
+            return "\n".join(description_parts)
+        else:
+            return "" 
+
+    def generate_item_specific_attribute_description(self, item_specific_attributes: Dict[str, Any]) -> str:
+        """
+        生成商品具体属性统计的自然语言描述
+        
+        Args:
+            item_specific_attributes: 商品具体属性统计信息
+            
+        Returns:
+            str: 商品具体属性统计的自然语言描述
+        """
+        if not item_specific_attributes:
+            return "暂无商品具体属性统计信息。"
+        
+        descriptions = []
+        
+        # 获取所有属性相关的特征
+        attr_features = {}
+        for key, value in item_specific_attributes.items():
+            if key.startswith('attr_') and key.endswith('_weighted_counts'):
+                attr_name = key.replace('_weighted_counts', '').replace('attr_', '')
+                attr_features[attr_name] = value
+        
+        if not attr_features:
+            return "暂无有效属性统计信息。"
+        
+        # 按总权重排序属性
+        sorted_attrs = []
+        for attr_name, weighted_counts in attr_features.items():
+            total_weight = sum(weighted_counts.values())
+            sorted_attrs.append((attr_name, weighted_counts, total_weight))
+        
+        sorted_attrs.sort(key=lambda x: x[2], reverse=True)
+        
+        # 生成描述
+        max_attrs = USER_PROFILE_BEHAVIOR_CONFIG['max_attributes_display']
+        max_options = USER_PROFILE_BEHAVIOR_CONFIG['max_options_per_attribute']
+        for attr_name, weighted_counts, total_weight in sorted_attrs[:max_attrs]:  # 取前N个属性
+            # 按权重排序选项，取前N个
+            sorted_options = sorted(weighted_counts.items(), key=lambda x: x[1], reverse=True)[:max_options]
+            
+            option_texts = []
+            for option_name, weight in sorted_options:
+                if option_name != '__empty__':
+                    # 计算百分比
+                    percentage = (weight / total_weight) * 100
+                    option_texts.append(f"{option_name}({percentage:.1f}%)")
+            
+            if option_texts:
+                desc = f"• {attr_name}: {', '.join(option_texts)}"
+                descriptions.append(desc)
+        
+        if descriptions:
+            return "\n".join(descriptions)
+        return "暂无有效属性统计信息。"
+    
+    def _extract_recent_search_keywords(self, user_profile: UserProfile) -> List[str]:
+        """
+        提取最近10个搜索词（过滤掉isSearchFactory=true的）
+        
+        Args:
+            user_profile: UserProfile对象
+            
+        Returns:
+            List[str]: 最近10个搜索词列表
+        """
+        if not user_profile or not user_profile.behavior_map:
+            return []
+        
+        search_keywords = user_profile.behavior_map.search_keyword
+        if not search_keywords:
+            return []
+        
+        # 过滤、去重并收集最近10个搜索词
+        seen_keywords = set()
+        recent_keywords = []
+        for search_behavior in search_keywords:
+            if not search_behavior.isSearchFactory and search_behavior.keyword:
+                keyword = search_behavior.keyword.strip()
+                
+                # 过滤掉纯数字、下划线、减号、空白字符构成的关键词
+                if self._is_valid_search_keyword(keyword):
+                    if keyword not in seen_keywords:
+                        seen_keywords.add(keyword)
+                        recent_keywords.append(keyword)
+                        if len(recent_keywords) >= SESSION_CONFIG['max_recent_search_keywords']:  # 达到最大数量就停止
+                            break
+                
+        logger.info(f"[UserProfileExtractor._extract_recent_search_keywords] Extracted {len(recent_keywords)} recent search keywords")
+        return recent_keywords
+    
+    def _is_valid_search_keyword(self, keyword: str) -> bool:
+        """
+        判断搜索关键词是否有效
+        
+        Args:
+            keyword: 搜索关键词
+            
+        Returns:
+            bool: 是否有效
+        """
+        if not keyword or keyword.strip() == '':
+            return False
+        
+        # 过滤掉纯数字、下划线、减号、空白字符构成的关键词
+        # 使用正则表达式匹配：只包含数字、下划线、减号、空白字符的字符串
+        if re.match(r'^[\d\s_-]+$', keyword):
+            return False
+        
+        # 只有一个单词(split后只有一个）、并且这个单词里面既包含数字又包含字母 （转小写后 既有小写字母、又有数字）
+        if len(keyword.split()) == 1:
+            if re.match(r'^[a-z0-9]+$', keyword.lower()):
+                return False
+            # 包含数字和-
+            if re.match(r'^[0-9-]+$', keyword):
+                return False
+        
+        return True
 \ No newline at end of file