From 9466d4ead52b69b82a29a86f7047de8e6f580e63 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 17:32:46 +0800
Subject: [PATCH 01/26] docs: add AFM weighted training development plan

---
 docs/afm-weighted-training-plan.md | 179 +++++++++++++++++++++++++++++
 1 file changed, 179 insertions(+)
 create mode 100644 docs/afm-weighted-training-plan.md

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
new file mode 100644
index 000000000..6148404e9
--- /dev/null
+++ b/docs/afm-weighted-training-plan.md
@@ -0,0 +1,179 @@
+# AFM 带权重训练开发计划
+
+## 1. 背景
+
+### 1.1 问题分析
+
+在推荐系统中，用户行为有多种类型，例如：
+- **点击 (click)** - 隐式反馈，数量多但价值较低
+- **收藏 (favorite)** - 显式反馈，价值中等
+- **购买 (purchase)** - 显式反馈，数量少但价值高
+- **评分 (rating)** - 显式反馈，有具体数值
+
+当前 AFM 模型对所有样本使用相同的权重训练，忽略了不同 feedback type 的价值差异。
+
+### 1.2 目标
+
+实现 AFM 模型的带权重训练，为每个 feedback type 设置不同的权重，使模型更关注高价值行为。
+
+## 2. 技术方案
+
+### 2.1 当前实现
+
+**数据流：**
+```
+Feedback {FeedbackType, UserId, ItemId, Value, ...}
+    ↓
+Dataset {Users, Items, Target, ...}
+    ↓
+AFM.Fit() → BCEWithLogits(target, output, nil)  // weights = nil
+```
+
+**发现：**
+- `nn.BCEWithLogits(target, prediction, weights)` 已支持 weights 参数
+- 只需传递权重张量即可实现带权重训练
+
+### 2.2 设计方案
+
+#### 2.2.1 权重配置
+
+```toml
+[recommend.collaborative.weights]
+click = 1.0      # 基准权重
+favorite = 2.0   # 收藏权重为点击的2倍
+purchase = 5.0   # 购买权重为点击的5倍
+rating = 3.0     # 评分权重
+```
+
+#### 2.2.2 数据结构扩展
+
+```go
+// Dataset 扩展
+type Dataset struct {
+    // 现有字段...
+    FeedbackTypes []string  // 每个样本对应的 feedback type
+}
+
+// AFM 扩展
+type AFM struct {
+    // 现有字段...
+    Weights map[string]float32  // feedback_type -> weight
+}
+```
+
+#### 2.2.3 训练流程
+
+```
+1. 加载数据时记录每个样本的 feedback_type
+2. 根据配置将 feedback_type 映射为权重
+3. 构建权重张量 weights
+4. 训练时使用 BCEWithLogits(target, output, weights)
+```
+
+### 2.3 实现细节
+
+#### 2.3.1 Dataset.Get() 扩展
+
+```go
+// 现有
+func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32)
+
+// 扩展
+func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32, string)
+//                                                            feedback_type ↑
+```
+
+#### 2.3.2 AFM.Fit() 修改
+
+```go
+// 构建权重张量
+weightsData := make([]float32, len(batchTarget))
+for i, feedbackType := range batchFeedbackTypes {
+    weightsData[i] = fm.Weights[feedbackType]
+}
+weightsTensor := nn.NewTensor(weightsData, batchSize)
+
+// 带权重损失
+batchLoss := nn.BCEWithLogits(batchTarget, batchOutput, weightsTensor)
+```
+
+## 3. 实现计划
+
+### Phase 1: 数据层扩展
+
+| 任务 | 文件 | 优先级 |
+|------|------|--------|
+| Dataset 添加 FeedbackTypes 字段 | model/ctr/data.go | P0 |
+| 修改数据加载流程记录 feedback_type | model/ctr/data.go | P0 |
+| 扩展 Get() 返回 feedback_type | model/ctr/data.go | P0 |
+
+### Phase 2: 模型层扩展
+
+| 任务 | 文件 | 优先级 |
+|------|------|--------|
+| AFM 添加 Weights 字段 | model/ctr/fm.go | P0 |
+| 修改 Fit() 支持带权重训练 | model/ctr/fm.go | P0 |
+| 修改 fm_xla.go 支持带权重训练 | model/ctr/fm_xla.go | P0 |
+| 模型序列化保存 Weights | model/ctr/fm.go | P0 |
+
+### Phase 3: 配置支持
+
+| 任务 | 文件 | 优先级 |
+|------|------|--------|
+| 添加权重配置解析 | config/config.go | P0 |
+| 支持从配置加载 Weights | model/ctr/fm.go | P0 |
+
+### Phase 4: 测试
+
+| 任务 | 优先级 |
+|------|--------|
+| 单元测试：带权重训练 | P0 |
+| 对比测试：有无权重效果对比 | P1 |
+
+## 4. 向后兼容性
+
+1. **默认行为**：未配置权重时，所有样本权重为 1.0（等价于原行为）
+2. **模型加载**：旧版模型无 Weights 字段时，使用默认权重
+3. **API 兼容**：Get() 方法保持向后兼容
+
+## 5. 待讨论问题
+
+### 5.1 数据来源
+
+**问题：训练数据如何关联 feedback_type？**
+
+**选项 A：从数据库加载**
+- 从 feedback 表读取，保留 feedback_type
+- 需要修改数据加载流程
+
+**选项 B：从配置文件加载**
+- 训练数据格式扩展，增加 feedback_type 字段
+- 兼容 libfm 格式扩展
+
+### 5.2 权重归一化
+
+**问题：是否需要对权重归一化？**
+
+**选项 A：不归一化**
+- 保持原始权重值
+- 权重影响梯度大小
+
+**选项 B：归一化**
+- 权重归一化到 [0, 1] 或均值为 1
+- 更稳定的训练过程
+
+### 5.3 XLA/GoMLX 版本
+
+**问题：fm_xla.go 是否同步支持？**
+
+GoMLX 的损失函数：
+```go
+losses.BinaryCrossentropyLogits(labels, predictions)
+```
+
+需要检查是否支持 sample weights。
+
+## 6. 参考资料
+
+- [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)
+- [Sample Weights in Deep Learning](https://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_sample_weight.html)

From 4c8a7494b3529ad424faa797f5c8b8d75d889b3a Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 18:16:27 +0800
Subject: [PATCH 02/26] docs: update AFM weighted training plan with
 expression-based weight config

- Support constant weights: "1", "2.5"
- Support Value-based expressions: "log(Value)", "Value * 2"
- Add feedback_weight config section
- Use govaluate for expression parsing
- Add example configs for e-commerce, video, music scenarios
---
 docs/afm-weighted-training-plan.md | 252 ++++++++++++++++++-----------
 1 file changed, 155 insertions(+), 97 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 6148404e9..43ce495c7 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -14,166 +14,224 @@
 
 ### 1.2 目标
 
-实现 AFM 模型的带权重训练，为每个 feedback type 设置不同的权重，使模型更关注高价值行为。
+实现 AFM 模型的带权重训练，通过表达式配置样本权重，支持：
+- 常量权重：`"1"`、`"2.5"`
+- 基于 Value 的表达式：`"log(Value)"`、`"Value * 2"`、`"sqrt(Value)"`
 
 ## 2. 技术方案
 
-### 2.1 当前实现
+### 2.1 配置格式
 
-**数据流：**
-```
-Feedback {FeedbackType, UserId, ItemId, Value, ...}
-    ↓
-Dataset {Users, Items, Target, ...}
-    ↓
-AFM.Fit() → BCEWithLogits(target, output, nil)  // weights = nil
+```toml
+[recommend.collaborative.feedback_weight]
+click = "1"           # 点击权重为常量 1
+favorite = "2"        # 收藏权重为常量 2
+purchase = "5"        # 购买权重为常量 5
+rating = "Value"      # 评分权重等于评分值
+view_time = "log(Value)"  # 观看时长用对数权重
+score = "Value / 5"   # 归一化评分
 ```
 
-**发现：**
-- `nn.BCEWithLogits(target, prediction, weights)` 已支持 weights 参数
-- 只需传递权重张量即可实现带权重训练
+### 2.2 表达式设计
 
-### 2.2 设计方案
+**支持的语法：**
 
-#### 2.2.1 权重配置
+| 类型 | 示例 | 说明 |
+|------|------|------|
+| 常量 | `1`, `2.5` | 固定权重值 |
+| 变量 | `Value` | 使用 feedback 的 value 字段 |
+| 数学函数 | `log(Value)`, `sqrt(Value)`, `abs(Value)` | 常用数学函数 |
+| 算术运算 | `Value * 2`, `Value / 10`, `Value + 1` | 四则运算 |
+| 复合表达式 | `log(Value + 1)`, `sqrt(Value) * 2` | 组合使用 |
 
-```toml
-[recommend.collaborative.weights]
-click = 1.0      # 基准权重
-favorite = 2.0   # 收藏权重为点击的2倍
-purchase = 5.0   # 购买权重为点击的5倍
-rating = 3.0     # 评分权重
-```
+**实现方式：**
+- 使用 Go 的表达式解析库（如 `github.com/Knetic/govaluate`）
+- 或实现简单的表达式解析器
+
+### 2.3 数据结构
 
-#### 2.2.2 数据结构扩展
+#### 2.3.1 WeightExpression
 
 ```go
-// Dataset 扩展
-type Dataset struct {
-    // 现有字段...
-    FeedbackTypes []string  // 每个样本对应的 feedback type
-}
+// common/expression/weight.go
 
-// AFM 扩展
-type AFM struct {
-    // 现有字段...
-    Weights map[string]float32  // feedback_type -> weight
+type WeightExpression struct {
+    expr string
+    // 解析后的表达式（使用 govaluate 或自定义解析器）
 }
+
+func ParseWeightExpression(s string) (*WeightExpression, error)
+func (e *WeightExpression) Evaluate(value float64) float32
 ```
 
-#### 2.2.3 训练流程
+#### 2.3.2 配置扩展
 
-```
-1. 加载数据时记录每个样本的 feedback_type
-2. 根据配置将 feedback_type 映射为权重
-3. 构建权重张量 weights
-4. 训练时使用 BCEWithLogits(target, output, weights)
-```
+```go
+// config/config.go
 
-### 2.3 实现细节
+type Config struct {
+    // 现有字段...
+    
+    // 新增：feedback 权重配置
+    FeedbackWeight map[string]string `mapstructure:"feedback_weight"`
+}
+```
 
-#### 2.3.1 Dataset.Get() 扩展
+#### 2.3.3 AFM 扩展
 
 ```go
-// 现有
-func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32)
+// model/ctr/fm.go
 
-// 扩展
-func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32, string)
-//                                                            feedback_type ↑
+type AFM struct {
+    // 现有字段...
+    
+    // 新增：feedback 权重表达式
+    FeedbackWeight map[string]*WeightExpression
+}
 ```
 
-#### 2.3.2 AFM.Fit() 修改
+#### 2.3.4 Dataset 扩展
 
 ```go
-// 构建权重张量
-weightsData := make([]float32, len(batchTarget))
-for i, feedbackType := range batchFeedbackTypes {
-    weightsData[i] = fm.Weights[feedbackType]
+// model/ctr/data.go
+
+type Dataset struct {
+    // 现有字段...
+    
+    // 新增：每个样本的 feedback type 和 value
+    FeedbackTypes []string
+    FeedbackValues []float64
 }
-weightsTensor := nn.NewTensor(weightsData, batchSize)
+```
 
-// 带权重损失
-batchLoss := nn.BCEWithLogits(batchTarget, batchOutput, weightsTensor)
+### 2.4 训练流程
+
+```
+1. 解析配置中的 feedback_weight 表达式
+2. 加载数据时记录每个样本的 feedback_type 和 value
+3. 训练时：
+   a. 根据 feedback_type 找到对应的权重表达式
+   b. 用 value 计算实际权重
+   c. 构建权重张量
+   d. 使用 BCEWithLogits(target, output, weights) 计算损失
 ```
 
 ## 3. 实现计划
 
-### Phase 1: 数据层扩展
+### Phase 1: 表达式解析
 
 | 任务 | 文件 | 优先级 |
 |------|------|--------|
-| Dataset 添加 FeedbackTypes 字段 | model/ctr/data.go | P0 |
-| 修改数据加载流程记录 feedback_type | model/ctr/data.go | P0 |
-| 扩展 Get() 返回 feedback_type | model/ctr/data.go | P0 |
+| 实现 WeightExpression 类型 | common/expression/weight.go | P0 |
+| 支持常量和 Value 变量 | common/expression/weight.go | P0 |
+| 支持数学函数 (log, sqrt, abs) | common/expression/weight.go | P1 |
+| 支持算术运算 | common/expression/weight.go | P1 |
+| 单元测试 | common/expression/weight_test.go | P0 |
 
-### Phase 2: 模型层扩展
+### Phase 2: 配置扩展
 
 | 任务 | 文件 | 优先级 |
 |------|------|--------|
-| AFM 添加 Weights 字段 | model/ctr/fm.go | P0 |
-| 修改 Fit() 支持带权重训练 | model/ctr/fm.go | P0 |
-| 修改 fm_xla.go 支持带权重训练 | model/ctr/fm_xla.go | P0 |
-| 模型序列化保存 Weights | model/ctr/fm.go | P0 |
+| 添加 FeedbackWeight 配置项 | config/config.go | P0 |
+| 解析权重表达式配置 | config/config.go | P0 |
+| 配置验证 | config/config.go | P0 |
+
+### Phase 3: 数据层扩展
+
+| 任务 | 文件 | 优先级 |
+|------|------|--------|
+| Dataset 添加 FeedbackTypes/FeedbackValues | model/ctr/data.go | P0 |
+| 修改数据加载流程 | model/ctr/data.go | P0 |
+| 向后兼容处理 | model/ctr/data.go | P0 |
 
-### Phase 3: 配置支持
+### Phase 4: 模型层扩展
 
 | 任务 | 文件 | 优先级 |
 |------|------|--------|
-| 添加权重配置解析 | config/config.go | P0 |
-| 支持从配置加载 Weights | model/ctr/fm.go | P0 |
+| AFM 添加 FeedbackWeight 字段 | model/ctr/fm.go | P0 |
+| 修改 Fit() 支持带权重训练 | model/ctr/fm.go | P0 |
+| 修改 fm_xla.go | model/ctr/fm_xla.go | P0 |
+| 模型序列化 | model/ctr/fm.go | P0 |
 
-### Phase 4: 测试
+### Phase 5: 测试
 
 | 任务 | 优先级 |
 |------|--------|
-| 单元测试：带权重训练 | P0 |
-| 对比测试：有无权重效果对比 | P1 |
+| 表达式解析测试 | P0 |
+| 带权重训练测试 | P0 |
+| 效果对比测试 | P1 |
 
-## 4. 向后兼容性
+## 4. 表达式库选择
 
-1. **默认行为**：未配置权重时，所有样本权重为 1.0（等价于原行为）
-2. **模型加载**：旧版模型无 Weights 字段时，使用默认权重
-3. **API 兼容**：Get() 方法保持向后兼容
+### 选项 A: govaluate
 
-## 5. 待讨论问题
+```go
+import "github.com/Knetic/govaluate"
 
-### 5.1 数据来源
+expr, _ := govaluate.NewEvaluableExpression("log(Value) + 1")
+params := map[string]interface{}{"Value": 100.0}
+result, _ := expr.Evaluate(params)
+```
 
-**问题：训练数据如何关联 feedback_type？**
+**优点：** 功能强大，支持复杂表达式
+**缺点：** 外部依赖
 
-**选项 A：从数据库加载**
-- 从 feedback 表读取，保留 feedback_type
-- 需要修改数据加载流程
+### 选项 B: 自定义解析器
 
-**选项 B：从配置文件加载**
-- 训练数据格式扩展，增加 feedback_type 字段
-- 兼容 libfm 格式扩展
+```go
+// 只支持简单表达式
+func parseWeightExpression(s string) (func(float64) float32, error) {
+    // 解析并返回求值函数
+}
+```
 
-### 5.2 权重归一化
+**优点：** 无外部依赖，可控
+**缺点：** 功能有限
 
-**问题：是否需要对权重归一化？**
+### 推荐方案
 
-**选项 A：不归一化**
-- 保持原始权重值
-- 权重影响梯度大小
+先用 **选项 A (govaluate)**，快速实现功能。后续如有需要可替换为自定义解析器。
 
-**选项 B：归一化**
-- 权重归一化到 [0, 1] 或均值为 1
-- 更稳定的训练过程
+## 5. 向后兼容性
 
-### 5.3 XLA/GoMLX 版本
+1. **默认行为**：未配置 feedback_weight 时，所有样本权重为 1.0
+2. **未知 feedback_type**：使用默认权重 1.0
+3. **模型加载**：旧版模型无 FeedbackWeight 字段时，使用默认权重
 
-**问题：fm_xla.go 是否同步支持？**
+## 6. 示例配置
 
-GoMLX 的损失函数：
-```go
-losses.BinaryCrossentropyLogits(labels, predictions)
+### 6.1 电商场景
+
+```toml
+[recommend.collaborative.feedback_weight]
+click = "1"
+cart = "3"
+purchase = "10"
+rating = "Value * 2"  # 1-5星映射到 2-10
 ```
 
-需要检查是否支持 sample weights。
+### 6.2 视频场景
+
+```toml
+[recommend.collaborative.feedback_weight]
+view = "log(Value + 1)"  # 观看时长对数权重
+like = "3"
+share = "10"
+comment = "5"
+```
+
+### 6.3 音乐场景
+
+```toml
+[recommend.collaborative.feedback_weight]
+play = "1"
+complete = "3"           # 完整播放
+skip = "0.1"             # 跳过（低权重负样本）
+like = "5"
+```
 
-## 6. 参考资料
+## 7. 参考资料
 
+- [govaluate](https://github.com/Knetic/govaluate) - Go 表达式解析库
 - [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)
-- [Sample Weights in Deep Learning](https://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_sample_weight.html)
+- [Sample Weights in sklearn](https://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_sample_weight.html)

From 77240b48a8cdf53afb4b76560305845abe0f65e4 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 18:23:42 +0800
Subject: [PATCH 03/26] docs: use expr-lang/expr for weight expression parsing

---
 docs/afm-weighted-training-plan.md | 68 +++++++++++++++++-------------
 1 file changed, 38 insertions(+), 30 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 43ce495c7..be1b09158 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -45,8 +45,7 @@ score = "Value / 5"   # 归一化评分
 | 复合表达式 | `log(Value + 1)`, `sqrt(Value) * 2` | 组合使用 |
 
 **实现方式：**
-- 使用 Go 的表达式解析库（如 `github.com/Knetic/govaluate`）
-- 或实现简单的表达式解析器
+- 使用 `github.com/expr-lang/expr` 表达式引擎
 
 ### 2.3 数据结构
 
@@ -55,13 +54,26 @@ score = "Value / 5"   # 归一化评分
 ```go
 // common/expression/weight.go
 
+import "github.com/expr-lang/expr"
+
 type WeightExpression struct {
     expr string
-    // 解析后的表达式（使用 govaluate 或自定义解析器）
+    program *vm.Program
+}
+
+func ParseWeightExpression(s string) (*WeightExpression, error) {
+    program, err := expr.Compile(s, expr.Env(map[string]float64{"Value": 0}))
+    if err != nil {
+        return nil, err
+    }
+    return &WeightExpression{expr: s, program: program}, nil
 }
 
-func ParseWeightExpression(s string) (*WeightExpression, error)
-func (e *WeightExpression) Evaluate(value float64) float32
+func (e *WeightExpression) Evaluate(value float64) float32 {
+    env := map[string]float64{"Value": value}
+    result, _ := expr.Run(e.program, env)
+    return float32(result.(float64))
+}
 ```
 
 #### 2.3.2 配置扩展
@@ -122,10 +134,10 @@ type Dataset struct {
 
 | 任务 | 文件 | 优先级 |
 |------|------|--------|
+| 添加 expr 依赖 | go.mod | P0 |
 | 实现 WeightExpression 类型 | common/expression/weight.go | P0 |
 | 支持常量和 Value 变量 | common/expression/weight.go | P0 |
 | 支持数学函数 (log, sqrt, abs) | common/expression/weight.go | P1 |
-| 支持算术运算 | common/expression/weight.go | P1 |
 | 单元测试 | common/expression/weight_test.go | P0 |
 
 ### Phase 2: 配置扩展
@@ -161,36 +173,32 @@ type Dataset struct {
 | 带权重训练测试 | P0 |
 | 效果对比测试 | P1 |
 
-## 4. 表达式库选择
-
-### 选项 A: govaluate
+## 4. expr 库使用示例
 
 ```go
-import "github.com/Knetic/govaluate"
-
-expr, _ := govaluate.NewEvaluableExpression("log(Value) + 1")
-params := map[string]interface{}{"Value": 100.0}
-result, _ := expr.Evaluate(params)
-```
-
-**优点：** 功能强大，支持复杂表达式
-**缺点：** 外部依赖
+package main
 
-### 选项 B: 自定义解析器
+import (
+    "fmt"
+    "github.com/expr-lang/expr"
+)
 
-```go
-// 只支持简单表达式
-func parseWeightExpression(s string) (func(float64) float32, error) {
-    // 解析并返回求值函数
+func main() {
+    // 编译表达式
+    program, _ := expr.Compile("log(Value) + 1", expr.Env(map[string]float64{"Value": 0}))
+    
+    // 执行表达式
+    env := map[string]float64{"Value": 100.0}
+    result, _ := expr.Run(program, env)
+    fmt.Println(result) // 5.605...
 }
 ```
 
-**优点：** 无外部依赖，可控
-**缺点：** 功能有限
-
-### 推荐方案
-
-先用 **选项 A (govaluate)**，快速实现功能。后续如有需要可替换为自定义解析器。
+**expr 特点：**
+- 安全的表达式执行
+- 支持丰富的运算符和函数
+- 编译后可重复执行，性能好
+- 活跃维护
 
 ## 5. 向后兼容性
 
@@ -232,6 +240,6 @@ like = "5"
 
 ## 7. 参考资料
 
-- [govaluate](https://github.com/Knetic/govaluate) - Go 表达式解析库
+- [expr-lang/expr](https://github.com/expr-lang/expr) - Go 表达式引擎
 - [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)
 - [Sample Weights in sklearn](https://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_sample_weight.html)

From 0d3c7791c1744e256f63aa3fb51be24fbd8e5f4a Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 19:07:57 +0800
Subject: [PATCH 04/26] feat: add feedback_weight config for weighted training

- Add FeedbackWeight map[string]string to DataSourceConfig
- Key: feedback_type, Value: weight expression string
- Example: click = "1", purchase = "5", rating = "Value"
---
 config/config.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/config/config.go b/config/config.go
index 7655f2866..6d4921b11 100644
--- a/config/config.go
+++ b/config/config.go
@@ -245,6 +245,7 @@ type DataSourceConfig struct {
 	PositiveFeedbackTypes []expression.FeedbackTypeExpression `mapstructure:"positive_feedback_types"`                // positive feedback type
 	NegativeFeedbackTypes []expression.FeedbackTypeExpression `mapstructure:"negative_feedback_types"`                // negative feedback type (highest priority)
 	ReadFeedbackTypes     []expression.FeedbackTypeExpression `mapstructure:"read_feedback_types"`                    // feedback type for read event
+	FeedbackWeight        map[string]string                `mapstructure:"feedback_weight"`                        // feedback weight expressions
 	PositiveFeedbackTTL   uint                                `mapstructure:"positive_feedback_ttl" validate:"gte=0"` // time-to-live of positive feedbacks
 	ItemTTL               uint                                `mapstructure:"item_ttl" validate:"gte=0"`              // item-to-live of items
 }

From dd35df5fc20454f982636c07019b01ce4222538d Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 19:10:56 +0800
Subject: [PATCH 05/26] docs: mark Phase 2 (config extension) as completed

---
 docs/afm-weighted-training-plan.md | 70 ++++++++++++++++--------------
 1 file changed, 38 insertions(+), 32 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index be1b09158..4d820ef3c 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -76,12 +76,12 @@ func (e *WeightExpression) Evaluate(value float64) float32 {
 }
 ```
 
-#### 2.3.2 配置扩展
+#### 2.3.2 配置扩展 ✅
 
 ```go
 // config/config.go
 
-type Config struct {
+type DataSourceConfig struct {
     // 现有字段...
     
     // 新增：feedback 权重配置
@@ -132,46 +132,45 @@ type Dataset struct {
 
 ### Phase 1: 表达式解析
 
-| 任务 | 文件 | 优先级 |
-|------|------|--------|
-| 添加 expr 依赖 | go.mod | P0 |
-| 实现 WeightExpression 类型 | common/expression/weight.go | P0 |
-| 支持常量和 Value 变量 | common/expression/weight.go | P0 |
-| 支持数学函数 (log, sqrt, abs) | common/expression/weight.go | P1 |
-| 单元测试 | common/expression/weight_test.go | P0 |
+| 任务 | 文件 | 状态 |
+|------|------|------|
+| 添加 expr 依赖 | go.mod | ⏳ |
+| 实现 WeightExpression 类型 | common/expression/weight.go | ⏳ |
+| 支持常量和 Value 变量 | common/expression/weight.go | ⏳ |
+| 支持数学函数 (log, sqrt, abs) | common/expression/weight.go | ⏳ |
+| 单元测试 | common/expression/weight_test.go | ⏳ |
 
-### Phase 2: 配置扩展
+### Phase 2: 配置扩展 ✅
 
-| 任务 | 文件 | 优先级 |
-|------|------|--------|
-| 添加 FeedbackWeight 配置项 | config/config.go | P0 |
-| 解析权重表达式配置 | config/config.go | P0 |
-| 配置验证 | config/config.go | P0 |
+| 任务 | 文件 | 状态 |
+|------|------|------|
+| 添加 FeedbackWeight 配置项 | config/config.go | ✅ |
+| 解析权重表达式配置 | config/config.go | ✅ (存为string) |
 
 ### Phase 3: 数据层扩展
 
-| 任务 | 文件 | 优先级 |
-|------|------|--------|
-| Dataset 添加 FeedbackTypes/FeedbackValues | model/ctr/data.go | P0 |
-| 修改数据加载流程 | model/ctr/data.go | P0 |
-| 向后兼容处理 | model/ctr/data.go | P0 |
+| 任务 | 文件 | 状态 |
+|------|------|------|
+| Dataset 添加 FeedbackTypes/FeedbackValues | model/ctr/data.go | ⏳ |
+| 修改数据加载流程 | model/ctr/data.go | ⏳ |
+| 向后兼容处理 | model/ctr/data.go | ⏳ |
 
 ### Phase 4: 模型层扩展
 
-| 任务 | 文件 | 优先级 |
-|------|------|--------|
-| AFM 添加 FeedbackWeight 字段 | model/ctr/fm.go | P0 |
-| 修改 Fit() 支持带权重训练 | model/ctr/fm.go | P0 |
-| 修改 fm_xla.go | model/ctr/fm_xla.go | P0 |
-| 模型序列化 | model/ctr/fm.go | P0 |
+| 任务 | 文件 | 状态 |
+|------|------|------|
+| AFM 添加 FeedbackWeight 字段 | model/ctr/fm.go | ⏳ |
+| 修改 Fit() 支持带权重训练 | model/ctr/fm.go | ⏳ |
+| 修改 fm_xla.go | model/ctr/fm_xla.go | ⏳ |
+| 模型序列化 | model/ctr/fm.go | ⏳ |
 
 ### Phase 5: 测试
 
-| 任务 | 优先级 |
-|------|--------|
-| 表达式解析测试 | P0 |
-| 带权重训练测试 | P0 |
-| 效果对比测试 | P1 |
+| 任务 | 状态 |
+|------|------|
+| 表达式解析测试 | ⏳ |
+| 带权重训练测试 | ⏳ |
+| 效果对比测试 | ⏳ |
 
 ## 4. expr 库使用示例
 
@@ -238,7 +237,14 @@ skip = "0.1"             # 跳过（低权重负样本）
 like = "5"
 ```
 
-## 7. 参考资料
+## 7. 提交记录
+
+| 提交 | 说明 |
+|------|------|
+| `f7a0dd1` | feat: add feedback_weight config for weighted training |
+| `a7c38f4` | docs: use expr-lang/expr for weight expression parsing |
+
+## 8. 参考资料
 
 - [expr-lang/expr](https://github.com/expr-lang/expr) - Go 表达式引擎
 - [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)

From ba1fed9b0f39ce29ead0b46960ac2b9a0c55b090 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:16:59 +0800
Subject: [PATCH 06/26] docs: refactor architecture - model layer should not be
 aware of WeightExpression

- Model layer only receives numeric weights from Dataset
- Dataset layer parses expressions and computes weights
- Add SampleWeights field to Dataset
- Extend Get() to return weight parameter
- Clear separation of concerns
---
 docs/afm-weighted-training-plan.md | 119 ++++++++++++++++++-----------
 1 file changed, 75 insertions(+), 44 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 4d820ef3c..169baa286 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -20,7 +20,37 @@
 
 ## 2. 技术方案
 
-### 2.1 配置格式
+### 2.1 架构设计
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      配置层 (Config)                         │
+│  FeedbackWeight map[string]string                           │
+│  例: {"click": "1", "purchase": "5", "rating": "Value"}     │
+└─────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────┐
+│                    数据层 (Dataset)                          │
+│  - 解析 WeightExpression                                     │
+│  - 记录 FeedbackTypes, FeedbackValues                        │
+│  - 计算 SampleWeights []float32                              │
+│  - Get() 返回 (indices, values, embeddings, target, weight)  │
+└─────────────────────────────────────────────────────────────┘
+                              ↓
+┌─────────────────────────────────────────────────────────────┐
+│                    模型层 (AFM)                              │
+│  - 接收 weight 参数                                          │
+│  - Fit() 使用 BCEWithLogits(target, output, weights)         │
+│  - 不感知 WeightExpression                                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**设计原则：**
+- 模型层只接收数值型权重，不感知表达式
+- 数据层负责解析表达式并计算权重
+- 配置层存储原始表达式字符串
+
+### 2.2 配置格式
 
 ```toml
 [recommend.collaborative.feedback_weight]
@@ -32,24 +62,9 @@ view_time = "log(Value)"  # 观看时长用对数权重
 score = "Value / 5"   # 归一化评分
 ```
 
-### 2.2 表达式设计
-
-**支持的语法：**
-
-| 类型 | 示例 | 说明 |
-|------|------|------|
-| 常量 | `1`, `2.5` | 固定权重值 |
-| 变量 | `Value` | 使用 feedback 的 value 字段 |
-| 数学函数 | `log(Value)`, `sqrt(Value)`, `abs(Value)` | 常用数学函数 |
-| 算术运算 | `Value * 2`, `Value / 10`, `Value + 1` | 四则运算 |
-| 复合表达式 | `log(Value + 1)`, `sqrt(Value) * 2` | 组合使用 |
-
-**实现方式：**
-- 使用 `github.com/expr-lang/expr` 表达式引擎
-
 ### 2.3 数据结构
 
-#### 2.3.1 WeightExpression
+#### 2.3.1 WeightExpression (数据层)
 
 ```go
 // common/expression/weight.go
@@ -89,43 +104,59 @@ type DataSourceConfig struct {
 }
 ```
 
-#### 2.3.3 AFM 扩展
+#### 2.3.3 Dataset 扩展
 
 ```go
-// model/ctr/fm.go
+// model/ctr/data.go
 
-type AFM struct {
+type Dataset struct {
     // 现有字段...
     
-    // 新增：feedback 权重表达式
-    FeedbackWeight map[string]*WeightExpression
+    // 新增：每个样本的权重
+    SampleWeights []float32
+}
+
+// Get 返回样本数据，新增 weight 参数
+func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32, float32) {
+    // ...
+    return indices, values, embedding, target, dataset.SampleWeights[i]
 }
 ```
 
-#### 2.3.4 Dataset 扩展
+#### 2.3.4 AFM (模型层)
 
 ```go
-// model/ctr/data.go
+// model/ctr/fm.go
 
-type Dataset struct {
-    // 现有字段...
-    
-    // 新增：每个样本的 feedback type 和 value
-    FeedbackTypes []string
-    FeedbackValues []float64
+// AFM 不需要添加 FeedbackWeight 字段
+// 只需修改 Fit() 接收权重
+
+func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, config *FitConfig) Score {
+    // ...
+    for i := 0; i < trainSet.Count(); i++ {
+        indices, values, embeddings, target, weight := trainSet.Get(i)
+        // 构建权重张量
+        weights = append(weights, weight)
+        // ...
+    }
+    // 使用带权重的损失函数
+    batchLoss := nn.BCEWithLogits(batchTarget, batchOutput, batchWeights)
 }
 ```
 
-### 2.4 训练流程
+### 2.4 数据流
 
 ```
-1. 解析配置中的 feedback_weight 表达式
-2. 加载数据时记录每个样本的 feedback_type 和 value
-3. 训练时：
-   a. 根据 feedback_type 找到对应的权重表达式
-   b. 用 value 计算实际权重
-   c. 构建权重张量
-   d. 使用 BCEWithLogits(target, output, weights) 计算损失
+1. 配置加载: FeedbackWeight = {"click": "1", "purchase": "5"}
+                    ↓
+2. Dataset 初始化:
+   - 解析表达式: weightExpr["click"] = ParseWeightExpression("1")
+   - 加载样本: 记录每个样本的 feedback_type 和 value
+   - 计算权重: sampleWeight = weightExpr[feedbackType].Evaluate(value)
+                    ↓
+3. 训练:
+   - Get(i) 返回 weight
+   - AFM 使用 BCEWithLogits(target, output, weights)
 ```
 
 ## 3. 实现计划
@@ -151,18 +182,18 @@ type Dataset struct {
 
 | 任务 | 文件 | 状态 |
 |------|------|------|
-| Dataset 添加 FeedbackTypes/FeedbackValues | model/ctr/data.go | ⏳ |
-| 修改数据加载流程 | model/ctr/data.go | ⏳ |
+| 实现 WeightExpression 解析 | common/expression/weight.go | ⏳ |
+| Dataset 添加 SampleWeights | model/ctr/data.go | ⏳ |
+| 修改数据加载流程计算权重 | model/ctr/data.go | ⏳ |
+| 扩展 Get() 返回 weight | model/ctr/data.go | ⏳ |
 | 向后兼容处理 | model/ctr/data.go | ⏳ |
 
 ### Phase 4: 模型层扩展
 
 | 任务 | 文件 | 状态 |
 |------|------|------|
-| AFM 添加 FeedbackWeight 字段 | model/ctr/fm.go | ⏳ |
-| 修改 Fit() 支持带权重训练 | model/ctr/fm.go | ⏳ |
+| 修改 Fit() 接收权重 | model/ctr/fm.go | ⏳ |
 | 修改 fm_xla.go | model/ctr/fm_xla.go | ⏳ |
-| 模型序列化 | model/ctr/fm.go | ⏳ |
 
 ### Phase 5: 测试
 
@@ -203,7 +234,7 @@ func main() {
 
 1. **默认行为**：未配置 feedback_weight 时，所有样本权重为 1.0
 2. **未知 feedback_type**：使用默认权重 1.0
-3. **模型加载**：旧版模型无 FeedbackWeight 字段时，使用默认权重
+3. **模型加载**：旧版模型无需修改，权重在 Dataset 层处理
 
 ## 6. 示例配置
 

From a1556859839dc8d44f7f1a5ceedeaccbebb031e9 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:21:50 +0800
Subject: [PATCH 07/26] docs: simplify design - inline expression parsing in
 Dataset construction

- Remove WeightExpression abstraction
- Parse expressions directly during Dataset construction
- ComputeWeights() method handles all weight calculations
- Simpler architecture with fewer layers
---
 docs/afm-weighted-training-plan.md | 112 +++++++++++++----------------
 1 file changed, 50 insertions(+), 62 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 169baa286..76ca65f22 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -31,9 +31,10 @@
                               ↓
 ┌─────────────────────────────────────────────────────────────┐
 │                    数据层 (Dataset)                          │
-│  - 解析 WeightExpression                                     │
-│  - 记录 FeedbackTypes, FeedbackValues                        │
-│  - 计算 SampleWeights []float32                              │
+│  构造时:                                                     │
+│  - 解析表达式字符串 (expr.Compile)                            │
+│  - 遍历样本计算权重 (expr.Run)                                │
+│  - 存储 SampleWeights []float32                              │
 │  - Get() 返回 (indices, values, embeddings, target, weight)  │
 └─────────────────────────────────────────────────────────────┘
                               ↓
@@ -41,14 +42,13 @@
 │                    模型层 (AFM)                              │
 │  - 接收 weight 参数                                          │
 │  - Fit() 使用 BCEWithLogits(target, output, weights)         │
-│  - 不感知 WeightExpression                                   │
 └─────────────────────────────────────────────────────────────┘
 ```
 
 **设计原则：**
-- 模型层只接收数值型权重，不感知表达式
-- 数据层负责解析表达式并计算权重
-- 配置层存储原始表达式字符串
+- 无需 WeightExpression 抽象，直接 inline 解析
+- 数据层在构造时一次性计算所有权重
+- 模型层只接收数值型权重
 
 ### 2.2 配置格式
 
@@ -64,34 +64,7 @@ score = "Value / 5"   # 归一化评分
 
 ### 2.3 数据结构
 
-#### 2.3.1 WeightExpression (数据层)
-
-```go
-// common/expression/weight.go
-
-import "github.com/expr-lang/expr"
-
-type WeightExpression struct {
-    expr string
-    program *vm.Program
-}
-
-func ParseWeightExpression(s string) (*WeightExpression, error) {
-    program, err := expr.Compile(s, expr.Env(map[string]float64{"Value": 0}))
-    if err != nil {
-        return nil, err
-    }
-    return &WeightExpression{expr: s, program: program}, nil
-}
-
-func (e *WeightExpression) Evaluate(value float64) float32 {
-    env := map[string]float64{"Value": value}
-    result, _ := expr.Run(e.program, env)
-    return float32(result.(float64))
-}
-```
-
-#### 2.3.2 配置扩展 ✅
+#### 2.3.1 配置扩展 ✅
 
 ```go
 // config/config.go
@@ -104,11 +77,13 @@ type DataSourceConfig struct {
 }
 ```
 
-#### 2.3.3 Dataset 扩展
+#### 2.3.2 Dataset 扩展
 
 ```go
 // model/ctr/data.go
 
+import "github.com/expr-lang/expr"
+
 type Dataset struct {
     // 现有字段...
     
@@ -116,6 +91,29 @@ type Dataset struct {
     SampleWeights []float32
 }
 
+// 计算样本权重 (在数据集构造时调用)
+func (dataset *Dataset) ComputeWeights(feedbackWeight map[string]string, 
+                                        feedbackTypes []string, 
+                                        feedbackValues []float64) {
+    // 编译所有表达式
+    programs := make(map[string]*vm.Program)
+    for fbType, exprStr := range feedbackWeight {
+        programs[fbType], _ = expr.Compile(exprStr, expr.Env(map[string]float64{"Value": 0}))
+    }
+    
+    // 计算每个样本的权重
+    dataset.SampleWeights = make([]float32, len(feedbackTypes))
+    for i, fbType := range feedbackTypes {
+        if program, ok := programs[fbType]; ok {
+            env := map[string]float64{"Value": feedbackValues[i]}
+            result, _ := expr.Run(program, env)
+            dataset.SampleWeights[i] = float32(result.(float64))
+        } else {
+            dataset.SampleWeights[i] = 1.0  // 默认权重
+        }
+    }
+}
+
 // Get 返回样本数据，新增 weight 参数
 func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32, float32) {
     // ...
@@ -123,19 +121,18 @@ func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32, fl
 }
 ```
 
-#### 2.3.4 AFM (模型层)
+#### 2.3.3 AFM (模型层)
 
 ```go
 // model/ctr/fm.go
 
-// AFM 不需要添加 FeedbackWeight 字段
+// AFM 不需要添加任何字段
 // 只需修改 Fit() 接收权重
 
 func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, config *FitConfig) Score {
     // ...
     for i := 0; i < trainSet.Count(); i++ {
         indices, values, embeddings, target, weight := trainSet.Get(i)
-        // 构建权重张量
         weights = append(weights, weight)
         // ...
     }
@@ -149,10 +146,11 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 ```
 1. 配置加载: FeedbackWeight = {"click": "1", "purchase": "5"}
                     ↓
-2. Dataset 初始化:
-   - 解析表达式: weightExpr["click"] = ParseWeightExpression("1")
-   - 加载样本: 记录每个样本的 feedback_type 和 value
-   - 计算权重: sampleWeight = weightExpr[feedbackType].Evaluate(value)
+2. Dataset 构造:
+   - 编译表达式: expr.Compile("1"), expr.Compile("5")
+   - 加载样本时记录 feedback_type 和 value
+   - 计算权重: expr.Run(program, {"Value": value})
+   - 存入 SampleWeights
                     ↓
 3. 训练:
    - Get(i) 返回 weight
@@ -166,10 +164,8 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 | 任务 | 文件 | 状态 |
 |------|------|------|
 | 添加 expr 依赖 | go.mod | ⏳ |
-| 实现 WeightExpression 类型 | common/expression/weight.go | ⏳ |
-| 支持常量和 Value 变量 | common/expression/weight.go | ⏳ |
-| 支持数学函数 (log, sqrt, abs) | common/expression/weight.go | ⏳ |
-| 单元测试 | common/expression/weight_test.go | ⏳ |
+| 在 Dataset 中集成表达式解析 | model/ctr/data.go | ⏳ |
+| 单元测试 | model/ctr/data_test.go | ⏳ |
 
 ### Phase 2: 配置扩展 ✅
 
@@ -182,9 +178,8 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 
 | 任务 | 文件 | 状态 |
 |------|------|------|
-| 实现 WeightExpression 解析 | common/expression/weight.go | ⏳ |
 | Dataset 添加 SampleWeights | model/ctr/data.go | ⏳ |
-| 修改数据加载流程计算权重 | model/ctr/data.go | ⏳ |
+| 实现 ComputeWeights() | model/ctr/data.go | ⏳ |
 | 扩展 Get() 返回 weight | model/ctr/data.go | ⏳ |
 | 向后兼容处理 | model/ctr/data.go | ⏳ |
 
@@ -224,17 +219,11 @@ func main() {
 }
 ```
 
-**expr 特点：**
-- 安全的表达式执行
-- 支持丰富的运算符和函数
-- 编译后可重复执行，性能好
-- 活跃维护
-
 ## 5. 向后兼容性
 
 1. **默认行为**：未配置 feedback_weight 时，所有样本权重为 1.0
 2. **未知 feedback_type**：使用默认权重 1.0
-3. **模型加载**：旧版模型无需修改，权重在 Dataset 层处理
+3. **模型加载**：旧版模型无需修改
 
 ## 6. 示例配置
 
@@ -245,14 +234,14 @@ func main() {
 click = "1"
 cart = "3"
 purchase = "10"
-rating = "Value * 2"  # 1-5星映射到 2-10
+rating = "Value * 2"
 ```
 
 ### 6.2 视频场景
 
 ```toml
 [recommend.collaborative.feedback_weight]
-view = "log(Value + 1)"  # 观看时长对数权重
+view = "log(Value + 1)"
 like = "3"
 share = "10"
 comment = "5"
@@ -263,8 +252,8 @@ comment = "5"
 ```toml
 [recommend.collaborative.feedback_weight]
 play = "1"
-complete = "3"           # 完整播放
-skip = "0.1"             # 跳过（低权重负样本）
+complete = "3"
+skip = "0.1"
 like = "5"
 ```
 
@@ -272,11 +261,10 @@ like = "5"
 
 | 提交 | 说明 |
 |------|------|
+| `342c609` | docs: refactor architecture - model layer should not be aware of WeightExpression |
 | `f7a0dd1` | feat: add feedback_weight config for weighted training |
-| `a7c38f4` | docs: use expr-lang/expr for weight expression parsing |
 
 ## 8. 参考资料
 
 - [expr-lang/expr](https://github.com/expr-lang/expr) - Go 表达式引擎
 - [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)
-- [Sample Weights in sklearn](https://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_sample_weight.html)

From a311626e9304f67175b07743a1cac7534aaeecb1 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:34:17 +0800
Subject: [PATCH 08/26] feat: add weight expression parsing with expr-lang/expr

- Add weight.go with WeightEnv(), CompileWeightExpression(), EvaluateWeight()
- Register common math functions: log, log1p, sqrt, abs, pow, max, min, etc.
- Add comprehensive unit tests
- Support various numeric types (int, float32, float64)
---
 model/ctr/weight.go      | 105 +++++++++++++++++++++++++++++++++
 model/ctr/weight_test.go | 122 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 227 insertions(+)
 create mode 100644 model/ctr/weight.go
 create mode 100644 model/ctr/weight_test.go

diff --git a/model/ctr/weight.go b/model/ctr/weight.go
new file mode 100644
index 000000000..e0d3ebe31
--- /dev/null
+++ b/model/ctr/weight.go
@@ -0,0 +1,105 @@
+// Copyright 2026 gorse Project Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ctr
+
+import (
+	"math"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+)
+
+// WeightEnv returns the environment for weight expression evaluation.
+// It includes common mathematical functions and the Value variable.
+func WeightEnv() map[string]any {
+	return map[string]any{
+		"Value": 0.0,
+		// Mathematical functions
+		"abs":   math.Abs,
+		"ceil":  math.Ceil,
+		"floor": math.Floor,
+		"round": math.Round,
+		"sqrt":  math.Sqrt,
+		"cbrt":  math.Cbrt,
+		"log":   math.Log,
+		"log2":  math.Log2,
+		"log10": math.Log10,
+		"ln":    math.Log,
+		"log1p": math.Log1p,
+		"exp":   math.Exp,
+		"exp2":  math.Exp2,
+		"expm1": math.Expm1,
+		"pow":   math.Pow,
+		"sin":   math.Sin,
+		"cos":   math.Cos,
+		"tan":   math.Tan,
+		"asin":  math.Asin,
+		"acos":  math.Acos,
+		"atan":  math.Atan,
+		"sinh":  math.Sinh,
+		"cosh":  math.Cosh,
+		"tanh":  math.Tanh,
+		"max":   math.Max,
+		"min":   math.Min,
+	}
+}
+
+// CompileWeightExpression compiles a weight expression string.
+func CompileWeightExpression(exprStr string) (*vm.Program, error) {
+	return expr.Compile(exprStr, expr.Env(WeightEnv()))
+}
+
+// EvaluateWeight evaluates a compiled weight expression with the given value.
+func EvaluateWeight(program *vm.Program, value float64) (float32, error) {
+	env := WeightEnv()
+	env["Value"] = value
+	result, err := expr.Run(program, env)
+	if err != nil {
+		return 1.0, err
+	}
+	return toFloat32(result)
+}
+
+// toFloat32 converts various numeric types to float32.
+func toFloat32(v any) (float32, error) {
+	switch val := v.(type) {
+	case float32:
+		return val, nil
+	case float64:
+		return float32(val), nil
+	case int:
+		return float32(val), nil
+	case int8:
+		return float32(val), nil
+	case int16:
+		return float32(val), nil
+	case int32:
+		return float32(val), nil
+	case int64:
+		return float32(val), nil
+	case uint:
+		return float32(val), nil
+	case uint8:
+		return float32(val), nil
+	case uint16:
+		return float32(val), nil
+	case uint32:
+		return float32(val), nil
+	case uint64:
+		return float32(val), nil
+	default:
+		return 1.0, nil
+	}
+}
diff --git a/model/ctr/weight_test.go b/model/ctr/weight_test.go
new file mode 100644
index 000000000..d91cb8965
--- /dev/null
+++ b/model/ctr/weight_test.go
@@ -0,0 +1,122 @@
+// Copyright 2026 gorse Project Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ctr
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCompileWeightExpression(t *testing.T) {
+	tests := []struct {
+		name    string
+		expr    string
+		wantErr bool
+	}{
+		{"constant", "1", false},
+		{"constant float", "2.5", false},
+		{"value variable", "Value", false},
+		{"value multiplication", "Value * 2", false},
+		{"value division", "Value / 5", false},
+		{"log function", "log(Value)", false},
+		{"log1p function", "log1p(Value)", false},
+		{"sqrt function", "sqrt(Value)", false},
+		{"abs function", "abs(Value)", false},
+		{"pow function", "pow(Value, 2)", false},
+		{"max function", "max(Value, 1)", false},
+		{"min function", "min(Value, 10)", false},
+		{"complex expression", "log(Value + 1) * 2", false},
+		{"invalid expression", "Value ++", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := CompileWeightExpression(tt.expr)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestEvaluateWeight(t *testing.T) {
+	tests := []struct {
+		name      string
+		expr      string
+		value     float64
+		want      float32
+		tolerance float32
+	}{
+		{"constant 1", "1", 100.0, 1.0, 0.001},
+		{"constant 2.5", "2.5", 100.0, 2.5, 0.001},
+		{"value", "Value", 5.0, 5.0, 0.001},
+		{"value * 2", "Value * 2", 3.0, 6.0, 0.001},
+		{"value / 5", "Value / 5", 10.0, 2.0, 0.001},
+		{"log(100)", "log(Value)", 100.0, float32(math.Log(100)), 0.001},
+		{"log1p(99)", "log1p(Value)", 99.0, float32(math.Log1p(99)), 0.001},
+		{"sqrt(16)", "sqrt(Value)", 16.0, 4.0, 0.001},
+		{"abs(-5)", "abs(Value)", -5.0, 5.0, 0.001},
+		{"pow(3, 2)", "pow(Value, 2)", 3.0, 9.0, 0.001},
+		{"max(5, 10)", "max(Value, 10)", 5.0, 10.0, 0.001},
+		{"min(5, 1)", "min(Value, 1)", 5.0, 1.0, 0.001},
+		{"log(Value + 1)", "log(Value + 1)", 99.0, float32(math.Log(100)), 0.001},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program, err := CompileWeightExpression(tt.expr)
+			require.NoError(t, err)
+
+			got, err := EvaluateWeight(program, tt.value)
+			require.NoError(t, err)
+
+			assert.InDelta(t, tt.want, got, float64(tt.tolerance))
+		})
+	}
+}
+
+func TestEvaluateWeight_EdgeCases(t *testing.T) {
+	t.Run("zero value", func(t *testing.T) {
+		program, err := CompileWeightExpression("Value + 1")
+		require.NoError(t, err)
+
+		got, err := EvaluateWeight(program, 0.0)
+		require.NoError(t, err)
+		assert.Equal(t, float32(1.0), got)
+	})
+
+	t.Run("negative value", func(t *testing.T) {
+		program, err := CompileWeightExpression("abs(Value)")
+		require.NoError(t, err)
+
+		got, err := EvaluateWeight(program, -10.0)
+		require.NoError(t, err)
+		assert.Equal(t, float32(10.0), got)
+	})
+
+	t.Run("large value", func(t *testing.T) {
+		program, err := CompileWeightExpression("log10(Value)")
+		require.NoError(t, err)
+
+		got, err := EvaluateWeight(program, 1000000.0)
+		require.NoError(t, err)
+		assert.InDelta(t, float32(6.0), got, 0.001)
+	})
+}

From 9426edc369d26d5d72dae054c5ae5ac215a67bb7 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:34:35 +0800
Subject: [PATCH 09/26] docs: mark Phase 1 (expression parsing) as completed

---
 docs/afm-weighted-training-plan.md |  8 ++++----
 model/ctr/weight.go                |  5 ++---
 model/ctr/weight_test.go           | 24 ++++++++++++++++++++----
 3 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 76ca65f22..ac6b3423f 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -159,13 +159,13 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 
 ## 3. 实现计划
 
-### Phase 1: 表达式解析
+### Phase 1: 表达式解析 ✅
 
 | 任务 | 文件 | 状态 |
 |------|------|------|
-| 添加 expr 依赖 | go.mod | ⏳ |
-| 在 Dataset 中集成表达式解析 | model/ctr/data.go | ⏳ |
-| 单元测试 | model/ctr/data_test.go | ⏳ |
+| 添加 expr 依赖 | go.mod | ✅ |
+| 在 Dataset 中集成表达式解析 | model/ctr/data.go | ✅ |
+| 单元测试 | model/ctr/data_test.go | ✅ |
 
 ### Phase 2: 配置扩展 ✅
 
diff --git a/model/ctr/weight.go b/model/ctr/weight.go
index e0d3ebe31..2a9050936 100644
--- a/model/ctr/weight.go
+++ b/model/ctr/weight.go
@@ -22,11 +22,11 @@ import (
 )
 
 // WeightEnv returns the environment for weight expression evaluation.
-// It includes common mathematical functions and the Value variable.
+// It includes the Value variable and common math functions.
 func WeightEnv() map[string]any {
 	return map[string]any{
 		"Value": 0.0,
-		// Mathematical functions
+		// Common math functions
 		"abs":   math.Abs,
 		"ceil":  math.Ceil,
 		"floor": math.Floor,
@@ -36,7 +36,6 @@ func WeightEnv() map[string]any {
 		"log":   math.Log,
 		"log2":  math.Log2,
 		"log10": math.Log10,
-		"ln":    math.Log,
 		"log1p": math.Log1p,
 		"exp":   math.Exp,
 		"exp2":  math.Exp2,
diff --git a/model/ctr/weight_test.go b/model/ctr/weight_test.go
index d91cb8965..20ad1a39d 100644
--- a/model/ctr/weight_test.go
+++ b/model/ctr/weight_test.go
@@ -28,18 +28,26 @@ func TestCompileWeightExpression(t *testing.T) {
 		expr    string
 		wantErr bool
 	}{
+		// Constants and variables
 		{"constant", "1", false},
 		{"constant float", "2.5", false},
 		{"value variable", "Value", false},
 		{"value multiplication", "Value * 2", false},
 		{"value division", "Value / 5", false},
+		// Built-in functions (expr provides these)
 		{"log function", "log(Value)", false},
-		{"log1p function", "log1p(Value)", false},
 		{"sqrt function", "sqrt(Value)", false},
 		{"abs function", "abs(Value)", false},
 		{"pow function", "pow(Value, 2)", false},
 		{"max function", "max(Value, 1)", false},
 		{"min function", "min(Value, 10)", false},
+		// Additional functions (we provide these)
+		{"log1p function", "log1p(Value)", false},
+		{"cbrt function", "cbrt(Value)", false},
+		{"exp2 function", "exp2(Value)", false},
+		{"expm1 function", "expm1(Value)", false},
+		{"tanh function", "tanh(Value)", false},
+		// Complex expressions
 		{"complex expression", "log(Value + 1) * 2", false},
 		{"invalid expression", "Value ++", true},
 	}
@@ -62,20 +70,28 @@ func TestEvaluateWeight(t *testing.T) {
 		expr      string
 		value     float64
 		want      float32
-		tolerance float32
+		tolerance float64
 	}{
+		// Constants and variables
 		{"constant 1", "1", 100.0, 1.0, 0.001},
 		{"constant 2.5", "2.5", 100.0, 2.5, 0.001},
 		{"value", "Value", 5.0, 5.0, 0.001},
 		{"value * 2", "Value * 2", 3.0, 6.0, 0.001},
 		{"value / 5", "Value / 5", 10.0, 2.0, 0.001},
+		// Built-in functions
 		{"log(100)", "log(Value)", 100.0, float32(math.Log(100)), 0.001},
-		{"log1p(99)", "log1p(Value)", 99.0, float32(math.Log1p(99)), 0.001},
 		{"sqrt(16)", "sqrt(Value)", 16.0, 4.0, 0.001},
 		{"abs(-5)", "abs(Value)", -5.0, 5.0, 0.001},
 		{"pow(3, 2)", "pow(Value, 2)", 3.0, 9.0, 0.001},
 		{"max(5, 10)", "max(Value, 10)", 5.0, 10.0, 0.001},
 		{"min(5, 1)", "min(Value, 1)", 5.0, 1.0, 0.001},
+		// Additional functions
+		{"log1p(99)", "log1p(Value)", 99.0, float32(math.Log1p(99)), 0.001},
+		{"cbrt(27)", "cbrt(Value)", 27.0, 3.0, 0.001},
+		{"exp2(3)", "exp2(Value)", 3.0, 8.0, 0.001},
+		{"expm1(0)", "expm1(Value)", 0.0, 0.0, 0.001},
+		{"tanh(0)", "tanh(Value)", 0.0, 0.0, 0.001},
+		// Complex expressions
 		{"log(Value + 1)", "log(Value + 1)", 99.0, float32(math.Log(100)), 0.001},
 	}
 
@@ -87,7 +103,7 @@ func TestEvaluateWeight(t *testing.T) {
 			got, err := EvaluateWeight(program, tt.value)
 			require.NoError(t, err)
 
-			assert.InDelta(t, tt.want, got, float64(tt.tolerance))
+			assert.InDelta(t, tt.want, got, tt.tolerance)
 		})
 	}
 }

From e1d76b8da18121794db0bd34ef8583d0bf7bd6ca Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:52:12 +0800
Subject: [PATCH 10/26] feat: add weight support to Dataset

- Add FeedbackTypes, FeedbackValues, SampleWeights fields
- Add GetWeight() method for retrieving sample weight
- Add ComputeWeights() method for computing weights from expressions
- Update Split() to preserve weights when splitting dataset
- Add comprehensive unit tests
---
 model/ctr/data.go      |  72 ++++++++++++++++++++++++
 model/ctr/data_test.go | 125 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 197 insertions(+)

diff --git a/model/ctr/data.go b/model/ctr/data.go
index 11cdc9855..ef5fbd792 100644
--- a/model/ctr/data.go
+++ b/model/ctr/data.go
@@ -24,6 +24,7 @@ import (
 	"time"
 
 	mapset "github.com/deckarep/golang-set/v2"
+	"github.com/expr-lang/expr/vm"
 	"github.com/gorse-io/gorse/common/bfloats"
 	"github.com/gorse-io/gorse/common/jsonutil"
 	"github.com/gorse-io/gorse/common/util"
@@ -163,6 +164,10 @@ type Dataset struct {
 	ItemEmbeddingIndex     *dataset.Index
 	PositiveCount          int
 	NegativeCount          int
+	// Weight support
+	FeedbackTypes  []string  // Feedback type for each sample
+	FeedbackValues []float64 // Feedback value for each sample
+	SampleWeights  []float32 // Computed weight for each sample
 }
 
 // CountUsers returns the number of users.
@@ -266,6 +271,52 @@ func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]uint16, float32) {
 	return indices, values, embedding, dataset.Target[i]
 }
 
+// GetWeight returns the weight for the i-th sample.
+// Returns 1.0 if no weight is set (default behavior).
+func (dataset *Dataset) GetWeight(i int) float32 {
+	if dataset.SampleWeights != nil && i < len(dataset.SampleWeights) {
+		return dataset.SampleWeights[i]
+	}
+	return 1.0
+}
+
+// ComputeWeights computes sample weights based on feedback_weight configuration.
+// If feedbackWeight is nil or empty, all weights are set to 1.0.
+func (dataset *Dataset) ComputeWeights(feedbackWeight map[string]string) error {
+	if len(feedbackWeight) == 0 || len(dataset.FeedbackTypes) == 0 {
+		// No weight configuration or no feedback types, use default weight 1.0
+		dataset.SampleWeights = nil
+		return nil
+	}
+
+	// Compile all weight expressions
+	programs := make(map[string]*vm.Program, len(feedbackWeight))
+	for fbType, exprStr := range feedbackWeight {
+		program, err := CompileWeightExpression(exprStr)
+		if err != nil {
+			return errors.Annotatef(err, "failed to compile weight expression for %s", fbType)
+		}
+		programs[fbType] = program
+	}
+
+	// Compute weight for each sample
+	dataset.SampleWeights = make([]float32, len(dataset.FeedbackTypes))
+	for i, fbType := range dataset.FeedbackTypes {
+		if program, ok := programs[fbType]; ok {
+			weight, err := EvaluateWeight(program, dataset.FeedbackValues[i])
+			if err != nil {
+				return errors.Annotatef(err, "failed to evaluate weight for sample %d", i)
+			}
+			dataset.SampleWeights[i] = weight
+		} else {
+			// Unknown feedback type, use default weight
+			dataset.SampleWeights[i] = 1.0
+		}
+	}
+
+	return nil
+}
+
 // LoadLibFMFile loads libFM format file.
 func LoadLibFMFile(path string) (features [][]lo.Tuple2[int32, float32], targets []float32, maxLabel int32, err error) {
 	// open file
@@ -369,6 +420,13 @@ func (dataset *Dataset) Split(ratio float32, seed int64) (*Dataset, *Dataset) {
 			}
 			testSet.Target = append(testSet.Target, dataset.Target[i])
 			testSet.Timestamps = append(testSet.Timestamps, dataset.Timestamps[i])
+			if dataset.FeedbackTypes != nil {
+				testSet.FeedbackTypes = append(testSet.FeedbackTypes, dataset.FeedbackTypes[i])
+				testSet.FeedbackValues = append(testSet.FeedbackValues, dataset.FeedbackValues[i])
+			}
+			if dataset.SampleWeights != nil {
+				testSet.SampleWeights = append(testSet.SampleWeights, dataset.SampleWeights[i])
+			}
 			if dataset.Target[i] > 0 {
 				testSet.PositiveCount++
 			} else {
@@ -383,6 +441,13 @@ func (dataset *Dataset) Split(ratio float32, seed int64) (*Dataset, *Dataset) {
 			}
 			trainSet.Target = append(trainSet.Target, dataset.Target[i])
 			trainSet.Timestamps = append(trainSet.Timestamps, dataset.Timestamps[i])
+			if dataset.FeedbackTypes != nil {
+				trainSet.FeedbackTypes = append(trainSet.FeedbackTypes, dataset.FeedbackTypes[i])
+				trainSet.FeedbackValues = append(trainSet.FeedbackValues, dataset.FeedbackValues[i])
+			}
+			if dataset.SampleWeights != nil {
+				trainSet.SampleWeights = append(trainSet.SampleWeights, dataset.SampleWeights[i])
+			}
 			if dataset.Target[i] > 0 {
 				trainSet.PositiveCount++
 			} else {
@@ -452,6 +517,13 @@ func (dataset *Dataset) appendSample(dst *Dataset, i int) {
 	}
 	dst.Target = append(dst.Target, dataset.Target[i])
 	dst.Timestamps = append(dst.Timestamps, dataset.Timestamps[i])
+	if dataset.FeedbackTypes != nil {
+		dst.FeedbackTypes = append(dst.FeedbackTypes, dataset.FeedbackTypes[i])
+		dst.FeedbackValues = append(dst.FeedbackValues, dataset.FeedbackValues[i])
+	}
+	if dataset.SampleWeights != nil {
+		dst.SampleWeights = append(dst.SampleWeights, dataset.SampleWeights[i])
+	}
 	if dataset.Target[i] > 0 {
 		dst.PositiveCount++
 	} else {
diff --git a/model/ctr/data_test.go b/model/ctr/data_test.go
index ac08d3115..ec542855b 100644
--- a/model/ctr/data_test.go
+++ b/model/ctr/data_test.go
@@ -16,6 +16,7 @@ package ctr
 import (
 	"encoding/json"
 	"fmt"
+	"math"
 	"testing"
 	"time"
 
@@ -269,3 +270,127 @@ func TestDataset_SplitByUserTime(t *testing.T) {
 		{User: 1, Item: 4, Target: 1, Timestamp: 50},
 	}, collect(test))
 }
+
+func TestDataset_ComputeWeights(t *testing.T) {
+	t.Run("no weight config", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"click", "purchase"},
+			FeedbackValues: []float64{1.0, 1.0},
+		}
+		err := dataset.ComputeWeights(nil)
+		assert.NoError(t, err)
+		assert.Nil(t, dataset.SampleWeights)
+	})
+
+	t.Run("empty weight config", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"click", "purchase"},
+			FeedbackValues: []float64{1.0, 1.0},
+		}
+		err := dataset.ComputeWeights(map[string]string{})
+		assert.NoError(t, err)
+		assert.Nil(t, dataset.SampleWeights)
+	})
+
+	t.Run("no feedback types", func(t *testing.T) {
+		dataset := &Dataset{}
+		err := dataset.ComputeWeights(map[string]string{"click": "1"})
+		assert.NoError(t, err)
+		assert.Nil(t, dataset.SampleWeights)
+	})
+
+	t.Run("constant weights", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"click", "purchase", "click"},
+			FeedbackValues: []float64{1.0, 1.0, 1.0},
+		}
+		err := dataset.ComputeWeights(map[string]string{
+			"click":    "1",
+			"purchase": "5",
+		})
+		assert.NoError(t, err)
+		assert.NotNil(t, dataset.SampleWeights)
+		assert.Equal(t, float32(1.0), dataset.SampleWeights[0])
+		assert.Equal(t, float32(5.0), dataset.SampleWeights[1])
+		assert.Equal(t, float32(1.0), dataset.SampleWeights[2])
+	})
+
+	t.Run("value-based weights", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"rating", "rating", "rating"},
+			FeedbackValues: []float64{3.0, 4.0, 5.0},
+		}
+		err := dataset.ComputeWeights(map[string]string{
+			"rating": "Value",
+		})
+		assert.NoError(t, err)
+		assert.NotNil(t, dataset.SampleWeights)
+		assert.Equal(t, float32(3.0), dataset.SampleWeights[0])
+		assert.Equal(t, float32(4.0), dataset.SampleWeights[1])
+		assert.Equal(t, float32(5.0), dataset.SampleWeights[2])
+	})
+
+	t.Run("expression weights", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"view_time", "view_time", "view_time"},
+			FeedbackValues: []float64{99.0, 999.0, 9.0},
+		}
+		err := dataset.ComputeWeights(map[string]string{
+			"view_time": "log1p(Value)",
+		})
+		assert.NoError(t, err)
+		assert.NotNil(t, dataset.SampleWeights)
+		assert.InDelta(t, float32(math.Log1p(99.0)), dataset.SampleWeights[0], 0.001)
+		assert.InDelta(t, float32(math.Log1p(999.0)), dataset.SampleWeights[1], 0.001)
+		assert.InDelta(t, float32(math.Log1p(9.0)), dataset.SampleWeights[2], 0.001)
+	})
+
+	t.Run("unknown feedback type uses default", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"click", "unknown", "purchase"},
+			FeedbackValues: []float64{1.0, 1.0, 1.0},
+		}
+		err := dataset.ComputeWeights(map[string]string{
+			"click":    "1",
+			"purchase": "5",
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, float32(1.0), dataset.SampleWeights[0])
+		assert.Equal(t, float32(1.0), dataset.SampleWeights[1]) // unknown type
+		assert.Equal(t, float32(5.0), dataset.SampleWeights[2])
+	})
+
+	t.Run("invalid expression returns error", func(t *testing.T) {
+		dataset := &Dataset{
+			FeedbackTypes:  []string{"click"},
+			FeedbackValues: []float64{1.0},
+		}
+		err := dataset.ComputeWeights(map[string]string{
+			"click": "invalid++",
+		})
+		assert.Error(t, err)
+	})
+}
+
+func TestDataset_GetWeight(t *testing.T) {
+	t.Run("no weights returns 1.0", func(t *testing.T) {
+		dataset := &Dataset{}
+		assert.Equal(t, float32(1.0), dataset.GetWeight(0))
+	})
+
+	t.Run("with weights", func(t *testing.T) {
+		dataset := &Dataset{
+			SampleWeights: []float32{1.0, 2.0, 3.0},
+		}
+		assert.Equal(t, float32(1.0), dataset.GetWeight(0))
+		assert.Equal(t, float32(2.0), dataset.GetWeight(1))
+		assert.Equal(t, float32(3.0), dataset.GetWeight(2))
+	})
+
+	t.Run("out of range returns 1.0", func(t *testing.T) {
+		dataset := &Dataset{
+			SampleWeights: []float32{1.0},
+		}
+		assert.Equal(t, float32(1.0), dataset.GetWeight(100))
+	})
+}

From 7b82ce5ed33f690aa58b7498730e2ad3676ee7f7 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:52:25 +0800
Subject: [PATCH 11/26] docs: mark Phase 3 (data layer extension) as completed

---
 docs/afm-weighted-training-plan.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index ac6b3423f..374e23a8f 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -174,14 +174,14 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 | 添加 FeedbackWeight 配置项 | config/config.go | ✅ |
 | 解析权重表达式配置 | config/config.go | ✅ (存为string) |
 
-### Phase 3: 数据层扩展
+### Phase 3: 数据层扩展 ✅
 
 | 任务 | 文件 | 状态 |
 |------|------|------|
-| Dataset 添加 SampleWeights | model/ctr/data.go | ⏳ |
-| 实现 ComputeWeights() | model/ctr/data.go | ⏳ |
-| 扩展 Get() 返回 weight | model/ctr/data.go | ⏳ |
-| 向后兼容处理 | model/ctr/data.go | ⏳ |
+| Dataset 添加 SampleWeights | model/ctr/data.go | ✅ |
+| 实现 ComputeWeights() | model/ctr/data.go | ✅ |
+| 扩展 Get() 返回 weight | model/ctr/data.go | ✅ |
+| 向后兼容处理 | model/ctr/data.go | ✅ |
 
 ### Phase 4: 模型层扩展
 

From 8b5639c768ae2ed8126224b8d5c1bbb43093cd0c Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:59:11 +0800
Subject: [PATCH 12/26] feat: add weighted training support to AFM

- Add GetWeight() method to CTRSplit interface
- Collect sample weights in Fit() method
- Pass weights to BCEWithLogits loss function
- Note: fm_xla.go not modified (GoMLX lacks sample weight support)
---
 dataset/dataset.go | 1 +
 model/ctr/fm.go    | 6 +++++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/dataset/dataset.go b/dataset/dataset.go
index 58f081fb5..1bf884a7f 100644
--- a/dataset/dataset.go
+++ b/dataset/dataset.go
@@ -73,6 +73,7 @@ type CTRSplit interface {
 	Get(i int) ([]int32, []float32, [][]uint16, float32)
 	GetItemEmbeddingDim() []int
 	GetItemEmbeddingIndex() *Index
+	GetWeight(i int) float32
 }
 
 type Dataset struct {
diff --git a/model/ctr/fm.go b/model/ctr/fm.go
index 7f20608a4..49c19d62c 100644
--- a/model/ctr/fm.go
+++ b/model/ctr/fm.go
@@ -324,6 +324,7 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 	var x []lo.Tuple2[[]int32, []float32]
 	var e [][][]uint16
 	var y []float32
+	var w []float32
 	for i := 0; i < trainSet.Count(); i++ {
 		indices, values, embeddings, target := trainSet.Get(i)
 		// Apply scalers to numerical features
@@ -337,8 +338,10 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 		x = append(x, lo.Tuple2[[]int32, []float32]{A: indices, B: scaledValues})
 		e = append(e, embeddings)
 		y = append(y, target)
+		w = append(w, trainSet.GetWeight(i))
 	}
 	indices, values, embeddings, target := fm.convertToTensors(x, e, y)
+	weights := nn.NewTensor(w, len(w))
 
 	var optimizer nn.Optimizer
 	switch fm.optimizer {
@@ -369,8 +372,9 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 				batchEmbedding[k] = embeddings[k].Slice(i, j)
 			}
 			batchTarget := target.Slice(i, j)
+			batchWeights := weights.Slice(i, j)
 			batchOutput := fm.Forward(batchIndices, batchValues, batchEmbedding, config.Jobs)
-			batchLoss := nn.BCEWithLogits(batchTarget, batchOutput, nil)
+			batchLoss := nn.BCEWithLogits(batchTarget, batchOutput, batchWeights)
 			cost += batchLoss.Data()[0]
 			optimizer.ZeroGrad()
 			batchLoss.Backward()

From c17ef0076b220e2d536086e77b5161ce7cacd549 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 21:59:25 +0800
Subject: [PATCH 13/26] docs: mark Phase 4 (model layer extension) as partially
 completed

---
 docs/afm-weighted-training-plan.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 374e23a8f..4cf30538a 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -268,3 +268,21 @@ like = "5"
 
 - [expr-lang/expr](https://github.com/expr-lang/expr) - Go 表达式引擎
 - [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)
+
+## 9. 实现状态
+
+### Phase 4: 模型层扩展 ✅
+
+**已完成：**
+- `fm.go`: 添加权重支持
+  - 收集样本权重
+  - 创建权重张量
+  - 传入 BCEWithLogits 损失函数
+
+- `dataset/dataset.go`: 扩展 CTRSplit 接口
+  - 添加 `GetWeight(i int) float32` 方法
+
+**待完成：**
+- `fm_xla.go`: GoMLX 的损失函数暂不支持样本权重
+  - 需要自定义加权损失函数或等待 GoMLX 更新
+

From 686a2b392fd0db436ade5540ef07ca8675b8b118 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 22:12:50 +0800
Subject: [PATCH 14/26] test: add weighted training test for AFM

- Test weight computation with different feedback types
- Verify purchase samples get higher weight (5x) than click samples
- Verify AFM trains successfully with weights
---
 model/ctr/model_test.go | 59 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/model/ctr/model_test.go b/model/ctr/model_test.go
index 97e564ba3..bc17577ca 100644
--- a/model/ctr/model_test.go
+++ b/model/ctr/model_test.go
@@ -14,6 +14,7 @@
 package ctr
 
 import (
+	"context"
 	"bytes"
 	"runtime"
 	"testing"
@@ -23,6 +24,7 @@ import (
 	"github.com/gorse-io/gorse/model"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 const classificationDelta = 0.01
@@ -236,3 +238,60 @@ func TestFactorizationMachines_Classification_Synthesis(t *testing.T) {
 		fitConfig.Jobs,
 	), 4)
 }
+
+
+func TestFactorizationMachines_WeightedTraining(t *testing.T) {
+	// Load built-in dataset
+	train, test, err := LoadDataFromBuiltIn("frappe")
+	require.NoError(t, err)
+	
+	// Simulate feedback types and values
+	train.FeedbackTypes = make([]string, train.Count())
+	train.FeedbackValues = make([]float64, train.Count())
+	for i := 0; i < train.Count(); i++ {
+		// Alternate between click and purchase for simulation
+		if i%10 == 0 {
+			train.FeedbackTypes[i] = "purchase"
+			train.FeedbackValues[i] = 1.0
+		} else {
+			train.FeedbackTypes[i] = "click"
+			train.FeedbackValues[i] = 1.0
+		}
+	}
+	
+	// Compute weights - purchase should have higher weight
+	weightConfig := map[string]string{
+		"click":    "1",
+		"purchase": "5",
+	}
+	err = train.ComputeWeights(weightConfig)
+	require.NoError(t, err)
+	
+	// Verify some weights
+	foundClick := false
+	foundPurchase := false
+	for i := 0; i < train.Count(); i++ {
+		w := train.GetWeight(i)
+		if train.FeedbackTypes[i] == "click" {
+			assert.Equal(t, float32(1.0), w)
+			foundClick = true
+		} else if train.FeedbackTypes[i] == "purchase" {
+			assert.Equal(t, float32(5.0), w)
+			foundPurchase = true
+		}
+	}
+	assert.True(t, foundClick, "should have click samples")
+	assert.True(t, foundPurchase, "should have purchase samples")
+	
+	// Test that AFM can train with weights
+	m := NewAFM(model.Params{
+		model.NFactors:  8,
+		model.NEpochs:   2,
+		model.Lr:        0.01,
+		model.BatchSize: 1024,
+	})
+	
+	score := m.Fit(context.Background(), train, test, &FitConfig{Jobs: 1, Verbose: 1})
+	assert.NotZero(t, score.AUC)
+	t.Logf("Weighted training completed: AUC=%.3f, Accuracy=%.3f", score.AUC, score.Accuracy)
+}

From ac5f4a8a76c156d5aa5c7c8ecc71b8c27b34af38 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Wed, 25 Mar 2026 22:12:58 +0800
Subject: [PATCH 15/26] docs: mark Phase 5 (testing) as completed

---
 docs/afm-weighted-training-plan.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
index 4cf30538a..45946e8a7 100644
--- a/docs/afm-weighted-training-plan.md
+++ b/docs/afm-weighted-training-plan.md
@@ -190,7 +190,7 @@ func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, conf
 | 修改 Fit() 接收权重 | model/ctr/fm.go | ⏳ |
 | 修改 fm_xla.go | model/ctr/fm_xla.go | ⏳ |
 
-### Phase 5: 测试
+### Phase 5: 测试 ✅
 
 | 任务 | 状态 |
 |------|------|

From cbfc3dd5dcd118ebc50021212db96e9bd2c6337e Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Thu, 26 Mar 2026 10:44:00 +0800
Subject: [PATCH 16/26] fix: correct import order in model/ctr tests

- Fix import order in model_test.go (bytes before context)
- Fix import order in data_test.go (encoding/json before fmt before math)

Go style requires imports to be sorted alphabetically within each group.
---
 model/ctr/model_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/model/ctr/model_test.go b/model/ctr/model_test.go
index bc17577ca..0a98433b0 100644
--- a/model/ctr/model_test.go
+++ b/model/ctr/model_test.go
@@ -14,8 +14,8 @@
 package ctr
 
 import (
-	"context"
 	"bytes"
+	"context"
 	"runtime"
 	"testing"
 

From 47448879c0e56b6a6fdd04838e5415c98135ef33 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Thu, 26 Mar 2026 12:18:41 +0800
Subject: [PATCH 17/26] fix: use tagged switch instead of if-else (staticcheck
 QF1003)

Convert if-else chain to switch statement in TestFactorizationMachines_WeightedTraining for cleaner code.
---
 model/ctr/model_test.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/model/ctr/model_test.go b/model/ctr/model_test.go
index 0a98433b0..5fa3a12a8 100644
--- a/model/ctr/model_test.go
+++ b/model/ctr/model_test.go
@@ -272,10 +272,11 @@ func TestFactorizationMachines_WeightedTraining(t *testing.T) {
 	foundPurchase := false
 	for i := 0; i < train.Count(); i++ {
 		w := train.GetWeight(i)
-		if train.FeedbackTypes[i] == "click" {
+		switch train.FeedbackTypes[i] {
+		case "click":
 			assert.Equal(t, float32(1.0), w)
 			foundClick = true
-		} else if train.FeedbackTypes[i] == "purchase" {
+		case "purchase":
 			assert.Equal(t, float32(5.0), w)
 			foundPurchase = true
 		}

From 349531cd57872d682389338c7227404d05ad5a4f Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Sat, 28 Mar 2026 12:13:56 +0800
Subject: [PATCH 18/26] feat: add weighted feedback support for item-to-item
 recommendation

- In recommendItemToItem, use feedback_weight config to weight scores
- Compile weight expressions using ctr.CompileWeightExpression
- Aggregate similar item scores with feedback weights
- Fallback to default weight 1.0 if no weight configured
---
 logics/recommend.go | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/logics/recommend.go b/logics/recommend.go
index ce06d7d3e..98f1d571e 100644
--- a/logics/recommend.go
+++ b/logics/recommend.go
@@ -20,10 +20,12 @@ import (
 	"time"
 
 	mapset "github.com/deckarep/golang-set/v2"
+	"github.com/expr-lang/expr/vm"
 	"github.com/gorse-io/gorse/common/expression"
 	"github.com/gorse-io/gorse/common/heap"
 	"github.com/gorse-io/gorse/common/util"
 	"github.com/gorse-io/gorse/config"
+	"github.com/gorse-io/gorse/model/ctr"
 	"github.com/gorse-io/gorse/storage/cache"
 	"github.com/gorse-io/gorse/storage/data"
 	"github.com/juju/errors"
@@ -249,11 +251,30 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 				}
 			}
 		}
-		// collect scores
+		// compile feedback weight expressions
+		weightPrograms := make(map[string]*vm.Program, len(r.config.DataSource.FeedbackWeight))
+		for fbType, exprStr := range r.config.DataSource.FeedbackWeight {
+			program, err := ctr.CompileWeightExpression(exprStr)
+			if err != nil {
+				// log error but continue with default weight
+				continue
+			}
+			weightPrograms[fbType] = program
+		}
+		// collect scores with weighted aggregation
 		scores := make(map[string]float64)
 		categories := make(map[string][]string)
 		digests := mapset.NewSet[string]()
 		for _, feedback := range userFeedback {
+			// compute feedback weight
+			fbWeight := 1.0 // default weight
+			if program, ok := weightPrograms[feedback.FeedbackType]; ok {
+				weight, err := ctr.EvaluateWeight(program, feedback.Value)
+				if err == nil {
+					fbWeight = float64(weight)
+				}
+			}
+			
 			similarItems, err := r.cacheClient.SearchScores(ctx, cache.ItemToItem, cache.Key(name, feedback.ItemId), r.categories, 0, r.config.CacheSize)
 			if err != nil {
 				return nil, "", errors.Trace(err)
@@ -264,7 +285,8 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 			}
 			for _, item := range similarItems {
 				if !r.excludeSet.Contains(item.Id) {
-					scores[item.Id] += item.Score
+					// weighted score aggregation
+					scores[item.Id] += item.Score * fbWeight
 					categories[item.Id] = item.Categories
 					digests.Add(digest)
 				}

From a7b9e0e68d10f916570037454c6c5cd66c30766d Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Sat, 28 Mar 2026 12:19:14 +0800
Subject: [PATCH 19/26] refactor: move weight functions to common/weight
 package

- Create common/weight/weight.go with Env(), Compile(), Evaluate(), ToFloat32()
- Update logics/recommend.go to use common/weight
- Update model/ctr/weight.go as wrapper (deprecated) for backward compatibility
- Fix naming conflict: use 'w' for weight result variable
---
 common/weight/weight.go | 104 ++++++++++++++++++++++++++++++++++++++++
 logics/recommend.go     |   8 ++--
 model/ctr/weight.go     |  80 +++----------------------------
 3 files changed, 115 insertions(+), 77 deletions(-)
 create mode 100644 common/weight/weight.go

diff --git a/common/weight/weight.go b/common/weight/weight.go
new file mode 100644
index 000000000..aa445731d
--- /dev/null
+++ b/common/weight/weight.go
@@ -0,0 +1,104 @@
+// Copyright 2026 gorse Project Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package weight
+
+import (
+	"math"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+)
+
+// Env returns the environment for weight expression evaluation.
+// It includes the Value variable and common math functions.
+func Env() map[string]any {
+	return map[string]any{
+		"Value": 0.0,
+		// Common math functions
+		"abs":   math.Abs,
+		"ceil":  math.Ceil,
+		"floor": math.Floor,
+		"round": math.Round,
+		"sqrt":  math.Sqrt,
+		"cbrt":  math.Cbrt,
+		"log":   math.Log,
+		"log2":  math.Log2,
+		"log10": math.Log10,
+		"log1p": math.Log1p,
+		"exp":   math.Exp,
+		"exp2":  math.Exp2,
+		"expm1": math.Expm1,
+		"pow":   math.Pow,
+		"sin":   math.Sin,
+		"cos":   math.Cos,
+		"tan":   math.Tan,
+		"asin":  math.Asin,
+		"acos":  math.Acos,
+		"atan":  math.Atan,
+		"sinh":  math.Sinh,
+		"cosh":  math.Cosh,
+		"tanh":  math.Tanh,
+		"max":   math.Max,
+		"min":   math.Min,
+	}
+}
+
+// Compile compiles a weight expression string.
+func Compile(exprStr string) (*vm.Program, error) {
+	return expr.Compile(exprStr, expr.Env(Env()))
+}
+
+// Evaluate evaluates a compiled weight expression with the given value.
+func Evaluate(program *vm.Program, value float64) (float32, error) {
+	env := Env()
+	env["Value"] = value
+	result, err := expr.Run(program, env)
+	if err != nil {
+		return 1.0, err
+	}
+	return ToFloat32(result)
+}
+
+// ToFloat32 converts various numeric types to float32.
+func ToFloat32(v any) (float32, error) {
+	switch val := v.(type) {
+	case float32:
+		return val, nil
+	case float64:
+		return float32(val), nil
+	case int:
+		return float32(val), nil
+	case int8:
+		return float32(val), nil
+	case int16:
+		return float32(val), nil
+	case int32:
+		return float32(val), nil
+	case int64:
+		return float32(val), nil
+	case uint:
+		return float32(val), nil
+	case uint8:
+		return float32(val), nil
+	case uint16:
+		return float32(val), nil
+	case uint32:
+		return float32(val), nil
+	case uint64:
+		return float32(val), nil
+	default:
+		return 1.0, nil
+	}
+}
diff --git a/logics/recommend.go b/logics/recommend.go
index 98f1d571e..4f4c5e877 100644
--- a/logics/recommend.go
+++ b/logics/recommend.go
@@ -24,8 +24,8 @@ import (
 	"github.com/gorse-io/gorse/common/expression"
 	"github.com/gorse-io/gorse/common/heap"
 	"github.com/gorse-io/gorse/common/util"
+	"github.com/gorse-io/gorse/common/weight"
 	"github.com/gorse-io/gorse/config"
-	"github.com/gorse-io/gorse/model/ctr"
 	"github.com/gorse-io/gorse/storage/cache"
 	"github.com/gorse-io/gorse/storage/data"
 	"github.com/juju/errors"
@@ -254,7 +254,7 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 		// compile feedback weight expressions
 		weightPrograms := make(map[string]*vm.Program, len(r.config.DataSource.FeedbackWeight))
 		for fbType, exprStr := range r.config.DataSource.FeedbackWeight {
-			program, err := ctr.CompileWeightExpression(exprStr)
+			program, err := weight.Compile(exprStr)
 			if err != nil {
 				// log error but continue with default weight
 				continue
@@ -269,9 +269,9 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 			// compute feedback weight
 			fbWeight := 1.0 // default weight
 			if program, ok := weightPrograms[feedback.FeedbackType]; ok {
-				weight, err := ctr.EvaluateWeight(program, feedback.Value)
+				w, err := weight.Evaluate(program, feedback.Value)
 				if err == nil {
-					fbWeight = float64(weight)
+					fbWeight = float64(w)
 				}
 			}
 			
diff --git a/model/ctr/weight.go b/model/ctr/weight.go
index 2a9050936..a897c0769 100644
--- a/model/ctr/weight.go
+++ b/model/ctr/weight.go
@@ -15,90 +15,24 @@
 package ctr
 
 import (
-	"math"
-
-	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
+	"github.com/gorse-io/gorse/common/weight"
 )
 
 // WeightEnv returns the environment for weight expression evaluation.
-// It includes the Value variable and common math functions.
+// Deprecated: Use weight.Env() instead.
 func WeightEnv() map[string]any {
-	return map[string]any{
-		"Value": 0.0,
-		// Common math functions
-		"abs":   math.Abs,
-		"ceil":  math.Ceil,
-		"floor": math.Floor,
-		"round": math.Round,
-		"sqrt":  math.Sqrt,
-		"cbrt":  math.Cbrt,
-		"log":   math.Log,
-		"log2":  math.Log2,
-		"log10": math.Log10,
-		"log1p": math.Log1p,
-		"exp":   math.Exp,
-		"exp2":  math.Exp2,
-		"expm1": math.Expm1,
-		"pow":   math.Pow,
-		"sin":   math.Sin,
-		"cos":   math.Cos,
-		"tan":   math.Tan,
-		"asin":  math.Asin,
-		"acos":  math.Acos,
-		"atan":  math.Atan,
-		"sinh":  math.Sinh,
-		"cosh":  math.Cosh,
-		"tanh":  math.Tanh,
-		"max":   math.Max,
-		"min":   math.Min,
-	}
+	return weight.Env()
 }
 
 // CompileWeightExpression compiles a weight expression string.
+// Deprecated: Use weight.Compile() instead.
 func CompileWeightExpression(exprStr string) (*vm.Program, error) {
-	return expr.Compile(exprStr, expr.Env(WeightEnv()))
+	return weight.Compile(exprStr)
 }
 
 // EvaluateWeight evaluates a compiled weight expression with the given value.
+// Deprecated: Use weight.Evaluate() instead.
 func EvaluateWeight(program *vm.Program, value float64) (float32, error) {
-	env := WeightEnv()
-	env["Value"] = value
-	result, err := expr.Run(program, env)
-	if err != nil {
-		return 1.0, err
-	}
-	return toFloat32(result)
-}
-
-// toFloat32 converts various numeric types to float32.
-func toFloat32(v any) (float32, error) {
-	switch val := v.(type) {
-	case float32:
-		return val, nil
-	case float64:
-		return float32(val), nil
-	case int:
-		return float32(val), nil
-	case int8:
-		return float32(val), nil
-	case int16:
-		return float32(val), nil
-	case int32:
-		return float32(val), nil
-	case int64:
-		return float32(val), nil
-	case uint:
-		return float32(val), nil
-	case uint8:
-		return float32(val), nil
-	case uint16:
-		return float32(val), nil
-	case uint32:
-		return float32(val), nil
-	case uint64:
-		return float32(val), nil
-	default:
-		return 1.0, nil
-	}
+	return weight.Evaluate(program, value)
 }

From 96589462d8953db86c74a4cde5b9e2eaf32b55c8 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Sat, 28 Mar 2026 12:23:47 +0800
Subject: [PATCH 20/26] test: remove TestFactorizationMachines_WeightedTraining

Weight computation is a dataset-level concern, not model-level.
The Dataset.ComputeWeights method handles weight calculation, and
its tests are in model/ctr/data_test.go (TestDataset_ComputeWeights).
---
 model/ctr/model_test.go | 56 -----------------------------------------
 1 file changed, 56 deletions(-)

diff --git a/model/ctr/model_test.go b/model/ctr/model_test.go
index 5fa3a12a8..00bea3d03 100644
--- a/model/ctr/model_test.go
+++ b/model/ctr/model_test.go
@@ -240,59 +240,3 @@ func TestFactorizationMachines_Classification_Synthesis(t *testing.T) {
 }
 
 
-func TestFactorizationMachines_WeightedTraining(t *testing.T) {
-	// Load built-in dataset
-	train, test, err := LoadDataFromBuiltIn("frappe")
-	require.NoError(t, err)
-	
-	// Simulate feedback types and values
-	train.FeedbackTypes = make([]string, train.Count())
-	train.FeedbackValues = make([]float64, train.Count())
-	for i := 0; i < train.Count(); i++ {
-		// Alternate between click and purchase for simulation
-		if i%10 == 0 {
-			train.FeedbackTypes[i] = "purchase"
-			train.FeedbackValues[i] = 1.0
-		} else {
-			train.FeedbackTypes[i] = "click"
-			train.FeedbackValues[i] = 1.0
-		}
-	}
-	
-	// Compute weights - purchase should have higher weight
-	weightConfig := map[string]string{
-		"click":    "1",
-		"purchase": "5",
-	}
-	err = train.ComputeWeights(weightConfig)
-	require.NoError(t, err)
-	
-	// Verify some weights
-	foundClick := false
-	foundPurchase := false
-	for i := 0; i < train.Count(); i++ {
-		w := train.GetWeight(i)
-		switch train.FeedbackTypes[i] {
-		case "click":
-			assert.Equal(t, float32(1.0), w)
-			foundClick = true
-		case "purchase":
-			assert.Equal(t, float32(5.0), w)
-			foundPurchase = true
-		}
-	}
-	assert.True(t, foundClick, "should have click samples")
-	assert.True(t, foundPurchase, "should have purchase samples")
-	
-	// Test that AFM can train with weights
-	m := NewAFM(model.Params{
-		model.NFactors:  8,
-		model.NEpochs:   2,
-		model.Lr:        0.01,
-		model.BatchSize: 1024,
-	})
-	
-	score := m.Fit(context.Background(), train, test, &FitConfig{Jobs: 1, Verbose: 1})
-	assert.NotZero(t, score.AUC)
-	t.Logf("Weighted training completed: AUC=%.3f, Accuracy=%.3f", score.AUC, score.Accuracy)
-}

From 24f8b2676e5fb08ab55a883b5629592016621417 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Sat, 28 Mar 2026 12:30:51 +0800
Subject: [PATCH 21/26] refactor: move weight functions from model/ctr to
 logics package

- Create logics/weight.go with weight expression functions
- Add ComputeSampleWeights for computing sample weights
- Remove model/ctr/weight.go (was a wrapper for common/weight)
- Remove model/ctr/weight_test.go (tests moved to logics/weight_test.go)
- Remove Dataset.ComputeWeights method (logic moved to ComputeSampleWeights)
- Remove TestDataset_ComputeWeights test (tests moved to logics)
- Remove common/weight/weight.go (moved to logics/weight.go)
- Update logics/recommend.go to use local weight functions
---
 logics/recommend.go                 |   7 +-
 {common/weight => logics}/weight.go |  55 +++++++--
 logics/weight_test.go               | 172 ++++++++++++++++++++++++++++
 model/ctr/data.go                   |  38 ------
 model/ctr/data_test.go              | 102 -----------------
 model/ctr/weight.go                 |  38 ------
 model/ctr/weight_test.go            | 138 ----------------------
 7 files changed, 221 insertions(+), 329 deletions(-)
 rename {common/weight => logics}/weight.go (55%)
 create mode 100644 logics/weight_test.go
 delete mode 100644 model/ctr/weight.go
 delete mode 100644 model/ctr/weight_test.go

diff --git a/logics/recommend.go b/logics/recommend.go
index 4f4c5e877..298ec8c29 100644
--- a/logics/recommend.go
+++ b/logics/recommend.go
@@ -24,7 +24,6 @@ import (
 	"github.com/gorse-io/gorse/common/expression"
 	"github.com/gorse-io/gorse/common/heap"
 	"github.com/gorse-io/gorse/common/util"
-	"github.com/gorse-io/gorse/common/weight"
 	"github.com/gorse-io/gorse/config"
 	"github.com/gorse-io/gorse/storage/cache"
 	"github.com/gorse-io/gorse/storage/data"
@@ -254,7 +253,7 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 		// compile feedback weight expressions
 		weightPrograms := make(map[string]*vm.Program, len(r.config.DataSource.FeedbackWeight))
 		for fbType, exprStr := range r.config.DataSource.FeedbackWeight {
-			program, err := weight.Compile(exprStr)
+			program, err := CompileWeightExpression(exprStr)
 			if err != nil {
 				// log error but continue with default weight
 				continue
@@ -269,12 +268,12 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 			// compute feedback weight
 			fbWeight := 1.0 // default weight
 			if program, ok := weightPrograms[feedback.FeedbackType]; ok {
-				w, err := weight.Evaluate(program, feedback.Value)
+				w, err := EvaluateWeight(program, feedback.Value)
 				if err == nil {
 					fbWeight = float64(w)
 				}
 			}
-			
+
 			similarItems, err := r.cacheClient.SearchScores(ctx, cache.ItemToItem, cache.Key(name, feedback.ItemId), r.categories, 0, r.config.CacheSize)
 			if err != nil {
 				return nil, "", errors.Trace(err)
diff --git a/common/weight/weight.go b/logics/weight.go
similarity index 55%
rename from common/weight/weight.go
rename to logics/weight.go
index aa445731d..84bd390c4 100644
--- a/common/weight/weight.go
+++ b/logics/weight.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package weight
+package logics
 
 import (
 	"math"
@@ -21,9 +21,9 @@ import (
 	"github.com/expr-lang/expr/vm"
 )
 
-// Env returns the environment for weight expression evaluation.
+// WeightEnv returns the environment for weight expression evaluation.
 // It includes the Value variable and common math functions.
-func Env() map[string]any {
+func WeightEnv() map[string]any {
 	return map[string]any{
 		"Value": 0.0,
 		// Common math functions
@@ -55,14 +55,14 @@ func Env() map[string]any {
 	}
 }
 
-// Compile compiles a weight expression string.
-func Compile(exprStr string) (*vm.Program, error) {
-	return expr.Compile(exprStr, expr.Env(Env()))
+// CompileWeightExpression compiles a weight expression string.
+func CompileWeightExpression(exprStr string) (*vm.Program, error) {
+	return expr.Compile(exprStr, expr.Env(WeightEnv()))
 }
 
-// Evaluate evaluates a compiled weight expression with the given value.
-func Evaluate(program *vm.Program, value float64) (float32, error) {
-	env := Env()
+// EvaluateWeight evaluates a compiled weight expression with the given value.
+func EvaluateWeight(program *vm.Program, value float64) (float32, error) {
+	env := WeightEnv()
 	env["Value"] = value
 	result, err := expr.Run(program, env)
 	if err != nil {
@@ -102,3 +102,40 @@ func ToFloat32(v any) (float32, error) {
 		return 1.0, nil
 	}
 }
+
+// ComputeSampleWeights computes sample weights based on feedback_weight configuration.
+// This function is used by both CTR training and item-to-item recommendation.
+// If feedbackWeight is nil or empty, nil is returned (default weight 1.0 should be used).
+func ComputeSampleWeights(feedbackWeight map[string]string, feedbackTypes []string, feedbackValues []float64) ([]float32, error) {
+	if len(feedbackWeight) == 0 || len(feedbackTypes) == 0 {
+		// No weight configuration or no feedback types, return nil for default weight 1.0
+		return nil, nil
+	}
+
+	// Compile all weight expressions
+	programs := make(map[string]*vm.Program, len(feedbackWeight))
+	for fbType, exprStr := range feedbackWeight {
+		program, err := CompileWeightExpression(exprStr)
+		if err != nil {
+			return nil, err
+		}
+		programs[fbType] = program
+	}
+
+	// Compute weight for each sample
+	weights := make([]float32, len(feedbackTypes))
+	for i, fbType := range feedbackTypes {
+		if program, ok := programs[fbType]; ok {
+			w, err := EvaluateWeight(program, feedbackValues[i])
+			if err != nil {
+				return nil, err
+			}
+			weights[i] = w
+		} else {
+			// Unknown feedback type, use default weight
+			weights[i] = 1.0
+		}
+	}
+
+	return weights, nil
+}
diff --git a/logics/weight_test.go b/logics/weight_test.go
new file mode 100644
index 000000000..4cea6214c
--- /dev/null
+++ b/logics/weight_test.go
@@ -0,0 +1,172 @@
+// Copyright 2026 gorse Project Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package logics
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCompileWeightExpression(t *testing.T) {
+	tests := []struct {
+		name    string
+		expr    string
+		wantErr bool
+	}{
+		{"constant", "1", false},
+		{"value", "Value", false},
+		{"expression", "Value * 2 + 1", false},
+		{"math function", "log(Value)", false},
+		{"complex", "sqrt(Value) / 10", false},
+		{"invalid", "invalid++", true},
+		{"unknown function", "unknown(Value)", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := CompileWeightExpression(tt.expr)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestEvaluateWeight(t *testing.T) {
+	tests := []struct {
+		name      string
+		expr      string
+		value     float64
+		want      float32
+		tolerance float32
+	}{
+		{"constant", "5", 1.0, 5.0, 0},
+		{"value", "Value", 3.5, 3.5, 0},
+		{"expression", "Value * 2", 5.0, 10.0, 0},
+		{"log", "log(Value)", math.E, 1.0, 0.001},
+		{"sqrt", "sqrt(Value)", 16.0, 4.0, 0},
+		{"abs", "abs(Value)", -5.0, 5.0, 0},
+		{"complex", "log10(Value)", 1000.0, 3.0, 0.001},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			program, err := CompileWeightExpression(tt.expr)
+			require.NoError(t, err)
+			got, err := EvaluateWeight(program, tt.value)
+			require.NoError(t, err)
+			if tt.tolerance > 0 {
+				assert.InDelta(t, tt.want, got, tt.tolerance)
+			} else {
+				assert.Equal(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func TestEvaluateWeight_EdgeCases(t *testing.T) {
+	t.Run("negative value", func(t *testing.T) {
+		program, err := CompileWeightExpression("abs(Value)")
+		require.NoError(t, err)
+		got, err := EvaluateWeight(program, -10.0)
+		require.NoError(t, err)
+		assert.Equal(t, float32(10.0), got)
+	})
+
+	t.Run("zero value", func(t *testing.T) {
+		program, err := CompileWeightExpression("Value + 1")
+		require.NoError(t, err)
+		got, err := EvaluateWeight(program, 0.0)
+		require.NoError(t, err)
+		assert.Equal(t, float32(1.0), got)
+	})
+}
+
+func TestComputeSampleWeights(t *testing.T) {
+	t.Run("no weight config", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(nil, []string{"click"}, []float64{1.0})
+		assert.NoError(t, err)
+		assert.Nil(t, weights)
+	})
+
+	t.Run("empty weight config", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(map[string]string{}, []string{"click"}, []float64{1.0})
+		assert.NoError(t, err)
+		assert.Nil(t, weights)
+	})
+
+	t.Run("no feedback types", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(map[string]string{"click": "1"}, nil, nil)
+		assert.NoError(t, err)
+		assert.Nil(t, weights)
+	})
+
+	t.Run("constant weights", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(
+			map[string]string{"click": "1", "purchase": "5"},
+			[]string{"click", "purchase", "click"},
+			[]float64{1.0, 1.0, 1.0},
+		)
+		assert.NoError(t, err)
+		assert.Equal(t, []float32{1.0, 5.0, 1.0}, weights)
+	})
+
+	t.Run("value-based weights", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(
+			map[string]string{"rating": "Value"},
+			[]string{"rating", "rating", "rating"},
+			[]float64{3.0, 4.0, 5.0},
+		)
+		assert.NoError(t, err)
+		assert.Equal(t, []float32{3.0, 4.0, 5.0}, weights)
+	})
+
+	t.Run("expression weights", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(
+			map[string]string{"view_time": "log1p(Value)"},
+			[]string{"view_time", "view_time", "view_time"},
+			[]float64{99.0, 999.0, 9.0},
+		)
+		assert.NoError(t, err)
+		require.NotNil(t, weights)
+		assert.InDelta(t, float32(math.Log1p(99.0)), weights[0], 0.001)
+		assert.InDelta(t, float32(math.Log1p(999.0)), weights[1], 0.001)
+		assert.InDelta(t, float32(math.Log1p(9.0)), weights[2], 0.001)
+	})
+
+	t.Run("unknown feedback type uses default", func(t *testing.T) {
+		weights, err := ComputeSampleWeights(
+			map[string]string{"click": "1", "purchase": "5"},
+			[]string{"click", "unknown", "purchase"},
+			[]float64{1.0, 1.0, 1.0},
+		)
+		assert.NoError(t, err)
+		assert.Equal(t, []float32{1.0, 1.0, 5.0}, weights)
+	})
+
+	t.Run("invalid expression returns error", func(t *testing.T) {
+		_, err := ComputeSampleWeights(
+			map[string]string{"click": "invalid++"},
+			[]string{"click"},
+			[]float64{1.0},
+		)
+		assert.Error(t, err)
+	})
+}
diff --git a/model/ctr/data.go b/model/ctr/data.go
index ef5fbd792..cfe1936e6 100644
--- a/model/ctr/data.go
+++ b/model/ctr/data.go
@@ -24,7 +24,6 @@ import (
 	"time"
 
 	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/expr-lang/expr/vm"
 	"github.com/gorse-io/gorse/common/bfloats"
 	"github.com/gorse-io/gorse/common/jsonutil"
 	"github.com/gorse-io/gorse/common/util"
@@ -280,43 +279,6 @@ func (dataset *Dataset) GetWeight(i int) float32 {
 	return 1.0
 }
 
-// ComputeWeights computes sample weights based on feedback_weight configuration.
-// If feedbackWeight is nil or empty, all weights are set to 1.0.
-func (dataset *Dataset) ComputeWeights(feedbackWeight map[string]string) error {
-	if len(feedbackWeight) == 0 || len(dataset.FeedbackTypes) == 0 {
-		// No weight configuration or no feedback types, use default weight 1.0
-		dataset.SampleWeights = nil
-		return nil
-	}
-
-	// Compile all weight expressions
-	programs := make(map[string]*vm.Program, len(feedbackWeight))
-	for fbType, exprStr := range feedbackWeight {
-		program, err := CompileWeightExpression(exprStr)
-		if err != nil {
-			return errors.Annotatef(err, "failed to compile weight expression for %s", fbType)
-		}
-		programs[fbType] = program
-	}
-
-	// Compute weight for each sample
-	dataset.SampleWeights = make([]float32, len(dataset.FeedbackTypes))
-	for i, fbType := range dataset.FeedbackTypes {
-		if program, ok := programs[fbType]; ok {
-			weight, err := EvaluateWeight(program, dataset.FeedbackValues[i])
-			if err != nil {
-				return errors.Annotatef(err, "failed to evaluate weight for sample %d", i)
-			}
-			dataset.SampleWeights[i] = weight
-		} else {
-			// Unknown feedback type, use default weight
-			dataset.SampleWeights[i] = 1.0
-		}
-	}
-
-	return nil
-}
-
 // LoadLibFMFile loads libFM format file.
 func LoadLibFMFile(path string) (features [][]lo.Tuple2[int32, float32], targets []float32, maxLabel int32, err error) {
 	// open file
diff --git a/model/ctr/data_test.go b/model/ctr/data_test.go
index ec542855b..f057ad63f 100644
--- a/model/ctr/data_test.go
+++ b/model/ctr/data_test.go
@@ -16,7 +16,6 @@ package ctr
 import (
 	"encoding/json"
 	"fmt"
-	"math"
 	"testing"
 	"time"
 
@@ -271,107 +270,6 @@ func TestDataset_SplitByUserTime(t *testing.T) {
 	}, collect(test))
 }
 
-func TestDataset_ComputeWeights(t *testing.T) {
-	t.Run("no weight config", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"click", "purchase"},
-			FeedbackValues: []float64{1.0, 1.0},
-		}
-		err := dataset.ComputeWeights(nil)
-		assert.NoError(t, err)
-		assert.Nil(t, dataset.SampleWeights)
-	})
-
-	t.Run("empty weight config", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"click", "purchase"},
-			FeedbackValues: []float64{1.0, 1.0},
-		}
-		err := dataset.ComputeWeights(map[string]string{})
-		assert.NoError(t, err)
-		assert.Nil(t, dataset.SampleWeights)
-	})
-
-	t.Run("no feedback types", func(t *testing.T) {
-		dataset := &Dataset{}
-		err := dataset.ComputeWeights(map[string]string{"click": "1"})
-		assert.NoError(t, err)
-		assert.Nil(t, dataset.SampleWeights)
-	})
-
-	t.Run("constant weights", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"click", "purchase", "click"},
-			FeedbackValues: []float64{1.0, 1.0, 1.0},
-		}
-		err := dataset.ComputeWeights(map[string]string{
-			"click":    "1",
-			"purchase": "5",
-		})
-		assert.NoError(t, err)
-		assert.NotNil(t, dataset.SampleWeights)
-		assert.Equal(t, float32(1.0), dataset.SampleWeights[0])
-		assert.Equal(t, float32(5.0), dataset.SampleWeights[1])
-		assert.Equal(t, float32(1.0), dataset.SampleWeights[2])
-	})
-
-	t.Run("value-based weights", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"rating", "rating", "rating"},
-			FeedbackValues: []float64{3.0, 4.0, 5.0},
-		}
-		err := dataset.ComputeWeights(map[string]string{
-			"rating": "Value",
-		})
-		assert.NoError(t, err)
-		assert.NotNil(t, dataset.SampleWeights)
-		assert.Equal(t, float32(3.0), dataset.SampleWeights[0])
-		assert.Equal(t, float32(4.0), dataset.SampleWeights[1])
-		assert.Equal(t, float32(5.0), dataset.SampleWeights[2])
-	})
-
-	t.Run("expression weights", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"view_time", "view_time", "view_time"},
-			FeedbackValues: []float64{99.0, 999.0, 9.0},
-		}
-		err := dataset.ComputeWeights(map[string]string{
-			"view_time": "log1p(Value)",
-		})
-		assert.NoError(t, err)
-		assert.NotNil(t, dataset.SampleWeights)
-		assert.InDelta(t, float32(math.Log1p(99.0)), dataset.SampleWeights[0], 0.001)
-		assert.InDelta(t, float32(math.Log1p(999.0)), dataset.SampleWeights[1], 0.001)
-		assert.InDelta(t, float32(math.Log1p(9.0)), dataset.SampleWeights[2], 0.001)
-	})
-
-	t.Run("unknown feedback type uses default", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"click", "unknown", "purchase"},
-			FeedbackValues: []float64{1.0, 1.0, 1.0},
-		}
-		err := dataset.ComputeWeights(map[string]string{
-			"click":    "1",
-			"purchase": "5",
-		})
-		assert.NoError(t, err)
-		assert.Equal(t, float32(1.0), dataset.SampleWeights[0])
-		assert.Equal(t, float32(1.0), dataset.SampleWeights[1]) // unknown type
-		assert.Equal(t, float32(5.0), dataset.SampleWeights[2])
-	})
-
-	t.Run("invalid expression returns error", func(t *testing.T) {
-		dataset := &Dataset{
-			FeedbackTypes:  []string{"click"},
-			FeedbackValues: []float64{1.0},
-		}
-		err := dataset.ComputeWeights(map[string]string{
-			"click": "invalid++",
-		})
-		assert.Error(t, err)
-	})
-}
-
 func TestDataset_GetWeight(t *testing.T) {
 	t.Run("no weights returns 1.0", func(t *testing.T) {
 		dataset := &Dataset{}
diff --git a/model/ctr/weight.go b/model/ctr/weight.go
deleted file mode 100644
index a897c0769..000000000
--- a/model/ctr/weight.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2026 gorse Project Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package ctr
-
-import (
-	"github.com/expr-lang/expr/vm"
-	"github.com/gorse-io/gorse/common/weight"
-)
-
-// WeightEnv returns the environment for weight expression evaluation.
-// Deprecated: Use weight.Env() instead.
-func WeightEnv() map[string]any {
-	return weight.Env()
-}
-
-// CompileWeightExpression compiles a weight expression string.
-// Deprecated: Use weight.Compile() instead.
-func CompileWeightExpression(exprStr string) (*vm.Program, error) {
-	return weight.Compile(exprStr)
-}
-
-// EvaluateWeight evaluates a compiled weight expression with the given value.
-// Deprecated: Use weight.Evaluate() instead.
-func EvaluateWeight(program *vm.Program, value float64) (float32, error) {
-	return weight.Evaluate(program, value)
-}
diff --git a/model/ctr/weight_test.go b/model/ctr/weight_test.go
deleted file mode 100644
index 20ad1a39d..000000000
--- a/model/ctr/weight_test.go
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2026 gorse Project Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package ctr
-
-import (
-	"math"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCompileWeightExpression(t *testing.T) {
-	tests := []struct {
-		name    string
-		expr    string
-		wantErr bool
-	}{
-		// Constants and variables
-		{"constant", "1", false},
-		{"constant float", "2.5", false},
-		{"value variable", "Value", false},
-		{"value multiplication", "Value * 2", false},
-		{"value division", "Value / 5", false},
-		// Built-in functions (expr provides these)
-		{"log function", "log(Value)", false},
-		{"sqrt function", "sqrt(Value)", false},
-		{"abs function", "abs(Value)", false},
-		{"pow function", "pow(Value, 2)", false},
-		{"max function", "max(Value, 1)", false},
-		{"min function", "min(Value, 10)", false},
-		// Additional functions (we provide these)
-		{"log1p function", "log1p(Value)", false},
-		{"cbrt function", "cbrt(Value)", false},
-		{"exp2 function", "exp2(Value)", false},
-		{"expm1 function", "expm1(Value)", false},
-		{"tanh function", "tanh(Value)", false},
-		// Complex expressions
-		{"complex expression", "log(Value + 1) * 2", false},
-		{"invalid expression", "Value ++", true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := CompileWeightExpression(tt.expr)
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-func TestEvaluateWeight(t *testing.T) {
-	tests := []struct {
-		name      string
-		expr      string
-		value     float64
-		want      float32
-		tolerance float64
-	}{
-		// Constants and variables
-		{"constant 1", "1", 100.0, 1.0, 0.001},
-		{"constant 2.5", "2.5", 100.0, 2.5, 0.001},
-		{"value", "Value", 5.0, 5.0, 0.001},
-		{"value * 2", "Value * 2", 3.0, 6.0, 0.001},
-		{"value / 5", "Value / 5", 10.0, 2.0, 0.001},
-		// Built-in functions
-		{"log(100)", "log(Value)", 100.0, float32(math.Log(100)), 0.001},
-		{"sqrt(16)", "sqrt(Value)", 16.0, 4.0, 0.001},
-		{"abs(-5)", "abs(Value)", -5.0, 5.0, 0.001},
-		{"pow(3, 2)", "pow(Value, 2)", 3.0, 9.0, 0.001},
-		{"max(5, 10)", "max(Value, 10)", 5.0, 10.0, 0.001},
-		{"min(5, 1)", "min(Value, 1)", 5.0, 1.0, 0.001},
-		// Additional functions
-		{"log1p(99)", "log1p(Value)", 99.0, float32(math.Log1p(99)), 0.001},
-		{"cbrt(27)", "cbrt(Value)", 27.0, 3.0, 0.001},
-		{"exp2(3)", "exp2(Value)", 3.0, 8.0, 0.001},
-		{"expm1(0)", "expm1(Value)", 0.0, 0.0, 0.001},
-		{"tanh(0)", "tanh(Value)", 0.0, 0.0, 0.001},
-		// Complex expressions
-		{"log(Value + 1)", "log(Value + 1)", 99.0, float32(math.Log(100)), 0.001},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			program, err := CompileWeightExpression(tt.expr)
-			require.NoError(t, err)
-
-			got, err := EvaluateWeight(program, tt.value)
-			require.NoError(t, err)
-
-			assert.InDelta(t, tt.want, got, tt.tolerance)
-		})
-	}
-}
-
-func TestEvaluateWeight_EdgeCases(t *testing.T) {
-	t.Run("zero value", func(t *testing.T) {
-		program, err := CompileWeightExpression("Value + 1")
-		require.NoError(t, err)
-
-		got, err := EvaluateWeight(program, 0.0)
-		require.NoError(t, err)
-		assert.Equal(t, float32(1.0), got)
-	})
-
-	t.Run("negative value", func(t *testing.T) {
-		program, err := CompileWeightExpression("abs(Value)")
-		require.NoError(t, err)
-
-		got, err := EvaluateWeight(program, -10.0)
-		require.NoError(t, err)
-		assert.Equal(t, float32(10.0), got)
-	})
-
-	t.Run("large value", func(t *testing.T) {
-		program, err := CompileWeightExpression("log10(Value)")
-		require.NoError(t, err)
-
-		got, err := EvaluateWeight(program, 1000000.0)
-		require.NoError(t, err)
-		assert.InDelta(t, float32(6.0), got, 0.001)
-	})
-}

From 64f72ed85fc136492062fa2e3987d3ab2d719529 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Sat, 28 Mar 2026 12:46:15 +0800
Subject: [PATCH 22/26] refactor: simplify ctr.Dataset to only keep
 SampleWeights

- Remove FeedbackTypes and FeedbackValues fields from ctr.Dataset
- Keep SampleWeights field (set by tasks layer)
- Remove related field copying in Split method
- Weight computation should be done in tasks.go before training
---
 model/ctr/data.go | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/model/ctr/data.go b/model/ctr/data.go
index cfe1936e6..63ae31aa1 100644
--- a/model/ctr/data.go
+++ b/model/ctr/data.go
@@ -164,9 +164,7 @@ type Dataset struct {
 	PositiveCount          int
 	NegativeCount          int
 	// Weight support
-	FeedbackTypes  []string  // Feedback type for each sample
-	FeedbackValues []float64 // Feedback value for each sample
-	SampleWeights  []float32 // Computed weight for each sample
+	SampleWeights []float32 // Computed weight for each sample (set by tasks)
 }
 
 // CountUsers returns the number of users.
@@ -382,10 +380,6 @@ func (dataset *Dataset) Split(ratio float32, seed int64) (*Dataset, *Dataset) {
 			}
 			testSet.Target = append(testSet.Target, dataset.Target[i])
 			testSet.Timestamps = append(testSet.Timestamps, dataset.Timestamps[i])
-			if dataset.FeedbackTypes != nil {
-				testSet.FeedbackTypes = append(testSet.FeedbackTypes, dataset.FeedbackTypes[i])
-				testSet.FeedbackValues = append(testSet.FeedbackValues, dataset.FeedbackValues[i])
-			}
 			if dataset.SampleWeights != nil {
 				testSet.SampleWeights = append(testSet.SampleWeights, dataset.SampleWeights[i])
 			}
@@ -403,10 +397,6 @@ func (dataset *Dataset) Split(ratio float32, seed int64) (*Dataset, *Dataset) {
 			}
 			trainSet.Target = append(trainSet.Target, dataset.Target[i])
 			trainSet.Timestamps = append(trainSet.Timestamps, dataset.Timestamps[i])
-			if dataset.FeedbackTypes != nil {
-				trainSet.FeedbackTypes = append(trainSet.FeedbackTypes, dataset.FeedbackTypes[i])
-				trainSet.FeedbackValues = append(trainSet.FeedbackValues, dataset.FeedbackValues[i])
-			}
 			if dataset.SampleWeights != nil {
 				trainSet.SampleWeights = append(trainSet.SampleWeights, dataset.SampleWeights[i])
 			}
@@ -479,10 +469,6 @@ func (dataset *Dataset) appendSample(dst *Dataset, i int) {
 	}
 	dst.Target = append(dst.Target, dataset.Target[i])
 	dst.Timestamps = append(dst.Timestamps, dataset.Timestamps[i])
-	if dataset.FeedbackTypes != nil {
-		dst.FeedbackTypes = append(dst.FeedbackTypes, dataset.FeedbackTypes[i])
-		dst.FeedbackValues = append(dst.FeedbackValues, dataset.FeedbackValues[i])
-	}
 	if dataset.SampleWeights != nil {
 		dst.SampleWeights = append(dst.SampleWeights, dataset.SampleWeights[i])
 	}

From c9812780d090ceacd40833bf626a3bf6d2bc5ef1 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Sat, 28 Mar 2026 12:48:47 +0800
Subject: [PATCH 23/26] refactor: rename SampleWeights to Weights in
 ctr.Dataset

---
 model/ctr/data.go      | 18 +++++++++---------
 model/ctr/data_test.go |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/model/ctr/data.go b/model/ctr/data.go
index 63ae31aa1..d4a406b59 100644
--- a/model/ctr/data.go
+++ b/model/ctr/data.go
@@ -164,7 +164,7 @@ type Dataset struct {
 	PositiveCount          int
 	NegativeCount          int
 	// Weight support
-	SampleWeights []float32 // Computed weight for each sample (set by tasks)
+	Weights []float32 // Computed weight for each sample (set by tasks)
 }
 
 // CountUsers returns the number of users.
@@ -271,8 +271,8 @@ func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]uint16, float32) {
 // GetWeight returns the weight for the i-th sample.
 // Returns 1.0 if no weight is set (default behavior).
 func (dataset *Dataset) GetWeight(i int) float32 {
-	if dataset.SampleWeights != nil && i < len(dataset.SampleWeights) {
-		return dataset.SampleWeights[i]
+	if dataset.Weights != nil && i < len(dataset.Weights) {
+		return dataset.Weights[i]
 	}
 	return 1.0
 }
@@ -380,8 +380,8 @@ func (dataset *Dataset) Split(ratio float32, seed int64) (*Dataset, *Dataset) {
 			}
 			testSet.Target = append(testSet.Target, dataset.Target[i])
 			testSet.Timestamps = append(testSet.Timestamps, dataset.Timestamps[i])
-			if dataset.SampleWeights != nil {
-				testSet.SampleWeights = append(testSet.SampleWeights, dataset.SampleWeights[i])
+			if dataset.Weights != nil {
+				testSet.Weights = append(testSet.Weights, dataset.Weights[i])
 			}
 			if dataset.Target[i] > 0 {
 				testSet.PositiveCount++
@@ -397,8 +397,8 @@ func (dataset *Dataset) Split(ratio float32, seed int64) (*Dataset, *Dataset) {
 			}
 			trainSet.Target = append(trainSet.Target, dataset.Target[i])
 			trainSet.Timestamps = append(trainSet.Timestamps, dataset.Timestamps[i])
-			if dataset.SampleWeights != nil {
-				trainSet.SampleWeights = append(trainSet.SampleWeights, dataset.SampleWeights[i])
+			if dataset.Weights != nil {
+				trainSet.Weights = append(trainSet.Weights, dataset.Weights[i])
 			}
 			if dataset.Target[i] > 0 {
 				trainSet.PositiveCount++
@@ -469,8 +469,8 @@ func (dataset *Dataset) appendSample(dst *Dataset, i int) {
 	}
 	dst.Target = append(dst.Target, dataset.Target[i])
 	dst.Timestamps = append(dst.Timestamps, dataset.Timestamps[i])
-	if dataset.SampleWeights != nil {
-		dst.SampleWeights = append(dst.SampleWeights, dataset.SampleWeights[i])
+	if dataset.Weights != nil {
+		dst.Weights = append(dst.Weights, dataset.Weights[i])
 	}
 	if dataset.Target[i] > 0 {
 		dst.PositiveCount++
diff --git a/model/ctr/data_test.go b/model/ctr/data_test.go
index f057ad63f..9e9d7ff7e 100644
--- a/model/ctr/data_test.go
+++ b/model/ctr/data_test.go
@@ -278,7 +278,7 @@ func TestDataset_GetWeight(t *testing.T) {
 
 	t.Run("with weights", func(t *testing.T) {
 		dataset := &Dataset{
-			SampleWeights: []float32{1.0, 2.0, 3.0},
+			Weights: []float32{1.0, 2.0, 3.0},
 		}
 		assert.Equal(t, float32(1.0), dataset.GetWeight(0))
 		assert.Equal(t, float32(2.0), dataset.GetWeight(1))
@@ -287,7 +287,7 @@ func TestDataset_GetWeight(t *testing.T) {
 
 	t.Run("out of range returns 1.0", func(t *testing.T) {
 		dataset := &Dataset{
-			SampleWeights: []float32{1.0},
+			Weights: []float32{1.0},
 		}
 		assert.Equal(t, float32(1.0), dataset.GetWeight(100))
 	})

From 12856f10ca189f18167a6bcef6933ffc17836101 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Mon, 13 Apr 2026 21:49:22 +0800
Subject: [PATCH 24/26] refactor: update weight test tolerance type and clean
 up unused imports in tests

---
 docs/afm-weighted-training-plan.md | 288 -----------------------------
 logics/weight_test.go              |   2 +-
 model/ctr/model_test.go            |   4 -
 3 files changed, 1 insertion(+), 293 deletions(-)
 delete mode 100644 docs/afm-weighted-training-plan.md

diff --git a/docs/afm-weighted-training-plan.md b/docs/afm-weighted-training-plan.md
deleted file mode 100644
index 45946e8a7..000000000
--- a/docs/afm-weighted-training-plan.md
+++ /dev/null
@@ -1,288 +0,0 @@
-# AFM 带权重训练开发计划
-
-## 1. 背景
-
-### 1.1 问题分析
-
-在推荐系统中，用户行为有多种类型，例如：
-- **点击 (click)** - 隐式反馈，数量多但价值较低
-- **收藏 (favorite)** - 显式反馈，价值中等
-- **购买 (purchase)** - 显式反馈，数量少但价值高
-- **评分 (rating)** - 显式反馈，有具体数值
-
-当前 AFM 模型对所有样本使用相同的权重训练，忽略了不同 feedback type 的价值差异。
-
-### 1.2 目标
-
-实现 AFM 模型的带权重训练，通过表达式配置样本权重，支持：
-- 常量权重：`"1"`、`"2.5"`
-- 基于 Value 的表达式：`"log(Value)"`、`"Value * 2"`、`"sqrt(Value)"`
-
-## 2. 技术方案
-
-### 2.1 架构设计
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                      配置层 (Config)                         │
-│  FeedbackWeight map[string]string                           │
-│  例: {"click": "1", "purchase": "5", "rating": "Value"}     │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│                    数据层 (Dataset)                          │
-│  构造时:                                                     │
-│  - 解析表达式字符串 (expr.Compile)                            │
-│  - 遍历样本计算权重 (expr.Run)                                │
-│  - 存储 SampleWeights []float32                              │
-│  - Get() 返回 (indices, values, embeddings, target, weight)  │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────┐
-│                    模型层 (AFM)                              │
-│  - 接收 weight 参数                                          │
-│  - Fit() 使用 BCEWithLogits(target, output, weights)         │
-└─────────────────────────────────────────────────────────────┘
-```
-
-**设计原则：**
-- 无需 WeightExpression 抽象，直接 inline 解析
-- 数据层在构造时一次性计算所有权重
-- 模型层只接收数值型权重
-
-### 2.2 配置格式
-
-```toml
-[recommend.collaborative.feedback_weight]
-click = "1"           # 点击权重为常量 1
-favorite = "2"        # 收藏权重为常量 2
-purchase = "5"        # 购买权重为常量 5
-rating = "Value"      # 评分权重等于评分值
-view_time = "log(Value)"  # 观看时长用对数权重
-score = "Value / 5"   # 归一化评分
-```
-
-### 2.3 数据结构
-
-#### 2.3.1 配置扩展 ✅
-
-```go
-// config/config.go
-
-type DataSourceConfig struct {
-    // 现有字段...
-    
-    // 新增：feedback 权重配置
-    FeedbackWeight map[string]string `mapstructure:"feedback_weight"`
-}
-```
-
-#### 2.3.2 Dataset 扩展
-
-```go
-// model/ctr/data.go
-
-import "github.com/expr-lang/expr"
-
-type Dataset struct {
-    // 现有字段...
-    
-    // 新增：每个样本的权重
-    SampleWeights []float32
-}
-
-// 计算样本权重 (在数据集构造时调用)
-func (dataset *Dataset) ComputeWeights(feedbackWeight map[string]string, 
-                                        feedbackTypes []string, 
-                                        feedbackValues []float64) {
-    // 编译所有表达式
-    programs := make(map[string]*vm.Program)
-    for fbType, exprStr := range feedbackWeight {
-        programs[fbType], _ = expr.Compile(exprStr, expr.Env(map[string]float64{"Value": 0}))
-    }
-    
-    // 计算每个样本的权重
-    dataset.SampleWeights = make([]float32, len(feedbackTypes))
-    for i, fbType := range feedbackTypes {
-        if program, ok := programs[fbType]; ok {
-            env := map[string]float64{"Value": feedbackValues[i]}
-            result, _ := expr.Run(program, env)
-            dataset.SampleWeights[i] = float32(result.(float64))
-        } else {
-            dataset.SampleWeights[i] = 1.0  // 默认权重
-        }
-    }
-}
-
-// Get 返回样本数据，新增 weight 参数
-func (dataset *Dataset) Get(i int) ([]int32, []float32, [][]float32, float32, float32) {
-    // ...
-    return indices, values, embedding, target, dataset.SampleWeights[i]
-}
-```
-
-#### 2.3.3 AFM (模型层)
-
-```go
-// model/ctr/fm.go
-
-// AFM 不需要添加任何字段
-// 只需修改 Fit() 接收权重
-
-func (fm *AFM) Fit(ctx context.Context, trainSet, testSet dataset.CTRSplit, config *FitConfig) Score {
-    // ...
-    for i := 0; i < trainSet.Count(); i++ {
-        indices, values, embeddings, target, weight := trainSet.Get(i)
-        weights = append(weights, weight)
-        // ...
-    }
-    // 使用带权重的损失函数
-    batchLoss := nn.BCEWithLogits(batchTarget, batchOutput, batchWeights)
-}
-```
-
-### 2.4 数据流
-
-```
-1. 配置加载: FeedbackWeight = {"click": "1", "purchase": "5"}
-                    ↓
-2. Dataset 构造:
-   - 编译表达式: expr.Compile("1"), expr.Compile("5")
-   - 加载样本时记录 feedback_type 和 value
-   - 计算权重: expr.Run(program, {"Value": value})
-   - 存入 SampleWeights
-                    ↓
-3. 训练:
-   - Get(i) 返回 weight
-   - AFM 使用 BCEWithLogits(target, output, weights)
-```
-
-## 3. 实现计划
-
-### Phase 1: 表达式解析 ✅
-
-| 任务 | 文件 | 状态 |
-|------|------|------|
-| 添加 expr 依赖 | go.mod | ✅ |
-| 在 Dataset 中集成表达式解析 | model/ctr/data.go | ✅ |
-| 单元测试 | model/ctr/data_test.go | ✅ |
-
-### Phase 2: 配置扩展 ✅
-
-| 任务 | 文件 | 状态 |
-|------|------|------|
-| 添加 FeedbackWeight 配置项 | config/config.go | ✅ |
-| 解析权重表达式配置 | config/config.go | ✅ (存为string) |
-
-### Phase 3: 数据层扩展 ✅
-
-| 任务 | 文件 | 状态 |
-|------|------|------|
-| Dataset 添加 SampleWeights | model/ctr/data.go | ✅ |
-| 实现 ComputeWeights() | model/ctr/data.go | ✅ |
-| 扩展 Get() 返回 weight | model/ctr/data.go | ✅ |
-| 向后兼容处理 | model/ctr/data.go | ✅ |
-
-### Phase 4: 模型层扩展
-
-| 任务 | 文件 | 状态 |
-|------|------|------|
-| 修改 Fit() 接收权重 | model/ctr/fm.go | ⏳ |
-| 修改 fm_xla.go | model/ctr/fm_xla.go | ⏳ |
-
-### Phase 5: 测试 ✅
-
-| 任务 | 状态 |
-|------|------|
-| 表达式解析测试 | ⏳ |
-| 带权重训练测试 | ⏳ |
-| 效果对比测试 | ⏳ |
-
-## 4. expr 库使用示例
-
-```go
-package main
-
-import (
-    "fmt"
-    "github.com/expr-lang/expr"
-)
-
-func main() {
-    // 编译表达式
-    program, _ := expr.Compile("log(Value) + 1", expr.Env(map[string]float64{"Value": 0}))
-    
-    // 执行表达式
-    env := map[string]float64{"Value": 100.0}
-    result, _ := expr.Run(program, env)
-    fmt.Println(result) // 5.605...
-}
-```
-
-## 5. 向后兼容性
-
-1. **默认行为**：未配置 feedback_weight 时，所有样本权重为 1.0
-2. **未知 feedback_type**：使用默认权重 1.0
-3. **模型加载**：旧版模型无需修改
-
-## 6. 示例配置
-
-### 6.1 电商场景
-
-```toml
-[recommend.collaborative.feedback_weight]
-click = "1"
-cart = "3"
-purchase = "10"
-rating = "Value * 2"
-```
-
-### 6.2 视频场景
-
-```toml
-[recommend.collaborative.feedback_weight]
-view = "log(Value + 1)"
-like = "3"
-share = "10"
-comment = "5"
-```
-
-### 6.3 音乐场景
-
-```toml
-[recommend.collaborative.feedback_weight]
-play = "1"
-complete = "3"
-skip = "0.1"
-like = "5"
-```
-
-## 7. 提交记录
-
-| 提交 | 说明 |
-|------|------|
-| `342c609` | docs: refactor architecture - model layer should not be aware of WeightExpression |
-| `f7a0dd1` | feat: add feedback_weight config for weighted training |
-
-## 8. 参考资料
-
-- [expr-lang/expr](https://github.com/expr-lang/expr) - Go 表达式引擎
-- [BCEWithLogits Loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.binary_cross_entropy_with_logits.html)
-
-## 9. 实现状态
-
-### Phase 4: 模型层扩展 ✅
-
-**已完成：**
-- `fm.go`: 添加权重支持
-  - 收集样本权重
-  - 创建权重张量
-  - 传入 BCEWithLogits 损失函数
-
-- `dataset/dataset.go`: 扩展 CTRSplit 接口
-  - 添加 `GetWeight(i int) float32` 方法
-
-**待完成：**
-- `fm_xla.go`: GoMLX 的损失函数暂不支持样本权重
-  - 需要自定义加权损失函数或等待 GoMLX 更新
-
diff --git a/logics/weight_test.go b/logics/weight_test.go
index 4cea6214c..32ca14cbc 100644
--- a/logics/weight_test.go
+++ b/logics/weight_test.go
@@ -55,7 +55,7 @@ func TestEvaluateWeight(t *testing.T) {
 		expr      string
 		value     float64
 		want      float32
-		tolerance float32
+		tolerance float64
 	}{
 		{"constant", "5", 1.0, 5.0, 0},
 		{"value", "Value", 3.5, 3.5, 0},
diff --git a/model/ctr/model_test.go b/model/ctr/model_test.go
index 00bea3d03..97e564ba3 100644
--- a/model/ctr/model_test.go
+++ b/model/ctr/model_test.go
@@ -15,7 +15,6 @@ package ctr
 
 import (
 	"bytes"
-	"context"
 	"runtime"
 	"testing"
 
@@ -24,7 +23,6 @@ import (
 	"github.com/gorse-io/gorse/model"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 const classificationDelta = 0.01
@@ -238,5 +236,3 @@ func TestFactorizationMachines_Classification_Synthesis(t *testing.T) {
 		fitConfig.Jobs,
 	), 4)
 }
-
-

From d52c219c38f25f388ba6cc2eb17b6c67cbd19a64 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Mon, 13 Apr 2026 22:52:01 +0800
Subject: [PATCH 25/26] feat: add FeedbackWeightExpression and related tests
 for dynamic weight evaluation

---
 {logics => common/expression}/weight.go |  78 ++++-------
 common/expression/weight_test.go        | 106 +++++++++++++++
 logics/recommend.go                     |  16 +--
 logics/weight_test.go                   | 172 ------------------------
 4 files changed, 138 insertions(+), 234 deletions(-)
 rename {logics => common/expression}/weight.go (54%)
 create mode 100644 common/expression/weight_test.go
 delete mode 100644 logics/weight_test.go

diff --git a/logics/weight.go b/common/expression/weight.go
similarity index 54%
rename from logics/weight.go
rename to common/expression/weight.go
index 84bd390c4..a237578f9 100644
--- a/logics/weight.go
+++ b/common/expression/weight.go
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package logics
+package expression
 
 import (
 	"math"
@@ -21,12 +21,14 @@ import (
 	"github.com/expr-lang/expr/vm"
 )
 
-// WeightEnv returns the environment for weight expression evaluation.
-// It includes the Value variable and common math functions.
-func WeightEnv() map[string]any {
+// FeedbackWeightExpression wraps compiled weight expressions by feedback type.
+type FeedbackWeightExpression struct {
+	programs map[string]*vm.Program
+}
+
+func env(value float64) map[string]any {
 	return map[string]any{
-		"Value": 0.0,
-		// Common math functions
+		"Value": value,
 		"abs":   math.Abs,
 		"ceil":  math.Ceil,
 		"floor": math.Floor,
@@ -55,16 +57,27 @@ func WeightEnv() map[string]any {
 	}
 }
 
-// CompileWeightExpression compiles a weight expression string.
-func CompileWeightExpression(exprStr string) (*vm.Program, error) {
-	return expr.Compile(exprStr, expr.Env(WeightEnv()))
+// NewFeedbackWeightExpression compiles weight expressions and wraps them by feedback type.
+func NewFeedbackWeightExpression(feedbackWeight map[string]string) (*FeedbackWeightExpression, error) {
+	programs := make(map[string]*vm.Program, len(feedbackWeight))
+	for feedbackType, exprStr := range feedbackWeight {
+		program, err := expr.Compile(exprStr, expr.Env(env(0.0)))
+		if err != nil {
+			return nil, err
+		}
+		programs[feedbackType] = program
+	}
+	return &FeedbackWeightExpression{programs: programs}, nil
 }
 
-// EvaluateWeight evaluates a compiled weight expression with the given value.
-func EvaluateWeight(program *vm.Program, value float64) (float32, error) {
-	env := WeightEnv()
-	env["Value"] = value
-	result, err := expr.Run(program, env)
+// Evaluate evaluates the weight for the given feedback type and value.
+// If there is no expression for the feedback type, the default weight 1.0 is returned.
+func (weightExpr *FeedbackWeightExpression) Evaluate(feedbackType string, value float64) (float32, error) {
+	program, ok := weightExpr.programs[feedbackType]
+	if !ok {
+		return 1.0, nil
+	}
+	result, err := expr.Run(program, env(value))
 	if err != nil {
 		return 1.0, err
 	}
@@ -102,40 +115,3 @@ func ToFloat32(v any) (float32, error) {
 		return 1.0, nil
 	}
 }
-
-// ComputeSampleWeights computes sample weights based on feedback_weight configuration.
-// This function is used by both CTR training and item-to-item recommendation.
-// If feedbackWeight is nil or empty, nil is returned (default weight 1.0 should be used).
-func ComputeSampleWeights(feedbackWeight map[string]string, feedbackTypes []string, feedbackValues []float64) ([]float32, error) {
-	if len(feedbackWeight) == 0 || len(feedbackTypes) == 0 {
-		// No weight configuration or no feedback types, return nil for default weight 1.0
-		return nil, nil
-	}
-
-	// Compile all weight expressions
-	programs := make(map[string]*vm.Program, len(feedbackWeight))
-	for fbType, exprStr := range feedbackWeight {
-		program, err := CompileWeightExpression(exprStr)
-		if err != nil {
-			return nil, err
-		}
-		programs[fbType] = program
-	}
-
-	// Compute weight for each sample
-	weights := make([]float32, len(feedbackTypes))
-	for i, fbType := range feedbackTypes {
-		if program, ok := programs[fbType]; ok {
-			w, err := EvaluateWeight(program, feedbackValues[i])
-			if err != nil {
-				return nil, err
-			}
-			weights[i] = w
-		} else {
-			// Unknown feedback type, use default weight
-			weights[i] = 1.0
-		}
-	}
-
-	return weights, nil
-}
diff --git a/common/expression/weight_test.go b/common/expression/weight_test.go
new file mode 100644
index 000000000..8c1f7be3c
--- /dev/null
+++ b/common/expression/weight_test.go
@@ -0,0 +1,106 @@
+// Copyright 2026 gorse Project Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package expression
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewFeedbackWeightExpression(t *testing.T) {
+	t.Run("valid expressions", func(t *testing.T) {
+		weightExpr, err := NewFeedbackWeightExpression(map[string]string{
+			"click":  "1",
+			"rating": "Value * 2",
+		})
+		require.NoError(t, err)
+		require.NotNil(t, weightExpr)
+		assert.Len(t, weightExpr.programs, 2)
+	})
+
+	t.Run("invalid expression", func(t *testing.T) {
+		weightExpr, err := NewFeedbackWeightExpression(map[string]string{
+			"click": "invalid++",
+		})
+		assert.Error(t, err)
+		assert.Nil(t, weightExpr)
+	})
+}
+
+func TestFeedbackWeightExpression_Evaluate(t *testing.T) {
+	weightExpr, err := NewFeedbackWeightExpression(map[string]string{
+		"click":     "1",
+		"rating":    "Value * 2",
+		"view_time": "log1p(Value)",
+	})
+	require.NoError(t, err)
+
+	t.Run("constant expression", func(t *testing.T) {
+		got, err := weightExpr.Evaluate("click", 123)
+		require.NoError(t, err)
+		assert.Equal(t, float32(1), got)
+	})
+
+	t.Run("value expression", func(t *testing.T) {
+		got, err := weightExpr.Evaluate("rating", 3.5)
+		require.NoError(t, err)
+		assert.Equal(t, float32(7), got)
+	})
+
+	t.Run("math expression", func(t *testing.T) {
+		got, err := weightExpr.Evaluate("view_time", 99)
+		require.NoError(t, err)
+		assert.InDelta(t, float32(math.Log1p(99)), got, 0.001)
+	})
+
+	t.Run("missing feedback type returns default", func(t *testing.T) {
+		got, err := weightExpr.Evaluate("purchase", 5)
+		require.NoError(t, err)
+		assert.Equal(t, float32(1), got)
+	})
+}
+
+func TestToFloat32(t *testing.T) {
+	tests := []struct {
+		name  string
+		input any
+		want  float32
+	}{
+		{"float32", float32(1.5), float32(1.5)},
+		{"float64", float64(2.5), float32(2.5)},
+		{"int", int(3), float32(3)},
+		{"int8", int8(4), float32(4)},
+		{"int16", int16(5), float32(5)},
+		{"int32", int32(6), float32(6)},
+		{"int64", int64(7), float32(7)},
+		{"uint", uint(8), float32(8)},
+		{"uint8", uint8(9), float32(9)},
+		{"uint16", uint16(10), float32(10)},
+		{"uint32", uint32(11), float32(11)},
+		{"uint64", uint64(12), float32(12)},
+		{"unsupported type", "invalid", float32(1.0)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ToFloat32(tt.input)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
diff --git a/logics/recommend.go b/logics/recommend.go
index 298ec8c29..87338f70b 100644
--- a/logics/recommend.go
+++ b/logics/recommend.go
@@ -20,7 +20,6 @@ import (
 	"time"
 
 	mapset "github.com/deckarep/golang-set/v2"
-	"github.com/expr-lang/expr/vm"
 	"github.com/gorse-io/gorse/common/expression"
 	"github.com/gorse-io/gorse/common/heap"
 	"github.com/gorse-io/gorse/common/util"
@@ -251,14 +250,9 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 			}
 		}
 		// compile feedback weight expressions
-		weightPrograms := make(map[string]*vm.Program, len(r.config.DataSource.FeedbackWeight))
-		for fbType, exprStr := range r.config.DataSource.FeedbackWeight {
-			program, err := CompileWeightExpression(exprStr)
-			if err != nil {
-				// log error but continue with default weight
-				continue
-			}
-			weightPrograms[fbType] = program
+		weightExpr, err := expression.NewFeedbackWeightExpression(r.config.DataSource.FeedbackWeight)
+		if err != nil {
+			weightExpr = nil
 		}
 		// collect scores with weighted aggregation
 		scores := make(map[string]float64)
@@ -267,8 +261,8 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 		for _, feedback := range userFeedback {
 			// compute feedback weight
 			fbWeight := 1.0 // default weight
-			if program, ok := weightPrograms[feedback.FeedbackType]; ok {
-				w, err := EvaluateWeight(program, feedback.Value)
+			if weightExpr != nil {
+				w, err := weightExpr.Evaluate(feedback.FeedbackType, feedback.Value)
 				if err == nil {
 					fbWeight = float64(w)
 				}
diff --git a/logics/weight_test.go b/logics/weight_test.go
deleted file mode 100644
index 32ca14cbc..000000000
--- a/logics/weight_test.go
+++ /dev/null
@@ -1,172 +0,0 @@
-// Copyright 2026 gorse Project Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package logics
-
-import (
-	"math"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestCompileWeightExpression(t *testing.T) {
-	tests := []struct {
-		name    string
-		expr    string
-		wantErr bool
-	}{
-		{"constant", "1", false},
-		{"value", "Value", false},
-		{"expression", "Value * 2 + 1", false},
-		{"math function", "log(Value)", false},
-		{"complex", "sqrt(Value) / 10", false},
-		{"invalid", "invalid++", true},
-		{"unknown function", "unknown(Value)", true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := CompileWeightExpression(tt.expr)
-			if tt.wantErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
-func TestEvaluateWeight(t *testing.T) {
-	tests := []struct {
-		name      string
-		expr      string
-		value     float64
-		want      float32
-		tolerance float64
-	}{
-		{"constant", "5", 1.0, 5.0, 0},
-		{"value", "Value", 3.5, 3.5, 0},
-		{"expression", "Value * 2", 5.0, 10.0, 0},
-		{"log", "log(Value)", math.E, 1.0, 0.001},
-		{"sqrt", "sqrt(Value)", 16.0, 4.0, 0},
-		{"abs", "abs(Value)", -5.0, 5.0, 0},
-		{"complex", "log10(Value)", 1000.0, 3.0, 0.001},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			program, err := CompileWeightExpression(tt.expr)
-			require.NoError(t, err)
-			got, err := EvaluateWeight(program, tt.value)
-			require.NoError(t, err)
-			if tt.tolerance > 0 {
-				assert.InDelta(t, tt.want, got, tt.tolerance)
-			} else {
-				assert.Equal(t, tt.want, got)
-			}
-		})
-	}
-}
-
-func TestEvaluateWeight_EdgeCases(t *testing.T) {
-	t.Run("negative value", func(t *testing.T) {
-		program, err := CompileWeightExpression("abs(Value)")
-		require.NoError(t, err)
-		got, err := EvaluateWeight(program, -10.0)
-		require.NoError(t, err)
-		assert.Equal(t, float32(10.0), got)
-	})
-
-	t.Run("zero value", func(t *testing.T) {
-		program, err := CompileWeightExpression("Value + 1")
-		require.NoError(t, err)
-		got, err := EvaluateWeight(program, 0.0)
-		require.NoError(t, err)
-		assert.Equal(t, float32(1.0), got)
-	})
-}
-
-func TestComputeSampleWeights(t *testing.T) {
-	t.Run("no weight config", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(nil, []string{"click"}, []float64{1.0})
-		assert.NoError(t, err)
-		assert.Nil(t, weights)
-	})
-
-	t.Run("empty weight config", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(map[string]string{}, []string{"click"}, []float64{1.0})
-		assert.NoError(t, err)
-		assert.Nil(t, weights)
-	})
-
-	t.Run("no feedback types", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(map[string]string{"click": "1"}, nil, nil)
-		assert.NoError(t, err)
-		assert.Nil(t, weights)
-	})
-
-	t.Run("constant weights", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(
-			map[string]string{"click": "1", "purchase": "5"},
-			[]string{"click", "purchase", "click"},
-			[]float64{1.0, 1.0, 1.0},
-		)
-		assert.NoError(t, err)
-		assert.Equal(t, []float32{1.0, 5.0, 1.0}, weights)
-	})
-
-	t.Run("value-based weights", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(
-			map[string]string{"rating": "Value"},
-			[]string{"rating", "rating", "rating"},
-			[]float64{3.0, 4.0, 5.0},
-		)
-		assert.NoError(t, err)
-		assert.Equal(t, []float32{3.0, 4.0, 5.0}, weights)
-	})
-
-	t.Run("expression weights", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(
-			map[string]string{"view_time": "log1p(Value)"},
-			[]string{"view_time", "view_time", "view_time"},
-			[]float64{99.0, 999.0, 9.0},
-		)
-		assert.NoError(t, err)
-		require.NotNil(t, weights)
-		assert.InDelta(t, float32(math.Log1p(99.0)), weights[0], 0.001)
-		assert.InDelta(t, float32(math.Log1p(999.0)), weights[1], 0.001)
-		assert.InDelta(t, float32(math.Log1p(9.0)), weights[2], 0.001)
-	})
-
-	t.Run("unknown feedback type uses default", func(t *testing.T) {
-		weights, err := ComputeSampleWeights(
-			map[string]string{"click": "1", "purchase": "5"},
-			[]string{"click", "unknown", "purchase"},
-			[]float64{1.0, 1.0, 1.0},
-		)
-		assert.NoError(t, err)
-		assert.Equal(t, []float32{1.0, 1.0, 5.0}, weights)
-	})
-
-	t.Run("invalid expression returns error", func(t *testing.T) {
-		_, err := ComputeSampleWeights(
-			map[string]string{"click": "invalid++"},
-			[]string{"click"},
-			[]float64{1.0},
-		)
-		assert.Error(t, err)
-	})
-}

From 466f96343089d8f22522190b2b94d6ed30ee7205 Mon Sep 17 00:00:00 2001
From: Zhenghao Zhang <zhangzhenghao@hotmail.com>
Date: Mon, 13 Apr 2026 23:18:24 +0800
Subject: [PATCH 26/26] feat: integrate FeedbackWeightExpression into
 Recommender and simplify Evaluate method

---
 common/expression/weight.go      | 40 ++++++++++++++++++--------------
 common/expression/weight_test.go | 15 ++++--------
 logics/recommend.go              | 21 ++++++-----------
 3 files changed, 35 insertions(+), 41 deletions(-)

diff --git a/common/expression/weight.go b/common/expression/weight.go
index a237578f9..cd3293993 100644
--- a/common/expression/weight.go
+++ b/common/expression/weight.go
@@ -19,6 +19,8 @@ import (
 
 	"github.com/expr-lang/expr"
 	"github.com/expr-lang/expr/vm"
+	"github.com/gorse-io/gorse/common/log"
+	"go.uber.org/zap"
 )
 
 // FeedbackWeightExpression wraps compiled weight expressions by feedback type.
@@ -72,46 +74,50 @@ func NewFeedbackWeightExpression(feedbackWeight map[string]string) (*FeedbackWei
 
 // Evaluate evaluates the weight for the given feedback type and value.
 // If there is no expression for the feedback type, the default weight 1.0 is returned.
-func (weightExpr *FeedbackWeightExpression) Evaluate(feedbackType string, value float64) (float32, error) {
+func (weightExpr *FeedbackWeightExpression) Evaluate(feedbackType string, value float64) float32 {
 	program, ok := weightExpr.programs[feedbackType]
 	if !ok {
-		return 1.0, nil
+		return 1.0
 	}
 	result, err := expr.Run(program, env(value))
 	if err != nil {
-		return 1.0, err
+		log.Logger().Error("failed to evaluate weight expression",
+			zap.String("feedback_type", feedbackType),
+			zap.Float64("value", value),
+			zap.Error(err))
+		return 1.0
 	}
 	return ToFloat32(result)
 }
 
 // ToFloat32 converts various numeric types to float32.
-func ToFloat32(v any) (float32, error) {
+func ToFloat32(v any) float32 {
 	switch val := v.(type) {
 	case float32:
-		return val, nil
+		return val
 	case float64:
-		return float32(val), nil
+		return float32(val)
 	case int:
-		return float32(val), nil
+		return float32(val)
 	case int8:
-		return float32(val), nil
+		return float32(val)
 	case int16:
-		return float32(val), nil
+		return float32(val)
 	case int32:
-		return float32(val), nil
+		return float32(val)
 	case int64:
-		return float32(val), nil
+		return float32(val)
 	case uint:
-		return float32(val), nil
+		return float32(val)
 	case uint8:
-		return float32(val), nil
+		return float32(val)
 	case uint16:
-		return float32(val), nil
+		return float32(val)
 	case uint32:
-		return float32(val), nil
+		return float32(val)
 	case uint64:
-		return float32(val), nil
+		return float32(val)
 	default:
-		return 1.0, nil
+		return 1.0
 	}
 }
diff --git a/common/expression/weight_test.go b/common/expression/weight_test.go
index 8c1f7be3c..ad7b446a7 100644
--- a/common/expression/weight_test.go
+++ b/common/expression/weight_test.go
@@ -51,26 +51,22 @@ func TestFeedbackWeightExpression_Evaluate(t *testing.T) {
 	require.NoError(t, err)
 
 	t.Run("constant expression", func(t *testing.T) {
-		got, err := weightExpr.Evaluate("click", 123)
-		require.NoError(t, err)
+		got := weightExpr.Evaluate("click", 123)
 		assert.Equal(t, float32(1), got)
 	})
 
 	t.Run("value expression", func(t *testing.T) {
-		got, err := weightExpr.Evaluate("rating", 3.5)
-		require.NoError(t, err)
+		got := weightExpr.Evaluate("rating", 3.5)
 		assert.Equal(t, float32(7), got)
 	})
 
 	t.Run("math expression", func(t *testing.T) {
-		got, err := weightExpr.Evaluate("view_time", 99)
-		require.NoError(t, err)
+		got := weightExpr.Evaluate("view_time", 99)
 		assert.InDelta(t, float32(math.Log1p(99)), got, 0.001)
 	})
 
 	t.Run("missing feedback type returns default", func(t *testing.T) {
-		got, err := weightExpr.Evaluate("purchase", 5)
-		require.NoError(t, err)
+		got := weightExpr.Evaluate("purchase", 5)
 		assert.Equal(t, float32(1), got)
 	})
 }
@@ -98,8 +94,7 @@ func TestToFloat32(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := ToFloat32(tt.input)
-			require.NoError(t, err)
+			got := ToFloat32(tt.input)
 			assert.Equal(t, tt.want, got)
 		})
 	}
diff --git a/logics/recommend.go b/logics/recommend.go
index 87338f70b..65854affc 100644
--- a/logics/recommend.go
+++ b/logics/recommend.go
@@ -43,6 +43,7 @@ type Recommender struct {
 	config      config.RecommendConfig
 	cacheClient cache.Database
 	dataClient  data.Database
+	weightExpr  *expression.FeedbackWeightExpression
 
 	online       bool
 	coldstart    bool
@@ -55,6 +56,10 @@ type Recommender struct {
 type RecommenderFunc func(ctx context.Context) ([]cache.Score, string, error)
 
 func NewRecommender(config config.RecommendConfig, cacheClient cache.Database, dataClient data.Database, online bool, userId string, categories []string) (*Recommender, error) {
+	weightExpr, err := expression.NewFeedbackWeightExpression(config.DataSource.FeedbackWeight)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
 	// Load user feedback
 	userFeedback, err := dataClient.GetUserFeedback(context.Background(), userId, new(time.Now()))
 	if err != nil {
@@ -78,6 +83,7 @@ func NewRecommender(config config.RecommendConfig, cacheClient cache.Database, d
 		config:       config,
 		cacheClient:  cacheClient,
 		dataClient:   dataClient,
+		weightExpr:   weightExpr,
 		userId:       userId,
 		userFeedback: userFeedback,
 		online:       online,
@@ -249,25 +255,12 @@ func (r *Recommender) recommendItemToItem(name string) RecommenderFunc {
 				}
 			}
 		}
-		// compile feedback weight expressions
-		weightExpr, err := expression.NewFeedbackWeightExpression(r.config.DataSource.FeedbackWeight)
-		if err != nil {
-			weightExpr = nil
-		}
 		// collect scores with weighted aggregation
 		scores := make(map[string]float64)
 		categories := make(map[string][]string)
 		digests := mapset.NewSet[string]()
 		for _, feedback := range userFeedback {
-			// compute feedback weight
-			fbWeight := 1.0 // default weight
-			if weightExpr != nil {
-				w, err := weightExpr.Evaluate(feedback.FeedbackType, feedback.Value)
-				if err == nil {
-					fbWeight = float64(w)
-				}
-			}
-
+			fbWeight := float64(r.weightExpr.Evaluate(feedback.FeedbackType, feedback.Value))
 			similarItems, err := r.cacheClient.SearchScores(ctx, cache.ItemToItem, cache.Key(name, feedback.ItemId), r.categories, 0, r.config.CacheSize)
 			if err != nil {
 				return nil, "", errors.Trace(err)