Proiect de detectare a fraudei cu cardul de credit – Proiect de învățare automată

Bun venit la proiectul nostru de detectare a fraudelor cu cardul de credit. Astăzi, vom folosi Python și învățarea automată pentru a detecta frauda într-un set de date de tranzacții cu cardul de credit. Deși am împărtășit codul pentru fiecare pas, cel mai bine ar fi să înțelegem cum funcționează fiecare pas și apoi să îl implementăm.

Sa incepem!

Proiect de detectare a fraudei cu carduri de credit cu pași

În proiectul nostru de detectare a fraudelor cu cardul de credit, vom folosi Python, unul dintre cele mai populare limbaje de programare disponibile. Soluția noastră ar detecta dacă cineva ocolește pereții de securitate ai sistemului nostru și face o tranzacție nelegitimă.

Setul de date are tranzacții cu cardul de credit, iar caracteristicile sale sunt rezultatul analizei PCA. Are funcții „Sumă”, „Timp” și „Clasă”, unde „Suma” arată valoarea monetară a fiecărei tranzacții, „Timp” arată secundele scurse între prima și respectiva tranzacție, iar „Clasa” arată dacă o tranzacție este legitim sau nu.

În „Clasă”, valoarea 1 reprezintă o tranzacție fraudă, iar valoarea 0 reprezintă o tranzacție validă.

Puteți obține setul de date și întregul cod sursă aici .

Pasul 1: importați pachete

Vom începe proiectul nostru de detectare a fraudelor cu cardul de credit instalând pachetele necesare. Creați un fișier „main.py” și importați aceste pachete:

import numpy ca np

importa panda ca pd

import sklearn

din scipy.stats import norm

din scipy.stats import multivariate_normal

din sklearn.preprocessing import MinMaxScaler

import matplotlib.pyplot ca plt

import seaborn ca sns

Pasul 2: Căutați erori

Înainte de a folosi setul de date, ar trebui să căutăm orice erori și valori lipsă în el. Prezența valorilor lipsă poate determina modelul dvs. să dea rezultate greșite, făcându-l ineficient și ineficient. Prin urmare, vom citi setul de date și vom căuta orice valori lipsă:

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

# valori lipsă

print(„valori lipsă:”, df.isnull().values.any())

Nu am găsit valori lipsă în acest set de date, așa că putem trece la pasul următor.

Alăturați-vă Cursului de inteligență artificială online de la cele mai bune universități din lume - Master, programe executive postuniversitare și program de certificat avansat în ML și AI pentru a vă accelera cariera.

Pasul 3: Vizualizare

În acest pas al proiectului nostru de detectare a fraudei cu cardul de credit, ne vom vizualiza datele. Vizualizarea ajută la înțelegerea a ceea ce arată datele noastre și dezvăluie orice tipare pe care am putea să le fi ratat. Să creăm o diagramă a setului nostru de date:

# complot normal și fraudă

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

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

plt.title(„Tranzacții distribuite”)

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

plt.xlabel(„Clasă”)

plt.ylabel(„Frecvență”)

plt.show()

În graficul nostru, am constatat că datele sunt foarte dezechilibrate. Aceasta înseamnă că nu putem folosi algoritmi de învățare supravegheată, deoarece va avea ca rezultat o supraadaptare. În plus, nu ne-am dat seama care ar fi cea mai bună metodă de a ne rezolva problema, așa că vom efectua mai multe vizualizări. Utilizați următoarele pentru a reprezenta harta termică:

# harta termografica

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

plt.show()

Acum, vom crea grafice de distribuție a datelor pentru a ne ajuta să înțelegem de unde provin datele noastre:

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

pentru i, ax în 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={“culoare”: „#4e8ef5”})

ax.set_xlabel(”)

fig.tight_layout(h_pad=-1,5, w_pad=-1,5)

plt.show()

Cu graficele de distribuție a datelor, am constatat că aproape fiecare caracteristică provine din distribuția Gaussiană, cu excepția „Timpului”.

Deci vom folosi distribuția Gaussiană multivariată pentru a detecta frauda. Deoarece numai caracteristica „Timp” provine din distribuția bimodală (și rețineți distribuția gaussiană), o vom renunța. Mai mult, vizualizarea noastră a dezvăluit că funcția „Timp” nu are valori extreme ca celelalte, ceea ce este un alt motiv pentru care o vom renunța.

Adăugați următorul cod pentru a renunța la caracteristicile discutate și pentru a scala altele:

clase = df['Class']

df.drop(['Timp', 'Clasa', 'Suma'], axa=1, inplace=True)

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

MMscaller = MinMaxScaler()

df = MMscaller.fit_transform(df)

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

df = pd.concat([df, clase], axa=1)

Pasul 4: Împărțirea setului de date

Creați un fișier „functions.py”. Aici, vom adăuga funcții pentru a implementa diferitele etape ale algoritmului nostru. Cu toate acestea, înainte de a adăuga acele funcții, să ne împărțim setul de date în două seturi, setul de validare și setul de testare.

importa panda ca pd

import numpy ca np

def train_validation_splits(df):

# Tranzacții de fraudă

fraudă = df[df['Clasa'] == 1]

# Tranzacții normale

normal = df[df['Clasa'] == 0]

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

print('fraud:', fraud.shape[0])

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

fraud_test_start = int(fraud.shape[0] * .5)

normal_train_start = normal_test_start * 2

val_normal = normal[:normal_test_start]

val_fraud = fraudă[:fraud_test_start]

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

test_normal = normal[normal_test_start:normal_train_start]

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

set_test = pd.concat([test_normal, test_fraud], axa=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]

returnează Xtrain.to_numpy(), Xtest.to_numpy(), Xval.to_numpy(), Ytest.to_numpy(), Yval.to_numpy()

Pasul 5: Calculați matricea medie și covarianță

Următoarea funcție ne va ajuta să calculăm media și matricea de covarianță:

def estimate_gaussian_params(X):

„””

Calculează media și covarianța pentru fiecare caracteristică.

Argumente:

X: set de date

„””

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

sigma = np.cov(XT)

return mu, sigma

Pasul 6: Adăugați atingerile finale

În fișierul nostru „main.py”, vom importa și vom apela funcțiile pe care le-am implementat în pasul anterior pentru fiecare set:

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

(mu, sigma) = estimate_gaussian_params(Xtrain)

# calculează pdf gaussian

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

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

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

Acum trebuie să ne referim la epsilon (sau la prag). De obicei, cel mai bine este să inițializați pragul cu valoarea minimă a pdf-ului și să creșteți cu fiecare pas până când ajungeți la pdf-ul maxim, salvând în același timp fiecare valoare epsilon într-un vector.

După ce creăm vectorul necesar, facem o buclă „for” și iterăm peste aceeași. Comparăm pragul cu valorile pdf-ului care generează predicțiile noastre în fiecare iterație.

De asemenea, calculăm scorul F1 în funcție de valorile noastre de adevăr la sol și de predicții. Dacă scorul F1 găsit este mai mare decât cel anterior, înlocuim o variabilă „cel mai bun prag”.

Rețineți că nu putem folosi „acuratețea” ca măsură în proiectul nostru de detectare a fraudelor cu cardul de credit. Asta pentru că ar reflecta toate tranzacțiile în mod normal, cu o acuratețe de 99%, făcând algoritmul nostru inutil.

Vom implementa toate procesele pe care le-am discutat mai sus în fișierul nostru „functions.py”:

def metrics(y, predictions):

fp = np.sum(np.all([predicții == 1, y == 0], axa=0))

tp = np.sum(np.all([predicții == 1, y == 1], axa=0))

fn = np.sum(np.all([predicții == 0, y == 1], axa=0))

precizie = (tp / (tp + fp)) dacă (tp + fp) > 0 altfel 0

recall = (tp / (tp + fn)) dacă (tp + fn) > 0 altfel 0

F1 = (2 * precizie * rechemare) / (precizie +

recall) dacă (precizie + recall) > 0 altfel 0

returnare precizie, recall, F1

def select Threshold(yval, pval):

e_values ​​= pval

cel mai bunF1 = 0

cel mai bun Epsilon = 0

pentru epsilon în e_values:

previziuni = pval < epsilon

(precizie, rechemare, F1) = metrics(yval, predictions)

dacă F1 > bestF1:

cel mai bunF1 = F1

bestEpsilon = epsilon

returnează bestEpsilon, bestF1

În cele din urmă, vom importa funcțiile din fișierul „main.py” și le vom apela pentru a returna scorul F1 și pragul. Ne va permite să evaluăm modelul nostru pe setul de testare:

(epsilon, F1) = select Threshold(Yval, pval)

print(„Cel mai bun epsilon găsit:”, epsilon)

print(„Cel mai bun F1 pe setul de validare încrucișată:”, F1)

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

print(„Valori abere găsite:”, np.sum(ptest < epsilon))

print(„Precizie set de testare:”, precizie_test)

print(„Test set Recall:”, test_recall)

print(„Scorul setului de test F1:”, test_F1)

Iată rezultatele acestui efort:

Cel mai bun epsilon găsit: 5e-324

Cel mai bun F1 pe set de validare încrucișată: 0,7852998065764023

Valori aberante găsite: 210

Set de testare Precizie: 0,9095238095238095

Set de testare Recall: 0,7764227642276422

Scorul setului de testare F1: 0,837719298245614

Concluzie

Iată-l – un proiect complet funcțional de detectare a fraudei cu cardul de credit!

Dacă aveți întrebări sau sugestii cu privire la acest proiect, anunțați-ne lăsând un comentariu mai jos. Ne-am bucura sa primim vesti de la tine.

Cu toate abilitățile învățate, puteți deveni activ și pe alte platforme competitive pentru a vă testa abilitățile și a obține și mai mult hands-on. Dacă sunteți interesat să aflați mai multe despre curs, consultați pagina Programului Executive PG în Machine Learning și AI și discutați cu consilierul nostru de carieră pentru mai multe informații.