Progetto di rilevamento delle frodi con carta di credito - Progetto di apprendimento automatico

Benvenuto nel nostro progetto di rilevamento delle frodi con carta di credito. Oggi utilizzeremo Python e l'apprendimento automatico per rilevare le frodi in un set di dati di transazioni con carta di credito. Sebbene abbiamo condiviso il codice per ogni passaggio, sarebbe meglio capire come funziona ogni passaggio e quindi implementarlo.

Cominciamo!

Progetto di rilevamento delle frodi con carta di credito con passaggi

Nel nostro progetto di rilevamento delle frodi con carta di credito, utilizzeremo Python, uno dei linguaggi di programmazione più popolari disponibili. La nostra soluzione rileverebbe se qualcuno aggira i muri di sicurezza del nostro sistema ed effettua una transazione illegittima.

Il set di dati contiene transazioni con carta di credito e le sue caratteristiche sono il risultato dell'analisi PCA. Ha le funzioni "Importo", "Tempo" e "Classe" dove "Importo" mostra il valore monetario di ogni transazione, "Tempo" mostra i secondi trascorsi tra la prima e la rispettiva transazione e "Classe" mostra se una transazione è legittimo o no.

In "Classe", il valore 1 rappresenta una transazione fraudolenta e il valore 0 rappresenta una transazione valida.

È possibile ottenere il set di dati e l'intero codice sorgente qui .

Passaggio 1: importare i pacchetti

Inizieremo il nostro progetto di rilevamento delle frodi con carta di credito installando i pacchetti richiesti. Crea un file 'main.py' e importa questi pacchetti:

importa numpy come np

importa panda come pd

importa sklearn

dalla norma di importazione di scipy.stats

da scipy.stats import multivariate_normal

da sklearn.preprocessing import MinMaxScaler

importa matplotlib.pyplot come plt

import seaborn come sns

Passaggio 2: cerca gli errori

Prima di utilizzare il set di dati, dovremmo cercare eventuali errori e valori mancanti in esso. La presenza di valori mancanti può far sì che il tuo modello dia risultati errati, rendendolo inefficiente e inefficace. Quindi, leggeremo il set di dati e cercheremo eventuali valori mancanti:

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

# valori mancanti

print("valori mancanti:", df.isnull().values.any())

Non abbiamo trovato valori mancanti in questo set di dati, quindi possiamo procedere al passaggio successivo.

Partecipa al corso di intelligenza artificiale online dalle migliori università del mondo: master, programmi post-laurea esecutivi e programma di certificazione avanzato in ML e AI per accelerare la tua carriera.

Passaggio 3: visualizzazione

In questa fase del nostro progetto di rilevamento delle frodi con carta di credito, visualizzeremo i nostri dati. La visualizzazione aiuta a capire cosa mostrano i nostri dati e rivela eventuali schemi che potremmo aver perso. Creiamo un grafico del nostro set di dati:

# trama normale e frode

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

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

plt.title ("Transazioni distribuite")

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

plt.xlabel ("Classe")

plt.ylabel ("Frequenza")

plt.show()

Nella nostra trama, abbiamo scoperto che i dati sono molto sbilanciati. Ciò significa che non possiamo utilizzare algoritmi di apprendimento supervisionato in quanto si tradurrà in un overfitting. Inoltre, non abbiamo capito quale sarebbe il metodo migliore per risolvere il nostro problema, quindi eseguiremo più visualizzazioni. Utilizzare quanto segue per tracciare la mappa di calore:

# mappa di calore

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

plt.show()

Ora creeremo grafici di distribuzione dei dati per aiutarci a capire da dove provengono i nostri dati:

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

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

ax.set_facecolor('xkcd:charcoal')

ax.set_title(df.colonne[i])

sns.distplot(df.iloc[:, i], ax=ax, fit=norma,

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

ax.set_xlabel()

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

plt.show()

Con i grafici di distribuzione dei dati, abbiamo scoperto che quasi tutte le caratteristiche provengono dalla distribuzione gaussiana ad eccezione di "Time".

Quindi useremo la distribuzione gaussiana multivariata per rilevare le frodi. Poiché solo la funzione "Tempo" deriva dalla distribuzione bimodale (e nota la distribuzione gaussiana), la scarteremo. Inoltre, la nostra visualizzazione ha rivelato che la funzione "Ora" non ha valori estremi come le altre, motivo in più per eliminarla.

Aggiungi il codice seguente per eliminare le funzionalità di cui abbiamo discusso e ridimensionarne altre:

classi = df['Classe']

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

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

MMscaler = MinMaxScaler()

df = MMscaller.fit_transform(df)

df = pd.DataFrame(dati=df, colonne=cols)

df = pd.concat([df, classi], asse=1)

Passaggio 4: dividere il set di dati

Crea un file 'functions.py'. Qui aggiungeremo funzioni per implementare le diverse fasi del nostro algoritmo. Tuttavia, prima di aggiungere queste funzioni, dividiamo il nostro set di dati in due set, il set di convalida e il set di test.

importa panda come pd

importa numpy come np

def train_validation_splits(df):

# Transazioni fraudolente

frode = df[df['Class'] == 1]

# Transazioni normali

normale = df[df['Classe'] == 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)

inizio_treno_normale = inizio_test_normale * 2

val_normale = normale[:normal_test_start]

val_fraud = frode[:fraud_test_start]

set_validazione = pd.concat([val_normal, val_fraud], asse=0)

test_normale = normale[normal_test_start:normal_train_start]

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

set_test = pd.concat([test_normal, test_fraud], asse=0)

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

Yval = validation_set.iloc[:, -1]

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

Ytest = set_test.iloc[:, -1]

treno_set = normale[normal_train_start:normal.shape[0]]

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

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

Passaggio 5: calcolare la media e la matrice di covarianza

La seguente funzione ci aiuterà a calcolare la media e la matrice di covarianza:

def stima_gaussiana_params(X):

“””

Calcola la media e la covarianza per ciascuna caratteristica.

Argomenti:

X: set di dati

“””

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

sigma = np.cov(XT)

ritorna mu, sigma

Passaggio 6: aggiungi i tocchi finali

Nel nostro file 'main.py' importeremo e chiameremo le funzioni che abbiamo implementato nel passaggio precedente per ogni set:

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

(mu, sigma) = stima_gaussiana_params(Xtrain)

# calcola il pdf gaussiano

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

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

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

Ora dobbiamo fare riferimento all'epsilon (o alla soglia). Di solito, è meglio inizializzare la soglia con il valore minimo del pdf e aumentare ad ogni passaggio fino a raggiungere il pdf massimo salvando ogni valore epsilon in un vettore.

Dopo aver creato il vettore richiesto, creiamo un ciclo "for" e ripetiamo lo stesso. Confrontiamo la soglia con i valori del pdf che generano le nostre previsioni in ogni iterazione.

Calcoliamo anche il punteggio F1 in base ai nostri valori di verità di base e alle previsioni. Se il punteggio F1 trovato è superiore al precedente, sovrascriviamo una variabile di "soglia migliore".

Tieni presente che non possiamo utilizzare la "precisione" come metrica nel nostro progetto di rilevamento delle frodi con carte di credito. Questo perché rifletterebbe tutte le transazioni normalmente con una precisione del 99%, rendendo il nostro algoritmo inutile.

Implementeremo tutti i processi di cui abbiamo discusso sopra nel nostro file 'functions.py':

def metriche(y, previsioni):

fp = np.sum(np.all([predizioni == 1, y == 0], asse=0))

tp = np.sum(np.all([predizioni == 1, y == 1], asse=0))

fn = np.sum(np.all([predizioni == 0, y == 1], asse=0))

precisione = (tp / (tp + fp)) se (tp + fp) > 0 altrimenti 0

richiamo = (tp / (tp + fn)) se (tp + fn) > 0 altrimenti 0

F1 = (2 * precisione * richiamo) / (precisione +

richiamo) se (precisione + richiamo) > 0 altrimenti 0

precisione di ritorno, richiamo, F1

def seleziona Soglia(yval, pval):

valori_e = pval

miglioreF1 = 0

bestEpsilon = 0

per epsilon in valori_e:

previsioni = pval < epsilon

(precisione, richiamo, F1) = metriche (yval, previsioni)

se F1 > miglioreF1:

miglioreF1 = F1

bestEpsilon = epsilon

restituisce bestEpsilon, bestF1

Alla fine importeremo le funzioni nel file 'main.py' e le chiameremo per restituire il punteggio F1 e la soglia. Ci permetterà di valutare il nostro modello sul set di prova:

(epsilon, F1) = seleziona Soglia (Yval, pval)

print("La migliore epsilon trovata:", epsilon)

print("Migliore F1 sul set di convalida incrociata:", F1)

(test_precisione, test_recall, test_F1) = metriche(Ytest, ptest < epsilon)

print("Sono stati trovati valori anomali:", np.sum(ptest < epsilon))

print("Test set Precision:", test_precision)

print("Richiama set di prova:", test_recall)

print("Test set punteggio F1:", test_F1)

Ecco i risultati di tutto questo sforzo:

Miglior epsilon trovato: 5e-324

Miglior set F1 su convalida incrociata: 0,7852998065764023

Valori anomali trovati: 210

Set di prova Precisione: 0.9095238095238095

Test set Richiamo: 0.7764227642276422

Punteggio F1 del set di prova: 0,837719298245614

Conclusione

Il gioco è fatto: un progetto di rilevamento delle frodi con carta di credito completamente funzionale!

Se hai domande o suggerimenti su questo progetto, faccelo sapere lasciando un commento qui sotto. Ci piacerebbe sentirti.

Con tutte le abilità apprese puoi diventare attivo anche su altre piattaforme competitive per mettere alla prova le tue abilità e avere ancora più esperienza. Se sei interessato a saperne di più sul corso, dai un'occhiata alla pagina dell'Execitive PG Program in Machine Learning & AI e parla con il nostro consulente di carriera per maggiori informazioni.