model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "       False       0.98      1.00      0.99     20308\n",
      "        True       0.96      0.77      0.86      2186\n",
      "\n",
      "    accuracy                           0.97     22494\n",
      "   macro avg       0.97      0.88      0.92     22494\n",
      "weighted avg       0.97      0.97      0.97     22494\n",
      "\n",
      "ROC-AUC Score: 0.8844437249162531\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['fraud_detection_model.pkl']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.metrics import classification_report, roc_auc_score\n",
    "from sklearn.impute import SimpleImputer\n",
    "import joblib\n",
    "\n",
    "# Load data\n",
    "data = pd.read_csv('synthetic_fraud_data.csv')\n",
    "\n",
    "# Step 1: Basic Data Preprocessing\n",
    "\n",
    "# Check for missing values\n",
    "data.isnull().sum()\n",
    "\n",
    "# Step 2: Feature Engineering\n",
    "\n",
    "# 2.1 Extract features from timestamp\n",
    "data['timestamp'] = pd.to_datetime(data['timestamp'])\n",
    "data['day_of_week'] = data['timestamp'].dt.dayofweek  # Monday=0, Sunday=6\n",
    "data['is_weekend'] = data['day_of_week'].isin([5, 6]).astype(int)\n",
    "data['transaction_hour'] = data['timestamp'].dt.hour\n",
    "\n",
    "# 2.2 Parse 'velocity_last_hour' to extract useful features\n",
    "# Assume 'velocity_last_hour' is in JSON-like format; here we parse and create new features\n",
    "data['velocity_last_hour'] = data['velocity_last_hour'].apply(eval)  # Convert string to dictionary\n",
    "data['num_transactions_last_hour'] = data['velocity_last_hour'].apply(lambda x: x['num_transactions'])\n",
    "data['total_amount_last_hour'] = data['velocity_last_hour'].apply(lambda x: x['total_amount'])\n",
    "\n",
    "# Drop unnecessary columns\n",
    "data = data.drop(columns=['transaction_id', 'customer_id', 'timestamp', 'velocity_last_hour', 'device_fingerprint'])\n",
    "\n",
    "# Step 3: Data Preprocessing Pipeline\n",
    "\n",
    "# Identify categorical and numerical columns\n",
    "categorical_features = ['merchant_category', 'merchant_type', 'merchant', 'currency', 'country', \n",
    "                        'city', 'city_size', 'card_type', 'device', 'channel']\n",
    "numerical_features = ['amount', 'distance_from_home', 'transaction_hour', 'num_transactions_last_hour', 'total_amount_last_hour']\n",
    "\n",
    "# Define preprocessing for numerical data: scaling\n",
    "numeric_transformer = Pipeline(steps=[\n",
    "    ('imputer', SimpleImputer(strategy='median')),\n",
    "    ('scaler', StandardScaler())])\n",
    "\n",
    "# Define preprocessing for categorical data: one-hot encoding\n",
    "categorical_transformer = Pipeline(steps=[\n",
    "    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),\n",
    "    ('onehot', OneHotEncoder(handle_unknown='ignore'))])\n",
    "\n",
    "# Combine preprocessors in a column transformer\n",
    "preprocessor = ColumnTransformer(\n",
    "    transformers=[\n",
    "        ('num', numeric_transformer, numerical_features),\n",
    "        ('cat', categorical_transformer, categorical_features)])\n",
    "\n",
    "# Step 4: Define the Model Pipeline\n",
    "\n",
    "# Random Forest model pipeline with preprocessing\n",
    "model_pipeline = Pipeline(steps=[\n",
    "    ('preprocessor', preprocessor),\n",
    "    ('classifier', RandomForestClassifier(random_state=42))])\n",
    "\n",
    "# Step 5: Split Data\n",
    "\n",
    "X = data.drop(columns=['is_fraud'])\n",
    "y = data['is_fraud']\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)\n",
    "\n",
    "# Step 6: Hyperparameter Tuning with Grid Search\n",
    "\n",
    "param_grid = {\n",
    "    'classifier__n_estimators': [100, 200],\n",
    "    'classifier__max_depth': [10, 20, None],\n",
    "    'classifier__min_samples_split': [2, 5, 10]\n",
    "}\n",
    "\n",
    "grid_search = GridSearchCV(model_pipeline, param_grid, cv=3, scoring='f1', n_jobs=-1)\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# Retrieve the best model\n",
    "best_model = grid_search.best_estimator_\n",
    "\n",
    "# Step 7: Model Evaluation\n",
    "\n",
    "# Predictions and evaluation on test data\n",
    "y_pred = best_model.predict(X_test)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "roc_auc = roc_auc_score(y_test, y_pred)\n",
    "print(f\"ROC-AUC Score: {roc_auc}\")\n",
    "\n",
    "# Step 8: Save the model\n",
    "joblib.dump(best_model, 'fraud_detection_model.pkl')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluation Results:\n",
    "# \n",
    "# The classification report shows the performance metrics for our fraud detection model:\n",
    "# \n",
    "# - **Precision**: The model has a precision of 0.98 for non-fraudulent transactions and 0.96 for fraudulent transactions.\n",
    "#   - This indicates that 98% of predicted non-fraud transactions were correct, while 96% of predicted fraud transactions were correct.\n",
    "# - **Recall**: The recall is 1.00 for non-fraud and 0.77 for fraud.\n",
    "#   - This shows that the model identified all actual non-fraud cases correctly but only identified 77% of actual fraud cases.\n",
    "# - **F1-Score**: The F1-score is high for both classes, at 0.99 for non-fraud and 0.86 for fraud.\n",
    "#   - The F1-score balances precision and recall; here, we see a high F1-score for non-fraud, indicating the model performs well overall but is slightly less effective in detecting fraud.\n",
    "# - **Accuracy**: The overall accuracy is 0.97, indicating the model correctly classifies 97% of all transactions.\n",
    "# \n",
    "# - **ROC-AUC Score**: The ROC-AUC of 0.88 suggests that the model has a good ability to differentiate between fraud and non-fraud cases.\n",
    "#   - While the AUC is strong, the lower recall for fraud cases shows that improvements could focus on reducing false negatives.\n",
    "# \n",
    "# **Summary**: The model performs well on non-fraud cases and has reasonable accuracy on fraud cases. For fraud detection models, improving recall for fraud can be essential, even if it means a minor trade-off in non-fraud precision.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction: Non-Fraudulent Transaction\n",
      "Probability of Non-Fraudulent Transaction: 0.95\n",
      "Probability of Fraudulent Transaction: 0.05\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "import joblib\n",
    "import pandas as pd\n",
    "\n",
    "# Load the saved model\n",
    "model = joblib.load('fraud_detection_model.pkl')\n",
    "\n",
    "# Sample input data for prediction\n",
    "new_data = pd.DataFrame({\n",
    "    'amount': [500.0],\n",
    "    'distance_from_home': [1],\n",
    "    'transaction_hour': [13],\n",
    "    'merchant_category': ['Retail'],\n",
    "    'merchant_type': ['online'],\n",
    "    'merchant': ['Amazon'],\n",
    "    'currency': ['USD'],\n",
    "    'country': ['United States'],\n",
    "    'city': ['New York'],\n",
    "    'city_size': ['large'],\n",
    "    'card_type': ['debit'],\n",
    "    'device': ['Chrome'],\n",
    "    'channel': ['web'],\n",
    "    'day_of_week': [2],\n",
    "    'is_weekend': [0],\n",
    "    'num_transactions_last_hour': [3],\n",
    "    'total_amount_last_hour': [1500.0],\n",
    "})\n",
    "\n",
    "# Make prediction using the model\n",
    "prediction = model.predict(new_data)\n",
    "\n",
    "# Interpreting prediction result\n",
    "if prediction[0] == 1:\n",
    "    print(\"Prediction: Fraudulent Transaction\")\n",
    "else:\n",
    "    print(\"Prediction: Non-Fraudulent Transaction\")\n",
    "    \n",
    "# Get probability of each class (non-fraud and fraud)\n",
    "proba = model.predict_proba(new_data)\n",
    "\n",
    "print(f\"Probability of Non-Fraudulent Transaction: {proba[0][0]:.2f}\")\n",
    "print(f\"Probability of Fraudulent Transaction: {proba[0][1]:.2f}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}