Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Amazon Neptunus ML untuk pembelajaran mesin pada grafik
Sering ada informasi berharga dalam set data terhubung yang besar yang sulit untuk diekstrak menggunakan kueri berdasarkan intuisi manusia saja. Teknik machine learning (ML) dapat membantu menemukan korelasi tersembunyi dalam grafik dengan miliaran hubungan. Korelasi ini sangat membantu untuk merekomendasikan produk, memprediksi kelayakan kredit, mengidentifikasi penipuan, dan banyak hal lainnya.
Fitur Neptune ML memungkinkan untuk membangun dan melatih model machine learning yang berguna pada grafik besar dalam hitungan jam, bukan minggu. [Untuk mencapai hal ini, Neptunus ML menggunakan teknologi jaringan saraf grafik (GNN) yang didukung oleh [ SageMaker Amazon](https://aws.amazon.com/sagemaker/) AI dan [Deep Graph Library (DGL) (yang merupakan](https://www.dgl.ai/) sumber terbuka).](https://github.com/dmlc/dgl/) Jaringan saraf grafik adalah bidang yang muncul dalam kecerdasan buatan (lihat, misalnya, [Survei Komprehensif tentang Jaringan Saraf Grafik](https://arxiv.org/abs/1901.00596)). Untuk tutorial langsung tentang penggunaan GNNs dengan DGL, lihat [Mempelajari jaringan saraf grafik dengan Deep](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library) Graph Library.
**catatan**
Grafik vertex diidentifikasi dalam model Neptune ML sebagai “simpul”. Sebagai contoh, klasifikasi vertex menggunakan model machine learning klasifikasi simpul, dan regresi vertex menggunakan model regresi simpul.
## Apa yang bisa dilakukan Neptune ML
Neptunus mendukung inferensi transduktif, yang mengembalikan prediksi yang telah dihitung sebelumnya pada saat pelatihan, berdasarkan data grafik Anda pada waktu itu, dan inferensi induktif, yang mengembalikan menerapkan pemrosesan data dan evaluasi model secara real time, berdasarkan data saat ini. Lihat [Perbedaan antara inferensi induktif dan transduktif](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference).
Neptunus ML dapat melatih model pembelajaran mesin untuk mendukung lima kategori inferensi yang berbeda:
**Jenis tugas inferensi saat ini didukung oleh Neptune ML**
+ **Klasifikasi simpul** — memprediksi fitur kategoris dari properti simpul.
Misalnya, film yang diberikan *The Shawshank Redemption*, Neptune ML dapat memprediksi properti `genre`-nya sebagai `story` dari satu set kandidat `[story, crime, action, fantasy, drama, family, ...]`.
Ada dua jenis tugas klasifikasi simpul:
+ **Klasifikasi kelas tunggal**: Dalam tugas semacam ini, setiap simpul memiliki hanya satu fitur target. Sebagai contoh, properti, `Place_of_birth` dari `Alan Turing` memiliki nilai `UK`.
+ **Klasifikasi kelas ganda**: Dalam tugas semacam ini, setiap simpul memiliki lebih dari satu fitur target. Sebagai contoh, properti `genre` dari film *The Godfather* memiliki nilai `crime`dan `story`.
+ **Regresi simpul** — memprediksi properti numerik dari sebuah simpul.
Misalnya, film yang diberikan *Avengers: Endgame*, Neptune ML dapat memprediksi bahwa propertinya `popularity` memiliki nilai `5.0`.
+ **Klasifikasi tepi** — memprediksi fitur kategoris properti tepi.
Ada dua jenis tugas klasifikasi tepi:
+ **Klasifikasi kelas tunggal**: Dalam tugas semacam ini, setiap tepi hanya memiliki satu fitur target. Misalnya, tepi peringkat antara pengguna dan film mungkin memiliki properti,`liked`, dengan nilai “Ya” atau “Tidak”.
+ **Klasifikasi multi-kelas**: Dalam tugas semacam ini, setiap tepi dapat memiliki lebih dari satu fitur target. Misalnya, peringkat antara pengguna dan film mungkin memiliki beberapa nilai untuk tag properti seperti “Lucu”, “Heartwarming”, “Chilling”, dan sebagainya.
+ **Regresi tepi** — memprediksi properti numerik tepi.
Misalnya, tepi peringkat antara pengguna dan film mungkin memiliki properti numerik`score`, di mana Neptunus ML dapat memprediksi nilai yang diberikan pengguna dan film.
+ **Prediksi tautan** — memprediksi node tujuan yang paling mungkin untuk node sumber tertentu dan tepi keluar, atau node sumber yang paling mungkin untuk node tujuan tertentu dan tepi masuk.
Misalnya, dengan grafik pengetahuan penyakit obat, diberikan `Aspirin` sebagai simpul sumber, dan `treats` sebagai tepi keluar, Neptunus ML dapat memprediksi node tujuan yang paling relevan sebagai,, dan seterusnya. `heart disease` `fever`
Atau, dengan grafik pengetahuan Wikimedia, diberikan `President-of` sebagai edge atau relasi dan `United-States` sebagai simpul tujuan, Neptune ML dapat memprediksi kepala yang paling relevan sebagai `George Washington`, `Abraham Lincoln`, `Franklin D. Roosevelt`, dan sebagainya.
**catatan**
Klasifikasi node dan klasifikasi Edge hanya mendukung nilai 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.
Dengan Neptune ML, Anda dapat menggunakan model machine learning yang termasuk dalam dua kategori umum:
**Jenis model machine learning saat ini didukung oleh Neptune ML**
+ **Model Graph Neural Network (GNN)** — Ini termasuk [Relational Graph Convolutional Networks (](https://arxiv.org/abs/1703.06103)R-). GCNs Model GNN berfungsi untuk ketiga-tiga jenis tugas di atas.
+ **Model Knowledge-Graph Embedding (KGE)** – Ini termasuk model `TransE`, `DistMult`, dan `RotatE`. Mereka hanya sesuai untuk prediksi link.
**Model yang ditentukan pengguna** - Neptunus ML juga memungkinkan Anda menyediakan implementasi model kustom Anda sendiri untuk semua jenis tugas yang tercantum di atas. Anda dapat menggunakan toolkit [Neptunus ML](https://github.com/awslabs/neptuneml-toolkit) untuk mengembangkan dan menguji implementasi model kustom berbasis python Anda sebelum menggunakan API pelatihan Neptunus Neptunus dengan model Anda. Lihat [Model khusus di Neptunus ML](machine-learning-custom-models.md) detail tentang cara menyusun dan mengatur implementasi Anda sehingga kompatibel dengan infrastruktur pelatihan Neptunus ML.
# Menyiapkan Neptunus ML
Cara termudah untuk memulai dengan Neptunus ML adalah dengan [menggunakan CloudFormation template quick-start](machine-learning-quick-start.md). Template ini menginstal semua komponen yang diperlukan, termasuk cluster DB Neptunus baru, semua peran IAM yang diperlukan, dan notebook grafik Neptunus baru untuk mempermudah bekerja dengan Neptunus ML.
Anda juga dapat menginstal Neptunus ML secara manual, seperti yang dijelaskan di. [Menyiapkan Neptunus ML tanpa menggunakan template quick-start CloudFormation](machine-learning-manual-setup.md)
# Menggunakan template Neptunus AWS CloudFormation ML untuk memulai dengan cepat di cluster DB baru
Cara termudah untuk memulai dengan Neptunus ML adalah dengan menggunakan CloudFormation template quick-start. Template ini menginstal semua komponen yang diperlukan, termasuk cluster DB Neptunus baru, semua peran IAM yang diperlukan, dan notebook grafik Neptunus baru untuk mempermudah bekerja dengan Neptunus ML.
**Untuk membuat tumpukan mulai cepat Neptune ML**
1. Untuk meluncurkan CloudFormation tumpukan di CloudFormation konsol, pilih salah satu tombol **Launch Stack** di tabel berikut:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/machine-learning-quick-start.html)
1. Pada halaman **Pilih Templat**, pilih **Selanjutnya**.
1. Pada halaman **Tentukan Detail**, pilih **Selanjutnya**.
1. Pada halaman **Opsi**, pilih **Selanjutnya**.
1. Pada halaman **Ulasan**, ada dua kotak centang yang perlu Anda centang:
+ Yang pertama mengakui bahwa AWS CloudFormation mungkin membuat sumber daya IAM dengan nama khusus.
+ Yang kedua mengakui bahwa AWS CloudFormation mungkin memerlukan `CAPABILITY_AUTO_EXPAND` kemampuan untuk tumpukan baru. `CAPABILITY_AUTO_EXPAND`secara eksplisit memungkinkan CloudFormation untuk memperluas makro secara otomatis saat membuat tumpukan, tanpa tinjauan sebelumnya.
Pelanggan sering membuat set perubahan dari template yang diproses sehingga perubahan yang dibuat oleh makro dapat ditinjau sebelum benar-benar membuat tumpukan. Untuk informasi selengkapnya, lihat CloudFormation [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html)API.
Lalu pilih **Buat**.
Template mulai cepat membuat dan mengatur berikut ini:
+ Klaster DB Neptune.
+ IAM role yang diperlukan (dan melampirkannya).
+ Grup EC2 keamanan Amazon yang diperlukan.
+ Titik akhir SageMaker AI VPC yang diperlukan.
+ Sebuah grup parameter klaster DB untuk Neptune ML.
+ Parameter yang diperlukan dalam grup parameter itu.
+ Notebook SageMaker AI dengan sampel notebook yang sudah terisi sebelumnya untuk Neptunus ML. Perhatikan bahwa tidak semua ukuran instans tersedia di setiap wilayah, jadi Anda harus memastikan bahwa ukuran instans notebook yang dipilih adalah salah satu yang didukung wilayah Anda.
+ Layanan Ekspor Neptune.
Saat tumpukan mulai cepat siap, buka notebook SageMaker AI yang dibuat template dan lihat contoh yang telah diisi sebelumnya. Mereka akan membantu Anda men-download set data sampel untuk digunakan bereksperimen dengan kemampuan Neptune ML.
Mereka juga dapat menghemat banyak waktu saat Anda menggunakan Neptune ML. Misalnya, lihat sihir [%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml) garis, dan sihir [%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml) sel yang didukung notebook ini.
Anda juga dapat menggunakan AWS CLI perintah berikut untuk menjalankan template quick-start CloudFormation :
```
aws cloudformation create-stack \
--stack-name neptune-ml-fullstack-$(date '+%Y-%m-%d-%H-%M') \
--template-url https://aws-neptune-customer-samples.s3.amazonaws.com/v2/cloudformation-templates/neptune-ml-nested-stack.json \
--parameters ParameterKey=EnableIAMAuthOnExportAPI,ParameterValue=(true if you have IAM auth enabled, or false otherwise) \
ParameterKey=Env,ParameterValue=test$(date '+%H%M')\
--capabilities CAPABILITY_IAM \
--region (the AWS region, like us-east-1) \
--disable-rollback \
--profile (optionally, a named CLI profile of yours)
```
# Menyiapkan Neptunus ML tanpa menggunakan template quick-start CloudFormation
Panduan ini memberikan step-by-step petunjuk untuk menyiapkan Amazon Neptunus ML tanpa menggunakan AWS CloudFormation templat mulai cepat. Ini mengasumsikan Anda sudah memiliki cluster DB Neptunus yang berfungsi dan mencakup pengaturan yang diperlukan, termasuk menginstal layanan Neptunus-Ekspor, membuat peran IAM khusus, dan mengonfigurasi cluster DB Anda untuk mengaktifkan Neptunus ML. Panduan ini juga menjelaskan cara membuat dua titik akhir SageMaker AI di VPC Neptunus Anda untuk memberi mesin Neptunus akses ke manajemen AI yang diperlukan. SageMaker APIs Dengan mengikuti petunjuk ini, Anda dapat mengatur Neptunus ML pada infrastruktur Neptunus yang ada tanpa bergantung pada template. CloudFormation
## Mulailah dengan cluster DB Neptunus yang berfungsi
Jika Anda tidak menggunakan template CloudFormation mulai cepat untuk menyiapkan Neptunus ML, Anda memerlukan cluster DB Neptunus yang ada untuk bekerja dengannya. Jika mau, Anda dapat menggunakan yang sudah Anda miliki, atau mengkloning yang sudah Anda gunakan, atau Anda dapat membuat yang baru (lihat[Buat cluster Neptunus](get-started-create-cluster.md)).
## Menginstal layanan Neptune-Ekspor
Jika Anda belum melakukannya, instal layanan Neptune-Export, seperti yang dijelaskan di. [Menggunakan layanan Neptunus-Ekspor untuk mengekspor data Neptunus](export-service.md)
Tambahkan aturan masuk ke grup `NeptuneExportSecurityGroup` keamanan yang dibuat penginstalan, dengan pengaturan berikut:
+ *Jenis*: `Custom TCP`
+ *Protokol*: `TCP`
+ *Rentang port*: `80 - 443`
+ *Sumber:* *(Neptune DB cluster security group ID)*
## Buat peran IAM NeptuneLoadFrom S3 kustom
Jika Anda belum melakukannya, buat peran `NeptuneLoadFromS3` IAM khusus, seperti yang dijelaskan di[Membuat peran IAM untuk mengakses Amazon S3](bulk-load-tutorial-IAM-CreateRole.md).
## Buat NeptuneSageMaker IAMRole peran khusus
Gunakan [konsol IAM](https://console.aws.amazon.com/iam/) untuk membuat kustom`NeptuneSageMakerIAMRole`, menggunakan kebijakan berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:CreateNetworkInterface",
"ec2:CreateNetworkInterfacePermission",
"ec2:CreateVpcEndpoint",
"ec2:DeleteNetworkInterface",
"ec2:DeleteNetworkInterfacePermission",
"ec2:DescribeDhcpOptions",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeRouteTables",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSubnets",
"ec2:DescribeVpcEndpoints",
"ec2:DescribeVpcs"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"ecr:GetAuthorizationToken",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::*:role/*"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"sagemaker.amazonaws.com"
]
}
},
"Effect": "Allow"
},
{
"Action": [
"kms:CreateGrant",
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "arn:aws:kms:*:*:key/*",
"Effect": "Allow"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams",
"logs:GetLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:log-group:/aws/sagemaker/*"
],
"Effect": "Allow"
},
{
"Action": [
"sagemaker:AddTags",
"sagemaker:CreateEndpoint",
"sagemaker:CreateEndpointConfig",
"sagemaker:CreateHyperParameterTuningJob",
"sagemaker:CreateModel",
"sagemaker:CreateProcessingJob",
"sagemaker:CreateTrainingJob",
"sagemaker:CreateTransformJob",
"sagemaker:DeleteEndpoint",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteModel",
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:DescribeHyperParameterTuningJob",
"sagemaker:DescribeModel",
"sagemaker:DescribeProcessingJob",
"sagemaker:DescribeTrainingJob",
"sagemaker:DescribeTransformJob",
"sagemaker:InvokeEndpoint",
"sagemaker:ListTags",
"sagemaker:ListTrainingJobsForHyperParameterTuningJob",
"sagemaker:StopHyperParameterTuningJob",
"sagemaker:StopProcessingJob",
"sagemaker:StopTrainingJob",
"sagemaker:StopTransformJob",
"sagemaker:UpdateEndpoint",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": [
"arn:aws:sagemaker:*:*:*"
],
"Effect": "Allow"
},
{
"Action": [
"sagemaker:ListEndpointConfigs",
"sagemaker:ListEndpoints",
"sagemaker:ListHyperParameterTuningJobs",
"sagemaker:ListModels",
"sagemaker:ListProcessingJobs",
"sagemaker:ListTrainingJobs",
"sagemaker:ListTransformJobs"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject",
"s3:AbortMultipartUpload",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::*"
],
"Effect": "Allow"
}
]
}
```
------
Saat membuat peran ini, edit hubungan kepercayaan sehingga berbunyi sebagai berikut:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"ec2.amazonaws.com",
"rds.amazonaws.com",
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Terakhir, salin ARN yang ditugaskan untuk peran baru `NeptuneSageMakerIAMRole` ini.
**penting**
Pastikan izin Amazon S3 `NeptuneSageMakerIAMRole` sesuai dengan yang di atas.
ARN universal, `arn:aws:s3:::*` digunakan untuk sumber daya Amazon S3 dalam kebijakan di atas. Jika karena alasan tertentu ARN universal tidak dapat digunakan, maka `arn:aws:s3:::graphlytics*` dan ARN untuk sumber daya Amazon S3 pelanggan lain yang akan digunakan perintah Neptuneml harus ditambahkan ke bagian sumber daya.
## Konfigurasikan cluster DB Anda untuk mengaktifkan Neptunus ML
**Untuk mengatur cluster DB Anda untuk Neptunus ML**
1. Di konsol [Neptunus](https://console.aws.amazon.com/neptune), navigasikan **ke Grup Parameter dan kemudian ke grup parameter** cluster DB yang terkait dengan cluster DB yang akan Anda gunakan. Atur `neptune_ml_iam_role` parameter ke ARN yang ditetapkan ke `NeptuneSageMakerIAMRole` peran yang baru saja Anda buat.
1. Arahkan ke Database, lalu pilih cluster DB yang akan Anda gunakan untuk Neptunus ML. Pilih **Tindakan** lalu **Kelola peran IAM**.
1. Pada halaman **Kelola peran IAM**, pilih **Tambah peran** dan tambahkan. `NeptuneSageMakerIAMRole` Kemudian tambahkan `NeptuneLoadFromS3` peran.
1. Reboot instance penulis dari cluster DB Anda.
## Buat dua titik akhir SageMaker AI di VPC Neptunus Anda
Terakhir, untuk memberi akses mesin Neptunus APIs manajemen AI yang SageMaker diperlukan, Anda perlu membuat SageMaker dua titik akhir AI di VPC Neptunus Anda, seperti yang dijelaskan dalam. [Buat dua titik akhir untuk SageMaker AI di VPC Neptunus Anda](machine-learning-cluster-setup.md#machine-learning-sm-endpoints)
# Mengkonfigurasi notebook Neptunus secara manual untuk Neptunus ML
Notebook SageMaker Neptunus AI hadir dengan berbagai notebook sampel untuk Neptunus ML. Anda dapat melihat pratinjau sampel ini di [repositori grafik-notebook GitHub sumber terbuka](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning).
Anda dapat menggunakan salah satu notebook Neptunus yang ada, atau jika mau, Anda dapat membuatnya sendiri, mengikuti instruksi di. [Menggunakan workbench Neptune untuk meng-host notebook Neptune](graph-notebooks.md#graph-notebooks-workbench)
Anda juga dapat mengonfigurasi notebook Neptunus default untuk digunakan dengan Neptunus ML dengan mengikuti langkah-langkah berikut:
**Memodifikasi notebook untuk Neptunus ML**
1. Buka konsol Amazon SageMaker AI di [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Pada panel navigasi di sebelah kiri, pilih **Notebook**, lalu **Instans Notebook**. Cari nama notebook Neptunus yang ingin Anda gunakan untuk Neptunus ML dan pilih untuk membuka halaman detailnya.
1. Jika instance notebook sedang berjalan, pilih tombol **Stop** di kanan atas halaman detail notebook.
1. Di **pengaturan instans Notebook**, di bawah **Konfigurasi Siklus Hidup**, pilih tautan untuk membuka halaman siklus hidup buku catatan.
1. Pilih **Edit** di kanan atas, lalu **Lanjutkan**.
1. Di tab **Start notebook**, ubah skrip untuk menyertakan perintah ekspor tambahan dan untuk mengisi bidang untuk peran Neptunus MLIAM Anda dan URI layanan Ekspor, sesuatu seperti ini tergantung pada shell Anda:
```
echo "export NEPTUNE_ML_ROLE_ARN=(your Neptune ML IAM role ARN)" >> ~/.bashrc
echo "export NEPTUNE_EXPORT_API_URI=(your export service URI)" >> ~/.bashrc
```
1. Pilih **Perbarui**.
1. Kembali ke halaman instance notebook. Di bawah **Izin dan enkripsi** ada bidang untuk peran **IAM ARN**. Pilih tautan di bidang ini untuk pergi ke peran IAM yang dijalankan oleh instance notebook ini.
1. Buat kebijakan inline baru seperti ini:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "arn:aws:cloudwatch:us-east-1:111122223333:*",
"Sid": "AllowPutMetrics",
"Effect": "Allow"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogStreams",
"logs:PutLogEvents",
"logs:GetLogEvents"
],
"Resource": "arn:aws:logs:us-east-1:111122223333:*",
"Sid": "AllowCreateLogs",
"Effect": "Allow"
},
{
"Action": [
"s3:Put*",
"s3:Get*",
"s3:List*"
],
"Resource": "arn:aws:s3:::*",
"Sid": "AllowS3Actions",
"Effect": "Allow"
},
{
"Action": "execute-api:Invoke",
"Resource": "arn:aws:execute-api:us-east-1:111122223333:*/*",
"Sid": "AllowExecute",
"Effect": "Allow"
},
{
"Action": [
"sagemaker:CreateModel",
"sagemaker:CreateEndpointConfig",
"sagemaker:CreateEndpoint",
"sagemaker:DescribeModel",
"sagemaker:DescribeEndpointConfig",
"sagemaker:DescribeEndpoint",
"sagemaker:DeleteModel",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteEndpoint"
],
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:*/*",
"Sid": "AllowApiActions",
"Effect": "Allow"
},
{
"Action": [
"iam:PassRole"
],
"Resource": "arn:aws:iam::111122223333:role/role-name",
"Sid": "AllowPassRole",
"Effect": "Allow"
}
]
}
```
------
1. Simpan kebijakan baru ini dan lampirkan ke peran IAM di Langkah 8.
1. Pilih **Mulai** di kanan atas halaman detail instans notebook SageMaker AI untuk memulai instance notebook.
# Menggunakan AWS CLI untuk mengatur Neptunus MLpada cluster DB
Selain template CloudFormation mulai cepat dan Konsol Manajemen AWS, Anda juga dapat mengatur Neptunus ML menggunakan file. AWS CLI
## Buat grup parameter cluster DB untuk cluster Neptunus MLmu yang baru
AWS CLI Perintah berikut membuat grup parameter cluster DB baru dan mengaturnya untuk bekerja dengan Neptunus ML:
**Untuk membuat dan mengkonfigurasi grup parameter klaster DB untuk Neptune ML**
1. Buat grup parameter klaster DB baru:
```
aws neptune create-db-cluster-parameter-group \
--db-cluster-parameter-group-name (name of the new DB cluster parameter group) \
--db-parameter-group-family neptune1
--description "(description of your machine learning project)" \
--region (AWS region, such as us-east-1)
```
1. Buat parameter cluster `neptune_ml_iam_role` DB yang disetel ke ARN `SageMakerExcecutionIAMRole` untuk digunakan cluster DB Anda saat memanggil SageMaker AI untuk membuat pekerjaan dan mendapatkan prediksi dari model ML-host:
```
aws neptune modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name (name of the new DB cluster parameter group) \
--parameters "ParameterName=neptune_ml_iam_role, \
ParameterValue=ARN of the SageMakerExcecutionIAMRole, \
Description=NeptuneMLRole, \
ApplyMethod=pending-reboot" \
--region (AWS region, such as us-east-1)
```
Menyetel parameter ini memungkinkan Neptunus untuk SageMaker mengakses AI tanpa Anda harus meneruskan peran dengan setiap panggilan.
Untuk informasi tentang cara membuat `SageMakerExcecutionIAMRole`, lihat [Buat NeptuneSageMaker IAMRole peran khusus](machine-learning-manual-setup.md#ml-manual-setup-sm-role).
1. Akhirnya, gunakan `describe-db-cluster-parameters` untuk memeriksa bahwa semua parameter dalam grup parameter klaster DB baru ditetapkan seperti yang Anda inginkan menjadi:
```
aws neptune describe-db-cluster-parameters \
--db-cluster-parameter-group-name (name of the new DB cluster parameter group) \
--region (AWS region, such as us-east-1)
```
## Melampirkan grup parameter klaster DB baru untuk klaster DB yang Anda gunakan dengan Neptune ML
Sekarang Anda dapat melampirkan grup parameter klaster DB baru yang baru saja Anda buat untuk klaster DB yang ada dengan menggunakan perintah berikut:
```
aws neptune modify-db-cluster \
--db-cluster-identifier (the name of your existing DB cluster) \
--apply-immediately
--db-cluster-parameter-group-name (name of your new DB cluster parameter group) \
--region (AWS region, such as us-east-1)
```
Untuk membuat semua parameter efektif, Anda dapat me-reboot klaster DB:
```
aws neptune reboot-db-instance
--db-instance-identifier (name of the primary instance of your DB cluster) \
--profile (name of your AWS profile to use) \
--region (AWS region, such as us-east-1)
```
Atau, jika Anda membuat klaster DB baru untuk digunakan dengan Neptune ML, Anda dapat menggunakan perintah berikut untuk membuat klaster dengan grup parameter baru yang dilampirkan, dan kemudian buat instans (penulis) primer baru:
```
cluster-name=(the name of the new DB cluster)
aws neptune create-db-cluster
--db-cluster-identifier ${cluster-name}
--engine graphdb \
--engine-version 1.0.4.1 \
--db-cluster-parameter-group-name (name of your new DB cluster parameter group) \
--db-subnet-group-name (name of the subnet to use) \
--region (AWS region, such as us-east-1)
aws neptune create-db-instance
--db-cluster-identifier ${cluster-name}
--db-instance-identifier ${cluster-name}-i \
--db-instance-class (the instance class to use, such as db.r5.xlarge)
--engine graphdb \
--region (AWS region, such as us-east-1)
```
## Lampirkan `NeptuneSageMakerIAMRole` ke cluster DB Anda sehingga dapat mengakses sumber daya SageMaker AI dan Amazon S3
Terakhir, ikuti instruksi [Buat NeptuneSageMaker IAMRole peran khusus](machine-learning-manual-setup.md#ml-manual-setup-sm-role) untuk membuat peran IAM yang memungkinkan cluster DB Anda berkomunikasi dengan SageMaker AI dan Amazon S3. Kemudian, gunakan perintah berikut untuk melampirkan `NeptuneSageMakerIAMRole` peran yang Anda buat ke cluster DB Anda:
```
aws neptune add-role-to-db-cluster
--db-cluster-identifier ${cluster-name}
--role-arn arn:aws:iam::(the ARN number of the role's ARN):role/NeptuneMLRole \
--region (AWS region, such as us-east-1)
```
## Buat dua titik akhir untuk SageMaker AI di VPC Neptunus Anda
Neptunus L membutuhkan SageMaker dua titik akhir AI di VPC cluster Neptunus DB Anda:
+ `com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime`
+ `com.amazonaws.(AWS region, like us-east-1).sagemaker.api`
Jika Anda belum menggunakan CloudFormation templat mulai cepat, yang membuatnya secara otomatis untuk Anda, Anda dapat menggunakan AWS CLI perintah berikut untuk membuatnya:
Yang satu ini membuat titik akhir `sagemaker.runtime`:
```
aws ec2 create-vpc-endpoint
--vpc-id (the ID of your Neptune DB cluster's VPC)
--vpc-endpoint-type Interface
--service-name com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime
--subnet-ids (the subnet ID or IDs that you want to use)
--security-group-ids (the security group for the endpoint network interface, or omit to use the default)
--private-dns-enabled
```
Dan yang satu ini membuat titik akhir `sagemaker.api`:
```
aws ec2 create-vpc-endpoint
--vpc-id (the ID of your Neptune DB cluster's VPC)
--vpc-endpoint-type Interface
--service-name com.amazonaws.(AWS region, like us-east-1).sagemaker.api
--subnet-ids (the subnet ID or IDs that you want to use)
--security-group-ids (the security group for the endpoint network interface, or omit to use the default)
--private-dns-enabled
```
Anda juga dapat menggunakan [Konsol VPC](https://console.aws.amazon.com/vpc/) untuk membuat titik akhir ini. Lihat [Panggilan prediksi aman di Amazon SageMaker dengan AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/secure-prediction-calls-in-amazon-sagemaker-with-aws-privatelink/) dan [Mengamankan semua panggilan SageMaker API Amazon](https://aws.amazon.com/blogs/machine-learning/securing-all-amazon-sagemaker-api-calls-with-aws-privatelink/) dengan. AWS PrivateLink
## Buat parameter titik akhir inferensi SageMaker AI di grup parameter cluster DB Anda
Untuk menghindari keharusan menentukan titik akhir inferensi SageMaker AI dari model yang Anda gunakan di setiap kueri yang Anda buat, buat parameter cluster DB yang dinamai `neptune_ml_endpoint` dalam grup parameter cluster DB untuk Neptunus ML. Mengatur parameter ke `id` dari titik akhir instans di pertanyaan.
Anda dapat menggunakan AWS CLI perintah berikut untuk melakukannya:
```
aws neptune modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name neptune-ml-demo \
--parameters "ParameterName=neptune_ml_endpoint, \
ParameterValue=(the name of the SageMaker AI inference endpoint you want to query), \
Description=NeptuneMLEndpoint, \
ApplyMethod=pending-reboot" \
--region (AWS region, such as us-east-1)
```
# Gambaran umum cara menggunakan fitur Neptune ML
Fitur Neptunus ML di Amazon Neptunus menyediakan alur kerja yang efisien untuk memanfaatkan model pembelajaran mesin dalam database grafik. Prosesnya melibatkan beberapa langkah kunci - mengekspor data dari Neptunus ke dalam format CSV, memproses data terlebih dahulu untuk mempersiapkannya untuk pelatihan model, melatih model pembelajaran mesin menggunakan SageMaker Amazon AI, membuat titik akhir inferensi untuk menyajikan prediksi, dan kemudian menanyakan model langsung dari kueri Gremlin. Meja kerja Neptunus menyediakan perintah ajaib garis dan sel yang nyaman untuk membantu mengelola dan mengotomatiskan langkah-langkah ini. Dengan mengintegrasikan kemampuan pembelajaran mesin langsung ke dalam database grafik, Neptunus ML memungkinkan pengguna untuk memperoleh wawasan berharga dan membuat prediksi menggunakan data relasional kaya yang disimpan dalam grafik Neptunus.
## Memulai alur kerja untuk menggunakan Neptunus ML
Menggunakan fitur Neptunus ML di Amazon Neptunus umumnya melibatkan lima langkah berikut untuk memulai:
![\[Diagram alur kerja Neptune ML\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/neptune-ML-workflow.png)
1. **Ekspor dan konfigurasi data** – Langkah ekspor data menggunakan layanan Ekspor Neptune atau alat baris perintah `neptune-export` untuk mengekspor data dari Neptune ke Amazon Simple Storage Service (Amazon S3) dalam bentuk CSV. Sebuah file konfigurasi bernama `training-data-configuration.json` secara otomatis dihasilkan pada saat yang sama, yang menentukan bagaimana data yang diekspor dapat dimuat ke dalam grafik yang dapat dilatih.
1. **Prapemrosesan data** – Pada langkah ini, set data yang diekspor diproses sebelumnya menggunakan teknik standar guna dipersiapkan untuk pelatihan model. Normalisasi fitur dapat dilakukan untuk data numerik, dan fitur teks dapat dikodekan menggunakan `word2vec`. Pada akhir langkah ini, grafik DGL (Deep Graph library) dihasilkan dari set data yang diekspor untuk langkah pelatihan model yang akan digunakan.
Langkah ini diterapkan menggunakan pekerjaan pemrosesan SageMaker AI di akun Anda, dan data yang dihasilkan disimpan di lokasi Amazon S3 yang telah Anda tentukan.
1. **Pelatihan model** – Langkah pelatihan model melatih model pembelajaran mesin yang akan digunakan untuk prediksi.
Pelatihan model dilakukan dalam dua tahap:
+ Tahap pertama menggunakan pekerjaan pemrosesan SageMaker AI untuk menghasilkan set konfigurasi strategi pelatihan model yang menentukan jenis model dan rentang hiperparameter model apa yang akan digunakan untuk pelatihan model.
+ Tahap kedua kemudian menggunakan pekerjaan penyetelan model SageMaker AI untuk mencoba konfigurasi hyperparameter yang berbeda dan memilih pekerjaan pelatihan yang menghasilkan model berkinerja terbaik. Pekerjaan tuning menjalankan sejumlah uji coba pekerjaan pelatihan model yang telah ditentukan sebelumnya pada data yang diproses. Pada akhir tahap ini, parameter model terlatih dari pekerjaan pelatihan terbaik digunakan untuk menghasilkan artefak model untuk inferensi.
1. **Buat titik akhir inferensi di Amazon SageMaker AI — Titik** akhir inferensi adalah instance titik akhir SageMaker AI yang diluncurkan dengan artefak model yang dihasilkan oleh pekerjaan pelatihan terbaik. Setiap model terikat pada titik akhir tunggal. Titik akhir mampu menerima permintaan masuk dari basis data grafik dan mengembalikan prediksi model untuk input dalam permintaan. Setelah Anda membuat titik akhir, itu tetap aktif sampai Anda menghapusnya.
1. **Query model pembelajaran mesin menggunakan Gremlin** – Anda dapat menggunakan ekstensi ke bahasa kueri Gremlin untuk kueri prediksi dari titik akhir inferensi.
**catatan**
Parameter [Neptune Workbench](graph-notebooks.md#graph-notebooks-workbench) berisi magic baris dan magic sel yang dapat menghemat banyak waktu mengelola langkah-langkah ini, yaitu:
[%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml)
[%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml)
# Membuat prediksi berdasarkan data grafik yang berkembang
Dengan grafik yang terus berubah, Anda mungkin ingin membuat prediksi batch baru secara berkala menggunakan data baru. Menanyakan prediksi yang telah dihitung sebelumnya (inferensi transduktif) dapat secara signifikan lebih cepat daripada menghasilkan prediksi baru dengan cepat berdasarkan data terbaru (inferensi induktif). Kedua pendekatan memiliki tempatnya, tergantung pada seberapa cepat data Anda berubah dan persyaratan kinerja Anda.
## Perbedaan antara inferensi induktif dan transduktif
Saat melakukan inferensi transduktif, Neptunus mencari dan mengembalikan prediksi yang telah dihitung sebelumnya pada saat pelatihan.
Saat melakukan inferensi induktif, Neptunus membangun subgraf yang relevan dan mengambil propertinya. Model DGL GNN kemudian menerapkan pemrosesan data dan evaluasi model secara real-time.
Oleh karena itu, inferensi induktif dapat menghasilkan prediksi yang melibatkan node dan tepi yang tidak ada pada saat pelatihan dan yang mencerminkan keadaan grafik saat ini. Ini datang, bagaimanapun, dengan biaya latensi yang lebih tinggi.
Jika grafik Anda dinamis, Anda mungkin ingin menggunakan inferensi induktif untuk memastikan memperhitungkan data terbaru, tetapi jika grafik Anda statis, inferensi transduktif lebih cepat dan lebih efisien.
Inferensi induktif dinonaktifkan secara default. Anda dapat mengaktifkannya untuk kueri dengan menggunakan [Neptunus \$1ml .InductiveInference](machine-learning-gremlin-inference-query-predicates.md#machine-learning-gremlin-inference-neptune-ml-inductiveInference) predikat Gremlin dalam kueri sebagai berikut:
```
.with( "Neptune#ml.inductiveInference")
```
# Alur kerja transduktif inkremental
Saat Anda memperbarui artefak model hanya dengan menjalankan kembali langkah satu hingga tiga (dari **ekspor Data dan konfigurasi** ke **transformasi Model**), Neptunus MLmendukung cara yang lebih sederhana untuk memperbarui prediksi batch MLmu menggunakan data baru. Salah satunya adalah menggunakan [alur kerja model tambahan,](#machine-learning-overview-incremental) dan yang lainnya adalah menggunakan [pelatihan ulang model](#machine-learning-overview-model-retraining) dengan awal yang hangat.
## Alur kerja model tambahan
Dalam alur kerja ini, Anda memperbarui prediksi ML tanpa melatih ulang model ML.
**catatan**
Anda hanya dapat melakukan ini ketika data grafik telah diperbarui dengan node dan/atau tepi baru. Saat ini tidak akan berfungsi ketika node dihapus.
1. **Ekspor dan konfigurasi data** — Langkah ini sama dengan alur kerja utama.
1. **Preprocessing data inkremental** — Langkah ini mirip dengan langkah preprocessing data dalam alur kerja utama, tetapi menggunakan konfigurasi pemrosesan yang sama yang digunakan sebelumnya, yang sesuai dengan model terlatih tertentu.
1. **Transformasi model** — Alih-alih langkah pelatihan model, langkah transformasi model ini mengambil model terlatih dari alur kerja utama dan hasil langkah pra-pemrosesan data tambahan, dan menghasilkan artefak model baru untuk digunakan untuk inferensi. Langkah transformasi model meluncurkan pekerjaan pemrosesan SageMaker AI untuk melakukan perhitungan yang menghasilkan artefak model yang diperbarui.
1. **Perbarui titik akhir inferensi Amazon SageMaker AI — Secara opsional, jika Anda memiliki titik** akhir inferensi yang ada, langkah ini memperbarui titik akhir dengan artefak model baru yang dihasilkan oleh langkah transformasi model. Atau, Anda juga dapat membuat titik akhir inferensi baru dengan artefak model baru.
## Model pelatihan ulang dengan awal yang hangat
Dengan menggunakan alur kerja ini, Anda dapat melatih dan menerapkan model ML baru untuk membuat prediksi menggunakan data grafik tambahan, tetapi mulai dari model yang ada yang dihasilkan menggunakan alur kerja utama:
1. **Ekspor dan konfigurasi data** — Langkah ini sama dengan alur kerja utama.
1. **Preprocessing data inkremental** — Langkah ini sama dengan alur kerja inferensi model inkremental. Data grafik baru harus diproses dengan metode pemrosesan yang sama yang digunakan sebelumnya untuk pelatihan model.
1. **Pelatihan model dengan awal yang hangat** — Pelatihan model mirip dengan apa yang terjadi di alur kerja utama, tetapi Anda dapat mempercepat pencarian hiperparameter model dengan memanfaatkan informasi dari tugas pelatihan model sebelumnya.
1. **Perbarui titik akhir inferensi Amazon SageMaker AI** — Langkah ini sama seperti pada alur kerja inferensi model inkremental.
# Alur kerja untuk model kustom di Neptunus ML
Neptunus ML memungkinkan Anda mengimplementasikan, melatih, dan menerapkan model kustom Anda sendiri untuk tugas apa pun yang didukung Neptunus ML. Alur kerja untuk mengembangkan dan menerapkan model khusus pada dasarnya sama dengan model bawaan, dengan beberapa perbedaan, seperti yang dijelaskan dalam. [Alur kerja model kustom](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow)
# Pemilihan instans untuk tahapan Neptunus Neptunus
Tahapan pemrosesan Neptunus ML yang berbeda menggunakan SageMaker instance AI yang berbeda. Di sini, kita membahas bagaimana memilih jenis instance yang tepat untuk setiap tahap. Anda dapat menemukan informasi tentang jenis dan harga instans SageMaker AI di [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Memilih instance untuk pemrosesan data
Langkah [pemrosesan data SageMaker ](machine-learning-on-graphs-processing.md) AI memerlukan [instance pemrosesan](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) yang memiliki memori dan penyimpanan disk yang cukup untuk data input, perantara, dan output. Jumlah memori dan penyimpanan disk tertentu yang diperlukan tergantung pada karakteristik grafik Neptune ML dan fitur yang diekspor.
Secara default, Neptunus ML memilih instance `ml.r5` terkecil yang memorinya sepuluh kali lebih besar dari ukuran data grafik yang diekspor pada disk.
## Memilih contoh untuk pelatihan model dan transformasi model
Memilih jenis instans yang tepat untuk [pelatihan model](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) [atau transformasi model](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-batch.html) bergantung pada jenis tugas, ukuran grafik, dan persyaratan putaran Anda. Instans GPU memberikan kinerja terbaik. Kami biasanya merekomendasikan `p3` dan contoh `g4dn` serial. Anda juga dapat menggunakan `p2` atau `p4d` contoh.
Secara default, Neptunus ML memilih instans GPU terkecil dengan lebih banyak memori daripada yang dibutuhkan pelatihan model dan transformasi model. Anda dapat menemukan pilihan apa yang ada di `train_instance_recommendation.json` file, di lokasi keluaran pemrosesan data Amazon S3. Berikut adalah contoh isi `train_instance_recommendation.json` file:
```
{
"instance": "(the recommended instance type for model training and transform)",
"cpu_instance": "(the recommended instance type for base processing instance)",
"disk_size": "(the estimated disk space required)",
"mem_size": "(the estimated memory required)"
}
```
## Memilih instance untuk titik akhir inferensi
Memilih jenis instans yang tepat untuk [titik akhir inferensi](machine-learning-on-graphs-inference-endpoint.md) tergantung pada jenis tugas, ukuran grafik, dan anggaran Anda. Secara default, Neptunus ML memilih instance `ml.m5d` terkecil dengan lebih banyak memori yang dibutuhkan titik akhir inferensi.
**catatan**
Jika lebih dari 384 GB memori diperlukan, Neptunus ML menggunakan sebuah instance. `ml.r5d.24xlarge`
Anda dapat melihat jenis instance apa yang direkomendasikan Neptunus ML dalam file `infer_instance_recommendation.json` yang terletak di lokasi Amazon S3 yang Anda gunakan untuk pelatihan model. Berikut adalah contoh isi file itu:
```
{
"instance" : "(the recommended instance type for an inference endpoint)",
"disk_size" : "(the estimated disk space required)",
"mem_size" : "(the estimated memory required)"
}
```
# Menggunakan alat ekspor neptunus atau layanan Ekspor Neptunus untuk mengekspor data dari Neptunus untuk Neptunus
Neptunus ML mengharuskan Anda menyediakan data pelatihan untuk [Deep Graph Library (DGL](https://www.dgl.ai/)) untuk membuat dan mengevaluasi model.
[Anda dapat mengekspor data dari Neptunus menggunakan layanan Neptunus-Ekspor[, atau utilitas](export-service.md). `neptune-export`](export-utility.md) Baik layanan dan alat baris perintah mempublikasikan data ke Amazon Simple Storage Service (Amazon S3) dalam format CSV, dienkripsi menggunakan enkripsi sisi server Amazon S3 (). `SSE-S3` Lihat [File yang diekspor oleh Neptune-Ekspor dan `neptune-export`](exported-files.md).
Selain itu, saat Anda mengonfigurasi ekspor data pelatihan untuk Neptunus, tugas ekspor akan membuat dan menerbitkan file konfigurasi pelatihan model terenkripsi bersama dengan data yang diekspor. Secara default, file ini diberi nama`training-data-configuration.json`.
# Contoh penggunaan layanan Neptunus-Ekspor untuk mengekspor data pelatihan untuk Neptunus ML
Permintaan ini mengekspor data pelatihan grafik properti untuk tugas klasifikasi simpul:
```
curl \
(your NeptuneExportApiUri) \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification"
}
]
}
}
}'
```
Permintaan ini mengekspor data pelatihan RDF untuk tugas klasifikasi node:
```
curl \
(your NeptuneExportApiUri) \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"command": "export-rdf",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
"type": "classification"
}
]
}
}
}'
```
# Bidang yang akan disetel di objek params saat mengekspor data pelatihan
`params`Objek dalam permintaan ekspor dapat berisi berbagai bidang, seperti yang dijelaskan dalam [`params`dokumentasi](export-params-fields.md). Yang berikut ini paling relevan untuk mengekspor data pelatihan pembelajaran mesin:
****
+ **`endpoint`**— Gunakan `endpoint` untuk menentukan titik akhir instance Neptunus di cluster DB Anda yang proses ekspor dapat kueri untuk mengekstrak data.
+ **`profile`**— `profile` Bidang dalam `params` objek harus diatur ke **`neptune-ml`**.
Hal ini menyebabkan proses ekspor memformat data yang diekspor dengan tepat untuk pelatihan model Neptunus ML, dalam format CSV untuk data grafik properti atau sebagai N-Triple untuk data RDF. Ini juga menyebabkan `training-data-configuration.json` file dibuat dan ditulis ke lokasi Amazon S3 yang sama dengan data pelatihan yang diekspor.
+ **`cloneCluster`**— Jika diatur ke`true`, proses ekspor mengkloning cluster DB Anda, mengekspor dari klon, dan kemudian menghapus klon setelah selesai.
+ **`useIamAuth`**— Jika cluster DB Anda mengaktifkan [otentikasi IAM](iam-auth-enable.md), Anda harus menyertakan bidang ini yang disetel ke. `true`
Proses ekspor juga menyediakan beberapa cara untuk memfilter data yang Anda ekspor (lihat [contoh ini](export-filtering-examples.md)).
# Menggunakan objek additionalParams untuk menyetel ekspor informasi pelatihan model
`additionalParams`Objek berisi bidang yang dapat Anda gunakan untuk menentukan label dan fitur kelas pembelajaran mesin untuk tujuan pelatihan dan memandu pembuatan file konfigurasi data pelatihan.
Proses ekspor tidak dapat secara otomatis menyimpulkan properti node dan edge mana yang harus menjadi label kelas pembelajaran mesin untuk dijadikan contoh untuk tujuan pelatihan. Ini juga tidak dapat secara otomatis menyimpulkan pengkodean fitur terbaik untuk properti numerik, kategoris dan teks, jadi Anda perlu menyediakan petunjuk menggunakan bidang dalam `additionalParams` objek untuk menentukan hal-hal ini, atau untuk mengganti pengkodean default.
Untuk data grafik properti, struktur tingkat atas `additionalParams` dalam permintaan ekspor mungkin terlihat seperti ini:
```
{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
}
}
}
```
Untuk data RDF, struktur tingkat atasnya mungkin terlihat seperti ini:
```
{
"command": "export-rdf",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [ (an array of node and edge class label targets) ]
}
}
}
```
Anda juga dapat menyediakan beberapa konfigurasi ekspor, menggunakan `jobs` bidang:
```
{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams" : {
"neptune_ml" : {
"version": "v2.0",
"jobs": [
{
"name" : "(training data configuration name)",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
},
{
"name" : "(another training data configuration name)",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
}
]
}
}
}
```
# Elemen tingkat atas di bidang neptune\$1mldi AdditionalParams
## Elemen versi di neptune\$1ml
Menentukan versi konfigurasi data pelatihan untuk menghasilkan.
(*Opsional*), *Jenis*: string, *Default*: “v2.0".
Jika Anda menyertakan`version`, atur ke`v2.0`.
## Bidang pekerjaan di neptune\$1ml
Berisi array objek konfigurasi data pelatihan, yang masing-masing mendefinisikan pekerjaan pemrosesan data, dan berisi:
+ **`name`**— Nama konfigurasi data pelatihan yang akan dibuat.
Misalnya, konfigurasi data pelatihan dengan nama “job-number-1" menghasilkan file konfigurasi data pelatihan bernama. `job-number-1.json`
+ **`targets`**— Array JSON dari target label kelas node dan edge yang mewakili label kelas pembelajaran mesin untuk tujuan pelatihan. Lihat [Bidang target dalam objek neptune\$1ml](machine-learning-neptune_ml-targets.md).
+ **`features`**— Sebuah array JSON dari fitur properti node. Lihat [Bidang fitur di neptune\$1ml](machine-learning-neptune_ml-features.md).
# Bidang target dalam objek neptune\$1ml
`targets`Bidang dalam konfigurasi ekspor data pelatihan JSON berisi array objek target yang menentukan tugas pelatihan dan dan label kelas pembelajaran mesin untuk melatih tugas ini. Isi objek target bervariasi tergantung pada apakah Anda melatih data grafik properti atau data RDF.
Untuk klasifikasi node grafik properti dan tugas regresi, objek target dalam array dapat terlihat seperti ini:
```
{
"node": "(node property-graph label)",
"property": "(property name)",
"type" : "(used to specify classification or regression)",
"split_rate": [0.8,0.2,0.0],
"separator": ","
}
```
Untuk tugas klasifikasi tepi grafik properti, regresi atau prediksi tautan, mereka dapat terlihat seperti ini:
```
{
"edge": "(edge property-graph label)",
"property": "(property name)",
"type" : "(used to specify classification, regression or link_prediction)",
"split_rate": [0.8,0.2,0.0],
"separator": ","
}
```
Untuk tugas klasifikasi dan regresi RDF, objek target dalam array dapat terlihat seperti ini:
```
{
"node": "(node type of an RDF node)",
"predicate": "(predicate IRI)",
"type" : "(used to specify classification or regression)",
"split_rate": [0.8,0.2,0.0]
}
```
Untuk tugas prediksi tautan RDF, objek target dalam array dapat terlihat seperti ini::
```
{
"subject": "(source node type of an edge)",
"predicate": "(relation type of an edge)",
"object": "(destination node type of an edge)",
"type" : "link_prediction",
"split_rate": [0.8,0.2,0.0]
}
```
Objek target dapat berisi bidang-bidang berikut:
**Contents**
+ [Bidang target grafik properti](#machine-learning-property-graph-neptune_ml-targets)
+ [simpul](#machine-learning-property-graph-neptune_ml-targets-node)
+ [edge](#machine-learning-property-graph-neptune_ml-targets-edge)
+ [properti](#machine-learning-property-graph-neptune_ml-targets-property)
+ [jenis](#machine-learning-property-graph-neptune_ml-targets-type)
+ [split\$1rate](#machine-learning-property-graph-neptune_ml-targets-split_rate)
+ [pemisah](#machine-learning-property-graph-neptune_ml-targets-separator)
+ [Bidang target RDF](#machine-learning-RDF-neptune_ml-targets)
+ [simpul](#machine-learning-RDF-neptune_ml-targets-node)
+ [subjek](#machine-learning-RDF-neptune_ml-targets-subject)
+ [predikat](#machine-learning-RDF-neptune_ml-targets-predicate)
+ [object](#machine-learning-RDF-neptune_ml-targets-object)
+ [jenis](#machine-learning-RDF-neptune_ml-targets-type)
+ [split\$1rate](#machine-learning-RDF-neptune_ml-targets-split_rate)
## Bidang dalam objek target grafik properti
### Bidang node (vertex) dalam objek target
Label grafik properti dari simpul target (simpul). Objek target harus mengandung `node` elemen atau `edge` elemen, tetapi tidak keduanya.
A `node` dapat mengambil salah satu nilai tunggal, seperti ini:
```
"node": "Movie"
```
Atau, dalam kasus simpul multi-label, dapat mengambil array nilai, seperti ini:
```
"node": ["Content", "Movie"]
```
### Bidang tepi dalam objek target grafik properti
Menentukan tepi target dengan label node awal, labelnya sendiri, dan label end-node nya. Objek target harus mengandung `edge` elemen atau `node` elemen, tetapi tidak keduanya.
Nilai `edge` bidang adalah larik JSON dari tiga string yang mewakili label grafik properti simpul awal, label grafik properti dari tepi itu sendiri, dan label grafik properti simpul akhir, seperti ini:
```
"edge": ["Person_A", "knows", "Person_B"]
```
Jika simpul and/or akhir simpul awal memiliki beberapa label, lampirkan dalam array, seperti ini:
```
"edge": [ ["Admin", Person_A"], "knows", ["Admin", "Person_B"] ]
```
### Bidang properti dalam objek target grafik properti
Menentukan properti dari simpul target atau tepi, seperti ini:
```
"property" : "rating"
```
Bidang ini diperlukan, kecuali jika tugas target adalah prediksi tautan.
### Bidang tipe dalam objek target grafik properti
Menunjukkan jenis tugas target yang akan dilakukan pada `node` atau`edge`, seperti ini:
```
"type" : "regression"
```
Jenis tugas yang didukung untuk node adalah:
+ `classification`
+ `regression`
Jenis tugas yang didukung untuk tepi adalah:
+ `classification`
+ `regression`
+ `link_prediction`
Bidang ini wajib diisi.
### Bidang split\$1rate dalam objek target grafik properti
(*Opsional*) Perkiraan proporsi node atau tepi yang akan digunakan masing-masing tahap pelatihan, validasi, dan pengujian. Proporsi ini diwakili oleh array JSON dari tiga angka antara nol dan satu yang menambahkan hingga satu:
```
"split_rate": [0.7, 0.1, 0.2]
```
Jika Anda tidak menyediakan `split_rate` bidang opsional, nilai estimasi default adalah `[0.9, 0.1, 0.0]` untuk tugas klasifikasi dan regresi, dan `[0.9,0.05, 0.05]` untuk tugas prediksi tautan.
### Bidang pemisah dalam objek target grafik properti
(*Opsional*) Digunakan dengan tugas klasifikasi.
`separator`Bidang menentukan karakter yang digunakan untuk membagi nilai properti target menjadi beberapa nilai kategoris ketika digunakan untuk menyimpan beberapa nilai kategori dalam string. Contoh:
```
"separator": "|"
```
Kehadiran `separator` bidang menunjukkan bahwa tugas tersebut adalah tugas klasifikasi multi-target.
## Bidang dalam objek target RDF
### Bidang node dalam objek target RDF
Mendefinisikan jenis node node target. Digunakan dengan tugas klasifikasi node atau tugas regresi node. Jenis node dari node dalam RDF didefinisikan oleh:
```
node_id, , node_type
```
RDF hanya `node` dapat mengambil satu nilai, seperti ini:
```
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```
### Bidang subjek dalam objek target RDF
Untuk tugas prediksi tautan, `subject` tentukan jenis simpul sumber dari tepi target.
```
"subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director"
```
**catatan**
Untuk tugas prediksi tautan, `subject` harus digunakan bersama dengan `predicate` dan`object`. Jika salah satu dari ketiganya tidak disediakan, semua sisi diperlakukan sebagai target pelatihan.
### Bidang predikat dalam objek target RDF
Untuk tugas klasifikasi node dan regresi node, `predicate` mendefinisikan data literal apa yang digunakan sebagai fitur node target dari node target.
```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre"
```
**catatan**
Jika node target hanya memiliki satu predikat yang mendefinisikan fitur simpul target, `predicate` bidang tersebut dapat dihilangkan.
Untuk tugas prediksi tautan, `predicate` tentukan jenis relasi tepi target:
```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/direct"
```
**catatan**
Untuk tugas prediksi tautan, `predicate` harus digunakan bersama dengan `subject` dan`object`. Jika salah satu dari ketiganya tidak disediakan, semua sisi diperlakukan sebagai target pelatihan.
### Bidang objek dalam objek target RDF
Untuk tugas prediksi tautan, `object` tentukan jenis simpul tujuan dari tepi target:
```
"object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```
**catatan**
Untuk tugas prediksi tautan, `object` harus digunakan bersama dengan `subject` dan`predicate`. Jika salah satu dari ketiganya tidak disediakan, semua sisi diperlakukan sebagai target pelatihan.
### Bidang tipe dalam objek target RDF
Menunjukkan jenis tugas target yang akan dilakukan, seperti ini:
```
"type" : "regression"
```
Jenis tugas yang didukung untuk data RDF adalah:
+ `link_prediction`
+ `classification`
+ `regression`
Bidang ini wajib diisi.
### `split_rate`Bidang dalam objek target grafik properti
(*Opsional*) Perkiraan proporsi node atau tepi yang akan digunakan masing-masing tahap pelatihan, validasi, dan pengujian. Proporsi ini diwakili oleh array JSON dari tiga angka antara nol dan satu yang menambahkan hingga satu:
```
"split_rate": [0.7, 0.1, 0.2]
```
Jika Anda tidak menyediakan `split_rate` bidang opsional, nilai estimasi default adalah`[0.9, 0.1, 0.0]`.
# Bidang fitur di neptune\$1ml
Nilai properti dan literal RDF datang dalam berbagai format dan tipe data. *Untuk mencapai kinerja yang baik dalam pembelajaran mesin, penting untuk mengubah nilai-nilai tersebut menjadi pengkodean numerik yang dikenal sebagai fitur.*
Neptunus ML melakukan ekstraksi fitur dan pengkodean sebagai bagian dari langkah-langkah ekspor data dan pemrosesan data, seperti yang dijelaskan dalam. [Pengkodean fitur di Neptunus ML](machine-learning-feature-encoding.md)
Untuk kumpulan data grafik properti, proses ekspor secara otomatis menyimpulkan `auto` fitur untuk properti string dan untuk properti numerik yang berisi nilai kelipatan. Untuk properti numerik yang berisi nilai tunggal, ini menyimpulkan fitur. `numerical` Untuk properti tanggal, ia menyimpulkan `datetime` fitur.
Jika Anda ingin mengganti spesifikasi fitur yang disimpulkan secara otomatis, atau menambahkan spesifikasi bucket numerik, TF-IDF, atau SBERT untuk properti FastText, Anda dapat mengontrol pengkodean fitur menggunakan bidang fitur.
**catatan**
Anda hanya dapat menggunakan `features` bidang untuk mengontrol spesifikasi fitur untuk data grafik properti, bukan untuk data RDF.
Untuk teks bentuk bebas, Neptunus ML dapat menggunakan beberapa model berbeda untuk mengubah urutan token dalam nilai properti string menjadi vektor nilai nyata ukuran tetap:
+ [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)— Menggunakan pengkodean [FastText](https://fasttext.cc/). Ini adalah pengkodean yang disarankan untuk fitur yang menggunakan satu dan hanya satu dari lima bahasa yang didukung FastText.
+ [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-sbert-features)— Menggunakan model pengkodean [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Ini adalah pengkodean yang disarankan untuk teks yang `text_fasttext` tidak mendukung.
+ [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features)— Menggunakan algoritma [Word2Vec](https://wikipedia.org/wiki/Word2vec) awalnya diterbitkan oleh [Google](https://code.google.com/archive/p/word2vec/) untuk menyandikan teks. Word2Vec hanya mendukung bahasa Inggris.
+ [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features)— Menggunakan [istilah frekuensi—inverse document frequency](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) vectorizer untuk pengkodean teks. Pengkodean TF-IDF mendukung fitur statistik yang tidak dilakukan pengkodean lainnya.
`features`Bidang berisi array JSON fitur properti node. Objek dalam array dapat berisi bidang-bidang berikut:
**Contents**
+ [simpul](#machine-learning-neptune_ml-features-node)
+ [edge](#machine-learning-neptune_ml-features-edge)
+ [properti](#machine-learning-neptune_ml-features-property)
+ [jenis](#machine-learning-neptune_ml-feature-types)
+ [norma](#machine-learning-neptune_ml-features-norm)
+ [language](#machine-learning-neptune_ml-features-language)
+ [max\$1length](#machine-learning-neptune_ml-features-max_length)
+ [pemisah](#machine-learning-neptune_ml-features-separator)
+ [jangkauan](#machine-learning-neptune_ml-features-range)
+ [ember\$1cnt](#machine-learning-neptune_ml-features-bucket_cnt)
+ [slide\$1window\$1size](#machine-learning-neptune_ml-features-slide_window_size)
+ [imputer](#machine-learning-neptune_ml-features-imputer)
+ [max\$1features](#machine-learning-neptune_ml-features-max_features)
+ [min\$1df](#machine-learning-neptune_ml-features-min_df)
+ [ngram\$1range](#machine-learning-neptune_ml-features-ngram_range)
+ [datetime\$1parts](#machine-learning-neptune_ml-features-datetime_parts)
## Bidang node dalam fitur
`node`Bidang menentukan label property-graph dari simpul fitur. Contoh:
```
"node": "Person"
```
Jika sebuah simpul memiliki beberapa label, gunakan array untuk menampungnya. Contoh:
```
"node": ["Admin", "Person"]
```
## Bidang tepi dalam fitur
`edge`Bidang menentukan jenis tepi tepi fitur. Tipe tepi terdiri dari array yang berisi label grafik properti dari simpul sumber, label grafik properti tepi, dan label grafik properti dari simpul tujuan. Anda harus menyediakan ketiga nilai saat menentukan fitur tepi. Contoh:
```
"edge": ["User", "reviewed", "Movie"]
```
Jika simpul sumber atau tujuan dari tipe tepi memiliki beberapa label, gunakan array lain untuk menampungnya. Contoh:
```
"edge": [["Admin", "Person"]. "edited", "Post"]
```
## Bidang properti dalam fitur
Gunakan parameter properti untuk menentukan properti dari simpul yang diidentifikasi oleh `node` parameter. Contoh:
```
"property" : "age"
```
## Nilai yang mungkin dari bidang tipe untuk fitur
`type`Parameter menentukan jenis fitur yang didefinisikan. Contoh:
```
"type": "bucket_numerical"
```
**Nilai `type` parameter yang mungkin**
+ **`"auto"`**— Menentukan bahwa Neptunus ML harus secara otomatis mendeteksi jenis properti dan menerapkan pengkodean fitur yang tepat. Sebuah `auto` fitur juga dapat memiliki `separator` bidang opsional.
Lihat [Pengkodean fitur otomatis di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
+ **`"category"`**- Pengkodean fitur ini mewakili nilai properti sebagai salah satu dari sejumlah kategori. Dengan kata lain, fitur ini dapat mengambil satu atau lebih nilai diskrit. Sebuah `category` fitur juga dapat memiliki `separator` bidang opsional.
Lihat [Fitur kategoris di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-categorical-features).
+ **`"numerical"`**- Pengkodean fitur ini mewakili nilai properti numerik sebagai angka dalam interval kontinu di mana “lebih besar dari” dan “kurang dari” memiliki makna.
Sebuah `numerical` fitur juga dapat memiliki opsional`norm`,`imputer`, dan `separator` bidang.
Lihat [Fitur numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
+ **`"bucket_numerical"`***- Pengkodean fitur ini membagi nilai properti numerik menjadi satu set ember atau kategori.*
Misalnya, Anda dapat menyandikan usia orang dalam 4 ember: anak-anak (0-20), dewasa muda (20-40), paruh baya (40-60), dan orang tua (60 ke atas).
Sebuah `bucket_numerical` fitur membutuhkan `range` dan `bucket_cnt` bidang, dan secara opsional juga dapat menyertakan `imputer` and/or `slide_window_size` bidang.
Lihat [Fitur bucket-numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
+ **`"datetime"`**— Pengkodean fitur ini mewakili nilai properti datetime sebagai larik fitur kategoris ini: tahun, bulan, hari kerja, dan jam.
Satu atau lebih dari empat kategori ini dapat dihilangkan menggunakan `datetime_parts` parameter.
Lihat [Fitur Datetime di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
+ **`"text_fasttext"`**[- Pengkodean fitur ini mengubah nilai properti yang terdiri dari kalimat atau teks bentuk bebas menjadi vektor numerik menggunakan model FastText.](https://fasttext.cc/) Ini mendukung lima bahasa, yaitu Inggris (`en`), Mandarin (`zh`), Hindi (`hi`), Spanyol (`es`), dan Prancis (`fr`). Untuk nilai properti teks dalam salah satu lima bahasa tersebut, `text_fasttext` adalah pengkodean yang disarankan. Namun, tidak dapat menangani kasus di mana kalimat yang sama berisi kata-kata dalam lebih dari satu bahasa.
Untuk bahasa lain selain yang didukung FastText, gunakan pengkodean. `text_sbert`
Jika Anda memiliki banyak string teks nilai properti yang lebih panjang dari, katakanlah, 120 token, gunakan `max_length` bidang untuk membatasi jumlah token di setiap string yang `"text_fasttext"` dikodekan.
Lihat [*FastText* encoding nilai properti teks di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-fasttext-features).
+ **`"text_sbert"`**— Pengkodean ini mengubah nilai properti teks menjadi vektor numerik menggunakan model [Sentence BERT (SBERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models)). Neptunus mendukung dua metode SBERT, `text_sbert128` yaitu, yang merupakan default jika Anda hanya menentukan, dan. `text_sbert` `text_sbert512` Perbedaan di antara mereka adalah jumlah maksimum token dalam properti teks yang dikodekan. `text_sbert128`Pengkodean hanya mengkodekan 128 token pertama, sementara `text_sbert512` mengkodekan hingga 512 token. Akibatnya, penggunaan `text_sbert512` dapat membutuhkan lebih banyak waktu pemrosesan daripada`text_sbert128`. Kedua metode lebih lambat dari`text_fasttext`.
`text_sbert*`Metode ini mendukung banyak bahasa, dan dapat menyandikan kalimat yang berisi lebih dari satu bahasa.
Lihat [Sentence BERT (SBERT) encoding fitur teks di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-sbert-features).
+ **`"text_word2vec"`**[— Pengkodean ini mengubah nilai properti teks menjadi vektor numerik menggunakan algoritma Word2Vec.](https://wikipedia.org/wiki/Word2vec) Ini hanya mendukung bahasa Inggris.
Lihat [Pengkodean Word2Vec fitur teks di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-word2vec-features).
+ **`"text_tfidf"`**— Pengkodean ini mengubah nilai properti teks menjadi vektor numerik menggunakan [istilah frekuensi-inverse document frequency (TF-IDF) vectorizer](https://wikipedia.org/wiki/Tf-idf).
Anda menentukan parameter pengkodean `text_tfidf` fitur menggunakan `ngram_range` bidang, `min_df` bidang, dan `max_features` bidang.
Lihat [Pengkodean fitur teks TF-IDF di Neptunus](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
+ **`"none"`**— Menggunakan `none` tipe menyebabkan tidak ada pengkodean fitur yang terjadi. Nilai properti mentah diurai dan disimpan sebagai gantinya.
Gunakan `none` hanya jika Anda berencana untuk melakukan pengkodean fitur kustom Anda sendiri sebagai bagian dari pelatihan model kustom.
## Bidang norma
Bidang ini diperlukan untuk fitur numerik. Ini menentukan metode normalisasi untuk digunakan pada nilai-nilai numerik:
```
"norm": "min-max"
```
Metode normalisasi berikut didukung:
+ **“min-max”** — Normalisasi setiap nilai dengan mengurangi nilai minimum darinya dan kemudian membaginya dengan selisih antara nilai maksimum dan minimum.
+ **“standar”** — Menormalkan setiap nilai dengan membaginya dengan jumlah semua nilai.
+ **“tidak ada”** — Jangan menormalkan nilai numerik selama pengkodean.
Lihat [Fitur numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
## Bidang bahasa
Bidang bahasa menentukan bahasa yang digunakan dalam nilai properti teks. Penggunaannya tergantung pada metode pengkodean teks:
+ Untuk [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)pengkodean, bidang ini diperlukan, dan harus menentukan salah satu bahasa berikut:
+ `en`(Bahasa Inggris)
+ `zh`(Tionghoa)
+ `hi`(Hindi)
+ `es`(Spanyol)
+ `fr`(Perancis)
+ Untuk [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)pengkodean, bidang ini tidak digunakan, karena pengkodean SBERT bersifat multibahasa.
+ Untuk [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features)pengkodean, bidang ini opsional, karena `text_word2vec` hanya mendukung bahasa Inggris. Jika ada, itu harus menentukan nama model bahasa Inggris:
```
"language" : "en_core_web_lg"
```
+ Untuk [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features)pengkodean, bidang ini tidak digunakan.
## Bidang max\$1length
`max_length`Bidang ini opsional untuk `text_fasttext` fitur, di mana ia menentukan jumlah maksimum token dalam fitur teks input yang akan dikodekan. Input teks yang lebih panjang dari `max_length` yang terpotong. Misalnya, menyetel max\$1length ke 128 menunjukkan bahwa token apa pun setelah ke-128 dalam urutan teks akan diabaikan:
```
"max_length": 128
```
## Bidang pemisah
Bidang ini digunakan secara opsional dengan`category`, `numerical` dan `auto` fitur. Ini menentukan karakter yang dapat digunakan untuk membagi nilai properti menjadi beberapa nilai kategoris atau nilai numerik:
```
"separator": ";"
```
Hanya gunakan `separator` bidang ketika properti menyimpan beberapa nilai yang dibatasi dalam satu string, seperti `"Actor;Director"` atau. `"0.1;0.2"`
Lihat[Fitur kategoris](machine-learning-feature-encoding.md#machine-learning-categorical-features),[Fitur numerik](machine-learning-feature-encoding.md#machine-learning-numerical-features), dan[Pengkodean otomatis](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
## Bidang rentang
Bidang ini diperlukan untuk `bucket_numerical` fitur. Ini menentukan kisaran nilai numerik yang akan dibagi menjadi ember, dalam format: `[lower-bound, upper-bound]`
```
"range" : [20, 100]
```
Jika nilai properti lebih kecil dari batas bawah maka nilai tersebut ditetapkan ke bucket pertama, atau jika lebih besar dari batas atas, itu ditetapkan ke bucket terakhir.
Lihat [Fitur bucket-numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Bidang bucket\$1cnt
Bidang ini diperlukan untuk `bucket_numerical` fitur. Ini menentukan jumlah ember yang rentang numerik yang ditentukan oleh `range` parameter harus dibagi menjadi:
```
"bucket_cnt": 10
```
Lihat [Fitur bucket-numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Bidang slide\$1window\$1size
Bidang ini digunakan secara opsional dengan `bucket_numerical` fitur untuk menetapkan nilai ke lebih dari satu bucket:
```
"slide_window_size": 5
```
Cara kerja jendela slide adalah bahwa Neptunus ML mengambil **`s`**ukuran jendela dan mengubah setiap **`v`**nilai numerik properti menjadi rentang dari hingga. ` v - s/2 ` ` v + s/2 ` Nilai tersebut kemudian ditetapkan ke setiap bucket yang rentangnya tumpang tindih.
Lihat [Fitur bucket-numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Bidang imputer
Bidang ini digunakan secara opsional dengan `numerical` dan `bucket_numerical` fitur untuk memberikan teknik imputasi untuk mengisi nilai yang hilang:
```
"imputer": "mean"
```
Teknik imputasi yang didukung adalah:
+ `"mean"`
+ `"median"`
+ `"most-frequent"`
Jika Anda tidak menyertakan parameter imputer, pra-pemrosesan data akan berhenti dan keluar saat nilai yang hilang ditemukan.
Lihat [Fitur numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-numerical-features) dan [Fitur bucket-numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Bidang max\$1features
Bidang ini digunakan secara opsional oleh `text_tfidf` fitur untuk menentukan jumlah maksimum istilah untuk dikodekan:
```
"max_features": 100
```
Pengaturan 100 menyebabkan vectorizer TF-IDF hanya menyandikan 100 istilah yang paling umum. Nilai default jika Anda tidak menyertakan `max_features` adalah 5.000.
Lihat [Pengkodean fitur teks TF-IDF di Neptunus](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Bidang min\$1df
Bidang ini digunakan secara opsional oleh `text_tfidf` fitur untuk menentukan frekuensi dokumen minimum istilah untuk dikodekan:
```
"min_df": 5
```
Pengaturan 5 menunjukkan bahwa istilah harus muncul dalam setidaknya 5 nilai properti yang berbeda untuk dikodekan.
Nilai default jika Anda tidak menyertakan `min_df` parameter adalah`2`.
Lihat [Pengkodean fitur teks TF-IDF di Neptunus](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Bidang ngram\$1range
Bidang ini digunakan secara opsional oleh `text_tfidf` fitur untuk menentukan urutan ukuran kata atau token apa yang harus dianggap sebagai istilah individual potensial untuk dikodekan:
```
"ngram_range": [2, 4]
```
Nilai `[2, 4]` menentukan bahwa urutan 2, 3 dan 4 kata harus dianggap sebagai istilah individu potensial.
Default jika Anda tidak secara eksplisit disetel `ngram_range` adalah`[1, 1]`, artinya hanya satu kata atau token yang dianggap sebagai istilah untuk dikodekan.
Lihat [Pengkodean fitur teks TF-IDF di Neptunus](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Bidang datetime\$1parts
Bidang ini digunakan secara opsional oleh `datetime` fitur untuk menentukan bagian mana dari nilai datetime yang akan dikodekan secara kategoris:
```
"datetime_parts": ["weekday", "hour"]
```
Jika Anda tidak menyertakan`datetime_parts`, secara default Neptunus ML mengkodekan bagian tahun, bulan, hari kerja, dan jam dari nilai datetime. Nilai `["weekday", "hour"]` menunjukkan bahwa hanya hari kerja dan jam nilai datetime yang harus dikodekan secara kategoris dalam fitur.
Jika salah satu bagian tidak memiliki lebih dari satu nilai unik dalam set pelatihan, itu tidak dikodekan.
Lihat [Fitur Datetime di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
# Contoh penggunaan parameter dalam AdditionalParams untuk menyetel konfigurasi pelatihan model
Contoh berikut menunjukkan bagaimana memanfaatkan fitur “AdditionalParams” dalam grafik properti dan model data RDF untuk mengonfigurasi berbagai aspek proses pelatihan model untuk aplikasi Neptunus ML. Contohnya mencakup berbagai fungsi, termasuk menentukan tingkat pemisahan default untuk training/validation/test data, mendefinisikan klasifikasi node, regresi, dan tugas prediksi tautan, serta mengonfigurasi berbagai jenis fitur seperti bucket numerik, penyematan teks, datetime, dan data kategoris. Konfigurasi terperinci ini memungkinkan Anda untuk menyesuaikan pipeline pembelajaran mesin dengan data spesifik dan persyaratan pemodelan Anda, membuka potensi penuh dari kemampuan Neptunus ML.
**Contents**
+ [Contoh grafik properti menggunakan AdditionalParams](#machine-learning-property-graph-additionalParams-examples)
+ [Menentukan tingkat pemisahan default untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-default-split-rate-example)
+ [Menentukan tugas klasifikasi simpul untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-node-classification-example)
+ [Menentukan tugas klasifikasi node multi-kelas untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-multi-class-example)
+ [Menentukan tugas regresi simpul untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-node-regression-example)
+ [Menentukan tugas klasifikasi tepi untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-edge-classification-example)
+ [Menentukan tugas klasifikasi tepi multi-kelas untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-multi-edge-classification-example)
+ [Menentukan regresi edge untuk konfigurasi model-training](#machine-learning-property-graph-additionalParams-edge-regression-example)
+ [Menentukan tugas prediksi tautan untuk konfigurasi pelatihan model](#machine-learning-property-graph-additionalParams-link-prediction-example)
+ [Menentukan fitur bucket numerik](#machine-learning-property-graph-additionalParams-numeric-bucket-example)
+ [Menentukan fitur `Word2Vec`](#machine-learning-property-graph-additionalParams-word2vec-example)
+ [Menentukan fitur `FastText`](#machine-learning-property-graph-additionalParams-fasttext-example)
+ [Menentukan fitur `Sentence BERT`](#machine-learning-property-graph-additionalParams-sbert-example)
+ [Menentukan fitur `TF-IDF`](#machine-learning-property-graph-additionalParams-tf-idf-example)
+ [Menentukan fitur `datetime`](#machine-learning-property-graph-additionalParams-datetime-example)
+ [Menentukan fitur `category`](#machine-learning-property-graph-additionalParams-category-example)
+ [Menentukan fitur `numerical`](#machine-learning-property-graph-additionalParams-numerical-example)
+ [Menentukan fitur `auto`](#machine-learning-property-graph-additionalParams-auto-example)
+ [Contoh RDF menggunakan `additionalParams`](#machine-learning-RDF-additionalParams-examples)
+ [Menentukan tingkat pemisahan default untuk konfigurasi pelatihan model](#machine-learning-RDF-additionalParams-default-split-rate-example)
+ [Menentukan tugas klasifikasi simpul untuk konfigurasi pelatihan model](#machine-learning-RDF-additionalParams-node-classification-example)
+ [Menentukan tugas regresi simpul untuk konfigurasi pelatihan model](#machine-learning-RDF-additionalParams-node-regression-example)
+ [Menentukan tugas prediksi tautan untuk tepi tertentu](#machine-learning-RDF-additionalParams-link-prediction-example)
+ [Menentukan tugas prediksi tautan untuk semua sisi](#machine-learning-RDF-additionalParams-link-prediction-example)
## Contoh grafik properti menggunakan AdditionalParams
### Menentukan tingkat pemisahan default untuk konfigurasi pelatihan model
Dalam contoh berikut, `split_rate` parameter menetapkan tingkat pemisahan default untuk pelatihan model. Jika tidak ada tingkat pemisahan default yang ditentukan, pelatihan menggunakan nilai [0,9, 0,1, 0,0]. Anda dapat mengganti nilai default pada basis per-target dengan menentukan untuk setiap target. `split_rate`
Dalam contoh berikut, `default split_rate` bidang menunjukkan bahwa tingkat perpecahan `[0.7,0.1,0.2]` harus digunakan kecuali diganti berdasarkan per target:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"split_rate": [0.7,0.1,0.2],
"targets": [
(...)
],
"features": [
(...)
]
}
}
```
### Menentukan tugas klasifikasi simpul untuk konfigurasi pelatihan model
Untuk menunjukkan properti node mana yang berisi contoh berlabel untuk tujuan pelatihan, tambahkan elemen klasifikasi node ke `targets` array, menggunakan`"type" : "classification"`. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
Dalam contoh berikut, `node` target menunjukkan bahwa `genre` properti dari setiap `Movie` node harus diperlakukan sebagai label kelas node. `split_rate`Nilai mengesampingkan tingkat pemisahan default:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification",
"split_rate": [0.7,0.1,0.2]
}
],
"features": [
(...)
]
}
}
```
### Menentukan tugas klasifikasi node multi-kelas untuk konfigurasi pelatihan model
Untuk menunjukkan properti node mana yang berisi beberapa contoh berlabel untuk tujuan pelatihan, tambahkan elemen klasifikasi node ke array target, gunakan`"type" : "classification"`, dan `separator` untuk menentukan karakter yang dapat digunakan untuk membagi nilai properti target menjadi beberapa nilai kategoris. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
Dalam contoh berikut, `node` target menunjukkan bahwa `genre` properti dari setiap `Movie` node harus diperlakukan sebagai label kelas node. `separator`Bidang menunjukkan bahwa setiap properti genre berisi beberapa nilai yang dipisahkan titik koma:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification",
"separator": ";"
}
],
"features": [
(...)
]
}
}
```
### Menentukan tugas regresi simpul untuk konfigurasi pelatihan model
Untuk menunjukkan properti node mana yang berisi regresi berlabel untuk tujuan pelatihan, tambahkan elemen regresi node ke array target, menggunakan. `"type" : "regression"` Tambahkan bidang split\$1rate jika Anda ingin mengganti tingkat pemisahan default.
Target `node` berikut in imenunjukkan bahwa properti `rating` masing-masing simpul `Movie` harus diperlakukan sebagai label regresi simpul :
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "rating",
"type" : "regression",
"split_rate": [0.7,0.1,0.2]
}
],
"features": [
...
]
}
}
```
### Menentukan tugas klasifikasi tepi untuk konfigurasi pelatihan model
Untuk menunjukkan properti edge mana yang berisi contoh berlabel untuk tujuan pelatihan, tambahkan elemen tepi ke `targets` array, menggunakan`"type" : "regression"`. Tambahkan bidang split\$1rate jika Anda ingin mengganti tingkat pemisahan default.
`edge`Target berikut menunjukkan bahwa `metAtLocation` properti setiap `knows` tepi harus diperlakukan sebagai label kelas tepi:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "knows", "Person"],
"property": "metAtLocation",
"type": "classification"
}
],
"features": [
(...)
]
}
}
```
### Menentukan tugas klasifikasi tepi multi-kelas untuk konfigurasi pelatihan model
Untuk menunjukkan properti edge mana yang berisi beberapa contoh berlabel untuk tujuan pelatihan, tambahkan elemen tepi ke `targets` array, menggunakan`"type" : "classification"`, dan `separator` bidang untuk menentukan karakter yang digunakan untuk membagi nilai properti target menjadi beberapa nilai kategoris. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
`edge`Target berikut menunjukkan bahwa `sentiment` properti setiap `repliedTo` tepi harus diperlakukan sebagai label kelas tepi. Bidang pemisah menunjukkan bahwa setiap properti sentimen berisi nilai yang dipisahkan koma multile:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "repliedTo", "Message"],
"property": "sentiment",
"type": "classification",
"separator": ","
}
],
"features": [
(...)
]
}
}
```
### Menentukan regresi edge untuk konfigurasi model-training
Untuk menunjukkan properti edge mana yang berisi contoh regresi berlabel untuk tujuan pelatihan, tambahkan `edge` elemen ke `targets` array, menggunakan. `"type" : "regression"` Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
`edge`Target berikut menunjukkan bahwa `rating` properti setiap `reviewed` tepi harus diperlakukan sebagai regresi tepi:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "reviewed", "Movie"],
"property": "rating",
"type" : "regression"
}
],
"features": [
(...)
]
}
}
```
### Menentukan tugas prediksi tautan untuk konfigurasi pelatihan model
Untuk menunjukkan tepi mana yang harus digunakan untuk tujuan pelatihan prediksi tautan, tambahkan elemen tepi ke larik target menggunakan`"type" : "link_prediction"`. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
`edge`Target berikut menunjukkan bahwa `cites` tepi harus digunakan untuk prediksi tautan:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Article", "cites", "Article"],
"type" : "link_prediction"
}
],
"features": [
(...)
]
}
}
```
### Menentukan fitur bucket numerik
Anda dapat menentukan fitur data numerik untuk properti node dengan menambahkan `"type": "bucket_numerical"` ke `features` array.
Fitur `node` berikut ini menunjukkan bahwa properti `age` masing-masing node `Person` harus diperlakukan sebagai fitur bucket numerik:
```
"additionalParams": {
"neptune_ml": {
"targets": [
...
],
"features": [
{
"node": "Person",
"property": "age",
"type": "bucket_numerical",
"range": [1, 100],
"bucket_cnt": 5,
"slide_window_size": 3,
"imputer": "median"
}
]
}
}
```
### Menentukan fitur `Word2Vec`
Anda dapat menentukan `Word2Vec` fitur untuk properti node dengan menambahkan `"type": "text_word2vec"` ke `features` array.
Fitur `node` berikut ini menunjukkan bahwa properti `description` masing-masing node `Movie`harus diperlakukan sebagai fitur `Word2Vec`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_word2vec",
"language": "en_core_web_lg"
}
]
}
}
```
### Menentukan fitur `FastText`
Anda dapat menentukan `FastText` fitur untuk properti node dengan menambahkan `"type": "text_fasttext"` ke `features` array. `language`Bidang diperlukan, dan harus menentukan salah satu kode bahasa berikut:
+ `en`(Bahasa Inggris)
+ `zh`(Tionghoa)
+ `hi`(Hindi)
+ `es`(Spanyol)
+ `fr`(Perancis)
Perhatikan bahwa `text_fasttext` pengkodean tidak dapat menangani lebih dari satu bahasa pada satu waktu dalam suatu fitur.
`node`Fitur berikut menunjukkan bahwa `description` properti Prancis dari setiap `Movie` node harus diperlakukan sebagai `FastText` fitur:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_fasttext",
"language": "fr",
"max_length": 1024
}
]
}
}
```
### Menentukan fitur `Sentence BERT`
Anda dapat menentukan `Sentence BERT` fitur untuk properti node dengan menambahkan `"type": "text_sbert"` ke `features` array. Anda tidak perlu menentukan bahasa, karena metode ini secara otomatis mengkodekan fitur teks menggunakan model bahasa multibahasa.
Fitur `node` berikut ini menunjukkan bahwa properti `description` masing-masing node `Movie`harus diperlakukan sebagai fitur `Sentence BERT`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_sbert128",
}
]
}
}
```
### Menentukan fitur `TF-IDF`
Anda dapat menentukan `TF-IDF` fitur untuk properti node dengan menambahkan `"type": "text_tfidf"` ke `features` array.
Fitur `node` berikut ini menunjukkan bahwa properti `bio` masing-masing node `Person`harus diperlakukan sebagai fitur `TF-IDF`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "bio",
"type": "text_tfidf",
"ngram_range": [1, 2],
"min_df": 5,
"max_features": 1000
}
]
}
}
```
### Menentukan fitur `datetime`
Proses ekspor secara otomatis menyimpulkan `datetime` fitur untuk properti tanggal. Namun, jika Anda ingin membatasi `datetime_parts` penggunaan untuk `datetime` fitur, atau mengganti spesifikasi fitur sehingga properti yang biasanya diperlakukan sebagai fitur secara eksplisit diperlakukan sebagai `auto` `datetime` fitur, Anda dapat melakukannya dengan menambahkan a `"type": "datetime"` ke array fitur.
Fitur `node` berikut ini menunjukkan bahwa properti `createdAt` masing-masing node `Post`harus diperlakukan sebagai fitur `datetime`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Post",
"property": "createdAt",
"type": "datetime",
"datetime_parts": ["month", "weekday", "hour"]
}
]
}
}
```
### Menentukan fitur `category`
Proses ekspor secara otomatis menyimpulkan `auto` fitur untuk properti string dan properti numerik yang berisi nilai kelipatan. Untuk properti numerik yang berisi nilai tunggal, ini menyimpulkan fitur. `numerical` Untuk properti tanggal, ia menyimpulkan `datetime` fitur.
Jika Anda ingin mengganti spesifikasi fitur sehingga properti diperlakukan sebagai fitur kategoris, tambahkan `"type": "category"` ke array fitur. Jika properti berisi beberapa nilai, sertakan `separator` bidang. Contoh:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Post",
"property": "tag",
"type": "category",
"separator": "|"
}
]
}
}
```
### Menentukan fitur `numerical`
Proses ekspor secara otomatis menyimpulkan `auto` fitur untuk properti string dan properti numerik yang berisi nilai kelipatan. Untuk properti numerik yang berisi nilai tunggal, ini menyimpulkan fitur. `numerical` Untuk properti tanggal, ia menyimpulkan `datetime` fitur.
Jika Anda ingin mengganti spesifikasi fitur sehingga properti diperlakukan sebagai `numerical` fitur, tambahkan `"type": "numerical"` ke array fitur. Jika properti berisi beberapa nilai, sertakan `separator` bidang. Contoh:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Recording",
"property": "duration",
"type": "numerical",
"separator": ","
}
]
}
}
```
### Menentukan fitur `auto`
Proses ekspor secara otomatis menyimpulkan `auto` fitur untuk properti string dan properti numerik yang berisi nilai kelipatan. Untuk properti numerik yang berisi nilai tunggal, ini menyimpulkan fitur. `numerical` Untuk properti tanggal, ia menyimpulkan `datetime` fitur.
Jika Anda ingin mengganti spesifikasi fitur sehingga properti diperlakukan sebagai `auto` fitur, tambahkan `"type": "auto"` ke array fitur. Jika properti berisi beberapa nilai, sertakan `separator` bidang. Contoh:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "User",
"property": "role",
"type": "auto",
"separator": ","
}
]
}
}
```
## Contoh RDF menggunakan `additionalParams`
### Menentukan tingkat pemisahan default untuk konfigurasi pelatihan model
Dalam contoh berikut, `split_rate` parameter menetapkan tingkat pemisahan default untuk pelatihan model. Jika tidak ada tingkat pemisahan default yang ditentukan, pelatihan menggunakan nilai [0,9, 0,1, 0,0]. Anda dapat mengganti nilai default pada basis per-target dengan menentukan untuk setiap target. `split_rate`
Dalam contoh berikut, `default split_rate` bidang menunjukkan bahwa tingkat perpecahan `[0.7,0.1,0.2]` harus digunakan kecuali diganti berdasarkan per target:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"split_rate": [0.7,0.1,0.2],
"targets": [
(...)
]
}
}
```
### Menentukan tugas klasifikasi simpul untuk konfigurasi pelatihan model
Untuk menunjukkan properti node mana yang berisi contoh berlabel untuk tujuan pelatihan, tambahkan elemen klasifikasi node ke `targets` array, menggunakan`"type" : "classification"`. Tambahkan bidang node untuk menunjukkan jenis node dari node target. Tambahkan `predicate` bidang untuk menentukan data literal mana yang digunakan sebagai fitur simpul target dari simpul target. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
Dalam contoh berikut, `node` target menunjukkan bahwa `genre` properti dari setiap `Movie` node harus diperlakukan sebagai label kelas node. `split_rate`Nilai mengesampingkan tingkat pemisahan default:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
"type": "classification",
"split_rate": [0.7,0.1,0.2]
}
]
}
}
```
### Menentukan tugas regresi simpul untuk konfigurasi pelatihan model
Untuk menunjukkan properti node mana yang berisi regresi berlabel untuk tujuan pelatihan, tambahkan elemen regresi node ke array target, menggunakan. `"type" : "regression"` Tambahkan `node` bidang untuk menunjukkan jenis node dari node target. Tambahkan `predicate` bidang untuk menentukan data literal mana yang digunakan sebagai fitur simpul target dari simpul target. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
Target `node` berikut in imenunjukkan bahwa properti `rating` masing-masing simpul `Movie` harus diperlakukan sebagai label regresi simpul :
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/rating",
"type": "regression",
"split_rate": [0.7,0.1,0.2]
}
]
}
}
```
### Menentukan tugas prediksi tautan untuk tepi tertentu
Untuk menunjukkan tepi mana yang harus digunakan untuk tujuan pelatihan prediksi tautan, tambahkan elemen tepi ke larik target menggunakan`"type" : "link_prediction"`. Tambahkan`subject`, `predicate` dan `object` bidang untuk menentukan jenis tepi. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
`edge`Target berikut menunjukkan bahwa `directed` tepi yang `Directors` terhubung `Movies` harus digunakan untuk prediksi tautan:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/directed",
"object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"type" : "link_prediction"
}
]
}
}
```
### Menentukan tugas prediksi tautan untuk semua sisi
Untuk menunjukkan bahwa semua tepi harus digunakan untuk tujuan pelatihan prediksi tautan, tambahkan `edge` elemen ke array target menggunakan`"type" : "link_prediction"`. Jangan menambahkan`subject`,`predicate`, atau `object` bidang. Tambahkan `split_rate` bidang jika Anda ingin mengganti tingkat pemisahan default.
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"type" : "link_prediction"
}
]
}
}
```
# Memproses data grafik yang diekspor dari Neptune untuk pelatihan
Langkah pemrosesan data mengambil data grafik Neptune yang dibuat oleh proses ekspor dan menciptakan informasi yang digunakan oleh [Deep Graph Library (DGL)](https://www.dgl.ai/) selama pelatihan. Ini termasuk melakukan berbagai pemetaan data dan transformasi:
+ Simpul parsing dan edge untuk membangun grafik- dan file pemetaan ID yang dibutuhkan oleh DGL.
+ Mengkonversi properti simpul dan fitur simpul dan edge yang dibutuhkan oleh DGL.
+ Memisahkan data ke dalam pelatihan, validasi, dan set tes.
## Mengelola langkah pemrosesan data untuk Neptune ML
Setelah Anda mengekspor data dari Neptune yang ingin Anda gunakan untuk pelatihan model, Anda dapat memulai tugas pemrosesan data menggunakan perintah `curl` (atau`awscurl`) seperti berikut ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{
"inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for the new job)",
"processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)",
"configFileName" : "training-job-configuration.json"
}'
```
Rincian tentang cara menggunakan perintah ini dijelaskan dalam [Perintah pemrosesandata](machine-learning-api-dataprocessing.md), bersama dengan informasi tentang cara untuk mendapatkan status tugas yang sedang berjalan, cara menghentikan tugas yang sedang berjalan, dan mendaftar semua pekerjaan yang sedang berjalan.
## Memproses data grafik yang diperbarui untuk Neptunus ML
Anda juga dapat menyediakan a `previousDataProcessingJobId` ke API untuk memastikan bahwa pekerjaan pemrosesan data baru menggunakan metode pemrosesan yang sama dengan pekerjaan sebelumnya. Ini diperlukan saat Anda ingin mendapatkan prediksi untuk data grafik yang diperbarui di Neptunus, baik dengan melatih ulang model lama pada data baru, atau dengan menghitung ulang artefak model pada data baru.
Anda melakukan ini dengan menggunakan perintah `curl` (atau`awscurl`) seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{ "inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for the new job)",
"processedDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your output folder)",
"previousDataProcessingJobId", "(the job ID of the previous data-processing job)"}'
```
Tetapkan nilai `previousDataProcessingJobId` parameter ke ID pekerjaan dari pekerjaan pemrosesan data sebelumnya yang sesuai dengan model terlatih.
**catatan**
Penghapusan node dalam grafik yang diperbarui saat ini tidak didukung. Jika node telah dihapus dalam grafik yang diperbarui, Anda harus memulai pekerjaan pemrosesan data yang sama sekali baru daripada menggunakan`previousDataProcessingJobId`.
# Pengkodean fitur di Neptunus ML
Nilai properti datang dalam berbagai format dan tipe data. *Untuk mencapai kinerja yang baik dalam pembelajaran mesin, penting untuk mengubah nilai-nilai tersebut menjadi pengkodean numerik yang dikenal sebagai fitur.*
Neptunus ML melakukan ekstraksi fitur dan pengkodean sebagai bagian dari langkah-langkah ekspor data dan pemrosesan data, menggunakan teknik pengkodean fitur yang dijelaskan di sini.
**catatan**
Jika Anda berencana untuk mengimplementasikan pengkodean fitur Anda sendiri dalam implementasi model khusus, Anda dapat menonaktifkan pengkodean fitur otomatis dalam tahap pra-pemrosesan data dengan memilih `none` sebagai jenis pengkodean fitur. Tidak ada pengkodean fitur yang terjadi pada properti node atau edge itu, dan sebagai gantinya nilai properti mentah diurai dan disimpan dalam kamus. Preprocessing data masih membuat grafik DGL dari dataset yang diekspor, tetapi grafik DGL yang dibangun tidak memiliki fitur pra-proses untuk pelatihan.
Anda harus menggunakan opsi ini hanya jika Anda berencana untuk melakukan pengkodean fitur kustom Anda sebagai bagian dari pelatihan model khusus. Lihat [Model khusus di Neptunus ML](machine-learning-custom-models.md) untuk detail.
## Fitur kategoris di Neptunus ML
Properti yang dapat mengambil satu atau lebih nilai berbeda dari daftar tetap nilai yang mungkin adalah fitur kategoris. [Di Neptunus ML, fitur kategoris dikodekan menggunakan pengkodean satu panas.](https://en.wikipedia.org/wiki/One-hot) Contoh berikut menunjukkan bagaimana nama properti makanan yang berbeda dikodekan satu panas sesuai dengan kategorinya:
```
Food Veg. Meat Fruit Encoding
--------- ---- ---- ----- --------
Apple 0 0 1 001
Chicken 0 1 0 010
Broccoli 1 0 0 100
```
**catatan**
Jumlah maksimum kategori dalam fitur kategoris apa pun adalah 100. Jika sebuah properti memiliki lebih dari 100 kategori nilai, hanya 99 yang paling umum ditempatkan dalam kategori yang berbeda, dan sisanya ditempatkan dalam kategori khusus bernama`OTHER`.
## Fitur numerik di Neptunus ML
Properti apa pun yang nilainya bilangan real dapat dikodekan sebagai fitur numerik di Neptunus ML. Fitur numerik dikodekan menggunakan angka floating-point.
Anda dapat menentukan metode normalisasi data yang akan digunakan saat menyandikan fitur numerik, seperti ini: `"norm": "normalization technique"` Teknik normalisasi berikut didukung:
+ **“tidak ada”** — Jangan menormalkan nilai numerik selama pengkodean.
+ **“min-max”** — Normalisasi setiap nilai dengan mengurangi nilai minimum darinya dan kemudian membaginya dengan selisih antara nilai maksimum dan minimum.
+ **“standar”** — Menormalkan setiap nilai dengan membaginya dengan jumlah semua nilai.
## Fitur bucket-numerik di Neptunus ML
Daripada mewakili properti numerik menggunakan angka mentah, Anda dapat memadatkan nilai numerik ke dalam kategori. Misalnya, Anda dapat membagi usia orang ke dalam kategori seperti anak-anak (0-20), dewasa muda (20-40), orang paruh baya (40-60) dan orang tua (dari 60 pada). Dengan menggunakan bucket numerik ini, Anda akan mengubah properti numerik menjadi semacam fitur kategoris.
Di Neptunus ML, Anda dapat menyebabkan properti numerik dikodekan sebagai fitur bucket-numerik, Anda harus memberikan dua hal:
+ Rentang numerik dalam bentuk,` "range": [a, b] `, di mana `a` dan `b` merupakan bilangan bulat.
+ Hitungan ember, dalam bentuk` "bucket_cnt": c `, di `c` mana jumlah ember, juga bilangan bulat.
Neptunus ML kemudian menghitung ukuran setiap bucket ` ( b - a ) / c ` sebagai, dan mengkodekan setiap nilai numerik sebagai jumlah bucket apa pun yang masuk ke dalamnya. Nilai apa pun yang kurang dari `a` dianggap termasuk dalam ember pertama, dan nilai apa pun yang lebih besar dari `b` dianggap termasuk dalam ember terakhir.
Anda juga dapat, secara opsional, membuat nilai numerik jatuh ke lebih dari satu ember, dengan menentukan ukuran jendela geser, seperti ini:` "slide_window_size": s `, di mana angka. `s` Neptunus ML kemudian mengubah setiap `v` nilai numerik properti menjadi rentang ` v - s/2 ` dari ` v + s/2 ` hingga, dan memberikan `v` nilai ke setiap ember yang dicakup oleh rentang tersebut.
Terakhir, Anda juga dapat secara opsional menyediakan cara mengisi nilai yang hilang untuk fitur numerik dan fitur bucket-numerik. Anda melakukan ini menggunakan` "imputer": "imputation technique "`, di mana teknik imputasi adalah salah satu dari`"mean"`,`"median"`, atau. `"most-frequent"` Jika Anda tidak menentukan imputer, nilai yang hilang dapat menyebabkan pemrosesan terhenti.
## Pengkodean fitur teks di Neptunus ML
Untuk teks bentuk bebas, Neptunus ML dapat menggunakan beberapa model berbeda untuk mengonversi urutan token dalam string nilai properti menjadi vektor nilai nyata ukuran tetap:
+ [`text_fasttext`](#machine-learning-fasttext-features)— Menggunakan pengkodean [FastText](https://fasttext.cc/). Ini adalah pengkodean yang disarankan untuk fitur yang menggunakan satu dan hanya satu dari lima bahasa yang didukung FastText.
+ [`text_sbert`](#machine-learning-sbert-features)— Menggunakan model pengkodean [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Ini adalah pengkodean yang disarankan untuk teks yang `text_fasttext` tidak mendukung.
+ [`text_word2vec`](#machine-learning-word2vec-features)— Menggunakan algoritma [Word2Vec](https://wikipedia.org/wiki/Word2vec) awalnya diterbitkan oleh [Google](https://code.google.com/archive/p/word2vec/) untuk menyandikan teks. Word2Vec hanya mendukung bahasa Inggris.
+ [`text_tfidf`](#machine-learning-tfidf-features)— Menggunakan [istilah frekuensi—inverse document frequency](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) vectorizer untuk pengkodean teks. Pengkodean TF-IDF mendukung fitur statistik yang tidak dilakukan pengkodean lainnya.
### *FastText* encoding nilai properti teks di Neptunus ML
Neptunus ML dapat menggunakan model [FastText untuk mengubah nilai properti teks](https://fasttext.cc/) menjadi vektor nilai nyata ukuran tetap. Ini adalah metode pengkodean yang direkomendasikan untuk nilai properti teks di salah satu dari lima bahasa yang didukung FastText:
+ `en`(Bahasa Inggris)
+ `zh`(Tionghoa)
+ `hi`(Hindi)
+ `es`(Spanyol)
+ `fr`(Perancis)
Perhatikan bahwa FastText tidak dapat menangani kalimat yang mengandung kata-kata dalam lebih dari satu bahasa.
`text_fasttext`Metode ini opsional dapat mengambil `max_length` bidang yang menentukan jumlah maksimum token dalam nilai properti teks yang akan dikodekan, setelah itu string terpotong. Ini dapat meningkatkan kinerja ketika nilai properti teks berisi string panjang, karena jika tidak `max_length` ditentukan, FastText mengkodekan semua token terlepas dari panjang string.
Contoh ini menentukan bahwa judul film Prancis dikodekan menggunakan FastText:
```
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{
"feature": ["title", "title", "text_fasttext"],
"language": "fr",
"max_length": 1024
}
]
}
```
### Sentence BERT (SBERT) encoding fitur teks di Neptunus ML
Neptunus ML dapat mengubah urutan token dalam nilai properti string menjadi vektor nilai nyata ukuran tetap [menggunakan](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) model Sentence BERT (SBERT). Neptunus mendukung dua metode SBERT`text_sbert128`:, yang merupakan default jika Anda hanya menentukan, dan. `text_sbert` `text_sbert512` Perbedaan antara keduanya adalah panjang maksimum string nilai properti teks yang dikodekan. `text_sbert128`Pengkodean memotong string teks setelah menyandikan 128 token, sementara `text_sbert512` memotong string teks setelah menyandikan 512 token. Akibatnya, `text_sbert512` membutuhkan lebih banyak waktu pemrosesan daripada`text_sbert128`. Kedua metode lebih lambat dari`text_fasttext`.
Pengkodean SBERT bersifat multibahasa, jadi tidak perlu menentukan bahasa untuk teks nilai properti yang Anda kodekan. SBERT mendukung banyak bahasa, dan dapat menyandikan kalimat yang berisi lebih dari satu bahasa. Jika Anda menyandikan nilai properti yang berisi teks dalam bahasa atau bahasa yang tidak didukung oleh FastText, SBERT adalah metode pengkodean yang disarankan.
Contoh berikut menentukan bahwa judul film dikodekan sebagai SBERT hingga maksimum 128 token:
```
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{ "feature": ["title", "title", "text_sbert128"] }
]
}
```
### Pengkodean Word2Vec fitur teks di Neptunus ML
[Neptunus ML dapat menyandikan nilai properti string sebagai fitur Word2Vec [(](https://wikipedia.org/wiki/Word2vec)algoritma Word2Vec awalnya diterbitkan oleh Google).](https://code.google.com/archive/p/word2vec/) `text_word2vec`Metode ini mengkodekan token dalam string sebagai vektor padat menggunakan salah satu model [terlatih SPacy](https://spacy.io/models). Ini hanya mendukung bahasa Inggris menggunakan model [en\$1core\$1web\$1lg](https://spacy.io/models/en#en_core_web_lg)).
Contoh berikut menentukan bahwa judul film dikodekan menggunakan Word2Vec:
```
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{
"feature": ["title", "title", "text_word2vec"],
"language": "en_core_web_lg"
}
]
}
```
Perhatikan bahwa bidang bahasa adalah opsional, karena `en_core_web_lg` model bahasa Inggris adalah satu-satunya yang didukung Neptunus.
### Pengkodean fitur teks TF-IDF di Neptunus
Neptunus ML dapat menyandikan nilai properti teks sebagai fitur. `text_tfidf` Pengkodean ini mengubah urutan kata dalam teks menjadi vektor numerik menggunakan [istilah frekuensi-inverse document frequency (TF-IDF) vectorizer](https://wikipedia.org/wiki/Tf-idf), diikuti oleh operasi reduksi dimensi.
[TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) (frekuensi istilah — frekuensi dokumen terbalik) adalah nilai numerik yang dimaksudkan untuk mengukur seberapa penting sebuah kata dalam kumpulan dokumen. Ini dihitung dengan membagi berapa kali sebuah kata muncul dalam nilai properti tertentu dengan jumlah total nilai properti yang muncul di.
Misalnya, jika kata “ciuman” muncul dua kali dalam judul film tertentu (katakanlah, “ciuman ciuman bang bang”), dan “ciuman” muncul dalam judul 4 film secara keseluruhan, maka nilai TF-IDF dari “ciuman” dalam judul “ciuman ciuman bang” akan menjadi. ` 2 / 4 `
Vektor yang awalnya dibuat memiliki dimensi ***d***, di mana ***d*** adalah jumlah istilah unik di semua nilai properti dari jenis itu. Operasi pengurangan dimensi menggunakan proyeksi jarang acak untuk mengurangi angka itu hingga maksimum 100. Kosakata grafik kemudian dihasilkan dengan menggabungkan semua `text_tfidf` fitur di dalamnya.
Anda dapat mengontrol vectorizer TF-IDF dengan beberapa cara:
+ **`max_features`**— Dengan menggunakan `max_features` parameter, Anda dapat membatasi jumlah istilah dalam `text_tfidf` fitur ke yang paling umum. Misalnya, jika Anda menyetel `max_features` ke 100, hanya 100 istilah teratas yang paling umum digunakan yang disertakan. Nilai default untuk `max_features` jika Anda tidak secara eksplisit menyetelnya adalah 5.000.
+ **`min_df`**— Menggunakan `min_df` parameter, Anda dapat membatasi jumlah istilah dalam `text_tfidf` fitur untuk yang memiliki setidaknya frekuensi dokumen tertentu. Misalnya, jika Anda menyetel `min_df` ke 5, hanya istilah yang muncul di setidaknya 5 nilai properti yang berbeda yang digunakan. Nilai default untuk `min_df` jika Anda tidak secara eksplisit mengaturnya adalah 2.
+ **`ngram_range`**— `ngram_range` Parameter menentukan kombinasi kata apa yang diperlakukan sebagai istilah. Misalnya, jika Anda mengatur `ngram_range` ke`[2, 4]`, 6 istilah berikut akan ditemukan di judul “kiss kiss bang bang”:
+ *Istilah 2 kata*: “ciuman ciuman”, “ciuman bang”, dan “bang bang”.
+ *Istilah 3 kata*: “kiss kiss bang” dan “kiss bang bang”.
+ *Istilah 4 kata*: “ciuman ciuman bang bang”.
Pengaturan default untuk `ngram_range` adalah`[1, 1]`.
## Fitur Datetime di Neptunus ML
[Neptunus ML dapat mengubah bagian `datetime` dari nilai properti menjadi fitur kategoris dengan menyandikannya sebagai array satu-panas.](https://en.wikipedia.org/wiki/One-hot) Gunakan `datetime_parts` parameter untuk menentukan satu atau beberapa bagian berikut untuk menyandikan:`["year", "month", "weekday", "hour"]`. Jika Anda tidak mengatur`datetime_parts`, secara default keempat bagian dikodekan.
Misalnya, jika rentang nilai datetime mencakup tahun 2010 hingga 2012, empat bagian dari entri datetime adalah sebagai berikut: `2011-04-22 01:16:34`
+ **tahun** —`[0, 1, 0]`.
Karena hanya ada 3 tahun dalam rentang (2010, 2011, dan 2012), array satu-panas memiliki tiga entri, satu untuk setiap tahun.
+ **bulan** —`[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]`.
Di sini, array satu-panas memiliki entri untuk setiap bulan dalam setahun.
+ **hari kerja** —`[0, 0, 0, 0, 1, 0, 0]`.
Standar ISO 8601 menyatakan bahwa Senin adalah hari pertama dalam seminggu, dan sejak 22 April 2011 adalah hari Jumat, array hari kerja satu panas yang sesuai panas di posisi kelima.
+ **jam** —`[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]`.
Jam 1 pagi diatur dalam array satu-panas 24 anggota.
Hari dalam sebulan, menit, dan detik tidak dikodekan secara kategoris.
Jika `datetime` rentang total yang dimaksud hanya mencakup tanggal dalam satu tahun, tidak ada `year` array yang dikodekan.
Anda dapat menentukan strategi imputasi untuk mengisi `datetime` nilai yang hilang, menggunakan `imputer` parameter dan salah satu strategi yang tersedia untuk fitur numerik.
## Pengkodean fitur otomatis di Neptunus ML
Alih-alih secara manual menentukan metode pengkodean fitur yang akan digunakan untuk properti dalam grafik Anda, Anda dapat mengatur `auto` sebagai metode pengkodean fitur. Neptunus ML kemudian mencoba menyimpulkan pengkodean fitur terbaik untuk setiap properti berdasarkan tipe data yang mendasarinya.
Berikut adalah beberapa heuristik yang digunakan Neptunus dalam memilih pengkodean fitur yang sesuai:
+ Jika properti hanya memiliki nilai numerik dan dapat dilemparkan ke tipe data numerik, maka Neptunus ML umumnya mengkodekannya sebagai nilai numerik. Namun, jika jumlah nilai unik untuk properti kurang dari 10% dari jumlah total nilai dan kardinalitas nilai unik tersebut kurang dari 100, maka Neptunus ML menggunakan pengkodean kategoris.
+ Jika nilai properti dapat dilemparkan ke suatu `datetime` tipe, maka Neptunus ML mengkodekannya sebagai fitur. `datetime`
+ Jika nilai properti dapat dipaksa untuk boolean (1/0 atau True/False), maka Neptunus ML menggunakan kategori encoding.
+ Jika properti adalah string dengan lebih dari 10% nilainya unik, dan jumlah rata-rata token per nilai lebih besar dari atau sama dengan 3, Neptunus ML menyimpulkan jenis properti menjadi teks dan secara otomatis mendeteksi bahasa yang digunakan. Jika bahasa yang terdeteksi adalah salah satu yang didukung oleh [FastText](#machine-learning-fasttext-features), yaitu Inggris, Mandarin, Hindi, Spanyol dan Prancis, maka Neptunus menggunakan untuk menyandikan teks. `text_fasttext` Sebaliknya, penggunaan Neptunus ML. [`text_sbert`](#machine-learning-sbert-features)
+ Jika properti adalah string yang tidak diklasifikasikan sebagai fitur teks maka Neptunus ML menganggapnya sebagai fitur kategoris dan menggunakan pengkodean kategori.
+ Jika setiap node memiliki nilai uniknya sendiri untuk properti yang disimpulkan sebagai fitur kategori, Neptunus ML menjatuhkan properti dari grafik pelatihan karena mungkin ID yang tidak informatif untuk pembelajaran.
+ Jika properti diketahui mengandung pemisah Neptunus yang valid seperti titik koma (“;”), maka Neptunus ML hanya dapat memperlakukan properti sebagai atau. `MultiNumerical` `MultiCategorical`
+ Neptunus ML pertama kali mencoba untuk menyandikan nilai sebagai fitur numerik. jika ini berhasil, Neptunus ML menggunakan pengkodean numerik untuk membuat fitur vektor numerik.
+ Jika tidak, Neptunus ML mengkodekan nilai sebagai multi-kategoris.
+ Jika Neptunus ML tidak dapat menyimpulkan tipe data dari nilai properti, MLdrops Neptunus properti dari grafik pelatihan.
# Mengedit file konfigurasi data pelatihan
Proses ekspor Neptune mengekspor data Neptune ML dari klaster DB Neptune ke dalam bucket S3. Proses ini mengekspor simpul dan edge secara terpisah menjadi `nodes/` dan sebuah folder `edges/`. Ini juga membuat file konfigurasi data pelatihan JSON, dinamai secara `training-data-configuration.json` default. File ini berisi informasi tentang skema grafik, jenis fitur-fiturnya, transformasi fitur dan operasi normalisasi, dan fitur target untuk klasifikasi atau tugas regresi.
Mungkin ada kasus ketika Anda ingin memodifikasi file konfigurasi secara langsung. Salah satu kasus tersebut adalah ketika Anda ingin mengubah cara fitur diproses atau bagaimana grafik dibangun, tanpa perlu menjalankan kembali ekspor setiap kali Anda ingin memodifikasi spesifikasi untuk tugas pembelajaran mesin yang Anda selesaikan.
**Untuk mengedit file konfigurasi data pelatihan**
1. **Unduh file ke mesin lokal Anda.**
Kecuali Anda menentukan satu atau lebih pekerjaan bernama dalam `additionalParams/neptune_ml` parameter yang diteruskan ke proses ekspor, file akan memiliki nama default, yaitu`training-data-configuration.json`. Anda dapat menggunakan perintah AWS CLI seperti ini untuk mengunduh file:
```
aws s3 cp \
s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json \
./
```
1. **Edit file menggunakan editor teks.**
1. **Unggah file yang dimodifikasi.** Unggah file yang dimodifikasi kembali ke lokasi yang sama di Amazon S3 tempat Anda mengunduhnya, menggunakan perintah AWS CLI seperti ini:
```
aws s3 cp \
training-data-configuration.json \
s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json
```
# Contoh file konfigurasi data pelatihan JSON
Berikut adalah contoh file konfigurasi data pelatihan yang menjelaskan grafik untuk tugas klasifikasi simpul:
```
{
"version" : "v2.0",
"query_engine" : "gremlin",
"graph" : [
{
"edges" : [
{
"file_name" : "edges/(movie)-included_in-(genre).csv",
"separator" : ",",
"source" : ["~from", "movie"],
"relation" : ["", "included_in"],
"dest" : [ "~to", "genre" ]
},
{
"file_name" : "edges/(user)-rated-(movie).csv",
"separator" : ",",
"source" : ["~from", "movie"],
"relation" : ["rating", "prefixname"], # [prefixname#value]
"dest" : ["~to", "genre"],
"features" : [
{
"feature" : ["rating", "rating", "numerical"],
"norm" : "min-max"
}
]
}
],
"nodes" : [
{
"file_name" : "nodes/genre.csv",
"separator" : ",",
"node" : ["~id", "genre"],
"features" : [
{
"feature": ["name", "genre", "category"],
"separator": ";"
}
]
},
{
"file_name" : "nodes/movie.csv",
"separator" : ",",
"node" : ["~id", "movie"],
"features" : [
{
"feature": ["title", "title", "word2vec"],
"language": ["en_core_web_lg"]
}
]
},
{
"file_name" : "nodes/user.csv",
"separator" : ",",
"node" : ["~id", "user"],
"features" : [
{
"feature": ["age", "age", "numerical"],
"norm" : "min-max",
"imputation": "median",
},
{
"feature": ["occupation", "occupation", "category"],
}
],
"labels" : [
{
"label": ["gender", "classification"],
"split_rate" : [0.8, 0.2, 0.0]
}
]
}
]
},
"warnings" : [ ]
]
}
```
# Struktur file konfigurasi data pelatihan JSON
File konfigurasi pelatihan mengacu pada file CSV yang disimpan oleh proses ekspor di folder `nodes/` dan `edges/`.
Setiap berkas di bawah informasi penyimpanan `nodes/` tentang simpul yang memiliki label simpul grafik properti yang sama. Setiap kolom di file simpul menyimpan baik ID simpul ataupun properti simpul. Baris pertama dari file berisi header yang menentukan `~id` atau nama properti untuk setiap kolom.
Setiap berkas di bawah `edges/` menyimpan informasi tentang simpul yang memiliki label simpul grafik properti yang sama. Setiap kolom di file simpul menyimpan baik ID simpul sumber atau properti edge. Baris pertama dari file berisi header yang menentukan `~from`, `~to`, atau nama properti untuk setiap kolom.
File konfigurasi data pelatihan memiliki tiga elemen tingkat atas:
```
{
"version" : "v2.0",
"query_engine" : "gremlin",
"graph" : [ ... ]
}
```
+ `version`— (String) Versi file konfigurasi yang digunakan.
+ `query_engine`— (String) Bahasa query yang digunakan untuk mengekspor data grafik. Saat ini, hanya “gremlin” yang valid.
+ `graph`— (JSON array) mencantumkan satu atau lebih objek konfigurasi yang berisi parameter model untuk masing-masing node dan tepi yang akan digunakan.
Objek konfigurasi dalam array grafik memiliki struktur yang dijelaskan di bagian berikutnya.
## Isi dari objek konfigurasi yang tercantum dalam `graph` array
Objek konfigurasi dalam `graph` array dapat berisi tiga node tingkat atas:
```
{
"edges" : [ ... ],
"nodes" : [ ... ],
"warnings" : [ ... ],
}
```
+ `edges`— (array objek JSON) Setiap objek JSON menentukan satu set parameter untuk menentukan bagaimana tepi dalam grafik akan diperlakukan selama pemrosesan model dan pelatihan. Ini hanya digunakan dengan mesin Gremlin.
+ `nodes`— (array objek JSON) Setiap objek JSON menentukan satu set parameter untuk menentukan bagaimana node dalam grafik akan diperlakukan selama pemrosesan model dan pelatihan. Ini hanya digunakan dengan mesin Gremlin.
+ `warnings`— (array objek JSON) Setiap objek berisi peringatan yang dihasilkan selama proses ekspor data.
## Isi dari objek konfigurasi tepi yang tercantum dalam `edges` array
Objek konfigurasi tepi yang tercantum dalam `edges` array dapat berisi bidang tingkat atas berikut:
```
{
"file_name" : "(path to a CSV file)",
"separator" : "(separator character)",
"source" : ["(column label for starting node ID)", "(starting node type)"],
"relation" : ["(column label for the relationship name)", "(the prefix name for the relationship name)"],
"dest" : ["(column label for ending node ID)", "(ending node type)"],
"features" : [(array of feature objects)],
"labels" : [(array of label objects)]
}
```
+ **`file_name`**— String yang menentukan jalur ke file CSV yang menyimpan informasi tentang tepi yang memiliki label grafik properti yang sama.
Baris pertama dari file itu berisi baris header label kolom.
Dua label kolom pertama adalah `~from` dan`~to`. Kolom pertama (`~from`kolom) menyimpan ID dari simpul awal tepi, dan yang kedua (`~to`kolom) menyimpan ID dari simpul akhir tepi.
Label kolom yang tersisa di baris header menentukan, untuk setiap kolom yang tersisa, nama properti tepi yang nilainya telah diekspor ke kolom itu.
+ **`separator`**— String yang berisi pembatas yang memisahkan kolom dalam file CSV itu.
+ **`source`**- Array JSON yang berisi dua string yang menentukan simpul awal tepi. String pertama berisi nama header kolom tempat ID simpul awal disimpan. String kedua menentukan jenis node.
+ **`relation`**— Sebuah array JSON yang berisi dua string yang menentukan tipe relasi edge. String pertama berisi nama header kolom tempat nama relasi (`relname`) disimpan. String kedua berisi awalan untuk nama relasi (`prefixname`).
Tipe relasi penuh terdiri dari dua string yang digabungkan, dengan karakter tanda hubung di antara keduanya, seperti ini:. `prefixname-relname`
Jika string pertama kosong, semua tepi memiliki tipe relasi yang sama, yaitu `prefixname` string.
+ **`dest`**- Array JSON yang berisi dua string yang menentukan simpul akhir tepi. String pertama berisi nama header kolom tempat ID node disimpan. String kedua menentukan jenis node.
+ **`features`**— Sebuah array JSON dari objek fitur nilai properti. Setiap objek fitur nilai properti berisi bidang-bidang berikut:
+ **fitur** - Sebuah array JSON dari tiga string. String pertama berisi nama header kolom yang berisi nilai properti. String kedua berisi nama fitur. String ketiga berisi jenis fitur.
+ **norma** - (*Opsional*) Menentukan metode normalisasi untuk diterapkan pada nilai-nilai properti.
+ **`labels`**— Sebuah array JSON objek. Masing-masing objek mendefinisikan fitur target dari tepi, dan menentukan proporsi tepi yang harus diambil oleh tahap pelatihan dan validasi. Setiap objek berisi bidang-bidang berikut:
+ **label** - Sebuah array JSON dari dua string. String pertama berisi nama header kolom yang berisi nilai properti fitur target. String kedua menentukan salah satu jenis tugas target berikut:
+ `"classification"`— Tugas klasifikasi tepi. Nilai properti yang disediakan dalam kolom yang diidentifikasi oleh string pertama dalam `label` array diperlakukan sebagai nilai kategoris. Untuk tugas klasifikasi tepi, string pertama dalam `label` array tidak bisa kosong.
+ `"regression"`— Tugas regresi tepi. Nilai properti yang disediakan dalam kolom yang diidentifikasi oleh string pertama dalam `label` array diperlakukan sebagai nilai numerik. Untuk tugas regresi tepi, string pertama dalam `label` array tidak bisa kosong.
+ `"link_prediction"`— Tugas prediksi tautan. Tidak ada nilai properti yang diperlukan. Untuk tugas prediksi tautan, string pertama dalam `label` array diabaikan.
+ **`split_rate`**— Array JSON yang berisi tiga angka antara nol dan satu yang menambahkan hingga satu dan yang mewakili perkiraan proporsi node yang akan digunakan masing-masing tahap pelatihan, validasi, dan pengujian. Entah bidang ini atau `custom_split_filenames` dapat didefinisikan, tetapi tidak keduanya. Lihat [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate).
+ **`custom_split_filenames`**— Objek JSON yang menentukan nama file untuk file yang menentukan populasi pelatihan, validasi, dan pengujian. Entah bidang ini atau `split_rate` dapat didefinisikan, tetapi tidak keduanya. Untuk informasi selengkapnya, lihat [train-validation-testProporsi khusus](#machine-learning-custom-stages-splits).
## Isi dari objek konfigurasi node yang tercantum dalam `nodes` array
Sebuah objek konfigurasi node yang tercantum dalam `nodes` array dapat berisi bidang-bidang berikut:
```
{
"file_name" : "(path to a CSV file)",
"separator" : "(separator character)",
"node" : ["(column label for the node ID)", "(node type)"],
"features" : [(feature array)],
"labels" : [(label array)],
}
```
+ **`file_name`**— String yang menentukan jalur ke file CSV yang menyimpan informasi tentang node yang memiliki label grafik properti yang sama.
Baris pertama dari file itu berisi baris header label kolom.
Label kolom pertama adalah`~id`, dan kolom pertama (`~id`kolom) menyimpan ID node.
Label kolom yang tersisa di baris header menentukan, untuk setiap kolom yang tersisa, nama properti node yang nilainya telah diekspor ke kolom itu.
+ **`separator`**— String yang berisi pembatas yang memisahkan kolom dalam file CSV itu.
+ **`node`**— Sebuah array JSON yang berisi dua string. String pertama berisi nama header kolom yang menyimpan node IDs. String kedua menentukan jenis node dalam grafik, yang sesuai dengan label property-graph dari node.
+ **`features`**- Sebuah array JSON dari objek fitur node. Lihat [Isi objek fitur yang tercantum dalam `features` array untuk simpul atau tepi](#machine-learning-graph-node-features-config).
+ **`labels`**- Sebuah array JSON dari objek label node. Lihat [Isi dari objek label node yang tercantum dalam `labels` array node](#machine-learning-graph-node-labels-config).
## Isi objek fitur yang tercantum dalam `features` array untuk simpul atau tepi
Objek fitur node yang terdaftar dalam `features` array node dapat berisi bidang tingkat atas berikut:
+ **`feature`**— Sebuah array JSON dari tiga string. String pertama berisi nama header kolom yang berisi nilai properti untuk fitur tersebut. String kedua berisi nama fitur.
String ketiga berisi jenis fitur. Jenis fitur yang valid tercantum dalam[Nilai yang mungkin dari bidang tipe untuk fitur](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-feature-types).
+ **`norm`**- Bidang ini diperlukan untuk fitur numerik. Ini menentukan metode normalisasi untuk digunakan pada nilai-nilai numerik. Nilai yang valid adalah`"none"`,`"min-max"`, dan “standar”. Lihat [Bidang norma](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-norm) untuk detail.
+ **`language`**- Bidang bahasa menentukan bahasa yang digunakan dalam nilai properti teks. Penggunaannya tergantung pada metode pengkodean teks:
+ Untuk [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)pengkodean, bidang ini diperlukan, dan harus menentukan salah satu bahasa berikut:
+ `en`(Bahasa Inggris)
+ `zh`(Tionghoa)
+ `hi`(Hindi)
+ `es`(Spanyol)
+ `fr`(Perancis)
Namun, `text_fasttext` tidak dapat menangani lebih dari satu bahasa dalam satu waktu.
+ Untuk [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)pengkodean, bidang ini tidak digunakan, karena pengkodean SBERT bersifat multibahasa.
+ Untuk [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features)pengkodean, bidang ini opsional, karena `text_word2vec` hanya mendukung bahasa Inggris. Jika ada, itu harus menentukan nama model bahasa Inggris:
```
"language" : "en_core_web_lg"
```
+ Untuk [`tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features)pengkodean, bidang ini tidak digunakan.
+ **`max_length`**— Bidang ini opsional untuk [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features)fitur, di mana ia menentukan jumlah maksimum token dalam fitur teks input yang akan dikodekan. Teks masukan setelah `max_length` tercapai diabaikan. Misalnya, menyetel max\$1length ke 128 menunjukkan bahwa token apa pun setelah ke-128 dalam urutan teks diabaikan.
+ **`separator`**— Bidang ini digunakan secara opsional dengan`category`, `numerical` dan `auto` fitur. Ini menentukan karakter yang dapat digunakan untuk membagi nilai properti menjadi beberapa nilai kategoris atau nilai numerik.
Lihat [Bidang pemisah](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-separator).
+ **`range`**- Bidang ini diperlukan untuk `bucket_numerical` fitur. Ini menentukan kisaran nilai numerik yang akan dibagi menjadi ember.
Lihat [Bidang rentang](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-range).
+ **`bucket_cnt`**- Bidang ini diperlukan untuk `bucket_numerical` fitur. Ini menentukan jumlah ember yang rentang numerik yang ditentukan oleh `range` parameter harus dibagi menjadi.
Lihat [Fitur bucket-numerik di Neptunus ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
+ **`slide_window_size`**— Bidang ini digunakan secara opsional dengan `bucket_numerical` fitur untuk menetapkan nilai ke lebih dari satu bucket.
Lihat [Bidang slide\$1window\$1size](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-slide_window_size).
+ **`imputer`**— Bidang ini digunakan secara opsional dengan`numerical`,`bucket_numerical`, dan `datetime` fitur untuk memberikan teknik imputasi untuk mengisi nilai yang hilang. Teknik imputasi yang didukung adalah`"mean"`,`"median"`, dan. `"most_frequent"`
Lihat [Bidang imputer](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-imputer).
+ **`max_features`**— Bidang ini digunakan secara opsional oleh `text_tfidf` fitur untuk menentukan jumlah maksimum istilah untuk dikodekan.
Lihat [Bidang max\$1features](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-max_features).
+ **`min_df`**— Bidang ini digunakan secara opsional oleh `text_tfidf` fitur untuk menentukan frekuensi dokumen minimum istilah untuk dikodekan
Lihat [Bidang min\$1df](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-min_df).
+ **`ngram_range`**— Bidang ini digunakan secara opsional oleh `text_tfidf` fitur untuk menentukan rentang jumlah kata atau token untuk dianggap sebagai istilah individu potensial untuk dikodekan
Lihat [Bidang ngram\$1range](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-ngram_range).
+ **`datetime_parts`**— Bidang ini digunakan secara opsional oleh `datetime` fitur untuk menentukan bagian mana dari nilai datetime yang akan dikodekan secara kategoris.
Lihat [Bidang datetime\$1parts](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-datetime_parts).
## Isi dari objek label node yang tercantum dalam `labels` array node
Objek label yang tercantum dalam `labels` array node mendefinisikan fitur target node dan menentukan proporsi node yang akan digunakan oleh tahap pelatihan, validasi, dan pengujian. Setiap objek dapat berisi bidang-bidang berikut:
```
{
"label" : ["(column label for the target feature property value)", "(task type)"],
"split_rate" : [(training proportion), (validation proportion), (test proportion)],
"custom_split_filenames" : {"train": "(training file name)", "valid": "(validation file name)", "test": "(test file name)"},
"separator" : "(separator character for node-classification category values)",
}
```
+ **`label`**— Sebuah array JSON yang berisi dua string. String pertama berisi nama header kolom yang menyimpan nilai properti untuk fitur tersebut. String kedua menentukan jenis tugas target, yang dapat berupa:
+ `"classification"`— Tugas klasifikasi simpul. Nilai properti di kolom tertentu digunakan untuk membuat fitur kategoris.
+ `"regression"`— Tugas regresi simpul. Nilai properti di kolom yang ditentukan digunakan untuk membuat fitur numerik.
+ **`split_rate`**— Array JSON yang berisi tiga angka antara nol dan satu yang menambahkan hingga satu dan mewakili perkiraan proporsi node yang akan digunakan masing-masing tahap pelatihan, validasi, dan pengujian. Lihat [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate).
+ **`custom_split_filenames`**— Objek JSON yang menentukan nama file untuk file yang menentukan populasi pelatihan, validasi, dan pengujian. Entah bidang ini atau `split_rate` dapat didefinisikan, tetapi tidak keduanya. Untuk informasi selengkapnya, lihat [train-validation-testProporsi khusus](#machine-learning-custom-stages-splits).
+ **`separator`**— String yang berisi pembatas yang memisahkan nilai fitur kategoris untuk tugas klasifikasi.
**catatan**
Jika tidak ada objek label yang disediakan untuk kedua tepi dan node, tugas secara otomatis diasumsikan sebagai prediksi tautan, dan tepi secara acak dibagi menjadi 90% untuk pelatihan dan 10% untuk validasi.
## train-validation-testProporsi khusus
Secara default, `split_rate` parameter digunakan oleh Neptunus ML untuk membagi grafik secara acak menjadi populasi pelatihan, validasi, dan uji menggunakan proporsi yang ditentukan dalam parameter ini. Untuk memiliki kontrol yang lebih tepat atas entitas mana yang digunakan dalam populasi yang berbeda ini, file dapat dibuat yang secara eksplisit mendefinisikannya, dan kemudian [file konfigurasi data pelatihan dapat diedit untuk memetakan file](machine-learning-processing-training-config-file.md) pengindeksan ini ke populasi. Pemetaan ini ditentukan oleh objek JSON untuk [`custom_split_filesnames`](#custom_split_filenames)kunci dalam file konfigurasi pelatihan. Jika opsi ini digunakan, nama file harus disediakan untuk kunci dan, `train` dan opsional untuk `validation` kunci. `test`
Pemformatan file-file ini harus sesuai dengan format data [Gremlin](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-systemheaders). Secara khusus, untuk tugas tingkat simpul, setiap file harus berisi kolom dengan `~id` header yang mencantumkan node IDs, dan untuk tugas tingkat tepi, file harus menentukan `~from` dan `~to` menunjukkan node sumber dan tujuan dari tepi, masing-masing. File-file ini harus ditempatkan di lokasi Amazon S3 yang sama dengan data yang diekspor yang digunakan untuk pemrosesan data (lihat:). [`outputS3Path`](export-parameters.md#export-parameters-outputS3Path)
Untuk tugas klasifikasi atau regresi properti, file-file ini secara opsional dapat menentukan label untuk tugas pembelajaran mesin. Dalam hal ini file harus memiliki kolom properti dengan nama header yang sama seperti yang [didefinisikan dalam file konfigurasi data pelatihan](#machine-learning-graph-node-labels-config). Jika label properti didefinisikan dalam file node dan edge yang diekspor dan file split khusus, prioritas diberikan ke file split khusus.
# Melatih model menggunakan Neptune ML
Setelah Anda memproses data yang Anda ekspor dari Neptune untuk pelatihan model, Anda dapat memulai tugas pelatihan model menggunakan perintah `curl` (atau `awscurl`) seperti berikut ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
}'
```
Rincian tentang cara menggunakan perintah ini dijelaskan dalam [Perintah modeltraining](machine-learning-api-modeltraining.md), bersama dengan informasi tentang cara untuk mendapatkan status tugas yang sedang berjalan, cara menghentikan tugas yang sedang berjalan, dan mendaftar semua tugas yang sedang berjalan.
Anda juga dapat menyediakan informasi penggunaan dari pekerjaan pelatihan model Neptunus ML yang telah selesai untuk mempercepat pencarian hyperparameter dalam pekerjaan pelatihan baru. `previousModelTrainingJobId` Ini berguna selama [pelatihan ulang model pada data grafik baru](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining), serta [pelatihan tambahan pada data grafik yang sama](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental). Gunakan perintah seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"previousModelTrainingJobId" : "(the model-training job-id of a completed job)"
}'
```
Anda dapat melatih implementasi model Anda sendiri pada infrastruktur pelatihan Neptunus Neptunus dengan memasok objek, `customModelTrainingParameters` seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"modelName": "custom",
"customModelTrainingParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"trainingEntryPointScript": "(your training script entry-point name in the Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
Lihat [Perintah modeltraining](machine-learning-api-modeltraining.md) untuk informasi selengkapnya, seperti tentang cara mendapatkan status pekerjaan yang sedang berjalan, cara menghentikan pekerjaan yang sedang berjalan, dan cara membuat daftar semua pekerjaan yang sedang berjalan. Lihat [Model khusus di Neptunus ML](machine-learning-custom-models.md) untuk informasi tentang cara menerapkan dan menggunakan model kustom.
**Topics**
+ [Model dan pelatihan model di Amazon Neptunus](machine-learning-models-and-training.md)
+ [Menyesuaikan konfigurasi hyperparameter model di Neptune ML](machine-learning-customizing-hyperparams.md)
+ [Praktik terbaik pelatihan model](machine-learning-improve-model-performance.md)
# Model dan pelatihan model di Amazon Neptunus
Neptunus menggunakan Graph Neural Networks (GNN) untuk membuat model untuk berbagai tugas pembelajaran mesin. Jaringan saraf grafik telah terbukti memperoleh state-of-the-art hasil untuk tugas pembelajaran mesin grafik dan sangat baik dalam mengekstraksi pola informatif dari data terstruktur grafik.
## Grafik jaringan saraf (GNNs) di Neptunus ML
Graph Neural Networks (GNNs) milik keluarga jaringan saraf yang menghitung representasi simpul dengan mempertimbangkan struktur dan fitur node terdekat. GNNs melengkapi pembelajaran mesin tradisional lainnya dan metode jaringan saraf yang tidak cocok untuk data grafik.
GNNs digunakan untuk menyelesaikan tugas-tugas pembelajaran mesin seperti klasifikasi node dan regresi (memprediksi properti node) dan klasifikasi tepi dan regresi (memprediksi properti tepi) atau prediksi tautan (memprediksi apakah dua node dalam grafik harus terhubung atau tidak).
Secara umum, menggunakan GNN untuk tugas pembelajaran mesin melibatkan dua tahap:
+ Tahap pengkodean, di mana GNN menghitung vektor dimensi-d untuk setiap node dalam grafik. *Vektor-vektor ini juga disebut *representasi* atau embeddings.*
+ Tahap decoding, yang membuat prediksi berdasarkan representasi yang dikodekan.
Untuk klasifikasi dan regresi simpul, representasi simpul digunakan secara langsung untuk tugas klasifikasi dan regresi. Untuk klasifikasi tepi dan regresi, representasi simpul dari node insiden di tepi digunakan sebagai masukan untuk klasifikasi atau regresi. Untuk prediksi tautan, skor kemungkinan tepi dihitung dengan menggunakan sepasang representasi simpul dan representasi tipe tepi.
[Deep Graph Library (DGL)](https://www.dgl.ai/) memfasilitasi definisi dan pelatihan yang efisien GNNs untuk tugas-tugas ini.
Model GNN yang berbeda disatukan di bawah perumusan pengiriman pesan. Dalam tampilan ini, representasi untuk node dalam grafik dihitung menggunakan representasi tetangga node (pesan), bersama dengan representasi awal node. Dalam Neptuneml, representasi awal dari sebuah node berasal dari fitur yang diekstraksi dari properti node, atau dapat dipelajari dan tergantung pada identitas node.
Neptunus ML juga menyediakan opsi untuk menggabungkan fitur simpul dan representasi simpul yang dapat dipelajari untuk berfungsi sebagai representasi simpul asli.
Untuk berbagai tugas di Neptunus ML yang melibatkan grafik dengan properti simpul, kami menggunakan [Relational Graph Convolutional](https://arxiv.org/abs/1703.06103) Network (R-GCN)) untuk melakukan tahap pengkodean. R-GCN adalah arsitektur GNN yang sangat cocok untuk grafik yang memiliki beberapa tipe simpul dan tepi (ini dikenal sebagai grafik heterogen).
Jaringan R-GCN terdiri dari sejumlah lapisan tetap, ditumpuk satu demi satu. Setiap lapisan R-GCN menggunakan parameter model yang dapat dipelajari untuk mengumpulkan informasi dari lingkungan 1-hop langsung dari sebuah node. Karena lapisan berikutnya menggunakan representasi keluaran lapisan sebelumnya sebagai input, radius lingkungan grafik yang mempengaruhi penyematan akhir node bergantung pada jumlah lapisan (`num-layer`), dari jaringan R-GCN.
Misalnya, ini berarti bahwa jaringan 2-layer menggunakan informasi dari node yang berjarak 2 hop.
Untuk mempelajari selengkapnya GNNs, lihat [Survei Komprehensif tentang Jaringan Saraf Grafik](https://arxiv.org/abs/1901.00596). [Untuk informasi lebih lanjut tentang Deep Graph Library (DGL), kunjungi halaman web DGL.](https://www.dgl.ai/) Untuk tutorial langsung tentang penggunaan DGL dengan GNNs, lihat [Mempelajari jaringan saraf grafik dengan Deep](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library) Graph Library.
## Grafik Pelatihan Jaringan Saraf
Dalam pembelajaran mesin, proses mendapatkan model untuk belajar bagaimana membuat prediksi yang baik untuk suatu tugas disebut pelatihan model. Ini biasanya dilakukan dengan menentukan tujuan tertentu untuk dioptimalkan, serta algoritma yang digunakan untuk melakukan pengoptimalan ini.
Proses ini digunakan dalam pelatihan GNN untuk mempelajari representasi yang baik untuk tugas hilir juga. Kami membuat fungsi obyektif untuk tugas yang diminimalkan selama pelatihan model. Misalnya, untuk klasifikasi simpul, kami gunakan [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)sebagai tujuan, yang menghukum salah klasifikasi, dan untuk regresi simpul kami meminimalkan. [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html)
Tujuannya biasanya fungsi kerugian yang mengambil prediksi model untuk titik data tertentu dan membandingkannya dengan nilai kebenaran dasar untuk titik data tersebut. Ini mengembalikan nilai kerugian, yang menunjukkan seberapa jauh prediksi model. Tujuan dari proses pelatihan adalah untuk meminimalkan kerugian dan memastikan bahwa prediksi model mendekati kebenaran dasar.
Algoritma optimasi yang digunakan dalam pembelajaran mendalam untuk proses pelatihan biasanya merupakan varian dari penurunan gradien. Di Neptunus ML, kami [menggunakan](https://arxiv.org/pdf/1412.6980.pdf) Adam, yang merupakan algoritme untuk optimalisasi fungsi objektif stokastik berbasis gradien orde pertama berdasarkan perkiraan adaptif momen orde rendah.
Sementara proses pelatihan model mencoba untuk memastikan bahwa parameter model yang dipelajari mendekati minimum fungsi objektif, kinerja keseluruhan model juga tergantung pada *hiperparameter* model, yang merupakan pengaturan model yang tidak dipelajari oleh algoritma pelatihan. Misalnya, dimensi representasi simpul yang dipelajari,`num-hidden`, adalah hiperparameter yang memengaruhi kinerja model. Oleh karena itu, adalah umum dalam pembelajaran mesin untuk melakukan optimasi hyperparameter (HPO) untuk memilih hyperparameter yang sesuai.
Neptunus MLmenggunakan SageMaker pekerjaan tuning hyperparameter AI untuk meluncurkan beberapa contoh pelatihan model dengan konfigurasi hyperparameter yang berbeda untuk mencoba menemukan model terbaik untuk berbagai pengaturan hyperparameters. Lihat [Menyesuaikan konfigurasi hyperparameter model di Neptune ML](machine-learning-customizing-hyperparams.md).
## Model penyematan grafik pengetahuan di Neptunus ML
Grafik pengetahuan (KGs) adalah grafik yang mengkodekan informasi tentang entitas yang berbeda (node) dan hubungannya (tepi). Di Neptunus ML, model penyematan grafik pengetahuan diterapkan secara default untuk melakukan prediksi tautan ketika grafik tidak berisi properti simpul, hanya hubungan dengan node lain. Meskipun, model R-GCN dengan penyematan yang dapat dipelajari juga dapat digunakan untuk grafik ini dengan menentukan jenis model sebagai`"rgcn"`, model penyematan grafik pengetahuan lebih sederhana dan dirancang agar efektif untuk mempelajari representasi untuk grafik pengetahuan skala besar.
Model penyematan grafik pengetahuan digunakan dalam tugas prediksi tautan untuk memprediksi node atau hubungan yang menyelesaikan rangkap tiga `(h, r, t)` di mana `h` simpul sumber, `r` adalah tipe relasi dan `t` merupakan simpul tujuan.
Model penyematan grafik pengetahuan yang diterapkan di Neptunus ML `distmult` adalah,, dan. `transE` `rotatE` Untuk mempelajari lebih lanjut tentang model penyematan grafik pengetahuan, lihat [DGL-KE](https://github.com/awslabs/dgl-ke).
## Melatih model kustom di Neptunus ML
Neptunus ML memungkinkan Anda menentukan dan mengimplementasikan model kustom Anda sendiri, untuk skenario tertentu. Lihat [Model khusus di Neptunus ML](machine-learning-custom-models.md) untuk informasi tentang cara menerapkan model kustom dan cara menggunakan infrastruktur Neptunus ML untuk melatihnya.
# Menyesuaikan konfigurasi hyperparameter model di Neptune ML
Ketika Anda memulai tugas pelatihan model Neptune ML, Neptune ML otomatis menggunakan informasi yang disimpulkan dari tugas [pemrosesan data](machine-learning-on-graphs-processing.md) sebelumnya. Ini menggunakan informasi untuk menghasilkan rentang konfigurasi hyperparameter yang digunakan untuk membuat pekerjaan [tuning hyperparameter SageMaker AI untuk melatih beberapa model untuk tugas](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html) Anda. Dengan begitu, Anda tidak harus menentukan daftar panjang nilai hyperparameter untuk model yang akan dilatih. Sebaliknya, rentang dan default hyperparameter model dipilih berdasarkan jenis tugas, jenis grafik, dan pengaturan tugas penyetelan.
Namun, Anda juga dapat mengganti konfigurasi hyperparameter default dan menyediakan hyperparameters kustom dengan memodifikasi file konfigurasi JSON yang dihasilkan tugas pemrosesan data.
Menggunakan Neptune ML [API Pelatihanmodel](machine-learning-api-modeltraining.md), Anda dapat mengontrol beberapa pengaturan tugas penyetelan hyperparameter tingkat tinggi seperti`maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs`, dan `trainingInstanceType`. Untuk kontrol yang lebih halus atas hyperparameter model, Anda dapat menyesuaikan file `model-HPO-configuration.json` yang dihasilkan tugas pengolahan data. File disimpan di lokasi Amazon S3 yang Anda tentukan untuk output tugas pemrosesan.
Anda dapat mengunduh file, mengeditnya untuk mengganti konfigurasi hyperparameter default, dan mengunggahnya kembali ke lokasi Amazon S3 yang sama. Jangan mengubah nama file, dan hati-hati untuk mengikuti petunjuk ini saat Anda mengedit.
Mengunduh file dari Amazon S3.
```
aws s3 cp \
s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \
./
```
Setelah selesai mengedit, unggah kembali file ke tempatnya:
```
aws s3 cp \
model-HPO-configuration.json \
s3://(bucket name)/(path to output folder)/model-HPO-configuration.json
```
## Struktur berkas `model-HPO-configuration.json`
File `model-HPO-configuration.json` menentukan model yang akan dilatih, machine learning `task_type` dan hyperparameters yang harus bervariasi atau diperbaiki untuk berbagai rangkaian pelatihan model.
Hyperparameters dikategorikan sebagai milik berbagai tier yang menandakan prioritas diberikan kepada hyperparameters ketika tugas penyetelan hyperparameter dipanggil:
+ Hyperparameters Tier-1 memiliki prioritas tertinggi. Jika Anda mengatur `maxHPONumberOfTrainingJobs` ke nilai kurang dari 10, hanya hyperparameters Tier-1 yang disetel, dan sisanya mengambil nilai default mereka.
+ Hyperparameters Tier-2 memiliki prioritas yang lebih rendah, jadi jika Anda memiliki lebih dari 10 tapi kurang dari 50 total tugas pelatihan untuk tugas penyetelan, maka hyperparameters Tier-1 dan Tier-2 disetel.
+ Hyperparameters Tier 3 disetel bersama dengan Tier-1 dan Tier-2 hanya jika Anda memiliki lebih dari 50 total tugas pelatihan.
+ Akhirnya, hiperparameter tetap tidak disetel sama sekali, dan selalu mengambil nilai defaultnya.
### Contoh file `model-HPO-configuration.json`
Berikut ini adalah sampel file `model-HPO-configuration.json`:
```
{
"models": [
{
"model": "rgcn",
"task_type": "node_class",
"eval_metric": {
"metric": "acc"
},
"eval_frequency": {
"type": "evaluate_every_epoch",
"value": 1
},
"1-tier-param": [
{
"param": "num-hidden",
"range": [16, 128],
"type": "int",
"inc_strategy": "power2"
},
{
"param": "num-epochs",
"range": [3,30],
"inc_strategy": "linear",
"inc_val": 1,
"type": "int",
"node_strategy": "perM"
},
{
"param": "lr",
"range": [0.001,0.01],
"type": "float",
"inc_strategy": "log"
}
],
"2-tier-param": [
{
"param": "dropout",
"range": [0.0,0.5],
"inc_strategy": "linear",
"type": "float",
"default": 0.3
},
{
"param": "layer-norm",
"type": "bool",
"default": true
}
],
"3-tier-param": [
{
"param": "batch-size",
"range": [128, 4096],
"inc_strategy": "power2",
"type": "int",
"default": 1024
},
{
"param": "fanout",
"type": "int",
"options": [[10, 30],[15, 30], [15, 30]],
"default": [10, 15, 15]
},
{
"param": "num-layer",
"range": [1, 3],
"inc_strategy": "linear",
"inc_val": 1,
"type": "int",
"default": 2
},
{
"param": "num-bases",
"range": [0, 8],
"inc_strategy": "linear",
"inc_val": 2,
"type": "int",
"default": 0
}
],
"fixed-param": [
{
"param": "concat-node-embed",
"type": "bool",
"default": true
},
{
"param": "use-self-loop",
"type": "bool",
"default": true
},
{
"param": "low-mem",
"type": "bool",
"default": true
},
{
"param": "l2norm",
"type": "float",
"default": 0
}
]
}
]
}
```
### Elemen file `model-HPO-configuration.json`
File berisi objek JSON dengan array tingkat atas tunggal bernama `models` yang berisi objek model-konfigurasi tunggal. Saat menyesuaikan file, pastikan `models` array hanya memiliki satu objek model-konfigurasi di dalamnya. Jika file Anda berisi lebih dari satu objek konfigurasi model, pekerjaan penyetelan akan gagal dengan peringatan.
Objek model-konfigurasi berisi elemen tingkat atas berikut:
+ **`model`**— (*String*) Jenis model yang akan dilatih (**jangan modifikasi**). Nilai yang valid adalah:
+ `"rgcn"`— Ini adalah default untuk klasifikasi node dan tugas regresi, dan untuk tugas prediksi tautan heterogen.
+ `"transe"`— Ini adalah default untuk tugas prediksi tautan KGE.
+ `"distmult"`— Ini adalah jenis model alternatif untuk tugas prediksi tautan KGE.
+ `"rotate"`— Ini adalah jenis model alternatif untuk tugas prediksi tautan KGE.
Sebagai aturan, jangan langsung memodifikasi nilai `model`, karena jenis model yang berbeda sering memiliki hyperparameter berlaku secara substansial berbeda, yang dapat mengakibatkan kesalahan parsing setelah pekerjaan pelatihan telah dimulai.
Untuk mengubah jenis model, gunakan parameter `modelName` dalam [modelTraining API](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) ketimbang mengubahnya di file `model-HPO-configuration.json`.
Cara untuk mengubah jenis model dan membuat perubahan hyperparameter fine-grain adalah dengan menyalin template konfigurasi model default untuk model yang ingin Anda gunakan dan menempelkannya ke file `model-HPO-configuration.json`. Ada folder bernama `hpo-configuration-templates` di lokasi Amazon S3 yang sama sebagai file `model-HPO-configuration.json` jika jenis tugas yang disimpulkan mendukung beberapa model. Folder ini berisi semua konfigurasi hyperparameter default untuk model lain yang berlaku untuk tugas tersebut.
Misalnya, jika Anda ingin mengubah konfigurasi model dan hyperparameter untuk tugas prediksi link `KGE` dari default model `transe` ke model `distmult`, cukup tempelkan isi file `hpo-configuration-templates/distmult.json` ke file `model-HPO-configuration.json` dan kemudian edit hyperparameters seperti yang diperlukan.
**catatan**
Jika Anda mengatur parameter `modelName` dalam API `modelTraining` dan juga mengubah spesifikasi hyperparameter `model` dalam file `model-HPO-configuration.json`, dan ini berbeda, nilai `model` dalam file `model-HPO-configuration.json` diutamakan, dan nilai `modelName` diabaikan.
+ **`task_type`**— (*String*) Jenis tugas pembelajaran mesin yang disimpulkan oleh atau diteruskan langsung ke pekerjaan pemrosesan data (**jangan** modifikasi). Nilai yang valid adalah:
+ `"node_class"`
+ `"node_regression"`
+ `"link_prediction"`
Tugas pemrosesan data menyimpulkan jenis tugas dengan memeriksa set data yang diekspor dan file konfigurasi tugas pelatihan yang dihasilkan untuk properti set data.
Nilai ini seharusnya tidak diubah. Jika Anda ingin melatih tugas yang berbeda, Anda perlu [menjalankan pekerjaan pemrosesan data baru](machine-learning-on-graphs-processing.md). Jika nilai `task_type` adalah bukan yang Anda harapkan, Anda harus memeriksa input untuk tugas pemrosesan data Anda untuk memastikan bahwa mereka benar. Ini termasuk parameter untuk API `modelTraining`, sebagaimana dalam file konfigurasi tugas pelatihan yang dihasilkan oleh proses ekspor data.
+ **`eval_metric`**— (*String*) Metrik evaluasi harus digunakan untuk mengevaluasi kinerja model dan untuk memilih model berkinerja terbaik di seluruh proses HPO. Nilai yang valid adalah:
+ `"acc"`- Akurasi klasifikasi standar. Ini adalah default untuk tugas klasifikasi label tunggal, kecuali label yang tidak seimbang ditemukan selama pemrosesan data, dalam hal ini defaultnya adalah. `"F1"`
+ `"acc_topk"`— Berapa kali label yang benar adalah salah satu **`k`**prediksi teratas. Anda juga dapat mengatur nilai **`k`**dengan meneruskan `topk` sebagai kunci tambahan.
+ `"F1"`— [Skor F1](https://en.wikipedia.org/wiki/F-score).
+ `"mse"`— [Metrik kesalahan kuadrat rata-rata](https://en.wikipedia.org/wiki/Mean_squared_error), untuk tugas regresi.
+ `"mrr"`— [Rata-rata metrik peringkat timbal balik](https://en.wikipedia.org/wiki/Mean_reciprocal_rank).
+ `"precision"`— Presisi model, dihitung sebagai rasio positif sejati terhadap positif yang diprediksi:. `= true-positives / (true-positives + false-positives)`
+ `"recall"`— Model recall, dihitung sebagai rasio positif sejati terhadap positif aktual:. `= true-positives / (true-positives + false-negatives)`
+ `"roc_auc"`— Area di bawah [kurva ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Ini adalah default untuk klasifikasi multi-label.
Misalnya, untuk mengubah metrik menjadi`F1`, ubah `eval_metric` nilainya sebagai berikut:
```
" eval_metric": {
"metric": "F1",
},
```
Atau, untuk mengubah metrik menjadi skor `topk` akurasi, Anda akan mengubah `eval_metric` sebagai berikut:
```
"eval_metric": {
"metric": "acc_topk",
"topk": 2
},
```
+ **`eval_frequency`**— (*Objek*) Menentukan seberapa sering selama pelatihan kinerja model pada set validasi harus diperiksa. Berdasarkan kinerja validasi, penghentian dini kemudian dapat dimulai dan model terbaik dapat disimpan.
`eval_frequency`Objek tersebut mengandung dua elemen, yaitu `"type"` dan`"value"`. Contoh:
```
"eval_frequency": {
"type": "evaluate_every_pct",
"value": 0.1
},
```
`type`Nilai yang valid adalah:
+ **`evaluate_every_pct`**— Menentukan persentase pelatihan yang harus diselesaikan untuk setiap evaluasi.
Untuk`evaluate_every_pct`, `"value"` bidang berisi angka floating-point antara nol dan satu yang menyatakan persentase itu.
+ **`evaluate_every_batch`**— Menentukan jumlah batch pelatihan yang harus diselesaikan untuk setiap evaluasi.
Untuk`evaluate_every_batch`, `"value"` bidang berisi integer yang menyatakan jumlah batch tersebut.
+ **`evaluate_every_epoch`**— Menentukan jumlah epoch per evaluasi, di mana epoch baru dimulai pada tengah malam.
Untuk`evaluate_every_epoch`, `"value"` bidang berisi bilangan bulat yang menyatakan jumlah epoch itu.
Pengaturan default untuk `eval_frequency` adalah:
```
"eval_frequency": {
"type": "evaluate_every_epoch",
"value": 1
},
```
+ **`1-tier-param`** – (*Wajib*) Sebuah array dari hyperparameters Tier-1 .
Jika Anda tidak ingin menyetel hyperparameters apa pun, Anda dapat mengatur ini ke array kosong. Ini tidak mempengaruhi jumlah total pekerjaan pelatihan yang diluncurkan oleh pekerjaan tuning hyperparameter SageMaker AI. Ini hanya berarti bahwa semua tugas pelatihan, jika ada lebih dari 1 tapi kurang dari 10, maka akan berjalan dengan set hyperparameters yang sama.
Di sisi lain, jika Anda ingin memperlakukan semua hyperparameters yang bisa disetel dengan signifikansi yang sama maka Anda dapat menempatkan semua hyperparameters dalam array ini.
+ **`2-tier-param`** – (*Wajib*) Sebuah array dari hyperparameters Tier-2 .
Parameter ini hanya disetel jika `maxHPONumberOfTrainingJobs` memiliki nilai lebih besar dari 10. Jika tidak, mereka tetap ke nilai default.
Jika Anda memiliki anggaran pelatihan paling banyak 10 tugas pelatihan atau tidak menginginkan hyperparameters Tier-2 untuk alasan apapun, tetapi Anda ingin menyetel semua hyperparameters yang dapat disetel, maka Anda dapat mengatur ini ke array kosong.
+ **`3-tier-param`** – (*Wajib*) Sebuah array dari hyperparameters Tier-3 .
Parameter ini hanya disetel jika `maxHPONumberOfTrainingJobs` memiliki nilai lebih besar dari 50. Jika tidak, mereka tetap ke nilai default.
Jika Anda tidak menginginkan hyperparameters Tier-3, Anda dapat mengatur ini ke array kosong.
+ **`fixed-param`**— (*Wajib*) Array hyperparameters tetap yang hanya mengambil nilai defaultnya dan tidak mengambil bervariasi dalam tugas pelatihan yang berbeda.
Jika Anda ingin memvariasi semua hyperparameter, Anda dapat mengatur ini ke array kosong dan juga mengatur nilai untuk `maxHPONumberOfTrainingJobs` cukup besar untuk memvariasi semua tier atau membuat semua hyperparameters Tier-1.
Objek JSON yang mewakili setiap hyperparameter di `1-tier-param`, `2-tier-param`, `3-tier-param`, dan `fixed-param` berisi elemen berikut:
+ **`param`**— (*String*) Nama hyperparameter (**jangan berubah**).
Lihat daftar [ nama hyperparameter yang valid di Neptune ML](#machine-learning-hyperparams-list).
+ **`type`**— (*String*) Tipe hyperparameter (**jangan berubah**).
Jenis yang valid adalah: `bool`, `int`, dan `float`.
+ **`default`**— (*String*) Nilai default untuk hyperparameter.
Anda dapat mengatur nilai default baru.
Hyperparameters yang dapat disetel juga dapat berisi elemen berikut:
+ **`range`**— (*Array*) Rentang untuk hyperparameter yang dapat disetel terus menerus.
Ini seharusnya array dengan dua nilai, yaitu minimum dan maksimum rentang (`[min, max]`).
+ **`options`**— (*Array*) Opsi untuk hyperparameter kategoris yang dapat disetel.
Array ini harus berisi semua opsi untuk dipertimbangkan:
```
"options" : [value1, value2, ... valuen]
```
+ **`inc_strategy`**— (*String*) Jenis perubahan inkremental untuk rentang hyperparameter yang dapat disetel terus menerus (**jangan** berubah).
Nilai yang valid adalah `log`, `linear`, dan `power2`. Ini hanya berlaku bila kunci rentang diatur.
Memodifikasi kunci ini dapat mengakibatkan tidak digunakannya secara penuh hyperparameter Anda untuk penyetelan.
+ **`inc_val`****— (*Float*) Jumlah dimana kenaikan berturut-turut berbeda untuk tunablehyperparameters kontinu (jangan berubah).**
Ini hanya berlaku bila kunci rentang diatur.
Memodifikasi kunci ini dapat mengakibatkan tidak digunakannya secara penuh hyperparameter Anda untuk penyetelan.
+ **`node_strategy`**— (*String*) Menunjukkan bahwa rentang efektif untuk hyperparameter ini harus berubah berdasarkan jumlah node dalam grafik (**jangan berubah**).
Nilai yang valid adalah `"perM"` (per juta), `"per10M"` (per 10 juta), dan `"per100M"` (per 100 juta).
Daripada mengubah nilai ini, ubah `range` sebagai gantinya.
+ **`edge_strategy`**— (*String*) Menunjukkan bahwa rentang efektif untuk hyperparameter ini harus berubah berdasarkan jumlah tepi dalam grafik (**jangan berubah**).
Nilai yang valid adalah `"perM"` (per juta), `"per10M"` (per 10 juta), dan `"per100M"` (per 100 juta).
Daripada mengubah nilai ini, ubah `range` sebagai gantinya.
### Daftar semua hyperparameters di Neptune ML
Daftar berikut berisi semua hyperparameters yang dapat diatur di mana saja di Neptune ML, untuk setiap jenis model dan tugas. Karena mereka semua tidak berlaku untuk setiap jenis model, adalah penting bahwa Anda hanya mengatur hyperparameters di file `model-HPO-configuration.json` yang muncul di templat untuk model yang Anda gunakan.
+ **`batch-size`** – Ukuran batch simpul target yang digunakan dalam satu forward pass. *Jenis*:`int`.
Mengatur ke nilai yang jauh lebih besar dapat menyebabkan masalah memori untuk pelatihan pada instans GPU.
+ **`concat-node-embed`**— Menunjukkan apakah akan mendapatkan representasi awal dari sebuah node dengan menggabungkan fitur yang diproses dengan penyematan simpul awal yang dapat dipelajari untuk meningkatkan ekspresivitas model. *Jenis*:`bool`.
+ **`dropout`** – Probabilitas dropout yang diterapkan pada lapisan dropout. *Jenis*:`float`.
+ **`edge-num-hidden`**- Ukuran lapisan tersembunyi atau jumlah unit untuk modul fitur tepi. Hanya digunakan saat `use-edge-features` disetel ke`True`. *Jenis*: mengapung.
+ **`enable-early-stop`**— Beralih apakah akan menggunakan fitur penghentian awal atau tidak. *Jenis*:`bool`. *Default*: `true`.
Gunakan parameter Boolean ini untuk mematikan fitur berhenti awal.
+ **`fanout`** – Jumlah neighbor yang akan dijadikan sampel untuk simpul target selama sampling neighbor. *Jenis*:`int`.
Nilai ini digabungkan dengan erat dengan `num-layers` dan harus selalu berada di tier hyperparameter yang sama. Hal ini karena Anda dapat menentukan fanout untuk setiap layer GNN potensial.
Karena hyperparameter ini dapat menyebabkan kinerja model bervariasi luas, seharusnya hyperparameter ini diperbaiki atau ditetapkan sebagai hyperparameter Tier-2 atau Tier-3. Mengaturnya ke nilai yang besar dapat menyebabkan masalah memori untuk pelatihan pada instans GPU.
+ **`gamma`** – Nilai margin dalam fungsi skor. *Jenis*:`float`.
Hal ini berlaku untuk model prediksi link `KGE` saja.
+ **`l2norm`**- Nilai peluruhan berat yang digunakan dalam pengoptimal yang memberlakukan penalti normalisasi L2 pada bobot. *Jenis*:`bool`.
+ **`layer-norm`** – Mengindikasikan apakah akan menggunakan normalisasi lapisan untuk model `rgcn`. *Jenis*:`bool`.
+ **`low-mem`** – Mengindikasikan apakah akan menggunakan implementasi memori rendah dari pesan relasi yang melewati fungsi di pengeluaran kecepatan. *Jenis*:`bool`.
+ **`lr`** – Tingkat pembelajaran. *Jenis*:`float`.
Ini harus ditetapkan sebagai hyperparameter Tier-1.
+ **`neg-share`** – Dalam prediksi link, menunjukkan apakah edge bersampel positif dapat berbagi sampel edge negatif. *Jenis*:`bool`.
+ **`num-bases`** – Jumlah basis untuk dekomposisi dasar dalam model `rgcn`. Menggunakan nilai `num-bases` yang kurang dari jumlah jenis tepi dalam grafik bertindak sebagai regularizer untuk model. `rgcn` *Jenis*:`int`.
+ **`num-epochs`** – Banyaknya jangka waktu pelatihan untuk dijalankan. *Jenis*:`int`.
Jangka waktu adalah pelatihan lengkap yang melewati grafik.
+ **`num-hidden`** – Ukuran lapisan tersembunyi atau jumlah unit. *Jenis*:`int`.
Ini juga menetapkan ukuran penanaman awal untuk simpul tanpa fitur.
Menyetel ini ke nilai yang jauh lebih besar tanpa mengurangi `batch-size` dapat menyebabkan out-of-memory masalah untuk pelatihan tentang instance GPU.
+ **`num-layer`** – Jumlah layer GNN pada model. *Jenis*:`int`.
Nilai ini dipasangkan erat dengan parameter fanout dan harus ada setelah fanout diatur di tier hyperparameter yang sama.
Karena ini dapat menyebabkan kinerja model bervariasi luas, seharusnya hyperparameter ini diperbaiki atau ditetapkan sebagai hyperparameter Tier-2 atau Tier-3.
+ **`num-negs`** – Dalam prediksi tautan, jumlah sampel negatif per sampel positif. *Jenis*:`int`.
+ **`per-feat-name-embed`**— Menunjukkan apakah akan menyematkan setiap fitur dengan mengubahnya secara independen sebelum menggabungkan fitur. *Jenis*:`bool`.
Ketika diatur ke`true`, setiap fitur per node ditransformasikan secara independen ke ukuran dimensi tetap sebelum semua fitur yang diubah untuk node digabungkan dan selanjutnya diubah ke dimensi. `num_hidden`
Saat disetel ke`false`, fitur digabungkan tanpa transformasi khusus fitur apa pun.
+ **`regularization-coef`** – Dalam prediksi link, koefisien kerugian regularisasi. *Jenis*:`float`.
+ **`rel-part`** – Mengindikasikan apakah akan menggunakan partisi relasi untuk prediksi link `KGE`. *Jenis*:`bool`.
+ **`sparse-lr`**— Tingkat pembelajaran untuk penyematan simpul yang dapat dipelajari. *Jenis*:`float`.
Penyematan simpul awal yang dapat dipelajari digunakan untuk node tanpa fitur atau kapan disetel. `concat-node-embed` Parameter lapisan penyematan simpul yang dapat dipelajari jarang dilatih menggunakan pengoptimal terpisah yang dapat memiliki tingkat pembelajaran terpisah.
+ **`use-class-weight`**— Menunjukkan apakah akan menerapkan bobot kelas untuk tugas klasifikasi yang tidak seimbang. Jika disetel ke`true`, jumlah label digunakan untuk menetapkan bobot untuk setiap label kelas. *Jenis*:`bool`.
+ **`use-edge-features`**— Menunjukkan apakah akan menggunakan fitur tepi selama pengiriman pesan. Jika disetel ke`true`, modul fitur tepi khusus ditambahkan ke lapisan RGCN untuk tipe tepi yang memiliki fitur. *Jenis*:`bool`.
+ **`use-self-loop`** – Menunjukkan apakah akan menyertakan self loop dalam pelatihan model `rgcn`. *Jenis*:`bool`.
+ **`window-for-early-stop`**— Mengontrol jumlah skor validasi terbaru ke rata-rata untuk memutuskan pemberhentian awal. Defaultnya adalah 3. type=int. Lihat juga [Penghentian awal proses pelatihan model di Neptunus ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Jenis*:`int`. *Default*: `3`.
Lihat .
## Menyesuaikan hiperparameter di Neptunus ML
Saat Anda mengedit file `model-HPO-configuration.json`, berikut ini adalah jenis perubahan yang paling umum dibuat:
+ Edit nilai and/or maksimum minimum `range` hyperparameters.
+ Menetapkan hyperparameter ke nilai tetap dengan memindahkannya ke bagian `fixed-param` dan menetapkan nilai defaultnya ke nilai tetap yang ingin Anda ambil.
+ Mengubah prioritas hyperparameter dengan menempatkannya di tier tertentu, mengedit rentangnya, dan memastikan bahwa nilai defaultnya diatur dengan tepat.
# Praktik terbaik pelatihan model
Ada beberapa hal yang dapat Anda lakukan untuk meningkatkan performa Neptune ML.
## Pilih properti simpul yang tepat
Tidak semua properti dalam grafik Anda bermakna atau relevan dengan tugas machine learning Anda. Setiap properti yang tidak relevan harus dikecualikan selama ekspor data.
Berikut ini adalah beberapa praktik terbaik:
+ Gunakan ahli domain untuk membantu mengevaluasi pentingnya fitur dan kelayakan menggunakannya untuk prediksi.
+ Menghapus fitur yang Anda tentukan bersifat berlebihan atau tidak relevan untuk mengurangi kebisingan dalam data dan korelasi tidak penting.
+ Iterate saat Anda membangun model Anda. Sesuaikan fitur, kombinasi fitur, dan tujuan penyetelan saat Anda mengikuti.
[Pemrosesan Fitur](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html)di Panduan Developer Amazon Machine Learning menyediakan pedoman tambahan untuk pemrosesan fitur yang relevan dengan Neptune ML.
## Menangani titik data outlier
Outlier adalah titik data yang berbeda secara signifikan dari data yang tersisa. Pencilan data dapat merusak atau menyesatkan proses pelatihan, menghasilkan waktu pelatihan yang lebih lama atau model yang kurang akurat. Kecuali outlier benar-benar penting, Anda harus menghilangkan outlier sebelum mengekspor data.
## Hapus simpul dan edge duplikat
Grafik yang disimpan di Neptune mungkin memiliki simpul atau edge duplikat . Elemen yang berlebihan ini akan memperkenalkan kebisingan untuk pelatihan Model ML. Hilangkan simpul atau edge duplikat sebelum mengekspor data.
## Menyetel struktur grafik
Ketika grafik diekspor, Anda dapat mengubah cara fitur diproses dan cara grafik dibangun, untuk meningkatkan performa model.
Berikut ini adalah beberapa praktik terbaik:
+ Ketika properti edge memiliki arti kategori edge, ada baiknya mengubahnya menjadi jenis edge dalam beberapa kasus.
+ Kebijakan normalisasi default yang digunakan untuk properti numerik adalah `min-max`, tetapi dalam beberapa kasus kebijakan normalisasi lainnya bekerja lebih baik. Anda dapat melakukan pra-proses properti dan mengubah kebijakan normalisasi seperti yang dijelaskan dalam [Elemen file `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements).
+ Proses ekspor secara otomatis menghasilkan jenis fitur berdasarkan jenis properti. Sebagai contoh, itu memperlakukan properti `String` sebagai fitur kategoris dan properti `Float` dan `Int` sebagai fitur numerik. Jika perlu, Anda dapat mengubah jenis fitur setelah ekspor (lihat [Elemen file `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)).
## Menyetel rentang dan default hyperparameter
Operasi pemrosesan data menyimpulkan rentang konfigurasi hyperparameter dari grafik. Jika rentang dan default hyperparameter model yang dihasilkan tidak bekerja dengan baik untuk data grafik Anda, Anda dapat mengedit file konfigurasi HPO untuk membuat strategi penyetelan hyperparameter Anda sendiri.
Berikut ini adalah beberapa praktik terbaik:
+ Ketika grafik menjadi besar, ukuran dimensi tersembunyi default mungkin tidak cukup besar untuk berisi semua informasi. Anda dapat mengubah hyperparameter `num-hidden` untuk mengontrol ukuran dimensi tersembunyi.
+ Untuk model knowledge graph embedding (KGE), Anda mungkin ingin mengubah model spesifik yang digunakan sesuai dengan struktur grafik dan anggaran Anda.
`TrainsE`model mengalami kesulitan dalam menangani hubungan one-to-many (1-N), many-to-one (N-1), dan many-to-many (N-N). `DistMult`model mengalami kesulitan dalam berurusan dengan hubungan simetris. `RotatE`pandai memodelkan semua jenis hubungan tetapi lebih mahal daripada `TrainsE` dan `DistMult` selama pelatihan.
+ Dalam beberapa kasus, ketika identifikasi simpul dan informasi fitur simpul penting, Anda harus menggunakan ``concat-node-embed`` untuk memberitahu model Neptune ML untuk mendapatkan representasi awal dari simpul dengan menggabungkan fitur-fiturnya dengan penanaman awalnya.
+ Ketika Anda mendapatkan performa yang cukup baik atas beberapa hyperparameters, Anda dapat menyesuaikan ruang pencarian hyperparameter sesuai dengan hasil tersebut.
## Penghentian awal proses pelatihan model di Neptunus ML
Penghentian dini dapat secara signifikan mengurangi waktu lari pelatihan model dan biaya terkait tanpa menurunkan kinerja model. Ini juga mencegah model agar tidak terlalu pas pada data pelatihan.
Penghentian dini tergantung pada pengukuran reguler kinerja set validasi. Awalnya, kinerja meningkat saat pelatihan berlangsung, tetapi ketika model mulai overfitting, itu mulai menurun lagi. Fitur penghentian awal mengidentifikasi titik di mana model mulai overfitting dan menghentikan pelatihan model pada saat itu.
Neptunus ML memantau panggilan metrik validasi dan membandingkan metrik validasi terbaru dengan rata-rata metrik validasi selama evaluasi **`n`**terakhir, di mana angka ditetapkan menggunakan parameter. **`n`**`window-for-early-stop` Segera setelah metrik validasi lebih buruk dari rata-rata itu, Neptunus ML menghentikan pelatihan model dan menyimpan model terbaik sejauh ini.
Anda dapat mengontrol penghentian awal menggunakan parameter berikut:
+ **`window-for-early-stop`**— Nilai parameter ini adalah bilangan bulat yang menentukan jumlah skor validasi terbaru menjadi rata-rata saat memutuskan pemberhentian awal. Nilai default-nya adalah `3`.
+ **`enable-early-stop`**— Gunakan parameter Boolean ini untuk mematikan fitur berhenti awal. Secara default, nilainya adalah`true`.
## Penghentian awal proses HPO di Neptunus ML
Fitur berhenti awal di Neptunus ML juga menghentikan pekerjaan pelatihan yang tidak berkinerja baik dibandingkan dengan pekerjaan pelatihan lainnya, menggunakan fitur AI HPO SageMaker warm-start. Hal ini juga dapat mengurangi biaya dan meningkatkan kualitas HPO.
Lihat [Menjalankan pekerjaan tuning hyperparameter start yang hangat](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html) untuk deskripsi cara kerjanya.
Warm start memberikan kemampuan untuk menyampaikan informasi yang dipelajari dari pekerjaan pelatihan sebelumnya ke pekerjaan pelatihan berikutnya dan memberikan dua manfaat berbeda:
+ Pertama, hasil pekerjaan pelatihan sebelumnya digunakan untuk memilih kombinasi hiperparameter yang baik untuk dicari dalam pekerjaan penyetelan baru.
+ Kedua, memungkinkan penghentian awal untuk mengakses lebih banyak model berjalan, yang mengurangi waktu penyetelan.
Fitur ini diaktifkan secara otomatis di Neptunus ML, dan memungkinkan Anda mencapai keseimbangan antara waktu pelatihan model dan kinerja. Jika Anda puas dengan kinerja model saat ini, Anda dapat menggunakan model itu. Jika tidak, Anda menjalankan lebih banyak HPOs yang dimulai dengan hasil lari sebelumnya untuk menemukan model yang lebih baik.
## Dapatkan layanan dukungan profesional
AWS menawarkan layanan dukungan profesional untuk membantu Anda dengan masalah dalam pembelajaran mesin Anda pada proyek Neptunus. Jika Anda terjebak, hubungi [dukungan AWS](https://aws.amazon.com/premiumsupport/).
# Gunakan model terlatih untuk menghasilkan artefak model baru
Dengan menggunakan perintah transformasi model Neptunus ML, Anda dapat menghitung artefak model seperti penyematan simpul pada data grafik yang diproses menggunakan parameter model yang telah dilatih sebelumnya.
## Transformasi model untuk inferensi inkremental
Dalam [alur kerja inferensi model inkremental](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental), setelah Anda memproses data grafik terbaru yang Anda ekspor dari Neptunus, Anda dapat memulai pekerjaan transformasi model menggunakan perintah curl (atau awscurl) seperti berikut:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"mlModelTrainingJobId": "(the ML model training job-id)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
}'
```
Anda kemudian dapat meneruskan ID pekerjaan ini ke panggilan API create-endpoint untuk membuat titik akhir baru atau memperbarui yang sudah ada dengan artefak model baru yang dihasilkan oleh pekerjaan ini. Ini memungkinkan titik akhir baru atau yang diperbarui untuk memberikan prediksi model untuk data grafik yang diperbarui.
## Transformasi model untuk pekerjaan pelatihan apa pun
Anda juga dapat menyediakan `trainingJobName` parameter untuk menghasilkan artefak model untuk salah satu pekerjaan pelatihan SageMaker AI yang diluncurkan selama pelatihan model Neptunus ML. Karena pekerjaan pelatihan model Neptunus ML berpotensi meluncurkan SageMaker banyak pekerjaan pelatihan AI, ini memberi Anda fleksibilitas untuk membuat titik akhir inferensi berdasarkan salah satu pekerjaan pelatihan AI tersebut. SageMaker
Misalnya:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"trainingJobName" : "(name a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
}'
```
Jika pekerjaan pelatihan asli adalah untuk model kustom yang disediakan pengguna, Anda harus menyertakan `customModelTransformParameters` objek saat menjalankan transformasi model. Lihat [Model khusus di Neptunus ML](machine-learning-custom-models.md) untuk informasi tentang cara menerapkan dan menggunakan model kustom.
**catatan**
`modeltransform`Perintah selalu menjalankan transformasi model pada pekerjaan pelatihan SageMaker AI terbaik untuk pelatihan itu.
Lihat [Perintah modeltransform](machine-learning-api-modeltransform.md) untuk informasi lebih lanjut tentang pekerjaan transformasi model.
# Artefak yang diproduksi oleh pelatihan model di Neptunus ML
Setelah pelatihan model, Neptunus ML menggunakan parameter model terlatih terbaik untuk menghasilkan artefak model yang diperlukan untuk meluncurkan titik akhir inferensi dan memberikan prediksi model. Artefak ini dikemas oleh pekerjaan pelatihan dan disimpan di lokasi keluaran Amazon S3 dari pekerjaan pelatihan AI SageMaker terbaik.
Bagian berikut menjelaskan apa yang termasuk dalam artefak model untuk berbagai tugas, dan bagaimana perintah transformasi model menggunakan model terlatih yang sudah ada sebelumnya untuk menghasilkan artefak bahkan pada data grafik baru.
## Artefak yang dihasilkan untuk tugas yang berbeda
Isi artefak model yang dihasilkan oleh proses pelatihan tergantung pada tugas pembelajaran mesin target:
****
+ **Klasifikasi dan regresi node** — Untuk prediksi properti node, artefak mencakup parameter model, penyematan simpul dari [encoder GNN](machine-learning-models-and-training.md#machine-learning-gnns), prediksi model untuk node dalam grafik pelatihan, dan beberapa file konfigurasi untuk titik akhir inferensi. Dalam klasifikasi node dan tugas regresi node, prediksi model dihitung sebelumnya untuk node yang ada selama pelatihan untuk mengurangi latensi kueri.
+ **Klasifikasi dan regresi tepi** — Untuk prediksi properti tepi, artefak juga menyertakan parameter model dan penyematan simpul. Parameter dekoder model sangat penting untuk inferensi karena kami menghitung klasifikasi tepi atau prediksi regresi tepi dengan menerapkan decoder model ke penyematan simpul sumber dan tujuan tepi.
+ **Prediksi tautan** - Untuk prediksi tautan, selain artefak yang dihasilkan untuk prediksi properti tepi, grafik DGL juga disertakan sebagai artefak karena prediksi tautan memerlukan grafik pelatihan untuk melakukan prediksi. Tujuan prediksi tautan adalah untuk memprediksi simpul tujuan yang cenderung bergabung dengan simpul sumber untuk membentuk tepi jenis tertentu dalam grafik. Untuk melakukan ini, penyematan simpul dari simpul sumber dan representasi yang dipelajari untuk tipe tepi digabungkan dengan penyematan simpul dari semua simpul tujuan yang mungkin untuk menghasilkan skor kemungkinan tepi untuk masing-masing simpul tujuan. Skor kemudian diurutkan untuk menentukan peringkat simpul tujuan potensial dan mengembalikan kandidat teratas.
Untuk setiap jenis tugas, bobot model Graph Neural Network dari DGL disimpan dalam artefak model. *Hal ini memungkinkan Neptunus ML untuk menghitung output model baru saat grafik berubah *(inferensi induktif), selain menggunakan prediksi dan penyematan yang telah dihitung sebelumnya (*inferensi transduktif) untuk mengurangi latensi.*
## Menghasilkan artefak model baru
Artefak model yang dihasilkan setelah pelatihan model di Neptunus ML terkait langsung dengan proses pelatihan. Ini berarti bahwa penyematan dan prediksi yang telah dihitung sebelumnya hanya ada untuk entitas yang ada dalam grafik pelatihan asli. Meskipun mode inferensi induktif untuk titik akhir Neptunus ML dapat menghitung prediksi untuk entitas baru secara real-time, Anda mungkin ingin menghasilkan prediksi batch pada entitas baru tanpa menanyakan titik akhir.
Untuk mendapatkan prediksi model batch untuk entitas baru yang telah ditambahkan ke grafik, artefak model baru perlu dihitung ulang untuk data grafik baru. Ini dilakukan dengan menggunakan `modeltransform` perintah. Anda menggunakan `modeltransform` perintah ketika Anda hanya ingin prediksi batch tanpa menyiapkan titik akhir, atau ketika Anda ingin semua prediksi dihasilkan sehingga Anda dapat menulisnya kembali ke grafik.
Karena pelatihan model secara implisit melakukan transformasi model pada akhir proses pelatihan, artefak model selalu dihitung ulang pada data grafik pelatihan oleh pekerjaan pelatihan. Namun, `modeltransform` perintah tersebut juga dapat menghitung artefak model pada data grafik yang tidak digunakan untuk melatih model. Untuk ini, data grafik baru harus diproses menggunakan pengkodean fitur yang sama dengan data grafik asli dan harus mematuhi skema grafik yang sama.
Anda dapat melakukannya dengan terlebih dahulu membuat pekerjaan pemrosesan data baru yang merupakan tiruan dari pekerjaan pemrosesan data yang dijalankan pada data grafik pelatihan asli, dan menjalankannya pada data grafik baru (lihat[Memproses data grafik yang diperbarui untuk Neptunus ML](machine-learning-on-graphs-processing.md#machine-learning-on-graphs-processing-updated)). Kemudian, panggil `modeltransform` perintah dengan yang baru `dataProcessingJobId` dan yang lama `modelTrainingJobId` untuk menghitung ulang artefak model pada data grafik yang diperbarui.
Untuk prediksi properti node, penyematan dan prediksi simpul dihitung ulang pada data grafik baru, bahkan untuk node yang ada dalam grafik pelatihan asli.
Untuk prediksi properti edge dan prediksi tautan, penyematan simpul juga dihitung ulang dan juga mengesampingkan penyematan simpul yang ada. Untuk menghitung ulang penyematan simpul, Neptunus MLmenerapkan encoder GNN yang dipelajari dari model terlatih sebelumnya ke node data grafik baru dengan fitur baru mereka.
Untuk node yang tidak memiliki fitur, representasi awal yang dipelajari dari pelatihan model asli digunakan kembali. Untuk node baru yang tidak memiliki fitur dan tidak ada dalam grafik pelatihan asli, Neptunus ML menginisialisasi representasi mereka sebagai rata-rata representasi simpul awal yang dipelajari dari tipe simpul yang ada dalam grafik pelatihan asli. Ini dapat menyebabkan beberapa penurunan kinerja dalam prediksi model jika Anda memiliki banyak node baru yang tidak memiliki fitur, karena semuanya akan diinisialisasi ke penyematan awal rata-rata untuk jenis node tersebut.
Jika model Anda dilatih dengan `concat-node-embed` set ke true, maka representasi node awal dibuat dengan menggabungkan fitur node dengan representasi awal yang dapat dipelajari. Jadi, untuk grafik yang diperbarui, representasi simpul awal dari node baru juga menggunakan penyematan simpul awal rata-rata, digabungkan dengan fitur node baru.
Selain itu, penghapusan node saat ini tidak didukung. Jika node telah dihapus dalam grafik yang diperbarui, Anda harus melatih kembali model pada data grafik yang diperbarui.
Menghitung ulang artefak model menggunakan kembali parameter model yang dipelajari pada grafik baru, dan hanya boleh dilakukan ketika grafik baru sangat mirip dengan grafik lama. Jika grafik baru Anda tidak cukup mirip, Anda perlu melatih ulang model untuk mendapatkan kinerja model yang serupa pada data grafik baru. Apa yang cukup mirip tergantung pada struktur data grafik Anda, tetapi sebagai aturan praktis Anda harus melatih kembali model Anda jika data baru Anda lebih dari 10-20% berbeda dari data grafik pelatihan asli.
Untuk grafik di mana semua node memiliki fitur, ujung ambang batas yang lebih tinggi (20% berbeda) berlaku tetapi untuk grafik di mana banyak node tidak memiliki fitur dan node baru yang ditambahkan ke grafik tidak memiliki properti, maka ujung bawah (10% berbeda) bahkan mungkin terlalu tinggi.
Lihat [Perintah modeltransform](machine-learning-api-modeltransform.md) untuk informasi lebih lanjut tentang pekerjaan transformasi model.
# Model khusus di Neptunus ML
**catatan**
Dukungan model kustom Neptunus ML bergantung pada versi Python 3 yang lebih lama. [Untuk membuat dan menjalankan model GNN kustom dengan up-to-date dependensi gunakan pada. GraphStorm SageMaker](https://graphstorm.readthedocs.io/en/v0.3.1/cli/model-training-inference/distributed/sagemaker.html)
[Inferensi induktif waktu nyata](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) saat ini tidak didukung untuk model khusus.
Neptunus ML memungkinkan Anda menentukan implementasi model kustom Anda sendiri menggunakan Python. Anda dapat melatih dan menerapkan model kustom menggunakan infrastruktur Neptunus ML seperti yang Anda lakukan untuk model bawaan, dan menggunakannya untuk mendapatkan prediksi melalui kueri grafik.
Anda dapat mulai menerapkan model kustom Anda sendiri dengan Python dengan mengikuti [contoh toolkit Neptunus ML, dan dengan menggunakan komponen model yang disediakan di toolkit](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/) Neptunus ML. Bagian berikut memberikan rincian lebih lanjut.
**Contents**
+ [Ikhtisar model khusus di Neptunus ML](machine-learning-custom-model-overview.md)
+ [Kapan menggunakan model kustom di Neptunus ML](machine-learning-custom-model-overview.md#machine-learning-custom-models-when-to-use)
+ [Alur kerja untuk mengembangkan dan menggunakan model kustom di Neptunus ML](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow)
+ [Pengembangan model khusus di Neptunus ML](machine-learning-custom-model-development.md)
+ [Pengembangan skrip pelatihan model khusus di Neptunus ML](machine-learning-custom-model-development.md#machine-learning-custom-model-training-script)
+ [Model kustom mengubah pengembangan skrip di Neptunus ML](machine-learning-custom-model-development.md#machine-learning-custom-model-transform-script)
+ [`model-hpo-configuration.json`File kustom di Neptunus ML](machine-learning-custom-model-development.md#machine-learning-custom-model-hpo-configuration-file)
+ [Pengujian lokal implementasi model kustom Anda di Neptunus ML](machine-learning-custom-model-development.md#machine-learning-custom-model-testing)
# Ikhtisar model khusus di Neptunus ML
## Kapan menggunakan model kustom di Neptunus ML
Model bawaan Neptunus ML menangani semua tugas standar yang didukung oleh Neptunus ML, tetapi mungkin ada kasus di mana Anda ingin memiliki kontrol yang lebih terperinci atas model untuk tugas tertentu, atau perlu menyesuaikan proses pelatihan model. Misalnya, model khusus sesuai dalam situasi berikut:
+ Pengkodean fitur untuk fitur teks dari model teks yang sangat besar perlu dijalankan pada GPU.
+ Anda ingin menggunakan model Graph Neural Network (GNN) kustom Anda sendiri yang dikembangkan di Deep Graph Library (DGL).
+ Anda ingin menggunakan model tabel atau model ansambel untuk klasifikasi dan regresi simpul.
## Alur kerja untuk mengembangkan dan menggunakan model kustom di Neptunus ML
Dukungan model khusus di Neptunus ML dirancang untuk diintegrasikan dengan mulus ke dalam alur kerja Neptunus ML yang ada. Ia bekerja dengan menjalankan kode kustom dalam modul sumber Anda pada infrastruktur Neptunus ML untuk melatih model. Sama seperti halnya untuk mode bawaan, Neptunus MLsecara otomatis meluncurkan SageMaker pekerjaan penyetelan HyperParameter AI dan memilih model terbaik sesuai dengan metrik evaluasi. Kemudian menggunakan implementasi yang disediakan dalam modul sumber Anda untuk menghasilkan artefak model untuk penerapan.
Ekspor data, konfigurasi pelatihan, dan preprocessing data sama untuk model kustom seperti model bawaan.
Setelah preprocessing data adalah ketika Anda dapat secara iteratif dan interaktif mengembangkan dan menguji implementasi model kustom Anda menggunakan Python. Ketika model Anda siap produksi, Anda dapat mengunggah modul Python yang dihasilkan ke Amazon S3 seperti ini:
```
aws s3 cp --recursive (source path to module) s3://(bucket name)/(destination path for your module)
```
Kemudian, Anda dapat menggunakan [default](machine-learning-overview.md#machine-learning-overview-starting-workflow) normal atau alur kerja data [tambahan](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) untuk menyebarkan model ke produksi, dengan beberapa perbedaan.
Untuk pelatihan model menggunakan model kustom, Anda harus menyediakan objek `customModelTrainingParameters` JSON ke API pelatihan model Neptunus ML untuk memastikan bahwa kode kustom Anda digunakan. Bidang dalam `customModelTrainingParameters` objek adalah sebagai berikut:
+ **`sourceS3DirectoryPath`**— (*Wajib*) Jalur ke lokasi Amazon S3 tempat modul Python yang mengimplementasikan model Anda berada. Ini harus menunjuk ke lokasi Amazon S3 yang valid yang berisi, setidaknya, skrip pelatihan, skrip transformasi, dan file. `model-hpo-configuration.json`
+ **`trainingEntryPointScript`**— (*Opsional*) Nama titik masuk dalam modul skrip Anda yang melakukan pelatihan model dan mengambil hyperparameters sebagai argumen baris perintah, termasuk hyperparameters tetap.
*Default*: `training.py`.
+ **`transformEntryPointScript`**— (*Opsional*) Nama titik masuk dalam modul skrip Anda yang harus dijalankan setelah model terbaik dari pencarian hyperparameter telah diidentifikasi, untuk menghitung artefak model yang diperlukan untuk penerapan model. Itu harus dapat berjalan tanpa argumen baris perintah.
*Default*: `transform.py`.
Contoh:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"modelName": "custom",
"customModelTrainingParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"trainingEntryPointScript": "(your training script entry-point name in the Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
Demikian pula, untuk mengaktifkan transformasi model kustom, Anda harus menyediakan objek `customModelTransformParameters` JSON ke API transformasi model Neptunus ML, dengan nilai bidang yang kompatibel dengan parameter model yang disimpan dari tugas pelatihan. `customModelTransformParameters`Objek berisi bidang-bidang ini:
+ **`sourceS3DirectoryPath`**— (*Wajib*) Jalur ke lokasi Amazon S3 tempat modul Python yang mengimplementasikan model Anda berada. Ini harus menunjuk ke lokasi Amazon S3 yang valid yang berisi, setidaknya, skrip pelatihan, skrip transformasi, dan file. `model-hpo-configuration.json`
+ **`transformEntryPointScript`**— (*Opsional*) Nama titik masuk dalam modul skrip Anda yang harus dijalankan setelah model terbaik dari pencarian hyperparameter telah diidentifikasi, untuk menghitung artefak model yang diperlukan untuk penerapan model. Itu harus dapat berjalan tanpa argumen baris perintah.
*Default*: `transform.py`.
Contoh:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"trainingJobName" : "(name of a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
"customModelTransformParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
# Pengembangan model khusus di Neptunus ML
Cara yang baik untuk memulai pengembangan model kustom adalah dengan mengikuti contoh [toolkit Neptunus ML](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/introduction) untuk menyusun dan menulis modul pelatihan Anda. Toolkit Neptunus ML juga mengimplementasikan komponen model HTML grafik termodulasi di modelzoo yang dapat Anda tumpuk dan gunakan [untuk](https://github.com/awslabs/neptuneml-toolkit/tree/main/src/neptuneml_toolkit/modelzoo) membuat model kustom Anda.
Selain itu, toolkit menyediakan fungsi utilitas yang membantu Anda menghasilkan artefak yang diperlukan selama pelatihan model dan transformasi model. Anda dapat mengimpor paket Python ini dalam implementasi kustom Anda. Setiap fungsi atau modul yang disediakan dalam toolkit juga tersedia di lingkungan pelatihan Neptunus ML.
Jika modul Python Anda memiliki dependensi eksternal tambahan, Anda dapat menyertakan dependensi tambahan ini dengan membuat `requirements.txt` file di direktori modul Anda. Paket yang tercantum dalam `requirements.txt` file kemudian akan diinstal sebelum skrip pelatihan Anda dijalankan.
Minimal, modul Python yang mengimplementasikan model kustom Anda harus berisi yang berikut:
+ Titik masuk skrip pelatihan
+ Titik masuk skrip transformasi
+ Sebuah `model-hpo-configuration.json` file
## Pengembangan skrip pelatihan model khusus di Neptunus ML
Skrip pelatihan model kustom Anda harus berupa skrip Python yang dapat dieksekusi seperti contoh toolkit Neptunus ML. [https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py) Itu harus menerima nama dan nilai hyperparameter sebagai argumen baris perintah. Selama pelatihan model, nama hyperparameter diperoleh dari `model-hpo-configuration.json` file. Nilai hyperparameter termasuk dalam rentang hyperparameter yang valid jika hyperparameter dapat disetel, atau mengambil nilai hyperparameter default jika tidak dapat disetel.
Skrip pelatihan Anda dijalankan pada instance pelatihan SageMaker AI menggunakan sintaks seperti ini:
```
python3 (script entry point) --(1st parameter) (1st value) --(2nd parameter) (2nd value) (...)
```
Untuk semua tugas, Neptunus AutoTrainer ML mengirimkan beberapa parameter yang diperlukan ke skrip pelatihan Anda selain hiperparameter yang Anda tentukan, dan skrip Anda harus dapat menangani parameter tambahan ini agar berfungsi dengan baik.
Parameter tambahan yang diperlukan ini agak berbeda menurut tugas:
**Untuk klasifikasi simpul atau regresi simpul**
+ **`task`**— Jenis tugas yang digunakan secara internal oleh Neptunus ML. Untuk klasifikasi node ini`node_class`, dan untuk regresi simpul itu. `node_regression`
+ **`model`**— Nama model yang digunakan secara internal oleh Neptunus ML, yang `custom` dalam hal ini.
+ **`name`**— Nama tugas yang digunakan secara internal oleh Neptunus ML, yang `node_class-custom` untuk klasifikasi simpul dalam kasus ini, dan untuk regresi simpul. `node_regression-custom`
+ **`target_ntype`**— Nama tipe node untuk klasifikasi atau regresi.
+ **`property`**— Nama properti node untuk klasifikasi atau regresi.
**Untuk prediksi tautan**
+ **`task`**— Jenis tugas yang digunakan secara internal oleh Neptunus ML. Untuk prediksi tautan, ini`link_predict`.
+ **`model`**— Nama model yang digunakan secara internal oleh Neptunus ML, yang `custom` dalam hal ini.
+ **`name`**— Nama tugas yang digunakan secara internal oleh Neptunus ML, yang `link_predict-custom` dalam kasus ini.
**Untuk klasifikasi tepi atau regresi tepi**
+ **`task`**— Jenis tugas yang digunakan secara internal oleh Neptunus ML. Untuk klasifikasi tepi ini`edge_class`, dan untuk regresi tepi memang demikian. `edge_regression`
+ **`model`**— Nama model yang digunakan secara internal oleh Neptunus ML, yang `custom` dalam hal ini.
+ **`name`**— Nama tugas yang digunakan secara internal oleh Neptunus ML, yang `edge_class-custom` untuk klasifikasi tepi dalam kasus ini, `edge_regression-custom` dan untuk regresi tepi.
+ **`target_etype`**— Nama tipe tepi untuk klasifikasi atau regresi.
+ **`property`**— Nama properti tepi untuk klasifikasi atau regresi.
Script Anda harus menyimpan parameter model, serta artefak lain yang akan diperlukan untuk pada akhir pelatihan.
Anda dapat menggunakan fungsi utilitas toolkit Neptunus ML untuk menentukan lokasi data grafik yang diproses, lokasi di mana parameter model harus disimpan, dan perangkat GPU apa yang tersedia pada instance pelatihan. Lihat contoh skrip pelatihan [train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py) untuk contoh cara menggunakan fungsi utilitas ini.
## Model kustom mengubah pengembangan skrip di Neptunus ML
Skrip transformasi diperlukan untuk memanfaatkan alur kerja [inkremental Neptunus ML](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) untuk inferensi model pada grafik yang berkembang tanpa melatih ulang model. Bahkan jika semua artefak yang diperlukan untuk penerapan model dihasilkan oleh skrip pelatihan, Anda masih perlu menyediakan skrip transformasi jika Anda ingin menghasilkan model yang diperbarui tanpa melatih ulang model.
**catatan**
[Inferensi induktif waktu nyata](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) saat ini tidak didukung untuk model khusus.
[Skrip transformasi model kustom Anda harus berupa skrip Python yang dapat dieksekusi seperti skrip contoh transform.py toolkit Neptunus MLkit.](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) Karena skrip ini dipanggil selama pelatihan model tanpa argumen baris perintah, argumen baris perintah apa pun yang diterima skrip harus memiliki default.
Skrip berjalan pada instance pelatihan SageMaker AI dengan sintaks seperti ini:
```
python3 (your transform script entry point)
```
Skrip transformasi Anda akan membutuhkan berbagai informasi, seperti:
+ Lokasi data grafik yang diproses.
+ Lokasi di mana parameter model disimpan dan di mana artefak model baru harus disimpan.
+ Perangkat yang tersedia pada instance.
+ Hyperparameter yang menghasilkan model terbaik.
Input ini diperoleh dengan menggunakan fungsi utilitas Neptunus ML yang dapat dipanggil skrip Anda. Lihat contoh skrip [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) toolkit untuk contoh cara melakukannya.
Skrip harus menyimpan penyematan simpul, pemetaan ID simpul, dan artefak lain yang diperlukan untuk penerapan model untuk setiap tugas. Lihat [dokumentasi artefak model](machine-learning-model-artifacts.md) untuk informasi lebih lanjut tentang artefak model yang diperlukan untuk tugas ML Neptunus yang berbeda.
## `model-hpo-configuration.json`File kustom di Neptunus ML
`model-hpo-configuration.json`File mendefinisikan hyperparameters untuk model kustom Anda. Ini dalam [format](machine-learning-customizing-hyperparams.md) yang sama dengan `model-hpo-configuration.json` file yang digunakan dengan model bawaan Neptunus ML, dan lebih diutamakan daripada versi yang dibuat secara otomatis oleh Neptunus ML dan diunggah ke lokasi data yang Anda proses.
Ketika Anda menambahkan hyperparameter baru ke model Anda, Anda juga harus menambahkan entri untuk hyperparameter dalam file ini sehingga hyperparameter diteruskan ke skrip pelatihan Anda.
Anda harus menyediakan rentang untuk hyperparameter jika Anda ingin dapat disetel, dan mengaturnya sebagai, `tier-1``tier-2`, atau `tier-3` param. Hyperparameter akan disetel jika jumlah total pekerjaan pelatihan yang dikonfigurasi memungkinkan untuk menyetel hiperparameter di tingkatnya. Untuk parameter yang tidak dapat disetel, Anda harus memberikan nilai default dan menambahkan hyperparameter ke `fixed-param` bagian file. Lihat contoh [`model-hpo-configuration.json`file contoh](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/model-hpo-configuration.json) toolkit untuk contoh cara melakukannya.
Anda juga harus memberikan definisi metrik yang akan digunakan pekerjaan HyperParameter Optimasi SageMaker AI untuk mengevaluasi model kandidat yang dilatih. Untuk melakukan ini, Anda menambahkan objek `eval_metric` JSON ke `model-hpo-configuration.json` file seperti ini:
```
"eval_metric": {
"tuning_objective": {
"MetricName": "(metric_name)",
"Type": "Maximize"
},
"metric_definitions": [
{
"Name": "(metric_name)",
"Regex": "(metric regular expression)"
}
]
},
```
`metric_definitions`Array dalam `eval_metric` objek mencantumkan objek definisi metrik untuk setiap metrik yang Anda ingin SageMaker AI ekstrak dari instance pelatihan. Setiap objek definisi metrik memiliki `Name` kunci yang memungkinkan Anda memberikan nama untuk metrik (seperti “akurasi”, “f1", dan seterusnya) `Regex` Kunci ini memungkinkan Anda memberikan string ekspresi reguler yang cocok dengan cara metrik tertentu dicetak dalam log pelatihan. Lihat [halaman SageMaker AI HyperParameter Tuning](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-metrics.html) untuk detail selengkapnya tentang cara menentukan metrik.
`tuning_objective`Objek `eval_metric` kemudian memungkinkan Anda untuk menentukan metrik mana yang `metric_definitions` harus digunakan sebagai metrik evaluasi yang berfungsi sebagai metrik objektif untuk optimasi hyperparameter. Nilai untuk `MetricName` harus sesuai dengan nilai a `Name` dalam salah satu definisi di`metric_definitions`. Nilai untuk `Type` harus berupa “Maksimalkan” atau “Minimalkan” tergantung pada apakah metrik harus ditafsirkan sebagai greater-is-better (seperti “akurasi”) atau less-is-better (seperti "mean-squared-error”.
Kesalahan di bagian `model-hpo-configuration.json` file ini dapat mengakibatkan kegagalan pekerjaan API pelatihan model Neptunus ML, karena SageMaker pekerjaan Tuning HyperParameter AI tidak akan dapat memilih model terbaik.
## Pengujian lokal implementasi model kustom Anda di Neptunus ML
Anda dapat menggunakan lingkungan Conda toolkit Neptunus ML untuk menjalankan kode Anda secara lokal untuk menguji dan memvalidasi model Anda. Jika Anda mengembangkan instance Notebook Neptunus, maka lingkungan Conda ini akan diinstal sebelumnya pada instance Notebook Neptunus. Jika Anda mengembangkan pada instance yang berbeda, maka Anda harus mengikuti [instruksi penyiapan lokal](https://github.com/awslabs/neptuneml-toolkit#local-installation) di toolkit Neptunus ML.
Lingkungan Conda secara akurat mereproduksi lingkungan tempat model Anda akan berjalan saat Anda memanggil API [pelatihan model](machine-learning-api-modeltraining.md). Semua contoh skrip pelatihan dan skrip transformasi memungkinkan Anda untuk meneruskan `--local` flag baris perintah untuk menjalankan skrip di lingkungan lokal agar mudah debugging. Ini adalah praktik yang baik saat mengembangkan model Anda sendiri karena memungkinkan Anda untuk menguji implementasi model Anda secara interaktif dan berulang. Selama pelatihan model di lingkungan pelatihan produksi Neptunus ML, parameter ini dihilangkan.
# Membuat titik akhir inferensi untuk kueri
Titik akhir inferensi memungkinkan Anda mengkueri satu model tertentu yang dibangun oleh proses pelatihan model. Titik akhir menempel pada model dengan performa terbaik dari jenis yang diberikan yang dihasilkan proses pelatihan. Endpoint ini kemudian dapat menerima kueri Gremlin dari Neptune dan mengembalikan prediksi model tersebut untuk input dalam kueri. Setelah Anda membuat titik akhir inferensi, itu tetap aktif sampai Anda menghapusnya.
## Mengelola endpoint inferensi untuk Neptune ML
Setelah Anda menyelesaikan pelatihan model pada data yang Anda ekspor dari Neptune, Anda dapat membuat titik akhir inferensi menggunakan perintah `curl` (atau `awscurl`) seperti berikut:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTrainingJobId": "(the model-training job-id of a completed job)"
}'
```
Anda juga dapat membuat titik akhir inferensi dari model yang dibuat oleh pekerjaan transformasi model yang telah selesai, dengan cara yang hampir sama:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTransformJobId": "(the model-transform job-id of a completed job)"
}'
```
Rincian tentang cara menggunakan perintah ini dijelaskan dalam[Perintah titik akhir](machine-learning-api-endpoints.md), bersama dengan informasi tentang cara mendapatkan status titik akhir, cara menghapus titik akhir, dan cara membuat daftar semua titik akhir inferensi.
# Kueri inferensi di Neptunus ML
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
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
## `Neptune#ml.deterministic`
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`
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`
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`
`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
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`
`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`
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`
`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`
`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`
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`
`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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Predikat berikut digunakan dengan inferensi SPARQL:
## `neptune-ml:timeout`predikat
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
`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
`neptune-ml:outputScore`Predikat adalah angka positif yang mewakili kemungkinan bahwa output dari model pembelajaran mesin benar.
## `neptune-ml:modelType`predikat
`neptune-ml:modelType`Predikat menentukan jenis model pembelajaran mesin yang dilatih:
+ `OBJECT_CLASSIFICATION`
+ `OBJECT_REGRESSION`
+ `OBJECT_PREDICTION`
+ `SUBJECT_PREDICTION`
## `neptune-ml:input`predikat
`neptune-ml:input`Predikat mengacu pada daftar yang URIs digunakan sebagai input untuk Neptunus ML.
## `neptune-ml:output`predikat
`neptune-ml:output`Predikat mengacu pada daftar set pengikatan di mana Neptunus ML mengembalikan hasil.
## `neptune-ml:predicate`predikat
`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
`neptune-ml:batchSize`Menentukan ukuran input untuk panggilan layanan jarak jauh.
# Contoh klasifikasi objek SPARQL
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 ;
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 ;
neptune-ml:output ?output .
}
}
```
# Contoh regresi objek SPARQL
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 ;
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 ;
neptune-ml:output ?output .
}
}
```
# Contoh prediksi objek SPARQL
*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 ?m .
?m a .
## 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 ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
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 ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
# Contoh prediksi subjek SPARQL
*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 ;
neptune-ml:output ?output ;
neptune-ml:outputClass ; }
}
```
# Daftar pengecualian untuk kueri inferensi Neptunus ML SPARQL
****
+ **`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)`.
# Referensi API manajemen Neptune ML
**Contents**
+ [Perintah pemrosesandata](machine-learning-api-dataprocessing.md)
+ [Membuat tugas pemrosesan data](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-create-job)
+ [Dapatkan status tugas](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-get-job-status)
+ [Menghentikan tugas](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-stop-job)
+ [Membuat daftar tugas](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-list-jobs)
+ [Perintah modeltraining](machine-learning-api-modeltraining.md)
+ [Membuat tugas pelatihan model](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job)
+ [Dapatkan status tugas](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-get-job-status)
+ [Menghentikan tugas](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-stop-job)
+ [Membuat daftar tugas](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-list-jobs)
+ [Perintah modeltransform](machine-learning-api-modeltransform.md)
+ [Buat pekerjaan transformasi model](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-create-job)
+ [Dapatkan status tugas](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-get-job-status)
+ [Menghentikan tugas](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-stop-job)
+ [Membuat daftar tugas](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-list-jobs)
+ [Perintah titik akhir](machine-learning-api-endpoints.md)
+ [Buat titik akhir inferensi](machine-learning-api-endpoints.md#machine-learning-api-endpoints-create-job)
+ [Dapatkan status titik akhir](machine-learning-api-endpoints.md#machine-learning-api-endpoints-get-endpoint-status)
+ [Hapus titik akhir](machine-learning-api-endpoints.md#machine-learning-api-endpoints-delete-endpoint)
+ [Membuat daftar titik akhir inferensi](machine-learning-api-endpoints.md#machine-learning-api-endpoints-list-endpoints)
+ [Pengecualian](machine-learning-api-exceptions.md)
# Pemrosesan data menggunakan perintah `dataprocessing`
Anda menggunakan perintah `dataprocessing` Neptune ML untuk membuat tugas pemrosesan data, memeriksa statusnya, menghentikannya, atau membuat daftar semua tugas pemrosesan data aktif.
## Membuat tugas pemrosesan data menggunakan perintah `dataprocessing` Neptune ML
Perintah Neptunus `dataprocessing` ML yang khas untuk membuat pekerjaan baru terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{
"inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for the new job)",
"processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)"
}'
```
Perintah untuk memulai pemrosesan ulang inkremental terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/dataprocessing \
-H 'Content-Type: application/json' \
-d '{
"inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)",
"id" : "(a job ID for this job)",
"processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)"
"previousDataProcessingJobId" : "(the job ID of a previously completed job to update)"
}'
```
**Parameter untuk pembuatan pekerjaan `dataprocessing`**
+ **`id`** – (*Opsional*) Pengidentifikasi unik untuk job baru.
*Tipe*: string. *Default*: UUID yang dihasilkan secara otomatis.
+ **`previousDataProcessingJobId`**— (*Opsional*) ID pekerjaan dari pekerjaan pemrosesan data yang telah selesai dijalankan pada versi data sebelumnya.
*Tipe*: string. *Default*: *tidak ada*.
*Catatan*: Gunakan ini untuk pemrosesan data tambahan, untuk memperbarui model ketika data grafik telah berubah (tetapi tidak ketika data telah dihapus).
+ **`inputDataS3Location`**— (*Wajib*) URI lokasi Amazon S3 tempat Anda ingin SageMaker AI mengunduh data yang diperlukan untuk menjalankan pekerjaan pemrosesan data.
*Tipe*: string.
+ **`processedDataS3Location`**— (*Wajib*) URI lokasi Amazon S3 tempat Anda ingin SageMaker AI menyimpan hasil pekerjaan pemrosesan data.
*Tipe*: string.
+ **`sagemakerIamRoleArn`**— (*Opsional*) ARN dari peran IAM untuk SageMaker eksekusi AI.
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`neptuneIamRoleArn`**— (*Opsional*) Nama Sumber Daya Amazon (ARN) dari peran IAM yang dapat diasumsikan SageMaker AI untuk melakukan tugas atas nama Anda.
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`processingInstanceType`**— (*Opsional*) Jenis instans ML yang digunakan selama pemrosesan data. Memorinya harus cukup besar untuk menahan set data yang diproses.
*Tipe*: string. *Default*: `ml.r5` tipe terkecil yang memorinya sepuluh kali lebih besar dari ukuran data grafik yang diekspor pada disk.
*Catatan*: Neptunus ML dapat memilih jenis instans secara otomatis. Lihat [Memilih instance untuk pemrosesan data](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size).
+ **`processingInstanceVolumeSizeInGB`** – (*Opsional*) Ukuran volume disk dari instans pemrosesan. Data input dan data yang diproses disimpan pada disk, sehingga ukuran volume harus cukup besar untuk menahan kedua set data.
*Tipe*: integer. *Default*: `0`.
*Catatan*: Jika tidak ditentukan atau 0, Neptunus ML memilih ukuran volume secara otomatis berdasarkan ukuran data.
+ **`processingTimeOutInSeconds`** – (*Opsional*) Timeout dalam hitungan detik untuk tugas pemrosesan data.
*Tipe*: integer. *Default*: `86,400` (1 hari).
+ **`modelType`**— (*Opsional*) Salah satu dari dua jenis model yang saat ini didukung Neptunus ML: model grafik heterogen `heterogeneous` (), dan grafik pengetahuan (). `kge`
*Tipe*: string. *Default*: *tidak ada*.
*Catatan*: Jika tidak ditentukan, Neptunus ML memilih jenis model secara otomatis berdasarkan data.
+ **`configFileName`** – (*Opsional*) File spesifikasi data yang menjelaskan cara memuat data grafik yang diekspor untuk pelatihan. File secara otomatis dihasilkan oleh kit alat ekspor Neptune.
*Tipe*: string. *Default*: `training-data-configuration.json`.
+ **`subnets`**— (*Opsional*) Subnet di VPC Neptunus. IDs
*Tipe*: daftar string. *Default*: *tidak ada*.
+ **`securityGroupIds`**— (*Opsional*) Grup keamanan VPC. IDs
*Tipe*: daftar string. *Default*: *tidak ada*.
+ **`volumeEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi data pada volume penyimpanan yang dilampirkan ke instance komputasi ML yang menjalankan tugas pemrosesan.
*Tipe*: string. *Default*: *tidak ada*.
+ **`enableInterContainerTrafficEncryption`**— (*Opsional*) Aktifkan atau nonaktifkan enkripsi lalu lintas antar-kontainer dalam pelatihan atau pekerjaan penyetelan hiper-parameter.
*Jenis*: boolean. *Default*: *Benar*.
**catatan**
`enableInterContainerTrafficEncryption`Parameter ini hanya tersedia dalam [rilis mesin 1.2.0.2.R3](engine-releases-1.2.0.2.R3.md).
+ **`s3OutputEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi output dari pekerjaan pelatihan.
*Tipe*: string. *Default*: *tidak ada*.
## Mendapatkan status job pemrosesan data menggunakan perintah `dataprocessing` Neptune ML
Perintah `dataprocessing` Neptune ML sampel untuk status tugas terlihat seperti ini:
```
curl -s \
"https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)" \
| python -m json.tool
```
**Parameter untuk status tugas `dataprocessing`**
+ **`id`** – (*Wajib*) Pengenal unik tugas pemrosesan data.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
## Menghentikan tugas pemrosesan data menggunakan perintah `dataprocessing` Neptune ML
Perintah `dataprocessing` Neptune ML sampel untuk menghentikan tugas terlihat seperti ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)"
```
Atau ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)?clean=true"
```
**Parameter untuk tugas berhenti `dataprocessing`**
+ **`id`** – (*Wajib*) Pengenal unik tugas pemrosesan data.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`clean`** – (*Opsional*) Bendera ini menetapkan bahwa semua artefak Amazon S3 harus dihapus ketika tugas dihentikan.
*Tipe*: Boolean. *Default*: `FALSE`.
## Membuat daftar tugas pemrosesan data aktif menggunakan perintah `dataprocessing`Neptune ML
Perintah `dataprocessing` Neptune ML sampel untuk membuat daftar tugas aktif terlihat seperti ini:
```
curl -s "https://(your Neptune endpoint)/ml/dataprocessing"
```
Atau ini:
```
curl -s "https://(your Neptune endpoint)/ml/dataprocessing?maxItems=3"
```
**Parameter untuk tugas daftar `dataprocessing`**
+ **`maxItems`** – (*Opsional*) Jumlah maksimum item yang akan dikembalikan.
*Tipe*: integer. *Default*: `10`. *Nilai maksimum yang diperbolehkan*: `1024`.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
# Pelatihan model menggunakan perintah `modeltraining`
Anda menggunakan perintah `modeltraining` Neptune ML untuk membuat tugas pelatihan model, memeriksa statusnya, menghentikannya, atau membuat daftar semua tugas pelatihan model aktif.
## Membuat tugas pelatihan model menggunakan perintah `modeltraining` Neptune ML
Perintah Neptunus `modeltraining` Neptunus untuk membuat pekerjaan yang sama sekali baru terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
}'
```
Perintah Neptunus `modeltraining` Neptunus untuk membuat pekerjaan pembaruan untuk pelatihan model tambahan terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"previousModelTrainingJobId" : "(the job ID of a completed model-training job to update)",
}'
```
Perintah Neptunus `modeltraining` Neptunus untuk membuat pekerjaan baru dengan implementasi model kustom yang disediakan pengguna terlihat seperti:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltraining
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"dataProcessingJobId" : "(the data-processing job-id of a completed job)",
"trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer"
"modelName": "custom",
"customModelTrainingParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"trainingEntryPointScript": "(your training script entry-point name in the Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
**Parameter untuk pembuatan pekerjaan `modeltraining`**
+ **`id`** – (*Opsional*) Pengidentifikasi unik untuk job baru.
*Tipe*: string. *Default*: UUID yang dihasilkan secara otomatis.
+ **`dataProcessingJobId`** – (*Wajib*) Tugas ID dari tugas pemrosesan data yang telah selesai yang telah membuat data yang akan dikerjakan oleh pelatihan.
*Tipe*: string.
+ **`trainModelS3Location`** – (*Wajib*) Lokasi di Amazon S3 di mana artefak model akan disimpan.
*Tipe*: string.
+ **`previousModelTrainingJobId`**— (*Opsional*) ID pekerjaan dari pekerjaan pelatihan model selesai yang ingin Anda perbarui secara bertahap berdasarkan data yang diperbarui.
*Tipe*: string. *Default*: *tidak ada*.
+ **`sagemakerIamRoleArn`**— (*Opsional*) ARN dari peran IAM untuk SageMaker eksekusi AI.
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`modelName`** – (*Opsional*) Jenis model untuk pelatihan. Secara default model ML secara otomatis didasarkan pada `modelType` yang digunakan dalam pemrosesan data, tetapi Anda dapat menentukan jenis model yang berbeda di sini.
*Tipe*: string. *Default*: `rgcn` untuk grafik heterogen dan `kge` untuk grafik pengetahuan. *Nilai yang valid*: Untuk grafik heterogen: `rgcn`. Untuk `kge` grafik:`transe`,`distmult`, atau`rotate`. Untuk implementasi model khusus:`custom`.
+ **`baseProcessingInstanceType`**— (*Opsional*) Jenis instance ML yang digunakan dalam mempersiapkan dan mengelola pelatihan model ML.
*Tipe*: string. *Catatan*: Ini adalah instance CPU yang dipilih berdasarkan persyaratan memori untuk memproses data dan model pelatihan. Lihat [Memilih contoh untuk pelatihan model dan transformasi model](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`trainingInstanceType`** – (*Opsional*) Jenis instans ML yang digunakan untuk pelatihan model Semua model Neptune ML mendukung pelatihan CPU, GPU, dan MultiGPU.
*Tipe*: string. *Default*: `ml.p3.2xlarge`.
*Catatan*: Memilih jenis instans yang tepat untuk pelatihan tergantung pada jenis tugas, ukuran grafik, dan anggaran Anda. Lihat [Memilih contoh untuk pelatihan model dan transformasi model](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`trainingInstanceVolumeSizeInGB`** – (*Opsional*) Ukuran volume disk dari instans pelatihan. Input data dan model output disimpan dalam disk, sehingga ukuran volume harus cukup besar untuk menahan kedua set data.
*Tipe*: integer. *Default*: `0`.
*Catatan*: Jika tidak ditentukan atau 0, Neptunus ML memilih ukuran volume disk berdasarkan rekomendasi yang dihasilkan dalam langkah pemrosesan data. Lihat [Memilih contoh untuk pelatihan model dan transformasi model](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`trainingTimeOutInSeconds`** – (*Opsional*) Timeout dalam hitungan detik untuk tugas pelatihan.
*Tipe*: integer. *Default*: `86,400` (1 hari).
+ **`maxHPONumberOfTrainingJobs`** – Jumlah total maksimum dari tugas pelatihan untuk memulai tugas penyetelan hyperparameter.
*Tipe*: integer. *Default*: `2`.
*Catatan*: Neptunus ML secara otomatis menyetel parameter hiper model pembelajaran mesin. Untuk mendapatkan model yang berkinerja baik, gunakan setidaknya 10 pekerjaan (dengan kata lain, atur `maxHPONumberOfTrainingJobs` ke 10). Secara umum, semakin banyak tuning berjalan, semakin baik hasilnya.
+ **`maxHPOParallelTrainingJobs`** – Jumlah maksimum dari tugas pelatihan untuk memulai tugas penyetelan hyperparameter.
*Tipe*: integer. *Default*: `2`.
*Catatan*: Jumlah pekerjaan paralel yang dapat Anda jalankan dibatasi oleh sumber daya yang tersedia pada instans pelatihan Anda.
+ **`subnets`**— (*Opsional*) Subnet di VPC Neptunus. IDs
*Tipe*: daftar string. *Default*: *tidak ada*.
+ **`securityGroupIds`**— (*Opsional*) Grup keamanan VPC. IDs
*Tipe*: daftar string. *Default*: *tidak ada*.
+ **`volumeEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi data pada volume penyimpanan yang dilampirkan ke instance komputasi ML yang menjalankan tugas pelatihan.
*Tipe*: string. *Default*: *tidak ada*.
+ **`s3OutputEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi output dari pekerjaan pemrosesan.
*Tipe*: string. *Default*: *tidak ada*.
+ **`enableInterContainerTrafficEncryption`**— (*Opsional*) Aktifkan atau nonaktifkan enkripsi lalu lintas antar-kontainer dalam pelatihan atau pekerjaan penyetelan hiper-parameter.
*Jenis*: boolean. *Default*: *Benar*.
**catatan**
`enableInterContainerTrafficEncryption`Parameter ini hanya tersedia dalam [rilis mesin 1.2.0.2.R3](engine-releases-1.2.0.2.R3.md).
+ **`enableManagedSpotTraining`**— (*Opsional*) Mengoptimalkan biaya pelatihan model machine learning dengan menggunakan instans spot Amazon Elastic Compute Cloud. Untuk informasi selengkapnya, lihat [Pelatihan Spot Terkelola di Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html).
*Tipe*: Boolean. *Default*: *Salah*.
+ **`customModelTrainingParameters`**— (*Opsional*) Konfigurasi untuk pelatihan model kustom. Ini adalah objek JSON dengan bidang-bidang berikut:
+ **`sourceS3DirectoryPath`**— (*Wajib*) Jalur ke lokasi Amazon S3 tempat modul Python yang mengimplementasikan model Anda berada. Ini harus menunjuk ke lokasi Amazon S3 yang valid yang berisi, setidaknya, skrip pelatihan, skrip transformasi, dan file. `model-hpo-configuration.json`
+ **`trainingEntryPointScript`**— (*Opsional*) Nama titik masuk dalam modul skrip Anda yang melakukan pelatihan model dan mengambil hyperparameters sebagai argumen baris perintah, termasuk hyperparameters tetap.
*Default*: `training.py`.
+ **`transformEntryPointScript`**— (*Opsional*) Nama titik masuk dalam modul skrip Anda yang harus dijalankan setelah model terbaik dari pencarian hyperparameter telah diidentifikasi, untuk menghitung artefak model yang diperlukan untuk penerapan model. Itu harus dapat berjalan tanpa argumen baris perintah.
*Default*: `transform.py`.
+ **`maxWaitTime`**— (*Opsional*) Waktu maksimum untuk menunggu, dalam hitungan detik, saat melakukan pelatihan model menggunakan instance spot. Harus lebih besar dari`trainingTimeOutInSeconds`.
*Tipe*: integer.
## Mendapatkan status tugas pelatihan model menggunakan perintah `modeltraining` Neptune ML
Perintah `modeltraining` Neptune ML sampel untuk status tugas terlihat seperti ini:
```
curl -s \
"https://(your Neptune endpoint)/ml/modeltraining/(the job ID)" \
| python -m json.tool
```
**Parameter untuk status tugas `modeltraining`**
+ **`id`** – (*Wajib*) Pengenal unik tugas pelatihan model.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
## Menghentikan tugas pelatihan model menggunakan perintah `modeltraining` Neptune ML
Perintah `modeltraining` Neptune ML sampel untuk menghentikan tugas terlihat seperti ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)"
```
Atau ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)?clean=true"
```
**Parameter untuk tugas berhenti `modeltraining`**
+ **`id`** – (*Wajib*) Pengenal unik tugas pelatihan model.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`clean`** – (*Opsional*) Bendera ini menetapkan bahwa semua artefak Amazon S3 harus dihapus ketika tugas dihentikan.
*Tipe*: Boolean. *Default*: `FALSE`.
## Mendaftar tugas pelatihan model aktif menggunakan perintah `modeltraining` Neptune ML
Perintah `modeltraining` Neptune ML sampel untuk membuat daftar tugas aktif terlihat seperti ini:
```
curl -s "https://(your Neptune endpoint)/ml/modeltraining" | python -m json.tool
```
Atau ini:
```
curl -s "https://(your Neptune endpoint)/ml/modeltraining?maxItems=3" | python -m json.tool
```
**Parameter untuk tugas daftar `modeltraining`**
+ **`maxItems`** – (*Opsional*) Jumlah maksimum item yang akan dikembalikan.
*Tipe*: integer. *Default*: `10`. *Nilai maksimum yang diperbolehkan*: `1024`.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
# Transformasi model menggunakan `modeltransform` perintah
Anda menggunakan perintah Neptunus `modeltransform` ML untuk membuat pekerjaan transformasi model, memeriksa statusnya, menghentikannya, atau mencantumkan semua pekerjaan transformasi model yang aktif.
## Membuat pekerjaan transformasi model menggunakan perintah Neptunus ML `modeltransform`
Perintah Neptunus `modeltransform` Neptunus untuk membuat pekerjaan transformasi inkremental, tanpa pelatihan ulang model, terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-transform job ID)",
"dataProcessingJobId" : "(the job-id of a completed data-processing job)",
"mlModelTrainingJobId" : "(the job-id of a completed model-training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform"
}'
```
Perintah Neptunus `modeltransform` ML untuk membuat pekerjaan dari pekerjaan pelatihan AI yang SageMaker telah selesai terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-transform job ID)",
"trainingJobName" : "(name of a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform",
"baseProcessingInstanceType" : ""
}'
```
Perintah Neptunus `modeltransform` Neptunus untuk membuat pekerjaan yang menggunakan implementasi model kustom terlihat seperti:
```
curl \
-X POST https://(your Neptune endpoint)/ml/modeltransform
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique model-training job ID)",
"trainingJobName" : "(name of a completed SageMaker AI training job)",
"modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/"
"customModelTransformParameters" : {
"sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)",
"transformEntryPointScript": "(your transform script entry-point name in the Python module)"
}
}'
```
**Parameter untuk pembuatan pekerjaan `modeltransform`**
+ **`id`** – (*Opsional*) Pengidentifikasi unik untuk job baru.
*Tipe*: string. *Default*: UUID yang dihasilkan secara otomatis.
+ **`dataProcessingJobId`**— Id pekerjaan dari pekerjaan pemrosesan data yang diselesaikan.
*Tipe*: string.
*Catatan*: Anda harus menyertakan keduanya `dataProcessingJobId` dan`mlModelTrainingJobId`, atau`trainingJobName`.
+ **`mlModelTrainingJobId`**— Id pekerjaan dari pekerjaan pelatihan model yang diselesaikan.
*Tipe*: string.
*Catatan*: Anda harus menyertakan keduanya `dataProcessingJobId` dan`mlModelTrainingJobId`, atau`trainingJobName`.
+ **`trainingJobName`**— Nama pekerjaan pelatihan SageMaker AI yang telah selesai.
*Tipe*: string.
*Catatan*: Anda harus menyertakan parameter `dataProcessingJobId` dan `mlModelTrainingJobId` parameter, atau `trainingJobName` parameternya.
+ **`sagemakerIamRoleArn`**— (*Opsional*) ARN dari peran IAM untuk SageMaker eksekusi AI.
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`customModelTransformParameters `**— (*Opsional*) Informasi konfigurasi untuk transformasi model menggunakan model kustom. `customModelTransformParameters`Objek berisi bidang berikut, yang harus memiliki nilai yang kompatibel dengan parameter model yang disimpan dari pekerjaan pelatihan:
+ **`sourceS3DirectoryPath`**— (*Wajib*) Jalur ke lokasi Amazon S3 tempat modul Python yang mengimplementasikan model Anda berada. Ini harus menunjuk ke lokasi Amazon S3 yang valid yang berisi, setidaknya, skrip pelatihan, skrip transformasi, dan file. `model-hpo-configuration.json`
+ **`transformEntryPointScript`**— (*Opsional*) Nama titik masuk dalam modul skrip Anda yang harus dijalankan setelah model terbaik dari pencarian hyperparameter telah diidentifikasi, untuk menghitung artefak model yang diperlukan untuk penerapan model. Itu harus dapat berjalan tanpa argumen baris perintah.
*Default*: `transform.py`.
+ **`baseProcessingInstanceType`**— (*Opsional*) Jenis instance ML yang digunakan dalam mempersiapkan dan mengelola pelatihan model ML.
*Tipe*: string. *Catatan*: Ini adalah instance CPU yang dipilih berdasarkan persyaratan memori untuk memproses data dan model transformasi. Lihat [Memilih contoh untuk pelatihan model dan transformasi model](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`baseProcessingInstanceVolumeSizeInGB`** – (*Opsional*) Ukuran volume disk dari instans pelatihan. Input data dan model output disimpan dalam disk, sehingga ukuran volume harus cukup besar untuk menahan kedua set data.
*Tipe*: integer. *Default*: `0`.
*Catatan*: Jika tidak ditentukan atau 0, Neptunus ML memilih ukuran volume disk berdasarkan rekomendasi yang dihasilkan dalam langkah pemrosesan data. Lihat [Memilih contoh untuk pelatihan model dan transformasi model](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size).
+ **`subnets`**— (*Opsional*) Subnet di VPC Neptunus. IDs
*Tipe*: daftar string. *Default*: *tidak ada*.
+ **`securityGroupIds`**— (*Opsional*) Grup keamanan VPC. IDs
*Tipe*: daftar string. *Default*: *tidak ada*.
+ **`volumeEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi data pada volume penyimpanan yang dilampirkan ke instance komputasi ML yang menjalankan tugas transformasi.
*Tipe*: string. *Default*: *tidak ada*.
+ **`enableInterContainerTrafficEncryption`**— (*Opsional*) Aktifkan atau nonaktifkan enkripsi lalu lintas antar kontainer dalam pelatihan atau pekerjaan penyetelan hiper-parameter.
*Jenis*: boolean. *Default*: *Benar*.
**catatan**
`enableInterContainerTrafficEncryption`Parameter ini hanya tersedia dalam [rilis mesin 1.2.0.2.R3](engine-releases-1.2.0.2.R3.md).
+ **`s3OutputEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi output dari pekerjaan pemrosesan.
*Tipe*: string. *Default*: *tidak ada*.
## Mendapatkan status pekerjaan transformasi model menggunakan perintah Neptunus ML `modeltransform`
Perintah `modeltransform` Neptune ML sampel untuk status tugas terlihat seperti ini:
```
curl -s \
"https://(your Neptune endpoint)/ml/modeltransform/(the job ID)" \
| python -m json.tool
```
**Parameter untuk status tugas `modeltransform`**
+ **`id`**— (*Wajib*) Pengidentifikasi unik dari pekerjaan transformasi model.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
## Menghentikan pekerjaan transformasi model menggunakan perintah Neptunus ML `modeltransform`
Perintah `modeltransform` Neptune ML sampel untuk menghentikan tugas terlihat seperti ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)"
```
Atau ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)?clean=true"
```
**Parameter untuk tugas berhenti `modeltransform`**
+ **`id`**— (*Wajib*) Pengidentifikasi unik dari pekerjaan transformasi model.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
+ **`clean`** – (*Opsional*) Bendera ini menetapkan bahwa semua artefak Amazon S3 harus dihapus ketika tugas dihentikan.
*Tipe*: Boolean. *Default*: `FALSE`.
## Daftar pekerjaan transformasi model aktif menggunakan perintah Neptunus ML `modeltransform`
Perintah `modeltransform` Neptune ML sampel untuk membuat daftar tugas aktif terlihat seperti ini:
```
curl -s "https://(your Neptune endpoint)/ml/modeltransform" | python -m json.tool
```
Atau ini:
```
curl -s "https://(your Neptune endpoint)/ml/modeltransform?maxItems=3" | python -m json.tool
```
**Parameter untuk tugas daftar `modeltransform`**
+ **`maxItems`** – (*Opsional*) Jumlah maksimum item yang akan dikembalikan.
*Tipe*: integer. *Default*: `10`. *Nilai maksimum yang diperbolehkan*: `1024`.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan terjadi.
# Mengelola titik akhir inferensi menggunakan perintah `endpoints`
Anda menggunakan perintah `endpoints` Neptune ML untuk membuat titik akhir inferensi, memeriksa statusnya, menghapus, atau membuat daftar titik akhir inferensi yang ada.
## Pembuatan titik akhir inferensi menggunakan perintah `endpoints` Neptune ML
Perintah Neptunus `endpoints` Neptunus untuk membuat titik akhir inferensi dari model yang dibuat oleh pekerjaan pelatihan terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTrainingJobId": "(the model-training job-id of a completed job)"
}'
```
Perintah Neptunus `endpoints` Neptunus untuk memperbarui titik akhir inferensi yang ada dari model yang dibuat oleh pekerjaan pelatihan terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"update" : "true",
"mlModelTrainingJobId": "(the model-training job-id of a completed job)"
}'
```
Perintah Neptunus `endpoints` Neptunus untuk membuat titik akhir inferensi dari model yang dibuat oleh pekerjaan transformasi model terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"mlModelTransformJobId": "(the model-training job-id of a completed job)"
}'
```
Perintah Neptunus `endpoints` Neptunus untuk memperbarui titik akhir inferensi yang ada dari model yang dibuat oleh pekerjaan transformasi model terlihat seperti ini:
```
curl \
-X POST https://(your Neptune endpoint)/ml/endpoints
-H 'Content-Type: application/json' \
-d '{
"id" : "(a unique ID for the new endpoint)",
"update" : "true",
"mlModelTransformJobId": "(the model-training job-id of a completed job)"
}'
```
**Parameter untuk pembuatan titik akhir inferensi `endpoints`**
+ **`id`** – (*Opsional*) Pengidentifikasi unik untuk titik akhir inferensi baru.
*Tipe*: string. *Default*: Nama berstampel waktu yang otomatis dihasilkan.
+ **`mlModelTrainingJobId`**— Id pekerjaan dari pekerjaan pelatihan model yang telah diselesaikan yang telah menciptakan model yang akan ditunjukkan oleh titik akhir inferensi.
*Tipe*: string.
*Catatan*: Anda harus menyediakan salah satu `mlModelTrainingJobId` atau`mlModelTransformJobId`.
+ **`mlModelTransformJobId`**— Id pekerjaan dari pekerjaan transformasi model yang telah selesai.
*Tipe*: string.
*Catatan*: Anda harus menyediakan salah satu `mlModelTrainingJobId` atau`mlModelTransformJobId`.
+ **`update`**— (*Opsional*) Jika ada, parameter ini menunjukkan bahwa ini adalah permintaan pembaruan.
*Tipe*: Boolean. *Default*: `false`
*Catatan*: Anda harus menyediakan salah satu `mlModelTrainingJobId` atau`mlModelTransformJobId`.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan dilemparkan.
+ **`modelName`** – (*Opsional*) Jenis model untuk latihan. Secara default model ML secara otomatis didasarkan pada `modelType` yang digunakan dalam pemrosesan data, tetapi Anda dapat menentukan jenis model yang berbeda di sini.
*Tipe*: string. *Default*: `rgcn` untuk grafik heterogen dan `kge` untuk grafik pengetahuan. *Nilai yang valid*: Untuk grafik heterogen: `rgcn`. Untuk grafik pengetahuan: `kge`, `transe`, `distmult`, atau `rotate`.
+ **`instanceType`** – (*Opsional*) Jenis instans ML yang digunakan untuk servis online.
*Tipe*: string. *Default*: `ml.m5.xlarge`.
*Catatan*: Memilih instans ML untuk titik akhir inferensi tergantung pada jenis tugas, ukuran grafik, dan anggaran Anda. Lihat [Memilih instance untuk titik akhir inferensi](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size).
+ **`instanceCount`** – (*Opsional*) Jumlah minimum instans Amazon EC2 untuk mendeploy ke titik akhir untuk prediksi.
*Tipe*: integer. *Default*: `1`.
+ **`volumeEncryptionKMSKey`**— (*Opsional*) Kunci AWS Key Management Service (AWS KMS) yang digunakan SageMaker AI untuk mengenkripsi data pada volume penyimpanan yang dilampirkan ke instance komputasi HTML yang menjalankan titik akhir.
*Tipe*: string. *Default*: *tidak ada*.
## Mendapatkan status titik akhir inferensi menggunakan perintah `endpoints` Neptune ML
Perintah `endpoints` Neptune ML sampel untuk status titik akhir instans terlihat seperti ini:
```
curl -s \
"https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)" \
| python -m json.tool
```
**Parameter untuk status titik akhir instans `endpoints`**
+ **`id`** – (*Wajib*) Pengenal unik dari titik akhir inferensi.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan dilemparkan.
## Menghapus titik akhir instans menggunakan perintah `endpoints` Neptune ML
Perintah `endpoints` Neptune ML sampel untuk menghapus titik akhir instans terlihat seperti ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)"
```
Atau ini:
```
curl -s \
-X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)?clean=true"
```
**Parameter untuk `endpoints` menghapus sebuah titik akhir inferensi**
+ **`id`** – (*Wajib*) Pengenal unik dari titik akhir inferensi.
*Tipe*: string.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan dilemparkan.
+ **`clean`**— (*Opsional*) Menunjukkan bahwa semua artefak yang terkait dengan titik akhir ini juga harus dihapus.
*Tipe*: Boolean. *Default*: `FALSE`.
## Membuat daftar titik akhir inferensi menggunakan perintah `endpoints` Neptune ML
Perintah Neptunus Neptunus `endpoints` untuk mencantumkan titik akhir inferensi terlihat seperti ini:
```
curl -s "https://(your Neptune endpoint)/ml/endpoints" \
| python -m json.tool
```
Atau ini:
```
curl -s "https://(your Neptune endpoint)/ml/endpoints?maxItems=3" \
| python -m json.tool
```
**Parameter untuk `dataprocessing` membuat daftar titik akhir inferensi**
+ **`maxItems`** – (*Opsional*) Jumlah maksimum item yang akan dikembalikan.
*Tipe*: integer. *Default*: `10`. *Nilai maksimum yang diperbolehkan*: `1024`.
+ **`neptuneIamRoleArn`**— (*Opsional*) ARN dari peran IAM yang menyediakan akses Neptunus ke sumber daya AI dan Amazon S3. SageMaker
*Tipe*: string. *Catatan*: Ini harus tercantum dalam grup parameter klaster DB Anda atau kesalahan akan dilemparkan.
# Kesalahan dan pengecualian API manajemen Neptunus ML
Semua pengecualian API manajemen Neptunus ML mengembalikan kode HTTP 400. Setelah menerima salah satu pengecualian ini, perintah yang menghasilkan pengecualian tidak boleh dicoba lagi.
****
+ **`MissingParameterException`**— Pesan kesalahan:
`Required credentials are missing. Please add IAM role to the cluster or pass as a parameter to this request.`
+ **`InvalidParameterException`**— Pesan kesalahan:
+ `Invalid ML instance type.`
+ `Invalid ID provided. ID can be 1-48 alphanumeric characters.`
+ `Invalid ID provided. Must contain only letters, digits, or hyphens.`
+ `Invalid ID provided. Please check whether a resource with the given ID exists.`
+ `Another resource with same ID already exists. Please use a new ID.`
+ `Failed to stop the job because it has already completed or failed.`
+ **`BadRequestException`**— Pesan kesalahan:
+ `Invalid S3 URL or incorrect S3 permissions. Please check your S3 configuration.`
+ `Provided ModelTraining job has not completed.`
+ `Provided SageMaker AI Training job has not completed.`
+ `Provided MLDataProcessing job is not completed.`
+ `Provided MLModelTraining job doesn't exist.`
+ `Provided ModelTransformJob doesn't exist.`
+ `Unable to find SageMaker AI resource. Please check your input.`
# Batas Neptune ML
+ Jenis inferensi yang saat ini didukung adalah klasifikasi simpul, regresi simpul, klasifikasi tepi, regresi tepi, dan prediksi tautan (lihat). [Kemampuan Neptune ML](machine-learning.md#machine-learning-capabilities)
+ [Ukuran grafik maksimum yang dapat didukung Neptunus ML tergantung pada jumlah memori dan penyimpanan yang diperlukan [selama persiapan data](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size), pelatihan [model,](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size) dan inferensi.](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size)
+ Ukuran maksimum memori instance pemrosesan data SageMaker AI adalah 768 GB. Akibatnya, tahap pemrosesan data gagal jika membutuhkan memori lebih dari 768 GB.
+ Ukuran maksimum memori instans pelatihan SageMaker AI adalah 732 GB. Akibatnya, tahap pelatihan gagal jika membutuhkan memori lebih dari 732 GB.
+ Ukuran maksimum payload inferensi untuk titik akhir SageMaker AI adalah 6 MiB. Akibatnya, inferensi induktif gagal jika muatan subgraf melebihi ukuran ini.
+ Neptunus ML saat ini hanya tersedia di Wilayah di mana Neptunus dan layanan lain yang bergantung padanya (seperti, Amazon API AWS Lambda Gateway dan Amazon AI) semuanya didukung. SageMaker
Ada perbedaan di Tiongkok (Beijing) dan Tiongkok (Ningxia) yang berkaitan dengan penggunaan default otentikasi IAM, seperti yang [dijelaskan](https://docs.amazonaws.cn/en_us/aws/latest/userguide/api-gateway.html#feature-diff) di sini bersama dengan perbedaan lainnya.
+ Titik akhir inferensi prediksi tautan yang diluncurkan oleh Neptunus ML saat ini hanya dapat memprediksi kemungkinan tautan dengan node yang ada dalam grafik selama pelatihan.
Misalnya, perhatikan grafik dengan `User` dan `Movie` simpul dan `Rated` tepi. Menggunakan model rekomendasi prediksi tautan Neptunus ML yang sesuai, Anda dapat menambahkan pengguna baru ke grafik dan meminta model memprediksi film untuk mereka, tetapi model hanya dapat merekomendasikan film yang ada selama pelatihan model. Meskipun penyematan `User` simpul dihitung secara real-time menggunakan subgraf lokal dan model GNN, dan karena itu dapat berubah seiring waktu saat pengguna menilai film, ini dibandingkan dengan penyematan film statis yang telah dihitung sebelumnya untuk rekomendasi akhir.
+ Model KGE yang didukung oleh Neptunus ML hanya berfungsi untuk tugas prediksi tautan, dan representasi khusus untuk simpul dan tipe tepi yang ada dalam grafik selama pelatihan. Ini berarti bahwa semua simpul dan tipe tepi yang dirujuk dalam kueri inferensi harus ada dalam grafik selama pelatihan. Prediksi untuk tipe tepi atau simpul baru tidak dapat dibuat tanpa melatih ulang model.
## SageMaker Keterbatasan sumber daya AI
Bergantung pada aktivitas dan penggunaan sumber daya dari waktu ke waktu, Anda mungkin menemukan pesan kesalahan yang mengatakan bahwa [Anda telah melebihi kuota](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html) ([ResourceLimitExceeded](https://repost.aws/knowledge-center/sagemaker-resource-limit-exceeded-error)). dan Anda perlu meningkatkan sumber daya SageMaker AI Anda, ikuti langkah-langkah dalam prosedur [Minta kuota layanan untuk SageMaker sumber daya di halaman ini untuk meminta peningkatan kuota](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure) dari Support. AWS
SageMaker Nama sumber daya AI sesuai dengan tahapan Neptunus ML sebagai berikut:
+ SageMaker AI `ProcessingJob` digunakan oleh pemrosesan data Neptunus, pelatihan model, dan pekerjaan transformasi model.
+ SageMaker AI `HyperParameterTuningJob` digunakan oleh pekerjaan pelatihan model Neptunus.
+ SageMaker AI `TrainingJob` digunakan oleh pekerjaan pelatihan model Neptunus.
+ SageMaker AI `Endpoint` digunakan oleh titik akhir inferensi Neptunus.