Elasticsearch Painless自定义点积计算结果不准确问题排查

在使用Painless脚本实现自定义点积计算时，出现结果不符合预期的情况：预期点积得分为6.0，但实际返回4.0；当移除向量中的0元素后，得分恢复为正确的6.0。需确认script_score是否存在额外计算逻辑。

索引映射 #

PUT /custom_dot_product
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "level1": {
        "type": "nested",
        "properties": {
          "level2": {
            "properties": {
              "vector_3": {
                "type": "long"
              }
            }
          }
        }
      }
    }
  }
}

文档数据 #

POST /custom_dot_product/_doc/1
{
  "level1": {
    "level2": {
      "vector_3": [
       2,
       2,
       2,
       0
      ]
    }
  }
}

查询语句 #

POST custom_dot_product/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "nested": {
            "path": "level1",
            "query": {
              "function_score": {
                "query": {
                  "match_all": {}
                },
                "script_score": {
                  "script": {
                    "source": " if(doc['level1.level2.vector_3'].size()>0){ double result = 0.0; for (int i = 0; i < params.user_vector.length; i++) result += params.user_vector[i] * doc['level1.level2.vector_3'][i]; return result;} ",
                    "params": {
                      "user_vector": [
                        1,
                        1,
                        1,
                        0
                      ]
                    }
                  }
                },
                "boost_mode": "replace"
              }
            },
            "inner_hits": {
              "sort": []
            }
          }
        }
      ]
    }
  }
}

查询输出 #

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 4.0,
    "hits" : [
      {
        "_index" : "knn_dot_product_poc",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 4.0,
        "_source" : {
          "level1" : {
            "level2" : {
              "vector_3" : [
                2,
                2,
                2,
                0
              ]
            }
          }
        },
        "inner_hits" : {
          "level1" : {
            "hits" : {
              "total" : {
                "value" : 1,
                "relation" : "eq"
              },
              "max_score" : 4.0,
              "hits" : [
                {
                  "_index" : "knn_dot_product_poc",
                  "_type" : "_doc",
                  "_id" : "1",
                  "_nested" : {
                    "field" : "level1",
                    "offset" : 0
                  },
                  "_score" : 4.0,
                  "_source" : {
                    "level2" : {
                      "vector_3" : [
                        2,
                        2,
                        2,
                        0
                      ]
                    }
                  }
                }
              ]
            }
          }
        }
      }
    ]
  }
}

问题原因及解决方案 #

原因 #

script_score本身没有额外计算，问题出在字段存储和访问方式：

1. 你将vector_3定义为long类型的单值字段，但传入了数组数据，Elasticsearch会自动将其视为多值字段存储。
2. Lucene对多值数值字段会自动按升序排序，导致原始数组[2,2,2,0]被存储为[0,2,2,2]。
3. 脚本中通过doc['level1.level2.vector_3'][i]访问时，使用的是排序后的数组，和你的user_vector对应位置元素相乘后总和为1*0 +1*2 +1*2 +0*2 =4.0，与预期不符。
4. 当移除0元素后，数组[2,2,2]排序后顺序不变，计算结果自然正确。

解决方案 #

有两种可行方案，根据你的需求选择：

方案1：使用_source访问原始顺序的数组

修改脚本，直接从原始文档_source中读取数组（保留原始顺序），注意在nested查询上下文里，_source指向当前嵌套的level1对象：

"script": {
  "source": "def vector = params._source.level2.vector_3; if(vector != null && vector.length > 0) { double result = 0.0; for(int i = 0; i < params.user_vector.length && i < vector.length; i++) { result += params.user_vector[i] * vector[i]; } return result; } return 0.0;",
  "params": {
    "user_vector": [1,1,1,0]
  }
}

注意：使用_source会比doc对象性能稍差，因为需要加载原始文档内容。

方案2：使用专门的向量类型dense_vector

如果你的场景是向量计算，推荐使用Elasticsearch原生的dense_vector类型，它专为向量运算设计，支持保留顺序，且性能更优：

1. 修改索引映射：

PUT /custom_dot_product
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "level1": {
        "type": "nested",
        "properties": {
          "level2": {
            "properties": {
              "vector_3": {
                "type": "dense_vector",
                "dims": 4
              }
            }
          }
        }
      }
    }
  }
}

2. 插入文档（数组格式不变）：

POST /custom_dot_product/_doc/1
{
  "level1": {
    "level2": {
      "vector_3": [2,2,2,0]
    }
  }
}

3. 点积查询脚本：

"script": {
  "source": "return doc['level1.level2.vector_3'].dotProduct(params.user_vector);",
  "params": {
    "user_vector": [1,1,1,0]
  }
}

这种方式既保留了数组顺序，又利用了Elasticsearch的优化，是向量计算场景的最佳实践。

内容的提问来源于stack exchange，提问作者Akhilendra