Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Kueri inferensi di Neptunus ML
<a name="machine-learning-inference-queries"></a>

Anda dapat menggunakan Gremlin atau SPARQL untuk menanyakan titik akhir inferensi Neptunus ML. [Inferensi induktif waktu nyata](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), bagaimanapun, saat ini hanya didukung untuk kueri Gremlin.

# Kueri inferensi Gremlin di Neptune ML
<a name="machine-learning-gremlin-inference-queries"></a>

Seperti dijelaskan dalam[Kemampuan Neptune ML](machine-learning.md#machine-learning-capabilities), Neptunus ML mendukung model pelatihan yang dapat melakukan jenis tugas inferensi berikut:
+ **Klasifikasi simpul**   –   Memprediksi fitur kategoris dari properti vertex.
+ **Regresi simpul** — Memprediksi properti numerik dari sebuah simpul.
+ **Klasifikasi tepi** - Memprediksi fitur kategoris properti tepi.
+ **Regresi tepi** - Memprediksi properti numerik tepi.
+ **Prediksi tautan** - Memprediksi node tujuan yang diberikan node sumber dan tepi keluar, atau node sumber yang diberi node tujuan dan tepi masuk.

[Kami dapat mengilustrasikan tugas-tugas yang berbeda ini dengan contoh yang menggunakan [kumpulan data MovieLens 100k yang disediakan oleh Research](https://grouplens.org/datasets/movielens/100k/). GroupLens ](https://grouplens.org/datasets/movielens/) Dataset ini terdiri dari film, pengguna, dan peringkat film oleh pengguna, dari mana kami telah membuat grafik properti seperti ini: 

![\[Contoh grafik properti film menggunakan kumpulan data MovieLens 100k\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/movie_property_graph_example.png)


**Klasifikasi simpul**: Dalam kumpulan data di atas, `Genre` adalah tipe simpul yang terhubung ke tipe `Movie` simpul berdasarkan tepi. `included_in` Namun, jika kita mengubah kumpulan data untuk membuat fitur [kategoris](https://en.wikipedia.org/wiki/Categorical_variable) untuk tipe simpul`Movie`, maka masalah menyimpulkan `Genre` untuk film baru yang ditambahkan ke grafik pengetahuan kita dapat diselesaikan dengan `Genre` menggunakan model klasifikasi simpul.

**Regresi simpul**: Jika kita mempertimbangkan tipe simpul`Rating`, yang memiliki properti seperti `timestamp` dan`score`, maka masalah menyimpulkan nilai numerik `Score` untuk a `Rating` dapat diselesaikan dengan menggunakan model regresi simpul.

**Klasifikasi tepi**: Demikian pula, untuk `Rated` tepi, jika kita memiliki properti `Scale` yang dapat memiliki salah satu nilai`Love`,`Like`,`Dislike`,`Neutral`,`Hate`,,, maka masalah menyimpulkan `Scale` untuk `Rated` tepi untuk yang baru movies/ratings dapat diselesaikan dengan menggunakan model klasifikasi tepi.

**Regresi tepi**: Demikian pula, untuk `Rated` tepi yang sama, jika kita memiliki properti `Score` yang memegang nilai numerik untuk peringkat, maka ini dapat disimpulkan dari model regresi tepi.

**Prediksi tautan**: Masalah seperti, temukan sepuluh pengguna teratas yang paling mungkin menilai film tertentu, atau menemukan sepuluh Film teratas yang kemungkinan besar akan dinilai oleh pengguna tertentu, berada di bawah prediksi tautan.

**catatan**  
Untuk kasus penggunaan Neptunus ML, kami memiliki seperangkat notebook yang sangat kaya yang dirancang untuk memberi Anda pemahaman langsung tentang setiap kasus penggunaan. Anda dapat membuat notebook ini bersama dengan cluster Neptunus Anda saat Anda menggunakan template Neptunus ML untuk membuat cluster [Neptunus CloudFormation ML](machine-learning-quick-start.md). Notebook ini juga tersedia di [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning).

**Topics**
+ [Predikat Neptune ML digunakan dalam query inferensi Gremlin](machine-learning-gremlin-inference-query-predicates.md)
+ [Kueri klasifikasi simpul Gremlin di Neptunus ML](machine-learning-gremlin-vertex-classification-queries.md)
+ [Kueri regresi simpul Gremlin di Neptunus ML](machine-learning-gremlin-vertex-regression-queries.md)
+ [Kueri klasifikasi tepi Gremlin di Neptunus ML](machine-learning-gremlin-edge-classification-queries.md)
+ [Kueri regresi tepi Gremlin di Neptunus ML](machine-learning-gremlin-edge-regression.md)
+ [Kueri prediksi tautan Gremlin menggunakan model prediksi tautan di Neptunus ML](machine-learning-gremlin-link-prediction-queries.md)
+ [Daftar pengecualian untuk kueri inferensi Gremlin Neptune ML](machine-learning-gremlin-exceptions.md)

# Predikat Neptune ML digunakan dalam query inferensi Gremlin
<a name="machine-learning-gremlin-inference-query-predicates"></a>

## `Neptune#ml.deterministic`
<a name="machine-learning-gremlin-inference-neptune-ml-deterministic-predicate"></a>

Predikat ini adalah opsi untuk kueri inferensi induktif — yaitu, untuk kueri yang menyertakan predikat. [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference)

Saat menggunakan inferensi induktif, mesin Neptunus membuat subgraf yang sesuai untuk mengevaluasi model GNN yang terlatih, dan persyaratan subgraf ini bergantung pada parameter model akhir. Secara khusus, `num-layer` parameter menentukan jumlah hop traversal dari node atau tepi target, dan `fanouts` parameter menentukan berapa banyak tetangga untuk sampel pada setiap hop (lihat parameter [HPO](machine-learning-customizing-hyperparams.md)).

Secara default, kueri inferensi induktif berjalan dalam mode non-deterministik, di mana Neptunus membangun lingkungan secara acak. Saat membuat prediksi, pengambilan sampel tetangga-acak yang normal ini terkadang menghasilkan prediksi yang berbeda.

Saat Anda memasukkan `Neptune#ml.deterministic` dalam kueri inferensi induktif, mesin Neptunus mencoba mengambil sampel tetangga dengan cara deterministik sehingga beberapa pemanggilan dari kueri yang sama mengembalikan hasil yang sama setiap saat. Hasilnya tidak dapat dijamin sepenuhnya deterministik, karena perubahan pada grafik dan artefak yang mendasari sistem terdistribusi masih dapat menimbulkan fluktuasi.

Anda menyertakan `Neptune#ml.deterministic` predikat dalam kueri seperti ini:

```
.with("Neptune#ml.deterministic")
```

Jika `Neptune#ml.deterministic` predikat disertakan dalam kueri yang tidak juga termasuk`Neptune#ml.inductiveInference`, itu diabaikan begitu saja.

## `Neptune#ml.disableInductiveInferenceMetadataCache`
<a name="machine-learning-gremlin-disableInductiveInferenceMetadataCache-predicate"></a>

Predikat ini adalah opsi untuk kueri inferensi induktif — yaitu, untuk kueri yang menyertakan predikat. [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference)

Untuk kueri inferensi induktif, Neptunus menggunakan file metadata yang disimpan di Amazon S3 untuk menentukan jumlah hop dan fanout saat membangun lingkungan. Neptunus biasanya menyimpan metadata model ini untuk menghindari pengambilan file dari Amazon S3 berulang kali. Caching dapat dinonaktifkan dengan memasukkan `Neptune#ml.disableInductiveInferenceMetadataCache` predikat dalam kueri. Meskipun mungkin lebih lambat bagi Neptunus untuk mengambil metadata langsung dari Amazon S3, ini SageMaker berguna ketika titik akhir AI telah diperbarui setelah pelatihan ulang atau transformasi dan cache sudah basi.

Anda menyertakan `Neptune#ml.disableInductiveInferenceMetadataCache` predikat dalam kueri seperti ini:

```
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
```

Berikut adalah bagaimana kueri sampel mungkin terlihat di notebook Jupyter:

```
%%gremlin
g.with("Neptune#ml.endpoint", "ep1")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .with("Neptune#ml.disableInductiveInferenceMetadataCache")
 .V('101').properties("rating")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
```

## `Neptune#ml.endpoint`
<a name="machine-learning-gremlin-inference-neptune-ml-endpoint-predicate"></a>

Predikat `Neptune#ml.endpoint` digunakan dalam langkah `with()` untuk menentukan titik akhir inferensi, jika perlu:

```
 .with("Neptune#ml.endpoint", "the model's SageMaker AI inference endpoint")
```

Anda dapat mengidentifikasi titik akhir baik dengan `id` atau URL-nya. Contoh:

```
 .with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" )
```

Atau:

```
 .with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" )
```

**catatan**  
Jika Anda [mengatur parameter `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) di grup parameter klaster Neptune DB Anda ke titik akhir `id` atau URL, Anda tidak perlu menyertakan predikat `Neptune#ml.endpoint`dalam setiap kueri.

## `Neptune#ml.iamRoleArn`
<a name="machine-learning-gremlin-inference-neptune-ml-iamRoleArn-predicate"></a>

`Neptune#ml.iamRoleArn`digunakan dalam `with()` langkah untuk menentukan ARN dari peran IAM eksekusi SageMaker AI, jika perlu:

```
 .with("Neptune#ml.iamRoleArn", "the ARN for the SageMaker AI execution IAM role")
```

Untuk informasi tentang cara membuat peran IAM eksekusi SageMaker AI, lihat[Buat NeptuneSageMaker IAMRole peran khusus](machine-learning-manual-setup.md#ml-manual-setup-sm-role).

**catatan**  
Jika Anda [menyetel `neptune_ml_iam_role` parameter](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) dalam grup parameter cluster Neptunus DB ke ARN peran IAM eksekusi AI SageMaker Anda, Anda tidak perlu menyertakan predikat di setiap kueri. `Neptune#ml.iamRoleArn`

## Neptunus \$1ml .InductiveInference
<a name="machine-learning-gremlin-inference-neptune-ml-inductiveInference"></a>

Inferensi transduktif diaktifkan secara default di Gremlin. Untuk membuat kueri [inferensi induktif real-time](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), sertakan `Neptune#ml.inductiveInference` predikat seperti ini:

```
.with("Neptune#ml.inductiveInference")
```

Jika grafik Anda dinamis, inferensi induktif seringkali merupakan pilihan terbaik, tetapi jika grafik Anda statis, inferensi transduktif lebih cepat dan lebih efisien.

## `Neptune#ml.limit`
<a name="machine-learning-gremlin-inference-neptune-ml-limit-predicate"></a>

`Neptune#ml.limit`Predikat secara opsional membatasi jumlah hasil yang dikembalikan per entitas:

```
 .with( "Neptune#ml.limit", 2 )
```

Secara default, batasnya adalah 1, dan jumlah maksimum yang dapat diatur adalah 100.

## `Neptune#ml.threshold`
<a name="machine-learning-gremlin-inference-neptune-ml-threshold-predicate"></a>

Predikat `Neptune#ml.threshold` secara opsional menetapkan ambang batas cutoff untuk skor hasil:

```
 .with( "Neptune#ml.threshold", 0.5D )
```

Hal ini memungkinkan Anda membuang semua hasil dengan skor di bawah ambang batas yang ditentukan.

## `Neptune#ml.classification`
<a name="machine-learning-gremlin-inference-neptune-ml-classification-predicate"></a>

`Neptune#ml.classification`Predikat dilampirkan pada `properties()` langkah untuk menetapkan bahwa properti perlu diambil dari titik akhir SageMaker AI dari model klasifikasi node:

```
 .properties( "property key of the node classification model" ).with( "Neptune#ml.classification" )
```

## `Neptune#ml.regression`
<a name="machine-learning-gremlin-inference-neptune-ml-regression-predicate"></a>

`Neptune#ml.regression`Predikat dilampirkan pada `properties()` langkah untuk menetapkan bahwa properti perlu diambil dari titik akhir SageMaker AI dari model regresi node:

```
 .properties( "property key of the node regression model" ).with( "Neptune#ml.regression" )
```

## `Neptune#ml.prediction`
<a name="machine-learning-gremlin-inference-neptune-ml-prediction-predicate"></a>

Predikat `Neptune#ml.prediction` dilampirkan ke langkah `in()` dan `out()` untuk menetapkan bahwa ini adalah kueri prediksi link:

```
 .in("edge label of the link prediction model").with("Neptune#ml.prediction").hasLabel("target node label")
```

## `Neptune#ml.score`
<a name="machine-learning-gremlin-inference-neptune-ml-score-predicate"></a>

`Neptune#ml.score`Predikat digunakan dalam kueri klasifikasi simpul atau tepi Gremlin untuk mengambil Skor kepercayaan pembelajaran mesin. `Neptune#ml.score`Predikat harus diteruskan bersama dengan predikat kueri dalam `properties()` langkah untuk mendapatkan skor kepercayaan ML untuk kueri klasifikasi simpul atau tepi.

Anda dapat menemukan contoh klasifikasi simpul dengan [contoh klasifikasi simpul lainnya](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries), dan contoh klasifikasi tepi di [bagian klasifikasi tepi](machine-learning-gremlin-edge-classification-queries.md).

# Kueri klasifikasi simpul Gremlin di Neptunus ML
<a name="machine-learning-gremlin-vertex-classification-queries"></a>

Untuk klasifikasi node Gremlin di Neptunus ML:
+ Model ini dilatih pada satu properti dari vertex. Rangkain nilai unik dari properti ini disebut sebagai satu set kelas simpul, atau hanya, kelas.
+ Kelas simpul atau nilai properti kategoris dari properti vertex ini dapat disimpulkan dari model klasifikasi simpul. Hal ini berguna di mana properti ini belum melekat pada simpul.
+ Dalam rangka untuk mengambil satu kelas atau lebih dari model klasifikasi simpul, Anda perlu menggunakan langkah `with()` dengan predikat `Neptune#ml.classification` untuk mengonfigurasi langkah `properties()`. Format output mirip dengan apa yang Anda harapkan jika format adalah properti vertex.

**catatan**  
Klasifikasi node hanya bekerja dengan nilai properti string. Itu berarti bahwa nilai properti numerik seperti `0` atau tidak `1` didukung, meskipun string setara `"0"` dan adalah. `"1"` Demikian pula, nilai properti Boolean `true` dan `false` tidak berfungsi, tetapi `"true"` dan `"false"` lakukan.

Berikut adalah contoh kueri klasifikasi node:

```
g.with( "Neptune#ml.endpoint","node-classification-movie-lens-endpoint" )
 .with( "Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role" )
 .with( "Neptune#ml.limit", 2 )
 .with( "Neptune#ml.threshold", 0.5D )
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
```

Output dari kueri ini akan terlihat seperti berikut ini:

```
==>vp[genre->Action]
==>vp[genre->Crime]
==>vp[genre->Comedy]
```

Dalam query di atas, langkah `V()` dan `properties()` digunakan sebagai berikut:

Langkah `V()` berisi rangkaian vertex di mana Anda ingin mengambil kelas dari model klasifikasi node:

```
 .V( "movie_1", "movie_2", "movie_3" )
```

`properties()`Langkah berisi kunci di mana model dilatih, dan `.with("Neptune#ml.classification")` harus menunjukkan bahwa ini adalah kueri inferensi MS klasifikasi node.

Kunci properti ganda saat ini tidak didukung di langkah `properties().with("Neptune#ml.classification")`. Sebagai contoh, hasil kueri berikut dalam pengecualian:

```
g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre", "other_label").with("Neptune#ml.classification")
```

Untuk pesan kesalahan tertentu, lihat [daftar pengecualian Neptune ML](machine-learning-gremlin-exceptions.md).

Langkah `properties().with("Neptune#ml.classification")` dapat digunakan dalam kombinasi dengan semua langkah-langkah berikut:
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`

## Kueri klasifikasi simpul lainnya
<a name="machine-learning-gremlin-node-class-other-queries"></a>

Jika titik akhir inferensi dan peran IAM yang sesuai telah disimpan dalam grup parameter cluster DB Anda, kueri klasifikasi simpul dapat sesederhana ini:

```
g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification")
```

Anda dapat mencampur properti vertex dan kelas dalam kueri menggunakan langkah `union()`:

```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .union(
   properties("genre").with("Neptune#ml.classification"),
   properties("genre")
 )
```

Anda juga dapat membuat kueri tak terbatas seperti ini:

```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V()
 .properties("genre").with("Neptune#ml.classification")
```

Anda dapat mengambil kelas simpul bersama-sama dengan vertex menggunakan langkah `select()` bersama dengan langkah `as()`:

```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" ).as("vertex")
 .properties("genre").with("Neptune#ml.classification").as("properties")
 .select("vertex","properties")
```

Anda juga dapat menyaring pada kelas simpul, seperti yang digambarkan dalam contoh-contoh ini:

```
g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, "Horror")

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, P.eq("Action"))

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, P.within("Action", "Horror"))
```

Anda bisa mendapatkan skor kepercayaan klasifikasi node menggunakan `Neptune#ml.score` predikat:

```
 g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre", "Neptune#ml.score").with("Neptune#ml.classification")
```

Responsnya akan terlihat seperti ini:

```
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.01234567]
==>vp[genre->Crime]
==>vp[Neptune#ml.score->0.543210]
==>vp[genre->Comedy]
==>vp[Neptune#ml.score->0.10101]
```

## Menggunakan inferensi induktif dalam kueri klasifikasi node
<a name="machine-learning-gremlin-node-class-inductive"></a>

Misalkan Anda menambahkan simpul baru ke grafik yang ada, di buku catatan Jupyter, seperti ini:

```
%%gremlin
g.addV('label1').property(id,'101').as('newV')
 .V('1').as('oldV1')
 .V('2').as('oldV2')
 .addE('eLabel1').from('newV').to('oldV1')
 .addE('eLabel2').from('oldV2').to('newV')
```

Anda kemudian dapat menggunakan kueri inferensi induktif untuk mendapatkan genre dan skor kepercayaan yang mencerminkan node baru:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("genre", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
```

Namun, jika Anda menjalankan kueri beberapa kali, Anda mungkin mendapatkan hasil yang agak berbeda:

```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.21365921]
```

Anda dapat membuat kueri deterministik yang sama:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("genre", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

Dalam hal ini, hasilnya kira-kira sama setiap saat:

```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
```

# Kueri regresi simpul Gremlin di Neptunus ML
<a name="machine-learning-gremlin-vertex-regression-queries"></a>

Regresi node mirip dengan klasifikasi node, kecuali bahwa nilai yang disimpulkan dari model regresi untuk setiap node adalah numerik. Anda dapat menggunakan kueri Gremlin yang sama untuk regresi node seperti untuk klasifikasi node kecuali untuk perbedaan berikut:
+ Sekali lagi, di Neptune ML, simpul mengacu pada vertex.
+ Langkah `properties()` mengambil bentuk, `properties().with("Neptune#ml.regression")` alih-alih `properties().with("Neptune#ml.classification")`.
+ Predikat `"Neptune#ml.limit`“ dan `"Neptune#ml.threshold"` tidak berlaku.
+ Ketika Anda menyaring nilai, Anda harus menentukan nilai numerik.

Berikut ini adalah contoh kueri klasifikasi vertex:

```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1","movie_2","movie_3")
 .properties("revenue").with("Neptune#ml.regression")
```

Anda dapat menyaring nilai yang disimpulkan menggunakan model regresi, seperti yang digambarkan dalam contoh berikut:

```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1","movie_2","movie_3")
 .properties("revenue").with("Neptune#ml.regression")
 .value().is(P.gte(1600000))

g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1","movie_2","movie_3")
 .properties("revenue").with("Neptune#ml.regression")
 .hasValue(P.lte(1600000D))
```

## Menggunakan inferensi induktif dalam kueri regresi simpul
<a name="machine-learning-gremlin-node-regress-inductive"></a>

Misalkan Anda menambahkan simpul baru ke grafik yang ada, di buku catatan Jupyter, seperti ini:

```
%%gremlin
g.addV('label1').property(id,'101').as('newV')
 .V('1').as('oldV1')
 .V('2').as('oldV2')
 .addE('eLabel1').from('newV').to('oldV1')
 .addE('eLabel2').from('oldV2').to('newV')
```

Anda kemudian dapat menggunakan kueri inferensi induktif untuk mendapatkan peringkat yang memperhitungkan node baru:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nr-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("rating")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
```

Karena kueri tidak deterministik, kueri mungkin mengembalikan hasil yang agak berbeda jika Anda menjalankannya beberapa kali, berdasarkan lingkungan:

```
# First time
==>vp[rating->9.1]

# Second time
==>vp[rating->8.9]
```

Jika Anda membutuhkan hasil yang lebih konsisten, Anda dapat membuat kueri deterministik:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("rating")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

Sekarang hasilnya kira-kira sama setiap saat:

```
# First time
==>vp[rating->9.1]

# Second time
==>vp[rating->9.1]
```

# Kueri klasifikasi tepi Gremlin di Neptunus ML
<a name="machine-learning-gremlin-edge-classification-queries"></a>

Untuk klasifikasi tepi Gremlin di Neptunus ML:
+ Model ini dilatih pada satu properti tepi. Himpunan nilai unik dari properti ini disebut sebagai satu set kelas.
+ Nilai properti kelas atau kategoris tepi dapat disimpulkan dari model klasifikasi tepi, yang berguna ketika properti ini belum melekat pada tepi.
+ Untuk mengambil satu atau lebih kelas dari model klasifikasi tepi, Anda perlu menggunakan `with()` langkah dengan predikat, `"Neptune#ml.classification"` untuk mengkonfigurasi langkah. `properties()` Format output mirip dengan apa yang Anda harapkan jika itu adalah properti tepi.

**catatan**  
Klasifikasi tepi hanya berfungsi dengan nilai properti string. Itu berarti bahwa nilai properti numerik seperti `0` atau tidak `1` didukung, meskipun string setara `"0"` dan adalah. `"1"` Demikian pula, nilai properti Boolean `true` dan `false` tidak berfungsi, tetapi `"true"` dan `"false"` lakukan.

Berikut adalah contoh kueri klasifikasi tepi yang meminta skor kepercayaan menggunakan `Neptune#ml.score` predikat:

```
g.with("Neptune#ml.endpoint","edge-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("relationship_1","relationship_2","relationship_3")
 .properties("knows_by", "Neptune#ml.score").with("Neptune#ml.classification")
```

Responsnya akan terlihat seperti ini:

```
==>p[knows_by->"Family"]
==>p[Neptune#ml.score->0.01234567]
==>p[knows_by->"Friends"]
==>p[Neptune#ml.score->0.543210]
==>p[knows_by->"Colleagues"]
==>p[Neptune#ml.score->0.10101]
```

## Sintaks kueri klasifikasi tepi Gremlin
<a name="machine-learning-gremlin-edge-classification-syntax"></a>

Untuk grafik sederhana di `User` mana simpul kepala dan ekor, dan `Relationship` merupakan tepi yang menghubungkannya, contoh kueri klasifikasi tepi adalah:

```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("relationship_1","relationship_2","relationship_3")
 .properties("knows_by").with("Neptune#ml.classification")
```

Output dari kueri ini akan terlihat seperti berikut ini:

```
==>p[knows_by->"Family"]
==>p[knows_by->"Friends"]
==>p[knows_by->"Colleagues"]
```

Dalam query di atas, langkah `E()` dan `properties()` digunakan sebagai berikut:
+ `E()`Langkah ini berisi kumpulan tepi yang ingin Anda ambil kelas dari model klasifikasi tepi:

  ```
  .E("relationship_1","relationship_2","relationship_3")
  ```
+ `properties()`Langkah berisi kunci di mana model dilatih, dan `.with("Neptune#ml.classification")` harus menunjukkan bahwa ini adalah kueri inferensi HTML klasifikasi tepi.

Kunci properti ganda saat ini tidak didukung di langkah `properties().with("Neptune#ml.classification")`. Misalnya, kueri berikut menghasilkan pengecualian yang dilemparkan:

```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("relationship_1","relationship_2","relationship_3")
 .properties("knows_by", "other_label").with("Neptune#ml.classification")
```

Untuk pesan kesalahan tertentu, lihat[Daftar pengecualian untuk kueri inferensi Gremlin Neptune ML](machine-learning-gremlin-exceptions.md).

Langkah `properties().with("Neptune#ml.classification")` dapat digunakan dalam kombinasi dengan semua langkah-langkah berikut:
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`

## Menggunakan inferensi induktif dalam kueri klasifikasi tepi
<a name="machine-learning-gremlin-edge-class-inductive"></a>

Misalkan Anda menambahkan tepi baru ke grafik yang ada, di buku catatan Jupyter, seperti ini:

```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```

Anda kemudian dapat menggunakan kueri inferensi induktif untuk mendapatkan skala yang memperhitungkan tepi baru:

```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("scale", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
```

Karena kueri tidak deterministik, hasilnya akan agak berbeda jika Anda menjalankannya beberapa kali, berdasarkan lingkungan acak:

```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.21365921]
```

Jika Anda membutuhkan hasil yang lebih konsisten, Anda dapat membuat kueri deterministik:

```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("scale", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

Sekarang hasilnya akan kurang lebih sama setiap kali Anda menjalankan kueri:

```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
```

# Kueri regresi tepi Gremlin di Neptunus ML
<a name="machine-learning-gremlin-edge-regression"></a>

Regresi tepi mirip dengan klasifikasi tepi, kecuali bahwa nilai yang disimpulkan dari model ML adalah numerik. Untuk regresi tepi, Neptunus ML mendukung kueri yang sama seperti untuk klasifikasi.

Poin penting yang perlu diperhatikan adalah:
+ Anda perlu menggunakan predikat ML `"Neptune#ml.regression"` untuk mengonfigurasi `properties()` langkah untuk kasus penggunaan ini.
+ `"Neptune#ml.limit"``"Neptune#ml.threshold"`Predikat dan tidak berlaku dalam kasus penggunaan ini.
+ Untuk memfilter nilai, Anda perlu menentukan nilai sebagai numerik.

## Sintaks kueri regresi tepi Gremlin
<a name="machine-learning-gremlin-edge-regression-syntax"></a>

Untuk grafik sederhana di mana `User` simpul kepala, `Movie` adalah simpul ekor, dan `Rated` tepi yang menghubungkannya, berikut adalah contoh kueri regresi tepi yang menemukan nilai peringkat numerik, disebut sebagai skor di sini, untuk tepi: `Rated`

```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("rating_1","rating_2","rating_3")
 .properties("score").with("Neptune#ml.regression")
```

Anda juga dapat memfilter nilai yang disimpulkan dari model regresi ML. Untuk `Rated` tepi yang ada (dari `User` ke`Movie`) yang diidentifikasi oleh `"rating_1"``"rating_2"`,`"rating_3"`, dan, di mana properti tepi tidak `Score` ada untuk peringkat ini, Anda dapat menggunakan kueri seperti berikut `Score` untuk menyimpulkan tepi yang lebih besar dari atau sama dengan 9:

```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("rating_1","rating_2","rating_3")
 .properties("score").with("Neptune#ml.regression")
 .value().is(P.gte(9))
```

## Menggunakan inferensi induktif dalam kueri regresi tepi
<a name="machine-learning-gremlin-edge-regression-inductive"></a>

Misalkan Anda menambahkan tepi baru ke grafik yang ada, di buku catatan Jupyter, seperti ini:

```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```

Anda kemudian dapat menggunakan kueri inferensi induktif untuk mendapatkan skor yang memperhitungkan keunggulan baru:

```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("score")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
```

Karena kueri tidak deterministik, hasilnya akan agak berbeda jika Anda menjalankannya beberapa kali, berdasarkan lingkungan acak:

```
# First time
==>ep[score->96]

# Second time
==>ep[score->91]
```

Jika Anda membutuhkan hasil yang lebih konsisten, Anda dapat membuat kueri deterministik:

```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("score")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

Sekarang hasilnya akan kurang lebih sama setiap kali Anda menjalankan kueri:

```
# First time
==>ep[score->96]

# Second time
==>ep[score->96]
```

# Kueri prediksi tautan Gremlin menggunakan model prediksi tautan di Neptunus ML
<a name="machine-learning-gremlin-link-prediction-queries"></a>

Model prediksi link dapat memecahkan masalah seperti berikut:
+ **Prediksi head-node**: Mengingat simpul dan tipe tepi, dari simpul apa yang mungkin ditautkan oleh simpul itu?
+ **Prediksi ekor-simpul**: Diberikan simpul dan label tepi, simpul apa yang mungkin ditautkan oleh simpul itu?

**catatan**  
Prediksi edge belum didukung di Neptune ML.

Untuk contoh di bawah ini, pertimbangkan grafik sederhana dengan simpul `User` dan `Movie` yang dihubungkan oleh tepi. `Rated`

Berikut adalah contoh kueri prediksi head-node, yang digunakan untuk memprediksi lima pengguna teratas yang paling mungkin menilai film,,`"movie_1"`, `"movie_2"` dan: `"movie_3"`

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .with("Neptune#ml.limit", 5)
 .V("movie_1", "movie_2", "movie_3")
 .in("rated").with("Neptune#ml.prediction").hasLabel("user")
```

Berikut ini adalah yang serupa untuk prediksi simpul ekor, yang digunakan untuk memprediksi lima film teratas yang kemungkinan akan `"user_1"` dinilai pengguna:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out("rated").with("Neptune#ml.prediction").hasLabel("movie")
```

Baik label tepi dan label simpul yang diprediksi diperlukan. Jika salah satu dihilangkan, maka akan melempar. Sebagai contoh, kueri berikut tanpa label vertex yang diprediksi melempar pengecualian:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out("rated").with("Neptune#ml.prediction")
```

Demikian pula, kueri berikut tanpa label edge melempar pengecualian:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out().with("Neptune#ml.prediction").hasLabel("movie")
```

Untuk pesan kesalahan spesifik yang ditampilkan pengecualian ini, lihat [daftar pengecualian Neptunus ML](machine-learning-gremlin-exceptions.md).

## Kueri prediksi link lainnya
<a name="machine-learning-gremlin-other-link-prediction-queries"></a>

Anda dapat menggunakan langkah `select()` dengan langkah `as(`) untuk mengirim vertex yang diprediksi bersama-sama dengan vertex input:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1").as("source")
 .in("rated").with("Neptune#ml.prediction").hasLabel("user").as("target")
 .select("source","target")

g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1").as("source")
 .out("rated").with("Neptune#ml.prediction").hasLabel("movie").as("target")
 .select("source","target")
```

Anda dapat membuat kueri tak terbatas, seperti berikut ini:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out("rated").with("Neptune#ml.prediction").hasLabel("movie")

g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1")
 .in("rated").with("Neptune#ml.prediction").hasLabel("user")
```

## Menggunakan inferensi induktif dalam kueri prediksi tautan
<a name="machine-learning-gremlin-link-predict-inductive"></a>

Misalkan Anda menambahkan simpul baru ke grafik yang ada, di buku catatan Jupyter, seperti ini:

```
%%gremlin
g.addV('label1').property(id,'101').as('newV1')
 .addV('label2').property(id,'102').as('newV2')
 .V('1').as('oldV1')
 .V('2').as('oldV2')
 .addE('eLabel1').from('newV1').to('oldV1')
 .addE('eLabel2').from('oldV2').to('newV2')
```

Anda kemudian dapat menggunakan kueri inferensi induktif untuk memprediksi node kepala, dengan mempertimbangkan node baru:

```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').out("eLabel1")
 .with("Neptune#ml.prediction")
 .with("Neptune#ml.inductiveInference")
 .hasLabel("label2")
```

Hasil:

```
==>V[2]
```

Demikian pula, Anda dapat menggunakan kueri inferensi induktif untuk memprediksi simpul ekor, dengan mempertimbangkan simpul baru:

```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('102').in("eLabel2")
 .with("Neptune#ml.prediction")
 .with("Neptune#ml.inductiveInference")
 .hasLabel("label1")
```

Hasil:

```
==>V[1]
```

# Daftar pengecualian untuk kueri inferensi Gremlin Neptune ML
<a name="machine-learning-gremlin-exceptions"></a>

 Ini adalah daftar lengkap pengecualian yang dapat terjadi saat menjalankan kueri inferensi Neptunus ML Gremlin. Pengecualian ini mencakup berbagai masalah, mulai dari masalah dengan peran IAM atau titik akhir yang ditentukan, hingga langkah Gremlin yang tidak didukung dan batasan jumlah kueri inferensi ML per kueri. Setiap entri menyertakan pesan terperinci yang menjelaskan masalah ini. 
+ **`BadRequestException`**   –   Kredensial untuk peran yang disediakan tidak dapat dimuat.

  *Pesan*: `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— Peran IAM yang ditentukan tidak diizinkan untuk memanggil titik akhir SageMaker AI.

  *Pesan*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`**   –   Titik akhir yang ditentukan tidak ada.

  *Pesan*: `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`**- Tidak dapat mengambil metadata inferensi induktif waktu-nyata Neptunus ML dari Amazon S3.

  *Pesan*: `Unable to fetch Neptune ML - Real-Time Inductive Inference metadata from S3. Check the permissions of the S3 bucket or if the Neptune instance can connect to S3.`
+ **`InternalFailureException`**— Neptunus ML tidak dapat menemukan file metadata untuk inferensi induktif real-time di Amazon S3.

  *Pesan*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`**   –   Titik akhir yang ditentukan tidak valid secara sintaksis.

  *Pesan*: `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— SageMaker Eksekusi IAM Role ARN yang ditentukan tidak valid secara sintaksis.

  *Pesan*: `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`**   –   Beberapa kunci properti ditentukan di langkah `properties()` dalam kueri.

  *Pesan*: `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`**— Beberapa label tepi ditentukan dalam kueri.

  *Pesan*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**— Beberapa kendala label vertex ditentukan dalam kueri.

  *Pesan*: `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`**   –   Predikat `Neptune#ml.classification` dan `Neptune#ml.regression` hadir dalam kueri yang sama.

  *Pesan*: `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`**   –   Lebih dari satu label edge ditentukan di langkah `in()` atau `out()`dalam kueri prediksi link.

  *Pesan*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**— Lebih dari satu kunci properti ditentukan dengan Neptunus \$1ml .score.

  *Pesan*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`**   –   Titik akhir tidak ditentukan dalam kueri atau sebagai parameter klaster DB.

  *Pesan*: `No endpoint provided for external service query.`
+ **``MissingParameterException**— Peran IAM eksekusi SageMaker AI tidak ditentukan dalam kueri atau sebagai parameter cluster DB.

  *Pesan*: `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`**   –   Kunci properti hilang dari langkah `properties()` dalam kueri.

  *Pesan*: `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`**   –   Tidak ada label edge yang ditentukan dalam langkah `in()` atau `out()`dari kueri prediksi link.

  *Pesan*: `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`**— Tidak ada kunci properti yang ditentukan dengan Neptunus \$1ml .score.

  *Pesan*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`**   –   Langkah `both()` digunakan dalam kueri prediksi link.

  *Pesan*: `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`**   –   Tidak ada label vertex yang diprediksikan ditentukan dalam langkah `has()` dengan langkah `in()` atau `out()` dalam kueri prediksi link.

  *Pesan*: `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`**— Kueri inferensi induktif Gremlin ML saat ini tidak didukung dengan langkah-langkah yang tidak dioptimalkan.

  *Pesan*: `Neptune ML - Real-Time Inductive Inference queries are currently not supported with Gremlin steps which are not optimized for Neptune. Check the Neptune User Guide for a list of Neptune-optimized steps.`
+ **`UnsupportedOperationException`**— Kueri inferensi Neptunus ML saat ini tidak didukung dalam satu langkah. `repeat`

  *Pesan*: `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`**— Tidak lebih dari satu kueri inferensi Neptunus Neptunus saat ini didukung per kueri Gremlin.

  *Pesan*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`

# Kueri inferensi SPARQL di Neptunus ML
<a name="machine-learning-sparql-inference-queries"></a>

Neptunus ML memetakan grafik RDF ke dalam grafik properti untuk memodelkan Tugas ML. Saat ini, ia mendukung kasus penggunaan berikut:
+ **Klasifikasi objek** — Memprediksi fitur kategoris suatu objek.
+ **Regresi objek** — Memprediksi properti numerik dari suatu objek.
+ **Prediksi objek** — Memprediksi objek yang diberikan subjek dan hubungan.
+ **Prediksi subjek** — Memprediksi subjek yang diberi objek dan hubungan.

**catatan**  
Neptunus ML tidak mendukung klasifikasi subjek dan kasus penggunaan regresi dengan SPARQL.

# Predikat Neptunus Neptunus yang digunakan dalam kueri inferensi SPARQL
<a name="machine-learning-sparql-inference-query-predicates"></a>

Predikat berikut digunakan dengan inferensi SPARQL:

## `neptune-ml:timeout`predikat
<a name="machine-learning-sparql-inference-predicates-timeout"></a>

Menentukan batas waktu untuk koneksi dengan server jarak jauh. Jangan bingung dengan batas waktu permintaan kueri, yang merupakan jumlah waktu maksimum yang dapat diambil server untuk memenuhi permintaan.

Perhatikan bahwa jika batas waktu kueri terjadi sebelum batas waktu layanan yang ditentukan oleh `neptune-ml:timeout` predikat terjadi, sambungan layanan juga dibatalkan.

## `neptune-ml:outputClass`predikat
<a name="machine-learning-sparql-inference-predicates-outputClass"></a>

`neptune-ml:outputClass`Predikat hanya digunakan untuk menentukan kelas objek yang diprediksi untuk prediksi objek atau subjek yang diprediksi untuk prediksi subect.

## `neptune-ml:outputScore`predikat
<a name="machine-learning-sparql-inference-predicates-outputScore"></a>

`neptune-ml:outputScore`Predikat adalah angka positif yang mewakili kemungkinan bahwa output dari model pembelajaran mesin benar.

## `neptune-ml:modelType`predikat
<a name="machine-learning-sparql-inference-predicates-modelType"></a>

`neptune-ml:modelType`Predikat menentukan jenis model pembelajaran mesin yang dilatih:
+ `OBJECT_CLASSIFICATION`
+ `OBJECT_REGRESSION`
+ `OBJECT_PREDICTION`
+ `SUBJECT_PREDICTION`

## `neptune-ml:input`predikat
<a name="machine-learning-sparql-inference-predicates-input"></a>

`neptune-ml:input`Predikat mengacu pada daftar yang URIs digunakan sebagai input untuk Neptunus ML.

## `neptune-ml:output`predikat
<a name="machine-learning-sparql-inference-predicates-output"></a>

`neptune-ml:output`Predikat mengacu pada daftar set pengikatan di mana Neptunus ML mengembalikan hasil.

## `neptune-ml:predicate`predikat
<a name="machine-learning-sparql-inference-predicates-predicate"></a>

`neptune-ml:predicate`Predikat digunakan secara berbeda tergantung pada tugas yang dilakukan:
+ Untuk **prediksi objek atau subjek**: mendefinisikan jenis predikat (tipe tepi atau hubungan).
+ Untuk **klasifikasi dan regresi objek**: mendefinisikan literal (properti) yang ingin kita prediksi.

## `neptune-ml:batchSize`predikat
<a name="machine-learning-sparql-inference-predicates-batchSize"></a>

`neptune-ml:batchSize`Menentukan ukuran input untuk panggilan layanan jarak jauh.

# Contoh klasifikasi objek SPARQL
<a name="machine-learning-sparql-inference-object-classification"></a>

Untuk klasifikasi objek SPARQL di Neptunus ML, model dilatih pada salah satu nilai predikat. Ini berguna di mana predikat itu belum ada dengan subjek tertentu.

Hanya nilai predikat kategoris yang dapat disimpulkan menggunakan model klasifikasi objek.

Kueri berikut berusaha untuk < http://www.example.org/team > memprediksi nilai predikat untuk semua input tipe: `foaf:Person`

```
SELECT * WHERE { ?input a foaf:Person .
  SERVICE neptune-ml:inference {
    neptune-ml:config neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
                      neptune-ml:input ?input ;
                      neptune-ml:predicate <http://www.example.org/team> ;
                      neptune-ml:output ?output .
  }
}
```

Kueri ini dapat disesuaikan sebagai berikut:

```
SELECT * WHERE { ?input a foaf:Person .
  SERVICE neptune-ml:inference {
    neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
                      neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;

                      neptune-ml:batchSize "40"^^xsd:integer ;
                      neptune-ml:timeout "1000"^^xsd:integer ;

                      neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
                      neptune-ml:input ?input ;
                      neptune-ml:predicate <http://www.example.org/team> ;
                      neptune-ml:output ?output .
  }
}
```

# Contoh regresi objek SPARQL
<a name="machine-learning-sparql-inference-object-regression"></a>

Regresi objek mirip dengan klasifikasi objek, kecuali bahwa nilai predikat numerik disimpulkan dari model regresi untuk setiap node. Anda dapat menggunakan kueri SPARQL yang sama untuk regresi objek seperti untuk klasifikasi objek dengan pengecualian bahwa `the Neptune#ml.limit` dan predikat `Neptune#ml.threshold` tidak berlaku.

Kueri berikut berusaha untuk < http://www.example.org/accountbalance > memprediksi nilai predikat untuk semua input tipe: `foaf:Person`

```
SELECT * WHERE { ?input a foaf:Person .
  SERVICE neptune-ml:inference {
    neptune-ml:config neptune-ml:modelType 'OBJECT_REGRESSION' ;
                      neptune-ml:input ?input ;
                      neptune-ml:predicate <http://www.example.org/accountbalance> ;
                      neptune-ml:output ?output .
  }
}
```

Kueri ini dapat disesuaikan sebagai berikut:

```
SELECT * WHERE { ?input a foaf:Person .
  SERVICE neptune-ml:inference {
    neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
                      neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;

                      neptune-ml:batchSize "40"^^xsd:integer ;
                      neptune-ml:timeout "1000"^^xsd:integer ;

                      neptune-ml:modelType 'OBJECT_REGRESSION' ;
                      neptune-ml:input ?input ;
                      neptune-ml:predicate <http://www.example.org/accountbalance> ;
                      neptune-ml:output ?output .
  }
}
```

# Contoh prediksi objek SPARQL
<a name="machine-learning-sparql-inference-object-prediction"></a>

*Prediksi objek* memprediksi nilai objek untuk subjek dan predikat tertentu.

Kueri prediksi objek berikut berupaya memprediksi film apa yang diinginkan oleh masukan tipe`foaf:Person`:

```
?x a foaf:Person .
?x   <http://www.example.org/likes> ?m .
?m a <http://www.example.org/movie> .

## Query
SELECT * WHERE { ?input a foaf:Person .
  SERVICE neptune-ml:inference {
    neptune-ml:config neptune-ml:modelType 'OBJECT_PREDICTION' ;
                      neptune-ml:input ?input ;
                      neptune-ml:predicate <http://www.example.org/likes> ;
                      neptune-ml:output ?output ;
                      neptune-ml:outputClass <http://www.example.org/movie> .
  }
}
```

Kueri itu sendiri dapat disesuaikan sebagai berikut:

```
SELECT * WHERE { ?input a foaf:Person .
  SERVICE neptune-ml:inference {
    neptune-ml:config neptune-ml:endpoint 'node-prediction-user-movie-prediction-endpoint' ;
                      neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;

                      neptune-ml:limit "5"^^xsd:integer ;
                      neptune-ml:batchSize "40"^^xsd:integer ;
                      neptune-ml:threshold "0.1"^^xsd:double ;
                      neptune-ml:timeout "1000"^^xsd:integer ;
                      neptune-ml:outputScore ?score ;

                      neptune-ml:modelType 'OBJECT_PREDICTION' ;
                      neptune-ml:input ?input ;
                      neptune-ml:predicate <http://www.example.org/likes> ;
                      neptune-ml:output ?output ;
                      neptune-ml:outputClass <http://www.example.org/movie> .
  }
}
```

# Contoh prediksi subjek SPARQL
<a name="machine-learning-sparql-inference-subject-prediction"></a>

*Prediksi subjek* memprediksi subjek yang diberi predikat dan objek.

Misalnya, kueri berikut memprediksi siapa (tipe`foaf:User`) yang akan menonton film tertentu:

```
SELECT * WHERE { ?input (a foaf:Movie) .
    SERVICE neptune-ml:inference {
        neptune-ml:config neptune-ml:modelType 'SUBJECT_PREDICTION' ;
                          neptune-ml:input ?input ;
                          neptune-ml:predicate <http://aws.amazon.com/neptune/csv2rdf/object_Property/rated> ;
                          neptune-ml:output ?output ;
                          neptune-ml:outputClass <http://aws.amazon.com/neptune/csv2rdf/class/User> ;        }
}
```

# Daftar pengecualian untuk kueri inferensi Neptunus ML SPARQL
<a name="machine-learning-sparql-exceptions"></a>

****
+ **`BadRequestException`**— *Pesan*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at least 1 value for the parameter (parameter name), found zero.`
+ **`BadRequestException`**— *Pesan*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at most 1 value for the parameter (parameter name), found (a number) values.`
+ **`BadRequestException`**— *Pesan*: `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.`
+ **`BadRequestException`**— *Pesan*:`The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`.
+ **`BadRequestException`**— *Pesan*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the value of (parameter) (parameter name) to be a variable, found: (type)"`
+ **`BadRequestException`**— *Pesan*:`The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`.
+ **`BadRequestException`**— *Pesan*:`The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`.
+ **`BadRequestException`**— *Pesan*:`"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`.
+ **`BadRequestException`**— *Pesan*:`The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`.
+ **`BadRequestException`**— *Pesan*:`The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`.
+ **`BadRequestException`**— *Pesan*:`The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates are expected to be part of the namespace (namespace name), found: (namespace name)`.