1. Visão geral
Neste laboratório, você vai usar o AI Platform Notebooks para criar e treinar um modelo para identificar transações fraudulentas, além de entender as previsões do modelo com o SDK do Explainable AI. A detecção de fraudes é um tipo de detecção de anomalias específico para serviços financeiros e apresenta alguns desafios interessantes para os modelos de ML: conjuntos de dados inerentemente desequilibrados e a necessidade de explicar os resultados de um modelo.
Conteúdo do laboratório
Você vai aprender a:
- Lide com conjuntos de dados desequilibrados
- Criar e avaliar um modelo de detecção de fraudes com o tf.keras no AI Platform Notebooks
- Use o SDK da Explainable AI no notebook para entender por que o modelo classificou transações como fraudulentas.
- Implantar o modelo no AI Platform com explicações e receber previsões e explicações sobre o modelo implantado
O custo total da execução deste laboratório no Google Cloud é de aproximadamente US$ 1.
2. Por que detectar fraudes?
A detecção de anomalias é uma boa opção para machine learning, já que muitas vezes é difícil escrever uma série de instruções baseadas em regras para identificar outliers nos dados. A detecção de fraudes é um tipo de detecção de anomalias e apresenta dois desafios interessantes quando se trata de machine learning:
- Conjuntos de dados muito desequilibrados: como anomalias são, bem, anomalias, não há muitas delas. O ML funciona melhor quando os conjuntos de dados estão equilibrados. Isso pode complicar quando os outliers constituem menos de 1% dos dados.
- Resultados que precisam de explicação: se você está procurando atividades fraudulentas, provavelmente quer saber por que um sistema sinalizou algo como fraudulento, em vez de apenas acreditar na palavra. As ferramentas de explicabilidade podem ajudar com isso.
3. Configurar o ambiente
Para executar este codelab, você vai precisar de um projeto do Google Cloud Platform com o faturamento ativado. Para criar um projeto, siga estas instruções.
Etapa 1: ativar a API Cloud AI Platform Models
Acesse a seção Modelos do AI Platform do console do Cloud e clique em "Ativar", caso essa opção ainda não esteja ativada.
Etapa 2: ativar a API Compute Engine
Acesse o Compute Engine e selecione Ativar, caso essa opção ainda não esteja ativada. Você vai precisar disso para criar sua instância de notebook.
Etapa 3: criar uma instância de Notebooks no AI Platform
Acesse a seção de Notebooks do AI Platform do console do Cloud e clique em Nova instância. Em seguida, selecione o tipo de instância TensorFlow Enterprise 2.1 sem GPUs:
Use as opções padrão e clique em Criar. Depois que a instância for criada, selecione Abrir JupyterLab:
Ao abrir a instância, selecione o notebook Python 3 no acesso rápido:
Etapa 4: importar pacotes do Python
Crie uma célula e importe as bibliotecas que vamos usar neste codelab:
import itertools
import numpy as np
import pandas as pd
import tensorflow as tf
import json
import matplotlib as mpl
import matplotlib.pyplot as plt
import explainable_ai_sdk
from sklearn.utils import shuffle
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from explainable_ai_sdk.metadata.tf.v2 import SavedModelMetadataBuilder
4. Fazer o download e processar dados
Usaremos este conjunto de dados gerado sinteticamente do Kaggle para treinar nosso modelo. O conjunto de dados original inclui 6,3 milhões de linhas, sendo que 8 mil são transações fraudulentas, o que representa apenas 0,1% de todo o conjunto de dados.
Etapa 1: faça o download do conjunto de dados do Kaggle e leia com o Pandas
Disponibilizamos o conjunto de dados do Kaggle para você no Google Cloud Storage. É possível fazer o download dele executando o seguinte comando gsutil no seu notebook do Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Em seguida, leia o conjunto de dados como um DataFrame do Pandas e visualize-o:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
A visualização vai ficar assim:
Etapa 2: contabilização de dados desequilibrados
Como mencionado acima, no momento o conjunto de dados contém 99,9% de exemplos não fraudulentos. Se treinarmos um modelo com os dados no estado em que se encontram, ele provavelmente atingirá 99,9% de acurácia ao supor que nenhuma transação é fraudulenta simplesmente porque 99,9% dos dados são casos não fraudulentos.
Há algumas abordagens diferentes para lidar com dados desequilibrados. Aqui, usaremos uma técnica chamada downsample. Redução de amostragem significa usar apenas uma pequena porcentagem da classe majoritária no treinamento. Nesse caso, o termo "não é fraude" é a classe majoritária, porque representa 99,9% dos dados.
Para reduzir o número de amostras do nosso conjunto de dados, vamos pegar todos os cerca de 8 mil exemplos fraudulentos e uma amostra aleatória de cerca de 31 mil casos não fraudulentos. Dessa forma, o conjunto de dados resultante terá 25% de casos de fraude, em comparação aos 0,1% que tínhamos antes.
Primeiro, divida os dados em dois DataFrames, um para fraude e outro para não fraude (vamos usar isso mais tarde no codelab quando implantarmos nosso modelo):
fraud = data[data['isFraud'] == 1]
not_fraud = data[data['isFraud'] == 0]
Em seguida, pegue uma amostra aleatória dos casos não fraudulentos. Estamos usando 0,005% porque isso nos dará uma divisão de 25 horas entre fraudes e transações não fraudulentas. Com isso, é possível reunir e embaralhar os dados. Para simplificar, também removeremos algumas colunas que não serão usadas no treinamento:
# Take a random sample of non fraud rows
not_fraud_sample = not_fraud.sample(random_state=2, frac=.005)
# Put it back together and shuffle
df = pd.concat([not_fraud_sample,fraud])
df = shuffle(df, random_state=2)
# Remove a few columns (isFraud is the label column we'll use, not isFlaggedFraud)
df = df.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])
# Preview the updated dataset
df.head()
Agora temos um conjunto de dados muito mais equilibrado. No entanto, se notarmos que nosso modelo está convergindo em torno de cerca de 75% de precisão, há uma boa chance de ele estar adivinhando "não fraude" em todos os casos.
Etapa 3: dividir os dados em conjuntos de treinamento e teste
A última coisa a fazer antes de criar o modelo é dividir os dados. Usaremos uma divisão de teste de treinamento 80/20:
train_test_split = int(len(df) * .8)
train_set = df[:train_test_split]
test_set = df[train_test_split:]
train_labels = train_set.pop('isFraud')
test_labels = test_set.pop('isFraud')
*E. A. Lopez-Rojas , A. Elmir e S. Axelsson. "PaySim: um simulador financeiro de dinheiro móvel para detecção de fraudes". In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Chipre. 2016
5. Criar, treinar e avaliar um modelo tf.keras
Vamos criar usando a API tf.keras do TensorFlow. O código do modelo nesta seção é baseado neste tutorial da documentação do TensorFlow. Primeiro, normalizaremos os dados. Depois, criaremos e treinaremos nosso modelo, usando o parâmetro class_weight para considerar o desequilíbrio de dados restante.
Etapa 1: normalizar os dados
Ao treinar um modelo com dados numéricos, é importante normalizar os dados, especialmente se cada coluna estiver em um intervalo diferente. Isso pode ajudar a evitar que a perda exploda durante o treinamento. Podemos normalizar nossos dados com o seguinte:
scaler = StandardScaler()
train_set = scaler.fit_transform(train_set) # Only normalize on the train set
test_set = scaler.transform(test_set)
# clip() ensures all values fall within the range [-5,5]
# useful if any outliers remain after normalizing
train_set = np.clip(train_set, -5, 5)
test_set = np.clip(test_set, -5, 5)
Em seguida, vamos visualizar nossos dados normalizados:
train_set
Etapa 2: determinar pesos de classe
Ao reduzir a amostragem dos dados, ainda queríamos manter um subconjunto de transações não fraudulentas para não perder informações sobre essas transações. Por isso, não conseguimos equilibrar os dados perfeitamente. Como o conjunto de dados ainda está desequilibrado, e nós nos preocupamos mais em identificar corretamente transações fraudulentas, queremos que nosso modelo dê mais peso a exemplos fraudulentos no conjunto de dados.
O parâmetro class_weight do Keras permite especificar exatamente o peso dos exemplos de cada classe, com base na frequência com que elas ocorrem no conjunto de dados:
weight_for_non_fraud = 1.0 / df['isFraud'].value_counts()[0]
weight_for_fraud = 1.0 / df['isFraud'].value_counts()[1]
class_weight = {0: weight_for_non_fraud, 1: weight_for_fraud}
Usaremos essa variável quando treinarmos nosso modelo na próxima etapa.
Etapa 3: treinar e avaliar o modelo
Vamos criar o modelo usando a API Keras Sequential Model, que permite definir o modelo como uma pilha de camadas. Há diversas métricas que vamos rastrear durante o treinamento, o que vai nos ajudar a entender o desempenho do modelo em cada classe do conjunto de dados.
METRICS = [
keras.metrics.TruePositives(name='tp'),
keras.metrics.FalsePositives(name='fp'),
keras.metrics.TrueNegatives(name='tn'),
keras.metrics.FalseNegatives(name='fn'),
keras.metrics.BinaryAccuracy(name='accuracy'),
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
def make_model(metrics = METRICS):
model = keras.Sequential([
keras.layers.Dense(
16, activation='relu',
input_shape=(train_set.shape[-1],)),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid'),
])
model.compile(
optimizer=keras.optimizers.Adam(lr=1e-3),
loss=keras.losses.BinaryCrossentropy(),
metrics=metrics)
return model
Em seguida, definiremos algumas variáveis globais para uso durante o treinamento, juntamente com alguns parâmetros de parada antecipada.
EPOCHS = 100
BATCH_SIZE = 512
early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_auc',
verbose=1,
patience=10,
mode='max',
restore_best_weights=True)
Por fim, vamos chamar a função definida acima para criar nosso modelo:
model = make_model()
model.summary()
É possível treinar o modelo com o método fit(), transmitindo os parâmetros definidos acima:
results = model.fit(
train_set,
train_labels,
batch_size=BATCH_SIZE,
epochs=EPOCHS,
callbacks = [early_stopping],
validation_data=(test_set, test_labels),
class_weight=class_weight)
O treinamento levará alguns minutos para ser executado.
Etapa 4: visualizar as métricas do modelo
Agora que temos um modelo treinado, vamos conferir o desempenho dele traçando várias métricas ao longo dos períodos de treinamento:
mpl.rcParams['figure.figsize'] = (12, 10)
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
def plot_metrics(history):
metrics = ['loss', 'auc', 'precision', 'recall']
for n, metric in enumerate(metrics):
name = metric.replace("_"," ").capitalize()
plt.subplot(2,2,n+1)
plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')
plt.plot(history.epoch, history.history['val_'+metric],
color=colors[0], linestyle="--", label='Val')
plt.xlabel('Epoch')
plt.ylabel(name)
if metric == 'loss':
plt.ylim([0, plt.ylim()[1]])
elif metric == 'auc':
plt.ylim([0.8,1])
else:
plt.ylim([0,1])
plt.legend()
plot_metrics(results)
Seus gráficos devem ser semelhantes aos seguintes (mas não serão exatamente os mesmos):
Etapa 5: imprimir uma matriz de confusão
Uma matriz de confusão é uma boa maneira de visualizar o desempenho do nosso modelo em todo o conjunto de dados de teste. Para cada classe, isso vai mostrar a porcentagem de exemplos de teste que nosso modelo previu corretamente e incorretamente. O Scikit Learn possui alguns utilitários para criar e traçar matrizes de confusão que serão usadas aqui.
No início do nosso notebook, importamos o utilitário confusion_matrix. Para usá-lo, primeiro vamos criar uma lista de previsões do nosso modelo. Aqui, arredondaremos os valores retornados do nosso modelo para que essa lista corresponda à nossa lista de rótulos de informações empíricas:
predicted = model.predict(test_set)
y_pred = []
for i in predicted.tolist():
y_pred.append(int(round(i[0])))
Agora está tudo pronto para alimentar o método confusion_matrix com nossos rótulos de informações empíricas:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Isso nos mostra os números absolutos das previsões corretas e incorretas do modelo no conjunto de teste. O número no canto superior esquerdo mostra quantos exemplos do nosso teste definiram que o modelo previu corretamente como não fraudulento. O número no canto inferior direito mostra quantos dados foram previstos corretamente como fraudulentos (esse número é importante para nós). Ele previu corretamente a maioria das amostras para cada classe.
Para facilitar a visualização, adaptamos a função plot_confusion_matrix dos documentos do Scikit Learn. Defina essa função aqui:
def plot_confusion_matrix(cm, classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
if normalize:
cm = np.round(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], 3)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
E criar o gráfico passando os dados do nosso modelo. Estamos definindo normalize como True aqui para que a matriz de confusão mostre o número de previsões corretas e incorretas em porcentagens:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Você vai ver algo assim (os números exatos podem variar):
Aqui podemos ver que o modelo previu corretamente cerca de 85% das 1.594 transações fraudulentas do conjunto de testes. O foco deste laboratório não é a qualidade do modelo. Se você estiver implantando um modelo de detecção de fraudes na produção, provavelmente vai querer mais de 85% de precisão na classe de fraude. O objetivo deste laboratório é apresentar as ferramentas para explicar modelos treinados em conjuntos de dados desequilibrados.
Em seguida, vamos usar o SDK do Explainable AI para entender em quais recursos nosso modelo depende para fazer essas previsões.
6. Como usar o SDK do Explainable AI
O SDK da Explainable AI fornece métodos utilitários para receber explicações sobre seu modelo. Ela vem pré-instalada nas instâncias do notebook da AI Platform do Tensorflow. Ela foi importada para o notebook no início do laboratório. Com o SDK, é possível receber atribuições de recursos do modelo dentro da instância do notebook, o que significa que não precisamos implantar o modelo na nuvem para usá-lo.
Nesta seção, vamos exportar o modelo que acabamos de treinar como um SavedModel do Tensorflow e apontar o SDK para os recursos de modelo salvos para receber explicações.
Etapa 1: exportar o modelo treinado
Primeiro, vamos salvar o modelo em um diretório na instância do notebook:
model_dir = 'fraud_model'
tf.saved_model.save(model, model_dir)
Ao atualizar a visualização de pastas na barra lateral esquerda do notebook, você verá um novo diretório chamado fraud_model/ criado.
Etapa 2: receber metadados de explicação com o SDK
Em seguida, vamos apontar o SDK do Explainable AI para esse diretório. Isso vai gerar metadados necessários para conseguir explicações do modelo. O método get_metadata() mostra os metadados que o SDK infere do seu modelo, como nomes de entrada:
model_builder = SavedModelMetadataBuilder(model_dir)
metadata = model_builder.get_metadata()
print(metadata)
A explicabilidade nos ajuda a responder à pergunta: "Por que nosso modelo achou que isso era uma fraude?"
Etapa 3: especificar o valor de referência do modelo
Para dados tabulares, o serviço Explainable AI funciona retornando valores de atribuição para cada atributo. Esses valores indicam quanto um determinado atributo afetou a previsão. Digamos que o valor de uma transação específica fez com que nosso modelo aumentasse a probabilidade de fraude prevista em 0,2%. Você pode estar pensando "0,2% em relação ao quê??". Isso nos leva ao conceito de linha de base.
A linha de base do nosso modelo é basicamente com o que ele está comparando. Selecionamos o valor do valor de referência para cada atributo no modelo. Consequentemente, a previsão do valor de referência se torna o valor previsto pelo modelo quando os atributos são definidos no valor de referência.
A escolha de um valor de referência depende da tarefa de previsão que você está resolvendo. Para atributos numéricos, é comum usar o valor médio de cada atributo do conjunto de dados como a linha de base. No entanto, no caso de detecção de fraudes, isso não é exatamente o que queremos. Nossa maior preocupação é explicar os casos em que o modelo rotula uma transação como fraudulenta. Isso significa que o caso de referência que queremos comparar são transações não fraudulentas.
Para isso, usaremos os valores médios das transações não fraudulentas em nosso conjunto de dados como referência. Podemos conseguir a mediana usando o DataFrame not_fraud_sample que extraímos acima e dimensionando-o para corresponder às entradas esperadas do nosso modelo:
not_fraud_sample = not_fraud_sample.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud', 'isFraud'])
baseline = scaler.transform(not_fraud_sample.values)
baseline = np.clip(baseline, -5, 5)
baseline_values = np.median(baseline, axis=0)
Não precisamos especificar um valor de referência. Caso contrário, o SDK vai usar 0 como o valor de referência para cada valor de entrada esperado pelo modelo. Em nosso caso de uso de detecção de fraudes, faz sentido especificar um valor de referência, que faremos a seguir:
input_name = list(metadata['inputs'])[0]
model_builder.set_numeric_metadata(input_name, input_baselines=[baseline_values.tolist()], index_feature_mapping=df.columns.tolist()[:6])
model_builder.save_metadata(model_dir)
Executar o método save_metadata() acima criou um arquivo no diretório do modelo chamado explanation_metadata.json. No seu notebook, acesse o diretório fraud_model/ para confirmar se o arquivo foi criado. Ele contém metadados que o SDK vai usar para gerar atribuições de recursos.
Etapa 4: receber explicações do modelo
Agora estamos prontos para conferir atribuições de atributos em exemplos individuais. Para isso, primeiro criaremos uma referência local para o nosso modelo usando o SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Em seguida, vamos fazer previsões e explicações sobre nosso modelo com base em uma transação de exemplo que precisa ser classificada como fraudulenta:
fraud_example = [0.722,0.139,-0.114,-0.258,-0.271,-0.305]
response = local_model.explain([{input_name: fraud_example}])
response[0].visualize_attributions()
Essa execução cria uma visualização semelhante a esta:
Neste exemplo, o saldo inicial da conta antes da transação foi o maior indicador de fraude, elevando a previsão do nosso modelo do valor de referência para mais de 0,5. O valor da transação, o saldo resultante na conta de destino e a taxa de passos foram os próximos indicadores mais significativos. No conjunto de dados, a "etapa" representa uma unidade de tempo (1 etapa equivale a 1 hora). Os valores de atribuição também podem ser negativos.
O "erro de aproximação" que está impresso acima das visualizações permite que você saiba o quanto você pode confiar na explicação. Geralmente, um erro acima de 5% significa que não é possível confiar nas atribuições de recursos. Lembre-se de que suas explicações são tão boas quanto os dados de treinamento e o modelo que você usou. Melhorar os dados de treinamento, o modelo ou tentar um valor de referência de modelo diferente pode diminuir o erro de aproximação.
Também é possível diminuir esse erro aumentando o número de etapas usadas no método de explicação. É possível mudar isso com o SDK adicionando um parâmetro path_count à sua configuração de explicação (o padrão é 10 se você não especificar):
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig(path_count=20)
)
É possível fazer muito mais com a Explainable AI neste modelo. Algumas ideias incluem:
- Como enviar muitos exemplos ao nosso modelo e calcular a média dos valores de atribuição para saber se determinados recursos são mais importantes no geral. Poderíamos usar isso para melhorar nosso modelo e potencialmente remover recursos que não são importantes
- Encontrar falsos positivos que nosso modelo sinaliza como fraude, mas não são transações fraudulentas e analisar os valores de atribuição deles
- Use um valor de referência diferente e confira como isso afeta os valores de atribuição
Parabéns! 🎉
Você aprendeu a contabilizar dados desequilibrados, treinar um modelo do TensorFlow para detectar transações fraudulentas e usar o SDK do Explainable AI para ver em quais atributos seu modelo mais depende para fazer previsões individuais. Se quiser, pode parar aqui. O uso do SDK em um notebook visa simplificar o processo de desenvolvimento do modelo, fornecendo acesso a explicações antes da implantação de um modelo. É provável que, depois de criar um modelo que atenda às suas necessidades, você queira implantá-lo para receber previsões em grande escala. Se for seu caso, siga para a próxima etapa opcional. Quando terminar, pule para a etapa de Limpeza.
7. Opcional: implantar o modelo no AI Platform Prediction
Nesta etapa, você aprenderá a implantar seu modelo no AI Platform Prediction.
Etapa 1: copiar o diretório do modelo salvo em um bucket do Cloud Storage
Com as etapas do SDK executadas anteriormente, você tem tudo o que precisa para implantar seu modelo no AI Platform. Para se preparar para a implantação, você precisará colocar os recursos do SavedModel e os metadados de explicação em um bucket do Cloud Storage que o serviço do Explainable AI possa ler.
Para isso, vamos definir algumas variáveis de ambiente. Preencha os valores abaixo com o nome do seu projeto do Google Cloud e do bucket que você quer criar (precisa ser globalmente exclusivo).
# Update these to your own GCP project and model
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
Agora estamos prontos para criar um bucket de armazenamento para armazenar os recursos do modelo do TensorFlow exportado. Vamos apontar o AI Platform para esse bucket quando implantarmos o modelo.
Execute este comando gsutil no seu notebook para criar um bucket:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Depois copie o diretório local do modelo para esse bucket:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Etapa 2: implantar o modelo
Em seguida, definiremos algumas variáveis que usaremos em nossos comandos de implantação:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
É possível criar o modelo com o seguinte comando gcloud:
!gcloud ai-platform models create $MODEL --region=us-central1
Agora estamos prontos para implantar a primeira versão desse modelo com a gcloud. A implantação da versão vai levar de 5 a 10 minutos:
!gcloud beta ai-platform versions create $VERSION \
--model $MODEL \
--origin $model_path \
--runtime-version 2.1 \
--framework TENSORFLOW \
--python-version 3.7 \
--machine-type n1-standard-4 \
--explanation-method 'sampled-shapley' \
--num-paths 10 \
--region=us-central1
Na sinalização origin, transmitimos o local do Cloud Storage do modelo salvo e do arquivo de metadados. Atualmente, a Explainable AI tem dois métodos de explicação disponíveis para modelos tabulares. Estamos usando o Sampled Shapley. O parâmetro num-paths indica o número de caminhos amostrados para cada recurso de entrada. Geralmente, quanto mais complexo o modelo, mais etapas de aproximação são necessárias para chegar a uma convergência razoável.
Para confirmar se o modelo foi implantado corretamente, execute o seguinte comando gcloud:
!gcloud ai-platform versions describe $VERSION --model $MODEL --region=us-central1
O estado precisa ser READY.
Etapa 3: receber previsões e explicações sobre o modelo implantado
Para fins de explicabilidade, o mais importante é explicar os casos em que o modelo prevê fraude. Vamos enviar cinco exemplos de teste ao nosso modelo que são todas transações fraudulentas.
Vamos usar a CLI do Google Cloud para receber previsões. Execute o código a seguir para conseguir os índices de todos os exemplos de fraude do nosso conjunto de teste:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Em seguida, salvaremos cinco exemplos no formato esperado pelo modelo e os gravaremos em um arquivo:
num_test_examples = 5
instances = []
for i in range(num_test_examples):
ex = test_set[fraud_indices[i]]
instances.append({input_name: ex.tolist()})
with open('prediction.json', 'a') as outputfile:
json.dump({"instances": instances}, outputfile)
Podemos enviar estes cinco exemplos para o modelo usando a gcloud:
!gcloud beta ai-platform explain \
--model=$MODEL \
--version=$VERSION \
--region='us-central1' \
--json-request=prediction.json
No JSON de resposta, você verá os valores de atribuição de cada recurso nesses exemplos. A chave example_score de cada exemplo inclui a previsão do modelo. Neste caso, a probabilidade percentual de que uma transação específica seja fraudulenta.
8. Limpeza
Se você quiser continuar usando este notebook, é recomendado que você o desative quando não estiver em uso. A partir da IU de Notebooks no Console do Cloud, selecione o notebook e depois clique em Parar:
Se quiser excluir todos os recursos criados neste laboratório, basta excluir a instância do notebook em vez de interrompê-la.
Usando o menu de navegação do console do Cloud, acesse "Storage" e exclua os dois buckets que você criou para armazenar os recursos do modelo.