Projekt zur Erkennung von Kreditkartenbetrug – Projekt für maschinelles Lernen

Willkommen bei unserem Projekt zur Erkennung von Kreditkartenbetrug. Heute werden wir Python und maschinelles Lernen verwenden, um Betrug in einem Datensatz von Kreditkartentransaktionen zu erkennen. Obwohl wir den Code für jeden Schritt geteilt haben, wäre es am besten zu verstehen, wie jeder Schritt funktioniert, und ihn dann zu implementieren.

Lass uns anfangen!

Projekt zur Erkennung von Kreditkartenbetrug mit Schritten

In unserem Projekt zur Erkennung von Kreditkartenbetrug verwenden wir Python, eine der beliebtesten verfügbaren Programmiersprachen. Unsere Lösung würde erkennen, wenn jemand die Sicherheitsmauern unseres Systems umgeht und eine illegitime Transaktion durchführt.

Der Datensatz enthält Kreditkartentransaktionen und seine Merkmale sind das Ergebnis einer PCA-Analyse. Es verfügt über die Funktionen „Betrag“, „Zeit“ und „Klasse“, wobei „Betrag“ den Geldwert jeder Transaktion anzeigt, „Zeit“ die Sekunden anzeigt, die zwischen der ersten und der jeweiligen Transaktion vergangen sind, und „Klasse“ zeigt, ob eine Transaktion stattgefunden hat legitim ist oder nicht.

In „Klasse“ steht der Wert 1 für eine betrügerische Transaktion und der Wert 0 für eine gültige Transaktion.

Den Datensatz und den gesamten Quellcode erhalten Sie hier .

Schritt 1: Pakete importieren

Wir beginnen unser Projekt zur Erkennung von Kreditkartenbetrug mit der Installation der erforderlichen Pakete. Erstellen Sie eine ‚main.py‘-Datei und importieren Sie diese Pakete:

importiere numpy als np

pandas als pd importieren

sklearn importieren

aus scipy.stats Importnorm

aus scipy.stats import multivariate_normal

aus sklearn.preprocessing import MinMaxScaler

importiere matplotlib.pyplot als plt

seegeboren als sns importieren

Schritt 2: Suchen Sie nach Fehlern

Bevor wir den Datensatz verwenden, sollten wir darin nach Fehlern und fehlenden Werten suchen. Das Vorhandensein fehlender Werte kann dazu führen, dass Ihr Modell fehlerhafte Ergebnisse liefert, wodurch es ineffizient und ineffektiv wird. Daher lesen wir den Datensatz und suchen nach fehlenden Werten:

df = pd.read_csv('Kreditkartenbetrug/Kreditkarte.csv')

# fehlende Werte

print("fehlende Werte:", df.isnull().values.any())

Wir haben in diesem Datensatz keine fehlenden Werte gefunden, sodass wir mit dem nächsten Schritt fortfahren können.

Nehmen Sie online am Kurs „Künstliche Intelligenz“ der weltbesten Universitäten teil – Master, Executive Post Graduate Programs und Advanced Certificate Program in ML & AI, um Ihre Karriere zu beschleunigen.

Schritt 3: Visualisierung

In diesem Schritt unseres Projekts zur Erkennung von Kreditkartenbetrug visualisieren wir unsere Daten. Die Visualisierung hilft zu verstehen, was unsere Daten zeigen, und zeigt alle Muster auf, die wir möglicherweise übersehen haben. Lassen Sie uns ein Diagramm unseres Datensatzes erstellen:

# Plot Normal und Betrug

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

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

plt.title („Verteilte Transaktionen“)

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

plt.xlabel("Klasse")

plt.ylabel("Frequenz")

plt.show()

In unserem Diagramm haben wir festgestellt, dass die Daten stark unausgewogen sind. Das bedeutet, dass wir keine überwachten Lernalgorithmen verwenden können, da dies zu einer Überanpassung führt. Außerdem haben wir noch nicht herausgefunden, was die beste Methode zur Lösung unseres Problems wäre, also führen wir mehr Visualisierung durch. Verwenden Sie Folgendes, um die Heatmap zu zeichnen:

# Heatmap

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

plt.show()

Jetzt erstellen wir Datenverteilungsdiagramme, um zu verstehen, woher unsere Daten stammen:

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

für i, ax in enumerate(axs.flatten()):

ax.set_facecolor('xkcd:charcoal')

ax.set_title(df.columns[i])

sns.distplot(df.iloc[:, i], 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()

Bei Datenverteilungsdiagrammen haben wir festgestellt, dass fast jedes Merkmal aus der Gaußschen Verteilung stammt, mit Ausnahme von „Zeit“.

Wir verwenden also die multivariate Gaußsche Verteilung, um Betrug zu erkennen. Da nur das Merkmal „Zeit“ aus der bimodalen Verteilung stammt (und beachten Sie die Gaußsche Verteilung), verwerfen wir es. Darüber hinaus hat unsere Visualisierung gezeigt, dass die Funktion „Zeit“ keine Extremwerte wie die anderen hat, was ein weiterer Grund ist, warum wir sie verwerfen.

Fügen Sie den folgenden Code hinzu, um die besprochenen Funktionen zu löschen und andere zu skalieren:

Klassen = df['Klasse']

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

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

MMscaler = MinMaxScaler()

df = MMscaller.fit_transform(df)

df = pd.DataFrame (Daten = df, Spalten = Spalten)

df = pd.concat([df, Klassen], Achse=1)

Schritt 4: Aufteilen des Datensatzes

Erstellen Sie eine Datei „functions.py“. Hier fügen wir Funktionen hinzu, um die verschiedenen Phasen unseres Algorithmus zu implementieren. Bevor wir diese Funktionen hinzufügen, teilen wir unser Dataset jedoch in zwei Sets auf, das Validierungsset und das Testset.

pandas als pd importieren

importiere numpy als np

def train_validation_splits(df):

# Betrugstransaktionen

Betrug = df[df['Klasse'] == 1]

# Normale Transaktionen

normal = df[df['Klasse'] == 0]

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

print('Betrug:', betrug.shape[0])

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

betrug_test_start = int(betrug.form[0] * .5)

normal_train_start = normal_test_start * 2

val_normal = normal[:normal_test_start]

val_fraud = betrug[:fraud_test_start]

validation_set = pd.concat([val_normal, val_fraud], Achse=0)

test_normal = normal[normaler_test_start:normaler_zug_start]

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

test_set = pd.concat([test_normal, test_fraud], Achse=0)

Xval = validierungssatz.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]

Rückgabe Xtrain.to_numpy(), Xtest.to_numpy(), Xval.to_numpy(), Ytest.to_numpy(), Yval.to_numpy()

Schritt 5: Berechnung von Mittelwert und Kovarianzmatrix

Die folgende Funktion hilft uns bei der Berechnung des Mittelwerts und der Kovarianzmatrix:

def schätzen_gaussian_params(X):

"""

Berechnet den Mittelwert und die Kovarianz für jedes Merkmal.

Argumente:

X: Datensatz

"""

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

sigma = np.cov(XT)

gib mu, sigma zurück

Schritt 6: Fügen Sie den letzten Schliff hinzu

In unsere Datei ‚main.py‘ importieren und rufen wir die Funktionen, die wir im vorherigen Schritt implementiert haben, für jeden Satz auf:

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

(mu, sigma) = schätzung_gaussian_params(Xtrain)

# Gaußsches pdf berechnen

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

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

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

Jetzt müssen wir uns auf das Epsilon (oder die Schwelle) beziehen. Normalerweise ist es am besten, den Schwellenwert mit dem Mindestwert des pdf zu initialisieren und mit jedem Schritt zu erhöhen, bis Sie den maximalen pdf erreichen, während Sie jeden Epsilon-Wert in einem Vektor speichern.

Nachdem wir unseren erforderlichen Vektor erstellt haben, erstellen wir eine 'for'-Schleife und iterieren darüber. Wir vergleichen den Schwellenwert mit den PDF-Werten, die unsere Vorhersagen in jeder Iteration generieren.

Wir berechnen auch den F1-Score gemäß unseren Ground-Truth-Werten und den Vorhersagen. Wenn der gefundene F1-Score höher als der vorherige ist, überschreiben wir eine „beste Schwellen“-Variable.

Beachten Sie, dass wir „Genauigkeit“ nicht als Metrik in unserem Projekt zur Erkennung von Kreditkartenbetrug verwenden können. Das liegt daran, dass es alle Transaktionen wie gewohnt mit einer Genauigkeit von 99 % wiedergeben würde, was unseren Algorithmus nutzlos macht.

Wir implementieren alle oben besprochenen Prozesse in unserer Datei „functions.py“:

def metrics(y, Vorhersagen):

fp = np.sum(np.all([Vorhersagen == 1, y == 0], Achse=0))

tp = np.sum(np.all([Vorhersagen == 1, y == 1], Achse=0))

fn = np.sum(np.all([Vorhersagen == 0, y == 1], Achse=0))

Präzision = (tp / (tp + fp)) wenn (tp + fp) > 0 sonst 0

Recall = (tp / (tp + fn)) if (tp + fn) > 0 else 0

F1 = (2 * Präzision * Rückruf) / (Präzision +

Abruf) wenn (Präzision + Abruf) > 0 sonst 0

Genauigkeit zurückgeben, Rückruf, F1

def selectThreshold(yval, pval):

e_Werte = pval

bestF1 = 0

bestEpsilon = 0

für epsilon in e_values:

Vorhersagen = pval < Epsilon

(Präzision, Erinnerung, F1) = Metriken (yval, Vorhersagen)

wenn F1 > bestF1:

bestF1 = F1

bestEpsilon = epsilon

BestEpsilon, BestF1 zurückgeben

Am Ende importieren wir die Funktionen in die Datei „main.py“ und rufen sie auf, um den F1-Score und den Schwellenwert zurückzugeben. Es ermöglicht uns, unser Modell auf dem Testset zu bewerten:

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

print("Bestes Epsilon gefunden:", Epsilon)

print("Bestes F1 im Kreuzvalidierungssatz:", F1)

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

print("Ausreißer gefunden:", np.sum(ptest < epsilon))

print("Präzision des Testsatzes:", test_precision)

print("Testsatz-Rückruf:", test_recall)

print("Testsatz F1 Ergebnis:", test_F1)

Hier sind die Ergebnisse all dieser Bemühungen:

Bestes gefundenes Epsilon: 5e-324

Bester F1 im Kreuzvalidierungssatz: 0,7852998065764023

Gefundene Ausreißer: 210

Testset Präzision: 0,9095238095238095

Testsatz-Rückruf: 0,7764227642276422

Testsatz F1-Punktzahl: 0,837719298245614

Fazit

Da haben Sie es – ein voll funktionsfähiges Projekt zur Erkennung von Kreditkartenbetrug!

Wenn Sie Fragen oder Anregungen zu diesem Projekt haben, lassen Sie es uns wissen, indem Sie unten einen Kommentar hinterlassen. Wir würden uns freuen, von Ihnen zu hören.

Mit all den erlernten Fähigkeiten können Sie auch auf anderen Wettbewerbsplattformen aktiv werden, um Ihre Fähigkeiten zu testen und noch mehr praktische Erfahrungen zu sammeln. Wenn Sie mehr über den Kurs erfahren möchten, besuchen Sie die Seite des Executive PG Program in Machine Learning & AI und sprechen Sie mit unserem Karriereberater für weitere Informationen.