leaderone-Copy2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "#import seaborn\n",
    "import sklearn as skl\n",
    "from sklearn import linear_model\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics.scorer import make_scorer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import KFold\n",
    "#import future\n",
    "#from autograd import grad\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "demand_pred=pd.read_csv('demand_pred.csv')\n",
    "demand_act=pd.read_csv('demand.csv')\n",
    "price_pred=pd.read_csv('price_pred.csv')\n",
    "price_act=pd.read_csv('price.csv')\n",
    "solar_pred=pd.read_csv('solar_pred.csv')\n",
    "solar_act=pd.read_csv('solar.csv')\n",
    "lb_demand=pd.read_csv('Data_TestSet_PrivateEvaluation/Demand_Test_pred.csv', header=None)\n",
    "lb_price=pd.read_csv('Data_TestSet_PrivateEvaluation/Price_Test_pred.csv', header=None)\n",
    "lb_solar=pd.read_csv('Data_TestSet_PrivateEvaluation/Solar_Test_pred.csv', header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_pred_train=price_pred[:-50]  \n",
    "price_pred_test=price_pred[-50:]\n",
    "price_act_train= price_act[:-50]\n",
    "price_act_test=price_act[-50:]\n",
    "\n",
    "solar_pred_train=solar_pred[:-50]\n",
    "solar_pred_test=solar_pred[-50:]\n",
    "solar_act_train =solar_act[:-50]\n",
    "solar_act_test=solar_act[-50:]\n",
    "\n",
    "demand_pred_train=demand_pred[:-50]\n",
    "demand_pred_test=demand_pred[-50:]\n",
    "demand_act_train=demand_act[:-50]\n",
    "demand_act_test=demand_act[-50:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#lin reg by passing all 24 value in a day as feature and outputting 24 values\n",
    "est = linear_model.LinearRegression()\n",
    "\n",
    "est.fit(demand_pred,demand_act)\n",
    "demandL24=est.predict(lb_demand)\n",
    "\n",
    "est.fit(price_pred,price_act)\n",
    "priceL24=est.predict(lb_price)\n",
    "\n",
    "est.fit(solar_pred,solar_act)\n",
    "solarL24=est.predict(lb_solar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.frame.DataFrame"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lb_solar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn import neighbors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done4\n"
     ]
    }
   ],
   "source": [
    "#KNN using 24 features at once\n",
    "\n",
    "estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=7, n_jobs=-1)\n",
    "estKnn24.fit(demand_pred, demand_act)\n",
    "demandKnn24 = estKnn24.predict(lb_demand)\n",
    "\n",
    "estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=5, n_jobs=-1)\n",
    "estKnn24.fit(price_pred, price_act)\n",
    "priceKnn24 = estKnn24.predict(lb_price)\n",
    "\n",
    "estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=7, n_jobs=-1)\n",
    "estKnn24.fit(solar_pred, solar_act)\n",
    "solarKnn24 = estKnn24.predict(lb_solar)\n",
    "\n",
    "print(\"done4\")\n",
    "#score2(pd.DataFrame(demandKnn24), pd.DataFrame(priceKnn24), pd.DataFrame(solarKnn24), np.concatenate( (demand_act_test,price_act_test,solar_act_test), axis=1) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done3\n"
     ]
    }
   ],
   "source": [
    "#Elasticnet using 1 feature\n",
    "estEN = linear_model.ElasticNetCV(cv=18)\n",
    "\n",
    "#est.fit(np.array(demand_pred).reshape(-1,1), np.array(demand_act).ravel())\n",
    "#scores=cross_val_score(estEN, np.array(demand_pred).reshape(-1,1), np.array(demand_act).ravel() )\n",
    "#print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "estEN.fit( np.array(demand_pred).reshape(-1,1), np.array(demand_act).ravel() )\n",
    "demandEN = estEN.predict(np.array(lb_demand).reshape(-1,1))\n",
    "\n",
    "''' \n",
    "#scores=cross_val_score(estEN, np.array(price_pred).reshape(-1,1), np.array(price_act).ravel() )\n",
    "#print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "estEN.fit( np.array(price_pred).reshape(-1,1), np.array(price_act).ravel())\n",
    "priceEN = estEN.predict(np.array(lb_price).reshape(-1,1))\n",
    "\n",
    "#scores=cross_val_score(estEN, np.array(solar_pred).reshape(-1,1), np.array(solar_act).ravel() )\n",
    "#print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "estEN.fit( np.array(solar_pred).reshape(-1,1), np.array(solar_act).ravel()) \n",
    "solarEN = estEN.predict(np.array(lb_solar).reshape(-1,1))\n",
    "''' \n",
    "print(\"done3\")\n",
    "#print(str(pd.DataFrame(demandEN).shape)+\"s \")\n",
    "\n",
    "#score3(pd.DataFrame(demandEN.reshape(50,24)), pd.DataFrame(priceEN.reshape(50,24)), pd.DataFrame(solarEN.reshape(50,24)), (demand_act_test), (price_act_test), (solar_act_test) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "0.96734275],[ 1.63682223]\n",
    "0.96745217],[ 1.63512839\n",
    "        \n",
    "1.02092761],[ 1.64126239\n",
    " 0.99368733],[ 1.6376168"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ElasticNetCV(alphas=None, copy_X=True, cv=18, eps=0.001, fit_intercept=True,\n",
       "       l1_ratio=0.5, max_iter=1000, n_alphas=100, n_jobs=1,\n",
       "       normalize=False, positive=False, precompute='auto',\n",
       "       random_state=None, selection='cyclic', tol=0.0001, verbose=0)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estEN.set_params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'grad' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-57-eb7a2576f004>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     24\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mscore4\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_predicted\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m \u001b[0mgradient\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcustom_loss_given_weights\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'grad' is not defined"
     ]
    }
   ],
   "source": [
    "''' \n",
    "def lin_reg(w,X):#w:2x1 X:nx1 X_new: nx2\n",
    "    bias_feature=np.ones((X.shape[0], 1))\n",
    "    X_new = np.concatenate((X, bias_feature), axis=1)\n",
    "    return np.dot(w,X_new)\n",
    "\n",
    "def custom_loss_given_weights(w):\n",
    "    y_predicted = lin_reg(w, X)\n",
    "    return score4(y_predicted, y)\n",
    "    \n",
    "gradient = grad(custom_loss_given_weights)\n",
    "''' \n",
    "def lin_reg(w,X):#w:2x1 X:nx1 X_new: nx2\n",
    "    bias_feature=np.ones((X.shape[0], 1))\n",
    "    X_new = np.concatenate((X, bias_feature), axis=1)\n",
    "    #print(\"X_new shape:\"+str(X_new.shape))\n",
    "    #print(\"bias_feature\"+str(bias_feature.shape))\n",
    "    #print(\"w shape:\"+str(w.shape))\n",
    "    return np.dot(X_new, w)\n",
    "\n",
    "def custom_loss_given_weights(w):\n",
    "    y_predicted = lin_reg(w, X)\n",
    "    #print(\"within custom loss given wt X:\"+str(X))\n",
    "    return score4(y_predicted, y)\n",
    "  \n",
    "gradient = grad(custom_loss_given_weights)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def score4(yhat, y):#yhat is array of demand, y is dataframe of demand act, price act, solar act #(bid, quantity,  demand_act, price_act, solar_act):\n",
    "    \n",
    "    bid = np.array(priceKnn24).reshape(-1,1)\n",
    "    quantity = yhat-np.array(solarKnn24).reshape(-1,1)\n",
    "    \n",
    "    demand_act = np.array(y.iloc[:,:24]).reshape(-1,1)\n",
    "    price_act = np.array(y.iloc[:,24:48]).reshape(-1,1)\n",
    "    solar_act = np.array(y.iloc[:,48:72]).reshape(-1,1)\n",
    "    \n",
    "    #print(\"yhat:\"+str(yhat))\n",
    "    #print(\"y:\"+str(y))\n",
    "    #demand_act = demand_act_cv_test\n",
    "    #price_act = price_act_cv_test\n",
    "    #solar_act = solar_act_cv_test\n",
    "    \n",
    "    battery=0\n",
    "    excess=0\n",
    "    paisa=0\n",
    "    for i in range(0, bid.shape[0]):\n",
    "        \n",
    "        #p-quantity we ordered\n",
    "        #q-how much less we are ordering from actual\n",
    "        #r-how much is actually required\n",
    "        p = quantity[i]\n",
    "        r = demand_act[i]-solar_act[i]\n",
    "        q = r-p\n",
    "        #print(\"q:\"+str(q))\n",
    "        if bid[i]>=price_act[i]: #bid won\n",
    "            paisa=paisa+p*bid[i]\n",
    "            if q>0:\n",
    "                paisa=paisa+(q-min(q,4,battery))*7\n",
    "                battery=battery-min(q,4,battery)\n",
    "            else:\n",
    "                battery=battery+min(-q,5)\n",
    "                battery=min(battery,25)\n",
    "        else:#bid lost\n",
    "            if r>=0:\n",
    "                paisa=paisa+(r-min(r,4,battery))*7\n",
    "                battery=battery-min(r,4,battery)\n",
    "            else:\n",
    "                battery=battery+min(-r,5)\n",
    "                battery=min(battery, 25)\n",
    "                \n",
    "    #print(\"battery left: \"+str(battery) )\n",
    "    #print(\"paisa:\"+str(paisa))\n",
    "    return paisa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def score5(yhat, y):#yhat is array of demand, y is dataframe of demand act, price act, solar act #(bid, quantity,  demand_act, price_act, solar_act):\n",
    "    \n",
    "    bid = np.array(priceKnn24).reshape(-1,1)\n",
    "    quantity = yhat-np.array(solarKnn24).reshape(-1,1)\n",
    "    \n",
    "    demand_act = np.array(y.iloc[:,:24]).reshape(-1,1)\n",
    "    price_act = np.array(y.iloc[:,24:48]).reshape(-1,1)\n",
    "    solar_act = np.array(y.iloc[:,48:72]).reshape(-1,1)\n",
    "    \n",
    "    #print(\"yhat:\"+str(yhat))\n",
    "    #print(\"y:\"+str(y))\n",
    "    #demand_act = demand_act_cv_test\n",
    "    #price_act = price_act_cv_test\n",
    "    #solar_act = solar_act_cv_test\n",
    "    bill_act = np.multiply(demand_act-solar_act, price_act)\n",
    "    bill_ped = np.multiply(quantity, bid)\n",
    "    \n",
    "    cost=np.sum(np.sum(np.square(bill_act-bill_ped), axis=1), axis=0)\n",
    "    return cost\n",
    "    ''' \n",
    "    battery=0\n",
    "    excess=0\n",
    "    paisa=0\n",
    "    for i in range(0, bid.shape[0]):\n",
    "        \n",
    "        #p-quantity we ordered\n",
    "        #q-how much less we are ordering from actual\n",
    "        #r-how much is actually required\n",
    "        p = quantity[i]\n",
    "        r = demand_act[i]-solar_act[i]\n",
    "        q = r-p\n",
    "        #print(\"q:\"+str(q))\n",
    "        if bid[i]>=price_act[i]: #bid won\n",
    "            paisa=paisa+p*bid[i]\n",
    "            if q>0:\n",
    "                paisa=paisa+(q-min(q,4,battery))*7\n",
    "                battery=battery-min(q,4,battery)\n",
    "            else:\n",
    "                battery=battery+min(-q,5)\n",
    "                battery=min(battery,25)\n",
    "        else:#bid lost\n",
    "            if r>=0:\n",
    "                paisa=paisa+(r-min(r,4,battery))*7\n",
    "                battery=battery-min(r,4,battery)\n",
    "            else:\n",
    "                battery=battery+min(-r,5)\n",
    "                battery=min(battery, 25)\n",
    "                \n",
    "    #print(\"battery left: \"+str(battery) )\n",
    "    #print(\"paisa:\"+str(paisa))\n",
    "    return paisa\n",
    "    ''' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_scorer=make_scorer(score4, greater_is_better=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2400,)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "demandEN.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(850, 24)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "demand_pred_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p_neighbours:4 s_neighbours:9\n",
      "scores: [ 309124.17694396]\n"
     ]
    }
   ],
   "source": [
    "splits=17\n",
    "cv = KFold(n_splits=splits, shuffle=True, random_state=1)\n",
    "scores=0\n",
    "score=0\n",
    "scores_array = []\n",
    "for p_neighbours in [4]:#[3,4,5,6,7,8,9]:\n",
    "    \n",
    "    for s_neighbours in [9]:\n",
    "        \n",
    "        scores=0\n",
    "        for traincv, testcv in cv.split(demand_pred_train,demand_act_train):\n",
    "\n",
    "            price_pred_cv_train = price_pred_train.iloc[traincv]\n",
    "            price_pred_cv_test  = price_pred_train.iloc[testcv]\n",
    "            price_act_cv_train  = price_act_train.iloc[traincv]\n",
    "            price_act_cv_test   = price_act_train.iloc[testcv]\n",
    "\n",
    "            demand_pred_cv_train = demand_pred_train.iloc[traincv]\n",
    "            demand_pred_cv_test  = demand_pred_train.iloc[testcv]\n",
    "            demand_act_cv_train  = demand_act_train.iloc[traincv]\n",
    "            demand_act_cv_test   = demand_act_train.iloc[testcv]\n",
    "\n",
    "            solar_pred_cv_train = solar_pred_train.iloc[traincv]\n",
    "            solar_pred_cv_test  = solar_pred_train.iloc[testcv]\n",
    "            solar_act_cv_train  = solar_act_train.iloc[traincv]\n",
    "            solar_act_cv_test   = solar_act_train.iloc[testcv]\n",
    "\n",
    "            #y = pd.concat((demand_act_cv_test, price_act_cv_test, solar_act_cv_test), axis=1, ignore_index=True)\n",
    "\n",
    "            #Knn in the house\n",
    "            #print(\"train shape:\"+str(demand_pred_cv_train.shape))\n",
    "            #print(\"test shape:\"+str(demand_pred_cv_test.shape))\n",
    "\n",
    "            estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=p_neighbours, n_jobs=-1)\n",
    "            estKnn24.fit(price_pred_cv_train, price_act_cv_train)\n",
    "            priceKnn24 = estKnn24.predict(price_pred_cv_test)+price_std2+0.34 #for cv 0.5 was faound earlier\n",
    "\n",
    "            estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=s_neighbours, n_jobs=-1)\n",
    "            estKnn24.fit(solar_pred_cv_train, solar_act_cv_train)\n",
    "            solarKnn24 = estKnn24.predict(solar_pred_cv_test)+1\n",
    "\n",
    "            estEN.fit( np.array(demand_pred_cv_train).reshape(-1,1), np.array(demand_act_cv_train).ravel() )\n",
    "            demandEN = (estEN.predict(np.array(demand_pred_cv_test).reshape(-1,1))).reshape(-1,1)\n",
    "\n",
    "            y = pd.concat((demand_pred_cv_test, price_pred_cv_test, solar_pred_cv_test), axis=1, ignore_index=True)\n",
    "            \n",
    "            score=score4(demandEN, y)\n",
    "            #print(str(score))\n",
    "            scores+=score\n",
    "\n",
    "\n",
    "        print(\"p_neighbours:\"+str(p_neighbours)+\" s_neighbours:\"+str(s_neighbours))\n",
    "        print(\"scores: \"+str(scores/splits))\n",
    "        scores_array.append(scores/splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_std2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "scores_array.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "scores_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from autograd import grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def lin_reg(w,X):#w:2x1 X:nx1 X_new: nx2\n",
    "    bias_feature=np.ones((X.shape[0], 1))\n",
    "    X_new = np.concatenate((X, bias_feature), axis=1)\n",
    "    print(\"X_new shape:\"+str(X_new.shape))\n",
    "    print(\"bias_feature\"+str(bias_feature.shape))\n",
    "    print(\"w shape:\"+str(w.shape))\n",
    "    return np.dot(X_new, w)\n",
    "\n",
    "def custom_loss_given_weights(w):\n",
    "    y_predicted = lin_reg(w, X)\n",
    "    return score4(y_predicted, y)\n",
    "    \n",
    "gradient = grad(custom_loss_given_weights)\n",
    "\n",
    "X = np.array(demand_pred_test).reshape(-1,1)\n",
    "y = pd.concat((demand_pred_test, price_pred_test, solar_pred_test), axis=1, ignore_index=True)\n",
    "    \n",
    "print(\"X shape:\"+str(X.shape))\n",
    "print(\"y shape:\"+str(y.shape))\n",
    "\n",
    "weights = np.zeros((X.shape[1]+1,1))\n",
    "\n",
    "for i in range(10000):\n",
    "    if i % 1000 == 0:\n",
    "        print('Iteration %-4d | Loss: %.4f' % (i, custom_loss_given_weights(weights)))\n",
    "    weights -= gradient(weights) * .01\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.],\n",
       "       [ 1.]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((10, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=np.array([[1,1],[2,4]])\n",
    "b=np.array([3,3]).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3],\n",
       "       [3]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [2, 4]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2,)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(np.sum(np.multiply(b,a), axis=1)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6],\n",
       "       [18]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_std2=(price_act-price_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_std2[price_std2<0]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "      <th>9</th>\n",
       "      <th>...</th>\n",
       "      <th>14</th>\n",
       "      <th>15</th>\n",
       "      <th>16</th>\n",
       "      <th>17</th>\n",
       "      <th>18</th>\n",
       "      <th>19</th>\n",
       "      <th>20</th>\n",
       "      <th>21</th>\n",
       "      <th>22</th>\n",
       "      <th>23</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.00000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "      <td>900.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.065211</td>\n",
       "      <td>0.059878</td>\n",
       "      <td>0.055989</td>\n",
       "      <td>0.060356</td>\n",
       "      <td>0.063667</td>\n",
       "      <td>0.077611</td>\n",
       "      <td>0.14220</td>\n",
       "      <td>0.149889</td>\n",
       "      <td>0.182711</td>\n",
       "      <td>0.174800</td>\n",
       "      <td>...</td>\n",
       "      <td>0.124622</td>\n",
       "      <td>0.106622</td>\n",
       "      <td>0.114544</td>\n",
       "      <td>0.123556</td>\n",
       "      <td>0.130967</td>\n",
       "      <td>0.107856</td>\n",
       "      <td>0.108722</td>\n",
       "      <td>0.100700</td>\n",
       "      <td>0.090811</td>\n",
       "      <td>0.057333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.087030</td>\n",
       "      <td>0.083870</td>\n",
       "      <td>0.079243</td>\n",
       "      <td>0.080793</td>\n",
       "      <td>0.083514</td>\n",
       "      <td>0.111632</td>\n",
       "      <td>0.18886</td>\n",
       "      <td>0.218895</td>\n",
       "      <td>0.242818</td>\n",
       "      <td>0.236641</td>\n",
       "      <td>...</td>\n",
       "      <td>0.169541</td>\n",
       "      <td>0.151813</td>\n",
       "      <td>0.153537</td>\n",
       "      <td>0.159969</td>\n",
       "      <td>0.174595</td>\n",
       "      <td>0.151415</td>\n",
       "      <td>0.145109</td>\n",
       "      <td>0.137718</td>\n",
       "      <td>0.116470</td>\n",
       "      <td>0.079199</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.00000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.00000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.010000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.01000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.015000</td>\n",
       "      <td>0.010000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.010000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.030000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.120000</td>\n",
       "      <td>0.110000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.120000</td>\n",
       "      <td>0.120000</td>\n",
       "      <td>0.150000</td>\n",
       "      <td>0.26000</td>\n",
       "      <td>0.260000</td>\n",
       "      <td>0.340000</td>\n",
       "      <td>0.320000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.210000</td>\n",
       "      <td>0.230000</td>\n",
       "      <td>0.260000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.210000</td>\n",
       "      <td>0.190000</td>\n",
       "      <td>0.180000</td>\n",
       "      <td>0.110000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>0.330000</td>\n",
       "      <td>0.330000</td>\n",
       "      <td>0.340000</td>\n",
       "      <td>0.340000</td>\n",
       "      <td>0.360000</td>\n",
       "      <td>0.450000</td>\n",
       "      <td>0.72000</td>\n",
       "      <td>0.990000</td>\n",
       "      <td>1.050000</td>\n",
       "      <td>0.990000</td>\n",
       "      <td>...</td>\n",
       "      <td>0.730000</td>\n",
       "      <td>0.600000</td>\n",
       "      <td>0.600000</td>\n",
       "      <td>0.660000</td>\n",
       "      <td>0.780000</td>\n",
       "      <td>0.580000</td>\n",
       "      <td>0.540000</td>\n",
       "      <td>0.560000</td>\n",
       "      <td>0.430000</td>\n",
       "      <td>0.300000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>8 rows × 24 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                0           1           2           3           4           5  \\\n",
       "count  900.000000  900.000000  900.000000  900.000000  900.000000  900.000000   \n",
       "mean     0.065211    0.059878    0.055989    0.060356    0.063667    0.077611   \n",
       "std      0.087030    0.083870    0.079243    0.080793    0.083514    0.111632   \n",
       "min      0.000000    0.000000    0.000000    0.000000    0.000000    0.000000   \n",
       "25%      0.000000    0.000000    0.000000    0.000000    0.000000    0.000000   \n",
       "50%      0.000000    0.000000    0.000000    0.000000    0.010000    0.000000   \n",
       "75%      0.120000    0.110000    0.100000    0.120000    0.120000    0.150000   \n",
       "max      0.330000    0.330000    0.340000    0.340000    0.360000    0.450000   \n",
       "\n",
       "               6           7           8           9     ...              14  \\\n",
       "count  900.00000  900.000000  900.000000  900.000000     ...      900.000000   \n",
       "mean     0.14220    0.149889    0.182711    0.174800     ...        0.124622   \n",
       "std      0.18886    0.218895    0.242818    0.236641     ...        0.169541   \n",
       "min      0.00000    0.000000    0.000000    0.000000     ...        0.000000   \n",
       "25%      0.00000    0.000000    0.000000    0.000000     ...        0.000000   \n",
       "50%      0.01000    0.000000    0.015000    0.010000     ...        0.010000   \n",
       "75%      0.26000    0.260000    0.340000    0.320000     ...        0.220000   \n",
       "max      0.72000    0.990000    1.050000    0.990000     ...        0.730000   \n",
       "\n",
       "               15          16          17          18          19          20  \\\n",
       "count  900.000000  900.000000  900.000000  900.000000  900.000000  900.000000   \n",
       "mean     0.106622    0.114544    0.123556    0.130967    0.107856    0.108722   \n",
       "std      0.151813    0.153537    0.159969    0.174595    0.151415    0.145109   \n",
       "min      0.000000    0.000000    0.000000    0.000000    0.000000    0.000000   \n",
       "25%      0.000000    0.000000    0.000000    0.000000    0.000000    0.000000   \n",
       "50%      0.000000    0.000000    0.030000    0.000000    0.000000    0.000000   \n",
       "75%      0.200000    0.210000    0.230000    0.260000    0.220000    0.210000   \n",
       "max      0.600000    0.600000    0.660000    0.780000    0.580000    0.540000   \n",
       "\n",
       "               21          22          23  \n",
       "count  900.000000  900.000000  900.000000  \n",
       "mean     0.100700    0.090811    0.057333  \n",
       "std      0.137718    0.116470    0.079199  \n",
       "min      0.000000    0.000000    0.000000  \n",
       "25%      0.000000    0.000000    0.000000  \n",
       "50%      0.000000    0.000000    0.000000  \n",
       "75%      0.190000    0.180000    0.110000  \n",
       "max      0.560000    0.430000    0.300000  \n",
       "\n",
       "[8 rows x 24 columns]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price_std2.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_std2=price_std2.describe().iloc[2,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_std2=np.array(price_std2).reshape(1,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 24)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price_std2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.08703023,  0.08386974,  0.07924294,  0.08079338,  0.08351364,\n",
       "         0.11163246,  0.18886007,  0.21889496,  0.24281805,  0.23664099,\n",
       "         0.20785652,  0.16684295,  0.16782499,  0.15498694,  0.16954093,\n",
       "         0.15181267,  0.15353714,  0.15996879,  0.17459522,  0.15141513,\n",
       "         0.14510949,  0.13771801,  0.11646971,  0.07919927]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price_std2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "priceslb_bk = np.copy(priceslb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "price_std=(price_act-price_pred).describe().iloc[2,:]\n",
    "quantity_std=(demand_act-solar_act-(demand_pred-solar_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(900, 24)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price_pred.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done4\n"
     ]
    }
   ],
   "source": [
    "#KNN using 24 features at once\n",
    "\n",
    "estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=7, n_jobs=-1)\n",
    "estKnn24.fit(demand_pred, demand_act)\n",
    "demandKnn24 = estKnn24.predict(lb_demand)\n",
    "\n",
    "estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=4, n_jobs=-1)\n",
    "estKnn24.fit(price_pred, price_act)\n",
    "priceKnn24 = estKnn24.predict(lb_price)\n",
    "\n",
    "estKnn24 = neighbors.KNeighborsRegressor(n_neighbors=9, n_jobs=-1)\n",
    "estKnn24.fit(solar_pred, solar_act)\n",
    "solarKnn24 = estKnn24.predict(lb_solar)\n",
    "\n",
    "print(\"done4\")\n",
    "#score2(pd.DataFrame(demandKnn24), pd.DataFrame(priceKnn24), pd.DataFrame(solarKnn24), np.concatenate( (demand_act_test,price_act_test,solar_act_test), axis=1) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(estEN.coef_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.97760076])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estEN.coef_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7105931282868312"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estEN.intercept_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done3\n"
     ]
    }
   ],
   "source": [
    "#Elasticnet using 1 feature\n",
    "estEN = linear_model.ElasticNetCV(cv=18)\n",
    "\n",
    "#est.fit(np.array(demand_pred).reshape(-1,1), np.array(demand_act).ravel())\n",
    "#scores=cross_val_score(estEN, np.array(demand_pred).reshape(-1,1), np.array(demand_act).ravel() )\n",
    "#print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "estEN.fit( np.array(demand_pred).reshape(-1,1), np.array(demand_act).ravel() )\n",
    "#estEN.coef_= np.array([1])\n",
    "#estEN.intercept_= 1.6376168\n",
    "demandEN = estEN.predict(np.array(lb_demand).reshape(-1,1))\n",
    "\n",
    "''' \n",
    "#scores=cross_val_score(estEN, np.array(price_pred).reshape(-1,1), np.array(price_act).ravel() )\n",
    "#print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "estEN.fit( np.array(price_pred).reshape(-1,1), np.array(price_act).ravel())\n",
    "priceEN = estEN.predict(np.array(lb_price).reshape(-1,1))\n",
    "\n",
    "#scores=cross_val_score(estEN, np.array(solar_pred).reshape(-1,1), np.array(solar_act).ravel() )\n",
    "#print(\"Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
    "estEN.fit( np.array(solar_pred).reshape(-1,1), np.array(solar_act).ravel()) \n",
    "solarEN = estEN.predict(np.array(lb_solar).reshape(-1,1))\n",
    "''' \n",
    "print(\"done3\")\n",
    "#print(str(pd.DataFrame(demandEN).shape)+\"s \")\n",
    "\n",
    "#score3(pd.DataFrame(demandEN.reshape(50,24)), pd.DataFrame(priceEN.reshape(50,24)), pd.DataFrame(solarEN.reshape(50,24)), (demand_act_test), (price_act_test), (solar_act_test) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "0.96734275],[ 1.63682223]\n",
    "0.96745217],[ 1.63512839\n",
    "        \n",
    "1.02092761],[ 1.64126239\n",
    " 0.99368733],[ 1.6376168"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "battery1200 = pd.read_csv('battery2400.csv', header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2400, 1)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battery1200.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "demandslb = np.array([demandEN.reshape(100,24)])\n",
    "priceslb = np.array([priceKnn24])\n",
    "solarslb = np.array([solarKnn24])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# i-demand\n",
    "#j-price\n",
    "#k-solar\n",
    "i=0\n",
    "j=0\n",
    "k=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=0.15 #on cv 0.5 worked\n",
    "b=-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "priceslbx=[]\n",
    "priceslbx=np.copy(priceslb[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100,)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priceslbx[:,0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "216.14545666154754"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.nan_to_num(np.multiply(demandslb[i][priceslbx>7], (priceslbx[priceslbx>7]-7) ) ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.21  ,  1.195 ,  1.105 , ...,  3.065 ,  2.335 ,  1.405 ],\n",
       "       [ 1.7825,  1.7025,  1.655 , ...,  2.73  ,  2.0275,  1.6875],\n",
       "       [ 1.3425,  1.3575,  1.3575, ...,  3.22  ,  2.1525,  1.345 ],\n",
       "       ..., \n",
       "       [ 1.3125,  1.3225,  1.3125, ...,  2.33  ,  2.0625,  1.82  ],\n",
       "       [ 1.8125,  1.705 ,  1.6425, ...,  2.615 ,  2.33  ,  1.815 ],\n",
       "       [ 1.9175,  1.785 ,  1.6725, ...,  2.5   ,  2.535 ,  2.11  ]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priceslbx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "priceslbx=priceslbx+price_std2+0.34 #based on cv\n",
    "priceslbx[priceslbx>=7]=6.85\n",
    "\n",
    "#priceslbx[priceslbx>=7]=6.3\n",
    "#priceslbx=priceslbx+a\n",
    "#priceslbx[priceslbx>=7]=6.85"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.63703023,  1.61886974,  1.52424294, ...,  3.54271801,\n",
       "         2.79146971,  1.82419927],\n",
       "       [ 2.20953023,  2.12636974,  2.07424294, ...,  3.20771801,\n",
       "         2.48396971,  2.10669927],\n",
       "       [ 1.76953023,  1.78136974,  1.77674294, ...,  3.69771801,\n",
       "         2.60896971,  1.76419927],\n",
       "       ..., \n",
       "       [ 1.73953023,  1.74636974,  1.73174294, ...,  2.80771801,\n",
       "         2.51896971,  2.23919927],\n",
       "       [ 2.23953023,  2.12886974,  2.06174294, ...,  3.09271801,\n",
       "         2.78646971,  2.23419927],\n",
       "       [ 2.34453023,  2.20886974,  2.09174294, ...,  2.97771801,\n",
       "         2.99146971,  2.52919927]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "priceslbx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submission = np.concatenate( ( (priceslbx).reshape(-1,1), demandslb[i].reshape(-1,1)-solarslb[k].reshape(-1,1)+b)  , axis=1 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2400, 2)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submission.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submissiondf = pd.DataFrame(submission)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submissiondf.to_csv('24.csv', index=False, index_label=False, header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fuck=np.array(lb_price).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3.04],\n",
       "       [ 2.56],\n",
       "       [ 2.74],\n",
       "       [ 2.34],\n",
       "       [ 1.87]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fuck[-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.08703023,  0.08386974,  0.07924294,  0.08079338,  0.08351364,\n",
       "         0.11163246,  0.18886007,  0.21889496,  0.24281805,  0.23664099,\n",
       "         0.20785652,  0.16684295,  0.16782499,  0.15498694,  0.16954093,\n",
       "         0.15181267,  0.15353714,  0.15996879,  0.17459522,  0.15141513,\n",
       "         0.14510949,  0.13771801,  0.11646971,  0.07919927]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price_std2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submissiondf = pd.read_csv('24.csv', header=None)\n",
    "submissiondf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "charged=0\n",
    "discharged=0\n",
    "#a-charge by, b-discharge by  1.5 1\n",
    "a=1.5\n",
    "b=1\n",
    "submissiondf = pd.read_csv('24.csv', header=None)\n",
    "\n",
    "for c in range(len(battery1200)):\n",
    "    if battery1200.iloc[c,0]==1:\n",
    "        print(\"chege\"+str(submissiondf.iloc[c,0]))\n",
    "        submissiondf.iloc[c,1] = submissiondf.iloc[c,1] + a\n",
    "        charged=charged+1\n",
    "        continue\n",
    "    if battery1200.iloc[c,0]==2 :\n",
    "        print(\"discharge:\"+str(submissiondf.iloc[c,0]))\n",
    "        submissiondf.iloc[c,1] = submissiondf.iloc[c,1] - b\n",
    "        discharged=discharged+1\n",
    "        continue\n",
    "submissiondf.to_csv('private_15.csv', index=False, index_label=False, header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 668,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "467"
      ]
     },
     "execution_count": 668,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "charged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submissiondf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 669,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "266"
      ]
     },
     "execution_count": 669,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1200-467*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 671,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1200, 2)"
      ]
     },
     "execution_count": 671,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submissiondf.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 672,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submissiondf.to_csv('23.csv', index=False, index_label=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1200,)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submissiondf.iloc[:,0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}