regression_tree.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOdZTNR8SrP9vOY7LOPLq0e",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yajuna/tensorflow_pde/blob/master/regression_tree.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# This notebook details the comparision between decision tree regression, and the KNN regression of the tree trunk temperature modeling problem."
      ],
      "metadata": {
        "id": "8h1RDf03E9UH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Problem set up.\n",
        "We model the temperature of a tree trunk using various regression methods, based on weather conditions and measurements of the bark and core of the tree trunks.\n",
        "\n",
        "We use data collected onsite in Brazil, over a 7 day period, in August of 2022. These data include weather data, as well as temperature data consisting of core and bark temperatures, with two mid-trunk temperatures as validation for our model.\n",
        "\n",
        "We used a developed wireless sensor device that can measure temperature in 10 different position (direction and height) around the tree trunk and 3 different depths. Two spreadsheets were populated with 1 week long of data both from the tree and from our weather station in Brazil.\n",
        "\n",
        "The Tree Data Spreadsheet has the following notation:\n",
        "\n",
        "1. DXX@YY, where D = direction (N = North, S = South, E = East, W =West), XX = depth of the temperature sensor from the tree core, and YY = height of the temperature sensor. For example: S4.5cm@1m = sensor to the South 4.5 cm depth at 1 m height.\n",
        "2. Only the external sensor has a different notation, namely W\\_Ext\\_Temp\\@ 3.5m = to the West at 3.5 m height.\n",
        "\n",
        "The weather station (Modelo D140193 of Ammonit Measurement GmbH) is located near the tree. The weather station Spreadsheet has the following parameters:\n",
        "\n",
        "  1. ``Anemometer;win\\_speed;Avg (m/s)'': Average wind speed in m/s measured by a anemometer\n",
        "  2. ``Wind Vane TMR;wind\\_direction;Avg ($^{\\circ}$)'': Average wind direction in $^{\\circ}$ measured by a Wind Vane\n",
        "  3. ``Hygro/Thermo;humidity;Avg (\\%)'': Average  humidity in \\% measured by a Hygrometer\n",
        "  4. ``Hygro/Thermo;temperature;Avg ($^{\\circ}$C)'': Average temperature in $^{\\circ}$C measured by a Hygrometer\n",
        "  5. ``Barometer;air\\_pressure;Avg (hPa)'': Average air pressure in hPa   measured by a Barometer\n",
        "  6. ``DNI (Direct Normal Irradiance) Pyrheliometer;solar\\_DNI;Avg (W/m$^2$)'':  Average Direct Normal Irradiance in W/m$^2$ measured by a Pyrheliometer.\n",
        "\n",
        "The Direct Normal Irradiance (DNI) is a measurement of the Solar Irradiance. The Global Irradiance is the sum of the DNI and the Diffuse Irradiance. DNI is a fraction of the global solar irradiation, and is the most important parameter in a solar plant installation. So, we use of DNI to measure solar radiation in this model.\n",
        "\n",
        "Weather data is collected every 10 minutes, starting at 00:00; temperature data is collected every 3 minutes, starting at 00:01. It is reasonable to assume weather parameters and tree temperatures are continuous functions of time, so we linearly interpret the collected data to obtain measurements of the same length for our regression analysis.\n",
        "\n",
        "The radius of the mango tree is $r = 0.135$ m, and consider a 24 hour period. We use $n_t$ to denote time steps over time, and $n_x$ grid points in space, and these are parameters used in the linear interpolation of temperature and weather data."
      ],
      "metadata": {
        "id": "ggZI74MskGY-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WG6lnAVebZdv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b12ead97-9719-4d60-d21e-4e13341b3331"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python 3 version is 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]\n",
            "Matplotlib version is 3.7.1\n",
            "Numpy version is 1.25.2\n",
            "Scipy version is 1.11.4\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "# import random\n",
        "# from scipy import sparse\n",
        "from matplotlib import pyplot as plt\n",
        "# from mpl_toolkits.mplot3d import Axes3D\n",
        "%matplotlib inline\n",
        "\n",
        "import sys\n",
        "print(\"Python 3 version is\", sys.version)\n",
        "import matplotlib\n",
        "print(\"Matplotlib version is\", matplotlib.__version__)\n",
        "print(\"Numpy version is\", np.__version__)\n",
        "import scipy\n",
        "\n",
        "print(\"Scipy version is\", scipy.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "# from sklearn.model_selection import train_test_split\n",
        "from sklearn.tree import DecisionTreeRegressor\n",
        "from sklearn.neighbors import KNeighborsRegressor\n",
        "from sklearn.metrics import mean_squared_error, mean_absolute_error\n",
        "from sklearn import preprocessing"
      ],
      "metadata": {
        "id": "nNWcRFPeHBYj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# define parameter\n",
        "n_t = 450\n",
        "radius = 0.135 # unit m\n",
        "time = np.linspace(0, 24, n_t, endpoint = False)"
      ],
      "metadata": {
        "id": "wy6LsHzVHHGj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def fetch_temp_for_date(data, date): # , num_points=412\n",
        "    # Filter data for the given date\n",
        "    date_filtered_data = data[data['datetime'].dt.date == date]\n",
        "\n",
        "    # # If there are more data points than needed, truncate the DataFrame\n",
        "    # if len(date_filtered_data) > num_points:\n",
        "    #     date_filtered_data = date_filtered_data.iloc[:num_points]\n",
        "\n",
        "    # Extract temperature data\n",
        "    core_temp = date_filtered_data['s135_3'].to_numpy()\n",
        "    mid_temp1 = date_filtered_data['w9_3'].to_numpy()\n",
        "    mid_temp2 = date_filtered_data['n45_3'].to_numpy()\n",
        "    bark_temp = date_filtered_data['w_ext_35'].to_numpy()\n",
        "\n",
        "    return core_temp, mid_temp1, mid_temp2, bark_temp"
      ],
      "metadata": {
        "id": "5NzWN_wb6-MZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def fetch_weather_for_date(data, date):\n",
        "    # Filter data for the given date\n",
        "    date_filtered_data = data[data['datetime'].dt.date == date]\n",
        "\n",
        "    # # If there are more data points than needed, truncate the DataFrame\n",
        "    # if len(date_filtered_data) > num_points:\n",
        "    #     date_filtered_data = date_filtered_data.iloc[:num_points]\n",
        "\n",
        "    # Extract temperature data\n",
        "    wind_speed = date_filtered_data['wind_speed'].to_numpy()\n",
        "    humidity = date_filtered_data['humidity'].to_numpy()\n",
        "    air_temperature = date_filtered_data['air_temperature'].to_numpy()\n",
        "    air_pressure = date_filtered_data['air_pressure'].to_numpy()\n",
        "    solar_DNI = date_filtered_data['solar_DNI'].to_numpy()\n",
        "\n",
        "    return wind_speed, humidity, air_temperature, air_pressure, solar_DNI"
      ],
      "metadata": {
        "id": "aTnYJn0J81jo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "colnames = ['datetime', 's45_1', 'e9_1', 'n135_1','e45_2', 'n9_2', 'w135_2', 'n45_3', 'w9_3','s135_3', 'w_ext_35']\n",
        "url1 = \"https://raw.githubusercontent.com/yajuna/linearRegression/master/Tree_Temp_Values_AUG21_to_AUG28_2022.xlsx\"\n",
        "dataTemp = pd.read_excel(url1,names=colnames)\n",
        "\n",
        "# if use data locally:\n",
        "# dataTemp = pandas.read_excel('Tree_Temp_Values_OCT21_to_OCT28_2022.xlsx', names=colnames)\n",
        "\n",
        "# training data processing- measured temperature data from Brazil\n",
        "\n",
        "# Now fetch and process data for August 21, 2022 for training\n",
        "train_coreTemp, train_midTemp1, train_midTemp2, train_barkTemp = fetch_temp_for_date(dataTemp, pd.Timestamp('2022-08-21'))\n",
        "\n",
        "# Now fetch and process data for August 22, 2022 for testing\n",
        "test_coreTemp, test_midTemp1, test_midTemp2, test_barkTemp = fetch_temp_for_date(dataTemp, pd.Timestamp('2022-08-22'))\n",
        "\n",
        "train_interp_temp_size = train_coreTemp.size\n",
        "# linear interpolate the measured temperature\n",
        "train_coreTemp = np. interp(time, np.linspace(0,24,train_interp_temp_size),train_coreTemp)\n",
        "train_midTemp1 = np. interp(time, np.linspace(0,24,train_interp_temp_size),train_midTemp1)\n",
        "train_midTemp2 = np. interp(time, np.linspace(0,24,train_interp_temp_size),train_midTemp2)\n",
        "train_barkTemp = np. interp(time, np.linspace(0,24,train_interp_temp_size),train_barkTemp)\n",
        "\n",
        "test_interp_temp_size = test_coreTemp.size\n",
        "test_coreTemp = np. interp(time, np.linspace(0,24,test_interp_temp_size),test_coreTemp)\n",
        "test_midTemp1 = np. interp(time, np.linspace(0,24,test_interp_temp_size),test_midTemp1)\n",
        "test_midTemp2 = np. interp(time, np.linspace(0,24,test_interp_temp_size),test_midTemp2)\n",
        "test_barkTemp = np. interp(time, np.linspace(0,24,test_interp_temp_size),test_barkTemp)\n",
        "\n",
        "print(\"measured temperature data read\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8-YUI6lgHV8a",
        "outputId": "6a66bf04-4909-4325-e165-b9b0a6829a64"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "measured temperature data read\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-37-438d4642de18>:3: FutureWarning: Comparison of Timestamp with datetime.date is deprecated in order to match the standard library behavior. In a future version these will be considered non-comparable. Use 'ts == pd.Timestamp(date)' or 'ts.date() == date' instead.\n",
            "  date_filtered_data = data[data['datetime'].dt.date == date]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# data on Aug 21\n",
        "train_tree_temp_index = 416 - 2\n",
        "train_weather_index = 145 - 2\n",
        "\n",
        "# data on Aug 22\n",
        "test_weather_index = 289 -2\n",
        "\n",
        "# # data on Aug 26\n",
        "# # index 722 to 865\n",
        "# test_weather_index = 865 -2\n",
        "\n",
        "train_interp_temp_size = train_tree_temp_index\n",
        "train_interp_weather_size = train_weather_index\n",
        "\n",
        "test_interp_temp_size = 414 # 395#\n",
        "test_interp_weather_size = 143"
      ],
      "metadata": {
        "id": "j9FssTZgUM4Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "### Read weather data\n",
        "\n",
        "colnames = ['datetime', 'wind_speed', 'wind_direction', 'humidity', 'air_temperature', 'air_pressure', 'solar_DNI']\n",
        "url2 = \"https://raw.githubusercontent.com/yajuna/linearRegression/master/Weather_Station_AUG21_to_AUG28_2022.xlsx\"\n",
        "dataWeather = pd.read_excel(url2,names=colnames)\n",
        "\n",
        "# if use locally:\n",
        "# dataWeather = pandas.read_excel('Weather_Station_OCT21_to_OCT28_2022.xlsx', names = colnames)\n",
        "\n",
        "# training data processing- measured temperature data from Brazil\n",
        "\n",
        "#########################\n",
        "# # Now fetch and process data for August 21, 2022 for training\n",
        "# train_windSpeed, train_humidity, train_airTemp, train_airPressure, train_solar = fetch_weather_for_date(dataWeather, pd.Timestamp('2022-08-21'))\n",
        "\n",
        "# # Now fetch and process data for August 21, 2022 for training\n",
        "# test_windSpeed, test_humidity, test_airTemp, test_airPressure, test_solar = fetch_weather_for_date(dataWeather, pd.Timestamp('2022-08-22'))\n",
        "########################\n",
        "print(\"weather data read\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_9R9k8fcJ2Eg",
        "outputId": "6a02bced-4a13-42aa-8c1f-833cb13acd4a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "weather data read\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#### training from Aug 21:\n",
        "\n",
        "train_windSpeed = np.array(dataWeather.wind_speed[:train_weather_index])\n",
        "train_humidity = np.array(dataWeather.humidity[:train_weather_index])\n",
        "train_airTemp = np.array(dataWeather.air_temperature[:train_weather_index])+ 273.15\n",
        "train_airPressure = np.array(dataWeather.air_pressure[:train_weather_index])\n",
        "train_solar = np.array(dataWeather.solar_DNI[:train_weather_index])\n",
        "\n",
        "### linear interpret\n",
        "train_airTemp = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,train_interp_weather_size),train_airTemp)\n",
        "train_windSpeed = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,train_interp_weather_size),train_windSpeed)\n",
        "train_solar = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,train_interp_weather_size),train_solar)\n",
        "train_humidity = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,train_interp_weather_size),train_humidity)\n",
        "train_airPressure = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,train_interp_weather_size),train_airPressure)\n",
        "#### testing from Aug 26\n",
        "## index is 722:865\n",
        "#### testing from Aug 22\n",
        "## index is 146:289\n",
        "\n",
        "test_windSpeed = np.array(dataWeather.wind_speed[146:289])\n",
        "test_humidity = np.array(dataWeather.humidity[146:289])\n",
        "test_airTemp = np.array(dataWeather.air_temperature[146:289])+ 273.15\n",
        "test_airPressure = np.array(dataWeather.air_pressure[146:289])\n",
        "test_solar = np.array(dataWeather.solar_DNI[146:289])\n",
        "\n",
        "print(\"test_weather size\", test_airTemp.size)\n",
        "\n",
        "test_airTemp = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,test_interp_weather_size),test_airTemp)\n",
        "test_windSpeed = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,test_interp_weather_size),test_windSpeed)\n",
        "test_solar = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,test_interp_weather_size),test_solar)\n",
        "test_humidity = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,test_interp_weather_size),test_humidity)\n",
        "test_airPressure = np.interp(np.linspace(0,24,n_t), np.linspace(0,24,test_interp_weather_size),test_airPressure)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "06gXl2NsWPCT",
        "outputId": "96976cf3-177e-48a2-d44a-dbdff36660e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "test_weather size 143\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Prepare training and testing data\n",
        "\n",
        "The training data is collected on August 21, and the testing data is collected on August 22, as well as August 26"
      ],
      "metadata": {
        "id": "0oPsO4hkKHkJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#include depth as training variable\n",
        "# n = 0 for 9cm; n = 1 for 4.5cm\n",
        "n = 1\n",
        "depth_list = [0.09/radius, 0.045/radius]\n",
        "\n",
        "# training Y temp\n",
        "Ytrain_list = [train_midTemp1, train_midTemp2]\n",
        "\n",
        "Ytest_list = [test_midTemp1, test_midTemp2]\n",
        "\n",
        "# depth for training is depth1 or depth2\n",
        "depth = np.ones(train_coreTemp.shape) * depth_list[n]\n",
        "\n",
        "# Training data in x; training data in y\n",
        "Xtrain = [1./train_humidity, train_airTemp, train_windSpeed, train_solar, depth, train_coreTemp, train_barkTemp]\n",
        "\n",
        "X_train = np.array(Xtrain).T\n",
        "Y_train = Ytrain_list[n]\n",
        "\n",
        "# testing data in x, testing data in y.\n",
        "ic_test = np.ones(test_coreTemp.shape) * Ytest_list[n][0]\n",
        "Xtest = [1./test_humidity, test_airTemp, test_windSpeed, test_solar, depth, test_coreTemp, test_barkTemp]\n",
        "X_test = np.array(Xtest).T\n",
        "Y_test = Ytest_list[n]"
      ],
      "metadata": {
        "id": "RNatEcDFKGQF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## In the following, we look at regression with the K nearest neighbors (KNN) as well as Decision trees.\n",
        "\n",
        "Both methods are implemented in Python, with the `scikit learn` library."
      ],
      "metadata": {
        "id": "-Q-svsJYjix4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The following two cells are for decision tree regression"
      ],
      "metadata": {
        "id": "9YtCX_syPWTb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Fit regression model with different max depth\n",
        "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
        "regr_2 = DecisionTreeRegressor(max_depth=50)\n",
        "regr_1.fit(X_train, Y_train)\n",
        "regr_2.fit(X_train, Y_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 75
        },
        "id": "Ip0S-_8MjuQt",
        "outputId": "82df3348-fa31-4188-cc30-33d91224ccc0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "DecisionTreeRegressor(max_depth=500)"
            ],
            "text/html": [
              "<style>#sk-container-id-4 {color: black;background-color: white;}#sk-container-id-4 pre{padding: 0;}#sk-container-id-4 div.sk-toggleable {background-color: white;}#sk-container-id-4 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-4 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-4 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-4 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-4 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-4 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-4 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-4 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-4 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-4 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-4 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-4 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-4 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-4 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-4 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-4 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-4 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-4 div.sk-item {position: relative;z-index: 1;}#sk-container-id-4 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-4 div.sk-item::before, #sk-container-id-4 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-4 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-4 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-4 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-4 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-4 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-4 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-4 div.sk-label-container {text-align: center;}#sk-container-id-4 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-4 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-4\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>DecisionTreeRegressor(max_depth=500)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" checked><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">DecisionTreeRegressor</label><div class=\"sk-toggleable__content\"><pre>DecisionTreeRegressor(max_depth=500)</pre></div></div></div></div></div>"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prediction with the above regression models\n",
        "\n",
        "y_1 = regr_1.predict(X_test)\n",
        "y_2 = regr_2.predict(X_test)"
      ],
      "metadata": {
        "id": "L_fcr6vym9QY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# visualization\n",
        "\n",
        "fig0, axs = plt.subplots(3, sharex=True, sharey=False)\n",
        "fig0.suptitle('Measured temperature, predicted temperature, absolute, and relative error with a shallow tree')\n",
        "axs[0].plot(time, Y_test, 'b-', label='Measured values (K)')\n",
        "axs[0].plot(time, y_1, 'r-', label='Predicted values (K)')\n",
        "axs[1].plot(time, Y_test - y_1, 'b-', label='Absolute error (K)')\n",
        "axs[2].plot(time, (Y_test - y_1)/Y_test, 'b-', label='Relative error (%)')\n",
        "axs[0].legend(loc='lower left', fontsize = 'x-small')\n",
        "axs[1].legend(loc='lower left', fontsize = 'x-small')\n",
        "axs[2].legend(loc='lower left', fontsize = 'x-small')\n",
        "plt.xlabel('time (hrs)', fontsize=10)\n",
        "fig0.savefig(\"shallow_decisionTree.eps\")\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "9iLB-l0QoQ2t",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 535
        },
        "outputId": "4ed74fd6-07f7-4207-b931-4e7a6ef218cd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.backends.backend_ps:The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualization\n",
        "\n",
        "fig, axs = plt.subplots(3, sharex=True, sharey=False)\n",
        "fig.suptitle('Measured temperature, predicted temperature, absolute, and relative error with a deep tree')\n",
        "axs[0].plot(time, Y_test, 'b-', label='Measured values (K)')\n",
        "# axs[0].plot(time, y_1, 'r-', label='Predicted values (K)')\n",
        "# axs[1].plot(time, Y_test - y_1, 'b-', label='Absolute error (K)')\n",
        "# axs[2].plot(time, (Y_test - y_1)/Y_test, 'b-', label='Relative error (%)')\n",
        "\n",
        "axs[0].plot(time, y_2, 'r-', label='Predicted values (K)')\n",
        "axs[1].plot(time, Y_test - y_2, 'b-', label='Absolute error (K)')\n",
        "axs[2].plot(time, (Y_test - y_2)/Y_test, 'b-', label='Relative error (%)')\n",
        "axs[0].legend(loc='lower left', fontsize = 'x-small')\n",
        "axs[1].legend(loc='lower left', fontsize = 'x-small')\n",
        "axs[2].legend(loc='lower left', fontsize = 'x-small')\n",
        "plt.xlabel('time (hrs)', fontsize=10)\n",
        "fig.savefig(\"deep_decisionTree.eps\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 535
        },
        "id": "v-Jxz1n-oQoF",
        "outputId": "70a1a72c-345d-4554-8dbf-35d5f55c3a7b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.backends.backend_ps:The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## The equation we are solving is\n",
        "$Y = f(X_0,X_1,...,X_n)$"
      ],
      "metadata": {
        "id": "LKV28udY4q0_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## In the following, we look at KNN regression model\n"
      ],
      "metadata": {
        "id": "u3qDXkuhpIrp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_neighbors = 17\n",
        "# weights = \"uniform\", \"distance\"\n",
        "\n",
        "knn = KNeighborsRegressor(n_neighbors, weights=\"distance\")\n",
        "knn.fit(X_train, Y_train)\n",
        "Y_pred = knn.predict(X_test)"
      ],
      "metadata": {
        "id": "GMLF1gBnpNZ2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# visualization\n",
        "\n",
        "fig1, axs = plt.subplots(3, sharex=True, sharey=False)\n",
        "fig1.suptitle('Measured temperature, predicted temperature, absolute, and relative error with KNN')\n",
        "axs[0].plot(time, Y_test, 'b-', label='Measured values (K)')\n",
        "axs[0].plot(time, Y_pred, 'r-', label='Predicted values (K)')\n",
        "axs[1].plot(time, Y_test - Y_pred, 'b-', label='Absolute error (K)')\n",
        "axs[2].plot(time, (Y_test - Y_pred)/Y_test, 'b-', label='Relative error (%)')\n",
        "\n",
        "axs[0].legend(loc='lower left', fontsize = 'x-small')\n",
        "axs[1].legend(loc='lower left', fontsize = 'x-small')\n",
        "axs[2].legend(loc='lower left', fontsize = 'x-small')\n",
        "plt.xlabel('time (hrs)', fontsize=10)\n",
        "fig.savefig(\"deep_decisionTree.eps\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 535
        },
        "id": "mDV-kN-YO7Y3",
        "outputId": "15036602-e1c4-4b37-a2fb-c5bec19c0755"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.backends.backend_ps:The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}