Machine_Learning2_3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "758d9a16-ac68-421a-bba6-a2b7e844e3db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 0.0\n",
      "R-Squared: nan\n",
      "Intercept: -500000.0000000034\n",
      "Coefficients: [4.87782282e-14 1.00000000e+03 4.29151007e-11]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_regression.py:1211: UndefinedMetricWarning: R^2 score is not well-defined with less than two samples.\n",
      "  warnings.warn(msg, UndefinedMetricWarning)\n"
     ]
    }
   ],
   "source": [
    "# Linear Regression - Linear Regression is a statistical method used t# # o\tmodel the relationship between one dependent variable (target) \n",
    "# and one or more independent variables (predictors). It predicts a continuous outcome by fitting a linear equation t# # o\tthe observed data.\n",
    "# Business Application: Predicting Loan Default Risk – A detailed view \n",
    "# Scenario: A bank wants t# # o\tpredict whether customers are at risk of defaulting on loans based on their income, credit score, \n",
    "# and debt-to-income ratio. Step-by-Step Implementation with all possible machine learning life cycles\n",
    "# Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "# Load Data\n",
    "\n",
    "# Example dataset\n",
    "data = {\n",
    "    'Income': [50000, 60000, 55000, 65000, 70000],\n",
    "    'Credit_Score': [700, 750, 720, 770, 800],\n",
    "    'Debt_Income_Ratio': [0.2, 0.25, 0.22, 0.18, 0.15],\n",
    "    'Loan_Amount': [200000, 250000, 220000, 270000, 300000]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "# Preprocess Data\n",
    "\n",
    "# Independent variables (X) and dependent variable (y)\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Income_Ratio']]\n",
    "y = df['Loan_Amount']\n",
    "\n",
    "# Split the dataset int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "# Train Linear Regression Model\n",
    "\n",
    "# Create the model\n",
    "model = LinearRegression()\n",
    "\n",
    "# Train the model\n",
    "model.fit(X_train, y_train)\n",
    "# Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate performance\n",
    "mse = mean_squared_error(y_test, y_pred)\n",
    "r2 = r2_score(y_test, y_pred)\n",
    "\n",
    "print(\"Mean Squared Error:\", mse)\n",
    "print(\"R-Squared:\", r2)\n",
    "# Output Coefficients\n",
    "\n",
    "# Coefficients of the model\n",
    "print(\"Intercept:\", model.intercept_)\n",
    "print(\"Coefficients:\", model.coef_)\n",
    "\n",
    "# Interpretation\n",
    "# 1.\tIntercept and Coefficients:\n",
    "# # o\tThe intercept is the predicted Loan_Amount when all predictors are zero.\n",
    "# # o\tCoefficients show the change in Loan_Amount for a one-unit increase in a predictor (e.g., Income).\n",
    "# 2.\tR-Squared: \n",
    "# # o\tIndicates the percentage of variance in the dependent variable explained by the predictors. Values close t# # o\t1 indicate a good fit.\n",
    "# # 3.\tMean Squared Error (MSE):\n",
    "# # o\tMeasures the average squared difference between predicted and actual values. Lower values indicate better performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4f582198-4285-4f8b-8221-051eb799dc50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 1.0\n",
      "Confusion Matrix:\n",
      " [[2]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         2\n",
      "\n",
      "    accuracy                           1.00         2\n",
      "   macro avg       1.00      1.00      1.00         2\n",
      "weighted avg       1.00      1.00      1.00         2\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:409: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# Logistic Regression Algorithm - Logistic Regression is a statistical method used for binary classification tasks. \n",
    "# Unlike linear regression, it predicts probabilities that an instance belongs t# # o\ta particular class, \n",
    "# and these probabilities are mapped t# # o\tbinary outcomes using a sigmoid function.\n",
    "# Business Application: A bank wants t# # o\tpredict whether a customer will default on their loan based on features like income, \n",
    "# credit score, and debt-to-income ratio.\n",
    "\n",
    "# # 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
    "import numpy as np\n",
    "# 2. Load and Preprocess Data\n",
    "\n",
    "# Example dataset\n",
    "data = {\n",
    "    'Income': [50000, 60000, 55000, 45000, 70000, 80000, 30000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 800, 820, 620],\n",
    "    'Debt_Income_Ratio': [0.2, 0.25, 0.22, 0.3, 0.18, 0.15, 0.4],\n",
    "    'Defaulted': [0, 0, 0, 1, 0, 0, 1]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Income_Ratio']]\n",
    "y = df['Defaulted']\n",
    "\n",
    "# Split the dataset int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "# # 3. Train the Logistic Regression Model\n",
    "\n",
    "# Create and train the model\n",
    "model = LogisticRegression()\n",
    "model.fit(X_train, y_train)\n",
    "# # 4. Evaluate the Model\n",
    "\n",
    "# Predict on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Accuracy\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "\n",
    "# Confusion Matrix\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "print(\"Confusion Matrix:\\n\", cm)\n",
    "\n",
    "# Classification Report\n",
    "report = classification_report(y_test, y_pred)\n",
    "print(\"Classification Report:\\n\", report)\n",
    "\n",
    "# # Output Interpretation\n",
    "# # 1.\tAccuracy:\n",
    "# # o\tIndicates the proportion of correct predictions.\n",
    "# # 2.\tConfusion Matrix:\n",
    "# # o\tProvides a breakdown of true positives, true negatives, false positives, and false negatives.\n",
    "# # 3.\tClassification Report:\n",
    "# # o\tIncludes precision, recall, F1-score, and support for each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "537ea080-c70b-4a03-abdf-1ab623063b56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.3333333333333333\n",
      "Confusion Matrix:\n",
      " [[1 0]\n",
      " [2 0]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.33      1.00      0.50         1\n",
      "           1       0.00      0.00      0.00         2\n",
      "\n",
      "    accuracy                           0.33         3\n",
      "   macro avg       0.17      0.50      0.25         3\n",
      "weighted avg       0.11      0.33      0.17         3\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    }
   ],
   "source": [
    "# Naive Bayes is a probabilistic classification algorithm based on Bayes' Theorem. It assumes that features are conditionally independent \n",
    "# given the class label, which simplifies calculations. Despite its simplicity, it is effective for many real-world applications.\n",
    "# Business Application:  Fraud Detection - A bank needs t# # o\tdetect fraudulent transactions based on features like transaction amount, \n",
    "# location, and time.\n",
    "\n",
    "# # 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
    "# 2. Load and Prepare Data\n",
    "\n",
    "# Example dataset\n",
    "data = {\n",
    "    'Transaction_Amount': [500, 10000, 200, 3000, 150, 8000, 50],\n",
    "    'Location_Risk': [0, 1, 0, 1, 0, 1, 0],\n",
    "    'Time_Of_Transaction': [2, 23, 15, 20, 12, 18, 10],\n",
    "    'Fraudulent': [0, 1, 0, 1, 0, 1, 0]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Transaction_Amount', 'Location_Risk', 'Time_Of_Transaction']]\n",
    "y = df['Fraudulent']\n",
    "\n",
    "# Split int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# # 3. Train Gaussian Naive Bayes Model\n",
    "\n",
    "# Create the model\n",
    "gnb = GaussianNB()\n",
    "\n",
    "# Train the model\n",
    "gnb.fit(X_train, y_train)\n",
    "# # 4. Evaluate the Model\n",
    "\n",
    "# Predict on test set\n",
    "y_pred = gnb.predict(X_test)\n",
    "\n",
    "# Performance metrics\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
    "\n",
    "report = classification_report(y_test, y_pred)\n",
    "print(\"Classification Report:\\n\", report)\n",
    "\n",
    "# # Output Interpretation\n",
    "# # 1.\tAccuracy:\n",
    "# # o\tPercentage of correct predictions.\n",
    "# # 2.\tConfusion Matrix:\n",
    "# # o\tBreakdown of true positives, true negatives, false positives, and false negatives.\n",
    "# # 3.\tClassification Report:\n",
    "# # o\tIncludes precision, recall, F1-score, and support."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2e587adc-5b2f-44b2-bd6d-5f473123f10a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predictions: [0 0]\n"
     ]
    }
   ],
   "source": [
    "# Example: Text Classification with Multinomial Naive Bayes\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "\n",
    "# Example dataset\n",
    "texts = [\"This is a good product\", \"This is a bad product\", \"Excellent quality\", \"Terrible service\"]\n",
    "labels = [1, 0, 1, 0]  # 1 = Positive, 0 = Negative\n",
    "\n",
    "# Convert text t# # o\tnumerical data\n",
    "vectorizer = CountVectorizer()\n",
    "X = vectorizer.fit_transform(texts)\n",
    "\n",
    "# Train Multinomial Naive Bayes\n",
    "mnb = MultinomialNB()\n",
    "mnb.fit(X, labels)\n",
    "\n",
    "# Predict sentiment\n",
    "new_texts = [\"Good service\", \"Bad quality\"]\n",
    "new_X = vectorizer.transform(new_texts)\n",
    "predictions = mnb.predict(new_X)\n",
    "print(\"Predictions:\", predictions)  # Output: [1, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "dcdd989d-6cd2-4705-a4f3-1bb590f06822",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.5\n",
      "Confusion Matrix:\n",
      " [[1 1]\n",
      " [0 0]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.50      0.67         2\n",
      "           1       0.00      0.00      0.00         0\n",
      "\n",
      "    accuracy                           0.50         2\n",
      "   macro avg       0.50      0.25      0.33         2\n",
      "weighted avg       1.00      0.50      0.67         2\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 in labels with no true samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Accuracy: 1.0\n",
      "Gradient Boosting Accuracy: 0.5\n"
     ]
    }
   ],
   "source": [
    "# Decision Tree Algorithm - A Decision Tree is a supervised learning algorithm used for classification and regression tasks. \n",
    "# It models decisions based on features by splitting the data int# # o\tbranches until a prediction is made. \n",
    "# It is intuitive and interpretable, making it suitable for various applications, including banking.\n",
    "                                                                                    \n",
    "# # # 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
    "# 2. Load and Prepare Data\n",
    "\n",
    "# Example dataset\n",
    "data = {\n",
    "    'Income': [50000, 60000, 55000, 45000, 70000, 80000, 30000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 800, 820, 620],\n",
    "    'Debt_Income_Ratio': [0.2, 0.25, 0.22, 0.3, 0.18, 0.15, 0.4],\n",
    "    'Defaulted': [0, 0, 0, 1, 0, 0, 1]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Income_Ratio']]\n",
    "y = df['Defaulted']\n",
    "\n",
    "# Split int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "# # 3. Train Decision Tree Model\n",
    "\n",
    "# Create the model\n",
    "model = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=42)\n",
    "\n",
    "# Train the model\n",
    "model.fit(X_train, y_train)\n",
    "# # 4. Evaluate the Model\n",
    "\n",
    "# Predict on test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Performance metrics\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
    "\n",
    "report = classification_report(y_test, y_pred)\n",
    "print(\"Classification Report:\\n\", report)\n",
    "# # 5. Visualize the Decision Tree\n",
    "\n",
    "from sklearn.tree import plot_tree\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(10, 8))\n",
    "plot_tree(model, feature_names=X.columns, class_names=['N# # o\tDefault', 'Default'], filled=True)\n",
    "plt.show()\n",
    "\n",
    "# # Output Interpretation\n",
    "# 1.\tDecision Rules:\n",
    "# # o\tEach split in the tree represents a decision rule based on feature thresholds (e.g., Credit Score > 720).\n",
    "# # 2.\tConfusion Matrix:\n",
    "# # o\tShows the breakdown of correct and incorrect predictions.\n",
    "# # 3.\tClassification Report:\n",
    "# # o\tProvides precision, recall, and F1-score for both classes.\n",
    "# # 4.\tTree Visualization:\n",
    "# # o\tDisplays the structure of decisions and the outcomes at each leaf node.\n",
    "\n",
    "# Advanced Variants - Random Forest\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "rf_model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
    "rf_model.fit(X_train, y_train)\n",
    "y_pred_rf = rf_model.predict(X_test)\n",
    "print(\"Random Forest Accuracy:\", accuracy_score(y_test, y_pred_rf))\n",
    "# Gradient Boosting\n",
    "\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "\n",
    "gb_model = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, random_state=42)\n",
    "gb_model.fit(X_train, y_train)\n",
    "y_pred_gb = gb_model.predict(X_test)\n",
    "print(\"Gradient Boosting Accuracy:\", accuracy_score(y_test, y_pred_gb))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6334d50f-fc8c-4183-b2de-36fa6e8fb160",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'DecisionTreeRegressor' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[35], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# Regression Tree Example - Use Case: Predict the loan amount based on customer data.\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# Create and train a regression tree\u001b[39;00m\n\u001b[1;32m----> 4\u001b[0m reg \u001b[38;5;241m=\u001b[39m DecisionTreeRegressor(max_depth\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m3\u001b[39m, random_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m42\u001b[39m)\n\u001b[0;32m      5\u001b[0m reg\u001b[38;5;241m.\u001b[39mfit(X_train, y_train)\n\u001b[0;32m      7\u001b[0m \u001b[38;5;66;03m# Predict loan amounts\u001b[39;00m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'DecisionTreeRegressor' is not defined"
     ]
    }
   ],
   "source": [
    "# Regression Tree Example - Use Case: Predict the loan amount based on customer data.\n",
    "\n",
    "# Create and train a regression tree\n",
    "reg = DecisionTreeRegressor(max_depth=3, random_state=42)\n",
    "reg.fit(X_train, y_train)\n",
    "\n",
    "# Predict loan amounts\n",
    "y_pred_reg = reg.predict(X_test)\n",
    "\n",
    "# Evaluate regression tree\n",
    "mse = mean_squared_error(y_test, y_pred_reg)\n",
    "print(\"Mean Squared Error:\", mse)\n",
    "\n",
    "# Output Interpretation\n",
    "# 1.\tClassification Report:\n",
    "# o\tPrecision: How accurate the positive predictions are.\n",
    "# o\tRecall: How well the model identifies actual positives.\n",
    "# o\tF1-Score: Harmonic mean of precision and recall.\n",
    "# 2.\tDecision Tree Rules:\n",
    "# o\tProvides an easy-to-interpret flow of decisions made at each node.\n",
    "# # 3.\tMean Squared Error:\n",
    "# o\tMeasures average squared difference between predicted and actual values (lower is better)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "44f482be-76b5-4309-82e2-0fefbde0af7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.3333333333333333\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00         1\n",
      "           1       0.50      0.50      0.50         2\n",
      "\n",
      "    accuracy                           0.33         3\n",
      "   macro avg       0.25      0.25      0.25         3\n",
      "weighted avg       0.33      0.33      0.33         3\n",
      "\n",
      "Decision Tree Rules:\n",
      " |--- Credit_Score <= 705.00\n",
      "|   |--- class: 0\n",
      "|--- Credit_Score >  705.00\n",
      "|   |--- class: 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Business Application: Predict Loan Approval Based on Customer Features - A bank wants t# # o\tpredict whether a loan will be approved or \n",
    "# denied based on customer attributes like income, credit score, and debt ratio.\n",
    "\n",
    "# Python Code Example for Decision Tree (Classification) Using Gini Impurity\n",
    "# # 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier, export_text\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "# # 2. Prepare Dataset for Classification (Loan Approval Prediction)\n",
    "\n",
    "# Sample dataset for loan approval\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# # 3. Train a Decision Tree Classifier Using Gini Impurity\n",
    "\n",
    "# Train the classifier using Gini Impurity as the criterion\n",
    "clf = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=42)\n",
    "clf.fit(X_train, y_train)\n",
    "# # 4. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "# Evaluate the model performance\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the decision tree rules\n",
    "tree_rules = export_text(clf, feature_names=list(X.columns))\n",
    "print(\"Decision Tree Rules:\\n\", tree_rules)\n",
    "\n",
    "# Output Interpretation\n",
    "# # 1.\tAccuracy:\n",
    "# o\tThe accuracy metric will indicate the percentage of correctly classified loan approvals and denials. A higher accuracy indicates better predictive power.\n",
    "# # 2.\tClassification Report:\n",
    "# o\tThe report will display precision, recall, and F1-score for both classes (approved or denied loans). Precision tells us how accurate our positive predictions are, while recall tells us how well we identify all actual positives.\n",
    "# # 3.\tDecision Tree Rules:\n",
    "# o\tThe decision tree rules help us understand the logic behind the classification. For example, the rules might state:\n",
    "# # \tIf Income > 50,000, approve the loan.\n",
    "# # \tIf Debt Rati# # o\t> 0.45, deny the loan.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c9d347bc-153b-4b18-b5db-76419a73e4ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.3333333333333333\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00         1\n",
      "           1       0.50      0.50      0.50         2\n",
      "\n",
      "    accuracy                           0.33         3\n",
      "   macro avg       0.25      0.25      0.25         3\n",
      "weighted avg       0.33      0.33      0.33         3\n",
      "\n",
      "Decision Tree Rules:\n",
      " |--- Credit_Score <= 705.00\n",
      "|   |--- class: 0\n",
      "|--- Credit_Score >  705.00\n",
      "|   |--- class: 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# CART (Classification and Regression Trees) is a decision tree algorithm that is used for both classification (categorical outcomes) and regression (continuous outcomes) problems. It creates binary trees where each node represents a decision based on a certain feature, and each leaf node contains the prediction.\n",
    "# Business Application Loan Approval Prediction In a banking scenario, CART can be used t# # o\tpredict loan approval based on features like income, credit score, and debt ratio.\n",
    "# Python Implementation for CART Algorithm\n",
    "# # 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor, export_text\n",
    "from sklearn.metrics import accuracy_score, classification_report, mean_squared_error\n",
    "# # 2. Prepare Dataset for Classification (Loan Approval Prediction)\n",
    "\n",
    "# Sample dataset for loan approval\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train a Decision Tree Classifier (Classification)\n",
    "\n",
    "# Train the classifier\n",
    "clf = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=42)\n",
    "clf.fit(X_train, y_train)\n",
    "# 4. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the decision tree rules\n",
    "tree_rules = export_text(clf, feature_names=list(X.columns))\n",
    "print(\"Decision Tree Rules:\\n\", tree_rules)\n",
    "# Output Interpretation\n",
    "# # 1.\tAccuracy:\n",
    "# o\tThe accuracy metric shows how many instances are correctly classified out of the total test instances. A higher accuracy indicates a better model performance.\n",
    "# # 2.\tClassification Report:\n",
    "# o\tPrecision: How accurate the positive predictions are.\n",
    "# o\tRecall: How well the model identifies actual positives.\n",
    "# o\tF1-Score: The harmonic mean of precision and recall, balancing both.\n",
    "# # 3.\tDecision Tree Rules:\n",
    "# o\tThe tree's logic is shown in text form. For instance, the first condition might check if the income is greater than a threshold, and the next condition might check the credit score.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "4b327f3e-2db9-4e8a-8117-d122f57fd395",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error: 16333333.333333334\n",
      "Decision Tree Regression Rules:\n",
      " |--- Credit_Score <= 705.00\n",
      "|   |--- Debt_Ratio <= 0.47\n",
      "|   |   |--- value: [12000.00]\n",
      "|   |--- Debt_Ratio >  0.47\n",
      "|   |   |--- value: [10000.00]\n",
      "|--- Credit_Score >  705.00\n",
      "|   |--- Credit_Score <= 760.00\n",
      "|   |   |--- value: [20000.00]\n",
      "|   |--- Credit_Score >  760.00\n",
      "|   |   |--- value: [25000.00]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Regression Use Case: Predict Loan Amount\n",
    "# 1. Prepare Dataset for Regression\n",
    "\n",
    "# Sample dataset for predicting loan amounts\n",
    "data_reg = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Loan_Amount': [15000, 18000, 20000, 10000, 12000, 14000, 25000]\n",
    "}\n",
    "\n",
    "df_reg = pd.DataFrame(data_reg)\n",
    "\n",
    "X_reg = df_reg[['Income', 'Credit_Score', 'Debt_Ratio']]\n",
    "y_reg = df_reg['Loan_Amount']\n",
    "\n",
    "# Split int# # o\ttraining and testing sets\n",
    "X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.3, random_state=42)\n",
    "# 2. Train a Decision Tree Regressor\n",
    "\n",
    "# Train the regressor\n",
    "reg = DecisionTreeRegressor(max_depth=3, random_state=42)\n",
    "reg.fit(X_train_reg, y_train_reg)\n",
    "# 3. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred_reg = reg.predict(X_test_reg)\n",
    "\n",
    "# Evaluate the model\n",
    "mse = mean_squared_error(y_test_reg, y_pred_reg)\n",
    "print(\"Mean Squared Error:\", mse)\n",
    "\n",
    "# Display the regression tree rules\n",
    "tree_rules_reg = export_text(reg, feature_names=list(X_reg.columns))\n",
    "print(\"Decision Tree Regression Rules:\\n\", tree_rules_reg)\n",
    "# Output Interpretation for Regression\n",
    "# # 1.\tMean Squared Error (MSE):\n",
    "# o\tA lower MSE value indicates that the model is making predictions close t# # o\tthe actual values.\n",
    "# 2.\tRegression Tree Rules:\n",
    "# o\tThe decision tree shows the rules for splitting the data. For example, a rule could be: \n",
    "# if Income > 50000, predict a higher loan amount, else predict a lower loan amount."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "70aa490f-772f-4bcb-bb55-303c6044c884",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.3333333333333333\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00         1\n",
      "           1       0.50      0.50      0.50         2\n",
      "\n",
      "    accuracy                           0.33         3\n",
      "   macro avg       0.25      0.25      0.25         3\n",
      "weighted avg       0.33      0.33      0.33         3\n",
      "\n",
      "Decision Tree Rules:\n",
      " |--- Credit_Score <= 705.00\n",
      "|   |--- class: 0\n",
      "|--- Credit_Score >  705.00\n",
      "|   |--- class: 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Entropy is a measure of uncertainty or impurity used primarily in decision tree algorithms (like CART and ID3). \n",
    "# It quantifies the amount of disorder or unpredictability in a dataset. In decision trees, lower entropy means a pure node \n",
    "# (more homogeneous), while higher entropy indicates impurity.\n",
    "# Business Application Loan Approval Prediction A bank wants t# # o\tpredict whether a loan will be approved or denied based on \n",
    "# customer attributes like income, credit score, and debt ratio.\n",
    "# Python Implementation Using Entropy (Decision Tree)\n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier, export_text\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "# 2. Prepare Dataset for Classification (Loan Approval Prediction)\n",
    "\n",
    "# Sample dataset for loan approval\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train a Decision Tree Classifier with Entropy Criterion\n",
    "\n",
    "# Train the classifier using Entropy as the criterion\n",
    "clf = DecisionTreeClassifier(criterion='entropy', max_depth=3, random_state=42)\n",
    "clf.fit(X_train, y_train)\n",
    "# 4. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "# Evaluate the model performance\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the decision tree rules\n",
    "tree_rules = export_text(clf, feature_names=list(X.columns))\n",
    "print(\"Decision Tree Rules:\\n\", tree_rules)\n",
    "\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tThe accuracy metric will show the proportion of correct predictions made by the model. A higher accuracy indicates better performance.\n",
    "# 2.\tClassification Report:\n",
    "# o\tThe report will show precision, recall, and F1-score for each class. It helps in assessing the model's performance in both predicting \"Approved\" and \"Denied\" loans.\n",
    "# 3.\tDecision Tree Rules:\n",
    "# o\tThe tree structure will display the splitting rules based on the features. For example, it might indicate:\n",
    "# \tIf Income > 50000, the loan is likely t# # o\tbe approved.\n",
    "# \tIf Debt Rati# # o\t> 0.4, the loan may be denied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5e351578-f61a-416b-ad32-463ad5bee15d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 1.0\n",
      "Confusion Matrix:\n",
      " [[2]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         2\n",
      "\n",
      "    accuracy                           1.00         2\n",
      "   macro avg       1.00      1.00      1.00         2\n",
      "weighted avg       1.00      1.00      1.00         2\n",
      "\n",
      "Feature Importances:\n",
      "Income: 0.34\n",
      "Credit_Score: 0.37\n",
      "Debt_Income_Ratio: 0.29\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:409: UserWarning: A single label was found in 'y_true' and 'y_pred'. For the confusion matrix to have the correct shape, use the 'labels' parameter to pass all known labels.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted Values: [0.47 0.16]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:776: UserWarning: The least populated class in y has only 2 members, which is less than n_splits=3.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Parameters: {'max_depth': None, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}\n"
     ]
    }
   ],
   "source": [
    "# Random Forest is an ensemble learning algorithm that combines multiple decision trees t# # o\timprove classification, regression, \n",
    "# and feature selection tasks. It uses bagging (Bootstrap Aggregating) t# # o\tenhance performance by reducing overfitting and variance.\n",
    "# Business Application:  Loan Default Prediction A bank wants to predict whether a customer will default on a loan based on financial features.\n",
    "\n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
    "# 2. Load and Prepare Data\n",
    "\n",
    "# Example dataset\n",
    "data = {\n",
    "    'Income': [50000, 60000, 55000, 45000, 70000, 80000, 30000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 800, 820, 620],\n",
    "    'Debt_Income_Ratio': [0.2, 0.25, 0.22, 0.3, 0.18, 0.15, 0.4],\n",
    "    'Defaulted': [0, 0, 0, 1, 0, 0, 1]\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Income_Ratio']]\n",
    "y = df['Defaulted']\n",
    "\n",
    "# Split int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "# 3. Train Random Forest Model\n",
    "\n",
    "# Create the model\n",
    "rf_model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
    "\n",
    "# Train the model\n",
    "rf_model.fit(X_train, y_train)\n",
    "# 4. Evaluate the Model\n",
    "\n",
    "# Predict on test set\n",
    "y_pred = rf_model.predict(X_test)\n",
    "\n",
    "# Performance metrics\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
    "\n",
    "report = classification_report(y_test, y_pred)\n",
    "print(\"Classification Report:\\n\", report)\n",
    "# 5. Feature Importance\n",
    "\n",
    "# Feature importance\n",
    "importances = rf_model.feature_importances_\n",
    "feature_names = X.columns\n",
    "\n",
    "print(\"Feature Importances:\")\n",
    "for feature, importance in zip(feature_names, importances):\n",
    "    print(f\"{feature}: {importance:.2f}\")\n",
    "\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tRepresents the percentage of correctly classified cases.\n",
    "# 2.\tConfusion Matrix:\n",
    "# o\tShows true positives, true negatives, false positives, and false negatives.\n",
    "# 3.\tClassification Report:\n",
    "# o\tProvides precision, recall, F1-score, and support metrics for each class.\n",
    "# 4.\tFeature Importance:\n",
    "# o\tIdentifies which features contribute the most t# # o\tthe prediction.\n",
    "\n",
    "# Advanced Variants - 1. Random Forest for Regression\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "# Create regression model\n",
    "rf_regressor = RandomForestRegressor(n_estimators=100, random_state=42)\n",
    "rf_regressor.fit(X_train, y_train)\n",
    "\n",
    "# Predict and evaluate\n",
    "y_pred_reg = rf_regressor.predict(X_test)\n",
    "print(\"Predicted Values:\", y_pred_reg)\n",
    "# 2. Hyperparameter Tuning\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Parameter grid\n",
    "param_grid = {\n",
    "    'n_estimators': [50, 100, 200],\n",
    "    'max_depth': [None, 10, 20],\n",
    "    'min_samples_split': [2, 5, 10],\n",
    "    'min_samples_leaf': [1, 2, 4]\n",
    "}\n",
    "\n",
    "# Grid search\n",
    "grid_search = GridSearchCV(RandomForestClassifier(), param_grid, cv=3, scoring='accuracy')\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "print(\"Best Parameters:\", grid_search.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "6c067c76-ca40-4f05-8f24-8828f55df302",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      1.00      0.67         1\n",
      "           1       1.00      0.50      0.67         2\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.75      0.75      0.67         3\n",
      "weighted avg       0.83      0.67      0.67         3\n",
      "\n",
      "Feature Importance: [0.33707865 0.38202247 0.28089888]\n"
     ]
    }
   ],
   "source": [
    "# Random Forest is an ensemble learning algorithm that combines multiple decision trees t# # o\timprove classification, regression, \n",
    "# and feature selection tasks. It uses bagging (Bootstrap Aggregating) t# # o\tenhance performance by reducing overfitting and variance.\n",
    "# Business Application Loan Approval Prediction - In this example, we will predict whether a loan will be approved or denied based on \n",
    "# customer features such as income, credit score, and debt ratio.\n",
    "# Python Code for Random Forest Classifier\n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "# 2. Prepare Dataset for Loan Approval Prediction\n",
    "\n",
    "# Sample dataset for loan approval\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train a Random Forest Classifier\n",
    "\n",
    "# Initialize the Random Forest classifier\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100, max_depth=3, random_state=42)\n",
    "\n",
    "# Train the model\n",
    "rf_classifier.fit(X_train, y_train)\n",
    "# 4. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = rf_classifier.predict(X_test)\n",
    "\n",
    "# Evaluate the model performance\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Display Feature Importances\n",
    "print(\"Feature Importance:\", rf_classifier.feature_importances_)\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tThe accuracy indicates the proportion of correctly classified loan approvals and denials. \n",
    "# A higher accuracy indicates that the model is effective in predicting loan approval.\n",
    "# 2.\tClassification Report:\n",
    "# o\tThe precision, recall, and F1-score metrics will give insights int# # o\thow well the model is performing in \n",
    "# classifying loan approvals and denials.\n",
    "# 3.\tFeature Importance:\n",
    "# o\tThe feature importance array will show the contribution of each feature (e.g., income, credit score, debt ratio) \n",
    "# to the model's predictions. Higher values indicate more importance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "db53eb1e-0043-467b-a06e-b63d4a1e0da7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      1.00      0.67         1\n",
      "           1       1.00      0.50      0.67         2\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.75      0.75      0.67         3\n",
      "weighted avg       0.83      0.67      0.67         3\n",
      "\n",
      "Feature Importances: [0.28089888 0.28089888 0.23595506 0.20224719]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAygAAAIhCAYAAACljJ6NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFbklEQVR4nO3de3zP9f//8fvbNttsNoYZmQ0zLIfMISyG0nL6ELVQbClRsZRD7VPOdHCIUuTTwUg5FAmFpBQfk8jwYTllUSYk5pC1w+v3Rz/vb2+bxbzX+8lu18vldfl6PV/P1+v1eL2fvT7f3fd8vd6zWZZlCQAAAAAMUMLVBQAAAADARQQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAQJFISkqSzWbLdxk6dGiRnHP37t0aPXq00tLSiuT41yItLU02m02TJ092dSmFtnHjRo0ePVqnTp1ydSkAbmDuri4AAHBjmz17tmrXru3QVrly5SI51+7duzVmzBi1bt1aoaGhRXKO4mzjxo0aM2aM4uPjVaZMGVeXA+AGRUABABSpunXrqnHjxq4u45pkZWXJZrPJ3b14/r/N33//XV5eXq4uA0AxwSNeAACXWrhwoZo3by4fHx/5+voqJiZG27Ztc+izZcsW9ejRQ6GhofL29lZoaKh69uypH3/80d4nKSlJ9957rySpTZs29sfJkpKSJEmhoaGKj4/Pc/7WrVurdevW9vV169bJZrPp3Xff1ZAhQ3TTTTfJ09NT+/fvlyR9/vnnuv322+Xn56dSpUopKipKa9euLdS1X3wM7osvvlC/fv1Urlw5+fn5qU+fPjp37pyOHj2q2NhYlSlTRpUqVdLQoUOVlZVl3//iY2MTJ07UhAkTVLVqVXl5ealx48b51rRhwwbdfvvtKl26tEqVKqUWLVrok08+ybemzz77TH379lWFChVUqlQpJSYmatiwYZKkatWq2T/fdevWSfpzHO+8805VqlRJ3t7eqlOnjp555hmdO3fO4fjx8fHy9fXV/v371aFDB/n6+io4OFhDhgxRZmamQ9/MzEyNHTtWderUkZeXl8qVK6c2bdpo48aN9j6WZWnGjBm65ZZb5O3trbJly+qee+7RDz/8UKgxAeB6BBQAQJHKyclRdna2w3LR888/r549eyoiIkKLFi3Su+++qzNnzqhly5bavXu3vV9aWppq1aqladOmafXq1XrppZeUnp6uJk2a6MSJE5Kkjh076vnnn5ckvf7660pOTlZycrI6duxYqLoTExN16NAhvfHGG1q+fLkCAwM1b9483XnnnfLz89OcOXO0aNEiBQQEKCYmptAhRZIefvhh+fv7a8GCBXruuef0/vvvq1+/furYsaMaNGigDz/8UHFxcZoyZYqmT5+eZ//XXntNq1at0rRp0zRv3jyVKFFC7du3V3Jysr3PV199pbZt2+r06dN6++23NX/+fJUuXVqdO3fWwoUL8xyzb9++8vDw0LvvvqsPP/xQjz76qAYNGiRJWrJkif3zjYyMlCTt27dPHTp00Ntvv61Vq1Zp8ODBWrRokTp37pzn2FlZWfrXv/6l22+/XR9//LH69u2rqVOn6qWXXrL3yc7OVvv27TVu3Dh16tRJH330kZKSktSiRQsdOnTI3q9///4aPHiw7rjjDi1dulQzZszQrl271KJFC/3yyy+FHhMALmQBAFAEZs+ebUnKd8nKyrIOHTpkubu7W4MGDXLY78yZM1ZQUJAVGxt72WNnZ2dbZ8+etXx8fKxXXnnF3v7BBx9Ykqwvv/wyzz4hISFWXFxcnvbo6GgrOjravv7ll19akqxWrVo59Dt37pwVEBBgde7c2aE9JyfHatCggdW0adMCPg3LOnjwoCXJmjRpkr3t4md06WfQtWtXS5L18ssvO7TfcsstVmRkZJ5jVq5c2fr999/t7RkZGVZAQIB1xx132NuaNWtmBQYGWmfOnLG3ZWdnW3Xr1rWqVKli5ebmOtTUp0+fPNcwadIkS5J18ODBAq81NzfXysrKsr766itLkrV9+3b7tri4OEuStWjRIod9OnToYNWqVcu+PnfuXEuS9eabb172PMnJyZYka8qUKQ7thw8ftry9va3hw4cXWCcAMzGDAgAoUnPnztW3337rsLi7u2v16tXKzs5Wnz59HGZXvLy8FB0dbX90SJLOnj2rp59+WmFhYXJ3d5e7u7t8fX117tw5paamFknd3bt3d1jfuHGjTp48qbi4OId6c3Nzddddd+nbb7/N8zjTlerUqZPDep06dSQpz+xPnTp1HB5ru6hbt24O74hcnBn5+uuvlZOTo3Pnzumbb77RPffcI19fX3s/Nzc39e7dWz/99JP27NlT4PX/nR9++EG9evVSUFCQ3Nzc5OHhoejoaEnKM0Y2my3PzEr9+vUdrm3lypXy8vJS3759L3vOFStWyGaz6YEHHnAYk6CgIDVo0MDhvyEA14/i+bYfAOAfU6dOnXxfkr/4+E2TJk3y3a9Eif/7HVqvXr20du1ajRgxQk2aNJGfn59sNps6dOig33//vUjqrlSpUr713nPPPZfd5+TJk/Lx8bnqcwUEBDislyxZ8rLtFy5cyLN/UFBQvm1//PGHzp49qzNnzsiyrDzXJP3fN6r9+uuvDu359b2cs2fPqmXLlvLy8tL48eMVHh6uUqVK6fDhw+rWrVueMSpVqlSel+49PT0dru348eOqXLmyw38Hl/rll19kWZYqVqyY7/bq1atf8TUAMAcBBQDgEuXLl5ckffjhhwoJCblsv9OnT2vFihUaNWqUnnnmGXt7ZmamTp48ecXn8/LyyvMStiSdOHHCXstf2Wy2fOudPn26mjVrlu85LveDclE7evRovm0lS5aUr6+v3N3dVaJECaWnp+fpd+TIEUnK8xlcev0F+eKLL3TkyBGtW7fOPmsi6Zr+XkqFChW0YcMG5ebmXjaklC9fXjabTevXr5enp2ee7fm1ATAfAQUA4BIxMTFyd3fXgQMHCnycyGazybKsPD9svvXWW8rJyXFou9gnv1mV0NBQ7dixw6Ft79692rNnT74B5VJRUVEqU6aMdu/erYEDB/5t/3/SkiVLNGnSJPusxJkzZ7R8+XK1bNlSbm5u8vHx0a233qolS5Zo8uTJ8vb2liTl5uZq3rx5qlKlisLDw//2PJf7fC+GmUvHaNasWYW+pvbt22v+/PlKSkq67GNenTp10osvvqiff/5ZsbGxhT4XALMQUAAALhEaGqqxY8fq2Wef1Q8//KC77rpLZcuW1S+//KLNmzfLx8dHY8aMkZ+fn1q1aqVJkyapfPnyCg0N1VdffaW33347zx8LrFu3riTpP//5j0qXLi0vLy9Vq1ZN5cqVU+/evfXAAw/oscceU/fu3fXjjz9q4sSJqlChwhXV6+vrq+nTpysuLk4nT57UPffco8DAQB0/flzbt2/X8ePHNXPmTGd/TFfEzc1N7dq101NPPaXc3Fy99NJLysjI0JgxY+x9XnjhBbVr105t2rTR0KFDVbJkSc2YMUP/+9//NH/+/CuaMalXr54k6ZVXXlFcXJw8PDxUq1YttWjRQmXLltWAAQM0atQoeXh46L333tP27dsLfU09e/bU7NmzNWDAAO3Zs0dt2rRRbm6uvvnmG9WpU0c9evRQVFSUHnnkET344IPasmWLWrVqJR8fH6Wnp2vDhg2qV6+eHn300ULXAMA1eEkeAOAyiYmJ+vDDD7V3717FxcUpJiZGw4cP148//qhWrVrZ+73//vtq06aNhg8frm7dumnLli1as2aN/P39HY5XrVo1TZs2Tdu3b1fr1q3VpEkTLV++XNKf77FMnDhRq1evVqdOnTRz5kzNnDnzimYOLnrggQf05Zdf6uzZs+rfv7/uuOMOPfHEE/ruu+90++23O+dDKYSBAweqXbt2SkhIUK9evZSdna1PPvlEUVFR9j7R0dH64osv5OPjo/j4ePXo0UOnT5/WsmXLdN99913ReVq3bq3ExEQtX75ct912m5o0aaKtW7eqXLly+uSTT1SqVCk98MAD6tu3r3x9ffP9+uIr5e7urk8//VSJiYn66KOP1KVLF/Xp00cbNmxweCRw1qxZeu211/T111+rR48e6tixo0aOHKlz586padOmhT4/ANexWZZluboIAABw9dLS0lStWjVNmjRJQ4cOdXU5AOAUzKAAAAAAMAYBBQAAAIAxeMQLAAAAgDGYQQEAAABgDAIKAAAAAGMQUAAAAAAYgz/UiBtCbm6ujhw5otKlS1/RHxsDAADAP8uyLJ05c0aVK1dWiRKXnychoOCGcOTIEQUHB7u6DAAAAPyNw4cPq0qVKpfdTkDBDaF06dKS/vwP3s/Pz8XVAAAA4FIZGRkKDg62/9x2OQQU3BAuPtbl5+dHQAEAADDY3z2Oz0vyAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAx+EONuKG0em6+3Dy9XV0GAACA0bZO6uPqEi6LGRQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgHlBhYfH6+uXbu6ugwAAADgihFQAAAAABiDgFJMtG7dWgkJCRo+fLgCAgIUFBSk0aNHO/Q5deqUHnnkEVWsWFFeXl6qW7euVqxYYd++ePFi3XzzzfL09FRoaKimTJnisH9oaKjGjx+vPn36yNfXVyEhIfr44491/PhxdenSRb6+vqpXr562bNnisN/GjRvVqlUreXt7Kzg4WAkJCTp37lyB15OZmamMjAyHBQAAANc/AkoxMmfOHPn4+Oibb77RxIkTNXbsWK1Zs0aSlJubq/bt22vjxo2aN2+edu/erRdffFFubm6SpK1btyo2NlY9evTQzp07NXr0aI0YMUJJSUkO55g6daqioqK0bds2dezYUb1791afPn30wAMP6LvvvlNYWJj69Okjy7IkSTt37lRMTIy6deumHTt2aOHChdqwYYMGDhxY4LW88MIL8vf3ty/BwcHO/8AAAADwj7NZF39SxA0nPj5ep06d0tKlS9W6dWvl5ORo/fr19u1NmzZV27Zt9eKLL+qzzz5T+/btlZqaqvDw8DzHuv/++3X8+HF99tln9rbhw4frk08+0a5duyT9OYPSsmVLvfvuu5Kko0ePqlKlShoxYoTGjh0rSdq0aZOaN2+u9PR0BQUFqU+fPvL29tasWbPsx92wYYOio6N17tw5eXl55XttmZmZyszMtK9nZGQoODhYDQa9ITdP72v41AAAAG58Wyf1+cfPmZGRIX9/f50+fVp+fn6X7ccMSjFSv359h/VKlSrp2LFjkqSUlBRVqVIl33AiSampqYqKinJoi4qK0r59+5STk5PvOSpWrChJqlevXp62i+fdunWrkpKS5Ovra19iYmKUm5urgwcPXvZaPD095efn57AAAADg+ufu6gLwz/Hw8HBYt9lsys3NlSR5exc862BZlmw2W562gs5xsX9+bRfPm5ubq/79+yshISHPsapWrVpgTQAAALjxEFAg6c+Zj59++kl79+7NdxYlIiJCGzZscGjbuHGjwsPD7e+pFEZkZKR27dqlsLCwQh8DAAAANw4e8YIkKTo6Wq1atVL37t21Zs0aHTx4UCtXrtSqVaskSUOGDNHatWs1btw47d27V3PmzNFrr72moUOHXtN5n376aSUnJ+vxxx9XSkqK9u3bp2XLlmnQoEHOuCwAAABcZwgosFu8eLGaNGminj17KiIiQsOHD7e/XxIZGalFixZpwYIFqlu3rkaOHKmxY8cqPj7+ms5Zv359ffXVV9q3b59atmyphg0basSIEapUqZITrggAAADXG77FCzeEi98Kwbd4AQAA/D2+xQsAAAAArgABBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAY7q4uAHCmr8f3lJ+fn6vLAAAAQCExgwIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMd1cXADhTq+fmy83T29VlAAAAGG3rpD6uLuGymEEBAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAuY7ZbDYtXbpUkpSWliabzaaUlBSX1gQAAABcCwKKkx09elSDBg1S9erV5enpqeDgYHXu3Flr164t0vMGBwcrPT1ddevWlSStW7dONptNp06duuJjHDt2TP3791fVqlXl6empoKAgxcTEKDk5uYiqBgAAABy5u7qAG0laWpqioqJUpkwZTZw4UfXr11dWVpZWr16txx9/XN9//32efbKysuTh4XHN53Zzc1NQUNA1HaN79+7KysrSnDlzVL16df3yyy9au3atTp48ec31Xc4ff/yhkiVLFtnxAQAAcH1hBsWJHnvsMdlsNm3evFn33HOPwsPDdfPNN+upp57Spk2bJP35WNYbb7yhLl26yMfHR+PHj5ckLV++XI0aNZKXl5eqV6+uMWPGKDs7237sffv2qVWrVvLy8lJERITWrFnjcO6/PuKVlpamNm3aSJLKli0rm82m+Pj4Ams/deqUNmzYoJdeeklt2rRRSEiImjZtqsTERHXs2NGh3yOPPKKKFSvKy8tLdevW1YoVK+zbFy9erJtvvlmenp4KDQ3VlClTHM4TGhqq8ePHKz4+Xv7+/urXr58kaePGjWrVqpW8vb0VHByshIQEnTt37ipHAAAAANc7ZlCc5OTJk1q1apUmTJggHx+fPNvLlClj//eoUaP0wgsvaOrUqXJzc9Pq1av1wAMP6NVXX1XLli114MABPfLII/a+ubm56tatm8qXL69NmzYpIyNDgwcPvmwtwcHBWrx4sbp37649e/bIz89P3t7eBdbv6+srX19fLV26VM2aNZOnp2eePrm5uWrfvr3OnDmjefPmqUaNGtq9e7fc3NwkSVu3blVsbKxGjx6t++67Txs3btRjjz2mcuXKOQSkSZMmacSIEXruueckSTt37lRMTIzGjRunt99+W8ePH9fAgQM1cOBAzZ49O996MzMzlZmZaV/PyMgo8PoAAABwfSCgOMn+/ftlWZZq1679t3179eqlvn372td79+6tZ555RnFxcZKk6tWra9y4cRo+fLhGjRqlzz//XKmpqUpLS1OVKlUkSc8//7zat2+f7/Hd3NwUEBAgSQoMDHQIR5fj7u6upKQk9evXT2+88YYiIyMVHR2tHj16qH79+pKkzz//XJs3b1ZqaqrCw8PttV708ssv6/bbb9eIESMkSeHh4dq9e7cmTZrkEFDatm2roUOH2tf79OmjXr162UNXzZo19eqrryo6OlozZ86Ul5dXnnpfeOEFjRkz5m+vCwAAANcXHvFyEsuyJP35CNffady4scP61q1bNXbsWPsshq+vr/r166f09HSdP39eqampqlq1qj2cSFLz5s2dewH68x2UI0eOaNmyZYqJidG6desUGRmppKQkSVJKSoqqVKliDyeXSk1NVVRUlENbVFSU9u3bp5ycHHtbfteflJTkcP0xMTHKzc3VwYMH8z1XYmKiTp8+bV8OHz58DVcOAAAAUzCD4iQ1a9aUzWZTamqqunbtWmDfSx8By83N1ZgxY9StW7c8fb28vOzh56+uJAgVhpeXl9q1a6d27dpp5MiRevjhhzVq1CjFx8f/7WNilmXlqSu/2vO7/v79+yshISFP36pVq+Z7Lk9Pz3wfQwMAAMD1jYDiJAEBAYqJidHrr7+uhISEPD+Enzp16rKPWkVGRmrPnj0KCwvLd3tERIQOHTqkI0eOqHLlypL0t1/9e/Gbsf46c1EYERER9r+1Ur9+ff3000/au3dvvrMoERER2rBhg0Pbxo0bFR4ebn9PJT+RkZHatWvXZa8fAAAAxQePeDnRjBkzlJOTo6ZNm2rx4sXat2+fUlNT9eqrrxb4SNbIkSM1d+5cjR49Wrt27VJqaqoWLlxof4n8jjvuUK1atdSnTx9t375d69ev17PPPltgLSEhIbLZbFqxYoWOHz+us2fPFtj/119/Vdu2bTVv3jzt2LFDBw8e1AcffKCJEyeqS5cukqTo6Gi1atVK3bt315o1a3Tw4EGtXLlSq1atkiQNGTJEa9eu1bhx47R3717NmTNHr732msP7Jvl5+umnlZycrMcff1wpKSnat2+fli1bpkGDBhW4HwAAAG48BBQnqlatmr777ju1adNGQ4YMUd26ddWuXTutXbtWM2fOvOx+MTExWrFihdasWaMmTZqoWbNmevnllxUSEiJJKlGihD766CNlZmaqadOmevjhhzVhwoQCa7nppps0ZswYPfPMM6pYsaIGDhxYYH9fX1/deuutmjp1qlq1aqW6detqxIgR6tevn1577TV7v8WLF6tJkybq2bOnIiIiNHz4cPssTWRkpBYtWqQFCxaobt26GjlypMaOHfu3X3Fcv359ffXVV9q3b59atmyphg0basSIEapUqVKB+wEAAODGY7Pye0kAuM5kZGTI399fDQa9ITfPgt+VAQAAKO62Turzj5/z4s9rp0+flp+f32X7MYMCAAAAwBgElGLi0KFDDl/je+ly6NAhV5cIAAAA8C1exUXlypWVkpJS4HYAAADA1QgoxYS7uztf4wsAAADj8YgXAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMUOqC8++67ioqKUuXKlfXjjz9KkqZNm6aPP/7YacUBAAAAKF4KFVBmzpypp556Sh06dNCpU6eUk5MjSSpTpoymTZvmzPoAAAAAFCOFCijTp0/Xm2++qWeffVZubm729saNG2vnzp1OKw4AAABA8VKogHLw4EE1bNgwT7unp6fOnTt3zUUBAAAAKJ4KFVCqVaumlJSUPO0rV65URETEtdYEAAAAoJhyL8xOw4YN0+OPP64LFy7Isixt3rxZ8+fP1wsvvKC33nrL2TUCAAAAKCYKFVAefPBBZWdna/jw4Tp//rx69eqlm266Sa+88op69Ojh7BoBAAAAFBNXHVCys7P13nvvqXPnzurXr59OnDih3NxcBQYGFkV9AAAAAIqRq34Hxd3dXY8++qgyMzMlSeXLlyecAAAAAHCKQr0kf+utt2rbtm3OrgUAAABAMVeod1Aee+wxDRkyRD/99JMaNWokHx8fh+3169d3SnHA1fp6fE/5+fm5ugwAAAAUks2yLOtqdypRIu/Ei81mk2VZstls9r8sD/xTMjIy5O/vr9OnTxNQAAAADHSlP68Vagbl4MGDhS4MAAAAAC6nUAElJCTE2XUAAAAAQOECyty5cwvc3qdPn0IVAwAAAKB4K9Q7KGXLlnVYz8rK0vnz51WyZEmVKlVKJ0+edFqBwJXgHRQAAACzXenPa4X6muHffvvNYTl79qz27Nmj2267TfPnzy900QAAAACKt0IFlPzUrFlTL774op544glnHRIAAABAMeO0gCJJbm5uOnLkiDMPCQAAAKAYKdRL8suWLXNYtyxL6enpeu211xQVFeWUwgAAAAAUP4UKKF27dnVYt9lsqlChgtq2baspU6Y4oy4AAAAAxVChAkpubq6z6wAAAACAwr2DMnbsWJ0/fz5P+++//66xY8dec1EAAAAAiqdC/R0UNzc3paenKzAw0KH9119/VWBgoHJycpxWIHAl+DsoAAAAZivSv4NiWZZsNlue9u3btysgIKAwhwQAAACAq3sHpWzZsrLZbLLZbAoPD3cIKTk5OTp79qwGDBjg9CIBAAAAFA9XFVCmTZsmy7LUt29fjRkzRv7+/vZtJUuWVGhoqJo3b+70IgEAAAAUD1cVUOLi4iRJ1apVU4sWLeTh4VEkRQEAAAAongr1NcPR0dH2f//+++/Kyspy2M5LygAAAAAKo1AvyZ8/f14DBw5UYGCgfH19VbZsWYcFAAAAAAqjUAFl2LBh+uKLLzRjxgx5enrqrbfe0pgxY1S5cmXNnTvX2TUCAAAAKCYK9YjX8uXLNXfuXLVu3Vp9+/ZVy5YtFRYWppCQEL333nu6//77nV0nAAAAgGKgUDMoJ0+eVLVq1ST9+b7JyZMnJUm33Xabvv76a+dVBwAAAKBYKdQMSvXq1ZWWlqaQkBBFRERo0aJFatq0qZYvX64yZco4uUTgyrV6br7cPL1dXQYAALhCWyf1cXUJMEyhZlAefPBBbd++XZKUmJhofxflySef1LBhw5xaIAAAAIDio1AzKE8++aT9323atNH333+vLVu2qEaNGmrQoIHTigMAAABQvBQqoPzVhQsXVLVqVVWtWtUZ9QAAAAAoxgr1iFdOTo7GjRunm266Sb6+vvrhhx8kSSNGjNDbb7/t1AIBAAAAFB+FCigTJkxQUlKSJk6cqJIlS9rb69Wrp7feestpxQEAAAAoXgoVUObOnav//Oc/uv/+++Xm5mZvr1+/vr7//nunFQcAAACgeClUQPn5558VFhaWpz03N1dZWVnXXBQAAACA4qlQAeXmm2/W+vXr87R/8MEHatiw4TUXBQAAAKB4KtS3eI0aNUq9e/fWzz//rNzcXC1ZskR79uzR3LlztWLFCmfXCAAAAKCYuKoZlB9++EGWZalz585auHChPv30U9lsNo0cOVKpqalavny52rVrV1S1AgAAALjBXdUMSs2aNZWenq7AwEDFxMTonXfe0f79+xUUFFRU9QEAAAAoRq5qBsWyLIf1lStX6vz5804tCAAAAEDxVaiX5C+6NLAAAAAAwLW4qoBis9lks9nytAEAAACAM1zVOyiWZSk+Pl6enp6SpAsXLmjAgAHy8fFx6LdkyRLnVQgAAACg2LiqgBIXF+ew/sADDzi1GAAAAADF21UFlNmzZxdVHQAAAABwbS/JAwAAAIAzEVAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCynVu9OjRuuWWW1xdxlW5HmsGAADAP4OA4iLx8fGy2Wyy2Wzy8PBQxYoV1a5dO73zzjvKzc11+rm6du16VftcrM1ms8nX11cNGjRQUlLSVZ/bZrNp6dKlDm1Dhw7V2rVrr/pYAAAAuPERUFzorrvuUnp6utLS0rRy5Uq1adNGTzzxhDp16qTs7GxXl6fZs2crPT1d27dv13333acHH3xQq1evvubj+vr6qly5ck6oEAAAADcaAooLeXp6KigoSDfddJMiIyP173//Wx9//LFWrlxpn604ffq0HnnkEQUGBsrPz09t27bV9u3b8xxr1qxZCg4OVqlSpXTvvffq1KlTkv58nGrOnDn6+OOP7TMi69atu6L6ypQpo6CgINWoUUP//ve/FRAQoM8++8y+/dtvv1W7du1Uvnx5+fv7Kzo6Wt999519e2hoqCTp7rvvls1ms69f+ohXbm6uxo4dqypVqsjT01O33HKLVq1aVWBtmZmZysjIcFgAAABw/SOgGKZt27Zq0KCBlixZIsuy1LFjRx09elSffvqptm7dqsjISN1+++06efKkfZ/9+/dr0aJFWr58uVatWqWUlBQ9/vjjkv58nCo2NtY+W5Oenq4WLVpcVU05OTlatGiRTp48KQ8PD3v7mTNnFBcXp/Xr12vTpk2qWbOmOnTooDNnzkj6M8BI/zcTc3H9Uq+88oqmTJmiyZMna8eOHYqJidG//vUv7du377I1vfDCC/L397cvwcHBV3VNAAAAMJO7qwtAXrVr19aOHTv05ZdfaufOnTp27Jg8PT0lSZMnT9bSpUv14Ycf6pFHHpEkXbhwQXPmzFGVKlUkSdOnT1fHjh01ZcoUBQUFydvbW5mZmQoKCrqqOnr27Ck3NzdduHBBOTk5CggI0MMPP2zf3rZtW4f+s2bNUtmyZfXVV1+pU6dOqlChgqT/m4m5nMmTJ+vpp59Wjx49JEkvvfSSvvzyS02bNk2vv/56vvskJibqqaeesq9nZGQQUgAAAG4AzKAYyLIs2Ww2bd26VWfPnlW5cuXk6+trXw4ePKgDBw7Y+1etWtUeTiSpefPmys3N1Z49e66pjqlTpyolJUVr1qzRLbfcoqlTpyosLMy+/dixYxowYIDCw8PtMxlnz57VoUOHrvgcGRkZOnLkiKKiohzao6KilJqaetn9PD095efn57AAAADg+scMioFSU1NVrVo15ebmqlKlSvm+M1KmTJnL7m+z2Rz+b2EFBQUpLCxMYWFh+uCDD9SwYUM1btxYERERkv78drDjx49r2rRpCgkJkaenp5o3b64//vjjqs91aa0XQxoAAACKF2ZQDPPFF19o586d6t69uyIjI3X06FG5u7vbg8LFpXz58vZ9Dh06pCNHjtjXk5OTVaJECYWHh0uSSpYsqZycnGuqKywsTN27d1diYqK9bf369UpISFCHDh108803y9PTUydOnHDYz8PDo8Bz+/n5qXLlytqwYYND+8aNG1WnTp1rqhkAAADXH2ZQXCgzM1NHjx5VTk6OfvnlF61atUovvPCCOnXqpD59+qhEiRJq3ry5unbtqpdeekm1atXSkSNH9Omnn6pr165q3LixJMnLy0txcXGaPHmyMjIylJCQoNjYWPt7H6GhoVq9erX27NmjcuXKyd/f3+Fl9ys1ZMgQNWjQQFu2bFHjxo0VFhamd999V40bN1ZGRoaGDRsmb29vh31CQ0O1du1aRUVFydPTU2XLls1z3GHDhmnUqFGqUaOGbrnlFs2ePVspKSl67733CvGpAgAA4HrGDIoLrVq1SpUqVVJoaKjuuusuffnll3r11Vf18ccfy83NTTabTZ9++qlatWqlvn37Kjw8XD169FBaWpoqVqxoP05YWJi6deumDh066M4771TdunU1Y8YM+/Z+/fqpVq1aaty4sSpUqKD//ve/haq3Xr16uuOOOzRy5EhJ0jvvvKPffvtNDRs2VO/evZWQkKDAwECHfaZMmaI1a9YoODhYDRs2zPe4CQkJGjJkiIYMGaJ69epp1apVWrZsmWrWrFmoOgEAAHD9slmWZbm6COBaZWRkyN/fXw0GvSE3T++/3wEAABhh66Q+ri4B/5CLP6+dPn26wC84YgYFAAAAgDEIKMXQ888/7/C1xX9d2rdv7+ryAAAAUIzxknwxNGDAAMXGxua77dKX3AEAAIB/EgGlGAoICFBAQICrywAAAADy4BEvAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMdxdXQDgTF+P7yk/Pz9XlwEAAIBCYgYFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGO6uLgBwplbPzZebp7erywAAwMHWSX1cXQJw3WAGBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADBGsQwo8fHx6tq1q6vLAAAAAHAJlwaU+Ph42Wy2PMtdd93lyrKuK+vWrZPNZtOpU6eueJ9jx46pf//+qlq1qjw9PRUUFKSYmBglJyfb+9hsNi1duvSq6wkNDdW0adOuej8AAABAktxdXcBdd92l2bNnO7R5enq6qJrioXv37srKytKcOXNUvXp1/fLLL1q7dq1Onjzp6tIAAABQzLn8Ea+Lv8H/61K2bFlJf/4Wf9asWerUqZNKlSqlOnXqKDk5Wfv371fr1q3l4+Oj5s2b68CBA/bjjR49WrfccotmzZql4OBglSpVSvfee2+BMwyZmZlKSEhQYGCgvLy8dNttt+nbb7+VJFmWpbCwME2ePNlhn//9738qUaKE/dyFqVWSli9frkaNGsnLy0vVq1fXmDFjlJ2dbd9us9n01ltv6e6771apUqVUs2ZNLVu2TJKUlpamNm3aSJLKli0rm82m+Pj4Aj/vU6dOacOGDXrppZfUpk0bhYSEqGnTpkpMTFTHjh0l/TkLIkl33323bDabff3AgQPq0qWLKlasKF9fXzVp0kSff/65/ditW7fWjz/+qCeffNI+G/bXMfmradOm2Y8r/TkT1LRpU/n4+KhMmTKKiorSjz/+WOC1AAAA4Mbj8oDyd8aNG6c+ffooJSVFtWvXVq9evdS/f38lJiZqy5YtkqSBAwc67LN//34tWrRIy5cv16pVq5SSkqLHH3/8sucYPny4Fi9erDlz5ui7775TWFiYYmJidPLkSdlsNvXt2zfPLM8777yjli1bqkaNGoWudfXq1XrggQeUkJCg3bt3a9asWUpKStKECRMczjVmzBjFxsZqx44d6tChg+6//36dPHlSwcHBWrx4sSRpz549Sk9P1yuvvFLg5+nr6ytfX18tXbpUmZmZ+fa5GM5mz56t9PR0+/rZs2fVoUMHff7559q2bZtiYmLUuXNnHTp0SJK0ZMkSValSRWPHjlV6errS09MLrOWi7Oxsde3aVdHR0dqxY4eSk5P1yCOP2ANOfjIzM5WRkeGwAAAA4Prn8oCyYsUK+w/NF5dx48bZtz/44IOKjY1VeHi4nn76aaWlpen+++9XTEyM6tSpoyeeeELr1q1zOOaFCxc0Z84c3XLLLWrVqpWmT5+uBQsW6OjRo3nOf+7cOc2cOVOTJk1S+/btFRERoTfffFPe3t56++237TXs2bNHmzdvliRlZWVp3rx56tu3r8OxrrbWCRMm6JlnnlFcXJyqV6+udu3aady4cZo1a5bDcePj49WzZ0+FhYXp+eef17lz57R582a5ubkpICBAkhQYGKigoCD5+/sX+Hm7u7srKSlJc+bMsc9U/Pvf/9aOHTvsfSpUqCBJKlOmjIKCguzrDRo0UP/+/VWvXj3VrFlT48ePV/Xq1e0zOgEBAXJzc1Pp0qXts2FXIiMjQ6dPn1anTp1Uo0YN1alTR3Fxcapatepl93nhhRfk7+9vX4KDg6/oXAAAADCbywNKmzZtlJKS4rD8dbajfv369n9XrFhRklSvXj2HtgsXLjj8Br1q1aqqUqWKfb158+bKzc3Vnj178pz/wIEDysrKUlRUlL3Nw8NDTZs2VWpqqiSpUqVK6tixo9555x1Jf4aqCxcu6N5773U41tXWunXrVo0dO9YhnPXr10/p6ek6f/58vsf18fFR6dKldezYsXw+zSvTvXt3HTlyRMuWLVNMTIzWrVunyMhIJSUlFbjfuXPnNHz4cEVERKhMmTLy9fXV999/b59BKayAgADFx8fbZ2ReeeWVv519SUxM1OnTp+3L4cOHr6kGAAAAmMHlAcXHx0dhYWEOy8VZAenPsHDRxUd+8mvLzc297Dku9snvkSHLsvLdZlmWQ9vDDz+sBQsW6Pfff9fs2bN13333qVSpUg77XG2tubm5GjNmjEM427lzp/bt2ycvL698j3vxOAVd75Xw8vJSu3btNHLkSG3cuFHx8fEaNWpUgfsMGzZMixcv1oQJE7R+/XqlpKSoXr16+uOPPwrcr0SJEvbP+aKsrCyH9dmzZys5OVktWrTQwoULFR4erk2bNl32mJ6envLz83NYAAAAcP1zeUApCocOHdKRI0fs68nJySpRooTCw8Pz9A0LC1PJkiW1YcMGe1tWVpa2bNmiOnXq2Ns6dOggHx8fzZw5UytXrszzeFdhREZGas+ePXkCWlhYmEqUuLKhKVmypCQpJyfnmmqJiIjQuXPn7OseHh55jrl+/XrFx8fr7rvvVr169RQUFKS0tLQ89Vy6X4UKFXT06FGHkJKSkpKnhoYNGyoxMVEbN25U3bp19f7771/TNQEAAOD64/KAkpmZqaNHjzosJ06cuKZjenl5KS4uTtu3b9f69euVkJCg2NjYfN+J8PHx0aOPPqphw4Zp1apV2r17t/r166fz58/roYcesvdzc3NTfHy8EhMTFRYWpubNm19TjZI0cuRIzZ07V6NHj9auXbuUmpqqhQsX6rnnnrviY4SEhMhms2nFihU6fvy4zp49W2D/X3/9VW3bttW8efO0Y8cOHTx4UB988IEmTpyoLl262PuFhoZq7dq1Onr0qH777TdJf4a5JUuWKCUlRdu3b1evXr3yzOSEhobq66+/1s8//2wfx9atW+v48eOaOHGiDhw4oNdff10rV66073Pw4EElJiYqOTlZP/74oz777DPt3bvXISACAACgeHB5QFm1apUqVarksNx2223XdMywsDB169ZNHTp00J133qm6detqxowZl+3/4osvqnv37urdu7ciIyO1f/9+rV692v51xxc99NBD+uOPP5wyeyJJMTExWrFihdasWaMmTZqoWbNmevnllxUSEnLFx7jppps0ZswYPfPMM6pYsWKebzS7lK+vr2699VZNnTpVrVq1Ut26dTVixAj169dPr732mr3flClTtGbNGgUHB6thw4aSpKlTp6ps2bJq0aKFOnfurJiYGEVGRjocf+zYsUpLS1ONGjXsL9fXqVNHM2bM0Ouvv64GDRpo8+bNGjp0qH2fUqVK6fvvv1f37t0VHh6uRx55RAMHDlT//v2v+HMAAADAjcFmXfpywHVu9OjRWrp0ab6PEF2r//73v2rdurV++ukn+0vwMENGRob8/f3VYNAbcvP0dnU5AAA42Dqpj6tLAFzu4s9rp0+fLvD9YZf/JfnrQWZmpg4fPqwRI0YoNjaWcAIAAAAUEZc/4nU9mD9/vmrVqqXTp09r4sSJri6nQIcOHcrzd2X+ulzrVwIDAAAARemGe8SruMvOzs7zzVp/FRoaKnf3G2/ijEe8AAAm4xEvgEe8ii13d3eFhYW5ugwAAACgUHjECwAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjEFAAAAAAGIOAAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFAAAAADGIKAAAAAAMAYBBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAx3VxcAONPX43vKz8/P1WUAAACgkJhBAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwBgEFAAAAgDEIKAAAAACMQUABAAAAYAwCCgAAAABjuLu6AMAZLMuSJGVkZLi4EgAAAOTn4s9pF39uuxwCCm4Iv/76qyQpODjYxZUAAACgIGfOnJG/v/9ltxNQcEMICAiQJB06dKjA/+DhOhkZGQoODtbhw4fl5+fn6nKQD8bIfIyR+Rgj8zFGrmNZls6cOaPKlSsX2I+AghtCiRJ/vk7l7+/P/9gYzs/PjzEyHGNkPsbIfIyR+Rgj17iSXyTzkjwAAAAAYxBQAAAAABiDgIIbgqenp0aNGiVPT09Xl4LLYIzMxxiZjzEyH2NkPsbIfDbr777nCwAAAAD+IcygAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKjDRjxgxVq1ZNXl5eatSokdavX19g/6+++kqNGjWSl5eXqlevrjfeeCNPn8WLFysiIkKenp6KiIjQRx99VFTlFwvOHqOkpCTZbLY8y4ULF4ryMm5oVzNG6enp6tWrl2rVqqUSJUpo8ODB+fbjPnIuZ48R95HzXc0YLVmyRO3atVOFChXk5+en5s2ba/Xq1Xn6cR85l7PHiPvI9QgoMM7ChQs1ePBgPfvss9q2bZtatmyp9u3b69ChQ/n2P3jwoDp06KCWLVtq27Zt+ve//62EhAQtXrzY3ic5OVn33Xefevfure3bt6t3796KjY3VN998809d1g2lKMZI+vOv+qanpzssXl5e/8Ql3XCudowyMzNVoUIFPfvss2rQoEG+fbiPnKsoxkjiPnKmqx2jr7/+Wu3atdOnn36qrVu3qk2bNurcubO2bdtm78N95FxFMUYS95HLWYBhmjZtag0YMMChrXbt2tYzzzyTb//hw4dbtWvXdmjr37+/1axZM/t6bGysdddddzn0iYmJsXr06OGkqouXohij2bNnW/7+/k6vtbi62jH6q+joaOuJJ57I08595FxFMUbcR851LWN0UUREhDVmzBj7OveRcxXFGHEfuR4zKDDKH3/8oa1bt+rOO+90aL/zzju1cePGfPdJTk7O0z8mJkZbtmxRVlZWgX0ud0xcXlGNkSSdPXtWISEhqlKlijp16pTnN1q4MoUZoyvBfeQ8RTVGEveRszhjjHJzc3XmzBkFBATY27iPnKeoxkjiPnI1AgqMcuLECeXk5KhixYoO7RUrVtTRo0fz3efo0aP59s/OztaJEycK7HO5Y+LyimqMateuraSkJC1btkzz58+Xl5eXoqKitG/fvqK5kBtYYcboSnAfOU9RjRH3kfM4Y4ymTJmic+fOKTY21t7GfeQ8RTVG3Eeu5+7qAoD82Gw2h3XLsvK0/V3/S9uv9pgomLPHqFmzZmrWrJl9e1RUlCIjIzV9+nS9+uqrziq7WCmK/+a5j5zL2Z8n95HzFXaM5s+fr9GjR+vjjz9WYGCgU46J/Dl7jLiPXI+AAqOUL19ebm5ueX7zcezYsTy/IbkoKCgo3/7u7u4qV65cgX0ud0xcXlGN0aVKlCihJk2a8BurQijMGF0J7iPnKaoxuhT3UeFdyxgtXLhQDz30kD744APdcccdDtu4j5ynqMboUtxH/zwe8YJRSpYsqUaNGmnNmjUO7WvWrFGLFi3y3ad58+Z5+n/22Wdq3LixPDw8CuxzuWPi8opqjC5lWZZSUlJUqVIl5xRejBRmjK4E95HzFNUYXYr7qPAKO0bz589XfHy83n//fXXs2DHPdu4j5ymqMboU95ELuOLNfKAgCxYssDw8PKy3337b2r17tzV48GDLx8fHSktLsyzLsp555hmrd+/e9v4//PCDVapUKevJJ5+0du/ebb399tuWh4eH9eGHH9r7/Pe//7Xc3NysF1980UpNTbVefPFFy93d3dq0adM/fn03gqIYo9GjR1urVq2yDhw4YG3bts168MEHLXd3d+ubb775x6/vRnC1Y2RZlrVt2zZr27ZtVqNGjaxevXpZ27Zts3bt2mXfzn3kXEUxRtxHznW1Y/T+++9b7u7u1uuvv26lp6fbl1OnTtn7cB85V1GMEfeR6xFQYKTXX3/dCgkJsUqWLGlFRkZaX331lX1bXFycFR0d7dB/3bp1VsOGDa2SJUtaoaGh1syZM/Mc84MPPrBq1apleXh4WLVr17YWL15c1JdxQ3P2GA0ePNiqWrWqVbJkSatChQrWnXfeaW3cuPGfuJQb1tWOkaQ8S0hIiEMf7iPncvYYcR8539WMUXR0dL5jFBcX53BM7iPncvYYcR+5ns2y/v+bqgAAAADgYryDAgAAAMAYBBQAAAAAxiCgAAAAADAGAQUAAACAMQgoAAAAAIxBQAEAAABgDAIKAAAAAGMQUAAAAAAYg4ACAAAAwBgEFABAsRYfH6+uXbu6uox8paWlyWazKSUlxdWlAMA/hoACAICB/vjjD1eXAAAuQUABAOD/a926tQYNGqTBgwerbNmyqlixov7zn//o3LlzevDBB1W6dGnVqFFDK1eutO+zbt062Ww2ffLJJ2rQoIG8vLx06623aufOnQ7HXrx4sW6++WZ5enoqNDRUU6ZMcdgeGhqq8ePHKz4+Xv7+/urXr5+qVasmSWrYsKFsNptat24tSfr222/Vrl07lS9fXv7+/oqOjtZ3333ncDybzaa33npLd999t0qVKqWaNWtq2bJlDn127dqljh07ys/PT6VLl1bLli114MAB+/bZs2erTp068vLyUu3atTVjxoxr/owB4O8QUAAA+Is5c+aofPny2rx5swYNGqRHH31U9957r1q0aKHvvvtOMTEx6t27t86fP++w37BhwzR58mR9++23CgwM1L/+9S9lZWVJkrZu3arY2Fj16NFDO3fu1OjRozVixAglJSU5HGPSpEmqW7eutm7dqhEjRmjz5s2SpM8//1zp6elasmSJJOnMmTOKi4vT+vXrtWnTJtWsWVMdOnTQmTNnHI43ZswYxcbGaseOHerQoYPuv/9+nTx5UpL0888/q1WrVvLy8tIXX3yhrVu3qm/fvsrOzpYkvfnmm3r22Wc1YcIEpaam6vnnn9eIESM0Z84cp3/mAODAAgCgGIuLi7O6dOliWZZlRUdHW7fddpt9W3Z2tuXj42P17t3b3paenm5JspKTky3Lsqwvv/zSkmQtWLDA3ufXX3+1vL29rYULF1qWZVm9evWy2rVr53DeYcOGWREREfb1kJAQq2vXrg59Dh48aEmytm3bVuA1ZGdnW6VLl7aWL19ub5NkPffcc/b1s2fPWjabzVq5cqVlWZaVmJhoVatWzfrjjz/yPWZwcLD1/vvvO7SNGzfOat68eYG1AMC1YgYFAIC/qF+/vv3fbm5uKleunOrVq2dvq1ixoiTp2LFjDvs1b97c/u+AgADVqlVLqampkqTU1FRFRUU59I+KitK+ffuUk5Njb2vcuPEV1Xjs2DENGDBA4eHh8vf3l7+/v86ePatDhw5d9lp8fHxUunRpe90pKSlq2bKlPDw88hz/+PHjOnz4sB566CH5+vral/Hjxzs8AgYARcHd1QUAAGCSS39gt9lsDm02m02SlJub+7fHutjXsiz7vy+yLCtPfx8fnyuqMT4+XsePH9e0adMUEhIiT09PNW/ePM+L9fldy8W6vb29L3v8i33efPNN3XrrrQ7b3NzcrqhGACgsAgoAAE6wadMmVa1aVZL022+/ae/evapdu7YkKSIiQhs2bHDov3HjRoWHhxf4A3/JkiUlyWGWRZLWr1+vGTNmqEOHDpKkw4cP68SJE1dVb/369TVnzhxlZWXlCTIVK1bUTTfdpB9++EH333//VR0XAK4VAQUAACcYO3asypUrp4oVK+rZZ59V+fLl7X9fZciQIWrSpInGjRun++67T8nJyXrttdf+9luxAgMD5e3trVWrVqlKlSry8vKSv7+/wsLC9O6776px48bKyMjQsGHDCpwRyc/AgQM1ffp09ejRQ4mJifL399emTZvUtGlT1apVS6NHj1ZCQoL8/PzUvn17ZWZmasuWLfrtt9/01FNPFfZjAoC/xTsoAAA4wYsvvqgnnnhCjRo1Unp6upYtW2afAYmMjNSiRYu0YMEC1a1bVyNHjtTYsWMVHx9f4DHd3d316quvatasWapcubK6dOkiSXrnnXf022+/qWHDhurdu7cSEhIUGBh4VfWWK1dOX3zxhc6ePavo6Gg1atRIb775pn025eGHH9Zbb72lpKQk1atXT9HR0UpKSrJ/9TEAFBWbld9DsAAA4IqsW7dObdq00W+//aYyZcq4uhwAuO4xgwIAAADAGAQUAAAAAMbgES8AAAAAxmAGBQAAAIAxCCgAAAAAjEFAAQAAAGAMAgoAAAAAYxBQAAAAABiDgAIAAADAGAQUAAAAAMYgoAAAAAAwxv8DkPqL5H4t/RYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Feature selection in Random Forest is the process of identifying the most important features that contribute t# # o\tthe prediction\n",
    "# Business Use Case: Banking – Predicting Loan Approval\n",
    "# In banking, Random Forest can be used for feature selection in predicting loan approval. Important features like income, \n",
    "# credit score, debt-to-income ratio, and employment status are used t# # o\tpredict whether a loan will be approved.\n",
    "\n",
    "# Python Code Example for Feature Selection in Random Forest\n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "# 2. Prepare the Loan Approval Dataset\n",
    "\n",
    "# Sample dataset for loan approval prediction\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Employment_Status': [1, 1, 1, 0, 0, 0, 1],  # 1 = Employed, 0 = Unemployed\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio', 'Employment_Status']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train Random Forest and Calculate Feature Importance\n",
    "\n",
    "# Train the Random Forest Classifier\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100, max_depth=3, random_state=42)\n",
    "rf_classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predict on the test data\n",
    "y_pred = rf_classifier.predict(X_test)\n",
    "\n",
    "# Evaluate the model performance\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Display Feature Importances\n",
    "feature_importances = rf_classifier.feature_importances_\n",
    "print(\"Feature Importances:\", feature_importances)\n",
    "\n",
    "# Plot Feature Importances\n",
    "features = X.columns\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.barplot(x=feature_importances, y=features)\n",
    "plt.title('Feature Importance')\n",
    "plt.xlabel('Importance')\n",
    "plt.ylabel('Feature')\n",
    "plt.show()\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tAccuracy provides the proportion of correct loan approval predictions. A higher accuracy means better performance.\n",
    "# 2.\tClassification Report:\n",
    "# o\tPrecision, recall, and F1-score metrics give insights int# # o\tthe model's ability to classify loan approval/denial accurately. \n",
    "# Precision indicates the correctness of positive predictions, while recall measures how many actual positive cases are identified.\n",
    "# 3.\tFeature Importances:\n",
    "# o\tThe feature importances are a set of values that indicate how much each feature contributes to the prediction.\n",
    "# Higher values represent more important features for predicting loan approval.\n",
    "# 4.\tFeature Importance Plot:\n",
    "# o\tThe plot visually represents how important each feature is. Features with higher bars are more influential in the \n",
    "# decision-making process of the Random Forest algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "f2ad57a1-d7a3-4556-8681-b8faea4e2301",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      1.00      0.67         1\n",
      "           1       1.00      0.50      0.67         2\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.75      0.75      0.67         3\n",
      "weighted avg       0.83      0.67      0.67         3\n",
      "\n",
      "Feature Importances: [0.28089888 0.28089888 0.23595506 0.20224719]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Ensemble learning techniques involve combining multiple models to\timprove the performance of machine learning algorithms. \n",
    "# Bootstrap Aggregation (Bagging) is one such technique, used to reduce variance and prevent overfitting by combining multiple models.\n",
    "# Random Forest uses Bagging to\tbuild many decision trees on different random subsets of data, making it a strong and robust model.\n",
    "# Business Use Case: Banking – Loan Approval Prediction In the banking industry, predicting whether a loan will be approved\n",
    "# or denied based on customer data (e.g., income, credit score, debt-to-income ratio) is a key application for Random Forest. \n",
    "# By using bagging, Random Forest reduces variance of the prediction and improves its accuracy, especially when data contains noise or outliers.\n",
    "                               \n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "# 2. Prepare the Dataset\n",
    "\n",
    "# Sample dataset for loan approval prediction\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Employment_Status': [1, 1, 1, 0, 0, 0, 1],  # 1 = Employed, 0 = Unemployed\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio', 'Employment_Status']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train Random Forest Classifier (with Bagging)\n",
    "\n",
    "# Initialize the Random Forest Classifier\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100, max_depth=3, random_state=42)\n",
    "\n",
    "# Train the model\n",
    "rf_classifier.fit(X_train, y_train)\n",
    "# 4. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = rf_classifier.predict(X_test)\n",
    "\n",
    "# Evaluate the model performance\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Feature importance for understanding which features are important\n",
    "feature_importances = rf_classifier.feature_importances_\n",
    "print(\"Feature Importances:\", feature_importances)\n",
    "\n",
    "# Visualize Feature Importance\n",
    "features = X.columns\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.barplot(x=feature_importances, y=features)\n",
    "plt.title('Feature Importance in Loan Approval Prediction')\n",
    "plt.xlabel('Importance')\n",
    "plt.ylabel('Feature')\n",
    "plt.show()\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tThe accuracy score indicates the proportion of correct predictions for loan approvals. \n",
    "# A higher accuracy means the model is better at classifying loan applications.\n",
    "# 2.\tClassification Report:\n",
    "# o\tThe precision, recall, and F1-score metrics show the model's ability t# # o\tpredict approved and denied loans correctly. \n",
    "# High precision means the model is good at predicting approved loans, while high recall means it catches most of the approvals.\n",
    "# 3.\tFeature Importance:\n",
    "# o\tFeature importances show how much each feature contributes to\tthe model's predictions. Features like income and \n",
    "# credit score will likely have higher importance, as they are directly related t# # o\ta customer's ability t# # o\trepay a loan.\n",
    "# 4.\tFeature Importance Plot:\n",
    "# The bar plot shows which features are most influential in the loan approval prediction process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "688d5b94-ef99-4967-a826-e8dcaeb2f36d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      1.00      0.67         1\n",
      "           1       1.00      0.50      0.67         2\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.75      0.75      0.67         3\n",
      "weighted avg       0.83      0.67      0.67         3\n",
      "\n",
      "Feature Importances: [0.28089888 0.28089888 0.23595506 0.20224719]\n"
     ]
    }
   ],
   "source": [
    "# Splitting Methods in Random Forest Algorithm\n",
    "# In the Random Forest Algorithm, splitting methods refer t# # o\tthe way the data is divided at each node of a decision tree t# # o\tmaximize model performance. The goal of splitting is t# # o\tseparate the data int# # o\tsubsets that are as \"pure\" as possible, meaning that the observations in each subset are similar t# # o\tone another.\n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "# 2. Prepare the Dataset\n",
    "\n",
    "# Sample dataset for loan approval prediction\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Employment_Status': [1, 1, 1, 0, 0, 0, 1],  # 1 = Employed, 0 = Unemployed\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio', 'Employment_Status']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train Random Forest Classifier (with Gini Impurity)\n",
    "\n",
    "# Initialize the Random Forest Classifier\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100, criterion='gini', random_state=42)\n",
    "\n",
    "# Train the model\n",
    "rf_classifier.fit(X_train, y_train)\n",
    "# 4. Evaluate the Model\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = rf_classifier.predict(X_test)\n",
    "\n",
    "# Evaluate the model performance\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "\n",
    "# Feature importance for understanding which features are important\n",
    "feature_importances = rf_classifier.feature_importances_\n",
    "print(\"Feature Importances:\", feature_importances)\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tThe accuracy score shows how well the model predicts loan approvals. A higher accuracy indicates that the splits chosen\n",
    "# by the decision trees lead to\tcorrect classifications.\n",
    "# 2.\tClassification Report:\n",
    "# o\tThis report provides details on the model's precision, recall, and F1-score. These metrics reflect the model's ability \n",
    "# to\tcorrectly classify approved and denied loans.\n",
    "# 3.\tFeature Importance:\n",
    "# o\tFeature importances tell us which features (e.g., income, credit score) are most important for making decisions about \n",
    "# loan approvals. This is determined by evaluating the reduction in Gini Impurity or Entropy for each feature during splitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "add46dc0-6452-4d65-8525-339d7a3d14d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Confusion Matrix:\n",
      " [[1 0]\n",
      " [1 1]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      1.00      0.67         1\n",
      "           1       1.00      0.50      0.67         2\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.75      0.75      0.67         3\n",
      "weighted avg       0.83      0.67      0.67         3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# KNN is a non-parametric, instance-based learning algorithm used for classification and regression. It predicts outcomes based \n",
    "# on the similarity of new data t# # o\tits nearest neighbors in the training dataset.\n",
    "# Business Application:  Loan Approval Prediction A bank needs t# # o\tclassify customers into\t\"Loan Approved\" or \"Loan Denied\" \n",
    "# categories based on factors such as income, credit score, and loan amount.\n",
    "# 1. # Import Libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
    "# 2. Prepare Dataset\n",
    "\n",
    "# Example dataset\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Loan_Amount': [15000, 18000, 20000, 10000, 12000, 14000, 25000],\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Income', 'Credit_Score', 'Loan_Amount']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Scale Features\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "# 4. Train KNN Classifier\n",
    "\n",
    "# Create KNN model\n",
    "knn = KNeighborsClassifier(n_neighbors=3)\n",
    "\n",
    "# Train the model\n",
    "knn.fit(X_train, y_train)\n",
    "# 5. Evaluate Model\n",
    "\n",
    "# Predict on test set\n",
    "y_pred = knn.predict(X_test)\n",
    "\n",
    "# Metrics\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "print(\"Confusion Matrix:\\n\", conf_matrix)\n",
    "\n",
    "report = classification_report(y_test, y_pred)\n",
    "print(\"Classification Report:\\n\", report)\n",
    "\n",
    "# Output Interpretation\n",
    "# 1.\tAccuracy:\n",
    "# o\tThe percentage of correctly classified instances.\n",
    "# 2.\tConfusion Matrix:\n",
    "# o\tTrue positives (TP), true negatives (TN), false positives (FP), and false negatives (FN).\n",
    "# 3.\tClassification Report:\n",
    "# o\tPrecision, recall, F1-score, and support for each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "70191c3d-bd3d-43ff-93c8-4e0ceaae6249",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted Loan Amounts: [0.33333333 0.66666667 0.33333333]\n"
     ]
    }
   ],
   "source": [
    "# KNN for Regression - Use Case: Predict Loan Amount\n",
    "\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "\n",
    "# Create KNN Regressor\n",
    "knn_reg = KNeighborsRegressor(n_neighbors=3)\n",
    "\n",
    "# Train the model\n",
    "knn_reg.fit(X_train, y_train)\n",
    "\n",
    "# Predict\n",
    "y_pred_reg = knn_reg.predict(X_test)\n",
    "\n",
    "print(\"Predicted Loan Amounts:\", y_pred_reg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f6e337bc-690c-4079-b2de-fe665862ec34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.50      1.00      0.67         1\n",
      "           1       1.00      0.50      0.67         2\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.75      0.75      0.67         3\n",
      "weighted avg       0.83      0.67      0.67         3\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Support Vector Machine (SVM) is a supervised machine learning algorithm used for classification, regression, \n",
    "# and outlier detection. It works by finding a hyperplane that best divides a dataset into\tclasses. The main objective is \n",
    "# to maximize the margin (distance between the hyperplane and the closest data points of each class), ensuring the most efficient separation.\n",
    "\n",
    "# 1. # Import Libraries:\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "# 2. Sample Dataset for Loan Approval Prediction:\n",
    "\n",
    "# Example dataset for loan approval classification\n",
    "data = {\n",
    "    'Income': [45000, 54000, 58000, 30000, 35000, 40000, 80000],\n",
    "    'Credit_Score': [700, 750, 720, 680, 690, 710, 800],\n",
    "    'Debt_Ratio': [0.3, 0.25, 0.2, 0.5, 0.45, 0.4, 0.15],\n",
    "    'Employment_Status': [1, 1, 1, 0, 0, 0, 1],  # 1 = Employed, 0 = Unemployed\n",
    "    'Loan_Status': [1, 1, 1, 0, 0, 0, 1]  # 1 = Approved, 0 = Denied\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Income', 'Credit_Score', 'Debt_Ratio', 'Employment_Status']]\n",
    "y = df['Loan_Status']\n",
    "\n",
    "# Split the data int# # o\ttraining and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Train the SVM Model:\n",
    "\n",
    "# Create an SVM classifier with a linear kernel\n",
    "svm_model = SVC(kernel='linear')\n",
    "\n",
    "# Fit the model on the training data\n",
    "svm_model.fit(X_train, y_train)\n",
    "# 4. Make Predictions and Evaluate the Model:\n",
    "\n",
    "# Predict on the test data\n",
    "y_pred = svm_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "# Output Interpretation:\n",
    "# •\tAccuracy: The percentage of correct predictions made by the model.\n",
    "# •\tClassification Report: Shows precision, recall, and F1-score for each class (approved or denied loan)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "318a71fb-cf0e-424c-a326-4e4279c33668",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.6666666666666666\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      1.00      0.80         2\n",
      "           1       0.00      0.00      0.00         1\n",
      "\n",
      "    accuracy                           0.67         3\n",
      "   macro avg       0.33      0.50      0.40         3\n",
      "weighted avg       0.44      0.67      0.53         3\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n",
      "C:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\metrics\\_classification.py:1531: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n"
     ]
    }
   ],
   "source": [
    "# Support Vector Machine (SVM) is a supervised machine learning algorithm used for classification, regression, and outlier detection. \n",
    "# It works by finding a hyperplane that best divides a dataset int# # o\tclasses. The main objective is to maximize the margin \n",
    "# (distance between the hyperplane and the closest data points of each class), ensuring the most efficient separation.\n",
    "\n",
    "# 1. Importing Libraries:\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "# 2. Sample Dataset (Insurance Claim Prediction):\n",
    "\n",
    "# Sample dataset for predicting insurance claim approval\n",
    "data = {\n",
    "    'Age': [23, 34, 45, 56, 67, 30, 42],\n",
    "    'Medical_History': [0, 1, 1, 0, 0, 1, 1],  # 0 = N# # o\tclaims, 1 = Claims history\n",
    "    'Income': [35000, 50000, 65000, 80000, 120000, 40000, 45000],\n",
    "    'Claim_Approval': [0, 1, 1, 0, 1, 0, 0]  # 0 = Denied, 1 = Approved\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Features and target\n",
    "X = df[['Age', 'Medical_History', 'Income']]\n",
    "y = df['Claim_Approval']\n",
    "\n",
    "# Split the data int# # o\ttraining and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "# 3. Training the SVM Model:\n",
    "\n",
    "# Create an SVM classifier with a linear kernel\n",
    "svm_model = SVC(kernel='linear')\n",
    "\n",
    "# Fit the model on the training data\n",
    "svm_model.fit(X_train, y_train)\n",
    "# 4. Making Predictions and Evaluating the Model:\n",
    "\n",
    "# Predict on the test data\n",
    "y_pred = svm_model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Classification Report:\\n\", classification_report(y_test, y_pred))\n",
    "# Output Interpretation:\n",
    "# •\tAccuracy: The percentage of correct predictions made by the model on the test data.\n",
    "# •\tClassification Report: Contains precision, recall, and F1-score for each class (Claim Approved or Denied)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "1470cdd9-6b02-4c2c-b2b4-633429c94867",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Number of informative, redundant and repeated features must sum to less than the number of total features",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[54], line 13\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdatasets\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m make_classification\n\u001b[0;32m     12\u001b[0m \u001b[38;5;66;03m# Create a simple linear dataset\u001b[39;00m\n\u001b[1;32m---> 13\u001b[0m X, y \u001b[38;5;241m=\u001b[39m make_classification(n_samples\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100\u001b[39m, n_features\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, n_classes\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m, random_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m42\u001b[39m)\n\u001b[0;32m     15\u001b[0m \u001b[38;5;66;03m# Split data int# # o\ttraining and testing sets\u001b[39;00m\n\u001b[0;32m     16\u001b[0m X_train, X_test, y_train, y_test \u001b[38;5;241m=\u001b[39m train_test_split(X, y, test_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.3\u001b[39m, random_state\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m42\u001b[39m)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\utils\\_param_validation.py:213\u001b[0m, in \u001b[0;36mvalidate_params.<locals>.decorator.<locals>.wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m    207\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m    208\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[0;32m    209\u001b[0m         skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[0;32m    210\u001b[0m             prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[0;32m    211\u001b[0m         )\n\u001b[0;32m    212\u001b[0m     ):\n\u001b[1;32m--> 213\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m func(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    214\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m InvalidParameterError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m    215\u001b[0m     \u001b[38;5;66;03m# When the function is just a wrapper around an estimator, we allow\u001b[39;00m\n\u001b[0;32m    216\u001b[0m     \u001b[38;5;66;03m# the function to delegate validation to the estimator, but we replace\u001b[39;00m\n\u001b[0;32m    217\u001b[0m     \u001b[38;5;66;03m# the name of the estimator by the name of the function in the error\u001b[39;00m\n\u001b[0;32m    218\u001b[0m     \u001b[38;5;66;03m# message to avoid confusion.\u001b[39;00m\n\u001b[0;32m    219\u001b[0m     msg \u001b[38;5;241m=\u001b[39m re\u001b[38;5;241m.\u001b[39msub(\n\u001b[0;32m    220\u001b[0m         \u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparameter of \u001b[39m\u001b[38;5;124m\\\u001b[39m\u001b[38;5;124mw+ must be\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    221\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mparameter of \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must be\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    222\u001b[0m         \u001b[38;5;28mstr\u001b[39m(e),\n\u001b[0;32m    223\u001b[0m     )\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\sklearn\\datasets\\_samples_generator.py:214\u001b[0m, in \u001b[0;36mmake_classification\u001b[1;34m(n_samples, n_features, n_informative, n_redundant, n_repeated, n_classes, n_clusters_per_class, weights, flip_y, class_sep, hypercube, shift, scale, shuffle, random_state)\u001b[0m\n\u001b[0;32m    212\u001b[0m \u001b[38;5;66;03m# Count features, clusters and samples\u001b[39;00m\n\u001b[0;32m    213\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_informative \u001b[38;5;241m+\u001b[39m n_redundant \u001b[38;5;241m+\u001b[39m n_repeated \u001b[38;5;241m>\u001b[39m n_features:\n\u001b[1;32m--> 214\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    215\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNumber of informative, redundant and repeated \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    216\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfeatures must sum to less than the number of total\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    217\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m features\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    218\u001b[0m     )\n\u001b[0;32m    219\u001b[0m \u001b[38;5;66;03m# Use log2 to avoid overflow errors\u001b[39;00m\n\u001b[0;32m    220\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_informative \u001b[38;5;241m<\u001b[39m np\u001b[38;5;241m.\u001b[39mlog2(n_classes \u001b[38;5;241m*\u001b[39m n_clusters_per_class):\n",
      "\u001b[1;31mValueError\u001b[0m: Number of informative, redundant and repeated features must sum to less than the number of total features"
     ]
    }
   ],
   "source": [
    "# In SVM, kernels are mathematical functions that enable the algorithm to operate in higher-dimensional spaces without \n",
    "# explicitly calculating the coordinates of the data in those spaces. This is known as the kernel trick. Kernels allow SVM to\t\n",
    "# classify non-linearly separable data by transforming it int# # o\ta higher-dimensional space where it becomes linearly separable.\n",
    "# Types of SVM Kernels: Linear Kernel: This kernel is used when the data is linearly separable. \n",
    "# It directly computes the dot product of input vectors. \n",
    "# Use Case (Insurance): Predicting whether an applicant qualifies for insurance based on features like age, income, and medical history.\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import make_classification\n",
    "\n",
    "# Create a simple linear dataset\n",
    "X, y = make_classification(n_samples=100, n_features=2, n_classes=2, random_state=42)\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n",
    "\n",
    "# Train SVM model with linear kernel\n",
    "model = SVC(kernel='linear')\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Model evaluation\n",
    "accuracy = model.score(X_test, y_test)\n",
    "print(f\"Accuracy with Linear Kernel: {accuracy}\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "24f3f20e-5687-4ba3-9600-35cbff6fef6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy with Polynomial Kernel: 0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "# Polynomial Kernel: This kernel is used for non-linear data that can be separated by a polynomial function. \n",
    "# It’s especially useful when the relationship between classes is more complex and not linear. \n",
    "# Use Case (Insurance): Predicting insurance claim amounts based on multiple factors like the applicant’s age, \n",
    "# past claims, and type of insurance policy.\n",
    "\n",
    "# Train SVM model with polynomial kernel\n",
    "model = SVC(kernel='poly', degree=3, coef0=1)\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Model evaluation\n",
    "accuracy = model.score(X_test, y_test)\n",
    "print(f\"Accuracy with Polynomial Kernel: {accuracy}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "d27cdcb4-3d45-464e-bd04-e3bdfaa13e41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy with RBF Kernel: 0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "# Radial Basis Function (RBF) Kernel: The RBF kernel is the most popular and widely used kernel. It can map data into an infinite-dimensional \n",
    "# space, making it highly effective for complex, non-linear data separations. \n",
    "# Use Case (Insurance): Detecting fraud by analyzing customer behavior patterns that do\tnot follow a simple linear pattern, \n",
    "# e.g., claim frequency combined with customer demographics.\n",
    "\n",
    "# Train SVM model with RBF kernel\n",
    "model = SVC(kernel='rbf', gamma='scale')\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Model evaluation\n",
    "accuracy = model.score(X_test, y_test)\n",
    "print(f\"Accuracy with RBF Kernel: {accuracy}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "290553c7-e2f0-4f84-af13-959d57c294e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy with Sigmoid Kernel: 0.3333333333333333\n"
     ]
    }
   ],
   "source": [
    "# Sigmoid Kernel: The sigmoid kernel is based on the neural network activation function and is less common. \n",
    "# It’s useful for data that has certain characteristics of a neural network-like relationship. \n",
    "# Use Case (Insurance): Customer segmentation, where the features and classes have non-linear relationships that are similar to\t\n",
    "# how neurons are activated in a neural network.\n",
    "\n",
    "# Train SVM model with Sigmoid kernel\n",
    "model = SVC(kernel='sigmoid', gamma='scale')\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Model evaluation\n",
    "accuracy = model.score(X_test, y_test)\n",
    "print(f\"Accuracy with Sigmoid Kernel: {accuracy}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "fc757a05-d324-4b63-8ff1-0594d0ab8135",
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'insurance_claims.csv'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[58], line 10\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmodel_selection\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m train_test_split\n\u001b[0;32m      9\u001b[0m \u001b[38;5;66;03m# Load dataset (insurance claim data)\u001b[39;00m\n\u001b[1;32m---> 10\u001b[0m data \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mread_csv(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minsurance_claims.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     12\u001b[0m \u001b[38;5;66;03m# Fill missing values (example)\u001b[39;00m\n\u001b[0;32m     13\u001b[0m data\u001b[38;5;241m.\u001b[39mfillna(data\u001b[38;5;241m.\u001b[39mmean(), inplace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[1;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[0;32m   1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[0;32m   1014\u001b[0m     dialect,\n\u001b[0;32m   1015\u001b[0m     delimiter,\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1022\u001b[0m     dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[0;32m   1023\u001b[0m )\n\u001b[0;32m   1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[1;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _read(filepath_or_buffer, kwds)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[1;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[0;32m    617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[0;32m    619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[1;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m TextFileReader(filepath_or_buffer, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[0;32m    622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[0;32m    623\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m parser\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[1;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[0;32m   1617\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[0;32m   1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_make_engine(f, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mengine)\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\pandas\\io\\parsers\\readers.py:1880\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[1;34m(self, f, engine)\u001b[0m\n\u001b[0;32m   1878\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[0;32m   1879\u001b[0m         mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m-> 1880\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m get_handle(\n\u001b[0;32m   1881\u001b[0m     f,\n\u001b[0;32m   1882\u001b[0m     mode,\n\u001b[0;32m   1883\u001b[0m     encoding\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m),\n\u001b[0;32m   1884\u001b[0m     compression\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcompression\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m),\n\u001b[0;32m   1885\u001b[0m     memory_map\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmemory_map\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m),\n\u001b[0;32m   1886\u001b[0m     is_text\u001b[38;5;241m=\u001b[39mis_text,\n\u001b[0;32m   1887\u001b[0m     errors\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mencoding_errors\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstrict\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[0;32m   1888\u001b[0m     storage_options\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mstorage_options\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m),\n\u001b[0;32m   1889\u001b[0m )\n\u001b[0;32m   1890\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m   1891\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n",
      "File \u001b[1;32mC:\\ProgramData\\anaconda3\\Lib\\site-packages\\pandas\\io\\common.py:873\u001b[0m, in \u001b[0;36mget_handle\u001b[1;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[0;32m    868\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m    869\u001b[0m     \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[0;32m    870\u001b[0m     \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[0;32m    871\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[0;32m    872\u001b[0m         \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[1;32m--> 873\u001b[0m         handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(\n\u001b[0;32m    874\u001b[0m             handle,\n\u001b[0;32m    875\u001b[0m             ioargs\u001b[38;5;241m.\u001b[39mmode,\n\u001b[0;32m    876\u001b[0m             encoding\u001b[38;5;241m=\u001b[39mioargs\u001b[38;5;241m.\u001b[39mencoding,\n\u001b[0;32m    877\u001b[0m             errors\u001b[38;5;241m=\u001b[39merrors,\n\u001b[0;32m    878\u001b[0m             newline\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    879\u001b[0m         )\n\u001b[0;32m    880\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m    881\u001b[0m         \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[0;32m    882\u001b[0m         handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'insurance_claims.csv'"
     ]
    }
   ],
   "source": [
    "# Steps to Implement SVM (Support Vector Machine) - Implementing an SVM model involves several steps that can be applied to various \n",
    "# business use cases, such as insurance, to\tpredict customer behavior, claim probability, fraud detection, etc. Let's go through the \n",
    "# SVM implementation process step by step.\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Load dataset (insurance claim data)\n",
    "data = pd.read_csv(\"insurance_claims.csv\")\n",
    "\n",
    "# Fill missing values (example)\n",
    "data.fillna(data.mean(), inplace=True)\n",
    "\n",
    "# Separate features and target variable\n",
    "X = data.drop(columns=[\"Claim_Made\"])\n",
    "y = data[\"Claim_Made\"]\n",
    "\n",
    "# Standardize the features\n",
    "scaler = StandardScaler()\n",
    "X_scaled = scaler.fit_transform(X)\n",
    "\n",
    "# Split data int# # o\ttraining and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)\n",
    "\n",
    "# Step 3: Choose the SVM Kernel \n",
    "# •\tBusiness Case: Choose the appropriate kernel for the problem. For example: # o\tIf the data has linear separability, use the Linear Kernel.\n",
    "# o\tFor more complex relationships, use RBF Kernel.\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "# Train SVM model with RBF Kernel\n",
    "model = SVC(kernel='rbf', gamma='scale')\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Step 4: Train the Model\n",
    "# Training the SVM model involves fitting the model to\tthe training data.\n",
    "# •\tBusiness Case: In an insurance use case, this step trains the model to\tunderstand patterns between customer features and the \n",
    "# likelihood of making a claim.\n",
    "\n",
    "# The model has already been trained in the previous step\n",
    "# model.fit(X_train, y_train)\n",
    "\n",
    "# Step 5: Evaluate the Model\n",
    "# After training, evaluate the performance of the model on unseen data (test set). Common evaluation metrics include accuracy, \n",
    "# precision, recall, and F1 score.\n",
    "\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "\n",
    "# Predict on test data\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f\"Accuracy: {accuracy * 100:.2f}%\")\n",
    "print(\"Classification Report:\")\n",
    "print(classification_report(y_test, y_pred))\n",
    "# Output Interpretation:\n",
    "# •\tAccuracy: Percentage of correctly predicted claims.\n",
    "# •\tPrecision: How many of the predicted claims are actual claims.\n",
    "# •\tRecall: How many actual claims were correctly predicted.\n",
    "# •\tF1-Score: Harmonic mean of precision and recall, useful when the dataset is imbalanced.\n",
    "\n",
    "# Step 6: Hyperparameter Tuning\n",
    "# Optimizing the SVM model parameters such as the regularization parameter (C), the kernel type, and kernel-specific parameters like \n",
    "# gamma can improve the model’s performance.\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Define parameter grid\n",
    "param_grid = {'C': [0.1, 1, 10], 'gamma': ['scale', 'auto'], 'kernel': ['linear', 'rbf']}\n",
    "\n",
    "# Perform Grid Search\n",
    "grid_search = GridSearchCV(SVC(), param_grid, refit=True, verbose=2)\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# Best parameters after tuning\n",
    "print(f\"Best Parameters: {grid_search.best_params_}\")\n",
    "\n",
    "# Step 7: Model Prediction and Deployment\n",
    "# Once the model is trained and evaluated, you can use it to make predictions on new, unseen data (e.g., predicting if new applicants\n",
    "# will file a claim).\n",
    "\n",
    "# New data t# # o\tpredict (e.g., new customer)\n",
    "new_data = [[35, 50000, 2]]  # Age, Income, Claim History\n",
    "\n",
    "# Predict claim probability\n",
    "prediction = model.predict(new_data)\n",
    "print(f\"Claim prediction: {'Claim' if prediction[0] == 1 else 'N# # o\tClaim'}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}