Update app.py

app.py

@@ -1,154 +1,149 @@
-import os
-import joblib
-import pandas as pd
-import streamlit as st
-from typing import Any, Dict, List
-from imblearn.over_sampling import SMOTE
-from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
-
-# Constants for directories and file names
-DIR = 'C:\\Users\\Afshin\\Desktop\\10_Projects\\Project_4_Fraud_Detection_Etherium\\'
-MODEL_DIR = os.path.join(DIR, 'models')
-DATA_DIR = os.path.join(DIR, 'datasets')
-DATA_FILE = 'cleaned_transaction_dataset.csv'
-MODEL_NAMES = [
-    'Ada Boost Classifier',
-    'Extra Trees Classifier',
-    'Gradient Boosting Classifier',
-    'LGBM Classifier', 
-    'Random Forest Classifier',
-    'XGBoost Classifier', 
-]
-
-# Load dataset
-data_path = os.path.join(DATA_DIR, DATA_FILE)
-df = pd.read_csv(data_path)
-
-# Load models
-def load_models(model_names: List[str]) -> Dict[str, Any]:
-    """Load machine learning models from disk."""
-    models = {}
-    for name in model_names:
-        path = os.path.join(MODEL_DIR, f"{name.replace(' ', '')}.joblib")
-        try:
-            models[name] = joblib.load(path)
-        except Exception as e:
-            st.error(f"Error loading model {name}: {str(e)}")
-    return models
-
-models = load_models(MODEL_NAMES)
-
-# Prepare features and target
-X = df.drop(columns=['FLAG'])
-y = df['FLAG']
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=123)
-
-# Prediction and metrics evaluation function
-def calculate_metrics(y_true, y_pred, average_type='binary'):
-    """Calculate and return accuracy, recall, F1, and precision scores."""
-    acc = accuracy_score(y_true, y_pred)
-    rec = recall_score(y_true, y_pred, average=average_type)
-    f1 = f1_score(y_true, y_pred, average=average_type)
-    prec = precision_score(y_true, y_pred, average=average_type)
-    return acc, rec, f1, prec
-
-def load_and_predict(sample):
-    try:
-        # Using StandardScaler to scale numric features
-        scaler = StandardScaler()
-        X_train_scaled = scaler.fit_transform(X_train)
-        sample_trans = scaler.fit_transform(sample)
-
-        # Using SMOTE to handle class imbalance
-        X_resampled, y_resampled = SMOTE(random_state=123).fit_resample(X_train_scaled, y_train)
-
-        results = []
-        for name, model in models.items():
-            y_resampled_pred = model.predict(X_resampled)
-            flag_pred = model.predict(sample_trans)
-            acc, rec, f1, prec = calculate_metrics(y_resampled, y_resampled_pred)
-
-            results.append({
-                'Model': name,
-                'Predicted Fraud': 'Yes' if flag_pred[0] == 1 else 'No',
-                'Accuracy %': acc * 100, 
-                'Recall %': rec * 100, 
-                'F1 %': f1 * 100, 
-                'Precision %': prec * 100
-            })
-
-        return pd.DataFrame(results).sort_values(by='Accuracy %', ascending=False)
-
-    except Exception as e:
-        st.error(f"An error occurred during model loading or prediction: {str(e)}")
-        return pd.DataFrame()
-
-# Streamlit UI setup
-st.set_page_config(page_title="Fraud Detection Etherium Prediction App", page_icon="🕵️", layout="wide")
-st.title("😎 **Fraud Detection Etherium Prediction App**")
-st.subheader("Enter the following information to predict **Fraud Detection Etherium**.")
-
-st.sidebar.title("🕵️ **Fraud Detection Parameters**")
-
-# Input features
-input_features = {
-    "Avg min between sent tnx": st.sidebar.number_input("Avg min between sent tnx", min_value=0.0, value=float(df["Avg min between sent tnx"].mean())),
-    "Avg min between received tnx": st.sidebar.number_input("Avg min between received tnx", min_value=0.0, value=float(df["Avg min between received tnx"].mean())),
-    "Time difference between first and last (mins)": st.sidebar.number_input("Time difference between first and last (mins)", min_value=0.0, value=float(df["Time difference between first and last (mins)"].mean())),
-    "Sent tnx": st.sidebar.number_input("Sent tnx", min_value=0.0, value=float(df["Sent tnx"].mean())),
-    "Received tnx": st.sidebar.number_input("Received tnx", min_value=0.0, value=float(df["Received tnx"].mean())),
-    "Number of created contracts": st.sidebar.number_input("Number of created contracts", min_value=0, value=int(df["Number of created contracts"].mean())),
-    "Max value received": st.sidebar.number_input("Max value received", min_value=0.0, value=float(df["Max value received"].mean())),
-    "Avg value received": st.sidebar.number_input("Avg value received", min_value=0.0, value=float(df["Avg value received"].mean())),
-    "Avg value sent": st.sidebar.number_input("Avg value sent", min_value=0.0, value=float(df["Avg value sent"].mean())),
-    "Total either sent": st.sidebar.number_input("Total either sent", min_value=0.0, value=float(df["Total either sent"].mean())),
-    "Total either balance": st.sidebar.number_input("Total either balance", min_value=0.0, value=float(df["Total either balance"].mean())),
-    "ERC20 total either received": st.sidebar.number_input("ERC20 total either received", min_value=0.0, value=float(df["ERC20 total either received"].mean())),
-    "ERC20 total either sent": st.sidebar.number_input("ERC20 total either sent", min_value=0.0, value=float(df["ERC20 total either sent"].mean())),
-    "ERC20 total either sent contract": st.sidebar.number_input("ERC20 total either sent contract", min_value=0.0, value=float(df["ERC20 total either sent contract"].mean())),
-    "ERC20 unique sent address": st.sidebar.number_input("ERC20 unique sent address", min_value=0.0, value=float(df["ERC20 unique sent address"].mean())),
-    "ERC20 unique received token name": st.sidebar.number_input("ERC20 unique received token name", min_value=0.0, value=float(df["ERC20 unique received token name"].mean())),
-}
-
-# Display predict button in main area
-st.markdown("---")
-if st.button(label=':rainbow[Predict Fraud]'):
-    # Prepare input data for prediction
-    input_data = pd.DataFrame([input_features])
-
-    # Predicting the input data
-    results_df = load_and_predict(input_data)
-
-    # Displaying results
-    if not results_df.empty:
-        st.write("### 😎 Prediction Results:")
-        styled_df = results_df.style.map(lambda x: 'color: green' if x == 'Yes' else 'color: red', subset=['Predicted Fraud'])
-        st.dataframe(styled_df)
-
-# Description Section
-st.markdown("---")
-st.subheader("Description")
-st.markdown('''This Streamlit application predicts fraud in Ethereum transactions using multiple machine learning models including LGBM, XGBoost, and Gradient Boosting classifiers. 
-Users can input transaction information through a user-friendly interface, which includes various fields related to transaction metrics and user activity.
-
-> **Features:**
-> - **Input Components:** Users can provide data using number inputs for transaction-related features.
-> - **Data Processing:** Upon submitting the form, the app processes the input data and transforms it using a pre-trained data preprocessor. 
-> - It leverages SMOTE to address any class imbalance in the data.
-> - **Prediction:** The app runs predictions using the loaded models and calculates performance metrics like accuracy, recall, F1 score, and precision.
-> - **Results Display:** The predicted fraud status and model performance metrics are displayed in a formatted output for easy interpretation.
-
-> **Usage:** Just fill out the information about the transaction and click "Predict Fraud" to receive insights on whether the transaction is likely to be fraudulent and how well each model performed.
-
-> **Disclaimer:** This application is intended for educational purposes only.
-''')
-
-# Disclaimer Section
-st.markdown("---")
-st.subheader("Disclaimer")
-st.text('''The fraud detection results provided by this app are for informational purposes only. 
-While we strive for accuracy, the predictions made by the models depend on the quality of the input data 
-and the model's training. Use this information at your own discretion, and do not solely rely on it for 
+import os
+import joblib
+import pandas as pd
+import streamlit as st
+from typing import Any, Dict, List
+from imblearn.over_sampling import SMOTE
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+# Constants for directories and file names
+MODEL_DIR = 'models'
+DATA_DIR = 'datasets'
+DATA_FILE = 'cleaned_transaction_dataset.csv'
+MODEL_NAMES = [
+    'LGBM Classifier', 
+    'XGBoost Classifier', 
+]
+
+# Load dataset
+data_path = os.path.join(DATA_DIR, DATA_FILE)
+df = pd.read_csv(data_path)
+
+# Load models
+def load_models(model_names: List[str]) -> Dict[str, Any]:
+    """Load machine learning models from disk."""
+    models = {}
+    for name in model_names:
+        path = os.path.join(MODEL_DIR, f"{name.replace(' ', '')}.joblib")
+        try:
+            models[name] = joblib.load(path)
+        except Exception as e:
+            st.error(f"Error loading model {name}: {str(e)}")
+    return models
+
+models = load_models(MODEL_NAMES)
+
+# Prepare features and target
+X = df.drop(columns=['FLAG'])
+y = df['FLAG']
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=123)
+
+# Prediction and metrics evaluation function
+def calculate_metrics(y_true, y_pred, average_type='binary'):
+    """Calculate and return accuracy, recall, F1, and precision scores."""
+    acc = accuracy_score(y_true, y_pred)
+    rec = recall_score(y_true, y_pred, average=average_type)
+    f1 = f1_score(y_true, y_pred, average=average_type)
+    prec = precision_score(y_true, y_pred, average=average_type)
+    return acc, rec, f1, prec
+
+def load_and_predict(sample):
+    try:
+        # Using StandardScaler to scale numric features
+        scaler = StandardScaler()
+        X_train_scaled = scaler.fit_transform(X_train)
+        sample_trans = scaler.fit_transform(sample)
+
+        # Using SMOTE to handle class imbalance
+        X_resampled, y_resampled = SMOTE(random_state=123).fit_resample(X_train_scaled, y_train)
+
+        results = []
+        for name, model in models.items():
+            y_resampled_pred = model.predict(X_resampled)
+            flag_pred = model.predict(sample_trans)
+            acc, rec, f1, prec = calculate_metrics(y_resampled, y_resampled_pred)
+
+            results.append({
+                'Model': name,
+                'Predicted Fraud': 'Yes' if flag_pred[0] == 1 else 'No',
+                'Accuracy %': acc * 100, 
+                'Recall %': rec * 100, 
+                'F1 %': f1 * 100, 
+                'Precision %': prec * 100
+            })
+
+        return pd.DataFrame(results).sort_values(by='Accuracy %', ascending=False)
+
+    except Exception as e:
+        st.error(f"An error occurred during model loading or prediction: {str(e)}")
+        return pd.DataFrame()
+
+# Streamlit UI setup
+st.set_page_config(page_title="Fraud Detection Etherium Prediction App", page_icon="🕵️", layout="wide")
+st.title("😎 **Fraud Detection Etherium Prediction App**")
+st.subheader("Enter the following information to predict **Fraud Detection Etherium**.")
+
+st.sidebar.title("🕵️ **Fraud Detection Parameters**")
+
+# Input features
+input_features = {
+    "Avg min between sent tnx": st.sidebar.number_input("Avg min between sent tnx", min_value=0.0, value=float(df["Avg min between sent tnx"].mean())),
+    "Avg min between received tnx": st.sidebar.number_input("Avg min between received tnx", min_value=0.0, value=float(df["Avg min between received tnx"].mean())),
+    "Time difference between first and last (mins)": st.sidebar.number_input("Time difference between first and last (mins)", min_value=0.0, value=float(df["Time difference between first and last (mins)"].mean())),
+    "Sent tnx": st.sidebar.number_input("Sent tnx", min_value=0.0, value=float(df["Sent tnx"].mean())),
+    "Received tnx": st.sidebar.number_input("Received tnx", min_value=0.0, value=float(df["Received tnx"].mean())),
+    "Number of created contracts": st.sidebar.number_input("Number of created contracts", min_value=0, value=int(df["Number of created contracts"].mean())),
+    "Max value received": st.sidebar.number_input("Max value received", min_value=0.0, value=float(df["Max value received"].mean())),
+    "Avg value received": st.sidebar.number_input("Avg value received", min_value=0.0, value=float(df["Avg value received"].mean())),
+    "Avg value sent": st.sidebar.number_input("Avg value sent", min_value=0.0, value=float(df["Avg value sent"].mean())),
+    "Total either sent": st.sidebar.number_input("Total either sent", min_value=0.0, value=float(df["Total either sent"].mean())),
+    "Total either balance": st.sidebar.number_input("Total either balance", min_value=0.0, value=float(df["Total either balance"].mean())),
+    "ERC20 total either received": st.sidebar.number_input("ERC20 total either received", min_value=0.0, value=float(df["ERC20 total either received"].mean())),
+    "ERC20 total either sent": st.sidebar.number_input("ERC20 total either sent", min_value=0.0, value=float(df["ERC20 total either sent"].mean())),
+    "ERC20 total either sent contract": st.sidebar.number_input("ERC20 total either sent contract", min_value=0.0, value=float(df["ERC20 total either sent contract"].mean())),
+    "ERC20 unique sent address": st.sidebar.number_input("ERC20 unique sent address", min_value=0.0, value=float(df["ERC20 unique sent address"].mean())),
+    "ERC20 unique received token name": st.sidebar.number_input("ERC20 unique received token name", min_value=0.0, value=float(df["ERC20 unique received token name"].mean())),
+}
+
+# Display predict button in main area
+st.markdown("---")
+if st.button(label=':rainbow[Predict Fraud]'):
+    # Prepare input data for prediction
+    input_data = pd.DataFrame([input_features])
+
+    # Predicting the input data
+    results_df = load_and_predict(input_data)
+
+    # Displaying results
+    if not results_df.empty:
+        st.write("### 😎 Prediction Results:")
+        styled_df = results_df.style.map(lambda x: 'color: green' if x == 'Yes' else 'color: red', subset=['Predicted Fraud'])
+        st.dataframe(styled_df)
+
+# Description Section
+st.markdown("---")
+st.subheader("Description")
+st.markdown('''This Streamlit application predicts fraud in Ethereum transactions using multiple machine learning models including LGBM, XGBoost, and Gradient Boosting classifiers. 
+Users can input transaction information through a user-friendly interface, which includes various fields related to transaction metrics and user activity.
+
+> **Features:**
+> - **Input Components:** Users can provide data using number inputs for transaction-related features.
+> - **Data Processing:** Upon submitting the form, the app processes the input data and transforms it using a pre-trained data preprocessor. 
+> - It leverages SMOTE to address any class imbalance in the data.
+> - **Prediction:** The app runs predictions using the loaded models and calculates performance metrics like accuracy, recall, F1 score, and precision.
+> - **Results Display:** The predicted fraud status and model performance metrics are displayed in a formatted output for easy interpretation.
+
+> **Usage:** Just fill out the information about the transaction and click "Predict Fraud" to receive insights on whether the transaction is likely to be fraudulent and how well each model performed.
+
+> **Disclaimer:** This application is intended for educational purposes only.
+''')
+
+# Disclaimer Section
+st.markdown("---")
+st.subheader("Disclaimer")
+st.text('''The fraud detection results provided by this app are for informational purposes only. 
+While we strive for accuracy, the predictions made by the models depend on the quality of the input data 
+and the model's training. Use this information at your own discretion, and do not solely rely on it for 
 making financial decisions. Consulting with a financial expert is recommended for critical decisions.''')