Projet de détection de fraude par carte de crédit - Projet d'apprentissage automatique

Bienvenue dans notre projet de détection de fraude par carte de crédit. Aujourd'hui, nous allons utiliser Python et l'apprentissage automatique pour détecter la fraude dans un ensemble de données de transactions par carte de crédit. Bien que nous ayons partagé le code pour chaque étape, il serait préférable de comprendre comment chaque étape fonctionne, puis de l'implémenter.

Commençons!

Projet de détection de fraude par carte de crédit avec étapes

Dans notre projet de détection de fraude par carte de crédit, nous utiliserons Python, l'un des langages de programmation les plus populaires disponibles. Notre solution détecterait si quelqu'un contourne les murs de sécurité de notre système et effectue une transaction illégitime.

L'ensemble de données contient des transactions par carte de crédit et ses caractéristiques sont le résultat d'une analyse PCA. Il a les fonctions 'Amount', 'Time' et 'Class' où 'Amount' montre la valeur monétaire de chaque transaction, 'Time' montre les secondes écoulées entre la première et la transaction respective, et 'Class' montre si une transaction est légitime ou non.

Dans 'Classe', la valeur 1 représente une transaction frauduleuse et la valeur 0 représente une transaction valide.

Vous pouvez obtenir l'ensemble de données et le code source complet ici .

Étape 1 : Importer des packages

Nous allons commencer notre projet de détection de fraude par carte de crédit en installant les packages requis. Créez un fichier "main.py" et importez ces packages :

importer numpy en tant que np

importer des pandas en tant que pd

importer sklearn

à partir de la norme d'importation scipy.stats

de scipy.stats importer multivariate_normal

de sklearn.preprocessing importer MinMaxScaler

importer matplotlib.pyplot en tant que plt

importer seaborn en tant que sns

Étape 2 : recherchez les erreurs

Avant d'utiliser l'ensemble de données, nous devons rechercher les erreurs et les valeurs manquantes qu'il contient. La présence de valeurs manquantes peut amener votre modèle à donner des résultats erronés, le rendant inefficace et inefficace. Par conséquent, nous allons lire l'ensemble de données et rechercher les valeurs manquantes :

df = pd.read_csv('fraude par carte de crédit/carte de crédit.csv')

# valeurs manquantes

print("valeurs manquantes :", df.isnull().values.any())

Nous n'avons trouvé aucune valeur manquante dans cet ensemble de données, nous pouvons donc passer à l'étape suivante.

Rejoignez le cours d'intelligence artificielle en ligne des meilleures universités du monde - Masters, Executive Post Graduate Programs et Advanced Certificate Program in ML & AI pour accélérer votre carrière.

Étape 3 : Visualisation

Dans cette étape de notre projet de détection de fraude par carte de crédit, nous allons visualiser nos données. La visualisation aide à comprendre ce que nos données montrent et révèle tous les modèles que nous aurions pu manquer. Créons un graphique de notre ensemble de données :

# complot normal et fraude

count_classes = pd.value_counts(df['Class'], sort=True)

count_classes.plot(kind='bar', rot=0)

plt.title("Transactions distribuées")

plt.xticks(range(2), ['Normal', 'Fraude'])

plt.xlabel("Classe")

plt.ylabel("Fréquence")

plt.show()

Dans notre graphique, nous avons constaté que les données sont fortement déséquilibrées. Cela signifie que nous ne pouvons pas utiliser d'algorithmes d'apprentissage supervisé car cela entraînerait un surajustement. De plus, nous n'avons pas déterminé quelle serait la meilleure méthode pour résoudre notre problème, nous allons donc effectuer plus de visualisation. Utilisez ce qui suit pour tracer la carte thermique :

# carte de chaleur

sns.heatmap(df.corr(), vmin=-1)

plt.show()

Nous allons maintenant créer des graphiques de distribution des données pour nous aider à comprendre d'où proviennent nos données :

fig, axs = plt.subplots(6, 5, squeeze=False)

for i, ax in enumerate(axs.flatten()):

ax.set_facecolor('xkcd:charcoal')

ax.set_title(df.columns[i])

sns.distplot(df.iloc[:, je], ax=ax, fit=norm,

color="#DC143C", fit_kws={"color": "#4e8ef5"})

ax.set_xlabel(")

fig.tight_layout(h_pad=-1.5, w_pad=-1.5)

plt.show()

Avec les graphiques de distribution de données, nous avons constaté que presque toutes les caractéristiques proviennent de la distribution gaussienne, à l'exception de "Time".

Nous allons donc utiliser une distribution gaussienne multivariée pour détecter la fraude. Comme seule la fonction 'Time' provient de la distribution bimodale (et notez la distribution gaussienne), nous la rejetterons. De plus, notre visualisation a révélé que la fonction 'Time' n'a pas de valeurs extrêmes comme les autres, ce qui est une autre raison pour laquelle nous la rejetterons.

Ajoutez le code suivant pour supprimer les fonctionnalités dont nous avons parlé et en mettre d'autres à l'échelle :

classes = df['Classe']

df.drop(['Time', 'Class', 'Amount'], axis=1, inplace=True)

cols = df.columns.difference(['Classe'])

MMscaler = MinMaxScaler()

df = MMcaller.fit_transform(df)

df = pd.DataFrame(data=df, colonnes=cols)

df = pd.concat([df, classes], axe=1)

Étape 4 : Fractionner l'ensemble de données

Créez un fichier 'functions.py'. Ici, nous allons ajouter des fonctions pour implémenter les différentes étapes de notre algorithme. Cependant, avant d'ajouter ces fonctions, divisons notre ensemble de données en deux ensembles, l'ensemble de validation et l'ensemble de test.

importer des pandas en tant que pd

importer numpy en tant que np

def train_validation_splits(df):

# Transactions frauduleuses

fraude = df[df['Class'] == 1]

# transactions normales

normal = df[df['Classe'] == 0]

print('normal:', normal.forme[0])

print('fraude:', fraude.forme[0])

normal_test_start = int(normal.forme[0] * .2)

fraud_test_start = int(fraude.forme[0] * .5)

normal_train_start = normal_test_start * 2

val_normal = normal[:normal_test_start]

val_fraud = fraude[:fraud_test_start]

validation_set = pd.concat([val_normal, val_fraude], axe=0)

test_normal = normal[normal_test_start:normal_train_start]

test_fraud = fraude[fraud_test_start:fraud.shape[0]]

test_set = pd.concat([test_normal, test_fraude], axe=0)

Xval = validation_set.iloc[:, :-1]

Yval = validation_set.iloc[:, -1]

Xtest = test_set.iloc[:, :-1]

Ytest = test_set.iloc[:, -1]

train_set = normal[normal_train_start:normal.shape[0]]

Xtrain = train_set.iloc[:, :-1]

retourner Xtrain.to_numpy(), Xtest.to_numpy(), Xval.to_numpy(), Ytest.to_numpy(), Yval.to_numpy()

Étape 5 : Calculer la moyenne et la matrice de covariance

La fonction suivante nous aidera à calculer la moyenne et la matrice de covariance :

def estimate_gaussian_params(X):

"""

Calcule la moyenne et la covariance pour chaque caractéristique.

Arguments:

X : jeu de données

"""

mu = np.mean(X, axe=0)

sigma = np.cov(XT)

retour mu, sigma

Étape 6 : Ajoutez les touches finales

Dans notre fichier 'main.py', nous allons importer et appeler les fonctions que nous avons implémentées à l'étape précédente pour chaque ensemble :

(Xtrain, Xtest, Xval, Ytest, Yval) = train_validation_splits(df)

(mu, sigma) = estimate_gaussian_params(Xtrain)

# calculer le pdf gaussien

p = multivariate_normal.pdf(Xtrain, mu, sigma)

pval = multivariate_normal.pdf(Xval, mu, sigma)

ptest = multivariate_normal.pdf(Xtest, mu, sigma)

Maintenant, nous devons nous référer à l'epsilon (ou au seuil). Habituellement, il est préférable d'initialiser le seuil avec la valeur minimale du pdf et d'augmenter à chaque étape jusqu'à ce que vous atteigniez le pdf maximum tout en enregistrant chaque valeur epsilon dans un vecteur.

Après avoir créé notre vecteur requis, nous faisons une boucle "for" et parcourons le même. Nous comparons le seuil avec les valeurs du pdf qui génèrent nos prédictions à chaque itération.

Nous calculons également le score F1 en fonction de nos valeurs de vérité terrain et des prédictions. Si le score F1 trouvé est supérieur au précédent, nous remplaçons une variable « meilleur seuil ».

Gardez à l'esprit que nous ne pouvons pas utiliser la "précision" comme métrique dans notre projet de détection de fraude par carte de crédit. En effet, cela refléterait toutes les transactions comme d'habitude avec une précision de 99 %, rendant notre algorithme inutile.

Nous allons implémenter tous les processus dont nous avons parlé ci-dessus dans notre fichier 'functions.py' :

def metrics(y, prédictions) :

fp = np.sum(np.all([prédictions == 1, y == 0], axe=0))

tp = np.sum(np.all([prédictions == 1, y == 1], axe=0))

fn = np.sum(np.all([prédictions == 0, y == 1], axe=0))

précision = (tp / (tp + fp)) si (tp + fp) > 0 sinon 0

rappeler = (tp / (tp + fn)) si (tp + fn) > 0 sinon 0

F1 = (2 * précision * rappel) / (précision +

rappel) si (précision + rappel) > 0 sinon 0

précision de retour, rappel, F1

def selectThreshold(yval, pval):

e_values ​​= pval

meilleurF1 = 0

meilleurEpsilon = 0

pour epsilon dans e_values :

prédictions = pval < epsilon

(précision, rappel, F1) = metrics(yval, prédictions)

si F1 > meilleurF1 :

meilleurF1 = F1

meilleurEpsilon = epsilon

retourner le meilleurEpsilon, le meilleurF1

À la fin, nous importerons les fonctions dans le fichier 'main.py' et les appellerons pour renvoyer le score F1 et le seuil. Cela nous permettra d'évaluer notre modèle sur le jeu de test :

(epsilon, F1) = selectThreshold(Yval, pval)

print("Meilleur epsilon trouvé :", epsilon)

print("Meilleur F1 sur l'ensemble de validation croisée :", F1)

(test_precision, test_recall, test_F1) = metrics(Ytest, ptest < epsilon)

print("Outliers trouvés :", np.sum(ptest < epsilon))

print("Tester la précision de l'ensemble :", test_precision)

print("Test set Recall:", test_recall)

print("Score F1 de l'ensemble de tests :", test_F1)

Voici les résultats de tous ces efforts :

Meilleur epsilon trouvé : 5e-324

Meilleur F1 sur l'ensemble de validation croisée : 0,7852998065764023

Valeurs aberrantes trouvées : 210

Précision de l'ensemble de test : 0,9095238095238095

Ensemble de test Rappel : 0.7764227642276422

Score F1 de l'ensemble de test : 0,837719298245614

Conclusion

Voilà, un projet de détection de fraude par carte de crédit entièrement fonctionnel !

Si vous avez des questions ou des suggestions concernant ce projet, faites-le nous savoir en laissant un commentaire ci-dessous. Nous aimerions recevoir de vos nouvelles.

Avec toutes les compétences acquises, vous pouvez également être actif sur d'autres plates-formes compétitives pour tester vos compétences et obtenir encore plus de pratique. Si vous souhaitez en savoir plus sur le cours, consultez la page du programme Execitive PG en Machine Learning & AI et parlez à notre conseiller en carrière pour plus d'informations.