Random forest.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "90dfad18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the libraries\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn import tree\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.metrics import classification_report, confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93b15f51",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "72da3e72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the dataset\n",
    "train_calc = pd.read_csv(r'C:\\Users\\Harsh\\Downloads\\calc_case_description_train_set.csv')\n",
    "test_calc = pd.read_csv(r'C:\\Users\\Harsh\\Downloads\\calc_case_description_test_set.csv')\n",
    "train_mass = pd.read_csv(r'C:\\Users\\Harsh\\Downloads\\mass_case_description_train_set.csv')\n",
    "test_mass = pd.read_csv(r'C:\\Users\\Harsh\\Downloads\\mass_case_description_test_set.csv')\n",
    "\n",
    "original = {'train_calc': train_calc, 'test_calc': test_calc, \n",
    "        'train_mass': train_mass, 'test_mass': test_mass}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "0af92406",
   "metadata": {},
   "outputs": [],
   "source": [
    "calc = train_calc.values.tolist() + test_calc.values.tolist()\n",
    "calc = pd.DataFrame(calc, columns = train_calc.columns)\n",
    "mass = train_mass.values.tolist() + test_mass.values.tolist()\n",
    "mass = pd.DataFrame(mass, columns = train_mass.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "37580f9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(data):\n",
    "        # make a copy of the data to avoid SettingWithCopyWarning\n",
    "        data = data.copy()\n",
    "        \n",
    "        # set the limitations on the numerical columns\n",
    "        try:\n",
    "                data['breast density'] = data['breast density'].clip(1, 4)\n",
    "        except KeyError:\n",
    "                data['breast_density'] = data['breast_density'].clip(1, 4)\n",
    "        data['abnormality id'] = data['abnormality id'].clip(0)\n",
    "        data['assessment'] = data['assessment'].clip(0, 5)\n",
    "        data['subtlety'] = data['subtlety'].clip(1, 5)\n",
    "        \n",
    "        # change the name of index\n",
    "        data.index = data['patient_id'] + '_' + data['image view'] + '_' \\\n",
    "        + data['left or right breast'] + '_' + data['abnormality id'].astype(str)\n",
    "\n",
    "        # Remove useless columns\n",
    "        data = data[data.columns.drop(list(data.filter(regex='file path')) \n",
    "                + ['image view', 'patient_id', 'left or right breast', 'abnormality type'])]\n",
    "\n",
    "        # Fill NaN values with appropriate placeholders\n",
    "        try:\n",
    "                data['calc type'] = data['calc type'].fillna('None')\n",
    "                data['calc distribution'] = data['calc distribution'].fillna('None')\n",
    "        except KeyError:\n",
    "                data['mass shape'] = data['mass shape'].fillna('None')\n",
    "                data['mass margins'] = data['mass margins'].fillna('None')\n",
    "\n",
    "        '''\n",
    "        pathology :\n",
    "        BENIGN_WITHOUT_CALLBACK = 0\n",
    "        BENIGN = 0.5\n",
    "        MALIGNANT = 1\n",
    "        '''\n",
    "        data['pathology'] = data['pathology'].map({'BENIGN_WITHOUT_CALLBACK': 0, 'BENIGN': 1, 'MALIGNANT': 2})\n",
    "        \n",
    "\n",
    "        # Encode categorical features\n",
    "        le_pathology = LabelEncoder()\n",
    "        try:\n",
    "                le_type = LabelEncoder()\n",
    "                le_distribution = LabelEncoder()\n",
    "                \n",
    "                data['calc type'] = le_type.fit_transform(data['calc type'])\n",
    "                data['calc distribution'] = le_distribution.fit_transform(data['calc distribution'])\n",
    "                \n",
    "        except KeyError:\n",
    "                le_shape = LabelEncoder()\n",
    "                le_distribution = LabelEncoder()\n",
    "                \n",
    "                data['mass shape'] = le_shape.fit_transform(data['mass shape'])\n",
    "                data['mass margins'] = le_distribution.fit_transform(data['mass margins'])\n",
    "        \n",
    "        # rename columns\n",
    "        data.rename(columns={'abnormality id': 'number of abnormalities', \n",
    "                             'assessment' : 'overall BI-RADS assessment'}, inplace=True)\n",
    "        try:\n",
    "                data.rename(columns={'breast_density' : 'breast density'}, inplace=True)\n",
    "                # split\n",
    "                return data[:train_mass.shape[0]], data[train_mass.shape[0]:]\n",
    "        except KeyError:\n",
    "                return data[:train_calc.shape[0]], data[train_calc.shape[0]:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "b69719cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_calc, test_calc = preprocess(calc)\n",
    "train_mass, test_mass = preprocess(mass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ff689aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "8d56253d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'max_depth': 5, 'max_features': 'auto', 'n_estimators': 200, 'random_state': 42}\n",
      "Best score: 0.6274375987208354\n",
      "Confusion Matrix:\n",
      " [[  0   0   6  56   0]\n",
      " [  0 135  10   4   0]\n",
      " [  0   0   2  46   0]\n",
      " [  0   0   6 229   0]\n",
      " [  0   0   2  45  13]]\n",
      "Accuracy: 0.6841155234657039\n",
      "Mean Squared Error: 1.894682787904892\n",
      "Feature importances:\n",
      "calc type: 0.5762787554983896\n",
      "calc distribution: 0.35859058692488627\n",
      "subtlety: 0.048586003936691914\n",
      "breast density: 0.010093944124681353\n",
      "number of abnormalities: 0.006450709515351024\n"
     ]
    }
   ],
   "source": [
    "# GRID SEARCH WITH RANDOM FOREST CALC                            BEST SCORE\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import mean_squared_error, confusion_matrix\n",
    "import pandas as pd\n",
    "\n",
    "# Define the features for the model\n",
    "features = ['breast density', 'number of abnormalities', 'calc type', 'calc distribution', 'subtlety']\n",
    "\n",
    "# Define the parameter grid to search over\n",
    "param_grid = {\n",
    "    'n_estimators': [50, 100, 200],\n",
    "    'max_depth': [None, 5, 10],\n",
    "    'max_features': ['auto', 'sqrt', 'log2'],\n",
    "    'random_state': [42]\n",
    "}\n",
    "\n",
    "# Create a random forest model object\n",
    "rf = RandomForestRegressor()\n",
    "\n",
    "# Create a GridSearchCV object to perform the search\n",
    "grid_search = GridSearchCV(rf, param_grid=param_grid, cv=5, scoring='r2')\n",
    "\n",
    "# Train the model on the calcification dataset\n",
    "test_X = test_calc[features]\n",
    "test_Y = test_calc['overall BI-RADS assessment']\n",
    "train_X = train_calc[features]\n",
    "train_Y = train_calc['overall BI-RADS assessment']\n",
    "\n",
    "grid_search.fit(train_X, train_Y)\n",
    "\n",
    "# Print the best hyperparameters and score\n",
    "print('Best parameters:', grid_search.best_params_)\n",
    "print('Best score:', grid_search.best_score_)\n",
    "\n",
    "# Make predictions on the test set using the best model\n",
    "best_rf = grid_search.best_estimator_\n",
    "y_pred = best_rf.predict(test_X)\n",
    "\n",
    "# Evaluate the performance of the model using a confusion matrix\n",
    "conf_m = confusion_matrix(test_Y, y_pred.round())\n",
    "print(\"Confusion Matrix:\\n\", conf_m)\n",
    "\n",
    "# Calculate the accuracy of the predictions\n",
    "accuracy = accuracy_score(test_Y, y_pred.round())\n",
    "print('Accuracy:', accuracy)\n",
    "\n",
    "# Calculate the Mean Squared Error of the predictions\n",
    "mse = mean_squared_error(test_Y, y_pred)\n",
    "print('Mean Squared Error:', mse)\n",
    "\n",
    "importances = best_rf.feature_importances_\n",
    "sorted_indices = importances.argsort()[::-1]\n",
    "print('Feature importances:')\n",
    "for index in sorted_indices:\n",
    "    print(f'{features[index]}: {importances[index]}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af9336ae",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "de37a67f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'max_depth': 5, 'max_features': 'auto', 'n_estimators': 100, 'random_state': 42}\n",
      "Best score: 0.3930291587159023\n",
      "Confusion Matrix:\n",
      " [[ 0  6 17  4  6  0]\n",
      " [ 0  0  1  0  1  0]\n",
      " [ 0  0  7  5  2  0]\n",
      " [ 0  0 11 56 18  0]\n",
      " [ 0  3  2 56 99  9]\n",
      " [ 0  0  1  2 32 40]]\n",
      "Accuracy: 0.5343915343915344\n",
      "Mean Squared Error: 1.0140120402077346\n",
      "Feature importances:\n",
      "mass margins: 0.7678348954349647\n",
      "breast density: 0.09594913594746818\n",
      "subtlety: 0.0648055608614647\n",
      "mass shape: 0.051243278271819424\n",
      "number of abnormalities: 0.02016712948428291\n"
     ]
    }
   ],
   "source": [
    "# GRID SEARCH WITH RANDOM FOREST MASS                            BEST SCORE\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import mean_squared_error, confusion_matrix, accuracy_score\n",
    "import pandas as pd\n",
    "\n",
    "# Define the features for the model\n",
    "features = ['breast density', 'number of abnormalities', 'mass shape', 'mass margins', 'subtlety']\n",
    "\n",
    "# Define the parameter grid to search over\n",
    "param_grid = {\n",
    "    'n_estimators': [50, 100, 200],\n",
    "    'max_depth': [None, 5, 10],\n",
    "    'max_features': ['auto', 'sqrt', 'log2'],\n",
    "    'random_state': [42]\n",
    "}\n",
    "\n",
    "# Create a random forest model object\n",
    "rf = RandomForestRegressor()\n",
    "\n",
    "# Create a GridSearchCV object to perform the search\n",
    "grid_search = GridSearchCV(rf, param_grid=param_grid, cv=5, scoring='r2')\n",
    "\n",
    "# Train the model on the mass dataset\n",
    "train_X = train_mass[features]\n",
    "train_Y = train_mass['overall BI-RADS assessment']\n",
    "test_X = test_mass[features]\n",
    "test_Y = test_mass['overall BI-RADS assessment']\n",
    "\n",
    "grid_search.fit(train_X, train_Y)\n",
    "\n",
    "# Print the best hyperparameters and score\n",
    "print('Best parameters:', grid_search.best_params_)\n",
    "print('Best score:', grid_search.best_score_)\n",
    "\n",
    "# Make predictions on the test set using the best model\n",
    "best_rf = grid_search.best_estimator_\n",
    "y_pred = best_rf.predict(test_X)\n",
    "\n",
    "# Evaluate the performance of the model using a confusion matrix\n",
    "conf_m = confusion_matrix(test_Y, y_pred.round())\n",
    "print(\"Confusion Matrix:\\n\", conf_m)\n",
    "\n",
    "# Calculate the accuracy of the predictions\n",
    "accuracy = accuracy_score(test_Y, y_pred.round())\n",
    "print('Accuracy:', accuracy)\n",
    "\n",
    "# Calculate the Mean Squared Error of the predictions\n",
    "mse = mean_squared_error(test_Y, y_pred)\n",
    "print('Mean Squared Error:', mse)\n",
    "\n",
    "importances = best_rf.feature_importances_\n",
    "sorted_indices = importances.argsort()[::-1]\n",
    "print('Feature importances:')\n",
    "for index in sorted_indices:\n",
    "    print(f'{features[index]}: {importances[index]}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb83768f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "acec1556",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'max_depth': 5, 'max_features': 'auto', 'n_estimators': 200, 'random_state': 42}\n",
      "Best score: 0.7412307430177936\n",
      "Confusion matrix:\n",
      "[[145   0   0]\n",
      " [  2 161  19]\n",
      " [  0 124 103]]\n",
      "Accuracy: 0.7382671480144405\n",
      "Mean Squared Error: 0.16154086222619435\n",
      "Feature importances:\n",
      "overall BI-RADS assessment: 0.9359343747361912\n",
      "calc type: 0.021166143003026803\n",
      "subtlety: 0.020907248766062123\n",
      "calc distribution: 0.0147948805072604\n",
      "breast density: 0.0041131955481095665\n",
      "number of abnormalities: 0.00308415743934989\n"
     ]
    }
   ],
   "source": [
    "# GRID SEARCH WITH RANDOM FOREST CALC                            BEST SCORE\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, mean_squared_error\n",
    "import pandas as pd\n",
    "\n",
    "# Define the features for the model\n",
    "features = ['breast density', 'number of abnormalities', 'calc type', 'calc distribution', 'subtlety', 'overall BI-RADS assessment']\n",
    "\n",
    "# Define the parameter grid to search over\n",
    "param_grid = {\n",
    "    'n_estimators': [50, 100, 200],\n",
    "    'max_depth': [None, 5, 10],\n",
    "    'max_features': ['auto', 'sqrt', 'log2'],\n",
    "    'random_state': [42]\n",
    "}\n",
    "\n",
    "# Create a random forest model object\n",
    "rf = RandomForestRegressor()\n",
    "\n",
    "# Create a GridSearchCV object to perform the search\n",
    "grid_search = GridSearchCV(rf, param_grid=param_grid, cv=5, scoring='r2')\n",
    "\n",
    "# Train the model on the calcification dataset\n",
    "train_X = train_calc[features]\n",
    "train_Y = train_calc['pathology']\n",
    "\n",
    "grid_search.fit(train_X, train_Y)\n",
    "\n",
    "# Print the best hyperparameters and score\n",
    "print('Best parameters:', grid_search.best_params_)\n",
    "print('Best score:', grid_search.best_score_)\n",
    "\n",
    "best_rf = grid_search.best_estimator_\n",
    "\n",
    "# Make predictions on the test set\n",
    "test_X = test_calc[features]\n",
    "test_Y = test_calc['pathology']\n",
    "test_pred = best_rf.predict(test_X)\n",
    "\n",
    "# Create a confusion matrix\n",
    "conf_m = confusion_matrix(test_Y, test_pred.round())\n",
    "print('Confusion matrix:')\n",
    "print(conf_m)\n",
    "\n",
    "# Calculate accuracy\n",
    "accuracy = accuracy_score(test_Y, test_pred.round())\n",
    "print('Accuracy:', accuracy)\n",
    "\n",
    "# Calculate MSE\n",
    "mse = mean_squared_error(test_Y, test_pred)\n",
    "print('Mean Squared Error:', mse)\n",
    "\n",
    "# Print feature importances\n",
    "importances = best_rf.feature_importances_\n",
    "sorted_indices = importances.argsort()[::-1]\n",
    "print('Feature importances:')\n",
    "for index in sorted_indices:\n",
    "    print(f'{features[index]}: {importances[index]}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "4d38968e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best parameters: {'max_depth': 10, 'max_features': 'sqrt', 'n_estimators': 200, 'random_state': 42}\n",
      "Best score: 0.5130567581564397\n",
      "Confusion matrix:\n",
      "[[ 15  15   7]\n",
      " [  1 153  40]\n",
      " [  0  28 119]]\n",
      "Accuracy: 0.7592592592592593\n",
      "Mean Squared Error: 0.23168943629489586\n",
      "Feature importances:\n",
      "overall BI-RADS assessment: 0.410302942037519\n",
      "mass margins: 0.24783724935083856\n",
      "mass shape: 0.1698787033060306\n",
      "subtlety: 0.08145129946883534\n",
      "breast density: 0.06968080623978576\n",
      "number of abnormalities: 0.02084899959699087\n"
     ]
    }
   ],
   "source": [
    "# GRID SEARCH WITH RANDOM FOREST MASS                            BEST SCORE\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, mean_squared_error\n",
    "import pandas as pd\n",
    "\n",
    "# Define the features for the model\n",
    "features = ['breast density', 'number of abnormalities', 'mass shape', 'mass margins', 'subtlety', 'overall BI-RADS assessment']\n",
    "\n",
    "# Define the parameter grid to search over\n",
    "param_grid = {\n",
    "    'n_estimators': [50, 100, 200],\n",
    "    'max_depth': [None, 5, 10],\n",
    "    'max_features': ['auto', 'sqrt', 'log2'],\n",
    "    'random_state': [42]\n",
    "}\n",
    "\n",
    "# Create a random forest model object\n",
    "rf = RandomForestRegressor()\n",
    "\n",
    "# Create a GridSearchCV object to perform the search\n",
    "grid_search = GridSearchCV(rf, param_grid=param_grid, cv=5, scoring='r2')\n",
    "\n",
    "# Train the model on the mass dataset\n",
    "train_X = train_mass[features]\n",
    "train_Y = train_mass['pathology']\n",
    "\n",
    "grid_search.fit(train_X, train_Y)\n",
    "\n",
    "# Print the best hyperparameters and score\n",
    "print('Best parameters:', grid_search.best_params_)\n",
    "print('Best score:', grid_search.best_score_)\n",
    "\n",
    "best_rf = grid_search.best_estimator_\n",
    "\n",
    "# Make predictions on the test set\n",
    "test_X = test_mass[features]\n",
    "test_Y = test_mass['pathology']\n",
    "test_pred = best_rf.predict(test_X)\n",
    "\n",
    "# Create a confusion matrix\n",
    "conf_m = confusion_matrix(test_Y, test_pred.round())\n",
    "print('Confusion matrix:')\n",
    "print(conf_m)\n",
    "\n",
    "# Calculate accuracy\n",
    "accuracy = accuracy_score(test_Y, test_pred.round())\n",
    "print('Accuracy:', accuracy)\n",
    "\n",
    "# Calculate MSE\n",
    "mse = mean_squared_error(test_Y, test_pred)\n",
    "print('Mean Squared Error:', mse)\n",
    "\n",
    "# Print feature importances\n",
    "importances = best_rf.feature_importances_\n",
    "sorted_indices = importances.argsort()[::-1]\n",
    "print('Feature importances:')\n",
    "for index in sorted_indices:\n",
    "    print(f'{features[index]}: {importances[index]}')\n"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}