Regression Tree Parsing Calculator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def get_squared_error(y_actual,y_pred):\n",
    "    return np.square(np.subtract(y_actual,y_pred))\n",
    "\n",
    "def get_absolute_error(y_actual,y_pred):\n",
    "    return np.abs(np.subtract(y_actual,y_pred))\n",
    "\n",
    "def reg_stump_train(X_trn,y_trn):\n",
    "    \n",
    "    feat_list = [\"X\"+str(i) for i in range(X_trn.shape[1])]\n",
    "    all_feat_dict = {}\n",
    "    for i in range(len(feat_list)):\n",
    "        feat_split_dict = {}\n",
    "        X = X_trn[:,i]\n",
    "        split_val_min = 0\n",
    "        total_mse_min = 0\n",
    "        sorted_x = list(np.sort(X,kind='mergesort'))\n",
    "        split_check = [(sorted_x[i]+sorted_x[i+1])/2.0 for i in range(len(sorted_x)-1)]\n",
    "        for split_val in split_check:\n",
    "            left  = np.where(X<=split_val)[0]\n",
    "            right = np.where(X>split_val)[0] \n",
    "            c1    = np.mean(y_trn[left])\n",
    "            c2    = np.mean(y_trn[right])\n",
    "            left_sum_mse  = np.sum([(c1-i)**2 for i in y_trn[left]])\n",
    "            right_sum_mse = np.sum([(c2-i)**2 for i in y_trn[right]])\n",
    "            total_mse_split = left_sum_mse+right_sum_mse\n",
    "            feat_split_dict[split_val] = (total_mse_split)\n",
    "        split_val_min,total_mse_min = min(feat_split_dict.items(),key=lambda x:x[1])\n",
    "        all_feat_dict[feat_list[i]] = (split_val_min,total_mse_min)\n",
    "    feature_selected,split_val_mse = min(all_feat_dict.items(),key=lambda x: x[1][1])\n",
    "    split_val,min_train_mse        = split_val_mse[0], split_val_mse[1]\n",
    "    \n",
    "    dim = int(feature_selected[-1])\n",
    "    X   = X_trn[:,dim]\n",
    "    thresh = split_val\n",
    "    c_left = np.mean(y_trn[np.where(X<=split_val)[0]])\n",
    "    c_right = np.mean(y_trn[np.where(X>split_val)[0]])\n",
    "    \n",
    "    return dim,thresh,c_left,c_right\n",
    "\n",
    "def reg_stump_predict(x,dim,c_left,c_right):\n",
    "    \"\"\"\n",
    "    Verify if x is row of the dataframe\n",
    "    \"\"\"\n",
    "    if x[dim]<=thresh:\n",
    "        return c_left\n",
    "    else:\n",
    "        return c_right\n",
    "\n",
    "def get_errors_dtree_data(X_data,y_data,dim,c_left,c_right):\n",
    "    mse_list = []\n",
    "    mae_list = []\n",
    "    pred_list = []\n",
    "    for row,actual in zip(X_data,y_data):\n",
    "        predicted_val = reg_stump_predict(row,dim,c_left,c_right)\n",
    "        pred_list.append(predicted_val)\n",
    "        mse_list.append(get_squared_error(actual,predicted_val))\n",
    "        mae_list.append(get_absolute_error(actual,predicted_val))\n",
    "    \n",
    "    return mse_list,mae_list,pred_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Enter X_trn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 2\n",
      "0 1\n",
      "2 3\n",
      "4 2\n",
      "7 2\n",
      "10 0\n"
     ]
    }
   ],
   "source": [
    "n, m = map(int, input().split()) # taking number of rows and column\n",
    "X_trn = np.array([input().strip().split() for _ in range(n)], float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  1.],\n",
       "       [ 2.,  3.],\n",
       "       [ 4.,  2.],\n",
       "       [ 7.,  2.],\n",
       "       [10.,  0.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_trn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Enter y_trn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of rows: 5\n",
      "1\n",
      "2\n",
      "3\n",
      "8\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "# Number of input rows for test set\n",
    "nrows = int(input(\"Enter number of rows: \"))\n",
    "y_trn_in = [0]*nrows\n",
    "for i in range((nrows)):\n",
    "    y_trn_in[i] = float(input())\n",
    "y_trn = np.array(y_trn_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  8., 12.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_trn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get dimension, threshold, c_left and c_right of the best split "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dim:  0\n",
      "thresh:  5.5\n",
      "c_left:  2.0\n",
      "c_right:  10.0\n"
     ]
    }
   ],
   "source": [
    "dim,thresh, c_left, c_right = reg_stump_train(X_trn,y_trn)\n",
    "print(\"dim: \",dim)\n",
    "print(\"thresh: \",thresh)\n",
    "print(\"c_left: \",c_left)\n",
    "print(\"c_right: \",c_right)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_mse_li,train_mae_li,pred_list = get_errors_dtree_data(X_trn,y_trn,dim,c_left,c_right)\n",
    "print(np.mean(train_mse_li))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read X_Val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p, q = map(int, input().split()) # taking number of rows and column\n",
    "X_val = np.array([input().strip().split() for _ in range(p)], float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read Y_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of input rows for test set\n",
    "rowc = int(input(\"Enter number of rows: \"))\n",
    "y_val_in = [0]*rowc\n",
    "for i in range((rowc)):\n",
    "    y_val_in[i] = float(input())\n",
    "y_val = np.array(y_val_in)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculate Test MSE "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_mse_li,test_mae_li,pred_list   = get_errors_dtree_data(X_val,y_val,dim,c_left,c_right)\n",
    "print(np.mean(test_mse_li))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}