Amazon Fraud Detector dejará de estar abierto a nuevos clientes a partir del 7 de noviembre de 2025. Para obtener funciones similares a Amazon Fraud Detector, explore Amazon SageMaker, AutoGluon, y AWS WAF.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Tutorial: Comience a usar el AWS SDK para Python (Boto3)
<a name="getting-started-python"></a>

En este tutorial se describe cómo crear y entrenar un modelo de Amazon Fraud Detector y, a continuación, cómo utilizar este modelo para generar predicciones de fraude en tiempo real mediante el AWS SDK para Python (Boto3). El modelo se entrena con el archivo de datos de ejemplo de registro de cuenta que se carga en el bucket de Amazon S3.

Al final de este tutorial, debe completar las siguientes acciones:
+ Cree y entrene un modelo de Amazon Fraud Detector
+ Genere predicciones de fraude en tiempo real

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

Los siguientes son pasos previos para este tutorial.
+ Completado[Configurar Amazon Fraud Detector](set-up.md). 

  Si ya lo has hecho[Configure el AWS SDK](set-up.md#set-up-sdk), asegúrate de utilizar la versión 1.14.29 o superior del SDK de Boto3.
+ He seguido las instrucciones necesarias para [Obtenga y cargue un conjunto de datos de ejemplo](step-1-get-s3-data.md) archivar este tutorial. 

## Introducción
<a name="get-started-python"></a>

### Paso 1: Configurar y verificar el entorno de Python
<a name="setup-and-verify-your-python-environment"></a>

Boto es el SDK de Amazon Web Services (AWS) para Python. Puede usarlo para crear, configurar y administrar Servicios de AWS. Para obtener instrucciones sobre cómo instalar Boto3, consulte [AWS SDK for Python (](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)Boto3).

Tras la instalación AWS SDK para Python (Boto3), ejecute el siguiente comando de ejemplo de Python para confirmar que el entorno está configurado correctamente. Si el entorno está configurado correctamente, la respuesta contiene una lista de detectores. Si no se creó ningún detector, la lista está vacía. 

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

### Paso 2: Crear variables, tipos de entidad y etiquetas
<a name="create-variables-entity-type-and-labels"></a>

En este paso, crea recursos que se utilizan para definir el modelo, el evento y las reglas.

#### Crear una variable
<a name="create-variable-gs-sdk"></a>

Una variable es un elemento de datos de su conjunto de datos que desea usar para crear el tipo de evento, el modelo y las reglas.

En el siguiente ejemplo, la [CreateVariable](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateVariable.html)API se usa para crear dos variables. Las variables son `email_address` y`ip_address`. Asígnelas a los tipos de variables correspondientes: `EMAIL_ADDRESS` y`IP_ADDRESS`. Estas variables forman parte del conjunto de datos de ejemplo que has subido. Al especificar el tipo de variable, Amazon Fraud Detector interpreta la variable durante el entrenamiento del modelo y al obtener predicciones. Solo las variables con un tipo de variable asociado se pueden utilizar para el entrenamiento del modelo.

```
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>'
)
```

#### Cree un tipo de entidad
<a name="create-entity-gs-sdk"></a>

Una entidad representa quién está realizando el evento y un tipo de entidad clasifica la entidad. *Los ejemplos de clasificaciones incluyen *cliente*, *comerciante* o cuenta.*

En el siguiente ejemplo, la [PutEntityType](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutEntityType.html)API se utiliza para crear un tipo de `sample_customer` entidad.

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

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

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

Una etiqueta clasifica un evento como fraudulento o legítimo y se utiliza para entrenar el modelo de detección de fraudes. El modelo aprende a clasificar los eventos utilizando estos valores de etiqueta.

En el siguiente ejemplo, la API [Putlabel](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutLabel.html) se utiliza para crear dos etiquetas `fraud` y`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'
)
```

### Paso 3: Crear el tipo de evento
<a name="python-create-event-type"></a>

Con Amazon Fraud Detector, puede crear modelos que evalúan los riesgos y generan predicciones de fraude para eventos individuales. Un tipo de evento define la estructura de un evento individual. 

En el siguiente ejemplo, la [PutEventType](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutEventType.html)API se utiliza para crear un tipo de evento`sample_registration`. Para definir el tipo de evento, especifique las variables (`email_address`,`ip_address`), el tipo de entidad (`sample_customer`) y las etiquetas (`fraud`,`legit`) que creó en el paso anterior. 

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

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

### Paso 4: Crear, entrenar e implementar el modelo
<a name="python-create-and-train-a-model"></a>

Amazon Fraud Detector entrena a los modelos para que aprendan a detectar el fraude en un tipo de evento específico. En el paso anterior, creó el tipo de evento. En este paso, creará y entrenará un modelo para el tipo de evento. El modelo actúa como contenedor para las versiones de su modelo. Cada vez que entrena un modelo, se crea una nueva versión. 

Utilice los siguientes códigos de ejemplo para crear y entrenar un modelo de Online Fraud Insights. Este modelo se llama`sample_fraud_detection_model`. Es para el tipo de evento que `sample_registration` utiliza el conjunto de datos de ejemplo de registro de cuenta que cargó en Amazon S3.

Para obtener más información sobre los distintos tipos de modelos compatibles con Amazon Fraud Detector, consulte[Elija un tipo de modelo](choosing-model-type.md).

**Crear un modelo**

En el siguiente ejemplo, la [CreateModel](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateModel.html)API se utiliza para crear un modelo.

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

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

**Entrena un modelo**

En el siguiente ejemplo, la [CreateModelVersion](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateModelVersion.html)API se utiliza para entrenar el modelo. Especifique `'EXTERNAL_EVENTS'` la ubicación `trainingDataSource` y la ubicación de Amazon S3 en la que almacenó su conjunto de datos *RoleArn*de ejemplo y la del bucket de Amazon S3`externalEventsDetail`. Como `trainingDataSchema` parámetro, especifique cómo interpreta Amazon Fraud Detector los datos del ejemplo. Más específicamente, especifique qué variables incluir y cómo clasificar las etiquetas de los eventos.

```
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}}'
}
)
```

Puede entrenar el modelo varias veces. Cada vez que entrenas un modelo, se crea una nueva versión. Una vez finalizado el entrenamiento del modelo, el estado de la versión del modelo se actualiza a`TRAINING_COMPLETE`. Puede revisar la puntuación de rendimiento del modelo y otras métricas de rendimiento del modelo.

**Revise el rendimiento del modelo**

Un paso importante a la hora de utilizar Amazon Fraud Detector es evaluar la precisión del modelo mediante las puntuaciones del modelo y las métricas de rendimiento. Una vez finalizada la formación del modelo, Amazon Fraud Detector valida el rendimiento del modelo utilizando el 15% de los datos que no se utilizaron para entrenar el modelo. Genera una puntuación de rendimiento del modelo y otras métricas de rendimiento.

Utilice la [DescribeModelVersions](https://docs.aws.amazon.com//frauddetector/latest/api/API_DescribeModelVersions.html)API para revisar el rendimiento del modelo. Observe la puntuación general del **rendimiento del modelo** y todas las demás métricas generadas por Amazon Fraud Detector para este modelo.

Para obtener más información sobre la puntuación de rendimiento del modelo y las métricas de rendimiento, consulte [Puntuaciones del modelo](model-scores.md) y[Métricas de rendimiento del modelo](training-performance-metrics.md).

Puedes esperar que todos tus modelos entrenados de Amazon Fraud Detector cuenten con métricas de rendimiento de detección de fraudes reales, similares a las métricas de este tutorial.

**Implemente un modelo**

Tras revisar las métricas de rendimiento de su modelo entrenado, impleméntelo y póngalo a disposición de Amazon Fraud Detector para generar predicciones de fraude. Para implementar el modelo entrenado, utilice la [UpdateModelVersionStatus](https://docs.aws.amazon.com//frauddetector/latest/api/API_UpdateModelVersionStatus.html)API. En el siguiente ejemplo, se usa para actualizar el estado de la versión del modelo a ACTIVO.

```
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'
)
```

### Paso 5: Cree el detector, los resultados, las reglas y la versión del detector
<a name="python-create-a-detector-outcome-rules-and-detector-version"></a>

Un detector contiene la lógica de detección, como los modelos y las reglas. Esta lógica es para un evento en particular que desee evaluar como fraude. Una regla es una condición que se especifica para indicar a Amazon Fraud Detector cómo interpretar los valores de las variables durante la predicción. Y el resultado es el resultado de una predicción de fraude. Un detector puede tener varias versiones y cada una de ellas puede tener el estado *BORRADOR*, *ACTIVO* o *INACTIVO*. La versión de un detector debe tener al menos una regla asociada. 

Utilice los siguientes códigos de ejemplo para crear el detector, las reglas, el resultado y publicar el detector. 

**Cree un detector**

En el siguiente ejemplo, la [PutDetector](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutDetector.html)API se utiliza para crear un `sample_detector` detector para el tipo de `sample_registration` evento.

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

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

**Crea resultados**

Se crean resultados para cada posible resultado de la predicción del fraude. En el siguiente ejemplo, la [PutOutcome](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutOutcome.html)API se utiliza para crear tres resultados: `verify_customer``review`, y`approve`. Estos resultados se asignan posteriormente a las reglas. 

```
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'
)
```

**Crea reglas**

La regla consta de una o más variables del conjunto de datos, una expresión lógica y uno o más resultados. 

En el siguiente ejemplo, la [CreateRule](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateRule.html)API se usa para crear tres reglas diferentes: `high_risk``medium_risk`, y`low_risk`. Cree expresiones de reglas para comparar el `sample_fraud_detection_model_insightscore` valor de la puntuación de rendimiento del modelo con varios umbrales. Esto sirve para determinar el nivel de riesgo de un evento y asignar el resultado que se definió en el paso anterior. 

```
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']
     )
```

**Cree una versión del detector**

La versión del detector define el modelo y las reglas que se utilizan para predecir el fraude.

En el siguiente ejemplo, la [CreateDetectorVersion](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateDetectorVersion.html)API se utiliza para crear una versión del detector. Para ello, proporciona detalles de la versión del modelo, reglas y un modo de ejecución de reglas FIRST\_MATCHED. Un modo de ejecución de reglas especifica la secuencia para evaluar las reglas. El modo de ejecución de reglas FIRST\_MATCHED especifica que las reglas se evalúan secuencialmente, de la primera a la última, y se detiene en la primera regla coincidente.

```
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'
)
```

### Paso 6: generar predicciones de fraude
<a name="python-generate-fraud-predictions"></a>

El último paso de este tutorial utiliza el detector `sample_detector` creado en el paso anterior para generar predicciones de fraude para cada tipo de `sample_registration` evento en tiempo real. El detector evalúa los datos de ejemplo que se cargan en Amazon S3. La respuesta incluye las puntuaciones de rendimiento del modelo, así como cualquier resultado asociado a las reglas coincidentes. 

En el siguiente ejemplo, la [GetEventPrediction](https://docs.aws.amazon.com//frauddetector/latest/api/API_GetEventPrediction.html)API se utiliza para proporcionar datos del registro de una sola cuenta con cada solicitud. Para este tutorial, toma los datos (dirección de correo electrónico y dirección IP) del archivo de datos de ejemplo de registro de la cuenta. Cada línea (fila) situada después de la línea del encabezado superior representa los datos de un único evento de registro de una cuenta. 

```
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'
}
)
```

Tras completar este tutorial, hizo lo siguiente:
+ Se cargó un conjunto de datos de eventos de ejemplo en Amazon S3.
+ Creó variables, entidades y etiquetas que se utilizan para crear y entrenar un modelo.
+ Creó y entrenó un modelo con el conjunto de datos de ejemplo.
+ He visto la puntuación de rendimiento del modelo y otras métricas de rendimiento generadas por Amazon Fraud Detector.
+ Implementó el modelo de detección de fraudes.
+ Creó un detector y agregó el modelo implementado.
+ Se agregaron las reglas, el orden de ejecución de las reglas y los resultados al detector.
+ Se creó la versión del detector.
+ Probé el detector proporcionando diferentes entradas y comprobando si las reglas y el orden de ejecución de las reglas funcionaban según lo esperado.

## (Opcional) Explore el Amazon Fraud Detector APIs con un cuaderno de Jupyter (iPython)
<a name="gs-jupyter-notebook"></a>

Para ver más ejemplos de cómo usar Amazon Fraud Detector APIs, consulta el [aws-fraud-detector-samples GitHub repositorio](https://github.com/aws-samples/aws-fraud-detector-samples). Los temas que tratan los cuadernos incluyen la creación de modelos y detectores con Amazon Fraud Detector APIs y la realización de solicitudes de predicción de fraudes por lotes mediante la `GetEventPrediction` API.