1. Visão geral
Neste laboratório, você vai usar os notebooks do AI Platform para criar e treinar um modelo de identificação de transações fraudulentas e entender as previsões do modelo com o SDK da IA explicável. A detecção de fraude é um tipo de detecção de anomalias específica para serviços financeiros e apresenta alguns desafios interessantes para 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:
- Processar conjuntos de dados desequilibrados
- Criar e avaliar um modelo de detecção de fraudes com o tf.keras nos Notebooks da AI Platform
- Use o SDK da IA explicável no Notebooks para entender por que o modelo classificou as transações como fraudulentas.
- Implante o modelo no AI Platform com explicações e receba prediçõ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 a detecção de fraudes?
A detecção de anomalias pode ser uma boa opção para o machine learning, já que geralmente é 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 as anomalias são, bem, anomalias, não há muitas delas. O aprendizado de máquina funciona melhor quando os conjuntos de dados são equilibrados. Por isso, as coisas podem ficar complicadas quando os outliers representam menos de 1% dos seus dados.
- Necessidade de explicar os resultados: se você estiver procurando atividades fraudulentas, provavelmente vai querer saber por que um sistema sinalizou algo como fraudulento em vez de apenas acreditar nele. 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", se ainda não tiver feito isso.
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 do AI Platform Notebooks
Acesse a seção AI Platform Notebooks 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. Quando a instância tiver sido criada, selecione Abrir o JupyterLab:
Ao abrir a instância, selecione o notebook Python 3 no menu inicial:
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
Vamos usar este conjunto de dados gerado sinteticamente do Kaggle para treinar nosso modelo. O conjunto de dados original inclui 6,3 milhões de linhas, 8 mil delas são transações fraudulentas, apenas 0,1% de todo o conjunto de dados.
Etapa 1: fazer o download do conjunto de dados do Kaggle e ler com o Pandas
Disponibilizamos o conjunto de dados do Kaggle para você no Google Cloud Storage. Para fazer o download, execute o seguinte comando gsutil no notebook do Jupyter:
!gsutil cp gs://financial_fraud_detection/fraud_data_kaggle.csv .
Em seguida, vamos ler o conjunto de dados como um DataFrame do Pandas e visualizar:
data = pd.read_csv('fraud_data_kaggle.csv')
data = data.drop(columns=['type'])
data.head()
A prévia vai mostrar algo 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, é provável que ele alcance 99,9% de acurácia ao adivinhar que toda transação não é fraudulenta, simplesmente porque 99,9% dos dados são casos não fraudulentos.
Há algumas abordagens diferentes para lidar com dados desequilibrados. Aqui, vamos usar uma técnica chamada subamostragem. A subamostragem significa usar apenas uma pequena porcentagem da classe majoritária no treinamento. Nesse caso, "não fraude" é a classe majoritária, já que representa 99,9% dos dados.
Para reduzir a amostragem do nosso conjunto de dados, vamos usar todos os cerca de 8 mil exemplos fraudulentos e uma amostra aleatória de cerca de 31 mil casos não fraudulentos. Assim, o conjunto de dados resultante terá 25% de casos de fraude, em comparação com os 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 ao implantar 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/75 de transações fraudulentas / não fraudulentas. Assim, você pode juntar os dados novamente e embaralhar. Para simplificar, também vamos remover algumas colunas que não serão usadas para 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 para uma acurácia de aproximadamente 75%, há uma boa chance de que ele esteja 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. Vamos usar uma divisão de treinamento e teste de 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, and S. Axelsson. "PaySim: A financial mobile money simulator for fraud detection". In: The 28th European Modeling and Simulation Symposium-EMSS, Larnaca, Cyprus. 2016
5. Criar, treinar e avaliar um modelo do 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, vamos normalizar os dados e, em seguida, criar e treinar nosso modelo usando o parâmetro class_weight para considerar o restante do desequilíbrio de dados.
Etapa 1: normalizar os dados
Ao treinar um modelo com dados numéricos, é importante normalizar os dados, principalmente se cada coluna estiver em um intervalo diferente. Isso ajuda a evitar a perda de explosão 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)
Agora, vamos visualizar os dados normalizados:
train_set
Etapa 2: determinar ponderações de classe
Ao fazer o downsampling dos dados, ainda queríamos manter um subconjunto das transações não fraudulentas para não perder informações sobre elas. Por isso, não deixamos os dados perfeitamente equilibrados. Como o conjunto de dados ainda não está balanceado e o mais importante é identificar corretamente as transações fraudulentas, queremos que nosso modelo dê mais peso aos exemplos fraudulentos no conjunto de dados.
O parâmetro class_weight do Keras permite especificar exatamente quanto peso queremos dar aos exemplos de cada classe, com base na frequência com que eles aparecem 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}
Vamos usar essa variável ao treinar nosso modelo na próxima etapa.
Etapa 3: treinar e avaliar o modelo
Vamos criar nosso modelo usando a API Keras Sequential Model, que permite definir o modelo como uma pilha de camadas. Vamos acompanhar várias métricas durante o treinamento para entender a performance 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, vamos definir algumas variáveis globais para uso durante o treinamento, além de 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()
Podemos treinar nosso 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 leva alguns minutos.
Etapa 4: visualizar métricas do modelo
Agora que temos um modelo treinado, vamos ver como ele se saiu ao representar várias métricas ao longo das nossas épocas 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 serão semelhantes a estes (mas não exatamente iguais):
Etapa 5: imprimir uma matriz de confusão
Uma matriz de confusão é uma boa maneira de visualizar o desempenho do modelo no conjunto de dados de teste. Para cada classe, ela mostra a porcentagem de exemplos de teste que nosso modelo previu corretamente e incorretamente. O scikit-learn tem algumas utilidades para criar e representar matrizes de confusão, que vamos usar aqui.
No início do notebook, importamos a utilidade confusion_matrix. Para usá-lo, primeiro vamos criar uma lista das previsões do nosso modelo. Aqui, vamos arredondar 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 estamos prontos para inserir isso no método confusion_matrix, junto com nossos rótulos de informações empíricas:
cm = confusion_matrix(test_labels.values, y_pred)
print(cm)
Isso mostra os números absolutos das previsões corretas e incorretas do nosso modelo no conjunto de teste. O número no canto superior esquerdo mostra quantos exemplos do nosso conjunto de teste o modelo previu corretamente como não fraudulentos. O número no canto inferior direito mostra quantas transações foram previstas corretamente como fraudulentas (esse é o número mais importante). É possível notar que ele previu a maioria das amostras corretamente para cada classe.
Para facilitar a visualização, adaptamos a função plot_confusion_matrix da documentação 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 crie o gráfico transmitindo os dados do nosso modelo. Estamos definindo normalize como True para que a matriz de confusão mostre o número de previsões corretas e incorretas como porcentagens:
classes = ['not fraud', 'fraud']
plot_confusion_matrix(cm, classes, normalize=True)
Você vai ver algo parecido com isto (os números exatos vão variar):
Aqui,podemos ver que nosso modelo previu corretamente cerca de 85% das 1.594 transações fraudulentas do nosso conjunto de teste. Neste laboratório, o foco não é a qualidade do modelo. Se você estiver implantando um modelo de detecção de fraude em produção, provavelmente vai querer uma acurácia maior que 85% na classe de fraude. O objetivo deste laboratório é apresentar a você as ferramentas para explicar modelos treinados em conjuntos de dados desequilibrados.
Em seguida, vamos usar o SDK da IA explicável para entender em quais recursos nosso modelo se baseia para fazer essas previsões.
6. Como usar o SDK de IA explicável
O SDK de IA explicável oferece métodos utilitários para receber explicações sobre seu modelo. Ela vem pré-instalada nas instâncias do notebook do Tensorflow AI Platform. Importamos ela no notebook no início do laboratório. Com o SDK, podemos receber atribuições de recursos do nosso modelo na 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, em seguida, apontar o SDK para os recursos do modelo salvo 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)
Se você atualizar a visualização de pastas na barra lateral esquerda do notebook, vai ver um novo diretório chamado fraud_model/.
Etapa 2: receber metadados de explicação com o SDK
Em seguida, vamos direcionar o SDK de IA explicável para esse diretório. Isso vai gerar os metadados necessários para receber explicações do modelo. O método get_metadata() mostra 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 ajuda a responder à pergunta: "Por que nosso modelo achou que isso era fraude?"
Etapa 3: especificar o valor de referência do nosso modelo
Para dados tabulares, o serviço de IA explicável retorna valores de atribuição para cada recurso. Esses valores indicam o quanto um atributo específico 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 a quê?". Isso nos leva ao conceito de um valor de referência.
O valor de referência do nosso modelo é essencialmente o que ele está comparando. Selecionamos o valor de referência para cada atributo no nosso modelo, e a previsão de referência se torna o valor que o modelo prevê quando os atributos são definidos como 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 mediano de cada atributo no conjunto de dados como valor de referência. No entanto, no caso da detecção de fraudes, não é exatamente isso que queremos. Nosso principal objetivo é explicar os casos em que nosso 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, vamos usar os valores medianos das transações não fraudulentas no nosso conjunto de dados como valor de referência. Podemos usar o DataFrame not_fraud_sample extraído acima e escaloná-lo 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 uma linha de base. Caso contrário, o SDK usará 0 como valor de referência para cada valor de entrada esperado pelo modelo. No nosso caso de uso de detecção de fraude, faz sentido especificar um valor de referência, o que faremos abaixo:
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 nosso modelo chamado explanation_metadata.json. No notebook, navegue até o diretório "fraud_model/" para confirmar se o arquivo foi criado. Contém metadados que o SDK usa para gerar atribuições de recursos.
Etapa 4: receber explicações do modelo
Agora estamos prontos para receber atribuições de recursos em exemplos individuais. Para fazer isso, primeiro vamos criar uma referência local ao nosso modelo usando o SDK:
local_model = explainable_ai_sdk.load_model_from_local_path(
model_dir,
explainable_ai_sdk.SampledShapleyConfig()
)
Em seguida, vamos receber previsões e explicações sobre nosso modelo de uma transação de exemplo que deve 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()
A execução desse comando vai criar uma visualização parecida com 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 em mais de 0,5 em relação ao valor de referência. O valor da transação, o saldo resultante na conta de destino e a etapa foram os próximos maiores indicadores. No conjunto de dados, a "etapa" representa uma unidade de tempo (uma etapa é uma hora). Os valores de atribuição também podem ser negativos.
O "erro de aproximação" impresso acima das visualizações informa o quanto você pode confiar na explicação. Em geral, um erro acima de 5% significa que você não pode confiar nas atribuições de recursos. Lembre-se de que a qualidade das suas explicações depende dos dados de treinamento e do modelo usados. Melhorar os dados de treinamento, o modelo ou tentar uma base de modelo diferente pode diminuir o erro de aproximação.
Você também pode diminuir esse erro aumentando o número de etapas usadas no seu método de explicação. É possível mudar isso com o SDK adicionando um parâmetro path_count à 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)
)
Há muito mais que você pode fazer com a IA explicável nesse modelo. Algumas ideias incluem:
- Enviar muitos exemplos para nosso modelo e calcular a média dos valores de atribuição para ver se determinados recursos são mais importantes no geral. Podemos usar isso para melhorar nosso modelo e remover recursos que não são importantes.
- Encontrar falsos positivos que nosso modelo sinaliza como fraude, mas que são transações não fraudulentas, e examinar os valores de atribuição deles
- Use outra linha de base e veja como isso afeta os valores de atribuição
Parabéns! 🎉
Você aprendeu a lidar com dados desequilibrados, treinar um modelo do TensorFlow para detectar transações fraudulentas e usar o SDK da IA explicável para saber em quais recursos seu modelo mais confia para fazer previsões individuais. Se quiser, você pode parar por aqui. O uso do SDK em um notebook simplifica o processo de desenvolvimento do modelo, acesso a explicações antes da implantação. Depois de criar um modelo que atenda às suas expectativas, é provável que você queira implantá-lo para receber previsões em grande escala. Se for o seu caso, siga para a próxima etapa opcional. Se você já tiver terminado, pule para a etapa Limpeza.
7. Opcional: implante o modelo no AI Platform Prediction
Nesta etapa, você vai aprender a implantar seu modelo no AI Platform Prediction.
Etapa 1: copie o diretório do modelo salvo para um bucket do Cloud Storage.
Com as etapas do SDK que executamos anteriormente, você tem tudo o que precisa para implantar seu modelo no AI Platform. Para se preparar para a implantação, coloque os recursos do SavedModel e os metadados de explicação em um bucket do Cloud Storage que o serviço de IA explicável possa ler.
Para isso, vamos definir algumas variáveis de ambiente. Preencha os valores abaixo com o nome do seu projeto na nuvem do Google e o nome 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 exportados do modelo do TensorFlow. Vamos direcionar a AI Platform para esse bucket ao implantar o modelo.
Execute este comando gsutil no notebook para criar um bucket:
!gsutil mb -l 'us-central1' $MODEL_BUCKET
Em seguida, copie o diretório do modelo local para esse bucket:
!gsutil -m cp -r ./$model_dir/* $MODEL_BUCKET/explanations
Etapa 2: implantar o modelo
Em seguida, vamos definir algumas variáveis que usaremos nos comandos de implantação:
MODEL = 'fraud_detection'
VERSION = 'v1'
model_path = MODEL_BUCKET + '/explanations'
Podemos 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 o gcloud. A implantação da versão leva 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 flag origin, transmitimos o local do Cloud Storage do modelo salvo e do arquivo de metadados. No momento, a IA explicável tem dois métodos de explicação diferentes disponíveis para modelos tabulares. Aqui, estamos usando o Shapley amostrado. O parâmetro num-paths indica o número de caminhos amostrados para cada recurso de entrada. Em geral, quanto mais complexo for o modelo, mais etapas de aproximação serão necessárias para alcançar 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 nosso modelo prevê fraude. Vamos enviar cinco exemplos de teste para 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 receber os índices de todos os exemplos de fraude do nosso conjunto de testes:
fraud_indices = []
for i,val in enumerate(test_labels):
if val == 1:
fraud_indices.append(i)
Em seguida, vamos salvar cinco exemplos no formato esperado pelo nosso modelo e gravá-los 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 esses cinco exemplos ao nosso 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ê vai encontrar os valores de atribuição de cada recurso nesses exemplos. A chave example_score de cada exemplo inclui a previsão do modelo. Nesse caso, a probabilidade percentual de que uma transação específica seja fraudulenta.
8. Limpeza
Se você quiser continuar usando esse notebook, recomendamos que o desative quando não estiver em uso. Na interface de Notebooks no console do Cloud, selecione o notebook e clique em Parar:
Se quiser excluir todos os recursos criados neste laboratório, exclua a instância do notebook em vez de interrompê-la.
No menu de navegação do console do Cloud, acesse "Storage" e exclua os dois buckets criados para armazenar os recursos do modelo.