Detecte transações fraudulentas usando machine learning com o Amazon SageMaker

As empresas podem perder bilhões de dólares a cada ano devido a usuários mal-intencionados e transações fraudulentas. À medida que mais e mais operações de negócios se movem on-line, fraudes e abusos em sistemas on-line também estão aumentando. Para combater a fraude online, muitas empresas têm usado sistemas de detecção de fraude baseados em regras.

No entanto, os sistemas tradicionais de detecção de fraudes contam com um conjunto de regras e filtros criados a mão por especialistas humanos. Os filtros muitas vezes podem ser frágeis e as regras podem não capturar todo o espectro de sinais fraudulentos. Além disso, enquanto os comportamentos fraudulentos estão em constante evolução, a natureza estática das regras e filtros predefinidos torna difícil manter e melhorar os sistemas tradicionais de detecção de fraudes de forma eficaz.

Neste post, mostramos como construir um sistema de detecção de fraudes de cartão de crédito dinâmico, auto-aprimorado e sustentável com aprendizado de máquina (ML) usando Amazon Sage Maker.

Como alternativa, se você estiver procurando por um serviço totalmente gerenciado para criar modelos personalizados de detecção de fraudes sem escrever código, recomendamos verificar Detector de fraude da Amazon. O Amazon Fraud Detector permite que clientes sem experiência em ML automatizem a criação de modelos de detecção de fraudes personalizados para seus dados, aproveitando mais de 20 anos de experiência em detecção de fraudes da AWS e Amazon.com.

Visão geral da solução

Esta solução cria o núcleo de um sistema de detecção de fraude de cartão de crédito usando o SageMaker. Começamos treinando um modelo de detecção de anomalia não supervisionada usando o algoritmo Floresta de corte aleatório (RCF). Em seguida, treinamos dois modelos de classificação supervisionada usando o algoritmo XGBoostName, um como modelo de linha de base e outro para fazer previsões, usando diferentes estratégias para lidar com o desequilíbrio extremo de classe nos dados. Por fim, treinamos um modelo ótimo de XGBoost com otimização de hiperparâmetros (HPO) para melhorar ainda mais o desempenho do modelo.

Para o conjunto de dados de amostra, usamos as transações de cartão de crédito públicas e anônimas conjunto de dados que foi originalmente lançado como parte de um pesquisa colaboração da Worldline e do Grupo de Aprendizado de Máquina da ULB (Université Libre de Bruxelas). No passo a passo, também discutimos como você pode personalizar a solução para usar seus próprios dados.

As saídas da solução são as seguintes:

• Um não supervisionado SageMaker RCF modelo. O modelo gera uma pontuação de anomalia para cada transação. Um valor de pontuação baixo indica que a transação é considerada normal (não fraudulenta). Um valor alto indica que a transação é fraudulenta. As definições de baixo e alto dependem da aplicação, mas a prática comum sugere que pontuações acima de três desvios padrão da pontuação média são consideradas anômalas.
• Um supervisionado SageMaker XGBoostName modelo treinado usando seu esquema de ponderação integrado para resolver o problema de dados altamente desequilibrados.
• Um modelo SageMaker XGBoost supervisionado treinado usando o Técnica de sobreamostragem de minoria sintética (SMOTE).
• Um modelo SageMaker XGBoost treinado com HPO.
• Previsões da probabilidade de cada transação ser fraudulenta. Se a probabilidade estimada de uma transação estiver acima de um limite, ela será classificada como fraudulenta.

Para demonstrar como você pode usar essa solução em suas infraestruturas de negócios existentes, também incluímos um exemplo de como fazer chamadas de API REST para o endpoint do modelo implantado, usando AWS Lambda para acionar os modelos RCF e XGBoost.

O diagrama a seguir ilustra a arquitetura da solução.

Pré-requisitos

Para experimentar a solução em sua própria conta, verifique se você tem o seguinte:

Quando a instância do Studio estiver pronta, você poderá iniciar o Studio e acessar o JumpStart. As soluções JumpStart não estão disponíveis em instâncias de notebook SageMaker e você não pode acessá-las por meio de APIs do SageMaker ou do Interface de linha de comando da AWS (AWSCL).

Lançar a solução

Para iniciar a solução, conclua as etapas a seguir:

1. Abra o JumpStart usando o iniciador do JumpStart no Iniciar seção ou escolhendo o ícone JumpStart na barra lateral esquerda.
2. Debaixo Soluções, escolha Detectar usuários e transações maliciosos para abrir a solução em outra aba do Studio.
   
3. Na guia solução, escolha Apresentação livro para lançar a solução.
   
   Os recursos da solução são provisionados e outra guia é aberta mostrando o andamento da implantação. Quando a implantação for concluída, um Abra o Notebook botão aparece.
4. Escolha Abra o Notebook para abrir o notebook da solução no Studio.
   

Investigue e processe os dados

O conjunto de dados padrão contém apenas recursos numéricos, porque os recursos originais foram transformados usando Análise de Componentes Principais (PCA) para proteger a privacidade do usuário. Como resultado, o conjunto de dados contém 28 componentes do PCA, V1–V28, e dois recursos que não foram transformados, Quantidade e Tempo. Valor refere-se ao valor da transação e Tempo são os segundos decorridos entre qualquer transação nos dados e a primeira transação.

A coluna Classe corresponde a se uma transação é fraudulenta ou não.

Podemos ver que a maioria não é fraudulenta, pois do total de 284,807 exemplos, apenas 492 (0.173%) são fraudulentos. Este é um caso de desequilíbrio de classe extremo, que é comum em cenários de detecção de fraude.

Em seguida, preparamos nossos dados para carregamento e treinamento. Dividimos os dados em um conjunto de treinamento e um conjunto de teste, usando o primeiro para treinar e o último para avaliar o desempenho do nosso modelo. É importante dividir os dados antes de aplicar qualquer técnica para aliviar o desequilíbrio de classe. Caso contrário, podemos vazar informações do conjunto de teste para o conjunto de trens e prejudicar o desempenho do modelo.

Se você quiser trazer seus próprios dados de treinamento, verifique se são dados tabulares no formato CSV, carregue os dados em um Serviço de armazenamento simples da Amazon (Amazon S3) e edite o caminho do objeto S3 no código do notebook.

Se seus dados incluem colunas categóricas com valores não numéricos, você precisa codificar esses valores (usando, por exemplo, OneHotEncoder do sklearn) porque o algoritmo XGBoost suporta apenas dados numéricos.

Treine um modelo Random Cut Forest não supervisionado

Em um cenário de detecção de fraude, geralmente temos muito poucos exemplos rotulados, e rotular a fraude pode levar muito tempo e esforço. Portanto, também queremos extrair informações dos dados não rotulados disponíveis. Fazemos isso usando um algoritmo de detecção de anomalias, aproveitando o alto desequilíbrio de dados que é comum em conjuntos de dados de detecção de fraudes.

A detecção de anomalias é uma forma de aprendizado não supervisionado em que tentamos identificar exemplos anômalos com base apenas em suas características de recursos. Random Cut Forest é um algoritmo de detecção de anomalias de última geração que é preciso e escalável. Com cada exemplo de dados, o RCF associa uma pontuação de anomalia.

Usamos o algoritmo RCF integrado do SageMaker para treinar um modelo de detecção de anomalias em nosso conjunto de dados de treinamento e, em seguida, fazer previsões em nosso conjunto de dados de teste.

Primeiro, examinamos e plotamos as pontuações de anomalia previstas para exemplos positivos (fraudulentos) e negativos (não fraudulentos) separadamente, porque os números de exemplos positivos e negativos diferem significativamente. Esperamos que os exemplos positivos (fraudulentos) tenham pontuações de anomalia relativamente altas, e os negativos (não fraudulentos) tenham pontuações de anomalia baixas. A partir dos histogramas, podemos ver os seguintes padrões:

• Quase metade dos exemplos positivos (histograma esquerdo) têm pontuações de anomalia superiores a 0.9, enquanto a maioria dos exemplos negativos (histograma direito) têm pontuações de anomalia inferiores a 0.85.
• O algoritmo de aprendizado não supervisionado RCF tem limitações para identificar exemplos fraudulentos e não fraudulentos com precisão. Isso ocorre porque nenhuma informação do rótulo é usada. Resolvemos esse problema coletando informações de rótulo e usando um algoritmo de aprendizado supervisionado em etapas posteriores.

Em seguida, assumimos um cenário mais real, onde classificamos cada exemplo de teste como positivo (fraudulento) ou negativo (não fraudulento) com base em sua pontuação de anomalia. Traçamos o histograma de pontuação para todos os exemplos de teste da seguinte forma, escolhendo uma pontuação de corte de 1.0 (com base no padrão mostrado no histograma) para classificação. Especificamente, se a pontuação de anomalia de um exemplo for menor ou igual a 1.0, ela será classificada como negativa (não fraudulenta). Caso contrário, o exemplo é classificado como positivo (fraudulento).

Por fim, comparamos o resultado da classificação com os rótulos de verdade e calculamos as métricas de avaliação. Como nosso conjunto de dados está desequilibrado, usamos as métricas de avaliação precisão equilibrada, Pontuação Kappa de Cohen, Pontuação F1 e ROC AUC, pois levam em consideração a frequência de cada classe nos dados. Para todas essas métricas, um valor maior indica um melhor desempenho preditivo. Observe que nesta etapa ainda não podemos calcular o ROC AUC, porque não há probabilidade estimada para classes positivas e negativas do modelo RCF em cada exemplo. Calculamos essa métrica em etapas posteriores usando algoritmos de aprendizado supervisionado.

.	FCR
Precisão equilibrada	0.560023
Kappa de Cohen	0.003917
F1	0.007082
ROC AUC	-

A partir desta etapa, podemos ver que o modelo não supervisionado já consegue alcançar alguma separação entre as classes, com maiores pontuações de anomalias correlacionadas com exemplos fraudulentos.

Treine um modelo XGBoost com o esquema de ponderação integrado

Depois de reunir uma quantidade adequada de dados de treinamento rotulados, podemos usar um algoritmo de aprendizado supervisionado para descobrir relacionamentos entre os recursos e as classes. Escolhemos o algoritmo XGBoost porque ele tem um histórico comprovado, é altamente escalável e pode lidar com dados ausentes. Precisamos lidar com o desequilíbrio de dados desta vez, caso contrário, a classe majoritária (os exemplos não fraudulentos ou negativos) dominará o aprendizado.

Treinamos e implantamos nosso primeiro modelo supervisionado usando o contêiner de algoritmo XGBoost integrado do SageMaker. Este é o nosso modelo básico. Para lidar com o desequilíbrio de dados, usamos o hiperparâmetro scale_pos_weight, que dimensiona os pesos dos exemplos de classe positivos em relação aos exemplos de classe negativos. Como o conjunto de dados é altamente distorcido, definimos esse hiperparâmetro com um valor conservador: sqrt(num_nonfraud/num_fraud).

Treinamos e implantamos o modelo da seguinte forma:

1. Recupere o URI do contêiner SageMaker XGBoost.
2. Defina os hiperparâmetros que queremos usar para o treinamento do modelo, incluindo aquele que mencionamos que trata do desequilíbrio de dados, scale_pos_weight.
3. Crie um estimador XGBoost e treine-o com nosso conjunto de dados de trem.
4. Implante o modelo XGBoost treinado em um endpoint gerenciado pelo SageMaker.
5. Avalie esse modelo de linha de base com nosso conjunto de dados de teste.

Em seguida, avaliamos nosso modelo com as mesmas quatro métricas mencionadas na última etapa. Desta vez, também podemos calcular a métrica ROC AUC.

.	FCR	XGBoostName
Precisão equilibrada	0.560023	0.847685
Kappa de Cohen	0.003917	0.743801
F1	0.007082	0.744186
ROC AUC	-	0.983515

Podemos ver que um método de aprendizado supervisionado XGBoost com o esquema de ponderação (usando o hiperparâmetro scale_pos_weight) alcança um desempenho significativamente melhor do que o método de aprendizado não supervisionado RCF. Ainda há espaço para melhorar o desempenho, no entanto. Em particular, aumentar a pontuação Kappa de Cohen acima de 0.8 seria geralmente muito favorável.

Além das métricas de valor único, também é útil observar as métricas que indicam o desempenho por classe. Por exemplo, a matriz de confusão, precisão por classe, recall e pontuação F1 podem fornecer mais informações sobre o desempenho do nosso modelo.

.	precisão	recordar	pontuação f1	ajuda
não fraude	1.00	1.00	1.00	28435
fraude	0.80	0.70	0.74	46

Continue enviando tráfego de teste para o endpoint via Lambda

Para demonstrar como usar nossos modelos em um sistema de produção, construímos uma API REST com Gateway de API da Amazon e uma função Lambda. Quando os aplicativos cliente enviam solicitações de inferência HTTP para a API REST, que aciona a função Lambda, que, por sua vez, invoca os endpoints do modelo RCF e XGBoost e retorna as previsões dos modelos. Você pode ler o código de função do Lambda e monitorar as invocações no console do Lambda.

Também criamos um script Python que faz solicitações de inferência HTTP para a API REST, com nossos dados de teste como dados de entrada. Para ver como isso foi feito, verifique o generate_endpoint_traffic.py arquivo no código-fonte da solução. As saídas de previsão são registradas em um bucket do S3 por meio de um Mangueira de incêndio de dados do Amazon Kinesis fluxo de entrega. Você pode encontrar o nome do bucket do S3 de destino no console do Kinesis Data Firehose e verificar os resultados da previsão no bucket do S3.

Treine um modelo XGBoost com a técnica de sobreamostragem SMOTE

Agora que temos um modelo de linha de base usando o XGBoost, podemos ver se as técnicas de amostragem projetadas especificamente para problemas desbalanceados podem melhorar o desempenho do modelo. Nós usamos Sobreamostragem de minoria sintética (SMOTE), que supera a classe minoritária interpolando novos pontos de dados entre os existentes.

As etapas são as seguintes:

1. Use SMOTE para superamostrar a classe minoritária (a classe fraudulenta) do nosso conjunto de dados de trem. O SMOTE supera a classe minoritária de cerca de 0.17 a 50%. Observe que este é um caso de superamostragem extrema da classe minoritária. Uma alternativa seria usar uma razão de reamostragem menor, como ter uma amostra de classe minoritária para cada sqrt(non_fraud/fraud) amostra majoritária, ou usando técnicas de reamostragem mais avançadas. Para mais opções de sobreamostragem, consulte Comparar amostradores de sobreamostragem.
2. Defina os hiperparâmetros para treinar o segundo XGBoost para que scale_pos_weight seja removido e os outros hiperparâmetros permaneçam os mesmos de quando treinando o modelo XGBoost de linha de base. Não precisamos mais lidar com o desequilíbrio de dados com esse hiperparâmetro, porque já fizemos isso com o SMOTE.
3. Treine o segundo modelo XGBoost com os novos hiperparâmetros no conjunto de dados de trem processado pelo SMOTE.
4. Implante o novo modelo XGBoost em um endpoint gerenciado pelo SageMaker.
5. Avalie o novo modelo com o conjunto de dados de teste.

Ao avaliar o novo modelo, podemos ver que com o SMOTE, o XGBoost alcança um melhor desempenho em precisão equilibrada, mas não nas pontuações Kappa e F1 de Cohen. A razão para isso é que o SMOTE superou tanto a classe de fraude que aumentou sua sobreposição no espaço de recursos com os casos não-fraude. Como o Kappa de Cohen dá mais peso a falsos positivos do que a precisão balanceada, a métrica cai significativamente, assim como a precisão e a pontuação F1 para casos de fraude.

.	FCR	XGBoostName	XGBoost SMOTE
Precisão equilibrada	0.560023	0.847685	0.912657
Kappa de Cohen	0.003917	0.743801	0.716463
F1	0.007082	0.744186	0.716981
ROC AUC	-	0.983515	0.967497

No entanto, podemos trazer de volta o equilíbrio entre as métricas ajustando o limite de classificação. Até agora, usamos 0.5 como limite para rotular se um ponto de dados é ou não fraudulento. Depois de experimentar diferentes limiares de 0.1 a 0.9, podemos ver que o Kappa de Cohen continua aumentando junto com o limiar, sem perda significativa na precisão balanceada.

Isso adiciona uma calibração útil ao nosso modelo. Podemos usar um limite baixo se não perder nenhum caso fraudulento (falsos negativos) for nossa prioridade, ou podemos aumentar o limite para minimizar o número de falsos positivos.

Treine um modelo XGBoost ideal com HPO

Nesta etapa, demonstramos como melhorar o desempenho do modelo treinando nosso terceiro modelo XGBoost com otimização de hiperparâmetros. Ao construir sistemas de ML complexos, explorar manualmente todas as combinações possíveis de valores de hiperparâmetros é impraticável. O recurso HPO no SageMaker pode acelerar sua produtividade experimentando muitas variações de um modelo em seu nome. Ele procura automaticamente o melhor modelo, concentrando-se nas combinações mais promissoras de valores de hiperparâmetros dentro dos intervalos especificados.

O processo HPO precisa de um conjunto de dados de validação, então primeiro dividimos ainda mais nossos dados de treinamento em conjuntos de dados de treinamento e validação usando amostragem estratificada. Para resolver o problema de desequilíbrio de dados, usamos o esquema de ponderação do XGBoost novamente, definindo o scale_pos_weight hiperparâmetro para sqrt(num_nonfraud/num_fraud).

Criamos um estimador XGBoost usando o contêiner de algoritmo XGBoost integrado do SageMaker e especificamos a métrica de avaliação objetiva e os intervalos de hiperparâmetros nos quais gostaríamos de experimentar. Com estes, criamos então um HiperparâmetroTuner e inicie o trabalho de ajuste HPO, que treina vários modelos em paralelo, procurando combinações ideais de hiperparâmetros.

Quando o trabalho de ajuste estiver concluído, podemos ver seu relatório de análise e inspecionar os hiperparâmetros de cada modelo, as informações do trabalho de treinamento e seu desempenho em relação à métrica de avaliação objetiva.

Em seguida, implantamos o melhor modelo e o avaliamos com nosso conjunto de dados de teste.

Avalie e compare todo o desempenho do modelo nos mesmos dados de teste

Agora temos os resultados da avaliação de todos os quatro modelos: RCF, XGBoost baseline, XGBoost com SMOTE e XGBoost com HPO. Vamos comparar o desempenho deles.

.	FCR	XGBoostName	XGBoost com SMOTE	XGBoost com HPO
Precisão equilibrada	0.560023	0.847685	0.912657	0.902156
Kappa de Cohen	0.003917	0.743801	0.716463	0.880778
F1	0.007082	0.744186	0.716981	0.880952
ROC AUC	-	0.983515	0.967497	0.981564

Podemos ver que o XGBoost com HPO alcança um desempenho ainda melhor do que com o método SMOTE. Em particular, as pontuações Kappa de Cohen e F1 estão acima de 0.8, indicando um ótimo desempenho do modelo.

limpar

Ao concluir esta solução, certifique-se de excluir todos os recursos indesejados da AWS para evitar cobranças não intencionais. No Excluir solução seção em sua guia de solução, escolha Excluir todos os recursos para excluir recursos criados automaticamente ao iniciar esta solução.

Alternativamente, você pode usar Formação da Nuvem AWS para excluir todos os recursos padrão criados automaticamente pela solução e pelo notebook. Para usar essa abordagem, no console do AWS CloudFormation, localize a pilha do CloudFormation cuja descrição contém detecção de fraude usando aprendizado de máquina e exclua-a. Esta é uma pilha pai, e optar por excluir esta pilha excluirá automaticamente as pilhas aninhadas.

Com qualquer uma das abordagens, você ainda precisa excluir manualmente quaisquer recursos extras que possa ter criado neste bloco de anotações. Alguns exemplos incluem buckets S3 extras (além do bucket padrão da solução), endpoints SageMaker extras (usando um nome personalizado) e Registro do Amazon Elastic Container (Amazon ECR).

Conclusão

Neste post, mostramos como construir o núcleo de um sistema de detecção de fraudes de cartão de crédito dinâmico, auto-aprimorado e sustentável usando ML com SageMaker. Construímos, treinamos e implantamos um modelo de detecção de anomalias RCF não supervisionado, um modelo XGBoost supervisionado como linha de base, outro modelo XGBoost supervisionado com SMOTE para resolver o problema de desequilíbrio de dados e um modelo XGBoost final otimizado com HPO. Discutimos como lidar com o desequilíbrio de dados e usar seus próprios dados na solução. Também incluímos um exemplo de implementação de API REST com API Gateway e Lambda para demonstrar como usar o sistema em sua infraestrutura de negócios existente.

Para experimentar você mesmo, abra Estúdio SageMaker e inicie a solução JumpStart. Para saber mais sobre a solução, confira seu Repositório GitHub.

---

Sobre os autores

Xiaoli Shen é arquiteto de soluções e membro da comunidade de campo técnico de aprendizado de máquina (TFC) da Amazon Web Services. Ela está focada em ajudar os clientes a arquitetar na nuvem e aproveitar os serviços da AWS para obter valor comercial. Antes de ingressar na AWS, ela foi líder de tecnologia e engenheira full-stack sênior na criação de sistemas distribuídos com uso intensivo de dados na nuvem.

Dr.Xin Huang é um cientista aplicado para algoritmos integrados Amazon SageMaker JumpStart e Amazon SageMaker. Ele se concentra no desenvolvimento de algoritmos de aprendizado de máquina escaláveis. Seus interesses de pesquisa estão na área de processamento de linguagem natural, aprendizado profundo explicável em dados tabulares e análise robusta de agrupamento não paramétrico de espaço-tempo. Ele publicou muitos artigos em conferências ACL, ICDM, KDD e Royal Statistical Society: Series A journal.

jainista vedante é um arquiteto de soluções especialista em IA/ML sênior, ajudando os clientes a obter valor do ecossistema de aprendizado de máquina na AWS. Antes de ingressar na AWS, a Vedant ocupou cargos de especialização em ML/Data Science em várias empresas, como Databricks, Hortonworks (agora Cloudera) e JP Morgan Chase. Fora de seu trabalho, Vedant é apaixonado por fazer música, usando a ciência para levar uma vida significativa e explorando a deliciosa culinária vegetariana de todo o mundo.