Exemplos de casos de uso Pré-requisitos Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift Etapa 2: Criar o modelo de machine learning Etapa 3: Executar previsões com o modelo Tópicos relacionados da

Tutorial: Como criar modelos de rotatividade de clientes

Neste tutorial, você usará o Amazon Redshift ML para criar um modelo de rotatividade de clientes com o comando CREATE MODEL e executar consultas de previsão para cenários de usuários. Em seguida, você implementa consultas usando a função SQL gerada pelo comando CREATE MODEL.

Você pode usar um comando CREATE MODEL simples para exportar dados de treinamento, treinar um modelo, importar o modelo e preparar uma função de previsão do Amazon Redshift. Use a instrução CREATE MODEL para especificar dados de treinamento como uma tabela ou instrução SELECT.

Esse exemplo usa informações históricas para construir um modelo de machine learning de rotatividade de clientes de uma operadora de telefonia móvel. Primeiro, o SageMaker treina e, em seguida, testa o modelo de machine learning usando as informações de perfil de um cliente arbitrário. Após a validação do modelo, o Amazon SageMaker implanta o modelo e a função de previsão no Amazon Redshift. Você pode usar a função de previsão para prever se um cliente vai se desligar ou não.

Exemplos de casos de uso

Você pode resolver outros problemas de classificação binária usando o Amazon Redshift ML, como prever se é possível ou não fechar um lead de vendas. Você também pode prever se uma transação financeira é fraudulenta ou não.

Tarefas

Pré-requisitos
Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
Etapa 2: Criar o modelo de machine learning
Etapa 3: Executar previsões com o modelo

Pré-requisitos

Para concluir as etapas neste tutorial, você precisa atender aos seguintes pré-requisitos:

Você deve configurar um cluster do Amazon Redshift para o Amazon Redshift ML. Para isso, use a documentação Definir cluster e configuração para administração do Amazon Redshift ML.
O cluster do Amazon Redshift que você usa para criar o modelo e o bucket do Amazon S3 usado para preparar os dados de treinamento e os artefatos do modelo devem estar na mesma região da AWS.
Para baixar os comandos SQL e o conjunto de dados de exemplo usados nessa documentação, siga um destes procedimentos:
- Baixe os Comandos SQL, o Arquivo de atividade do cliente e o Arquivo Abalone.
- Usando a AWS CLI para Amazon S3, execute o comando a seguir. Você pode usar seu próprio caminho de destino.
```
aws s3 cp s3://redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql </target/path>
aws s3 cp s3://redshift-downloads/redshift-ml/customer_activity/customer_activity.csv </target/path>
aws s3 cp s3://redshift-downloads/redshift-ml/abalone_xgb/abalone_xgb.csv </target/path>
```

Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift

Use o editor de consultas v2 do Amazon Redshift para editar e executar consultas e visualizar resultados.

A execução das consultas a seguir cria um perfil chamado customer_activity e ingere o conjunto de dados de exemplo do Amazon S3.


DROP TABLE IF EXISTS customer_activity;

CREATE TABLE customer_activity (
state varchar(2),
account_length int,
area_code int,
phone varchar(8),
intl_plan varchar(3),
vMail_plan varchar(3),
vMail_message int,
day_mins float,
day_calls int,
day_charge float,
total_charge float,
eve_mins float,
eve_calls int,
eve_charge float,
night_mins float,
night_calls int,
night_charge float,
intl_mins float,
intl_calls int,
intl_charge float,
cust_serv_calls int,
churn varchar(6),
record_date date
);

COPY customer_activity
FROM 's3://redshift-downloads/redshift-ml/customer_activity/'
REGION 'us-east-1' IAM_ROLE default
FORMAT AS CSV IGNOREHEADER 1;

Etapa 2: Criar o modelo de machine learning

A rotatividade é nossa entrada de destino nesse modelo. Todas as outras entradas para o modelo são atributos que ajudam a criar uma função para prever a rotatividade.

O exemplo a seguir usa a operação CREATE MODEL para fornecer um modelo que prevê se um cliente estará ativo, usando entradas como idade, código postal, gastos e casos do cliente. No exemplo a seguir, substitua amzn-s3-demo-bucket por seu próprio bucket do Amazon S3.


CREATE MODEL customer_churn_auto_model
FROM
    (
      SELECT state,
             account_length,
             area_code,
             total_charge/account_length AS average_daily_spend,
             cust_serv_calls/account_length AS average_daily_cases,
             churn
      FROM customer_activity
      WHERE  record_date < '2020-01-01'
     )
TARGET churn FUNCTION ml_fn_customer_churn_auto
IAM_ROLE default SETTINGS (
  S3_BUCKET 'amzn-s3-demo-bucket'
);

A consulta SELECT no exemplo anterior cria os dados de treinamento. A cláusula TARGET especifica qual coluna é o “rótulo” de machine learning que CREATE MODEL usa para aprender a prever. A coluna de destino “rotatividade” indica se o cliente ainda tem uma associação ativa ou suspendeu a associação. O campo S3_BUCKET é o nome do bucket do Amazon S3 que você criou anteriormente. O bucket do Amazon S3 é usado para compartilhar dados de treinamento e artefatos entre o Amazon Redshift e o Amazon SageMaker. As colunas restantes são os recursos que são usados para a previsão.

Para obter um resumo da sintaxe e dos recursos de um caso de uso simples do comando CREATE MODEL, consulte Simple CREATE MODEL (CREATE MODEL simples).

Adicionar permissões para criptografia do lado do servidor (opcional)

Por padrão, o Amazon Redshift usa o Amazon SageMaker Autopilot para treinamento. Observe, especificamente, que o Amazon Redshift exporta os dados de treinamento com segurança para o bucket do Amazon S3 especificado pelo cliente. Se você não especificar um KMS_KEY_ID, os dados serão criptografados usando a criptografia do lado do servidor SSE-S3 por padrão.

Se sua entrada for criptografada usando a criptografia do lado do servidor com uma chave gerenciada pelo AWS KMS (SSE-KMS), adicione as seguintes permissões:


{
    "Effect": "Allow",
    "Action": [
    "kms:Encrypt"
    "kms:Decrypt"
    ]
}

Para obter mais informações sobre as funções do Amazon SageMaker, consulte Amazon SageMaker roles (Funções do Amazon SageMaker) no Guia do desenvolvedor do Amazon SageMaker.

Conferir o status do modelo de treinamento (opcional)

Você pode usar o comando SHOW MODEL para saber quando o modelo está pronto.

Use a operação a seguir para verificar o status do modelo.


SHOW MODEL customer_churn_auto_model;

Veja a seguir um exemplo de saída da operação anterior.


+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
|           Key            |                                                                             Value                                                                             |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
|        Model Name        |                                                                   customer_churn_auto_model                                                                   |
|       Schema Name        |                                                                            public                                                                             |
|          Owner           |                                                                            awsuser                                                                            |
|      Creation Time       |                                                                   Tue, 14.06.2022 17:15:52                                                                    |
|       Model State        |                                                                           TRAINING                                                                            |
|                          |                                                                                                                                                               |
|      TRAINING DATA:      |                                                                                                                                                               |
|          Query           | SELECT STATE, ACCOUNT_LENGTH, AREA_CODE, TOTAL_CHARGE / ACCOUNT_LENGTH AS AVERAGE_DAILY_SPEND, CUST_SERV_CALLS / ACCOUNT_LENGTH AS AVERAGE_DAILY_CASES, CHURN |
|                          |                                                                    FROM CUSTOMER_ACTIVITY                                                                     |
|                          |                                                               WHERE RECORD_DATE < '2020-01-01'                                                                |
|      Target Column       |                                                                             CHURN                                                                             |
|                          |                                                                                                                                                               |
|       PARAMETERS:        |                                                                                                                                                               |
|        Model Type        |                                                                             auto                                                                              |
|       Problem Type       |                                                                                                                                                               |
|        Objective         |                                                                                                                                                               |
|     AutoML Job Name      |                                                                redshiftml-20220614171552640901                                                                |
|      Function Name       |                                                                   ml_fn_customer_churn_auto                                                                   |
|   Function Parameters    |                                            state account_length area_code average_daily_spend average_daily_cases                                             |
| Function Parameter Types |                                                                 varchar int4 int4 float8 int4                                                                 |
|         IAM Role         |                                                                     default-aws-iam-role                                                                      |
|        S3 Bucket         |                                                                        amzn-s3-demo-bucket                                                                     |
|       Max Runtime        |                                                                             5400                                                                              |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+

Ao concluir o treinamento do modelo, a variável model_state se tornará Model is Ready e a função de previsão se tornará disponível.

Etapa 3: Executar previsões com o modelo

Você pode usar instruções SQL para exibir as previsões feitas pelo respectivo modelo. Neste exemplo, a função de previsão criada pela operação CREATE MODEL é denominada ml_fn_customer_churn_auto. Os argumentos de entrada para a função de previsão correspondem aos tipos de recurso, como varchar para state e integer para account_length. A saída da função de previsão é do mesmo tipo que a coluna TARGET da instrução CREATE MODEL.

Como você treinou o modelo em dados anteriores a 1/1/2020, agora você usa a função de previsão no conjunto de testes. A consulta a seguir exibe as previsões sobre se os clientes cadastrados após 1.º/1/2020 passarão por rotatividade ou não.


SELECT
    phone,
    ml_fn_customer_churn_auto(
        state,
        account_length,
        area_code,
        total_charge / account_length,
        cust_serv_calls / account_length
    ) AS active
FROM
    customer_activity
WHERE
    record_date > '2020-01-01';

O exemplo a seguir usa a mesma função de previsão para um caso de uso diferente. Neste caso, o Amazon Redshift prevê a proporção de rotatividade e não rotatividade entre clientes de diferentes estados onde a data de registro é posterior a 1.º/1/2020.


WITH predicted AS (
    SELECT
        state,
        ml_fn_customer_churn_auto(
            state,
            account_length,
            area_code,
            total_charge / account_length,
            cust_serv_calls / account_length
        ) :: varchar(6) AS active
    FROM
        customer_activity
    WHERE
        record_date > '2020-01-01'
)
SELECT
    state,
    SUM(
        CASE
            WHEN active = 'True.' THEN 1
            ELSE 0
        END
    ) AS churners,
    SUM(
        CASE
            WHEN active = 'False.' THEN 1
            ELSE 0
        END
    ) AS nonchurners,
    COUNT(*) AS total_per_state
FROM
    predicted
GROUP BY
    state
ORDER BY
    state;

O exemplo a seguir usa a função de previsão para o caso de uso de previsão da porcentagem de clientes que se desligam em um estado. Neste caso, o Amazon Redshift prevê a porcentagem de rotatividade quando a data de registro é posterior a 1/1/2020.


WITH predicted AS (
    SELECT
        state,
        ml_fn_customer_churn_auto(
            state,
            account_length,
            area_code,
            total_charge / account_length,
            cust_serv_calls / account_length
        ) :: varchar(6) AS active
    FROM
        customer_activity
    WHERE
        record_date > '2020-01-01'
)
SELECT
    state,
    CAST((CAST((SUM(
        CASE
            WHEN active = 'True.' THEN 1
            ELSE 0
        END
    )) AS FLOAT) / CAST(COUNT(*) AS FLOAT)) AS DECIMAL (3, 2)) AS pct_churn,
    COUNT(*) AS total_customers_per_state
FROM
    predicted
GROUP BY
    state
ORDER BY
    3 DESC;

Tópicos relacionados da

Para obter mais informações sobre o Amazon Redshift ML, consulte a seguinte documentação:

Para obter mais informações sobre machine learning, consulte a seguinte documentação:

Visão geral do Machine Learning
Machine Learning para iniciantes e especialistas
What Is Fairness and Model Explainability for Machine Learning Predictions? (O que é equidade e explicabilidade de modelo para previsões de machine learning?)

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Tutoriais para o Amazon Redshift ML

Tutorial: Como criar modelos de inferência remota