List of Topics:
Location Research Breakthrough Possible @S-Logix pro@slogix.in

Office Address

Social List

How to Detect Credit Card Fraud Transaction Using Deep Neural Networks from Keras in Python?

Detect Credit Card Fraud Transaction Using Deep Neural Networks from Keras in Python

Condition for Detecting Credit Card Fraud Transaction Using Deep Neural Networks from Keras in Python

  • Description:
    This code uses an Artificial Neural Network (ANN) to detect fraudulent credit card transactions. It preprocesses the data, handles class imbalance, and trains the model using the training set. Performance is evaluated using classification metrics and visualized through a confusion matrix.
Step-by-Step Process
  • Step1: The dataset containing credit card transaction data is loaded from a CSV file.
  • Step2: Null and NaN values are checked to ensure data quality.
  • Step3: The class distribution (fraudulent vs. non-fraudulent transactions) is visualized to detect class imbalance.
  • Step4: The features are scaled using StandardScaler to standardize the data.
  • Step5: The data is split into training and testing sets (80% for training and 20% for testing).
  • Step6: An ANN model with two hidden layers and dropout layers is defined for binary classification.
  • Step7: The model is compiled using the Adam optimizer and binary crossentropy loss function.
  • Step8: The ANN model is trained on the training data for 10 epochs, with validation data used for evaluation.
  • Step9: The model's performance is evaluated using metrics like accuracy, F1 score, recall, precision, and a confusion matrix.
  • Step10: The confusion matrix is plotted to visualize the true vs. predicted labels, showing the model's effectiveness in detecting fraudulent transactions.
Sample Code
  • #Import Necessary Libraries
    import pandas as pd
    from sklearn.preprocessing import StandardScaler
    import matplotlib.pyplot as plt
    import seaborn as sns
    from sklearn.model_selection import train_test_split
    import warnings
    warnings.filterwarnings("ignore")
    from tensorflow.keras.layers import Dense,Dropout,Input
    from tensorflow.keras.models import Model
    from sklearn.metrics import (classification_report,confusion_matrix,accuracy_score,
    f1_score,recall_score,precision_score)
    df = pd.read_csv("/home/soft12/Downloads/sample_dataset/Website/Dataset/creditcard_2023.csv")
    #Check null values
    print("Check null values\n")
    print(df.isnull().sum())
    #Check Nan Values
    print("Check Nan Values\n")
    print(df.isna().sum())
    #Seperate Dependent and Independent Variable
    x = df.drop('Class',axis=1)
    y = df['Class']
    class_counts = y.value_counts()
    # Plotting the class imbalance
    plt.figure(figsize=(8,6))
    sns.barplot(x=class_counts.index, y=class_counts.values)
    plt.title('Class Imbalance')
    plt.xlabel('Class')
    plt.ylabel('Count')
    plt.xticks(rotation=45)
    plt.show()
    scaler = StandardScaler()
    x = scaler.fit_transform(x)
    #Split the train_test_data
    X_train,X_test,y_train,y_test = train_test_split(x,y,test_size=.2,random_state=42)
    def ANN_model(input_shape):
        # Input layer
        inputs = Input(shape=(input_shape,))
        # Hidden layers
        layer1 = Dense(32, activation='relu')(inputs)
        Dropout1 = Dropout(0.2)(layer1)
        layer2 = Dense(16, activation='relu')(Dropout1)
        Dropout2 = Dropout(0.2)(layer2)
        # Output layer
        output_layer = Dense(1, activation='sigmoid')(Dropout2)
        # Build the model
        ann_model = Model(inputs=inputs, outputs=output_layer)
        ann_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
        return ann_model
    model = ANN_model(X_train.shape[1])
    model.fit(X_train,y_train,batch_size=16,epochs=10,validation_data=(X_test,y_test))
    y_pred = model.predict(X_test)
    y_pred = [1 if i>0.5 else 0 for i in y_pred]
    print("___Performance_Metrics___\n")
    print('Classification_Report:\n',classification_report(y_test, y_pred))
    print('Confusion_Matrix:\n',confusion_matrix(y_test, y_pred))
    print('Accuracy_Score: ',accuracy_score(y_test, y_pred))
    print('F1_Score: ',f1_score(y_test, y_pred))
    print('Recall_Score: ',recall_score(y_test, y_pred))
    print('Precision_Score: ',precision_score(y_test, y_pred))
    #Plot Confusion Matrix
    # Compute confusion matrix
    cm = confusion_matrix(y_test, y_pred)
    # Plot confusion matrix using seaborn heatmap
    plt.figure(figsize=(6,6))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Not', 'Fraudulent'], yticklabels=['Not', 'Fraudulent'])
    plt.title('Confusion Matrix')
    plt.xlabel('Predicted Label')
    plt.ylabel('True Label')
    plt.show()
Screenshots
  • Detect Credit Card Fraud Transaction

List