Amazon Fraud Detector tidak lagi terbuka untuk pelanggan baru per 7 November 2025. Untuk kemampuan yang mirip dengan Amazon Fraud Detector, jelajahi Amazon SageMaker AutoGluon,, dan AWS WAF.

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

# Tutorial: Mulai menggunakan AWS SDK untuk Python (Boto3)
<a name="getting-started-python"></a>

Tutorial ini menjelaskan cara membangun dan melatih model Amazon Fraud Detector dan kemudian menggunakan model ini untuk menghasilkan prediksi penipuan real-time menggunakan. AWS SDK untuk Python (Boto3) Model dilatih menggunakan file data contoh pendaftaran akun yang Anda unggah ke bucket Amazon S3.

Pada akhir tutorial ini, Anda menyelesaikan tindakan berikut:
+ Membangun dan melatih model Amazon Fraud Detector
+ Hasilkan prediksi penipuan waktu nyata

## Prasyarat
<a name="gs-sdk-prerequisites"></a>

Berikut ini adalah langkah-langkah prasyarat untuk tutorial ini.
+ Selesai[Siapkan untuk Amazon Fraud Detector](set-up.md). 

  Jika sudah[Siapkan AWS SDK](set-up.md#set-up-sdk), pastikan Anda menggunakan Boto3 SDK versi 1.14.29 atau lebih tinggi.
+ Ikuti instruksi untuk [Dapatkan dan unggah contoh dataset](step-1-get-s3-data.md) file yang diperlukan untuk tutorial ini. 

## Memulai
<a name="get-started-python"></a>

### Langkah 1: Siapkan dan verifikasi lingkungan Python Anda
<a name="setup-and-verify-your-python-environment"></a>

Boto adalah Amazon Web Services (AWS) SDK untuk Python. Anda dapat menggunakannya untuk membuat, mengkonfigurasi, dan mengelola Layanan AWS. Untuk petunjuk tentang cara menginstal Boto3, lihat [AWS SDK for Python (Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)).

Setelah Anda menginstal AWS SDK untuk Python (Boto3), jalankan perintah contoh Python berikut untuk mengonfirmasi bahwa lingkungan Anda dikonfigurasi dengan benar. Jika lingkungan Anda dikonfigurasi dengan benar, respons berisi daftar detektor. Jika tidak ada detektor yang dibuat, daftarnya kosong. 

```
import boto3
fraudDetector = boto3.client('frauddetector')
            
response = fraudDetector.get_detectors()
print(response)
```

### Langkah 2: Buat variabel, tipe entitas, dan label
<a name="create-variables-entity-type-and-labels"></a>

Pada langkah ini, Anda membuat sumber daya yang digunakan untuk menentukan model, acara, dan aturan.

#### Buat variabel
<a name="create-variable-gs-sdk"></a>

Variabel adalah elemen data dari dataset Anda yang ingin Anda gunakan untuk membuat jenis acara, model, dan aturan.

Dalam contoh berikut, [CreateVariable](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateVariable.html)API digunakan untuk membuat dua variabel. Variabel-variabelnya adalah `email_address` dan`ip_address`. Tetapkan mereka ke jenis variabel yang sesuai: `EMAIL_ADDRESS` dan`IP_ADDRESS`. Variabel ini adalah bagian dari contoh kumpulan data yang Anda unggah. Saat Anda menentukan jenis variabel, Amazon Fraud Detector menafsirkan variabel selama pelatihan model dan saat mendapatkan prediksi. Hanya variabel dengan tipe variabel terkait yang dapat digunakan untuk pelatihan model.

```
import boto3
fraudDetector = boto3.client('frauddetector')

 #Create variable email_address
fraudDetector.create_variable(
    name = 'email_address',
    variableType = 'EMAIL_ADDRESS',
    dataSource = 'EVENT',
    dataType = 'STRING',
    defaultValue = '<unknown>'
)

#Create variable ip_address
fraudDetector.create_variable(
    name = 'ip_address',
    variableType = 'IP_ADDRESS',
    dataSource = 'EVENT',
    dataType = 'STRING',
    defaultValue = '<unknown>'
)
```

#### Buat tipe entitas
<a name="create-entity-gs-sdk"></a>

Entitas mewakili siapa yang melakukan acara dan tipe entitas mengklasifikasikan entitas. Contoh klasifikasi termasuk *pelanggan*, *pedagang*, atau *akun*.

Dalam contoh berikut, [PutEntityType](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutEntityType.html)API digunakan untuk membuat tipe `sample_customer` entitas.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_entity_type(
   name = 'sample_customer',
   description = 'sample customer entity type'
)
```

#### Buat label
<a name="create-label-gs-sdk"></a>

Label mengklasifikasikan suatu peristiwa sebagai penipuan atau sah dan digunakan untuk melatih model deteksi penipuan. Model belajar mengklasifikasikan peristiwa menggunakan nilai label ini.

Dalam contoh berikut, API [Putlabel](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutLabel.html) digunakan untuk membuat dua label, `fraud` dan`legit`.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_label(
    name = 'fraud',
    description = 'label for fraud events'
)

fraudDetector.put_label(
    name = 'legit',
    description = 'label for legitimate events'
)
```

### Langkah 3: Buat jenis acara
<a name="python-create-event-type"></a>

Dengan Amazon Fraud Detector, Anda membuat model yang mengevaluasi risiko dan menghasilkan prediksi penipuan untuk setiap peristiwa. Tipe acara mendefinisikan struktur peristiwa individu. 

Dalam contoh berikut, [PutEventType](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutEventType.html)API digunakan untuk membuat jenis acara`sample_registration`. Anda menentukan jenis acara dengan menentukan variabel (`email_address`,`ip_address`), tipe entitas (`sample_customer`), dan label (`fraud`,`legit`) yang Anda buat pada langkah sebelumnya. 

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_event_type (
     name = 'sample_registration',
     eventVariables = ['ip_address', 'email_address'],
     labels = ['legit', 'fraud'],
     entityTypes = ['sample_customer'])
```

### Langkah 4: Buat, latih, dan terapkan model
<a name="python-create-and-train-a-model"></a>

Amazon Fraud Detector melatih model untuk belajar mendeteksi penipuan untuk jenis peristiwa tertentu. Pada langkah sebelumnya, Anda membuat jenis acara. Pada langkah ini, Anda membuat dan melatih model untuk jenis acara. Model bertindak sebagai wadah untuk versi model Anda. Setiap kali Anda melatih model, versi baru dibuat. 

Gunakan kode contoh berikut untuk membuat dan melatih model Wawasan Penipuan Online. Model ini disebut`sample_fraud_detection_model`. Ini untuk jenis acara `sample_registration` menggunakan dataset contoh pendaftaran akun yang Anda unggah ke Amazon S3.

Untuk informasi selengkapnya tentang berbagai jenis model yang didukung Amazon Fraud Detector, lihat[Pilih jenis model](choosing-model-type.md).

**Buat model**

Dalam contoh berikut, [CreateModel](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateModel.html)API digunakan untuk membuat model.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_model (
       modelId = 'sample_fraud_detection_model',
       eventTypeName = 'sample_registration',
       modelType = 'ONLINE_FRAUD_INSIGHTS')
```

**Latih model**

Dalam contoh berikut, [CreateModelVersion](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateModelVersion.html)API digunakan untuk melatih model. Tentukan `'EXTERNAL_EVENTS'` untuk `trainingDataSource` dan lokasi Amazon S3 tempat Anda menyimpan kumpulan data contoh dan bucket Amazon S3 untuk. *RoleArn*`externalEventsDetail` Untuk `trainingDataSchema` parameter, tentukan bagaimana Amazon Fraud Detector menafsirkan data contoh. Lebih khusus lagi, tentukan variabel mana yang akan disertakan dan bagaimana mengklasifikasikan label acara.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_model_version (
         modelId = 'sample_fraud_detection_model',
         modelType = 'ONLINE_FRAUD_INSIGHTS',
         trainingDataSource = 'EXTERNAL_EVENTS',
         trainingDataSchema = {
            'modelVariables' : ['ip_address', 'email_address'],
            'labelSchema' : {
               'labelMapper' : {
                   'FRAUD' : ['fraud'],
                   'LEGIT' : ['legit']
        }
    }
}, 
         externalEventsDetail = {
              'dataLocation' : 's3://{{amzn-s3-demo-bucket}}/{{your-example-data-filename}}.csv',
              'dataAccessRoleArn' : '{{role_arn}}'
}
)
```

Anda dapat melatih model Anda beberapa kali. Setiap kali Anda melatih model, versi baru dibuat. Setelah pelatihan model selesai, status versi model diperbarui ke`TRAINING_COMPLETE`. Anda dapat meninjau skor kinerja model dan metrik kinerja model lainnya.

**Tinjau kinerja model**

Langkah penting dalam menggunakan Amazon Fraud Detector adalah menilai keakuratan model Anda menggunakan skor model dan metrik kinerja. Setelah pelatihan model selesai, Amazon Fraud Detector memvalidasi kinerja model menggunakan 15% data Anda yang tidak digunakan untuk melatih model. Ini menghasilkan skor kinerja model dan metrik kinerja lainnya.

Gunakan [DescribeModelVersions](https://docs.aws.amazon.com//frauddetector/latest/api/API_DescribeModelVersions.html)API untuk meninjau performa model. Lihat skor keseluruhan **kinerja Model** dan semua metrik lain yang dihasilkan oleh Amazon Fraud Detector untuk model ini.

Untuk mempelajari lebih lanjut tentang skor kinerja model dan metrik kinerja, lihat [Skor model](model-scores.md) dan[Metrik kinerja model](training-performance-metrics.md).

Anda dapat mengharapkan semua model Amazon Fraud Detector Anda yang terlatih memiliki metrik kinerja deteksi penipuan dunia nyata, yang mirip dengan metrik dalam tutorial ini.

**Menyebarkan model**

Setelah Anda meninjau metrik kinerja model terlatih Anda, terapkan model dan sediakan untuk Amazon Fraud Detector untuk menghasilkan prediksi penipuan. Untuk menerapkan model terlatih, gunakan [UpdateModelVersionStatus](https://docs.aws.amazon.com//frauddetector/latest/api/API_UpdateModelVersionStatus.html)API. Dalam contoh berikut, ini digunakan untuk memperbarui status versi model ke ACTIVE.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.update_model_version_status (
     modelId = 'sample_fraud_detection_model',
     modelType = 'ONLINE_FRAUD_INSIGHTS',
     modelVersionNumber = '1.00',
     status = 'ACTIVE'
)
```

### Langkah 5: Buat detektor, hasil, aturan, dan versi detektor
<a name="python-create-a-detector-outcome-rules-and-detector-version"></a>

Detektor berisi logika deteksi, seperti model dan aturan. Logika ini untuk acara tertentu yang ingin Anda evaluasi untuk penipuan. Aturan adalah kondisi yang Anda tentukan untuk memberi tahu Amazon Fraud Detector cara menafsirkan nilai variabel selama prediksi. Dan hasilnya adalah hasil dari prediksi penipuan. Detektor dapat memiliki beberapa versi dengan setiap versi memiliki status *DRAFT*, *ACTIVE*, atau *INACTIVE*. Versi detektor harus memiliki setidaknya satu aturan yang terkait dengannya. 

Gunakan kode contoh berikut untuk membuat detektor, aturan, hasil, dan untuk mempublikasikan detektor. 

**Buat detektor**

Dalam contoh berikut, [PutDetector](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutDetector.html)API digunakan untuk membuat `sample_detector` detektor untuk jenis `sample_registration` peristiwa.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_detector (
     detectorId = 'sample_detector',
     eventTypeName = 'sample_registration'
)
```

**Ciptakan hasil**

Hasil diciptakan untuk setiap kemungkinan hasil prediksi penipuan. Dalam contoh berikut, [PutOutcome](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutOutcome.html)API digunakan untuk membuat tiga hasil -`verify_customer`,`review`, dan`approve`. Hasil ini kemudian ditetapkan untuk aturan. 

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_outcome(
     name = 'verify_customer',
     description = 'this outcome initiates a verification workflow'
    )

fraudDetector.put_outcome(
     name = 'review',
     description = 'this outcome sidelines event for review'
    )

fraudDetector.put_outcome(
     name = 'approve',
     description = 'this outcome approves the event'
)
```

**Buat aturan**

Aturan terdiri dari satu atau lebih variabel dari dataset Anda, ekspresi logika, dan satu atau lebih hasil. 

Dalam contoh berikut, [CreateRule](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateRule.html)API digunakan untuk membuat tiga aturan berbeda:`high_risk`,`medium_risk`, dan`low_risk`. Buat ekspresi aturan untuk membandingkan `sample_fraud_detection_model_insightscore` nilai skor kinerja model dengan berbagai ambang batas. Ini untuk menentukan tingkat risiko suatu peristiwa dan menetapkan hasil yang ditentukan pada langkah sebelumnya. 

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_rule(
     ruleId = 'high_fraud_risk',
     detectorId = 'sample_detector',
     expression = '$sample_fraud_detection_model_insightscore > 900',
     language = 'DETECTORPL',
     outcomes = ['verify_customer']
     )

fraudDetector.create_rule(
     ruleId = 'medium_fraud_risk',
     detectorId = 'sample_detector',
     expression = '$sample_fraud_detection_model_insightscore <= 900 and $sample_fraud_detection_model_insightscore > 700',
     language = 'DETECTORPL',
     outcomes = ['review']
     )

fraudDetector.create_rule(
     ruleId = 'low_fraud_risk',
     detectorId = 'sample_detector',
     expression = '$sample_fraud_detection_model_insightscore <= 700',
     language = 'DETECTORPL',
     outcomes = ['approve']
     )
```

**Buat versi detektor**

Versi detektor mendefinisikan model dan aturan yang digunakan untuk mendapatkan prediksi penipuan.

Dalam contoh berikut, [CreateDetectorVersion](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateDetectorVersion.html)API digunakan untuk membuat versi detektor. Ini dilakukan dengan memberikan detail versi model, aturan, dan mode eksekusi aturan FIRST\_MATCHED. Mode eksekusi aturan menentukan urutan untuk mengevaluasi aturan. Mode eksekusi aturan FIRST\_MATCHED menetapkan bahwa aturan dievaluasi secara berurutan, pertama hingga terakhir, berhenti pada aturan pertama yang cocok.

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_detector_version(
      detectorId = 'sample_detector',
      rules = [{
          'detectorId' : 'sample_detector',
          'ruleId' : 'high_fraud_risk',
          'ruleVersion' : '1'
},
{
          'detectorId' : 'sample_detector',
          'ruleId' : 'medium_fraud_risk',
          'ruleVersion' : '1'
},
{
          'detectorId' : 'sample_detector',
          'ruleId' : 'low_fraud_risk',
          'ruleVersion' : '1'
}
],
      modelVersions = [{
          'modelId' : 'sample_fraud_detection_model',
          'modelType': 'ONLINE_FRAUD_INSIGHTS',
          'modelVersionNumber' : '1.00'
}      ],
      ruleExecutionMode = 'FIRST_MATCHED'
)
```

### Langkah 6: Hasilkan prediksi penipuan
<a name="python-generate-fraud-predictions"></a>

Langkah terakhir dari tutorial ini menggunakan detektor yang `sample_detector` dibuat pada langkah sebelumnya untuk menghasilkan prediksi penipuan untuk jenis `sample_registration` peristiwa secara real time. Detektor mengevaluasi contoh data yang diunggah ke Amazon S3. Respons mencakup skor kinerja model serta hasil apa pun yang terkait dengan aturan yang cocok. 

Dalam contoh berikut, [GetEventPrediction](https://docs.aws.amazon.com//frauddetector/latest/api/API_GetEventPrediction.html)API digunakan untuk menyediakan data dari pendaftaran akun tunggal dengan setiap permintaan. Untuk tutorial ini, ambil data (email\_address dan ip\_address) dari file data contoh pendaftaran akun. Setiap baris (baris) setelah baris header atas mewakili data dari acara pendaftaran akun tunggal. 

```
import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.get_event_prediction(
      detectorId = 'sample_detector',
      eventId = '802454d3-f7d8-482d-97e8-c4b6db9a0428',
      eventTypeName = 'sample_registration',
      eventTimestamp = '2020-07-13T23:18:21Z',
      entities = [{'entityType':'sample_customer', 'entityId':'12345'}],
 eventVariables = {
      'email_address': 'johndoe@exampledomain.com',
      'ip_address': '1.2.3.4'
}
)
```

Setelah Anda menyelesaikan tutorial ini, Anda melakukan hal berikut:
+ Mengunggah contoh dataset peristiwa ke Amazon S3.
+ Membuat variabel, entitas, dan label yang digunakan untuk membuat dan melatih model.
+ Membuat dan melatih model menggunakan contoh dataset.
+ Melihat skor kinerja model dan metrik kinerja lainnya yang dihasilkan Amazon Fraud Detector.
+ Menggunakan model deteksi penipuan.
+ Membuat detektor dan menambahkan model yang digunakan.
+ Menambahkan aturan, urutan eksekusi aturan, dan hasil ke detektor.
+ Versi detektor yang dibuat.
+ Menguji detektor dengan memberikan input yang berbeda dan memeriksa apakah aturan dan perintah eksekusi aturan berfungsi seperti yang diharapkan.

## (Opsional) Jelajahi Amazon Fraud Detector APIs dengan Notebook Jupyter (IPython)
<a name="gs-jupyter-notebook"></a>

Untuk contoh selengkapnya tentang cara menggunakan Amazon Fraud Detector APIs, lihat [aws-fraud-detector-samples GitHub repositori](https://github.com/aws-samples/aws-fraud-detector-samples). Topik yang dibahas notebook mencakup model bangunan dan detektor menggunakan Amazon Fraud Detector APIs dan membuat permintaan prediksi penipuan batch menggunakan API. `GetEventPrediction`