Elasticsearch simple term query gives strange scores - elasticsearch

Question

Elasticsearch version: 5.0.2
I populate my index with:
{_id: 1, tags: ['plop', 'plip', 'plup']},
{_id: 2, tags: ['plop', 'plup']},
{_id: 3, tags: ['plop']},
{_id: 4, tags: ['plap', 'plep']},
{_id: 5, tags: ['plop', 'plip', 'plup']},
{_id: 6, tags: ['plup', 'plip']},
{_id: 7, tags: ['plop', 'plip']}
Then, I would like to retrieve the max relevant rows for tags plop and plip:
query: {
bool: {
should: [
{term: {tags: {value:'plop', _name: 'plop'}}},
{term: {tags: {value:'plip', _name: 'plip'}}}
]
}
}
which is equivalent to (but I used the former one to debug):
query: {
bool: {
should: [
{terms: {tags: ['plop', 'plip']}}
]
}
}
Then, I find really strange scores:
[
{ id: '2', score: 0.88002616, tags: [ 'plop', 'plup' ] },
{ id: '6', score: 0.88002616, tags: [ 'plup', 'plip' ] },
{ id: '5', score: 0.5063205, tags: [ 'plop', 'plip', 'plup' ] },
{ id: '7', score: 0.3610978, tags: [ 'plop', 'plip' ] },
{ id: '1', score: 0.29277915, tags: [ 'plop', 'plip', 'plup' ] },
{ id: '3', score: 0.2876821, tags: [ 'plop' ] }
]
Here is the detail of the response:
{
"took": 1,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"failed": 0
},
"hits": {
"total": 6,
"max_score": 0.88002616,
"hits": [
{
"_index": "myindex",
"_type": "mytype",
"_id": "2",
"_score": 0.88002616,
"_source": {
"tags": [
"plop",
"plup"
]
},
"matched_queries": [
"plop"
]
},
{
"_index": "myindex",
"_type": "mytype",
"_id": "6",
"_score": 0.88002616,
"_source": {
"tags": [
"plup",
"plip"
]
},
"matched_queries": [
"plip"
]
},
{
"_index": "myindex",
"_type": "mytype",
"_id": "5",
"_score": 0.5063205,
"_source": {
"tags": [
"plop",
"plip",
"plup"
]
},
"matched_queries": [
"plop",
"plip"
]
},
{
"_index": "myindex",
"_type": "mytype",
"_id": "7",
"_score": 0.3610978,
"_source": {
"tags": [
"plop",
"plip"
]
},
"matched_queries": [
"plop",
"plip"
]
},
{
"_index": "myindex",
"_type": "mytype",
"_id": "1",
"_score": 0.29277915,
"_source": {
"tags": [
"plop",
"plip",
"plup"
]
},
"matched_queries": [
"plop",
"plip"
]
},
{
"_index": "myindex",
"_type": "mytype",
"_id": "3",
"_score": 0.2876821,
"_source": {
"tags": [
"plop"
]
},
"matched_queries": [
"plop"
]
}
]
}
}
So, two questions:
Why a row maching only one query (id 2 and 6) have a better score than one matching two (id 1, 5 and 7)?
Why two rows having the same tags can have different scores? (id 1 and 5)
Did I miss something?

Answer 1

Ok i figure out your real problem. Elasitcsearch by default use 5 shards to store your index data, and if you have small number it can matter in case computing your _score value. Some theory about shards: https://www.elastic.co/guide/en/elasticsearch/reference/current/_basic_concepts.html
Why does it matter? Because for better performance each shard make _score computing on his own data. But while computing score value elasticsearch use IDF/TF algorithm which relies on total number of docs and frequency of searching terms (IN SHARD) (https://www.elastic.co/guide/en/elasticsearch/guide/current/scoring-theory.html)
To solve this problem you can create index with one shard like this:
{
"settings": {
"number_of_shards" : 1,
"number_of_replicas" : 0
},
"mappings": {
"my_type": {
"properties": {
"tags": {
"type": "keyword"
}
}
}
}
}
You can verify my theory using ?explain in your search query:
http://localhost:9200/test1/my_type/_search?explain
Or you can read this example if you need more ;)
Those are my results for your query: ["plop", "plip"]
{
"took": 5,
"timed_out": false,
"_shards": {
"total": 5,
"successful": 5,
"failed": 0
},
"hits": {
"total": 6,
"max_score": 0.9808292,
"hits": [
{
"_index": "test",
"_type": "my_type",
"_id": "2",
"_score": 0.9808292,
"_source": {
"tags": [
"plop",
"plup"
]
}
},
{
"_index": "test",
"_type": "my_type",
"_id": "6",
"_score": 0.9808292,
"_source": {
"tags": [
"plup",
"plip"
]
}
},
{
"_index": "test",
"_type": "my_type",
"_id": "5",
"_score": 0.5753642,
"_source": {
"tags": [
"plop",
"plip",
"plup"
]
}
},
{
"_index": "test",
"_type": "my_type",
"_id": "1",
"_score": 0.36464313,
"_source": {
"tags": [
"plop",
"plip",
"plup"
]
}
},
{
"_index": "test",
"_type": "my_type",
"_id": "7",
"_score": 0.36464313,
"_source": {
"tags": [
"plop",
"plip"
]
}
},
{
"_index": "test",
"_type": "my_type",
"_id": "3",
"_score": 0.2876821,
"_source": {
"tags": [
"plop"
]
}
}
]
}
}
Why is document with plop,plip,plup as third? Check explain for this one:
"_shard": "[test][1]",
"_node": "LjGrgIa7QgiPlEvMxqKOdA",
"_index": "test",
"_type": "my_type",
"_id": "5",
"_score": 0.5753642,
"_source": {
"tags": [
"plop",
"plip",
"plup"
]
},
This is the only one doc in this shard: test[1] (i verified in other returned docs) !! So IDF value is equal to '1' which is the highest possible value. Score = TF/IDF (so for lower IDF, the score is higher). Check how this 0.5753642 score is computed for this doc:
"value": 0.2876821,
"description": "weight(tags:plop...
"details": [
{
"value": 0.2876821,
"description": "idf(docFreq=1, docCount=1)",
sum with
{
"value": 0.2876821,
"description": "weight(tags:plip..
"value": 0.2876821,
"description": "idf(docFreq=1, docCount=1)",
"details": []
},

Answer 2

The problem I had is nicely explained in the answer of jgr.
The solution I've found is to use dfs_query_then_fetch as search type.
Here is the resulting query with the JavaScript client:
body: {
query: {
bool: {
should: [
{terms: {tags: ['plop', 'plip']}}
]
}
},
searchType: 'dfs_query_then_fetch'
}
Note that with more data in the index type, this certainly wouldn't be needed because scores would balance naturally between shards.