

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

# Memproses data grafik yang diekspor dari Neptune untuk pelatihan
<a name="machine-learning-on-graphs-processing"></a>

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
<a name="machine-learning-on-graphs-processing-managing"></a>

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
<a name="machine-learning-on-graphs-processing-updated"></a>

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
<a name="machine-learning-feature-encoding"></a>

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
<a name="machine-learning-categorical-features"></a>

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
<a name="machine-learning-numerical-features"></a>

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
<a name="machine-learning-bucket_numerical-features"></a>

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
<a name="machine-learning-text-features"></a>

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
<a name="machine-learning-fasttext-features"></a>

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
<a name="machine-learning-sbert-features"></a>

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
<a name="machine-learning-word2vec-features"></a>

[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
<a name="machine-learning-tfidf-features"></a>

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
<a name="machine-learning-datetime-features"></a>

[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
<a name="machine-learning-auto-encoding"></a>

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
<a name="machine-learning-processing-training-config-file"></a>

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
<a name="machine-learning-processing-training-config-file-example"></a>

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
<a name="machine-learning-processing-training-config-file-structure"></a>

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
<a name="machine-learning-graph-training-config-object"></a>

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
<a name="machine-learning-graph-edges-config"></a>

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
<a name="machine-learning-graph-nodes-config"></a>

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
<a name="machine-learning-graph-node-features-config"></a>

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
<a name="machine-learning-graph-node-labels-config"></a>

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
<a name="machine-learning-custom-stages-splits"></a>

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.