Refactoring code and randomized search cv for random forest hyperparams

k_means.py

+from sklearn.cluster import KMeans
+import matplotlib.pyplot as plt
+
+def elbow(X_train):
+    wcss = []
+    for i in range(1,20):
+        kmeans = KMeans(n_clusters=i, init='k-means++', max_iter=300, random_state=0, n_init=10)
+        kmeans.fit(X_train)
+        wcss.append(kmeans.inertia_) # Sum of squared distances of samples to their closest cluster center.
+
+    plt.plot(range(1,20),wcss)
+    plt.title("The Elbow Method")
+    plt.ylabel("no. of clusters")
+    plt.xlabel("WCSS")
+    plt.show()
+
+def kmeans_fit_predict(X_train, X_test):
+    kmeans = KMeans(n_clusters=10, init="k-means++", max_iter=1000, random_state=0, n_init=10)
+    kmeans.fit(X_train)
+    return kmeans.predict(X_test)
\ No newline at end of file

music_genre_classification.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from util import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = load_scale_xy_with_25p_split()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Random Forest"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from random_forest import *"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Search for best hyperparameters by doing randomized cross validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fitting 3 folds for each of 100 candidates, totalling 300 fits\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
+      "[Parallel(n_jobs=-1)]: Done  25 tasks      | elapsed:  2.0min\n",
+      "[Parallel(n_jobs=-1)]: Done 146 tasks      | elapsed: 10.4min\n",
+      "[Parallel(n_jobs=-1)]: Done 300 out of 300 | elapsed: 21.7min finished\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy:  74.8\n",
+      "Hyperparamters:  {'n_estimators': 1000, 'min_samples_split': 2, 'min_samples_leaf': 1, 'max_features': 'auto', 'max_depth': 50, 'bootstrap': False}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 288x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "search_fit_predict_print(randomized_search_cv_rf_fit_predict, X_train, y_train, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Use hyper parameters obtained with randomized search cross validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy:  76.0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 288x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fit_predict_print(rf_fit_predict, X_train, y_train, X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# K-Means"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from k_means import *\n",
+    "X, y = load_scale_x_encode_y()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Find number clusters by the elbow method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "elbow(X)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let number of clusters be 6. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy:  3.3000000000000003\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 288x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fit_predict_print_unsupervised(kmeans_fit_predict,X,X,y)"
+   ]
+  }
+ ],
+ "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.8.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

random_forest.py

+from sklearn.ensemble import RandomForestClassifier
+from sklearn.ensemble import ExtraTreesClassifier
+from sklearn.model_selection import RandomizedSearchCV
+import numpy as np
+
+# def rf_fit_predict(X_train, y_train, X_test):
+#   classifier = RandomForestClassifier(n_estimators= 10, criterion="entropy", random_state=0)
+#   classifier.fit(X_train,y_train)
+#   print(classifier.get_params())
+#   return classifier.predict(X_test)
+  
+
+def rf_fit_predict(X_train, y_train, X_test):
+  classifier = RandomForestClassifier(max_samples=0.95, n_estimators= 3000, bootstrap=True, min_samples_split=2, min_samples_leaf=1, criterion="entropy", random_state=0)
+  # classifier = ExtraTreesClassifier(max_samples=0.75, n_estimators= 3000, bootstrap=True, min_samples_split=2, min_samples_leaf=1, criterion="entropy", random_state=0)
+  classifier.fit(X_train,y_train)
+  # print(classifier.get_params())
+  return classifier.predict(X_test)
+
+def randomized_search_fold_size_rf_fit_predict(X_train, y_train, X_test):
+    max_samples = [0.1,0.2,0.3,0.4,0.5,0.6,0.7]
+
+    random_grid = {'max_samples': max_samples}
+
+    classifier = RandomForestClassifier(n_estimators= 5000, bootstrap=True, max_depth=40, min_samples_split=2, min_samples_leaf=1, criterion="entropy", random_state=0)
+    rf_random = RandomizedSearchCV(estimator = classifier, param_distributions = random_grid, n_iter = 100, cv = 5, verbose=2, random_state=42, n_jobs = -1)
+
+    rf_random.fit(X_train, y_train)
+
+    print(rf_random.best_params_)
+    return rf_random, rf_random.predict(X_test)
+
+def randomized_search_cv_rf_fit_predict(X_train, y_train, X_test):
+    n_estimators = [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)]
+    max_depth = [int(x) for x in np.linspace(10, 110, num = 11)]
+    max_depth.append(None)
+    max_features = ['auto', 'sqrt']
+    min_samples_split = [2, 5, 10]
+    min_samples_leaf = [1, 2, 4]
+    bootstrap = [True, False]
+
+    random_grid = {'n_estimators': n_estimators,
+                'max_features': max_features,
+                'max_depth': max_depth,
+                'min_samples_split': min_samples_split,
+                'min_samples_leaf': min_samples_leaf,
+                'bootstrap': bootstrap}
+
+    classifier = RandomForestClassifier(criterion="entropy")
+    rf_random = RandomizedSearchCV(estimator = classifier, param_distributions = random_grid, n_iter = 100, cv = 3, verbose=2, random_state=42, n_jobs = -1)
+
+    rf_random.fit(X_train, y_train)
+
+    #print("Hyperparameters: ", rf_random.best_params_)
+    return rf_random, rf_random.predict(X_test)
\ No newline at end of file

util.py

+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import LabelEncoder
+
+def load_scale_xy_with_25p_split():
+    dataset = pd.read_csv("data/features_30_sec.csv")
+    X = dataset.iloc[:, 1:59].values
+    y = dataset.iloc[:, 59].values
+
+    #importing the dataset
+    X_train, X_test = train_test_split(X, test_size=0.25, random_state= 0)
+    y_train, y_test = train_test_split(y, test_size=0.25, random_state= 0)
+
+    #feature scaling
+    sc_X = StandardScaler()
+    X_train = sc_X.fit_transform(X_train)
+    X_test = sc_X.transform(X_test)
+
+    return X_train, X_test, y_train, y_test
+
+def load_scale_x_encode_y():
+    dataset = pd.read_csv("data/features_30_sec.csv")
+    X = dataset.iloc[:, 1:59].values
+    y = dataset.iloc[:, 59].values
+
+    sc_X = StandardScaler()
+    X = sc_X.fit_transform(X)
+
+    encoder = LabelEncoder()
+    y = encoder.fit_transform(y)
+    return X, y
+    
+def get_accuracy(cm):
+    sum = 0
+    for i in range(cm.shape[0]):
+        sum = sum + cm[i][i]
+    return 100*(sum/np.sum(cm))
+
+def fit_predict_print(fit_predict_function, X_train, y_train, X_test, y_test):
+    y_pred = fit_predict_function(X_train, y_train, X_test)
+    cm = confusion_matrix(y_test, y_pred)
+    #print(cm)
+    print("Accuracy: ", get_accuracy(cm))
+    plt.matshow(cm)
+    plt.show()
+
+def fit_predict_print_unsupervised(fit_predict_function, X_train, X_test, y_test):
+    y_pred = fit_predict_function(X_train, X_test)
+    if y_test is not None:
+        cm = confusion_matrix(y_test, y_pred)
+        #print(cm)
+        print("Accuracy: ", get_accuracy(cm))
+        plt.matshow(cm)
+        plt.show()
+    
+
+def search_fit_predict_print(fit_predict_function, X_train, y_train, X_test, y_test):
+    ensemble, y_pred = fit_predict_function(X_train, y_train, X_test)
+    cm = confusion_matrix(y_test, y_pred)
+    #print(cm)
+    print("Accuracy: ", get_accuracy(cm))
+    print("Hyperparamters: ", ensemble.best_params_)
+    plt.matshow(cm)
+    plt.show()