TrainTest_Scripts.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DCAMgu6Ha8u-"
   },
   "outputs": [],
   "source": [
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.models import load_model\n",
    "from keras.layers import Dense\n",
    "from keras.optimizers import Adam\n",
    "import math\n",
    "import numpy as np\n",
    "import random as random\n",
    "from collections import deque\n",
    "import pandas as pd\n",
    "from pandas import DataFrame\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-FEF1WHca8vA"
   },
   "outputs": [],
   "source": [
    "df=pd.read_csv(\"...csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0CwgX9HFa8vB"
   },
   "outputs": [],
   "source": [
    "df=df[\"Open\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RR_s3EYPa8vB"
   },
   "outputs": [],
   "source": [
    "initial_data=df.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Bwe7Qp-La8vC"
   },
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    def __init__(self, state_size, is_eval=False, model_name=\"\"):\n",
    "        self.state_size = state_size # normalized previous days\n",
    "        self.action_size = 5\n",
    "        self.memory = deque(maxlen=int(len(initial_data)))\n",
    "        self.inventory = []\n",
    "        self.model_name = model_name\n",
    "        self.is_eval = is_eval\n",
    "        self.gamma = 0.95\n",
    "\n",
    "        self.epsilon = 1.0\n",
    "        self.epsilon_min = 0.01\n",
    "        self.epsilon_decay = 0.99\n",
    "        self.model = load_model(\"\") if is_eval else self._model()\n",
    "    def _model(self):\n",
    "        model = Sequential()\n",
    "        model.add(Dense(units=64, input_dim=self.state_size, activation=\"relu\"))\n",
    "        model.add(Dense(units=32, activation=\"linear\", input_shape=(64,1)))\n",
    "        model.add(Dense(units=5, activation=\"linear\", input_shape=(64,1)))\n",
    "\n",
    "        model.compile(loss=\"mse\", optimizer=Adam(learning_rate=0.001))\n",
    "        return model\n",
    "    def act(self, state):\n",
    "        if not self.is_eval and random.random()<= self.epsilon:\n",
    "            return random.randrange(self.action_size)\n",
    "\n",
    "        options = self.model.predict(next_state)\n",
    "        print(options[0],np.argmax(options[0]),\"options\")\n",
    "        return np.argmax(options[0])\n",
    "\n",
    "    def expReplay(self, batch_size):\n",
    "        mini_batch = []\n",
    "        l = len(self.memory)\n",
    "        for i in range(l - batch_size + 1, l):\n",
    "            mini_batch.append(self.memory[i])\n",
    "        for state, action, reward, next_state, done in mini_batch:\n",
    "            target = reward\n",
    "            if not done:\n",
    "                target = reward + self.gamma * np.amax(self.model.predict(next_state)[0])\n",
    "            target_f = self.model.predict(state)\n",
    "            target_f[0][action] = target\n",
    "            print(self.model.predict(next_state)[0],\"prednext\",target,\"target\",target_f[0],\"targetf\")\n",
    "            self.model.fit(state, target_f, epochs=1, verbose=0)\n",
    "        if self.epsilon > self.epsilon_min:\n",
    "            self.epsilon *= self.epsilon_decay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "orQAz5VDa8vC"
   },
   "outputs": [],
   "source": [
    "def getStockDataVec():\n",
    "\n",
    "    vec=np.asarray(initial_data)\n",
    "    if is_eval is False:\n",
    "        vec=vec[0:int(len(vec)*0.8)]\n",
    "    else:\n",
    "        vec=vec[int(len(vec)*0.8):len(vec)+1]\n",
    "    global start\n",
    "    start=random.randint(1,10)\n",
    "    vec=vec[start:len(vec)]\n",
    "    return vec\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Pm5qrggfa8vC"
   },
   "outputs": [],
   "source": [
    "def getState(data, t, n):\n",
    "    d = t - n + 1\n",
    "    res = []\n",
    "    if d >= 0:\n",
    "        block = data[d:t + 1]\n",
    "    else:\n",
    "        block= np.append(-d * [data[0]] , data[0:t + 1]) # pad with t0\n",
    "    for i in range( n - 1):\n",
    "        res.append(block[i +1 ]- block[i])\n",
    "\n",
    "    return np.array([res])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "F-_8SH9fa8vC",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "stock_name = \"\"\n",
    "is_eval=False\n",
    "window_size =64\n",
    "episode_count = 2\n",
    "balance=100000\n",
    "trade_fee=.002\n",
    "amount_stocks=0 #for that individual hour\n",
    "current_stocks=0  #cumulative\n",
    "asset=balance\n",
    "index=[0,1,2,3,4,5,6,]\n",
    "agent = Agent(window_size)\n",
    "data = getStockDataVec()\n",
    "l = len(data) - 1\n",
    "batch_size = 32\n",
    "\n",
    "for e in range(1,episode_count + 1):\n",
    "    print(\"Episode \" + str(e) + \"/\" + str(episode_count))\n",
    "    data = getStockDataVec()\n",
    "    state = getState(data, 0, window_size + 1)\n",
    "    total_profit = 0\n",
    "    balance=100000\n",
    "    agent.inventory = []\n",
    "    asset=balance\n",
    "    reward=0\n",
    "    bal_list=[balance]\n",
    "    current_stocks_list=[0]\n",
    "    reward_list=[reward]\n",
    "    current_asset_list=[balance]\n",
    "    stocks=[0]\n",
    "    amount_stocks=0 #for that individual hour\n",
    "    current_stocks=0  #cumulative\n",
    "    profit=0\n",
    "    reward=0\n",
    "    actions=[]\n",
    "\n",
    "\n",
    "    for t in range(1,l):\n",
    "        action = agent.act(state)\n",
    "        next_state = getState(data, t+1 , window_size + 1)\n",
    "        reward=0\n",
    "\n",
    "\n",
    "        if action == 0 and balance>1: # strong buy\n",
    "            amount_stocks=(balance*0.6)/data[t]\n",
    "            balance=balance-(amount_stocks*data[t])-(amount_stocks*data[t]*trade_fee)\n",
    "            current_stocks+=amount_stocks\n",
    "            asset=balance+data[t]*current_stocks\n",
    "            current_asset_list.append(asset)\n",
    "            agent.inventory.append(data[t])\n",
    "            stocks.append(amount_stocks)\n",
    "\n",
    "            print(t,\")\",\"Strong Buy at stock price\", data[t] , \", current balance\" , balance , \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "            reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "\n",
    "            act=\"strong buy\"\n",
    "\n",
    "\n",
    "        elif action==1 and balance>1: #buy\n",
    "            amount_stocks=(balance*0.3)/data[t]\n",
    "            balance=balance-(amount_stocks*data[t])-(amount_stocks*data[t]*trade_fee)\n",
    "            current_stocks+=amount_stocks\n",
    "            stocks.append(amount_stocks)\n",
    "            asset=balance+data[t]*current_stocks\n",
    "            current_asset_list.append(asset)\n",
    "            agent.inventory.append(data[t])\n",
    "            print(t,\")\",\"Buy at stock price\", data[t] , \", current balance\" , balance , \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "            reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "\n",
    "            act=\"buy\"\n",
    "\n",
    "        elif action==2: #hold\n",
    "            balance=balance\n",
    "            asset=balance+data[t]*current_stocks\n",
    "            current_asset_list.append(asset)\n",
    "            amount_stocks=0\n",
    "            stocks.append(amount_stocks)\n",
    "\n",
    "            print(t,\")\",\"Hold at stock price\", data[t],\",current balance\", balance ,\"TL\", \"current asset:\", balance+data[t]*current_stocks )\n",
    "\n",
    "            reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "\n",
    "            act=\"hold\"\n",
    "\n",
    "        elif action == 3 and current_stocks > 1: # sell \n",
    "            sold_stocks=(current_stocks*0.5)\n",
    "            current_stocks-=sold_stocks\n",
    "            balance+=sold_stocks*data[t]\n",
    "            asset=balance+data[t]*current_stocks\n",
    "            current_asset_list.append(asset)\n",
    "            reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "            stocks.append(-1*sold_stocks)\n",
    "            print(t,\")\",\"Sell at stock price\", data[t] , \", current balance\" , balance, \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "            act=\"sell\"\n",
    "\n",
    "        elif action == 4 and current_stocks > 0: #strong sell\n",
    "            sold_stocks=(current_stocks)\n",
    "            current_stocks-=sold_stocks\n",
    "            balance+=sold_stocks*data[t]\n",
    "            asset=balance+data[t]*current_stocks\n",
    "            current_asset_list.append(asset)\n",
    "            reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "            stocks.append(-1*sold_stocks)\n",
    "            print(t,\")\",\"Strong Sell at stock price\", data[t] , \", current balance\" , balance , \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "            act=\"strong sell\"\n",
    "\n",
    "\n",
    "        else:\n",
    "            action=2\n",
    "            balance=balance\n",
    "            asset=balance+data[t]*current_stocks\n",
    "            current_asset_list.append(asset)\n",
    "            amount_stocks=0\n",
    "            stocks.append(amount_stocks)\n",
    "\n",
    "            print(t,\")\",\"Hold at stock price\", data[t],\",current balance\", balance ,\"TL\", \"current asset:\", balance+data[t]*current_stocks )\n",
    "\n",
    "            reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "            act=\"else hold\"\n",
    "\n",
    "        done = True if t == l else False\n",
    "        agent.memory.append((state, action, reward, next_state, done))\n",
    "        state = next_state\n",
    "        print(action)\n",
    "\n",
    "        current_stocks_list.append(current_stocks)\n",
    "        reward_list.append(reward)\n",
    "        bal_list.append(balance)\n",
    "        actions.append(act)\n",
    "\n",
    "        if done:\n",
    "            print(\"epoch completed\")\n",
    "        if len(agent.memory) > batch_size:\n",
    "            agent.expReplay(batch_size)\n",
    "\n",
    "    e+=1\n",
    "    if e % episode_count  == 0:\n",
    "        agent.model.save('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ePg9ERD4a8vD"
   },
   "outputs": [],
   "source": [
    "is_eval= True\n",
    "model = load_model()\n",
    "\n",
    "window_size = model.layers[0].input.shape.as_list()[1]\n",
    "agent = Agent(window_size, True, model)\n",
    "\n",
    "\n",
    "data = getStockDataVec()\n",
    "state = getState(data, 0, window_size + 1)\n",
    "total_profit = 0\n",
    "balance=100000\n",
    "agent.inventory = []\n",
    "asset=balance\n",
    "reward=0\n",
    "bal_list=[balance]\n",
    "current_stocks_list=[0]\n",
    "reward_list=[reward]\n",
    "current_asset_list=[balance]\n",
    "stocks=[0]\n",
    "amount_stocks=0 #for that individual hour\n",
    "current_stocks=0  #cumulative\n",
    "profit=0\n",
    "reward=0\n",
    "actions=[]\n",
    "\n",
    "\n",
    "for t in range(1,len(data)-1):\n",
    "    next_state = getState(data, t+1 , window_size + 1)\n",
    "    action = agent.act(state)\n",
    "\n",
    "    reward=0\n",
    "\n",
    "\n",
    "    if action == 0 and balance>1: # strong buy\n",
    "        amount_stocks=(balance*0.4)/data[t]\n",
    "        balance=balance-(amount_stocks*data[t])-(amount_stocks*data[t]*trade_fee)\n",
    "        current_stocks+=amount_stocks\n",
    "        asset=balance+data[t]*current_stocks\n",
    "        current_asset_list.append(asset)\n",
    "        agent.inventory.append(data[t])\n",
    "        stocks.append(amount_stocks)\n",
    "\n",
    "        print(t,\")\",\"Strong Buy at stock price\", data[t] , \", current balance\" , balance , \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "        reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "\n",
    "        act=\"strong buy\"\n",
    "\n",
    "\n",
    "    elif action==1 and balance>1: #buy\n",
    "        amount_stocks=(balance*0.2)/data[t]\n",
    "        balance=balance-(amount_stocks*data[t])-(amount_stocks*data[t]*trade_fee)\n",
    "        current_stocks+=amount_stocks\n",
    "        stocks.append(amount_stocks)\n",
    "        asset=balance+data[t]*current_stocks\n",
    "        current_asset_list.append(asset)\n",
    "        agent.inventory.append(data[t])\n",
    "        print(t,\")\",\"Buy at stock price\", data[t] , \", current balance\" , balance , \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "        reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "\n",
    "        act=\"buy\"\n",
    "\n",
    "    elif action==2: #hold\n",
    "        balance=balance\n",
    "        asset=balance+data[t]*current_stocks\n",
    "        current_asset_list.append(asset)\n",
    "        amount_stocks=0\n",
    "        stocks.append(amount_stocks)\n",
    "\n",
    "        print(t,\")\",\"Hold at stock price\", data[t],\",current balance\", balance ,\"TL\", \"current asset:\", balance+data[t]*current_stocks )\n",
    "\n",
    "        reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "\n",
    "        act=\"hold\"\n",
    "\n",
    "    elif action == 3 and current_stocks > 1: #sell\n",
    "        sold_stocks=(current_stocks*0.5)\n",
    "        current_stocks-=sold_stocks\n",
    "        balance+=sold_stocks*data[t]\n",
    "        asset=balance+data[t]*current_stocks\n",
    "        current_asset_list.append(asset)\n",
    "        reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "        stocks.append(-1*sold_stocks)\n",
    "        print(t,\")\",\"Sell at stock price\", data[t] , \", current balance\" , balance, \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "        act=\"sell\"\n",
    "\n",
    "    elif action == 4 and current_stocks > 0: #strong sell\n",
    "        sold_stocks=(current_stocks)\n",
    "        current_stocks-=sold_stocks\n",
    "        balance+=sold_stocks*data[t]\n",
    "        asset=balance+data[t]*current_stocks\n",
    "        current_asset_list.append(asset)\n",
    "        reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "        stocks.append(-1*sold_stocks)\n",
    "        print(t,\")\",\"Strong Sell at stock price\", data[t] , \", current balance\" , balance , \"TL,\",\n",
    "                 \"current stocks\", current_stocks, \"current asset:\", balance+data[t]*current_stocks)\n",
    "\n",
    "        act=\"strong sell\"\n",
    "\n",
    "\n",
    "    else:\n",
    "        action=2\n",
    "        balance=balance\n",
    "        asset=balance+data[t]*current_stocks\n",
    "        current_asset_list.append(asset)\n",
    "        amount_stocks=0\n",
    "        stocks.append(amount_stocks)\n",
    "\n",
    "        print(t,\")\",\"Hold at stock price\", data[t],\",current balance\", balance ,\"TL\", \"current asset:\", balance+data[t]*current_stocks )\n",
    "\n",
    "        reward=(current_asset_list[t]-current_asset_list[t-1])/current_asset_list[t-1]\n",
    "        act=\"else hold\"\n",
    "\n",
    "    done = True if t == l else False\n",
    "    agent.memory.append((state, action, reward, next_state, done))\n",
    "    state = next_state\n",
    "    print(action)\n",
    "\n",
    "    current_stocks_list.append(current_stocks)\n",
    "    reward_list.append(reward)\n",
    "    bal_list.append(balance)\n",
    "\n",
    "    actions.append(act)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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": 1
}