Modelle zur Erkennung von Geldwäsche trainieren und testen

Instanz erstellen

In diesem Abschnitt wird beschrieben, wie Sie eine Instanz erstellen. Die AML AI-Instanz ist die Wurzel aller anderen AML AI-Ressourcen. Jede Instanz benötigt einen einzelnen verknüpften vom Kunden verwalteten Verschlüsselungsschlüssel (Customer-Managed Encryption Key, CMEK), mit dem alle von AML AI erstellten Daten verschlüsselt werden.

Schlüsselbund erstellen

Verwenden Sie zum Erstellen eines Schlüsselanhängers die Methode projects.locations.keyRings.create.

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d "" \
     "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings?key_ring_id=my-key-ring"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -Uri "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings?key_ring_id=my-key-ring" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring",
  "createTime": CREATE_TIME
}

gcloud kms keyrings create my-key-ring \
  --location LOCATION

gcloud kms keyrings create my-key-ring `
  --location LOCATION

gcloud kms keyrings create my-key-ring ^
  --location LOCATION

$

Schlüssel erstellen

Verwenden Sie zum Erstellen eines Schlüssels die Methode projects.locations.keyRings.cryptoKeys.

{
  "purpose": "ENCRYPT_DECRYPT"
}

cat > request.json << 'EOF'
{
  "purpose": "ENCRYPT_DECRYPT"
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys?crypto_key_id=my-key"

@'
{
  "purpose": "ENCRYPT_DECRYPT"
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys?crypto_key_id=my-key" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key",
  "primary": {
    "name": "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key/cryptoKeyVersions/1",
    "state": "ENABLED",
    "createTime": CREATE_TIME,
    "protectionLevel": "SOFTWARE",
    "algorithm": "GOOGLE_SYMMETRIC_ENCRYPTION",
    "generateTime": GENERATE_TIME
  },
  "purpose": "ENCRYPT_DECRYPT",
  "createTime": CREATE_TIME,
  "versionTemplate": {
    "protectionLevel": "SOFTWARE",
    "algorithm": "GOOGLE_SYMMETRIC_ENCRYPTION"
  },
  "destroyScheduledDuration": "86400s"
}

gcloud kms keys create my-key \
  --keyring my-key-ring \
  --location LOCATION \
  --purpose "encryption"

gcloud kms keys create my-key `
  --keyring my-key-ring `
  --location LOCATION `
  --purpose "encryption"

gcloud kms keys create my-key ^
  --keyring my-key-ring ^
  --location LOCATION ^
  --purpose "encryption"

$

Instanz mit der API erstellen

Verwenden Sie zum Erstellen einer Instanz die Methode projects.locations.instances.create.

JSON-Text der Anfrage:

{
  "kmsKey": "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key"
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
  "kmsKey": "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key"
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances?instance_id=my-instance"

@'
{
  "kmsKey": "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key"
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances?instance_id=my-instance" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Bei erfolgreicher Ausführung enthält der Antworttext einen Vorgang mit langer Laufzeit mit einer ID, mit der der aktuelle Status des asynchronen Vorgangs abgerufen werden kann. Kopieren Sie den zurückgegebenen OPERATION_ID, um ihn im nächsten Abschnitt zu verwenden.

Ergebnis prüfen

Verwenden Sie die Methode projects.locations.operations.get, um zu prüfen, ob die Instanz erstellt wurde. Wenn die Antwort "done": false enthält, wiederholen Sie den Befehl, bis die Antwort "done": true enthält.

Die in diesem Leitfaden beschriebenen Vorgänge können einige Minuten bis mehrere Stunden dauern. Sie müssen warten, bis ein Vorgang abgeschlossen ist, bevor Sie mit diesem Leitfaden fortfahren können, da die API die Ausgabe einiger Methoden als Eingabe für andere Methoden verwendet.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

• OPERATION_ID: die Kennzeichnung für den Vorgang

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "endTime": END_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.Instance",
    "name": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance",
    "createTime": CREATE_TIME,
    "updateTime": UPDATE_TIME,
    "kmsKey": "projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key",
    "state": "ACTIVE"
  }
}

Zugriff auf den CMEK-Schlüssel gewähren

Die API erstellt automatisch ein Dienstkonto in Ihrem Projekt. Das Dienstkonto benötigt Zugriff auf den CMEK-Schlüssel, damit es die zugrunde liegenden Daten damit verschlüsseln und entschlüsseln kann. Gewähren Sie Zugriff auf den Schlüssel.

gcloud kms keys add-iam-policy-binding "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring/cryptoKeys/my-key" \
  --keyring "projects/PROJECT_ID/locations/LOCATION/keyRings/my-key-ring" \
  --location "LOCATION" \
  --member "serviceAccount:service-PROJECT_NUMBER@gcp-sa-financialservices.iam.gserviceaccount.com" \
  --role="roles/cloudkms.cryptoKeyEncrypterDecrypter" \
  --project="PROJECT_ID"

BigQuery-Datasets erstellen

In diesem Abschnitt wird beschrieben, wie Sie BigQuery-Eingabe- und -Ausgabe-Datasets erstellen und dann Beispieldaten für Banken in das Eingabe-Dataset kopieren.

Ausgabe-Dataset erstellen

Erstellen Sie ein Dataset, an das die AML-Pipeline-Ausgaben gesendet werden sollen.

bq mk \
  --location=LOCATION \
  --project_id=PROJECT_ID \
  my_bq_output_dataset

bq mk `
  --location=LOCATION `
  --project_id=PROJECT_ID `
  my_bq_output_dataset

Eingabe-Dataset erstellen

Erstellen Sie ein Dataset, in das Sie die Beispieltabellen für Banken kopieren.

bq mk \
  --location=LOCATION \
  --project_id=PROJECT_ID \
  my_bq_input_dataset

bq mk `
  --location=LOCATION `
  --project_id=PROJECT_ID `
  my_bq_input_dataset

Beispiel-Dataset kopieren

Beispieldaten für Banken werden als BigQuery-Dataset im freigegebenen Dataset-Projekt von Google bereitgestellt. Sie benötigen Zugriff auf die AML AI API, damit Sie auf diesen Datensatz zugreifen können. Zu den wichtigsten Merkmalen dieses Datasets gehören:

• 100.000 Teilnehmer
• einen Hauptzeitraum vom 1. Januar 2020 bis zum 1. Januar 2023 sowie zusätzliche 24 Monate an Verlaufsdaten
• 300 negative und 20 positive Risikofälle pro Monat
• Risikofälle mit den folgenden Attributen:
  • Die Hälfte der Fälle mit positiven Risiken bezieht sich auf Strukturierungsaktivitäten, die in den zwei Monaten vor dem Ereignis vom AML_PROCESS_START stattgefunden haben.
  • Die andere Hälfte wird an die Parteien mit dem höchsten Geldeingang in den zwei Monaten vor dem AML_PROCESS_START-Ereignis ausgezahlt.
  • Negative Fälle werden zufällig generiert.
  • Eine Wahrscheinlichkeit von 0,1 %, dass der Risikofall im umgekehrten Zustand generiert wird (z. B. eine zufällige Partei, die positiv ist, oder eine Partei, die Strukturierungsaktivitäten oder das höchste Einkommen hat und als negativ gemeldet wird)
• Das AML-Schema ist im AML-Eingabedatenmodell definiert.

1. Kopieren Sie die Beispieldaten für Banken in das von Ihnen erstellte Eingabe-Dataset.

   Bash

   bq mk --transfer_config \
     --project_id=PROJECT_ID \
     --data_source=cross_region_copy \
     --target_dataset="my_bq_input_dataset" \
     --display_name="Copy the AML sample dataset." \
     --schedule=None \
     --params='{
       "source_project_id":"bigquery-public-data",
       "source_dataset_id":"aml_ai_input_dataset",
       "overwrite_destination_table":"true"
     }'
   

   PowerShell

   bq mk --transfer_config `
   --project_id=PROJECT_ID `
   --data_source=cross_region_copy `
   --target_dataset="my_bq_input_dataset" `
   --display_name="Copy the AML sample dataset." `
   --schedule=None `
   --params='{\"source_project_id\":\"bigquery-public-data\",\"source_dataset_id\":\"aml_ai_input_dataset\",\"overwrite_destination_table\":\"true\"}'
   

2. Überwachen Sie den Datenübertragungsjob.

   Bash

   bq ls --transfer_config \
   --transfer_location=LOCATION \
   --project_id=PROJECT_ID \
   --filter="dataSourceIds:cross_region_copy"
   

   PowerShell

   bq ls --transfer_config `
   --transfer_location=LOCATION `
   --project_id=PROJECT_ID `
   --filter="dataSourceIds:cross_region_copy"
   

   Nach Abschluss der Übertragung wird ein Datenübertragungsjob mit dem Anzeigenamen Copy the AML sample dataset erstellt.

   Sie können den Status der Übertragung auch über die Google Cloud Console prüfen.

   Die Ausgabe sollte in etwa so aussehen:

                        name                           displayName         dataSourceId       state
   -------------------------------------------  -----------------------  -----------------  ---------
   projects/294024168771/locations/us-central1  Copy AML sample dataset  cross_region_copy  SUCCEEDED
   

Zugriff auf die BigQuery-Datasets gewähren

Die API erstellt automatisch ein Dienstkonto in Ihrem Projekt. Das Dienstkonto benötigt Zugriff auf die BigQuery-Eingabe- und -Ausgabe-Datasets.

1. Gewähren Sie Lesezugriff auf das Eingabe-Dataset und seine Tabellen.

   Bash

   bq query --project_id=PROJECT_ID --use_legacy_sql=false \
     'GRANT `roles/bigquery.dataViewer` ON SCHEMA `PROJECT_ID.my_bq_input_dataset` TO "serviceAccount:service-PROJECT_NUMBER@gcp-sa-financialservices.iam.gserviceaccount.com"'
   

   PowerShell

   bq query --project_id=PROJECT_ID --use_legacy_sql=false "GRANT ``roles/bigquery.dataViewer`` ON SCHEMA ``PROJECT_ID.my_bq_input_dataset`` TO 'serviceAccount:service-PROJECT_NUMBER@gcp-sa-financialservices.iam.gserviceaccount.com'"
   

2. Gewähren Sie Schreibzugriff auf das Ausgabe-Dataset.

   Bash

   bq query --project_id=PROJECT_ID --use_legacy_sql=false \
     'GRANT `roles/bigquery.dataEditor` ON SCHEMA `PROJECT_ID.my_bq_output_dataset` TO "serviceAccount:service-PROJECT_NUMBER@gcp-sa-financialservices.iam.gserviceaccount.com"'
   

   PowerShell

   bq query --project_id=PROJECT_ID --use_legacy_sql=false "GRANT ``roles/bigquery.dataEditor`` ON SCHEMA ``PROJECT_ID.my_bq_output_dataset`` TO 'serviceAccount:service-PROJECT_NUMBER@gcp-sa-financialservices.iam.gserviceaccount.com'"
   

AML AI-Dataset erstellen

Erstellen Sie ein AML-KI-Dataset, um die BigQuery-Datasettabellen für die Eingabe und den zu verwendenden Zeitraum anzugeben.

Verwenden Sie zum Erstellen eines Datasets die Methode projects.locations.instances.datasets.create.

JSON-Text der Anfrage:

{
  "tableSpecs": {
    "party": "bq://PROJECT_ID.my_bq_input_dataset.party",
    "account_party_link": "bq://PROJECT_ID.my_bq_input_dataset.account_party_link",
    "transaction": "bq://PROJECT_ID.my_bq_input_dataset.transaction",
    "risk_case_event": "bq://PROJECT_ID.my_bq_input_dataset.risk_case_event",
    "party_supplementary_data": "bq://PROJECT_ID.my_bq_input_dataset.party_supplementary_data"
  },
  "dateRange": {
    "startTime": "2020-01-01T00:00:0.00Z",
    "endTime": "2023-01-01T00:00:0.00Z"
  },
  "timeZone": {
    "id": "UTC"
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
  "tableSpecs": {
    "party": "bq://PROJECT_ID.my_bq_input_dataset.party",
    "account_party_link": "bq://PROJECT_ID.my_bq_input_dataset.account_party_link",
    "transaction": "bq://PROJECT_ID.my_bq_input_dataset.transaction",
    "risk_case_event": "bq://PROJECT_ID.my_bq_input_dataset.risk_case_event",
    "party_supplementary_data": "bq://PROJECT_ID.my_bq_input_dataset.party_supplementary_data"
  },
  "dateRange": {
    "startTime": "2020-01-01T00:00:0.00Z",
    "endTime": "2023-01-01T00:00:0.00Z"
  },
  "timeZone": {
    "id": "UTC"
  }
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets?dataset_id=my-dataset"

@'
{
  "tableSpecs": {
    "party": "bq://PROJECT_ID.my_bq_input_dataset.party",
    "account_party_link": "bq://PROJECT_ID.my_bq_input_dataset.account_party_link",
    "transaction": "bq://PROJECT_ID.my_bq_input_dataset.transaction",
    "risk_case_event": "bq://PROJECT_ID.my_bq_input_dataset.risk_case_event",
    "party_supplementary_data": "bq://PROJECT_ID.my_bq_input_dataset.party_supplementary_data"
  },
  "dateRange": {
    "startTime": "2020-01-01T00:00:0.00Z",
    "endTime": "2023-01-01T00:00:0.00Z"
  },
  "timeZone": {
    "id": "UTC"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets?dataset_id=my-dataset" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Sie können das Ergebnis des Vorgangs anhand der neuen Vorgangs-ID prüfen. Das gilt auch für die übrigen API-Anfragen in diesem Leitfaden.

Engine-Konfiguration erstellen

Erstellen Sie eine AML-KI-Engine-Konfiguration, um Hyperparameter automatisch basierend auf einer bestimmten Engine-Version und den bereitgestellten Daten abzustimmen. Engine-Versionen werden regelmäßig veröffentlicht und entsprechen unterschiedlichen Modelllogiken (z. B. Ausrichtung auf einen Einzelhandels- oder einen kommerziellen Geschäftsbereich).

Verwenden Sie zum Erstellen einer Engine-Konfiguration die Methode projects.locations.instances.engineConfigs.create.

In dieser Phase werden die Hyperparameter angepasst. Das kann einige Zeit in Anspruch nehmen. Wenn sich Ihre Daten nicht wesentlich ändern, können Sie mit diesem Schritt viele Modelle erstellen und testen.

JSON-Text der Anfrage:

{
  "engineVersion": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineVersions/aml-commercial.default.v004.000.202312-000",
  "tuning": {
    "primaryDataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2021-07-01T00:00:00Z"
  },
  "performanceTarget": {
    "partyInvestigationsPerPeriodHint": "30"
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
  "engineVersion": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineVersions/aml-commercial.default.v004.000.202312-000",
  "tuning": {
    "primaryDataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2021-07-01T00:00:00Z"
  },
  "performanceTarget": {
    "partyInvestigationsPerPeriodHint": "30"
  }
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineConfigs?engine_config_id=my-engine-config"

@'
{
  "engineVersion": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineVersions/aml-commercial.default.v004.000.202312-000",
  "tuning": {
    "primaryDataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2021-07-01T00:00:00Z"
  },
  "performanceTarget": {
    "partyInvestigationsPerPeriodHint": "30"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineConfigs?engine_config_id=my-engine-config" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineConfigs/my-engine-config",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Modell erstellen

In diesem Schritt trainieren Sie ein AML-KI-Modell mit Daten aus den 12 Monaten bis zum 01.07.2021.

Verwenden Sie zum Erstellen eines Modells die Methode projects.locations.instances.models.create.

JSON-Text der Anfrage:

{
    "engineConfig": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineConfigs/my-engine-config",
    "primaryDataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2021-07-01T00:00:00Z"
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
    "engineConfig": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineConfigs/my-engine-config",
    "primaryDataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2021-07-01T00:00:00Z"
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models?model_id=my-model"

@'
{
    "engineConfig": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/engineConfigs/my-engine-config",
    "primaryDataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2021-07-01T00:00:00Z"
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models?model_id=my-model" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Backtestergebnis erstellen

Bei der Backtest-Prognose wird das trainierte Modell auf vorhandene Verlaufsdaten angewendet. Erstellen Sie ein Backtest-Ergebnis für die 12 Monate bis Januar 2023, die nicht für das Training verwendet wurden. Anhand dieser Monate wird ermittelt, wie viele Fälle wir bearbeiten müssten, wenn wir das bis Juli 2021 trainierte Modell von Januar bis Dezember 2022 in der Produktion verwendet hätten.

Verwenden Sie zum Erstellen eines Backtest-Ergebnisses die Methode projects.locations.instances.backtestResults.create.

JSON-Text der Anfrage:

{
    "model": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "dataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2023-01-01T00:00:00Z",
    "backtestPeriods": 12,
    "performanceTarget": {
      "partyInvestigationsPerPeriodHint": "150"
    }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
    "model": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "dataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2023-01-01T00:00:00Z",
    "backtestPeriods": 12,
    "performanceTarget": {
      "partyInvestigationsPerPeriodHint": "150"
    }
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/backtestResults?backtest_result_id=my-backtest-results"

@'
{
    "model": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "dataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2023-01-01T00:00:00Z",
    "backtestPeriods": 12,
    "performanceTarget": {
      "partyInvestigationsPerPeriodHint": "150"
    }
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/backtestResults?backtest_result_id=my-backtest-results" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/backtestResults/my-backtest-results",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Metadaten zu Backtest-Ergebnissen exportieren

Nachdem ein Backtest ausgeführt wurde, müssen Sie die Ergebnisse in BigQuery exportieren, um sie aufzurufen. Verwenden Sie die Methode projects.locations.instances.backtestResults.exportMetadata, um Metadaten aus dem Backtestergebnis zu exportieren.

JSON-Text der Anfrage:

{
  "structuredMetadataDestination": {
    "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_backtest_results_metadata",
    "writeDisposition": "WRITE_TRUNCATE"
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
  "structuredMetadataDestination": {
    "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_backtest_results_metadata",
    "writeDisposition": "WRITE_TRUNCATE"
  }
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/backtestResults/my-backtest-results:exportMetadata"

@'
{
  "structuredMetadataDestination": {
    "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_backtest_results_metadata",
    "writeDisposition": "WRITE_TRUNCATE"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/backtestResults/my-backtest-results:exportMetadata" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/backtestResults/my-backtest-results",
    "verb": "exportMetadata",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Gehen Sie nach Abschluss des Vorgangs so vor:

1. Öffnen Sie BigQuery in der Google Cloud Console.

   Google Cloud Console aufrufen

2. Suchen Sie im Bereich Explorer nach Ihrem Projekt und maximieren Sie es.

3. Maximieren Sie my_bq_output_dataset und klicken Sie auf my_backtest_results_metadata.

4. Klicken Sie in der Menüleiste auf Vorschau.

5. Suchen Sie in der Spalte name nach der Zeile mit ObservedRecallValues.

   

6. Angenommen, Sie können 120 Untersuchungen pro Monat durchführen. Suchen Sie mit "partyInvestigationsPerPeriod": "120" nach dem Objekt „Wert für Rückruf“. Wenn Sie die Prüfungen auf Parteien mit einem Risikowert von über 0, 53 beschränken, können Sie bei den folgenden Beispielwerten jeden Monat 120 neue Parteien prüfen. Im Backtestzeitraum, also im Jahr 2022, würden Sie 86% der Fälle identifizieren, die auch das vorherige System erkannt hat (und möglicherweise auch andere, die mit Ihren aktuellen Prozessen nicht erkannt wurden).

   {
     "recallValues": [
       ...
       {
         "partyInvestigationsPerPeriod": "105",
         "recallValue": 0.8142077,
         "scoreThreshold": 0.6071321
       },
       {
         "partyInvestigationsPerPeriod": "120",
         "recallValue": 0.863388,
         "scoreThreshold": 0.5339603
       },
       {
         "partyInvestigationsPerPeriod": "135",
         "recallValue": 0.89071035,
         "scoreThreshold": 0.4739899
       },
       ...
     ]
   }
   

Weitere Informationen zu den anderen Feldern finden Sie in den Backtest-Ergebnissen.

Mit dem Feld partyInvestigationsPerPeriodHint können Sie die Anzahl der Prüfungen ändern, die ein Backtest generiert. Wenn Sie Bewertungen erhalten möchten, um sie zu untersuchen, registrieren Sie Parteien und erstellen Sie Vorhersagen für sie.

Registrierte Parteien importieren

Bevor Sie Prognoseergebnisse erstellen können, müssen Sie registrierte Teilnehmer (d. h. Kunden im Dataset) importieren.

Verwenden Sie die Methode projects.locations.instances.importRegisteredParties, um registrierte Parteien zu importieren.

JSON-Text der Anfrage:

{
  "partyTables": [
     "bq://PROJECT_ID.my_bq_input_dataset.party_registration"
  ],
  "mode": "REPLACE",
  "lineOfBusiness": "COMMERCIAL"
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
  "partyTables": [
     "bq://PROJECT_ID.my_bq_input_dataset.party_registration"
  ],
  "mode": "REPLACE",
  "lineOfBusiness": "COMMERCIAL"
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance:importRegisteredParties"

@'
{
  "partyTables": [
     "bq://PROJECT_ID.my_bq_input_dataset.party_registration"
  ],
  "mode": "REPLACE",
  "lineOfBusiness": "COMMERCIAL"
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance:importRegisteredParties" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance",
    "verb": "importRegisteredParties",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Prüfen Sie das Ergebnis dieses Vorgangs, bis er abgeschlossen ist. Nach Abschluss sollten in der JSON-Ausgabe 10.000 Parteien angezeigt werden.

Vorhersageergebnis erstellen

Erstellen Sie eine Vorhersage für die letzten 12 Monate im Dataset. Diese Monate wurden nicht für das Training verwendet. Wenn Sie Vorhersageergebnisse erstellen, werden für jede Partei in jedem Monat über alle Vorhersagezeiträume hinweg Bewertungen erstellt.

Verwenden Sie die Methode projects.locations.instances.predictionResults.create, um ein Vorhersageergebnis zu erstellen.

JSON-Text der Anfrage:

{
    "model": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "dataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2023-01-01T00:00:00Z",
    "predictionPeriods": "12",
    "outputs": {
      "predictionDestination": {
        "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_prediction_results",
        "writeDisposition": "WRITE_TRUNCATE"
      },
      "explainabilityDestination": {
        "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_prediction_results_explainability",
        "writeDisposition": "WRITE_TRUNCATE"
      }
    }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

cat > request.json << 'EOF'
{
    "model": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "dataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2023-01-01T00:00:00Z",
    "predictionPeriods": "12",
    "outputs": {
      "predictionDestination": {
        "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_prediction_results",
        "writeDisposition": "WRITE_TRUNCATE"
      },
      "explainabilityDestination": {
        "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_prediction_results_explainability",
        "writeDisposition": "WRITE_TRUNCATE"
      }
    }
}
EOF

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/predictionResults?prediction_result_id=my-prediction-results"

@'
{
    "model": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/models/my-model",
    "dataset": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/datasets/my-dataset",
    "endTime": "2023-01-01T00:00:00Z",
    "predictionPeriods": "12",
    "outputs": {
      "predictionDestination": {
        "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_prediction_results",
        "writeDisposition": "WRITE_TRUNCATE"
      },
      "explainabilityDestination": {
        "tableUri": "bq://PROJECT_ID.my_bq_output_dataset.my_prediction_results_explainability",
        "writeDisposition": "WRITE_TRUNCATE"
      }
    }
}
'@  | Out-File -FilePath request.json -Encoding utf8

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://financialservices.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/instances/my-instance/predictionResults?prediction_result_id=my-prediction-results" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.financialservices.v1.OperationMetadata",
    "createTime": CREATE_TIME,
    "target": "projects/PROJECT_ID/locations/LOCATION/instances/my-instance/predictionResults/my-prediction-results",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "v1"
  },
  "done": false
}

Einzelnen Fall mit Strukturierungsproblemen in der Google Cloud Console analysieren

1. Öffnen Sie BigQuery in der Google Cloud Console.

   Google Cloud Console aufrufen

2. Klicken Sie im Detailbereich auf den Tab Untitled Query (Unbenannte Abfrage), um den Editor aufzurufen.

3. Kopieren Sie die folgende SQL-Anweisung in den Editor und klicken Sie auf Ausführen.

   SELECT *
   FROM `PROJECT_ID.my_bq_input_dataset.transaction`
   WHERE account_id = '1E60OAUNKP84WDKB' AND DATE_TRUNC(book_time, MONTH) = "2022-08-01"
   ORDER by book_time
   

   In diesem Kontoauszug wird die Konto-ID 1E60OAUNKP84WDKB im August 2022 geprüft. Dieses Konto ist mit der Partei-ID EGS4NJD38JZ8NTL8 verknüpft. Die Partei-ID für eine bestimmte Konto-ID finden Sie in der Tabelle AccountPartyLink.

   Die Transaktionsdaten zeigen häufige runde Transaktionen, die kurz nach großen Bargeldeinzahlungen auf ein einzelnes Konto erfolgen. Das sieht verdächtig aus. Diese Transaktionen könnten auf Geldwäsche (d. h. die Aufteilung einer großen Geldtransaktion in kleinere Transaktionsbeträge) oder Strukturierung hinweisen.

   

4. Kopieren Sie die folgende SQL-Anweisung in den Editor und klicken Sie auf Ausführen.

   SELECT *
   FROM `PROJECT_ID.my_bq_input_dataset.risk_case_event`
   WHERE party_id = 'EGS4NJD38JZ8NTL8'
   

   Diese Aussage zeigt, dass es einen Risikofall gab, der zum Ausscheiden dieses Teilnehmers geführt hat. Der Risikofall wurde zwei Monate nach der verdächtigen Aktivität eröffnet.

   

5. Kopieren Sie die folgende SQL-Anweisung in den Editor und klicken Sie auf Ausführen.

   SELECT *
   FROM `PROJECT_ID.my_bq_output_dataset.my_prediction_results`
   WHERE party_id = 'EGS4NJD38JZ8NTL8'
   ORDER BY risk_period_end_time
   

   In den Prognoseergebnissen sehen Sie, dass der Risikowert der Partei in den Monaten nach den verdächtigen Aktivitäten von fast null (beachten Sie den Exponentenwert) auf hohe Werte ansteigt. Ihre Ergebnisse können von den angezeigten Ergebnissen abweichen.

   

   Der Risikowert ist keine Wahrscheinlichkeit. Ein Risiko-Score sollte immer im Vergleich zu anderen Risiko-Scores bewertet werden. Ein scheinbar niedriger Wert kann beispielsweise als positiv eingestuft werden, wenn die anderen Risikobewertungen niedriger sind.

6. Kopieren Sie die folgende SQL-Anweisung in den Editor und klicken Sie auf Ausführen.

   SELECT *
   FROM `PROJECT_ID.my_bq_output_dataset.my_prediction_results_explainability`
   WHERE party_id = 'EGS4NJD38JZ8NTL8'
   AND risk_period_end_time = '2022-10-01'
   

   In den Ergebnissen zur Erklärbarkeit sehen Sie, dass die richtigen Feature-Familien die höchsten Werte erzielen.