fastai/courses/ml1/FeatureImportanceScratch.ipynb

FeatureImportanceScratch.ipynb

{
  "cells": [
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "%load_ext autoreload\n%autoreload 2",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "%matplotlib inline\n\nfrom fastai.imports import *\nfrom fastai.structured import *\nfrom sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\nfrom IPython.display import display\nfrom sklearn import metrics\nfrom numpy import array\nfrom numpy import reshape",
      "execution_count": 2,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "\nclass TreeEnsemble():\n    def __init__(self, x, y, n_trees, sample_sz, min_leaf=5):\n        np.random.seed(42)\n        self.x,self.y,self.sample_sz,self.min_leaf = x,y,sample_sz,min_leaf\n        self.trees = [self.create_tree() for i in range(n_trees)]\n\n    def create_tree(self):\n        idxs = np.random.permutation(len(self.y))[:self.sample_sz]\n        return DecisionTree(self.x.iloc[idxs], self.y[idxs], \n                    idxs=np.array(range(self.sample_sz)), min_leaf=self.min_leaf)\n        \n    def predict(self, x):\n        return np.mean([t.predict(x) for t in self.trees], axis=0)\n\ndef std_agg(cnt, s1, s2): return math.sqrt((s2/cnt) - (s1/cnt)**2)",
      "execution_count": 3,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "class DecisionTree():\n    def __init__(self, x, y, idxs, min_leaf=5):\n        self.x,self.y,self.idxs,self.min_leaf = x,y,idxs,min_leaf\n        self.n,self.c = len(idxs), x.shape[1]\n        self.val = np.mean(y[idxs])\n        self.score = float('inf')\n        self.find_varsplit()\n        \n    def find_varsplit(self):\n        for i in range(self.c): self.find_better_split(i)\n        if self.score == float('inf'): return\n        x = self.split_col\n        lhs = np.nonzero(x<=self.split)[0]\n        rhs = np.nonzero(x>self.split)[0]\n        self.lhs = DecisionTree(self.x, self.y, self.idxs[lhs])\n        self.rhs = DecisionTree(self.x, self.y, self.idxs[rhs])\n\n    def find_better_split(self, var_idx):\n        x,y = self.x.values[self.idxs,var_idx], self.y[self.idxs]\n        sort_idx = np.argsort(x)\n        sort_y,sort_x = y[sort_idx], x[sort_idx]\n        rhs_cnt,rhs_sum,rhs_sum2 = self.n, sort_y.sum(), (sort_y**2).sum()\n        lhs_cnt,lhs_sum,lhs_sum2 = 0,0.,0.\n\n        for i in range(0,self.n-self.min_leaf-1):\n            xi,yi = sort_x[i],sort_y[i]\n            lhs_cnt += 1; rhs_cnt -= 1\n            lhs_sum += yi; rhs_sum -= yi\n            lhs_sum2 += yi**2; rhs_sum2 -= yi**2\n            if i<self.min_leaf or xi==sort_x[i+1]:\n                continue\n\n            lhs_std = std_agg(lhs_cnt, lhs_sum, lhs_sum2)\n            rhs_std = std_agg(rhs_cnt, rhs_sum, rhs_sum2)\n            curr_score = lhs_std*lhs_cnt + rhs_std*rhs_cnt\n            if curr_score<self.score: \n                self.var_idx,self.score,self.split = var_idx,curr_score,xi\n\n    @property\n    def split_name(self): return self.x.columns[self.var_idx]\n    \n    @property\n    def split_col(self): return self.x.values[self.idxs,self.var_idx]\n\n    @property\n    def is_leaf(self): return self.score == float('inf')\n    \n    def __repr__(self):\n        s = f'n: {self.n}; val:{self.val}'\n        if not self.is_leaf:\n            s += f'; score:{self.score}; split:{self.split}; var:{self.split_name}'\n        return s\n\n    def predict(self, x):\n        return np.array([self.predict_row(xi) for xi in x])\n\n    def predict_row(self, xi):\n        if self.is_leaf: return self.val\n        t = self.lhs if xi[self.var_idx]<=self.split else self.rhs\n        return t.predict_row(xi)",
      "execution_count": 11,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Load in our data from last lesson"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "PATH = \"data/bulldozers/\"\n\ndf_raw = pd.read_feather('tmp/bulldozers-raw')\ndf_raw['random'] = np.random.randint(0,10000, size=len(df_raw))\ndf_trn, y_trn, nas = proc_df(df_raw, 'SalePrice')",
      "execution_count": 19,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def split_vals(a,n): return a[:n], a[n:]\nn_valid = 12000\nn_trn = len(df_trn)-n_valid\nX_train, X_valid = split_vals(df_trn, n_trn)\ny_train, y_valid = split_vals(y_trn, n_trn)\nraw_train, raw_valid = split_vals(df_raw, n_trn)",
      "execution_count": 20,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "cols = ['MachineID', 'YearMade', 'MachineHoursCurrentMeter', 'ProductSize', 'Enclosure',\n        'Coupler_System', 'saleYear', 'random']",
      "execution_count": 21,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "tree = TreeEnsemble(X_train[cols], y_train, 5, 1000)\npreds = tree.predict(X_valid[cols].values)",
      "execution_count": 22,
      "outputs": []
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Feature importance"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def rmse(x,y): return math.sqrt(((x-y)**2).mean())",
      "execution_count": 23,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def shuffle_df_column(df, column):\n    shuffled = df.iloc[:,[column]].sample(frac=1)\n    shuffled.reset_index(inplace=True, drop=True)\n    df.iloc[:,[column]] = shuffled\n    return df\n",
      "execution_count": 24,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def featureImportance(self, x,y):\n    result = pd.DataFrame({'cols':[],'imp':[]})\n    benchRmse = rmse(self.predict(x.values), y)\n    for column in range(x.shape[1]):\n        shuffledRmse = rmse(self.predict(shuffle_df_column(x.copy(), column).values), y)\n        fi = np.absolute(benchRmse - shuffledRmse)\n        result.loc[result.shape[0]] = [x.columns[column], fi]\n    return result.sort_values('imp', ascending=False)\n\n        \n",
      "execution_count": 25,
      "outputs": []
    },
    {
      "metadata": {
        "scrolled": false,
        "trusted": true
      },
      "cell_type": "code",
      "source": "my_fi = featureImportance(tree, X_valid[cols], y_valid);",
      "execution_count": 35,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "def plot_fi(fi): return fi.plot('cols', 'imp', 'barh', figsize=(12,7), legend=False)",
      "execution_count": 30,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "plot_fi(my_fi[:10]);",
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 864x504 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "#sklearn results"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "m = RandomForestRegressor(n_estimators=5, bootstrap=False)\nm.fit(X_train[cols], y_train)",
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 27,
          "data": {
            "text/plain": "RandomForestRegressor(bootstrap=False, criterion='mse', max_depth=None,\n           max_features='auto', max_leaf_nodes=None,\n           min_impurity_decrease=0.0, min_impurity_split=None,\n           min_samples_leaf=1, min_samples_split=2,\n           min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=1,\n           oob_score=False, random_state=None, verbose=0, warm_start=False)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "fi = rf_feat_importance(m, X_valid[cols]); plot_fi(fi[:10])",
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 34,
          "data": {
            "text/plain": "<matplotlib.axes._subplots.AxesSubplot at 0x2c50fd33b70>"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 864x504 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.5",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "gist": {
      "id": "f9019bf80803758a6b1323217d31a99a",
      "data": {
        "description": "fastai/courses/ml1/FeatureImportanceScratch.ipynb",
        "public": true
      }
    },
    "_draft": {
      "nbviewer_url": "https://gist.github.com/f9019bf80803758a6b1323217d31a99a"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}

RFFromScratch.ipynb

RfFromScratch.ipynb