専門的なクエリ - スクリプトスコア（Script score） - 《Elasticsearchガイドv8.15》日本語

スクリプトスコアクエリ
script_scoreのトップレベルパラメータ
ノート

スクリプトスコアクエリ

カスタムスコアを返されたドキュメントに提供するために、スクリプトを使用します。


## 例のリクエスト
次の`````script_score`````クエリは、返された各ドキュメントに`````my-int`````フィールドの値を`````10`````で割ったスコアを割り当てます。
#### Python
``````python
resp = client.search(
   query={
   "script_score": {
   "query": {
   "match": {
   "message": "elasticsearch"
   }
   },
   "script": {
   "source": "doc['my-int'].value / 10 "
   }
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  body: {
   query: {
   script_score: {
   query: {
   match: {
   message: 'elasticsearch'
   }
   },
   script: {
   source: "doc['my-int'].value / 10 "
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  query: {
   script_score: {
   query: {
   match: {
   message: "elasticsearch",
   },
   },
   script: {
   source: "doc['my-int'].value / 10 ",
   },
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "script_score": {
   "query": {
   "match": { "message": "elasticsearch" }
   },
   "script": {
   "source": "doc['my-int'].value / 10 "
   }
   }
  }
}

script_scoreのトップレベルパラメータ

query
(必須、クエリオブジェクト) ドキュメントを返すために使用されるクエリ。
script
(必須、スクリプトオブジェクト) queryによって返されたドキュメントのスコアを計算するために使用されるスクリプト。
script_scoreクエリからの最終的な関連スコアは負の値にはできません。特定の検索最適化をサポートするために、Luceneはスコアが正または0であることを要求します。
min_score
(オプション、浮動小数点) この浮動小数点数よりもスコアが低いドキュメントは検索結果から除外されます。
boost
(オプション、浮動小数点) scriptによって生成されたドキュメントのスコアはboostで乗算され、最終的なドキュメントのスコアが生成されます。デフォルトは1.0です。

ノート

スクリプト内での関連スコアの使用

スクリプト内で、ドキュメントの現在の関連スコアを表す_score変数にアクセスできます。

事前定義された関数

利用可能なペインレス関数のいずれかをscriptで使用できます。また、スコアリングをカスタマイズするために次の事前定義された関数を使用できます：

これらの事前定義された関数を使用することをお勧めします。これらの関数はElasticsearchの内部メカニズムからの効率を活用します。

飽和

saturation(value,k) = value/(k + value)

Js

"script" : {
   "source" : "saturation(doc['my-int'].value, 1)"
}

シグモイド

sigmoid(value, k, a) = value^a/ (k^a + value^a)

Js

"script" : {
   "source" : "sigmoid(doc['my-int'].value, 2, 1)"
}

ランダムスコア関数


`````randomScore`````関数は次の構文を持ちます：`````randomScore(<seed>, <fieldName>)`````。必須パラメータとして整数値の`````seed`````があり、オプションパラメータとして文字列値の`````fieldName`````があります。
#### Js
``````js
"script" : {
   "source" : "randomScore(100, '_seq_no')"
}
`


#### Js
``````js
"script" : {
   "source" : "randomScore(100)"
}
`

同じシャード内にあり、フィールドの値が同じドキュメントは同じスコアを取得するため、通常はシャード全体でユニークな値を持つフィールドを使用することが望ましいです。良いデフォルトの選択肢は_seq_noフィールドを使用することですが、唯一の欠点は、ドキュメントが更新されるとスコアが変わることです。なぜなら、更新操作も_seq_noフィールドの値を更新するからです。

数値フィールドの減衰関数

減衰関数についてはこちらで詳しく読むことができます。

double decayNumericLinear(double origin, double scale, double offset, double decay, double docValue)
double decayNumericExp(double origin, double scale, double offset, double decay, double docValue)
double decayNumericGauss(double origin, double scale, double offset, double decay, double docValue)

Js

"script" : {
   "source" : "decayNumericLinear(params.origin, params.scale, params.offset, params.decay, doc['dval'].value)",
   "params": {
   "origin": 20,
   "scale": 10,
   "decay" : 0.5,
   "offset" : 0
   }
}


	`params`を使用すると、パラメータが変更されてもスクリプトを1回だけコンパイルできます。

地理フィールドの減衰関数

double decayGeoLinear(String originStr, String scaleStr, String offsetStr, double decay, GeoPoint docValue)
double decayGeoExp(String originStr, String scaleStr, String offsetStr, double decay, GeoPoint docValue)
double decayGeoGauss(String originStr, String scaleStr, String offsetStr, double decay, GeoPoint docValue)

Js

"script" : {
   "source" : "decayGeoExp(params.origin, params.scale, params.offset, params.decay, doc['location'].value)",
   "params": {
   "origin": "40, -70.12",
   "scale": "200km",
   "offset": "0km",
   "decay" : 0.2
   }
}

日付フィールドの減衰関数

double decayDateLinear(String originStr, String scaleStr, String offsetStr, double decay, JodaCompatibleZonedDateTime docValueDate)
double decayDateExp(String originStr, String scaleStr, String offsetStr, double decay, JodaCompatibleZonedDateTime docValueDate)
double decayDateGauss(String originStr, String scaleStr, String offsetStr, double decay, JodaCompatibleZonedDateTime docValueDate)

Js

"script" : {
   "source" : "decayDateGauss(params.origin, params.scale, params.offset, params.decay, doc['date'].value)",
   "params": {
   "origin": "2008-01-01T01:00:00Z",
   "scale": "1h",
   "offset" : "0",
   "decay" : 0.5
   }
}

日付の減衰関数は、デフォルト形式およびデフォルトタイムゾーンの日付に制限されています。また、nowとの計算はサポートされていません。

ベクトルフィールドの関数

ベクトルフィールドの関数はscript_scoreクエリを通じてアクセスできます。

高価なクエリを許可する

スクリプトスコアクエリは、search.allow_expensive_queriesがfalseに設定されている場合、実行されません。

より高速な代替手段


-  一部の静的フィールドでドキュメントをブーストしたい場合は、[`````rank_feature`````](/read/elasticsearch-8-15/c374b3493be80889.md)クエリを使用します。  
-  日付や地理的ポイントに近いドキュメントをブーストしたい場合は、[`````distance_feature`````](/read/elasticsearch-8-15/7310ef6f3c063975.md)クエリを使用します。
### 関数スコアクエリからの移行
`````script_score`````クエリを[`````function_score`````](/read/elasticsearch-8-15/516b6d3b74ec50ab.md)クエリの代わりに使用することをお勧めします。`````script_score`````クエリのシンプルさのためです。  
`````function_score`````クエリの次の関数を`````script_score`````クエリを使用して実装できます：  
-  [`````script_score`````](2ffee97f686b4ace.md#script-score)  
-  [`````weight`````](2ffee97f686b4ace.md#weight)  
-  [`````random_score`````](2ffee97f686b4ace.md#random-score)  
-  [`````field_value_factor`````](2ffee97f686b4ace.md#field-value-factor)  
-  [`````decay`````関数](2ffee97f686b4ace.md#decay-functions)
#### script_score
Function Scoreクエリの`````script_score`````で使用したものを、Script Scoreクエリにコピーできます。ここに変更はありません。
#### weight
`````weight`````関数は、次のスクリプトを通じてScript Scoreクエリで実装できます：
#### Js
``````js
"script" : {
   "source" : "params.weight * _score",
   "params": {
   "weight": 2
   }
}
`

random_score

[randomScore]関数を、ランダムスコア関数で説明されているように使用します。

field_value_factor


#### Js
``````js
"script" : {
   "source" : "Math.log10(doc['field'].value * params.factor)",
   "params" : {
   "factor" : 5
   }
}
`

ドキュメントにフィールドfieldがない場合に値が欠落しているかどうかを確認するには、doc['field'].size() == 0を使用できます。たとえば、このスクリプトは、ドキュメントにフィールドfieldがない場合に値1を使用します：

Js

"script" : {
   "source" : "Math.log10((doc['field'].size() == 0 ? 1 : doc['field'].value()) * params.factor)",
   "params" : {
   "factor" : 5
   }
}

この表は、field_value_factor修飾子がスクリプトを通じてどのように実装できるかを示しています：

修飾子	Script Scoreでの実装
`none`	-
`log`	`Math.log10(doc['f'].value)`
`log1p`	`Math.log10(doc['f'].value + 1)`
`log2p`	`Math.log10(doc['f'].value + 2)`
`ln`	`Math.log(doc['f'].value)`
`ln1p`	`Math.log(doc['f'].value + 1)`
`ln2p`	`Math.log(doc['f'].value + 2)`
`square`	`Math.pow(doc['f'].value, 2)`
`sqrt`	`Math.sqrt(doc['f'].value)`
`reciprocal`	`1.0 / doc['f'].value`

減衰関数


### ベクトルフィールドの関数
ベクトル関数の計算中、すべての一致するドキュメントが線形スキャンされます。したがって、一致するドキュメントの数に応じてクエリ時間が線形に増加することを期待してください。このため、`````query`````パラメータで一致するドキュメントの数を制限することをお勧めします。  
利用可能なベクトル関数とベクトルアクセスメソッドのリストは次のとおりです：  
- 1*.*  [`````cosineSimilarity`````](2ffee97f686b4ace.md#vector-functions-cosine) – コサイン類似度を計算  
- 2*.*  [`````dotProduct`````](2ffee97f686b4ace.md#vector-functions-dot-product) – ドット積を計算  
- 3*.*  [`````l1norm`````](2ffee97f686b4ace.md#vector-functions-l1) – L1距離を計算  
- 4*.*  [`````hamming`````](2ffee97f686b4ace.md#vector-functions-hamming) – ハミング距離を計算  
- 5*.*  [`````l2norm`````](2ffee97f686b4ace.md#vector-functions-l2) - L2距離を計算  
- 6*.*  [`````doc[<field>].vectorValue`````](2ffee97f686b4ace.md#vector-functions-accessing-vectors) – ベクトルの値を浮動小数点の配列として返す  
- 7*.*  [`````doc[<field>].magnitude`````](2ffee97f686b4ace.md#vector-functions-accessing-vectors) – ベクトルの大きさを返す
`````cosineSimilarity`````および`````dotProduct`````関数は`````bit`````ベクトルにはサポートされていません。  
密なベクトルにアクセスする推奨方法は、`````cosineSimilarity`````、`````dotProduct`````、`````l1norm`````または`````l2norm`````関数を通じてです。ただし、これらの関数はスクリプトごとに1回だけ呼び出す必要があります。たとえば、ドキュメントベクトルと複数の他のベクトルとの類似度を計算するためにループ内でこれらの関数を使用しないでください。その機能が必要な場合は、[ベクトル値に直接アクセスする](2ffee97f686b4ace.md#vector-functions-accessing-vectors)ことによってこれらの関数を再実装してください。  
`````dense_vector`````マッピングを持つインデックスを作成し、いくつかのドキュメントをインデックスに追加しましょう。
#### Python
``````python
resp = client.indices.create(
   index="my-index-000001",
   mappings={
   "properties": {
   "my_dense_vector": {
   "type": "dense_vector",
   "index": False,
   "dims": 3
   },
   "my_byte_dense_vector": {
   "type": "dense_vector",
   "index": False,
   "dims": 3,
   "element_type": "byte"
   },
   "status": {
   "type": "keyword"
   }
   }
   },
)
print(resp)
resp1 = client.index(
   index="my-index-000001",
   id="1",
   document={
   "my_dense_vector": [
            0.5,
   10,
   6
   ],
   "my_byte_dense_vector": [
   0,
   10,
   6
   ],
   "status": "published"
   },
)
print(resp1)
resp2 = client.index(
   index="my-index-000001",
   id="2",
   document={
   "my_dense_vector": [
   -0.5,
   10,
   10
   ],
   "my_byte_dense_vector": [
   0,
   10,
   10
   ],
   "status": "published"
   },
)
print(resp2)
resp3 = client.indices.refresh(
   index="my-index-000001",
)
print(resp3)
`

Js

const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
   properties: {
   my_dense_vector: {
   type: "dense_vector",
   index: false,
   dims: 3,
   },
   my_byte_dense_vector: {
   type: "dense_vector",
   index: false,
   dims: 3,
   element_type: "byte",
   },
   status: {
   type: "keyword",
   },
   },
  },
});
console.log(response);
const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  document: {
   my_dense_vector: [0.5, 10, 6],
   my_byte_dense_vector: [0, 10, 6],
   status: "published",
  },
});
console.log(response1);
const response2 = await client.index({
  index: "my-index-000001",
  id: 2,
  document: {
   my_dense_vector: [-0.5, 10, 10],
   my_byte_dense_vector: [0, 10, 10],
   status: "published",
  },
});
console.log(response2);
const response3 = await client.indices.refresh({
  index: "my-index-000001",
});
console.log(response3);

コンソール

PUT my-index-000001
{
  "mappings": {
   "properties": {
   "my_dense_vector": {
   "type": "dense_vector",
   "index": false,
   "dims": 3
   },
   "my_byte_dense_vector": {
   "type": "dense_vector",
   "index": false,
   "dims": 3,
   "element_type": "byte"
   },
   "status" : {
   "type" : "keyword"
   }
   }
  }
}
PUT my-index-000001/_doc/1
{
  "my_dense_vector": [0.5, 10, 6],
  "my_byte_dense_vector": [0, 10, 6],
  "status" : "published"
}
PUT my-index-000001/_doc/2
{
  "my_dense_vector": [-0.5, 10, 10],
  "my_byte_dense_vector": [0, 10, 10],
  "status" : "published"
}
POST my-index-000001/_refresh

コサイン類似度


#### Python
``````python
resp = client.search(
   index="my-index-000001",
   query={
   "script_score": {
   "query": {
   "bool": {
   "filter": {
   "term": {
   "status": "published"
   }
   }
   }
   },
   "script": {
   "source": "cosineSimilarity(params.query_vector, 'my_dense_vector') + 1.0",
   "params": {
   "query_vector": [
   4,
                        3.4,
   -0.2
   ]
   }
   }
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: 'published'
   }
   }
   }
   },
   script: {
   source: "cosineSimilarity(params.query_vector, 'my_dense_vector') + 1.0",
   params: {
   query_vector: [
   4,
              3.4,
   -0.2
   ]
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: "published",
   },
   },
   },
   },
   script: {
   source:
   "cosineSimilarity(params.query_vector, 'my_dense_vector') + 1.0",
   params: {
   query_vector: [4, 3.4, -0.2],
   },
   },
   },
  },
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "script_score": {
   "query" : {
   "bool" : {
   "filter" : {
   "term" : {
   "status" : "published"
   }
   }
   }
   },
   "script": {
   "source": "cosineSimilarity(params.query_vector, 'my_dense_vector') + 1.0",
   "params": {
   "query_vector": [4, 3.4, -0.2]
   }
   }
   }
  }
}


	スクリプトスコア計算が適用されるドキュメントの数を制限するには、フィルターを提供します。
	スクリプトはコサイン類似度に1.0を加算して、スコアが負にならないようにします。
	スクリプトの最適化を活用するには、スクリプトパラメータとしてクエリベクトルを提供します。

ドキュメントの密なベクトルフィールドの次元数がクエリのベクトルと異なる場合、エラーが発生します。

ドット積


#### Python
``````python
resp = client.search(
   index="my-index-000001",
   query={
   "script_score": {
   "query": {
   "bool": {
   "filter": {
   "term": {
   "status": "published"
   }
   }
   }
   },
   "script": {
   "source": "\n          double value = dotProduct(params.query_vector, 'my_dense_vector');\n          return sigmoid(1, Math.E, -value); \n        ",
   "params": {
   "query_vector": [
   4,
                        3.4,
   -0.2
   ]
   }
   }
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: 'published'
   }
   }
   }
   },
   script: {
   source: "\n          double value = dotProduct(params.query_vector, 'my_dense_vector');\n          return sigmoid(1, Math.E, -value); \n        ",
   params: {
   query_vector: [
   4,
              3.4,
   -0.2
   ]
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: "published",
   },
   },
   },
   },
   script: {
   source:
   "\n          double value = dotProduct(params.query_vector, 'my_dense_vector');\n          return sigmoid(1, Math.E, -value); \n        ",
   params: {
   query_vector: [4, 3.4, -0.2],
   },
   },
   },
  },
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "script_score": {
   "query" : {
   "bool" : {
   "filter" : {
   "term" : {
   "status" : "published"
   }
   }
   }
   },
   "script": {
   "source": """
   double value = dotProduct(params.query_vector, 'my_dense_vector');
   return sigmoid(1, Math.E, -value);
   """,
   "params": {
   "query_vector": [4, 3.4, -0.2]
   }
   }
   }
  }
}


	標準のシグモイド関数を使用すると、スコアが負になるのを防ぎます。

L1距離（マンハッタン距離）


#### Python
``````python
resp = client.search(
   index="my-index-000001",
   query={
   "script_score": {
   "query": {
   "bool": {
   "filter": {
   "term": {
   "status": "published"
   }
   }
   }
   },
   "script": {
   "source": "1 / (1 + l1norm(params.queryVector, 'my_dense_vector'))",
   "params": {
   "queryVector": [
   4,
                        3.4,
   -0.2
   ]
   }
   }
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: 'published'
   }
   }
   }
   },
   script: {
   source: "1 / (1 + l1norm(params.queryVector, 'my_dense_vector'))",
   params: {
   "queryVector": [
   4,
              3.4,
   -0.2
   ]
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: "published",
   },
   },
   },
   },
   script: {
   source: "1 / (1 + l1norm(params.queryVector, 'my_dense_vector'))",
   params: {
   queryVector: [4, 3.4, -0.2],
   },
   },
   },
  },
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "script_score": {
   "query" : {
   "bool" : {
   "filter" : {
   "term" : {
   "status" : "published"
   }
   }
   }
   },
   "script": {
   "source": "1 / (1 + l1norm(params.queryVector, 'my_dense_vector'))",
   "params": {
   "queryVector": [4, 3.4, -0.2]
   }
   }
   }
  }
}

cosineSimilarityは類似性を表すのに対し、l1normおよび
l2normは距離または差を表します。これは、ベクトルがより類似しているほど、l1normおよびl2norm関数によって生成されるスコアが低くなることを意味します。
したがって、より類似したベクトルが高いスコアを得る必要があるため、l1normおよびl2normからの出力を反転させました。また、ドキュメントベクトルがクエリと正確に一致する場合に0での除算を避けるために、分母に1を追加しました。


	`cosineSimilarity`は類似性を表すのに対し、`l1norm`および `l2norm`は距離または差を表します。これは、ベクトルがより類似しているほど、`l1norm`および`l2norm`関数によって生成されるスコアが低くなることを意味します。したがって、より類似したベクトルが高いスコアを得る必要があるため、`l1norm`および`l2norm`からの出力を反転させました。また、ドキュメントベクトルがクエリと正確に一致する場合に0での除算を避けるために、分母に`1`を追加しました。

ハミング距離


#### Python
``````python
resp = client.search(
   index="my-index-000001",
   query={
   "script_score": {
   "query": {
   "bool": {
   "filter": {
   "term": {
   "status": "published"
   }
   }
   }
   },
   "script": {
   "source": "(24 - hamming(params.queryVector, 'my_byte_dense_vector')) / 24",
   "params": {
   "queryVector": [
   4,
   3,
   0
   ]
   }
   }
   }
   },
)
print(resp)
`

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: "published",
   },
   },
   },
   },
   script: {
   source:
   "(24 - hamming(params.queryVector, 'my_byte_dense_vector')) / 24",
   params: {
   queryVector: [4, 3, 0],
   },
   },
   },
  },
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "script_score": {
   "query" : {
   "bool" : {
   "filter" : {
   "term" : {
   "status" : "published"
   }
   }
   }
   },
   "script": {
   "source": "(24 - hamming(params.queryVector, 'my_byte_dense_vector')) / 24",
   "params": {
   "queryVector": [4, 3, 0]
   }
   }
   }
  }
}


	ハミング距離を計算し、ビットで正規化して0から1のスコアを取得します。

L2距離（ユークリッド距離）


#### Python
``````python
resp = client.search(
   index="my-index-000001",
   query={
   "script_score": {
   "query": {
   "bool": {
   "filter": {
   "term": {
   "status": "published"
   }
   }
   }
   },
   "script": {
   "source": "1 / (1 + l2norm(params.queryVector, 'my_dense_vector'))",
   "params": {
   "queryVector": [
   4,
                        3.4,
   -0.2
   ]
   }
   }
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: 'published'
   }
   }
   }
   },
   script: {
   source: "1 / (1 + l2norm(params.queryVector, 'my_dense_vector'))",
   params: {
   "queryVector": [
   4,
              3.4,
   -0.2
   ]
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: "published",
   },
   },
   },
   },
   script: {
   source: "1 / (1 + l2norm(params.queryVector, 'my_dense_vector'))",
   params: {
   queryVector: [4, 3.4, -0.2],
   },
   },
   },
  },
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "script_score": {
   "query" : {
   "bool" : {
   "filter" : {
   "term" : {
   "status" : "published"
   }
   }
   }
   },
   "script": {
   "source": "1 / (1 + l2norm(params.queryVector, 'my_dense_vector'))",
   "params": {
   "queryVector": [4, 3.4, -0.2]
   }
   }
   }
  }
}

欠落値の確認

ドキュメントにベクトル関数が実行されるベクトルフィールドの値がない場合、エラーが発生します。

フィールドmy_vectorに値があるかどうかをdoc['my_vector'].size() == 0で確認できます。全体のスクリプトは次のようになります：

Js

"source": "doc['my_vector'].size() == 0 ? 0 : cosineSimilarity(params.queryVector, 'my_vector')"

ベクトルへの直接アクセス

次の関数を通じてベクトル値に直接アクセスできます：

doc[<field>].vectorValue – ベクトルの値を浮動小数点の配列として返します


-  `````doc[<field>].magnitude````` – ベクトルの大きさを浮動小数点として返します（バージョン7.5以前に作成されたベクトルの場合、大きさは保存されません。したがって、この関数は呼び出されるたびに新たに計算します）。
`````bit`````ベクトルの場合、これは`````1`````ビットの合計の平方根です。  
たとえば、以下のスクリプトはこれらの2つの関数を使用してコサイン類似度を実装します：
#### Python
``````python
resp = client.search(
   index="my-index-000001",
   query={
   "script_score": {
   "query": {
   "bool": {
   "filter": {
   "term": {
   "status": "published"
   }
   }
   }
   },
   "script": {
   "source": "\n          float[] v = doc['my_dense_vector'].vectorValue;\n          float vm = doc['my_dense_vector'].magnitude;\n          float dotProduct = 0;\n          for (int i = 0; i < v.length; i++) {\n            dotProduct += v[i] * params.queryVector[i];\n          }\n          return dotProduct / (vm * (float) params.queryVectorMag);\n        ",
   "params": {
   "queryVector": [
   4,
                        3.4,
   -0.2
   ],
   "queryVectorMag": 5.25357
   }
   }
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: 'published'
   }
   }
   }
   },
   script: {
   source: "\n          float[] v = doc['my_dense_vector'].vectorValue;\n          float vm = doc['my_dense_vector'].magnitude;\n          float dotProduct = 0;\n          for (int i = 0; i < v.length; i++) {\n            dotProduct += v[i] * params.queryVector[i];\n          }\n          return dotProduct / (vm * (float) params.queryVectorMag);\n        ",
   params: {
   "queryVector": [
   4,
              3.4,
   -0.2
   ],
   "queryVectorMag": 5.25357
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   script_score: {
   query: {
   bool: {
   filter: {
   term: {
   status: "published",
   },
   },
   },
   },
   script: {
   source:
   "\n          float[] v = doc['my_dense_vector'].vectorValue;\n          float vm = doc['my_dense_vector'].magnitude;\n          float dotProduct = 0;\n          for (int i = 0; i < v.length; i++) {\n            dotProduct += v[i] * params.queryVector[i];\n          }\n          return dotProduct / (vm * (float) params.queryVectorMag);\n        ",
   params: {
   queryVector: [4, 3.4, -0.2],
   queryVectorMag: 5.25357,
   },
   },
   },
  },
});
console.log(response);

コンソール

GET my-index-000001/_search
{
  "query": {
   "script_score": {
   "query" : {
   "bool" : {
   "filter" : {
   "term" : {
   "status" : "published"
   }
   }
   }
   },
   "script": {
   "source": """
   float[] v = doc['my_dense_vector'].vectorValue;
   float vm = doc['my_dense_vector'].magnitude;
   float dotProduct = 0;
   for (int i = 0; i < v.length; i++) {
   dotProduct += v[i] * params.queryVector[i];
   }
   return dotProduct / (vm * (float) params.queryVectorMag);
   """,
   "params": {
   "queryVector": [4, 3.4, -0.2],
   "queryVectorMag": 5.25357
   }
   }
   }
  }
}

ビットベクトルとベクトル関数


-  [`````hamming`````](2ffee97f686b4ace.md#vector-functions-hamming) – ハミング距離を計算します。これは2つのベクトルのビット単位のXORの合計です。  
-  [`````l1norm`````](2ffee97f686b4ace.md#vector-functions-l1) – L1距離を計算します。これは単に`````hamming`````距離です。  
-  [`````l2norm`````](2ffee97f686b4ace.md#vector-functions-l2) - L2距離を計算します。これは`````hamming`````距離の平方根です。
現在、`````cosineSimilarity`````および`````dotProduct`````関数は`````bit`````ベクトルにはサポートされていません。
### 説明リクエスト
[説明リクエスト](/read/elasticsearch-8-15/d97b1394fff1a56f.md)を使用すると、スコアの各部分がどのように計算されたかの説明が得られます。`````script_score`````クエリは、`````explanation`````パラメータを設定することで独自の説明を追加できます：
#### Python
``````python
resp = client.explain(
   index="my-index-000001",
   id="0",
   query={
   "script_score": {
   "query": {
   "match": {
   "message": "elasticsearch"
   }
   },
   "script": {
   "source": "\n          long count = doc['count'].value;\n          double normalizedCount = count / 10;\n          if (explanation != null) {\n            explanation.set('normalized count = count / 10 = ' + count + ' / 10 = ' + normalizedCount);\n          }\n          return normalizedCount;\n        "
   }
   }
   },
)
print(resp)
`

Ruby

response = client.explain(
  index: 'my-index-000001',
  id: 0,
  body: {
   query: {
   script_score: {
   query: {
   match: {
   message: 'elasticsearch'
   }
   },
   script: {
   source: "\n          long count = doc['count'].value;\n          double normalizedCount = count / 10;\n          if (explanation != nil) {\n            explanation.set('normalized count = count / 10 = ' + count + ' / 10 = ' + normalizedCount);\n          }\n          return normalizedCount;\n        "
   }
   }
   }
  }
)
puts response

Js

const response = await client.explain({
  index: "my-index-000001",
  id: 0,
  query: {
   script_score: {
   query: {
   match: {
   message: "elasticsearch",
   },
   },
   script: {
   source:
   "\n          long count = doc['count'].value;\n          double normalizedCount = count / 10;\n          if (explanation != null) {\n            explanation.set('normalized count = count / 10 = ' + count + ' / 10 = ' + normalizedCount);\n          }\n          return normalizedCount;\n        ",
   },
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_explain/0
{
  "query": {
   "script_score": {
   "query": {
   "match": { "message": "elasticsearch" }
   },
   "script": {
   "source": """
   long count = doc['count'].value;
   double normalizedCount = count / 10;
   if (explanation != null) {
   explanation.set('normalized count = count / 10 = ' + count + ' / 10 = ' + normalizedCount);
   }
   return normalizedCount;
   """
   }
   }
  }
}

explanationは通常の_searchリクエストで使用する場合はnullになるため、条件付きガードを持つことがベストプラクティスです。