uploading model files

cc_fraud_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2c83dc0754303c7ec9763c35ccd5f814d5edb700f85702fdafef18f6f6e17dc
+size 4125097

cc_fraud_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d47ec231c6957765359861d79982c61872aaff2f3573f922347223f0c9f43878
+size 1127

model.ipynb

@@ -0,0 +1,502 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# This is fraud Detection Application\n",
+    "### This model uses Random Forest Algorithim for Fraud Classification\n",
+    "#### This model utilizes dataset from kaggle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### This Model is comprised of the following steps:\n",
+    "\n",
+    "1. Library Imports\n",
+    "2. Data Loading\n",
+    "3. Data Preprocessing\n",
+    "4. Model Training\n",
+    "5. Class Imbalance Handling\n",
+    "6. Model Export"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Library Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from datasets import load_dataset\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, ConfusionMatrixDisplay\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import joblib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Load"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = load_dataset(\"Nooha/cc_fraud_detection_dataset\")\n",
+    "df = pd.DataFrame(dataset['train'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset Preview:\n",
+      "           ssn            cc_num    first   last gender      city state  \\\n",
+      "0  367-85-9826  4361337605230458  Kristie  Davis      F  Chandler    OK   \n",
+      "1  367-85-9826  4361337605230458  Kristie  Davis      F  Chandler    OK   \n",
+      "2  367-85-9826  4361337605230458  Kristie  Davis      F  Chandler    OK   \n",
+      "3  367-85-9826  4361337605230458  Kristie  Davis      F  Chandler    OK   \n",
+      "4  367-85-9826  4361337605230458  Kristie  Davis      F  Chandler    OK   \n",
+      "\n",
+      "     zip  city_pop                     job         dob      acct_num  \\\n",
+      "0  74834      7590  Chief Strategy Officer  1987-06-12  349734538563   \n",
+      "1  74834      7590  Chief Strategy Officer  1987-06-12  349734538563   \n",
+      "2  74834      7590  Chief Strategy Officer  1987-06-12  349734538563   \n",
+      "3  74834      7590  Chief Strategy Officer  1987-06-12  349734538563   \n",
+      "4  74834      7590  Chief Strategy Officer  1987-06-12  349734538563   \n",
+      "\n",
+      "                          trans_num  trans_date trans_time   unix_time  \\\n",
+      "0  c036244703adb9d5392f4027d9d4b38d  2021-07-31   02:30:01  1627678801   \n",
+      "1  42f000b0b3b0ef534e5b8ef9ec1db13a  2021-08-01   22:37:41  1627837661   \n",
+      "2  543037b1baf088961e58d00b705f4bcc  2021-08-01   23:02:09  1627839129   \n",
+      "3  00a4e08643edebf9277c2967676f6a26  2021-08-01   22:27:24  1627837044   \n",
+      "4  492c4412815306718f686fc5b459a285  2021-12-02   02:28:51  1638392331   \n",
+      "\n",
+      "         category     amt  is_fraud                merchant  \n",
+      "0     grocery_pos  337.54         1           fraud_Kovacek  \n",
+      "1   personal_care   21.13         1           fraud_Bradtke  \n",
+      "2   personal_care   22.61         1     fraud_Kozey-Kuhlman  \n",
+      "3  health_fitness   17.32         1             fraud_Hills  \n",
+      "4        misc_pos   75.82         0  fraud_Kemmer-Buckridge  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display the first few rows of the dataset\n",
+    "print(\"Dataset Preview:\")\n",
+    "print(df.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Dataset Information:\n",
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 2646694 entries, 0 to 2646693\n",
+      "Data columns (total 20 columns):\n",
+      " #   Column      Dtype  \n",
+      "---  ------      -----  \n",
+      " 0   ssn         object \n",
+      " 1   cc_num      int64  \n",
+      " 2   first       object \n",
+      " 3   last        object \n",
+      " 4   gender      object \n",
+      " 5   city        object \n",
+      " 6   state       object \n",
+      " 7   zip         int64  \n",
+      " 8   city_pop    int64  \n",
+      " 9   job         object \n",
+      " 10  dob         object \n",
+      " 11  acct_num    int64  \n",
+      " 12  trans_num   object \n",
+      " 13  trans_date  object \n",
+      " 14  trans_time  object \n",
+      " 15  unix_time   int64  \n",
+      " 16  category    object \n",
+      " 17  amt         float64\n",
+      " 18  is_fraud    int64  \n",
+      " 19  merchant    object \n",
+      "dtypes: float64(1), int64(6), object(13)\n",
+      "memory usage: 403.9+ MB\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display dataset information\n",
+    "print(\"\\nDataset Information:\")\n",
+    "print(df.info())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Preprocessing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Missing Values:\n",
+      "ssn           0\n",
+      "cc_num        0\n",
+      "first         0\n",
+      "last          0\n",
+      "gender        0\n",
+      "city          0\n",
+      "state         0\n",
+      "zip           0\n",
+      "city_pop      0\n",
+      "job           0\n",
+      "dob           0\n",
+      "acct_num      0\n",
+      "trans_num     0\n",
+      "trans_date    0\n",
+      "trans_time    0\n",
+      "unix_time     0\n",
+      "category      0\n",
+      "amt           0\n",
+      "is_fraud      0\n",
+      "merchant      0\n",
+      "dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Check for missing values\n",
+    "print(\"Missing Values:\")\n",
+    "print(df.isnull().sum())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Drop non-numeric columns (if any)\n",
+    "numeric_df = df.select_dtypes(include=['number'])\n",
+    "\n",
+    "# Ensure the target column 'is_fraud' is included\n",
+    "if 'is_fraud' not in numeric_df.columns:\n",
+    "    numeric_df['is_fraud'] = df['is_fraud']\n",
+    "\n",
+    "# Separate features and target\n",
+    "X = numeric_df.drop(columns=['is_fraud'])\n",
+    "y = numeric_df['is_fraud']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Shape of Features (X): (2646694, 6)\n",
+      "Shape of Target (y): (2646694,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display the shape of the dataset\n",
+    "print(\"\\nShape of Features (X):\", X.shape)\n",
+    "print(\"Shape of Target (y):\", y.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Feature Scaling"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Scaled Features:\n",
+      "[[-0.31022966  0.75530067 -0.4848491  -0.49208358 -1.12618154  1.60692892]\n",
+      " [-0.31022966  0.75530067 -0.4848491  -0.49208358 -1.12037479 -0.29432497]\n",
+      " [-0.31022966  0.75530067 -0.4848491  -0.49208358 -1.12032113 -0.2854319 ]\n",
+      " [-0.31022966  0.75530067 -0.4848491  -0.49208358 -1.12039735 -0.31721862]\n",
+      " [-0.31022966  0.75530067 -0.4848491  -0.49208358 -0.73457409  0.03429794]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize the scaler\n",
+    "scaler = StandardScaler()\n",
+    "\n",
+    "# Scale the features\n",
+    "X_scaled = scaler.fit_transform(X)\n",
+    "\n",
+    "print(\"Scaled Features:\")\n",
+    "print(X_scaled[:5])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Splitting"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Split the dataset\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of X_train: (2117355, 6)\n",
+      "Shape of X_test: (529339, 6)\n",
+      "Shape of y_train: (2117355,)\n",
+      "Shape of y_test: (529339,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display the shape of the splits\n",
+    "print(\"Shape of X_train:\", X_train.shape)\n",
+    "print(\"Shape of X_test:\", X_test.shape)\n",
+    "print(\"Shape of y_train:\", y_train.shape)\n",
+    "print(\"Shape of y_test:\", y_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model training completed!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize the Random Forest model\n",
+    "model = RandomForestClassifier(\n",
+    "    n_estimators=100,\n",
+    "    max_depth=10,\n",
+    "    random_state=42,\n",
+    "    class_weight='balanced'  # Handle class imbalance\n",
+    ")\n",
+    "\n",
+    "# Train the model\n",
+    "model.fit(X_train, y_train)\n",
+    "\n",
+    "# Display training completion message\n",
+    "print(\"Model training completed!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model Evaluation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Make predictions\n",
+    "y_pred = model.predict(X_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy: 0.9615\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display accuracy\n",
+    "accuracy = accuracy_score(y_test, y_pred)\n",
+    "print(f\"Accuracy: {accuracy:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "   Not Fraud       1.00      0.96      0.98    527441\n",
+      "       Fraud       0.07      0.82      0.13      1898\n",
+      "\n",
+      "    accuracy                           0.96    529339\n",
+      "   macro avg       0.54      0.89      0.56    529339\n",
+      "weighted avg       1.00      0.96      0.98    529339\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Display classification report\n",
+    "print(\"\\nClassification Report:\")\n",
+    "print(classification_report(y_test, y_pred, target_names=['Not Fraud', 'Fraud']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Display confusion matrix\n",
+    "cm = confusion_matrix(y_test, y_pred)\n",
+    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Not Fraud', 'Fraud'])\n",
+    "disp.plot(cmap=plt.cm.Blues)\n",
+    "plt.title('Confusion Matrix')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model Export\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model and scaler saved successfully!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Save the model\n",
+    "joblib.dump(model, 'cc_fraud_model.pkl')\n",
+    "\n",
+    "# Save the scaler\n",
+    "joblib.dump(scaler, 'cc_fraud_scaler.pkl')\n",
+    "\n",
+    "print(\"Model and scaler saved successfully!\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}