Implementare la rilevazione delle transazioni fraudolente utilizzando le MLOP

Potenziare la rilevazione delle transazioni fraudolente mediante l'utilizzo delle MLOP

Introduzione

Nel mondo digitale di oggi, le persone stanno sempre più passando alle transazioni online e ai pagamenti digitali per comodità anziché usare moneta contante. Con l’aumento delle transazioni, aumenta anche la frode. La transazione fraudolenta può essere di qualsiasi tipo, poiché coinvolge richieste di denaro utilizzando false identità o false informazioni. Ciò rappresenta un problema significativo per individui e istituzioni finanziarie. In questo progetto, utilizzeremo il dataset delle carte di credito per progettare un modello di MLOPs utilizzando lo strumento Airflow per monitorare le transazioni in tempo reale e prevedere se sono genuine o fraudolente.

Obiettivi di Apprendimento

  • Importanza del rilevamento delle transazioni fraudolente.
  • Pulizia dei dati, trasformazione dei dataset e pre-elaborazione dei dati.
  • Analisi visiva del dataset per ottenere informazioni.
  • Applicazione del modello di rilevamento delle transazioni fraudolente nell’ambito della scienza dei dati.
  • Analisi dei dati delle transazioni fraudolente utilizzando il linguaggio di programmazione Python.
  • Creazione di un sistema di rilevamento delle transazioni fraudolente end-to-end utilizzando MS Azure e Airflow.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Cos’è il modello di stima delle transazioni fraudolente?

Il dataset delle transazioni fraudolente contiene dati da diverse fonti, che includono colonne come orario della transazione, nome, importo, genere, categoria, ecc. Il modello di stima delle transazioni fraudolente è un modello di apprendimento automatico sviluppato per prevedere le transazioni false. Il modello viene addestrato su un ampio set di transazioni valide e fraudolente per prevedere le nuove transazioni false.

Cos’è l’analisi delle transazioni fraudolente?

L’analisi delle transazioni fraudolente è il processo di analisi del dataset storico. L’analisi del dataset mira a individuare l’irregolarità dei dati e a trovare i pattern nel dataset. L’analisi delle transazioni fraudolente svolge un ruolo cruciale nel mondo degli affari per proteggere i clienti e ridurre le perdite finanziarie. Ci sono diversi tipi di analisi delle transazioni fraudolente, come l’analisi basata su regole e la rilevazione delle anomalie.

  • Analisi basata su regole: L’analisi basata su regole prevede la creazione di una regola per identificare le transazioni non valide. Ad esempio, le regole possono essere basate sulla regione geografica.
  • Rilevazione delle anomalie: La rilevazione delle anomalie consiste nel trovare transazioni insolite o anomale. Ad esempio, una transazione effettuata da un nuovo indirizzo IP.

Importanza del Rilevamento delle Transazioni Fraudolente

Il rilevamento delle transazioni fraudolente è essenziale per le aziende e le istituzioni finanziarie al fine di proteggere i clienti dalla frode e salvaguardare il loro denaro. Di seguito sono riportati alcuni motivi cruciali per rilevare le transazioni fraudolente.

  • Riduzione delle Perdite Finanziarie: Le transazioni fraudolente comportano per le aziende una significativa perdita di denaro, riducendo il loro profitto. Pertanto, diventa essenziale per le aziende rilevare le transazioni fraudolente.
  • Protezione della Reputazione: Il mantenimento della reputazione è una delle cose essenziali per le aziende, poiché porta alla perdita di potenziali clienti.
  • Protezione dei Clienti e dell’Attività: Le transazioni fraudolente possono causare una perdita finanziaria e un impatto emotivo sui clienti. Rilevando la frode, l’attività può proteggere i clienti e la propria attività.

Raccolta e Pre-elaborazione dei Dati

La raccolta e la pre-elaborazione dei dati sono parti importanti nello sviluppo del modello di rilevamento delle frodi. Una volta raccolti i dati, ci sono diverse fasi da eseguire sul dataset.

  • Pulizia dei Dati: La pulizia dei dati comporta la rimozione dei dati indesiderati, come i dati duplicati, e il riempimento dei valori mancanti.
  • Trasformazione dei Dati: La trasformazione dei dati comporta la conversione delle colonne dei dati nei tipi di dati richiesti per l’analisi. Questa fase garantisce la qualità dei dati.
  • Esplorazione dei Dati: L’esplorazione dei dati comporta la comprensione del dataset e la ricerca delle relazioni e dei pattern tra i dati.
  • Gestione dei Dati Sbilanciati: Il dataset di rilevamento delle frodi è fortemente sbilanciato, in quanto ci sono molte transazioni valide e un numero ridotto di transazioni fraudolente. Quindi, c’è un’alta probabilità che il modello possa diventare sovradattato. Questo problema può essere affrontato utilizzando tecniche di sovracampionamento o sotto campionamento. Utilizzando queste tecniche, è possibile creare un dataset bilanciato.

Visualizzazione del set di dati per la rilevazione delle frodi utilizzando le librerie

Guardare i numeri numerici potrebbe non aiutarti a trovare una relazione tra di loro. Utilizzeremo le librerie Python per creare grafici e grafici per ottenere informazioni dal set di dati.

  • Matplotlib: Uno degli strumenti essenziali in Python utilizzato per creare diversi tipi di grafici come grafici a barre e a linee.
  • Seaborn: Questo è un altro strumento di visualizzazione in Python. Aiuta a creare immagini di visualizzazione più dettagliate come mappe di calore e grafici a violino.

Tecniche utilizzate per visualizzare il set di dati delle prenotazioni degli hotel.

  • Countplot: Countplot viene utilizzato per graficare l’istogramma del valore categorico. Questo aiuta a graficare le frodi rispetto a diversi valori categorici, il che aiuta a comprendere la loro relazione.
  • Distplot: Utilizzando distplot, possiamo determinare la distribuzione nel tempo. Questo aiuta a verificare l’asimmetria.

Casi d’uso e applicazioni del modello MLOPs per la rilevazione delle frodi

Il modello MLOP per la rilevazione delle frodi ha molteplici casi d’uso in diversi settori. Di seguito è riportata l’applicazione dei casi d’uso:

  1. Banche e istituti finanziari: – Banche e istituti finanziari utilizzano strumenti MLOP per individuare transazioni fraudolente come frodi con carte di credito e assicurazioni. Utilizzando questi strumenti, possono ridurre le frodi.
  2. E-commerce e settore al dettaglio: – L’identificazione delle transazioni fraudolente durante l’acquisto di un oggetto può aiutare a proteggere i dati dei clienti e l’azienda.
  3. Sanità e ospitalità: – Il settore sanitario utilizza i MLOP per rilevare false richieste mediche o pratiche di fatturazione. Utilizzando un modello di rilevamento, queste false pratiche possono essere ridotte.
  4. Telecomunicazioni e biglietteria online: – Rilevare scambio fraudolento di SIM, frodi di abbonamento e prenotazioni false. Questo problema può essere affrontato utilizzando il modello MLOPs.

Sfide e migliori pratiche nel modello MLOPs per la rilevazione delle frodi

La creazione di un modello di rilevamento delle frodi presenta diverse sfide per vari motivi:

  • Qualità dei dati: La qualità dei dati svolge un ruolo cruciale nel modello di rilevamento delle frodi addestrato su dati storici. Più è buono il set di dati, più preciso sarà il modello. Il set di dati delle frodi è più un set di dati sbilanciato, il che significa che abbiamo più transazioni valide rispetto a transazioni non valide. Questo pone una sfida nella fase di addestramento del modello.
  • Privacy dei dati: Le transazioni fraudolente spesso si verificano a causa della violazione dell’accesso ai dati del cliente o dell’azienda tramite mezzi non autorizzati. Progettare il modello in modo tale da mantenere la privacy dei dati dei clienti.
  • Deriva del modello: La deriva del modello rappresenta una sfida significativa a causa dei cambiamenti nella qualità dei dati. Garantire che il modello non subisca deriva del modello richiede il mantenimento della qualità dei dati e il monitoraggio del modello.
  • Elaborazione in tempo reale: L’elaborazione in tempo reale comporta spesso maggiori sfide in quanto aggiunge un ulteriore livello di complessità.

Migliori pratiche nella creazione di un modello di rilevamento delle frodi:

Le migliori pratiche per la creazione di un modello di rilevamento delle frodi sono discusse di seguito

  • Ingegneria delle caratteristiche: Dopo aver completato la raccolta dei dati, eseguiamo la pre-elaborazione dei dati e l’ingegneria delle caratteristiche per garantire l’ottenimento di dati di buona qualità.
  • Elaborazione dei dati sbilanciati: I set di dati per la rilevazione delle frodi spesso presentano uno sbilanciamento, con molte transazioni valide rispetto a transazioni fraudolente. Questo sbilanciamento spesso causa un bias nel modello. Per affrontare questo problema, utilizziamo tecniche di sotto-campionamento e sovracampionamento.
  • Creazione del modello: La tecnica dell’ensemble viene utilizzata per addestrare il modello, garantendo che il modello risultante abbia una buona accuratezza. Il modello risultante sarà in grado di prevedere sia le frodi che le transazioni valide.
  • MLOPs: Utilizzare il framework MLOPs per costruire l’intero ciclo di vita della soluzione, dall’addestramento alla distribuzione e al monitoraggio. Questo framework stabilisce le regole per la costruzione del modello e garantisce che il modello sia accurato e affidabile.

Con l’aumento della digitalizzazione e dell’adozione di Internet, sempre più persone utilizzeranno metodi di pagamento digitali e servizi di prenotazione online. Con l’aumento dello sviluppo tecnologico, verrà creato uno strumento di pagamento facile e veloce. Pertanto, diventa essenziale sviluppare uno strumento che prevenga le frodi e aumenti la fiducia dei clienti nell’azienda e nei servizi. Le aziende cercano spesso soluzioni affidabili, accessibili ed economiche. La tecnologia può svolgere un ruolo cruciale in questo. Costruire strumenti e servizi attorno al prodotto finanziario può aiutare l’azienda a fornire una vasta gamma di servizi ai propri clienti. Questo prodotto finanziario personalizzato può anche essere fornito, consentendo maggiore fiducia e migliorando le relazioni tra clienti e aziende.

Analisi dei dati di rilevamento frodi utilizzando Python

Eseguiamo un’analisi dei dati fondamentale utilizzando l’implementazione di Python su un dataset da Kaggle. Per scaricare il dataset, clicca qui.

Dettagli dei dati

Il dataset di rilevamento frodi contiene oltre 1 milione di record su cui il modello verrà addestrato. Di seguito sono riportati i dettagli del dataset:

Passo 1 Importare le librerie

import randomimport calendarimport pandas as pdimport numpy as npimport seaborn as snsimport matplotlib.pyplot as pltfrom scipy.stats import norm, skew, ttest_indimport warningswarnings.filterwarnings('ignore')

Passo 2 Importazione del dataset e ispezione dei dati

#Leggere i dati dal file di addestramento e di test e convertirli in dataframe df=pd.read_csv('C:\Decodr\G3\B\FRAUD_DETECTION_IN_IMBALANCED_DATA\data2\Train.csv')T_df=pd.read_csv('C:\Decodr\G3\B\FRAUD_DETECTION_IN_IMBALANCED_DATA\data2\Test.csv')#Forma del dataframe df.shape,T_df.shape((1048575, 22), (555719, 22))#Controllare le informazioni sui dataframe di addestramento e di test df.info(),T_df.info()#Controllare i valori nulli nei dataframe di addestramento e di test df.isna().sum(),T_df.isna().sum()

OUTPUT

Passo 3 Visualizzazione del Dataset

#Frode in base alla categoria sns.countplot(data=df[df['is_fraud_cat'] == "T"], x='category')plt.xticks(rotation=45)plt.show()

OUTPUT

IntuizioneLa maggior parte delle frodi si verifica nelle categorie di shopping_net e grocery_pos

#Frode in base al genere sns.countplot(data=df[df['is_fraud_cat']=="T"],x='gender') plt.show()

OUTPUT

IntuizioneSebbene più casi di frode siano avvenuti con clienti femminili, il numero è quasi lo stesso sia per maschi che per femmine.

#Frode in base allo statofig, ax = plt.subplots(figsize=(120,60))plt.rcParams.update({'font.size': 60})sns.countplot(data=df[df['is_fraud_cat']=="T"],x='state')plt.xticks(rotation=45)for p, label in zip(ax.patches, df["state"].value_counts().index):    ax.annotate(label, (p.get_x(), p.get_height()+0.15))plt.title("Numero di frodi con carte di credito per stato")plt.show()

OUTPUT

IntuizioneGli Stati OH, TX e LA segnalano il numero più significativo di frodi con carte di credito

#Frode in base alla cittàdef randomcolor():    r = random.random()    b = random.random()    g = random.random()    rgb = [r,g,b]    return rgbplt.rcParams.update({'font.size': 20})df[df['is_fraud_cat']=="T"]["city"].value_counts(sort=True,ascending=False).head(10).plot(kind="bar",color=randomcolor())plt.title("Numero di frodi con carte di credito per città")plt.show()

OUTPUT

Insight Dallas, Houston e Birmingham segnalano il maggior numero di frodi a livello cittadino.

#Frode in base a Jobdf[df['is_fraud_cat']=="T"]["job"].value_counts(sort=True,ascending=False).head(10).plot(kind="bar",color=randomcolor())plt.title("Numero di frodi con carte di credito per lavoro")plt.show()

OUTPUT

Insight La maggior parte delle frodi si verificano nel lavoro di geometra, seguito da architetto navale e ingegnere dei materiali

#Frode vs Non Frode plt.figure(figsize=(8,5))ax = sns.countplot(x="is_fraud", data=df,color=randomcolor())for p in ax.patches:     ax.annotate('{:.1f}'.format(p.get_height()), (p.get_x()+0.25, p.get_height()+0.01))plt.show()

OUTPUT

Insight Solo circa 6006 voci rappresentano transazioni fraudolente su quasi 1 milione di voci; quindi, stiamo guardando un dataset sbilanciato.

Passaggio 4. Preprocessing e Feature Engineering

data['trans_date_trans_time'] = pd.to_datetime(data['trans_date_trans_time'], format='%d-%m-%Y %H:%M')data['trans_date']=data['trans_date_trans_time'].dt.strftime('%Y-%m-%d')data['trans_date']=pd.to_datetime(data['trans_date'])data['dob']=pd.to_datetime(data['dob'],format='%d-%m-%Y')data["age"] = data["trans_date"]-data["dob"]data["age"] = data["age"].astype('int64')data['trans_month'] = pd.DatetimeIndex(data['trans_date']).monthdata['trans_year'] = pd.DatetimeIndex(data['trans_date']).yeardata['Month_name'] = data['trans_month'].apply(lambda x: calendar.month_abbr[x])data['latitudinal_distance'] = abs(round(data['merch_lat']-data['lat'],3))data['longitudinal_distance'] = abs(round(data['merch_long']-data['long'],3))data.gender=data.gender.apply(lambda x: 1 if x=="M" else 0)data = data.drop(['cc_num','merchant','first','last','street','zip','trans_num','unix_time','trans_date_trans_time','city','lat','long','job','dob','merch_lat','merch_long','trans_date','state','Month_name'],axis=1)data =pd.get_dummies(data,columns=['category'],drop_first=True)#Esecuzione di Undersamplingnormal = data[data['is_fraud']==0]fraud = data[data['is_fraud']==1]normal_sample=normal.sample(n=len(fraud),random_state=42)new_data = pd.concat([normal_sample,fraud],ignore_index=True)

Creazione di un modello end-to-end utilizzando MS Azure e Airflow

Nel passaggio precedente, stavo leggendo i file di dati in locale per la visualizzazione, ma per la parte di implementazione, utilizzeremo servizi cloud come MS Azure.
Ti mostrerò come ho integrato MS Azure con lo strumento Airflow per l’ingestione e la creazione del modello dati. In MS Azure, innanzitutto, creare un account di archiviazione e quindi al suo interno un contenitore. In questo contenitore, memorizzare il file. Costruiremo un flusso di lavoro di Airflow che recupera i dati dal contenitore e li tiene nella posizione richiesta. Successivamente, costruiremo un modello end-to-end e verrà distribuito nel cloud in streaming dove può essere reso pubblico.

Per creare un account di archiviazione, è necessario creare un account di Azure. Segui i seguenti passaggi:

  • Crea un account MS Azure
  • Crea un account di archiviazione
  • Crea un contenitore all’interno dell’account di archiviazione
  • Una volta creato il contenitore, carica il file manualmente o utilizzando Airflow DAG.

Che cos’è Airflow?

Airflow è una piattaforma di gestione dei flussi di lavoro open-source che aiuta a creare e monitorare il modello. Utilizza il Grafo Aciclico Diretto (DAG) per definire il flusso di lavoro. Airflow offre diversi vantaggi, come descritto di seguito:

  • Flussi di lavoro definiti dinamicamente: In Airflow, è possibile definire un flusso di lavoro personalizzato utilizzando Python. È possibile creare e modificare facilmente questo flusso di lavoro, offrendo flessibilità al flusso di lavoro.
  • Scalabile: È possibile scalare rapidamente Airflow per gestire contemporaneamente più flussi di lavoro utilizzando un’architettura distribuita.
  • Monitoraggio e registrazione: Airflow offre un’interfaccia web user-friendly. Utilizzando l’interfaccia web, gli utenti possono monitorare e visualizzare i log. Questo aiuta a risolvere rapidamente i problemi.
  • Esecuzione parallela: Airflow offre la funzionalità di eseguire il flusso di lavoro in parallelo, riducendo significativamente i tempi di esecuzione. Migliora anche le prestazioni del modello.

Nel mondo reale, costruire un modello non è sufficiente; è necessario distribuire il modello in produzione e monitorare le prestazioni del modello nel tempo e come interagisce con i dati del mondo reale. È possibile creare un processo di apprendimento automatico end-to-end e monitorarlo utilizzando Airflow. In Airflow, è possibile creare un flusso di lavoro e impostare le dipendenze in base alle quali verranno eseguite. Lo stato del flusso di lavoro può essere controllato in Airflow, ad esempio se è stato completato con successo, se è stato riavviato, ecc. Dopo l’esecuzione del flusso di lavoro, i log possono essere monitorati in Airflow. In questo modo, è possibile tenere traccia del modello pronto per la produzione. Consiglio vivamente di consultare il documento Airflow per ulteriori dettagli.

Il Flusso di Lavoro

Il flusso di lavoro è composto dai seguenti passaggi:

  • data_upload_operator: – Questo operatore prenderà il file dalla memoria locale e lo caricherà nel contenitore Azure Blob.
  • data_download_operator: – Questo operatore scaricherà il file dal cloud Azure nella memoria locale.
  • data_preprocessing_operator: – Questo operatore esegue il preprocessing sul dataset scaricato da Azure.
  • data_split_operator: – Questo operatore suddividerà il dataset in due parti. Nella prima parte, il modello verrà addestrato e nella seconda parte verrà testato.
  • model_training_operator: – Questo operatore addestra il modello sul dataset.
  • model_evaluation_operator: – Questo operatore viene utilizzato per valutare le prestazioni del modello.
  • model_prediction_operator: – Questo operatore viene utilizzato per effettuare la previsione del modello su un nuovo dataset non visto.

Sviluppo del Modello

Come descritto sopra, abbiamo diversi operatori di Airflow. Ora passiamo alla parte di codifica.

data_upload_operator

from azure.storage.blob import BlobServiceClientfrom config.constant import storage_account_key, storage_account_name, connection_string, container_name, file_path_up, file_namedef uploadToBlobStorage():    try:        blob_service_client = BlobServiceClient.from_connection_string        (connection_string)        blob_client = blob_service_client.get_blob_client        (container = container_name, blob = file_name)        with open(file_path_up,"rb") as data:            blob_client.upload_blob(data)        print("Upload " + file_name + " from local to container " + container_name)    except Exception as e:        print(f"Si è verificato un errore: {str(e)}")uploadToBlobStorage()

Sopra, abbiamo definito il metodo uploadToBlobStorage(), che si collegherà all’account di archiviazione MS Azure. Quindi, prenderà il file dalla memoria locale e lo caricherà nel cloud.

data_download_operator

from azure.storage.blob import BlobServiceClientfrom config.constant import storage_account_key, storage_account_name, connection_string, container_name, blob_name, file_path_downdef downloadFromBlobStorage():    try:        # Inizializza un BlobServiceClient utilizzando la stringa di connessione        blob_service_client = BlobServiceClient.from_connection_string        (connection_string)        # Ottieni un BlobClient per il blob di destinazione        blob_client = blob_service_client.get_blob_client        (container=container_name, blob=blob_name)        # Scarica il blob in un file locale        with open(file_path_down, "wb") as data:            data.write(blob_client.download_blob().readall())        print(f"Scaricato {blob_name} da {container_name} a {file_path_down}")    except Exception as e:        print(f"Si è verificato un errore: {str(e)}")downloadFromBlobStorage()

Qui è definito il metodo downloadFromBlobStorage(). Si collegherà all’account di storage e scaricherà il file. Successivamente, il file verrà memorizzato nel percorso locale.

data_preprocessing_operator

from airflow.models import BaseOperator
from airflow.utils.decorators import apply_defaults 
import pandas as pd
import calendar

class DataPreprocessingOperator(BaseOperator):
    @apply_defaults
    def __init__(self, preprocessed_data, *args, **kwargs):
        super(DataPreprocessingOperator, self).__init__(*args, **kwargs)
        self.preprocessed_data = preprocessed_data

    def execute(self, context):
        try:
            # Esegui qui la logica di elaborazione dei dati.
            # Ad esempio, è possibile pulire, trasformare o elaborare
            # le caratteristiche dei dati acquisiti.
            data = pd.read_csv('data/processed/ingested_data.csv')
            data['trans_date_trans_time'] = pd.to_datetime(data['trans_date_trans_time'], format='%d-%m-%Y %H:%M')
            data['trans_date'] = data['trans_date_trans_time'].dt.strftime('%Y-%m-%d')
            data['trans_date'] = pd.to_datetime(data['trans_date'])
            data['dob'] = pd.to_datetime(data['dob'], format='%d-%m-%Y')
            data["age"] = data["trans_date"] - data["dob"]
            data["age"] = data["age"].astype('int64')
            data['trans_month'] = pd.DatetimeIndex(data['trans_date']).month
            data['trans_year'] = pd.DatetimeIndex(data['trans_date']).year
            data['Month_name'] = data['trans_month'].apply(lambda x: calendar.month_abbr[x])
            data['latitudinal_distance'] = abs(round(data['merch_lat'] - data['lat'], 3))
            data['longitudinal_distance'] = abs(round(data['merch_long'] - data['long'], 3))
            data.gender = data.gender.apply(lambda x: 1 if x == "M" else 0)
            data = data.drop(['cc_num', 'merchant', 'first', 'last', 'street', 'zip', 'trans_num', 'unix_time', 'trans_date_trans_time', 'city', 'lat', 'long', 'job', 'dob', 'merch_lat', 'merch_long', 'trans_date', 'state', 'Month_name'], axis=1)
            data = pd.get_dummies(data, columns=['category'], drop_first=True)
            
            # Esegui il Sottocampionamento
            normal = data[data['is_fraud'] == 0]
            fraud = data[data['is_fraud'] == 1]
            normal_sample = normal.sample(n=len(fraud), random_state=42)
            new_data = pd.concat([normal_sample, fraud], ignore_index=True)
            
            # Esegui il Sovracampionamento
            # normal = data[data['is_fraud']==0]
            # fraud = data[data['is_fraud']==1]
            # fraud_sample = fraud.sample(n=len(normal), replace=True, random_state=42)
            # new_data = pd.concat([normal, fraud_sample], ignore_index=True)

            # Salva i dati elaborati nel file di output (ad esempio, un file CSV)
            new_data.to_csv(self.preprocessed_data, index=False)
        
        except Exception as e:
            self.log.error(f'Elaborazione dei dati fallita: {str(e)}')
            raise e
  • Sopra, abbiamo cambiato il tipo di dato e cancellato le colonne
  • Dato che il dataset è sbilanciato, abbiamo eseguito il Sottocampionamento. Abbiamo anche inserito il codice per il Sovracampionamento.

model_training_operator

from airflow.models import BaseOperator
from airflow.utils.decorators import apply_defaults
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
import joblib

class ModelTrainingRFCOperator(BaseOperator):
    """Operator di Apache Airflow personalizzato per addestrare un modello di machine learning e salvarlo su un file."""
    def __init__(self, X_train_file, y_train_file, model_file, *args, **kwargs):
        """Inizializza l'operatore.
        :param X_train_file: Percorso del file delle caratteristiche del set di addestramento (X_train).
        :param y_train_file: Percorso del file delle etichette del set di addestramento (y_train).
        :param model_file: Percorso del file in cui salvare il modello addestrato.
        """
        super(ModelTrainingRFCOperator, self).__init__(*args, **kwargs)
        self.X_train_file = X_train_file
        self.y_train_file = y_train_file
        self.model_file = model_file

    def execute(self, context):
        self.log.info(f'Stiamo addestrando un modello di machine learning usando dati da {self.X_train_file, self.y_train_file}')
        try:
            X_train = pd.read_csv(self.X_train_file)
            y_train = pd.read_csv(self.y_train_file)

            print(X_train.shape)
            print(y_train.shape)

            # Inizializza e addestra il tuo modello di machine learning (sostituisci con la tua classe di modello)
            RFC = RandomForestClassifier(n_estimators=100, random_state=0)
            RFC.fit(X_train, y_train)

            # Salva il modello addestrato nel file model_file fornito
            joblib.dump(RFC, self.model_file)

        except Exception as e:
            self.log.error(f'Addestramento del modello fallito: {str(e)}')
            raise e

Dopo la fase di preprocessing e suddivisione dei dati, il passo successivo è addestrare il modello. Nel codice, abbiamo utilizzato RandomForestClassifier per l’addestramento del modello.

model_evaluation_operator

from airflow.models import BaseOperator
from airflow.utils.decorators import apply_defaults
import pandas as pd
from sklearn.metrics import accuracy_score, classification_report
import joblib

class ModelEvaluationRFCOperator(BaseOperator):
    """Operatore personalizzato di Apache Airflow per valutare un modello di apprendimento automatico e 
       salvare i risultati della valutazione su un file."""
       
    @apply_defaults
    def __init__(self, X_test_file, y_test_file, model_file, output_file, *args, **kwargs):
        """Inizializza l'operatore.
        
        :param X_test_file: Percorso del file contenente le caratteristiche del set di test (X_test).
        :param y_test_file: Percorso del file contenente le etichette del set di test (y_test).
        :param model_file: Percorso del file per caricare il modello addestrato.
        :param output_file: Percorso del file per salvare i risultati della valutazione.
        """
        super(ModelEvaluationRFCOperator, self).__init__(*args, **kwargs)
        self.X_test_file = X_test_file
        self.y_test_file = y_test_file
        self.model_file = model_file
        self.output_file = output_file
        
    def execute(self, context):
        self.log.info(f'Valutazione del modello di apprendimento automatico utilizzando i dati da {self.X_test_file, 
                                                                                             self.y_test_file}')
        # Recupera i dati di test dal task precedente utilizzando XCom
        test_data = context['ti'].xcom_pull(task_ids='data_split_task', key='test_data')
        try:
            """Esegui l'operatore per valutare un modello di apprendimento automatico e
               salvare i risultati della valutazione su un file."""
            # Carica i dati di test e il modello addestrato dai file forniti
            X_test = pd.read_csv(self.X_test_file)
            y_test = pd.read_csv(self.y_test_file)
            model = joblib.load(self.model_file)
            # Fai previsioni utilizzando il modello addestrato
            y_pred = model.predict(X_test)
            # Calcola e stampa le metriche di valutazione
            accuracy = accuracy_score(y_test, y_pred)
            classification_rep = classification_report(y_test, y_pred, target_names=['classe_0', 'classe_1'])  # Personalizza le etichette se necessario
            # Salva i risultati della valutazione nel file di output specificato
            with open(self.output_file, 'w') as f:
                f.write(f"Accuracy: {accuracy}\n\nClassification Report:\n{classification_rep}")
        except Exception as e:
            self.log.error(f'Fallimento della valutazione del modello: {str(e)}')
            raise e

Dopo l’addestramento del modello, abbiamo valutato il modello e preparato il report di classificazione. Qui, stiamo controllando l’accuratezza del modello, la precisione, il richiamo e il punteggio F1.

model_prediction_operator

from airflow.models import BaseOperator
from airflow.utils.decorators import apply_defaults
import pandas as pd
from sklearn.metrics import accuracy_score, classification_report
import joblib
import calendar

class ModelPredictionOperator(BaseOperator):
    """Operatore personalizzato di Apache Airflow per valutare un modello di apprendimento automatico e 
       salvare i risultati della valutazione su un file."""
       
    @apply_defaults
    def __init__(self, input_file, model_file, output_file, *args, **kwargs):
        """Inizializza l'operatore.
        
        :param input_file: Percorso del file di input.
        :param model_file: Percorso del file per caricare il modello addestrato.
        :param output_file: Percorso del file per salvare i risultati della valutazione.
        """
        super(ModelPredictionOperator, self).__init__(*args, **kwargs)
        self.input_file = input_file
        self.model_file = model_file
        self.output_file = output_file
        
    def execute(self, context):
        self.log.info(f'Valutazione del modello di apprendimento automatico utilizzando i dati da {self.input_file}')
        try:
            """Esegui l'operatore per valutare un modello di apprendimento automatico e
               salvare i risultati della valutazione su un file."""
            # Carica i dati di test e il modello addestrato dai file forniti
            new_data = pd.read_csv('data/raw/Test.csv')
            new_data['trans_date_trans_time'] = pd.to_datetime(new_data['trans_date_trans_time'], format='%d-%m-%Y %H:%M')
            new_data['trans_date'] = new_data['trans_date_trans_time'].dt.strftime('%Y-%m-%d')
            new_data['trans_date'] = pd.to_datetime(new_data['trans_date'])
            new_data['dob'] = pd.to_datetime(new_data['dob'], format='%d-%m-%Y')
            new_data["age"] = new_data["trans_date"] - new_data["dob"]
            new_data["age"] = new_data["age"].astype('int64')
            new_data['trans_month'] = pd.DatetimeIndex(new_data['trans_date']).month
            new_data['trans_year'] = pd.DatetimeIndex(new_data['trans_date']).year
            new_data['Month_name'] = new_data['trans_month'].apply(lambda x: calendar.month_abbr[x])
            new_data['latitudinal_distance'] = abs(round(new_data['merch_lat'] - new_data['lat'], 3))
            new_data['longitudinal_distance'] = abs(round(new_data['merch_long'] - new_data['long'], 3))
            new_data.gender = new_data.gender.apply(lambda x: 1 if x == "M" else 0)
            new_data = new_data.drop(['cc_num', 'merchant', 'first', 'last', 'street', 'zip', 'trans_num', 'unix_time', 'trans_date_trans_time', 'city', 'lat', 'long', 'job', 'dob', 'merch_lat', 'merch_long', 'trans_date', 'state', 'Month_name'], axis=1)
            new_data = pd.get_dummies(new_data, columns=['category'], drop_first=True)
            X_new = new_data.drop(["is_fraud"], axis=1)
            y_new = new_data["is_fraud"]
            model = joblib.load(self.model_file)
            # Fai previsioni utilizzando il modello addestrato
            y_pred_new = model.predict(X_new)
            print('y_new', y_new)
            print('y_pred_new', y_pred_new)
            # Calcola e stampa le metriche di valutazione
            accuracy = accuracy_score(y_new, y_pred_new)
            classification_rep = classification_report(y_new, y_pred_new, target_names=['classe_0', 'classe_1'])  # Personalizza le etichette se necessario
            # Salva i risultati della valutazione nel file di output specificato
            with open(self.output_file, 'w') as f:
                f.write(f"Accuracy: {accuracy}\n\nClassification Report:\n{classification_rep}")
        except Exception as e:
            self.log.error(f'Fallimento della valutazione del modello: {str(e)}')
            raise e

Nell’operatore di predizione, stiamo testando il modello su un nuovo dataset, cioè un file di dati di test. Dopo la predizione, stiamo preparando un report di classificazione.

Setup dell’ambiente e deployment del modello nel cloud

Crea l’ambiente virtuale usando python o anaconda.

#Comando per creare l'ambiente virtualepython3 -m venv <nome_ambiente_virtuale>

Devi installare alcuni pacchetti Python nel tuo ambiente usando il seguente comando.

cd airflow-projects/fraud-predictionpip install -r requirements.txt

Prima di eseguire il flusso di lavoro, devi installare l’airflow e configurare il database.

#Installazione di airflows pip install 'apache-airflow==2.7.1' \ --constraint "https://raw.githubusercontent.com/apache/airflow/constraints-2.7.1/ constraints-3.8.txt"#Imposta il percorso homeexport AIRFLOW_HOME=/c/Users/[TuoNomeUtente]/airflow#Inizializza il database:airflow db init#Crea un utente Airflowairflow users create --username admin –password admin –firstname admin –lastname admin –role Admin –email [email protected]#Controlla l'utente creatoairflow users list#Avvia il server web#Avvia il schedulerairflow scheduler#Se la porta predefinita 8080 è già in uso, cambia la porta digitando:airflow webserver –port <numero_porta>

Puoi accedere al portale web di Airflow utilizzando il nome utente e la password creati in precedenza.

In precedenza, abbiamo creato diversi operatori di airflow che possono essere eseguiti utilizzando un DAG di Airflow. Possiamo avviare il DAG con un solo clic.

image.png

Ci sono diversi stati attraverso i quali un flusso di lavoro passa prima di essere completato con successo o fallire. Questi sono mostrati di seguito:

Sono presenti diversi operatori di cui abbiamo parlato in precedenza. Possiamo anche monitorare lo stato del flusso di lavoro in tempo reale quando viene eseguito.

Puoi monitorare il registro del DAG attivato dal flusso di lavoro in Airflow. Ecco un esempio.

Deployment del modello nel cloud

Dopo aver ottenuto il migliore modello, abbiamo effettuato il deployment del modello utilizzando il codice streamlit. Per eseguire questa app Streamlit sul tuo sistema locale, utilizza il seguente comando:

# comando per eseguire l'app Streamlit localmentestreamlit run streamlit_app.py

La versione cloud dell’app può essere accessibile utilizzando l’URL seguente, che può essere accessibile pubblicamente.

https://fraud-prediction-mlops-d8rcgc2prmv9xapx5ahhhn.streamlit.app/

Per il codice di implementazione completa dell’IA end-to-end, fai clic qui.

Risultati

Abbiamo sperimentato con diversi algoritmi e confrontato le prestazioni di ogni modello. I risultati sono i seguenti:

Dopo aver utilizzato la tecnica di apprendimento ensemble su un dataset molto sbilanciato come mostrato nel risultato precedente, possiamo vedere che tutti e quattro i modelli si sono comportati molto bene con un’accuratezza superiore al 90%. Il classificatore Random Forest e il classificatore ad albero decisionale hanno quasi la stessa accuratezza, con un Random Forest leggermente migliore di un albero decisionale.

  • Accuratezza: L’accuratezza è il rapporto tra le previsioni corrette e il numero totale di previsioni.
  • Precisione: La precisione indica quante previsioni corrette vengono fatte nelle classi positive.
  • Richiamo: Il richiamo è definito come quante previsioni ottimistiche corrette vengono fatte da tutto il campione positivo effettivo nel dataset.
  • F1-Score: L’F1-score misura l’accuratezza del modello. È definito come la media armonica di precisione e accuratezza.

Applicazione demo

Una demo live di questa applicazione del progetto utilizzando Streamlit. Richiede alcune caratteristiche di input per il prodotto e predice la transazione valida o fraudolenta utilizzando i nostri modelli addestrati.

Conclusioni

Oggi il mondo è digitale e la tecnologia è diventata parte della nostra vita. C’è un aumento dei servizi online, dai libri agli smartphone e ai laptop. Tutto può essere acquistato online. Pertanto, prevenire le frodi e implementare un modello di rilevamento delle frodi diventa essenziale per ogni azienda. L’apprendimento automatico può svolgere un ruolo essenziale per le aziende e i clienti.

  • Aumenta i profitti delle aziende identificando transazioni finanziarie fraudolente.
  • Aiuta a mantenere la reputazione aziendale e ad incrementare il numero di clienti.
  • Gli strumenti di machine learning aiutano a fornire servizi accessibili e migliori.
  • Aiuta a fornire buoni servizi e a instaurare fiducia con i clienti.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.