diff --git a/house-prices-py/house-prices-random-forest.ipynb b/house-prices-py/house-prices-random-forest.ipynb new file mode 100644 index 0000000..f9330fa --- /dev/null +++ b/house-prices-py/house-prices-random-forest.ipynb @@ -0,0 +1,1567 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.cross_validation import train_test_split\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DOTSCIENCE_INPUTS=[\"agent1\", \"agent2\"]\n", + "DOTSCIENCE_OUTPUTS=[\"model\"]\n", + "DOTSCIENCE_LABELS={\"model_type\": \"random_forest\"}\n" + ] + } + ], + "source": [ + "print('DOTSCIENCE_INPUTS=[\"agent1\", \"agent2\"]')\n", + "print('DOTSCIENCE_OUTPUTS=[\"model\"]')\n", + "print('DOTSCIENCE_LABELS={\"model_type\": \"random_forest\"}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are using a housing price dataset sourced from Bay Area Home Sales Database and Zillow. This dataset was based on the homes sold between January 2013 and December 2015. " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "inputs = [pd.read_csv('./agent1/bay_area_zillow_agent1.csv'), pd.read_csv('./agent2/bay_area_zillow_agent2.csv')]\n", + "df = pd.concat(f for f in inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# randomise my dataframe rows to remove any ordering in the data\n", + "# TODO fix seed to preserve reproducibility\n", + "df = df.sample(frac=1).reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0addressinfoz_addressbathroomsbedroomsfinishedsqftlastsolddatelastsoldpricelatitudelongitudeneighborhoodtotalroomsusecodeyearbuiltzestimatezindexvaluezipcodezpid
count11330.00000011330113301133011330.00000011330.00000011330.000000113301.133000e+0411330.00000011330.0000001133011330.0000001133011330.0000001.133000e+041.133000e+0411330.0000001.133000e+04
uniqueNaN107301123210684NaNNaNNaN954NaNNaNNaN71NaN10NaNNaNNaNNaNNaN
topNaNAddress: 1300 Eddy StreetSan FranciscoSales price: 850000Sales date: 02...1300 Eddy StNaNNaNNaN08/30/2013NaNNaNNaNMissionNaNSingleFamilyNaNNaNNaNNaNNaN
freqNaN535NaNNaNNaN46NaNNaNNaN540NaN5803NaNNaNNaNNaNNaN
mean9171.729214NaNNaNNaN1.9802292.6144751585.420918NaN1.263928e+0637.759711-122.436518NaN6.111562NaN1948.4981471.565695e+061.320205e+0694116.9120043.689973e+07
std4921.941074NaNNaNNaN1.0473581.299457921.978245NaN1.042079e+060.0255780.030743NaN12.125819NaN37.9111961.229417e+065.848170e+059.4008777.800741e+07
min2.000000NaNNaNNaN0.5000000.0000001.000000NaN5.350000e+0237.708170-122.510726NaN1.000000NaN1860.0000004.323850e+056.881000e+0594102.0000001.506329e+07
25%5039.750000NaNNaNNaN1.0000002.0000001019.000000NaN7.292500e+0537.739286-122.455157NaN4.000000NaN1916.0000009.052375e+059.829000e+0594110.0000001.510847e+07
50%9198.500000NaNNaNNaN2.0000002.0000001362.000000NaN9.900000e+0537.760513-122.432510NaN5.000000NaN1940.0000001.230758e+061.211900e+0694115.0000001.515697e+07
75%13374.750000NaNNaNNaN2.0000003.0000001876.000000NaN1.450000e+0637.781386-122.413359NaN7.000000NaN1986.0000001.731170e+061.480400e+0694123.0000005.970040e+07
max17632.000000NaNNaNNaN14.00000020.00000027275.000000NaN2.388900e+0737.806083-122.381201NaN1264.000000NaN2016.0000001.553325e+075.333500e+0694158.0000002.146999e+09
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 address \\\n", + "count 11330.000000 11330 \n", + "unique NaN 10730 \n", + "top NaN Address: 1300 Eddy Street \n", + "freq NaN 5 \n", + "mean 9171.729214 NaN \n", + "std 4921.941074 NaN \n", + "min 2.000000 NaN \n", + "25% 5039.750000 NaN \n", + "50% 9198.500000 NaN \n", + "75% 13374.750000 NaN \n", + "max 17632.000000 NaN \n", + "\n", + " info z_address \\\n", + "count 11330 11330 \n", + "unique 11232 10684 \n", + "top San FranciscoSales price: 850000Sales date: 02... 1300 Eddy St \n", + "freq 3 5 \n", + "mean NaN NaN \n", + "std NaN NaN \n", + "min NaN NaN \n", + "25% NaN NaN \n", + "50% NaN NaN \n", + "75% NaN NaN \n", + "max NaN NaN \n", + "\n", + " bathrooms bedrooms finishedsqft lastsolddate lastsoldprice \\\n", + "count 11330.000000 11330.000000 11330.000000 11330 1.133000e+04 \n", + "unique NaN NaN NaN 954 NaN \n", + "top NaN NaN NaN 08/30/2013 NaN \n", + "freq NaN NaN NaN 46 NaN \n", + "mean 1.980229 2.614475 1585.420918 NaN 1.263928e+06 \n", + "std 1.047358 1.299457 921.978245 NaN 1.042079e+06 \n", + "min 0.500000 0.000000 1.000000 NaN 5.350000e+02 \n", + "25% 1.000000 2.000000 1019.000000 NaN 7.292500e+05 \n", + "50% 2.000000 2.000000 1362.000000 NaN 9.900000e+05 \n", + "75% 2.000000 3.000000 1876.000000 NaN 1.450000e+06 \n", + "max 14.000000 20.000000 27275.000000 NaN 2.388900e+07 \n", + "\n", + " latitude longitude neighborhood totalrooms usecode \\\n", + "count 11330.000000 11330.000000 11330 11330.000000 11330 \n", + "unique NaN NaN 71 NaN 10 \n", + "top NaN NaN Mission NaN SingleFamily \n", + "freq NaN NaN 540 NaN 5803 \n", + "mean 37.759711 -122.436518 NaN 6.111562 NaN \n", + "std 0.025578 0.030743 NaN 12.125819 NaN \n", + "min 37.708170 -122.510726 NaN 1.000000 NaN \n", + "25% 37.739286 -122.455157 NaN 4.000000 NaN \n", + "50% 37.760513 -122.432510 NaN 5.000000 NaN \n", + "75% 37.781386 -122.413359 NaN 7.000000 NaN \n", + "max 37.806083 -122.381201 NaN 1264.000000 NaN \n", + "\n", + " yearbuilt zestimate zindexvalue zipcode zpid \n", + "count 11330.000000 1.133000e+04 1.133000e+04 11330.000000 1.133000e+04 \n", + "unique NaN NaN NaN NaN NaN \n", + "top NaN NaN NaN NaN NaN \n", + "freq NaN NaN NaN NaN NaN \n", + "mean 1948.498147 1.565695e+06 1.320205e+06 94116.912004 3.689973e+07 \n", + "std 37.911196 1.229417e+06 5.848170e+05 9.400877 7.800741e+07 \n", + "min 1860.000000 4.323850e+05 6.881000e+05 94102.000000 1.506329e+07 \n", + "25% 1916.000000 9.052375e+05 9.829000e+05 94110.000000 1.510847e+07 \n", + "50% 1940.000000 1.230758e+06 1.211900e+06 94115.000000 1.515697e+07 \n", + "75% 1986.000000 1.731170e+06 1.480400e+06 94123.000000 5.970040e+07 \n", + "max 2016.000000 1.553325e+07 5.333500e+06 94158.000000 2.146999e+09 " + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe(include = \"all\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Unnamed: 0', 'address', 'info', 'z_address', 'bathrooms', 'bedrooms',\n", + " 'finishedsqft', 'lastsolddate', 'lastsoldprice', 'latitude',\n", + " 'longitude', 'neighborhood', 'totalrooms', 'usecode', 'yearbuilt',\n", + " 'zestimate', 'zindexvalue', 'zipcode', 'zpid'],\n", + " dtype='object')" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# drop unneeded columns\n", + "df.drop(df.columns[[0, 1, 2, 3, 11, 13, 14, 15, 16, 17, 18]], axis=1, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bathroomsbedroomsfinishedsqftlastsolddatelastsoldpricelatitudelongitudetotalrooms
count11330.00000011330.00000011330.000000113301.133000e+0411330.00000011330.00000011330.000000
uniqueNaNNaNNaN954NaNNaNNaNNaN
topNaNNaNNaN08/30/2013NaNNaNNaNNaN
freqNaNNaNNaN46NaNNaNNaNNaN
mean1.9802292.6144751585.420918NaN1.263928e+0637.759711-122.4365186.111562
std1.0473581.299457921.978245NaN1.042079e+060.0255780.03074312.125819
min0.5000000.0000001.000000NaN5.350000e+0237.708170-122.5107261.000000
25%1.0000002.0000001019.000000NaN7.292500e+0537.739286-122.4551574.000000
50%2.0000002.0000001362.000000NaN9.900000e+0537.760513-122.4325105.000000
75%2.0000003.0000001876.000000NaN1.450000e+0637.781386-122.4133597.000000
max14.00000020.00000027275.000000NaN2.388900e+0737.806083-122.3812011264.000000
\n", + "
" + ], + "text/plain": [ + " bathrooms bedrooms finishedsqft lastsolddate lastsoldprice \\\n", + "count 11330.000000 11330.000000 11330.000000 11330 1.133000e+04 \n", + "unique NaN NaN NaN 954 NaN \n", + "top NaN NaN NaN 08/30/2013 NaN \n", + "freq NaN NaN NaN 46 NaN \n", + "mean 1.980229 2.614475 1585.420918 NaN 1.263928e+06 \n", + "std 1.047358 1.299457 921.978245 NaN 1.042079e+06 \n", + "min 0.500000 0.000000 1.000000 NaN 5.350000e+02 \n", + "25% 1.000000 2.000000 1019.000000 NaN 7.292500e+05 \n", + "50% 2.000000 2.000000 1362.000000 NaN 9.900000e+05 \n", + "75% 2.000000 3.000000 1876.000000 NaN 1.450000e+06 \n", + "max 14.000000 20.000000 27275.000000 NaN 2.388900e+07 \n", + "\n", + " latitude longitude totalrooms \n", + "count 11330.000000 11330.000000 11330.000000 \n", + "unique NaN NaN NaN \n", + "top NaN NaN NaN \n", + "freq NaN NaN NaN \n", + "mean 37.759711 -122.436518 6.111562 \n", + "std 0.025578 0.030743 12.125819 \n", + "min 37.708170 -122.510726 1.000000 \n", + "25% 37.739286 -122.455157 4.000000 \n", + "50% 37.760513 -122.432510 5.000000 \n", + "75% 37.781386 -122.413359 7.000000 \n", + "max 37.806083 -122.381201 1264.000000 " + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe(include = \"all\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bathrooms False\n", + "bedrooms False\n", + "finishedsqft False\n", + "lastsolddate False\n", + "lastsoldprice False\n", + "latitude False\n", + "longitude False\n", + "totalrooms False\n", + "dtype: bool" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# check none of our data is null or NaN\n", + "df.isnull().any()" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bathrooms float64\n", + "bedrooms int64\n", + "finishedsqft int64\n", + "lastsolddate object\n", + "lastsoldprice int64\n", + "latitude float64\n", + "longitude float64\n", + "totalrooms int64\n", + "dtype: object" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.dtypes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "df['bathrooms'] = df['bathrooms'].astype('int64', copy=False)\n", + "df['lastsolddate'] = pd.to_datetime(df['lastsolddate'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "bathrooms int64\n", + "bedrooms int64\n", + "finishedsqft int64\n", + "lastsolddate datetime64[ns]\n", + "lastsoldprice int64\n", + "latitude float64\n", + "longitude float64\n", + "totalrooms int64\n", + "dtype: object" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We hypothesise that `finishedsqft`, `bathrooms` and `bedrooms` are positively correlated with `lastsoldprice`. Let's plot these to see." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.plot(x='finishedsqft', y='lastsoldprice', style='o')\n", + "df.plot(x='bathrooms', y='lastsoldprice', style='o')\n", + "df.plot(x='bedrooms', y='lastsoldprice', style='o')\n", + "df.plot(x='totalrooms', y='lastsoldprice', style='o')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try a random forest model on those features to predict `lastsoldprice`" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "X = df[['bathrooms', 'bedrooms', 'finishedsqft', 'totalrooms', 'longitude', 'latitude']]\n", + "Y = df['lastsoldprice']" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "features = df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['bathrooms', 'bedrooms', 'finishedsqft', 'lastsolddate',\n", + " 'lastsoldprice', 'latitude', 'longitude', 'totalrooms'],\n", + " dtype='object')" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# These are our features:\n", + "features" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# Split data into test and training set. Use random_state for reproducibility\n", + "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=0)\n", + "\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "param_grid = [\n", + " {'n_estimators': [3, 10, 12, 14], 'max_features': [1,2, 3, 4, 5, 6], 'bootstrap': [False]}\n", + "]\n", + "\n", + "rand_forest_regressor = RandomForestRegressor()\n", + "\n", + "# grid_search = GridSearchCV(rand_forest_regressor, param_grid, cv=5, scoring='neg_mean_squared_error')\n", + "\n", + "# grid_search.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys(['bootstrap', 'criterion', 'max_depth', 'max_features', 'max_leaf_nodes', 'min_impurity_decrease', 'min_impurity_split', 'min_samples_leaf', 'min_samples_split', 'min_weight_fraction_leaf', 'n_estimators', 'n_jobs', 'oob_score', 'random_state', 'verbose', 'warm_start'])" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rand_forest_regressor.get_params().keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "grid_search = GridSearchCV(rand_forest_regressor, param_grid, cv=5, scoring='neg_mean_squared_error')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'bootstrap': False, 'max_features': 1, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 14}]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#rand_forest_regressor.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GridSearchCV(cv=5, error_score='raise',\n", + " estimator=RandomForestRegressor(bootstrap=True, 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=10, n_jobs=1,\n", + " oob_score=False, random_state=None, verbose=0, warm_start=False),\n", + " fit_params=None, iid=True, n_jobs=1,\n", + " param_grid=[{'n_estimators': [3, 10, 12, 14], 'max_features': [1, 2, 3, 4, 5, 6], 'bootstrap': [False]}],\n", + " pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',\n", + " scoring='neg_mean_squared_error', verbose=0)" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_search.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bootstrap False\n", + "max_features 1\n", + "n_estimators 3\n", + "bootstrap False\n", + "max_features 1\n", + "n_estimators 10\n", + "bootstrap False\n", + "max_features 1\n", + "n_estimators 12\n", + "bootstrap False\n", + "max_features 1\n", + "n_estimators 14\n", + "bootstrap False\n", + "max_features 2\n", + "n_estimators 3\n", + "bootstrap False\n", + "max_features 2\n", + "n_estimators 10\n", + "bootstrap False\n", + "max_features 2\n", + "n_estimators 12\n", + "bootstrap False\n", + "max_features 2\n", + "n_estimators 14\n", + "bootstrap False\n", + "max_features 3\n", + "n_estimators 3\n", + "bootstrap False\n", + "max_features 3\n", + "n_estimators 10\n", + "bootstrap False\n", + "max_features 3\n", + "n_estimators 12\n", + "bootstrap False\n", + "max_features 3\n", + "n_estimators 14\n", + "bootstrap False\n", + "max_features 4\n", + "n_estimators 3\n", + "bootstrap False\n", + "max_features 4\n", + "n_estimators 10\n", + "bootstrap False\n", + "max_features 4\n", + "n_estimators 12\n", + "bootstrap False\n", + "max_features 4\n", + "n_estimators 14\n", + "bootstrap False\n", + "max_features 5\n", + "n_estimators 3\n", + "bootstrap False\n", + "max_features 5\n", + "n_estimators 10\n", + "bootstrap False\n", + "max_features 5\n", + "n_estimators 12\n", + "bootstrap False\n", + "max_features 5\n", + "n_estimators 14\n", + "bootstrap False\n", + "max_features 6\n", + "n_estimators 3\n", + "bootstrap False\n", + "max_features 6\n", + "n_estimators 10\n", + "bootstrap False\n", + "max_features 6\n", + "n_estimators 12\n", + "bootstrap False\n", + "max_features 6\n", + "n_estimators 14\n" + ] + } + ], + "source": [ + "for param_dict in grid_search.cv_results_['params']:\n", + " for key in param_dict:\n", + " print(key, param_dict[key])\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'bootstrap': False, 'max_features': 1, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 14}]" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#print(grid_search.cv_results_)\n", + "grid_search.cv_results_['params']" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split0_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n", + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split1_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n", + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split2_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n", + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split3_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n", + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('split4_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n", + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('mean_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n", + "/opt/conda/lib/python3.6/site-packages/sklearn/utils/deprecation.py:122: FutureWarning: You are accessing a training score ('std_train_score'), which will not be available by default any more in 0.21. If you need training scores, please set return_train_score=True\n", + " warnings.warn(*warn_args, **warn_kwargs)\n" + ] + }, + { + "data": { + "text/plain": [ + "{'mean_fit_time': array([ 0.02670035, 0.07218471, 0.0794826 , 0.09442725, 0.03206363,\n", + " 0.09923239, 0.11128678, 0.13725066, 0.04301653, 0.13199544,\n", + " 0.17645354, 0.19107656, 0.05362077, 0.16885095, 0.21285925,\n", + " 0.23253999, 0.06591096, 0.21372252, 0.23496523, 0.26321697,\n", + " 0.06686144, 0.22868457, 0.28511877, 0.33475099]),\n", + " 'std_fit_time': array([ 0.0027579 , 0.00708657, 0.00544732, 0.00600505, 0.00313444,\n", + " 0.00198584, 0.0021343 , 0.00471558, 0.00172394, 0.00476192,\n", + " 0.01372714, 0.01207889, 0.00258355, 0.00605446, 0.00831972,\n", + " 0.00932508, 0.00374727, 0.0087858 , 0.00829984, 0.00423302,\n", + " 0.00184826, 0.00382915, 0.02120295, 0.01036391]),\n", + " 'mean_score_time': array([ 0.00182452, 0.00407996, 0.00453982, 0.00528498, 0.00177431,\n", + " 0.00419474, 0.00507927, 0.00540996, 0.00154238, 0.00390286,\n", + " 0.00559421, 0.005477 , 0.00178895, 0.0042151 , 0.00505462,\n", + " 0.00534844, 0.00163779, 0.00430694, 0.00482154, 0.00492797,\n", + " 0.00133824, 0.0037324 , 0.00462227, 0.00533772]),\n", + " 'std_score_time': array([ 2.85087678e-04, 4.44251950e-04, 8.28719934e-05,\n", + " 3.31613740e-04, 2.64974638e-04, 4.98963847e-04,\n", + " 8.44094708e-04, 3.86222350e-04, 4.98128023e-05,\n", + " 1.73863773e-04, 5.80196938e-04, 5.62661409e-04,\n", + " 3.03510076e-04, 3.24203004e-04, 4.87569144e-04,\n", + " 3.82854244e-04, 7.05502451e-05, 8.13061547e-04,\n", + " 1.00646838e-03, 7.94383515e-05, 9.54047369e-05,\n", + " 2.45328589e-04, 4.12959738e-04, 4.63507548e-04]),\n", + " 'param_bootstrap': masked_array(data = [False False False False False False False False False False False False\n", + " False False False False False False False False False False False False],\n", + " mask = [False False False False False False False False False False False False\n", + " False False False False False False False False False False False False],\n", + " fill_value = ?),\n", + " 'param_max_features': masked_array(data = [1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5 6 6 6 6],\n", + " mask = [False False False False False False False False False False False False\n", + " False False False False False False False False False False False False],\n", + " fill_value = ?),\n", + " 'param_n_estimators': masked_array(data = [3 10 12 14 3 10 12 14 3 10 12 14 3 10 12 14 3 10 12 14 3 10 12 14],\n", + " mask = [False False False False False False False False False False False False\n", + " False False False False False False False False False False False False],\n", + " fill_value = ?),\n", + " 'params': [{'bootstrap': False, 'max_features': 1, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 1, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 2, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 3, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 4, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 5, 'n_estimators': 14},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 3},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 10},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 12},\n", + " {'bootstrap': False, 'max_features': 6, 'n_estimators': 14}],\n", + " 'split0_test_score': array([ -3.73210453e+11, -3.75617421e+11, -3.53000648e+11,\n", + " -3.48841678e+11, -3.89588473e+11, -3.50343802e+11,\n", + " -3.38603327e+11, -3.36419514e+11, -4.35346491e+11,\n", + " -3.19536464e+11, -3.37024631e+11, -3.29556892e+11,\n", + " -4.12524444e+11, -3.31318687e+11, -3.43613585e+11,\n", + " -3.31097418e+11, -4.08422691e+11, -3.67054186e+11,\n", + " -3.69188263e+11, -3.73568342e+11, -5.09776978e+11,\n", + " -5.07857455e+11, -5.16109617e+11, -5.03238538e+11]),\n", + " 'split1_test_score': array([ -4.85921454e+11, -4.26055299e+11, -4.37122637e+11,\n", + " -3.57437502e+11, -4.85473380e+11, -4.07036025e+11,\n", + " -3.85138089e+11, -3.87314074e+11, -4.39112367e+11,\n", + " -3.46495062e+11, -3.70806046e+11, -4.14826225e+11,\n", + " -4.54859564e+11, -3.76532174e+11, -3.68583079e+11,\n", + " -3.86200349e+11, -4.99693692e+11, -3.74434248e+11,\n", + " -4.07055253e+11, -3.95715275e+11, -5.77531645e+11,\n", + " -5.70379520e+11, -5.75627608e+11, -5.74490267e+11]),\n", + " 'split2_test_score': array([ -3.53828995e+11, -3.04408880e+11, -2.89291056e+11,\n", + " -2.66893217e+11, -3.51380273e+11, -2.72608128e+11,\n", + " -3.02995686e+11, -2.88950680e+11, -3.31649826e+11,\n", + " -2.70944599e+11, -2.80415236e+11, -2.55037934e+11,\n", + " -3.80568173e+11, -2.84812762e+11, -2.85750408e+11,\n", + " -2.76453429e+11, -3.47291223e+11, -3.66580438e+11,\n", + " -2.92836064e+11, -2.89943075e+11, -4.97099654e+11,\n", + " -4.88324636e+11, -4.85433095e+11, -4.86742451e+11]),\n", + " 'split3_test_score': array([ -3.39816242e+11, -2.83434114e+11, -2.68707981e+11,\n", + " -2.82834452e+11, -3.69059905e+11, -3.10539503e+11,\n", + " -3.04013156e+11, -2.72275162e+11, -3.69934651e+11,\n", + " -2.88188104e+11, -2.82239079e+11, -3.07033906e+11,\n", + " -3.35689531e+11, -2.86390315e+11, -2.97174218e+11,\n", + " -3.12073956e+11, -3.83696120e+11, -3.01340113e+11,\n", + " -2.79114192e+11, -2.77464461e+11, -4.07529908e+11,\n", + " -4.03536456e+11, -4.00890599e+11, -4.08953559e+11]),\n", + " 'split4_test_score': array([ -3.94472822e+11, -3.01609342e+11, -2.82826344e+11,\n", + " -3.12078007e+11, -4.22748129e+11, -2.71236224e+11,\n", + " -2.89100625e+11, -3.02856998e+11, -3.74722610e+11,\n", + " -3.04669627e+11, -2.96513114e+11, -2.83199011e+11,\n", + " -4.26019631e+11, -3.65731558e+11, -3.10472419e+11,\n", + " -3.41221055e+11, -4.31300989e+11, -3.99737860e+11,\n", + " -3.86339668e+11, -3.81359891e+11, -5.84484502e+11,\n", + " -5.71717919e+11, -5.87681309e+11, -5.79422226e+11]),\n", + " 'mean_test_score': array([ -3.89447945e+11, -3.38229726e+11, -3.26193114e+11,\n", + " -3.13621413e+11, -4.03648259e+11, -3.22356266e+11,\n", + " -3.23972022e+11, -3.17565663e+11, -3.90158887e+11,\n", + " -3.05968482e+11, -3.13402600e+11, -3.17932259e+11,\n", + " -4.01933604e+11, -3.28957397e+11, -3.21121578e+11,\n", + " -3.29409454e+11, -4.14080230e+11, -3.61830028e+11,\n", + " -3.46909497e+11, -3.43613986e+11, -5.15283843e+11,\n", + " -5.08363134e+11, -5.13148819e+11, -5.10568484e+11]),\n", + " 'std_test_score': array([ 5.16266300e+10, 5.40327175e+10, 6.25603187e+10,\n", + " 3.54797081e+10, 4.72966041e+10, 5.13430957e+10,\n", + " 3.46673258e+10, 4.07575192e+10, 4.12533288e+10,\n", + " 2.59641526e+10, 3.52060003e+10, 5.44107709e+10,\n", + " 4.08343925e+10, 3.84214836e+10, 3.06470604e+10,\n", + " 3.59766998e+10, 5.10696945e+10, 3.25702517e+10,\n", + " 5.13563692e+10, 4.95820595e+10, 6.42383656e+10,\n", + " 6.20449245e+10, 6.75790690e+10, 6.28830243e+10]),\n", + " 'rank_test_score': array([16, 12, 9, 3, 19, 7, 8, 4, 17, 1, 2, 5, 18, 10, 6, 11, 20,\n", + " 15, 14, 13, 24, 21, 23, 22], dtype=int32),\n", + " 'split0_train_score': array([ -1.39474571e+09, -1.39557176e+09, -1.39474593e+09,\n", + " -1.39488215e+09, -1.39492085e+09, -1.39478511e+09,\n", + " -1.39516107e+09, -1.39478041e+09, -1.39474571e+09,\n", + " -1.39477849e+09, -1.39496611e+09, -1.39479348e+09,\n", + " -1.39509599e+09, -1.39474571e+09, -1.39531606e+09,\n", + " -1.39474571e+09, -1.39474571e+09, -1.39474571e+09,\n", + " -1.39474571e+09, -1.39474973e+09, -1.39474571e+09,\n", + " -1.39474571e+09, -1.39474571e+09, -1.39474571e+09]),\n", + " 'split1_train_score': array([ -3.71654798e+09, -3.71667824e+09, -3.71682614e+09,\n", + " -3.71659435e+09, -3.72530378e+09, -3.71657083e+09,\n", + " -3.71657912e+09, -3.71677602e+09, -3.71709522e+09,\n", + " -3.71654924e+09, -3.71654957e+09, -3.71656658e+09,\n", + " -3.71655148e+09, -3.71656124e+09, -3.71655148e+09,\n", + " -3.71674498e+09, -3.71654798e+09, -3.71655082e+09,\n", + " -3.71654820e+09, -3.71654898e+09, -3.71654798e+09,\n", + " -3.71654798e+09, -3.71654798e+09, -3.71654798e+09]),\n", + " 'split2_train_score': array([ -3.83041187e+09, -3.83046681e+09, -3.83129961e+09,\n", + " -3.83111138e+09, -3.83041187e+09, -3.83054584e+09,\n", + " -3.83076155e+09, -3.83104134e+09, -3.83041187e+09,\n", + " -3.83041344e+09, -3.83042318e+09, -3.83041776e+09,\n", + " -3.83041187e+09, -3.83041187e+09, -3.83041187e+09,\n", + " -3.83041187e+09, -3.83041187e+09, -3.83041187e+09,\n", + " -3.83041187e+09, -3.83041187e+09, -3.83041187e+09,\n", + " -3.83041187e+09, -3.83041187e+09, -3.83041187e+09]),\n", + " 'split3_train_score': array([ -3.82759258e+09, -3.82757983e+09, -3.82763665e+09,\n", + " -3.82771829e+09, -3.83186892e+09, -3.82777968e+09,\n", + " -3.82758574e+09, -3.82757857e+09, -3.82757857e+09,\n", + " -3.82757857e+09, -3.82757857e+09, -3.82757857e+09,\n", + " -3.82757857e+09, -3.82757857e+09, -3.82757857e+09,\n", + " -3.82757857e+09, -3.82757857e+09, -3.82757857e+09,\n", + " -3.82757857e+09, -3.82757857e+09, -3.82757857e+09,\n", + " -3.82757857e+09, -3.82757857e+09, -3.82757857e+09]),\n", + " 'split4_train_score': array([ -1.80517362e+09, -1.80562566e+09, -1.80531850e+09,\n", + " -1.80520222e+09, -1.80517362e+09, -1.80520514e+09,\n", + " -1.80536271e+09, -1.80517430e+09, -1.80517712e+09,\n", + " -1.80517393e+09, -1.80517362e+09, -1.80519409e+09,\n", + " -1.80517362e+09, -1.80517393e+09, -1.80517383e+09,\n", + " -1.80517510e+09, -1.80517362e+09, -1.80517362e+09,\n", + " -1.80517449e+09, -1.80517378e+09, -1.80517362e+09,\n", + " -1.80517362e+09, -1.80517362e+09, -1.80517362e+09]),\n", + " 'mean_train_score': array([ -2.91489435e+09, -2.91518446e+09, -2.91516536e+09,\n", + " -2.91510168e+09, -2.91753581e+09, -2.91497732e+09,\n", + " -2.91509004e+09, -2.91507013e+09, -2.91500170e+09,\n", + " -2.91489874e+09, -2.91493821e+09, -2.91491010e+09,\n", + " -2.91496231e+09, -2.91489426e+09, -2.91500636e+09,\n", + " -2.91493125e+09, -2.91489155e+09, -2.91489212e+09,\n", + " -2.91489177e+09, -2.91489259e+09, -2.91489155e+09,\n", + " -2.91489155e+09, -2.91489155e+09, -2.91489155e+09]),\n", + " 'std_train_score': array([ 1.08223574e+09, 1.08193741e+09, 1.08240484e+09,\n", + " 1.08233799e+09, 1.08420872e+09, 1.08227581e+09,\n", + " 1.08214290e+09, 1.08236379e+09, 1.08231375e+09,\n", + " 1.08222455e+09, 1.08217361e+09, 1.08221951e+09,\n", + " 1.08213549e+09, 1.08223527e+09, 1.08207363e+09,\n", + " 1.08226226e+09, 1.08223337e+09, 1.08223379e+09,\n", + " 1.08223323e+09, 1.08223236e+09, 1.08223337e+09,\n", + " 1.08223337e+09, 1.08223337e+09, 1.08223337e+09])}" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_search.cv_results_" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grid_search.best_params_" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "ename": "NotFittedError", + "evalue": "This GridSearchCV instance is not fitted yet. Call 'fit' with appropriate arguments before using this method.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotFittedError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgrid_search\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/utils/metaestimators.py\u001b[0m in \u001b[0;36m\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 113\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[0;31m# lambda, but not partial, allows help() to work with update_wrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 115\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 116\u001b[0m \u001b[0;31m# update the docstring of the returned function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0mupdate_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/model_selection/_search.py\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m 465\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 466\u001b[0m \"\"\"\n\u001b[0;32m--> 467\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_is_fitted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'predict'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 468\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbest_estimator_\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 469\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/model_selection/_search.py\u001b[0m in \u001b[0;36m_check_is_fitted\u001b[0;34m(self, method_name)\u001b[0m\n\u001b[1;32m 449\u001b[0m % (type(self).__name__, method_name))\n\u001b[1;32m 450\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 451\u001b[0;31m \u001b[0mcheck_is_fitted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'best_estimator_'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 452\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 453\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mif_delegate_has_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdelegate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'best_estimator_'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'estimator'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_is_fitted\u001b[0;34m(estimator, attributes, msg, all_or_any)\u001b[0m\n\u001b[1;32m 766\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 767\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mall_or_any\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mattr\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mattributes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 768\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mNotFittedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'name'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 769\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 770\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNotFittedError\u001b[0m: This GridSearchCV instance is not fitted yet. Call 'fit' with appropriate arguments before using this method." + ] + } + ], + "source": [ + "y_pred = grid_search.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#rand_forest_regressor.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-387803891893.90759" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_search.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Mix type of y not allowed, got types {'multiclass', 'continuous'}", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mclassification_report\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/metrics/classification.py\u001b[0m in \u001b[0;36mclassification_report\u001b[0;34m(y_true, y_pred, labels, target_names, sample_weight, digits)\u001b[0m\n\u001b[1;32m 1419\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1420\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1421\u001b[0;31m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0munique_labels\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_true\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1422\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1423\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/sklearn/utils/multiclass.py\u001b[0m in \u001b[0;36munique_labels\u001b[0;34m(*ys)\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 81\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mys_types\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 82\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Mix type of y not allowed, got types %s\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mys_types\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 83\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[0mlabel_type\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mys_types\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Mix type of y not allowed, got types {'multiclass', 'continuous'}" + ] + } + ], + "source": [ + "from sklearn.metrics import classification_report\n", + "\n", + "\n", + "classification_report(y_test, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear Regression coefficient of determination (R squared): 387803891893.9076\n" + ] + } + ], + "source": [ + "print('Linear Regression coefficient of determination (R squared): %.4f' % (0 - grid_search.score(X_test, y_test))) # since score is negative" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "lin_mse = mean_squared_error(y_pred, y_test)\n", + "lin_rmse = np.sqrt(lin_mse)\n", + "print('Linear Regression RMSE: %.4f' % lin_rmse)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print('DOTSCIENCE_PARAMETERS=' + json.dumps({\"features\": \", \".join(sorted(features))}))\n", + "\n", + "\n", + "print('DOTSCIENCE_SUMMARY=' + json.dumps({\"lin_rmse\": lin_rmse, \"regressor_score\": regressor_score}))" + ] + } + ], + "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.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}