svm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.svm import SVC  # for classification\n",
    "from sklearn.metrics import accuracy_score  # for classification accuracy\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.decomposition import PCA\n",
    "from scipy.stats import skew,boxcox\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_features = pd.read_csv('train_features.csv')\n",
    "train_targets = pd.read_csv('train_targets_scored.csv')\n",
    "train_features = train_features.drop('sig_id',axis=1)\n",
    "train_targets = train_targets.drop('sig_id',axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "train_features, test_features, train_scored, test_scored = train_test_split(train_features, train_targets, test_size=0.2, random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "train_features = train_features[:5000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_features = test_features[:5000]\n",
    "train_scored = train_scored[:5000]\n",
    "test_scored = test_scored[:5000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PREPROCESSING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_skewness(data) :\n",
    "    columns = data.columns\n",
    "\n",
    "    # removing the skewness from the data set\n",
    "    skew_threshold = 0.5\n",
    "\n",
    "    for col in columns : \n",
    "        skewness_before = skew(data[col])\n",
    "\n",
    "        if abs(skewness_before) > skew_threshold:\n",
    "            # Apply Box-Cox transformation and find the best lambda\n",
    "            min_value = data[col].min()\n",
    "            if (min_value<=0):\n",
    "                data[col] += (-min_value+1)\n",
    "            transformed_data, lambda_best_fit = boxcox(data[col])  # Adding 1 to avoid zero values\n",
    "            data[col] = transformed_data  # Replace the original feature with the transformed data\n",
    "        \n",
    "        skewness_after = skew(data[col])\n",
    "\n",
    "    return data\n",
    "\n",
    "\n",
    "def oneHotEncoding(data):\n",
    "    # performing one hot encoding on discrete features\n",
    "    discrete_features = ['cp_dose','cp_time','cp_type']\n",
    "    data = pd.get_dummies(data,columns=discrete_features,dtype=int)\n",
    "    return data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TRAINING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cross_entropy(predicted_probabilities,true_labels):\n",
    "    # Compute cross-entropy loss\n",
    "    epsilon = 1e-15  # A small constant to prevent numerical instability (avoid log(0))\n",
    "    predicted_probabilities = np.clip(predicted_probabilities, epsilon, 1 - epsilon)  # Clip probabilities\n",
    "    cross_entropy_loss = -np.mean(true_labels * np.log(predicted_probabilities) + (1 - true_labels) * np.log(1 - predicted_probabilities))\n",
    "    return cross_entropy_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------1----------------------------------------\n",
      "cross validation score for training : [0.019242567477756704, 0.019403216376670848, 0.01916953840152598]\n",
      "cross validation scores : [0.019318324683340705, 0.019583528145884634, 0.019675147907895655]\n",
      "mean loss : 0.019525666912373663\n",
      "std dev of loss : 0.0001513090549240335\n",
      "---------------------------------------------------------------------------------\n",
      "---------------------------------------2----------------------------------------\n",
      "cross validation score for training : [0.018909481125669814, 0.018883789377713282, 0.018669998956540756]\n",
      "cross validation scores : [0.01915233772918148, 0.019082233208511372, 0.0192924789306243]\n",
      "mean loss : 0.01917568328943905\n",
      "std dev of loss : 8.740548153863772e-05\n",
      "---------------------------------------------------------------------------------\n",
      "---------------------------------------3----------------------------------------\n",
      "cross validation score for training : [0.01817640744086516, 0.017894736879142743, 0.017997605059374925]\n",
      "cross validation scores : [0.018572626786789812, 0.01857990682261804, 0.018904082837207216]\n",
      "mean loss : 0.018685538815538357\n",
      "std dev of loss : 0.00015456253704313215\n",
      "---------------------------------------------------------------------------------\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32md:\\ML\\Project\\svm.ipynb Cell 10\u001b[0m line \u001b[0;36m7\n\u001b[0;32m     <a href='vscode-notebook-cell:/d%3A/ML/Project/svm.ipynb#X12sZmlsZQ%3D%3D?line=68'>69</a>\u001b[0m     y_train_pred \u001b[39m=\u001b[39m [\u001b[39m0.001\u001b[39m \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mlen\u001b[39m(X_train))]\n\u001b[0;32m     <a href='vscode-notebook-cell:/d%3A/ML/Project/svm.ipynb#X12sZmlsZQ%3D%3D?line=69'>70</a>\u001b[0m \u001b[39m# Train a classifier on the transformed training data\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/d%3A/ML/Project/svm.ipynb#X12sZmlsZQ%3D%3D?line=70'>71</a>\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m---> <a href='vscode-notebook-cell:/d%3A/ML/Project/svm.ipynb#X12sZmlsZQ%3D%3D?line=71'>72</a>\u001b[0m     clf\u001b[39m.\u001b[39;49mfit(X_train, y_train[col])\n\u001b[0;32m     <a href='vscode-notebook-cell:/d%3A/ML/Project/svm.ipynb#X12sZmlsZQ%3D%3D?line=73'>74</a>\u001b[0m     y_train_pred \u001b[39m=\u001b[39m clf\u001b[39m.\u001b[39mpredict_proba(X_train)\n\u001b[0;32m     <a href='vscode-notebook-cell:/d%3A/ML/Project/svm.ipynb#X12sZmlsZQ%3D%3D?line=74'>75</a>\u001b[0m     y_train_pred \u001b[39m=\u001b[39m [row[\u001b[39m1\u001b[39m] \u001b[39mfor\u001b[39;00m row \u001b[39min\u001b[39;00m y_train_pred]\n",
      "File \u001b[1;32mc:\\Users\\Admin\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\base.py:1151\u001b[0m, in \u001b[0;36m_fit_context.<locals>.decorator.<locals>.wrapper\u001b[1;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1144\u001b[0m     estimator\u001b[39m.\u001b[39m_validate_params()\n\u001b[0;32m   1146\u001b[0m \u001b[39mwith\u001b[39;00m config_context(\n\u001b[0;32m   1147\u001b[0m     skip_parameter_validation\u001b[39m=\u001b[39m(\n\u001b[0;32m   1148\u001b[0m         prefer_skip_nested_validation \u001b[39mor\u001b[39;00m global_skip_validation\n\u001b[0;32m   1149\u001b[0m     )\n\u001b[0;32m   1150\u001b[0m ):\n\u001b[1;32m-> 1151\u001b[0m     \u001b[39mreturn\u001b[39;00m fit_method(estimator, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
      "File \u001b[1;32mc:\\Users\\Admin\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\svm\\_base.py:250\u001b[0m, in \u001b[0;36mBaseLibSVM.fit\u001b[1;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[0;32m    247\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39m[LibSVM]\u001b[39m\u001b[39m\"\u001b[39m, end\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m    249\u001b[0m seed \u001b[39m=\u001b[39m rnd\u001b[39m.\u001b[39mrandint(np\u001b[39m.\u001b[39miinfo(\u001b[39m\"\u001b[39m\u001b[39mi\u001b[39m\u001b[39m\"\u001b[39m)\u001b[39m.\u001b[39mmax)\n\u001b[1;32m--> 250\u001b[0m fit(X, y, sample_weight, solver_type, kernel, random_seed\u001b[39m=\u001b[39;49mseed)\n\u001b[0;32m    251\u001b[0m \u001b[39m# see comment on the other call to np.iinfo in this file\u001b[39;00m\n\u001b[0;32m    253\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mshape_fit_ \u001b[39m=\u001b[39m X\u001b[39m.\u001b[39mshape \u001b[39mif\u001b[39;00m \u001b[39mhasattr\u001b[39m(X, \u001b[39m\"\u001b[39m\u001b[39mshape\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39melse\u001b[39;00m (n_samples,)\n",
      "File \u001b[1;32mc:\\Users\\Admin\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\svm\\_base.py:329\u001b[0m, in \u001b[0;36mBaseLibSVM._dense_fit\u001b[1;34m(self, X, y, sample_weight, solver_type, kernel, random_seed)\u001b[0m\n\u001b[0;32m    315\u001b[0m libsvm\u001b[39m.\u001b[39mset_verbosity_wrap(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mverbose)\n\u001b[0;32m    317\u001b[0m \u001b[39m# we don't pass **self.get_params() to allow subclasses to\u001b[39;00m\n\u001b[0;32m    318\u001b[0m \u001b[39m# add other parameters to __init__\u001b[39;00m\n\u001b[0;32m    319\u001b[0m (\n\u001b[0;32m    320\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msupport_,\n\u001b[0;32m    321\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msupport_vectors_,\n\u001b[0;32m    322\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_n_support,\n\u001b[0;32m    323\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdual_coef_,\n\u001b[0;32m    324\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mintercept_,\n\u001b[0;32m    325\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_probA,\n\u001b[0;32m    326\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_probB,\n\u001b[0;32m    327\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfit_status_,\n\u001b[0;32m    328\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_iter,\n\u001b[1;32m--> 329\u001b[0m ) \u001b[39m=\u001b[39m libsvm\u001b[39m.\u001b[39;49mfit(\n\u001b[0;32m    330\u001b[0m     X,\n\u001b[0;32m    331\u001b[0m     y,\n\u001b[0;32m    332\u001b[0m     svm_type\u001b[39m=\u001b[39;49msolver_type,\n\u001b[0;32m    333\u001b[0m     sample_weight\u001b[39m=\u001b[39;49msample_weight,\n\u001b[0;32m    334\u001b[0m     \u001b[39m# TODO(1.4): Replace \"_class_weight\" with \"class_weight_\"\u001b[39;49;00m\n\u001b[0;32m    335\u001b[0m     class_weight\u001b[39m=\u001b[39;49m\u001b[39mgetattr\u001b[39;49m(\u001b[39mself\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39m_class_weight\u001b[39;49m\u001b[39m\"\u001b[39;49m, np\u001b[39m.\u001b[39;49mempty(\u001b[39m0\u001b[39;49m)),\n\u001b[0;32m    336\u001b[0m     kernel\u001b[39m=\u001b[39;49mkernel,\n\u001b[0;32m    337\u001b[0m     C\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mC,\n\u001b[0;32m    338\u001b[0m     nu\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnu,\n\u001b[0;32m    339\u001b[0m     probability\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mprobability,\n\u001b[0;32m    340\u001b[0m     degree\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdegree,\n\u001b[0;32m    341\u001b[0m     shrinking\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mshrinking,\n\u001b[0;32m    342\u001b[0m     tol\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtol,\n\u001b[0;32m    343\u001b[0m     cache_size\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcache_size,\n\u001b[0;32m    344\u001b[0m     coef0\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcoef0,\n\u001b[0;32m    345\u001b[0m     gamma\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_gamma,\n\u001b[0;32m    346\u001b[0m     epsilon\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mepsilon,\n\u001b[0;32m    347\u001b[0m     max_iter\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmax_iter,\n\u001b[0;32m    348\u001b[0m     random_seed\u001b[39m=\u001b[39;49mrandom_seed,\n\u001b[0;32m    349\u001b[0m )\n\u001b[0;32m    351\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_warn_from_fit_status()\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# \n",
    "kfold = 3\n",
    "\n",
    "# Initialize a KFold object\n",
    "kf = KFold(n_splits=kfold, shuffle=True, random_state=42)\n",
    "\n",
    "\n",
    "penalty = [0.01,0.5,1,3,5]\n",
    "\n",
    "# Initialize a list to store the cross-validation accuracies\n",
    "\n",
    "\n",
    "# Perform k-fold cross-validation with PCA\n",
    "itr = 0\n",
    "\n",
    "pc = [5,10,20,40,60,80]\n",
    "contamination = [0.001,0.005,0.01,0.005,0.1,0.2]\n",
    "neighbour = [5,10,25,50,100,200,300]\n",
    "avg_training = []\n",
    "avg_validation = []\n",
    "\n",
    "for i in range(len(penalty)):\n",
    "    cross_val_scores = []\n",
    "    train_cross_val_score = []\n",
    "    for train_index, test_index in kf.split(train_features):\n",
    "\n",
    "        # Split the data into training and testing sets for this fold\n",
    "        X_train, X_test = train_features.iloc[train_index], train_features.iloc[test_index]\n",
    "        y_train, y_test = train_scored.iloc[train_index], train_scored.iloc[test_index]\n",
    "\n",
    "        X_train = oneHotEncoding(X_train)\n",
    "        X_test = oneHotEncoding(X_test)\n",
    "        \n",
    "        # lof_model = LocalOutlierFactor(n_neighbors=5, contamination=contamination[itr])\n",
    "\n",
    "        # # Fit the model and identify outliers\n",
    "        # outlier_scores = lof_model.fit_predict(X_train)\n",
    "        # outlier_indices = X_train.index[outlier_scores == -1]\n",
    "\n",
    "        # X_train = X_train.drop(outlier_indices)\n",
    "        # y_train  = y_train.drop(outlier_indices)\n",
    "\n",
    "        # X_train = X_train.reset_index(drop=True)\n",
    "        # y_train = y_train.reset_index(drop=True)\n",
    "\n",
    "        # X_train = remove_skewness(X_train)\n",
    "        \n",
    "        # X_test = remove_skewness(X_test)\n",
    "\n",
    "        scaler = StandardScaler()\n",
    "        scaler.fit(X_train)\n",
    "        X_train = scaler.transform(X_train)\n",
    "        X_test = scaler.transform(X_test)\n",
    "\n",
    "        # Initialize a PCA object (you can adjust the number of components)\n",
    "        pca = PCA(n_components=pc[itr])\n",
    "        pca.fit(X_train)\n",
    "        X_train = pca.transform(X_train)\n",
    "        X_test  = pca.transform(X_test)\n",
    "\n",
    "        clf = SVC(kernel='linear',probability=True, C = 0.5)  # You can choose different kernels like 'linear', 'rbf', etc.\n",
    "\n",
    "        test_columns = y_train.columns\n",
    "        loss = 0\n",
    "        loss_train = 0\n",
    "        for col in test_columns:\n",
    "            if (y_train[col].unique().shape[0]==1):\n",
    "                y_pred = [0.001 for x in range(len(X_test))]\n",
    "                y_train_pred = [0.001 for x in range(len(X_train))]\n",
    "            # Train a classifier on the transformed training data\n",
    "            else:\n",
    "                clf.fit(X_train, y_train[col])\n",
    "            \n",
    "                y_train_pred = clf.predict_proba(X_train)\n",
    "                y_train_pred = [row[1] for row in y_train_pred]\n",
    "                # Make predictions on the transformed test data\n",
    "                y_pred = clf.predict_proba(X_test)\n",
    "\n",
    "                # print(y_pred)\n",
    "                y_pred = [row[1] for row in y_pred]\n",
    "                \n",
    "                # print(y_pred)\n",
    "                # print(y_train_pred)\n",
    "            \n",
    "            loss += cross_entropy(y_pred,y_test[col].values)\n",
    "\n",
    "            loss_train += cross_entropy(y_train_pred,y_train[col].values)\n",
    "        cross_val_scores.append(loss/test_columns.shape[0])\n",
    "        train_cross_val_score.append(loss_train/test_columns.shape[0])\n",
    "\n",
    "    itr += 1\n",
    "    print(f\"---------------------------------------{itr}----------------------------------------\")\n",
    "    # Calculate the mean and standard deviation of cross-validation scores\n",
    "    print(f\"cross validation score for training : {train_cross_val_score}\")\n",
    "    print(f\"cross validation scores : {cross_val_scores}\")\n",
    "    mean_accuracy = np.mean(cross_val_scores)\n",
    "    std_accuracy = np.std(cross_val_scores)\n",
    "    print(f\"mean loss : {mean_accuracy}\")\n",
    "    print(f\"std dev of loss : {std_accuracy}\")\n",
    "    print(\"---------------------------------------------------------------------------------\")\n",
    "\n",
    "\n",
    "    avg_training.append(np.mean(train_cross_val_score))\n",
    "    avg_validation.append(np.mean(cross_val_scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(penalty,avg_training,label = 'training loss')\n",
    "plt.plot(penalty,avg_validation,label = 'validation loss')\n",
    "plt.xlabel('svm penalty')\n",
    "plt.ylabel('loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.674898734983465\n",
      "2.7720958491049847\n",
      "Test Loss : 0.01783931424749255\n",
      "Training Loss : 0.013456775966529052\n"
     ]
    }
   ],
   "source": [
    "# clf = LogisticRegression(penalty = 'l1', C = 0.5, max_iter=10000,solver='liblinear')\n",
    "clf = SVC(kernel='rbf',probability=True,C=0.5)  # You can choose different kernels like 'linear', 'rbf', etc.\n",
    "X_train = train_features\n",
    "y_train = train_scored\n",
    "\n",
    "X_test = test_features\n",
    "y_test = test_scored\n",
    "\n",
    "X_train = oneHotEncoding(X_train)\n",
    "X_test = oneHotEncoding(X_test)\n",
    "\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(X_train)\n",
    "X_train = scaler.transform(X_train)\n",
    "X_test = scaler.transform(X_test)\n",
    "\n",
    "pca = PCA(n_components=50)\n",
    "pca.fit(X_train)\n",
    "X_train = pca.transform(X_train)\n",
    "X_test  = pca.transform(X_test)\n",
    "\n",
    "test_columns = y_test.columns\n",
    "loss = 0\n",
    "loss_train = 0\n",
    "for col in test_columns:\n",
    "    if (y_train[col].unique().shape[0]==1):\n",
    "        y_pred = [0.001 for x in range(len(X_test))]\n",
    "        # Train a classifier on the transformed training data\n",
    "        y_train_pred = [0.001 for x in range(len(X_train))]\n",
    "    else:\n",
    "        clf.fit(X_train, y_train[col])\n",
    "        y_train_pred = clf.predict_proba(X_train)\n",
    "        y_train_pred = [row[1] for row in y_train_pred]\n",
    "        \n",
    "        # Make predictions on the transformed test data\n",
    "        y_pred = clf.predict_proba(X_test)\n",
    "        y_pred = [row[1] for row in y_pred]\n",
    "\n",
    "\n",
    "        \n",
    "    \n",
    "    loss += cross_entropy(y_pred,y_test[col].values)\n",
    "\n",
    "    loss_train += cross_entropy(y_train_pred,y_train[col].values)\n",
    "print(loss)\n",
    "print(loss_train)\n",
    "print(f\"Test Loss : {loss/test_columns.shape[0]}\")\n",
    "print(f\"Training Loss : {loss_train/test_columns.shape[0]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}