Détection de fraude bancaire avec un Auto-encodeur en keras

Dans cet article, je vous présente de façon pratique comment détecter les fraudes bancaires avec un auto-encodeur en Keras .

Le fonctionnement d’un auto-encodeur

D’abord, je vous explique brièvement le fonctionnement d’un auto-encodeur. Vous pouvez également consulter mon article sur le fonctionnement des auto-encodeurs pour apprendre plus. L’article se trouve ici https://jafwin.com/2020/07/04/les-auto-encodeurs-expliques-en-detail/

Un auto-encodeur est un algorithme de deep learning qui permet de faire l’apprentissage non supervisé. Il est composé d’encodage et de décodage. En effet, l’encodeur est constitué par un ensemble de couches de neurones, qui traitent les données afin d’obtenir une nouvelle représentation des données tandis que les couches de neurones du décodeur analysent les données encodées pour essayer de reconstruire les données d’origines. Généralement, la nouvelle représentation des données a moins de caractéristiques. La différence entre les données d’origines et les données reconstruites par le décodeur permet d’évaluer l’erreur de reconstruction. Ainsi, le but de l’entrainement de l’auto-encodeur est de modifier les paramètres afin de minimiser l’erreur de reconstruction.  

L’achitecture d’un auto-encodeur

L’image suivante montre l’architecture d’un auto-encodeur constitué des couches d’encodage et de décodage.

Méthodologie de détection de fraude bancaire avec un auto-encodeur

Dans cette partie de l’article, je vous explique la méthodologie que j’ai utilisé pour la détection des fraudes bancaire.

D’abord, pour l’entrainement de la machine d’auto-encodeur, j’ai utilisé uniquement les transactions normales afin d’apprendre le comportement de transactions légitimes.  En effet, l’encodeur réduit la dimension des transactions d’entrées sur un ensemble plus petit de caractéristiques. Le décodeur reconstruit à son tour la transaction d’origine. Ensuite, on calcul la moyenne des erreurs de reconstruction des transactions normales. Une erreur de reconstruction est la différence en distance entre la transaction d’origine et celle reproduite. Si l’erreur de reconstruction d’une transaction est supérieure au seuil fixé en fonction de la moyenne des erreurs de reconstruction des transactions normales alors la transaction est considérée comme une candidat à la fraude.

Présentation du Data Set

Je vous explique ici la structure et les caractéristiques du Data set utilisé.

J’ai utilisé les données de carte de crédit fournies par Kaggle. En effet, le Data Set contient les transactions par carte de crédit effectuées en septembre 2013 par des titulaires de carte européens. Le nombre total de transactions est de 284 807.  Donc, le Data set est très déséquilibré, seuls 492 d’entre eux (0,172%) sont frauduleux.  Malheureusement, en raison de problèmes de confidentialité, les caractéristiques d’origine et plus d’informations de fond sur les données n’ont pas été fournies. Les caractéristiques V1, V2, … V28 sont les attributs obtenus avec PCA, les seuls attributs qui n’ont pas été transformées avec PCA sont ‘Time’ et ‘Amount’.  En effet, l’attribut « Time » contient les secondes écoulées entre chaque transaction et la première transaction de l’ensemble de données. L’attribut « Montant » est le montant payé pour chaque transaction. L’attribut ‘Classe’ est la variable de réponse et prend la valeur 1 en cas de fraude et 0 sinon.

Prétraitement des données

La variable Time n’a pas d’impact sur la prédiction. J’ai donc supprimé cette variable du Data Set. Aussi, j’ai extrait uniquement les transactions normales pour l’entrainement de l’auto-encodeur. Parmi ces données d’entrainement, 20% sont utilisés pour fixer le seul des erreurs de reconstruction et la validation du model.  Ensuite, j’ai pris 20% pour les données de test. Les données du test sont composées des transactions normales et frauduleuses. J’ai enfin normalisé toutes les données d’entrée pour être dans [0,1] puisque les réseaux de neurones n’acceptent que des vecteurs d’entrée qui sont dans [0,1].

La topologie du prétraitement des données

Comme constaté, la figure suivante montre la structure utiliée pour le prétraitement des données.

Le code source écrit en keras pour la détection des fraudes bancaires avec un auto-encodeur

Je vous présente dans cette partie le code source que j’ai écrit en Keras. Je vous rappelle que vous devez importer toutes les librairies nécessaires pour faire fonctionner ce code.

1-On charge le Data Set

   df = pd.read_csv('creditcard.csv')

2-normal_df contient les transactions normales

  normal_df = df[df.Class == 0]

3-fraud_df  contient les transactions frauduleuses
  
fraud_df = df[df.Class == 1]

4-On normalise la valeur de la variable Time dans lintervalle (-1, 1)

5-fraud_df  contient les transactions frauduleuses

  df_norm['Time'] =    StandardScaler().fit_transform(df_norm['Time'].values.reshape(-1, 1))
6-On prend 10% des transactions pour le test 

train_x, test_x = train_test_split(normal_df, test_size=0.1,random_state=1)

7-On prend que les transactions normales pour l'entrainement de la machine d'auto-encodeur 

train_x = train_x[train_x.Class == 0]  

8-On supprime la colonne Class puisqu'on n'a pas besoin des labelles pour entrainer notre machine de façon non supervisée 

train_x = train_x.drop(['Class'], axis=1)

9-On récupère les données du test et on supprime les labelles 

test_y = test_x['Class']  
test_x = test_x.drop(['Class'], axis=1) 

10-Le code source pour faire le model d'auto-encodeur  

nb_epoch = 100
batch_size = 128
input_dim = train_x.shape[1]  # num of columns, 30
encoding_dim = 14
hidden_dim = int(encoding_dim / 2)  # i.e. 7
learning_rate = 1e-7

input_layer = Input(shape=(input_dim,))
encoder = Dense(encoding_dim, activation="tanh", activity_regularizer=regularizers.l1(learning_rate))(input_layer)
encoder = Dense(hidden_dim, activation="relu")(encoder)
decoder = Dense(hidden_dim, activation='tanh')(encoder)
decoder = Dense(input_dim, activation='relu')(decoder)
autoencoder = Model(inputs=input_layer, outputs=decoder)

11-On compile le model dauto encodeur en keras

autoencoder.compile(loss='mean_squared_error',
                  optimizer='adam', metrics=['accuracy'])

12-On entraine le model dauto encodeur en keras

history = autoencoder.fit(train_x, train_x,
                          epochs=nb_epoch,
                          batch_size=batch_size,
                          shuffle=True,
                          validation_data=(test_x, test_x),
                          validation_split=0.1,
                          verbose=1,
                          callbacks=[cp, tb]).history

13-On affiche le graphique montrant la performance du model pour les données d'entrainement et du test

plt.plot(history['loss'], linewidth=2, label='Train')
plt.plot(history['val_loss'], linewidth=2, label='Test')

plt.legend(loc='upper right')
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')

Résultat montrant la performance du model

L’image de la Figure ci-dessous montre la performance en termes de précision de l’auto-encodeur pour les données d’entrainement et du test.

Dans cet article. j’ai entrainé un model d’auto-encodeur pour la détection des fraudes bancaires. Vous pouvez me laisser savoir dans les commentaires si vous avez besoin du Data set et le code source au complet . Je vous enverrai avec plaisir!

Partagez l'article à vos réseaux: on Twitter on Facebook on Google+ on LinkedIn