DTTrans_TransGRU.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DTTrans: TransGRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "\n",
    "from urllib.request import Request, urlopen\n",
    "from urllib.parse import urlencode, quote_plus\n",
    "from datetime import datetime\n",
    "import ast\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import random\n",
    "import os\n",
    "\n",
    "def seed_everything(seed: int = 42):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed) # type: ignore\n",
    "    torch.backends.cudnn.deterministic = True # type: ignore\n",
    "    torch.backends.cudnn.benchmark = True # type: ignore\n",
    "\n",
    "seed_everything(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## load Delaunay Triangulation result\n",
    "del_result_path = r'D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\PV_delaunay_tri(bell)_20211028_updated.csv' # 들로네 삼각분할 결과 => But, 21.10.28일까지의 PV 사이트에 대한 Update 필요!\n",
    "del_pv = pd.read_csv(del_result_path)\n",
    "\n",
    "del_pv.head()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Union-Inner Triangles Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python3 code to find all three angles\n",
    "# of a triangle given coordinate\n",
    "# of all three vertices\n",
    "import math\n",
    "\n",
    "# returns square of distance b/w two points\n",
    "def lengthSquare(X, Y):\n",
    "    xDiff = X[0] - Y[0]\n",
    "    yDiff = X[1] - Y[1]\n",
    "    return xDiff * xDiff + yDiff * yDiff\n",
    "\n",
    "def getAngle(A, B, C):\n",
    "    # Square of lengths be a2, b2, c2\n",
    "    a2 = lengthSquare(B, C)\n",
    "    b2 = lengthSquare(A, C)\n",
    "    c2 = lengthSquare(A, B)\n",
    "\n",
    "    # length of sides be a, b, c\n",
    "    a = math.sqrt(a2)\n",
    "    b = math.sqrt(b2)\n",
    "    c = math.sqrt(c2)\n",
    "\n",
    "    # From Cosine law\n",
    "    alpha = math.acos((b2 + c2 - a2) /\n",
    "                         (2 * b * c))\n",
    "    betta = math.acos((a2 + c2 - b2) /\n",
    "                         (2 * a * c))\n",
    "    gamma = math.acos((a2 + b2 - c2) /\n",
    "                         (2 * a * b))\n",
    "\n",
    "    # Converting to degree\n",
    "    alpha = alpha * 180 / math.pi\n",
    "    betta = betta * 180 / math.pi\n",
    "    gamma = gamma * 180 / math.pi\n",
    "    \n",
    "    return [alpha, betta, gamma]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv_not_del_3weathers = []\n",
    "\n",
    "del_pv.reset_index(drop=True, inplace=True)\n",
    "for i in range(len(del_pv)):\n",
    "    euclidean_dist_result = pd.read_csv(r\"D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\Expection_result\\each_PV_weather_dist_euclidean/\"+\n",
    "                                      \"PV_\"+del_pv[\"발전기명\"][i]+\"_dist_weather.csv\")\n",
    "                                      \n",
    "    euclidean_3weathers = [euclidean_dist_result['지점번호'][0], euclidean_dist_result['지점번호'][1], euclidean_dist_result['지점번호'][2]]\n",
    "    euclidean_3weathers.sort()\n",
    "\n",
    "    del_3weathers  = [del_pv[del_pv['발전기명']== del_pv[\"발전기명\"][i]]['지점번호0'].values[0], del_pv[del_pv['발전기명']== del_pv[\"발전기명\"][i]]['지점번호1'].values[0], del_pv[del_pv['발전기명']== del_pv[\"발전기명\"][i]]['지점번호2'].values[0]] # 들로네 삼각분할로 구성된 3개 기상관측소 지점번호 \n",
    "    del_3weathers.sort()\n",
    "\n",
    "    if euclidean_3weathers != del_3weathers:\n",
    "        pv_not_del_3weathers.append(del_pv[\"발전기명\"][i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial import distance\n",
    "import warnings\n",
    "warnings.filterwarnings(action='ignore')\n",
    "\n",
    "PV_sites = del_pv[\"발전기명\"].values.tolist()\n",
    "\n",
    "diff_PV_results = pd.DataFrame(columns=[\"PV site name\", \"algorithm result\", \"Recommend weather stations\"]) # 태양광 발전소별 판별 알고리즘 결과 dataframe 화\n",
    "obtuse_triangles = []\n",
    "\n",
    "for i in range(len(PV_sites)):\n",
    "    # del weather stations\n",
    "    del_3weather_stations = del_pv[del_pv['발전기명'] == PV_sites[i]].loc[:, ['지점번호0', '지점번호1', '지점번호2']].to_numpy().tolist()[0]\n",
    "    \n",
    "    # nearset distance based weather stations\n",
    "    nearest_weather_station = pd.read_csv(r\"D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\Expection_result\\each_PV_weather_dist_euclidean/\"+\n",
    "                                      \"PV_\"+PV_sites[i]+\"_dist_weather.csv\")\n",
    "\n",
    "    dist_based_3weather_stations = nearest_weather_station['지점번호'].values.tolist()[:3]\n",
    "\n",
    "    # Union of del_3weather_stations and dist_based_3weather_stations\n",
    "    union_3weather_stations_ = del_3weather_stations + dist_based_3weather_stations\n",
    "\n",
    "    # remove the repeated stations\n",
    "    union_3weather_stations, counts = np.unique(union_3weather_stations_, return_counts=True)\n",
    "\n",
    "    pv_site_loc = del_pv[del_pv['발전기명'] == PV_sites[i]].loc[:, ['latitude', 'longitude']].to_numpy().tolist()[0] # PV site location\n",
    "    weather_station_loc1 = del_pv[del_pv['발전기명'] == PV_sites[i]].loc[:, ['latitude(지점)0', 'longitude(지점)0']].to_numpy().tolist()[0] # weather station 1 location\n",
    "    weather_station_loc2 = del_pv[del_pv['발전기명'] == PV_sites[i]].loc[:, ['latitude(지점)1', 'longitude(지점)1']].to_numpy().tolist()[0] # weather station 2 location\n",
    "    weather_station_loc3 = del_pv[del_pv['발전기명'] == PV_sites[i]].loc[:, ['latitude(지점)2', 'longitude(지점)2']].to_numpy().tolist()[0] # weather station 3 location\n",
    "\n",
    "    if len(union_3weather_stations) == 5:\n",
    "        obtuse_triangles.append(PV_sites[i])\n",
    "        # print(\"Delaunay triangle is sparse. Highly recommend nearest distance based method.\")\n",
    "        # diff_PV_results.loc[i, :] = [PV_sites[i], union_3weather_stations.tolist(), dist_based_3weather_stations]\n",
    "\n",
    "        inner_tri1 = getAngle(pv_site_loc, weather_station_loc1, weather_station_loc2)\n",
    "        inner_tri2 = getAngle(pv_site_loc, weather_station_loc2, weather_station_loc3)\n",
    "        inner_tri3 = getAngle(pv_site_loc, weather_station_loc1, weather_station_loc3)\n",
    "        \n",
    "        inner_tri_angles = inner_tri1 + inner_tri2 + inner_tri3\n",
    "        \n",
    "        if min(inner_tri_angles) < 2: # parameter (base angle) => It means how PV site is located on the side of triangle\n",
    "            diff_PV_results.loc[i, :] = [PV_sites[i], \"nearest 3 weather stations\", dist_based_3weather_stations]\n",
    "        else:\n",
    "            diff_PV_results.loc[i, :] = [PV_sites[i], \"delaunay triangle\", del_3weather_stations]        \n",
    "    elif len(union_3weather_stations) == 3:\n",
    "        # print(\"Use delaunay method.\")\n",
    "        diff_PV_results.loc[i, :] = [PV_sites[i], \"delaunay triangle\", del_3weather_stations]\n",
    "    else:\n",
    "        inner_tri1 = getAngle(pv_site_loc, weather_station_loc1, weather_station_loc2)\n",
    "        inner_tri2 = getAngle(pv_site_loc, weather_station_loc2, weather_station_loc3)\n",
    "        inner_tri3 = getAngle(pv_site_loc, weather_station_loc1, weather_station_loc3)\n",
    "        \n",
    "        inner_tri_angles = inner_tri1 + inner_tri2 + inner_tri3\n",
    "        \n",
    "        if min(inner_tri_angles) < 1.3: # parameter (base angle) => It means how PV site is located on the side of triangle\n",
    "            diff_PV_results.loc[i, :] = [PV_sites[i], \"nearest 3 weather stations\", dist_based_3weather_stations]\n",
    "        else:\n",
    "            diff_PV_results.loc[i, :] = [PV_sites[i], \"delaunay triangle\", del_3weather_stations]    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff_PV_results[diff_PV_results['algorithm result'] == 'delaunay triangle']\n",
    "diff_PV_results[diff_PV_results['algorithm result'] == 'nearest 3 weather stations']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Weather data (KMA-ASOS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ASOS(pageNo, StartDate, EndDate, Location):\n",
    "    url = 'http://apis.data.go.kr/1360000/AsosHourlyInfoService/getWthrDataList'\n",
    "    # ServiceKey = 'AJeNviCSzwS9vhEB3iIDJ1ilqGFIjEqaGvIcH0z+dFT15mFhQWW6Dh2SCdufI0uGHxo6dtKcUdEqBGw0Hjb6Aw=='   # key1\n",
    "    ServiceKey = 'UKa6C8yfdD9RivsIRVFN8OAplj7C6T8CLdENXcE2Wq1kg/M2chZTf6gJOTOmHNW0VMLIaoG7HXZS+tIfbVHRXw=='     # key2\n",
    "    queryParams = '?' + urlencode({quote_plus('ServiceKey') : ServiceKey,\n",
    "                                   quote_plus('pageNo') : pageNo,\n",
    "                                   quote_plus('numOfRows') : '999',\n",
    "                                   quote_plus('dataType') : 'JSON',\n",
    "                                   quote_plus('dataCd') : 'ASOS',\n",
    "                                   quote_plus('dateCd') : 'HR',\n",
    "                                   quote_plus('startDt') : StartDate,\n",
    "                                   quote_plus('startHh') : '00',\n",
    "                                   quote_plus('endDt') : EndDate,\n",
    "                                   quote_plus('endHh') : '23',\n",
    "                                   quote_plus('stnIds') : Location})\n",
    "\n",
    "    request = Request(url + queryParams)\n",
    "    request.get_method = lambda: 'GET'\n",
    "    response_body = urlopen(request).read()\n",
    "    \n",
    "    dict_str = response_body.decode(\"UTF-8\")\n",
    "    data_out = ast.literal_eval(dict_str)\n",
    "\n",
    "    return data_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input data\n",
    "## Input - training data (ASOS 관측데이터)\n",
    "StartDate = '20191201'\n",
    "EndDate   = '20211028'\n",
    "\n",
    "test_pv_site_name = '현대하이텍태양광발전기' # predict PV site\n",
    "Location = diff_PV_results[diff_PV_results['PV site name'] == test_pv_site_name]['Recommend weather stations'].values[0]\n",
    "\n",
    "TotalDate = (datetime.strptime(EndDate, '%Y%m%d') - datetime.strptime(StartDate, '%Y%m%d')).days + 1\n",
    "TotalPage = int(24*TotalDate/999) + 1\n",
    "\n",
    "del_data_weather = pd.DataFrame()\n",
    "for l in range(len(Location)):\n",
    "    data_Weather = {}\n",
    "    data_Weather['Temp'] = []\n",
    "    data_Weather['Wind'] = []\n",
    "    data_Weather['Humid'] = []\n",
    "    data_Weather['Cloud'] = []\n",
    "    \n",
    "    data_Weather_data = {}\n",
    "    data_Weather_data['Date'] = []\n",
    "    \n",
    "    for i in range(TotalPage):\n",
    "        pageNo = str(i+1)\n",
    "        data_ASOS = get_ASOS(pageNo, StartDate, EndDate, Location[l])\n",
    "        if data_ASOS['response']['header']['resultCode'] == '00':\n",
    "            data_ASOS_item = data_ASOS['response']['body']['items']['item']\n",
    "            for j in range(len(data_ASOS_item)):\n",
    "                data_Weather_data['Date']  += [data_ASOS_item[j]['tm']]\n",
    "                data_Weather['Temp']  += [data_ASOS_item[j]['ta']]\n",
    "                data_Weather['Wind']  += [data_ASOS_item[j]['ws']]\n",
    "                data_Weather['Humid'] += [data_ASOS_item[j]['hm']]\n",
    "                data_Weather['Cloud'] += [data_ASOS_item[j]['dc10Tca']]\n",
    "        else:\n",
    "            print(pageNo + ': ' + data_ASOS['response']['header']['resultMsg'])\n",
    "\n",
    "    data_Weather = pd.DataFrame(data_Weather)\n",
    "    data_Weather_data = pd.DataFrame(data_Weather_data)\n",
    "    data_Weather = data_Weather.replace('', np.nan)\n",
    "\n",
    "    data_Weather['Temp'] = data_Weather['Temp'].astype(float)\n",
    "    data_Weather['Wind'] = data_Weather['Wind'].astype(float)\n",
    "    data_Weather['Humid'] = data_Weather['Humid'].astype(float)\n",
    "    data_Weather['Cloud'] = data_Weather['Cloud'].astype(float)\n",
    "    data_Weather = data_Weather[['Temp', 'Wind', 'Humid', 'Cloud']]\n",
    "\n",
    "    del_data_weather = pd.concat([del_data_weather, data_Weather], axis=1)\n",
    "\n",
    "del_data_weather = pd.concat([data_Weather_data, del_data_weather], axis=1)\n",
    "del_data_weather.columns = ['Date', 'Temp_'+str(int(Location[0])), 'Wind_'+str(int(Location[0])), 'Humid_'+str(int(Location[0])), 'Cloud_'+str(int(Location[0])),\n",
    "                            'Temp_'+str(int(Location[1])), 'Wind_'+str(int(Location[1])), 'Humid_'+str(int(Location[1])), 'Cloud_'+str(int(Location[1])),\n",
    "                            'Temp_'+str(int(Location[2])), 'Wind_'+str(int(Location[2])), 'Humid_'+str(int(Location[2])), 'Cloud_'+str(int(Location[2]))]\n",
    "\n",
    "del_data_weather.interpolate(method='linear', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Temp_156</th>\n",
       "      <th>Wind_156</th>\n",
       "      <th>Humid_156</th>\n",
       "      <th>Cloud_156</th>\n",
       "      <th>Temp_251</th>\n",
       "      <th>Wind_251</th>\n",
       "      <th>Humid_251</th>\n",
       "      <th>Cloud_251</th>\n",
       "      <th>Temp_172</th>\n",
       "      <th>Wind_172</th>\n",
       "      <th>Humid_172</th>\n",
       "      <th>Cloud_172</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2019-12-01 00:00</td>\n",
       "      <td>8.4</td>\n",
       "      <td>2.5</td>\n",
       "      <td>53.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>6.3</td>\n",
       "      <td>0.1</td>\n",
       "      <td>67.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>6.3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>76.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2019-12-01 01:00</td>\n",
       "      <td>8.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>56.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.7</td>\n",
       "      <td>69.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>6.3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>72.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2019-12-01 02:00</td>\n",
       "      <td>7.9</td>\n",
       "      <td>0.0</td>\n",
       "      <td>57.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>67.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>5.9</td>\n",
       "      <td>0.0</td>\n",
       "      <td>78.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2019-12-01 03:00</td>\n",
       "      <td>7.8</td>\n",
       "      <td>0.1</td>\n",
       "      <td>60.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>5.8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>70.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>5.7</td>\n",
       "      <td>0.0</td>\n",
       "      <td>82.0</td>\n",
       "      <td>8.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2019-12-01 04:00</td>\n",
       "      <td>7.6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>62.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>5.9</td>\n",
       "      <td>0.0</td>\n",
       "      <td>69.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>5.9</td>\n",
       "      <td>0.0</td>\n",
       "      <td>78.0</td>\n",
       "      <td>7.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               Date  Temp_156  Wind_156  Humid_156  Cloud_156  Temp_251  \\\n",
       "0  2019-12-01 00:00       8.4       2.5       53.0       10.0       6.3   \n",
       "1  2019-12-01 01:00       8.0       1.0       56.0       10.0       6.0   \n",
       "2  2019-12-01 02:00       7.9       0.0       57.0       10.0       6.0   \n",
       "3  2019-12-01 03:00       7.8       0.1       60.0       10.0       5.8   \n",
       "4  2019-12-01 04:00       7.6       0.0       62.0       10.0       5.9   \n",
       "\n",
       "   Wind_251  Humid_251  Cloud_251  Temp_172  Wind_172  Humid_172  Cloud_172  \n",
       "0       0.1       67.0        9.0       6.3       0.0       76.0        0.0  \n",
       "1       0.7       69.0       10.0       6.3       0.0       72.0       10.0  \n",
       "2       0.0       67.0        9.0       5.9       0.0       78.0       10.0  \n",
       "3       0.0       70.0        8.0       5.7       0.0       82.0        8.5  \n",
       "4       0.0       69.0        7.0       5.9       0.0       78.0        7.0  "
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del_data_weather.head()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data preprocessing"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input data (Weather data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_0_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,1].to_numpy(), (698 ,24)))/40\n",
    "wind_0_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,2].to_numpy(), (698 ,24)))/20\n",
    "humid_0_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,3].to_numpy(), (698 ,24)))/100\n",
    "cloud_0_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,4].to_numpy(), (698 ,24)))/10\n",
    "\n",
    "temp_1_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,5].to_numpy(), (698 ,24)))/40\n",
    "wind_1_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,6].to_numpy(), (698  ,24)))/20\n",
    "humid_1_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,7].to_numpy(), (698 ,24)))/100\n",
    "cloud_1_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,8].to_numpy(), (698 ,24)))/10\n",
    "\n",
    "temp_2_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,9].to_numpy(), (698 ,24)))/40\n",
    "wind_2_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,10].to_numpy(), (698 ,24)))/20\n",
    "humid_2_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,11].to_numpy(), (698 ,24)))/100\n",
    "cloud_2_live = np.nan_to_num(np.reshape(del_data_weather.iloc[:,12].to_numpy(), (698 ,24)))/10\n",
    "\n",
    "KMA_dataset = np.concatenate((temp_0_live, wind_0_live, humid_0_live, cloud_0_live,\n",
    "                              temp_1_live, wind_1_live, humid_1_live, cloud_1_live,\n",
    "                              temp_2_live, wind_2_live, humid_2_live, cloud_2_live), axis=1)\n",
    "\n",
    "# Divide dataset to Training, Validation, Test\n",
    "train_len = int(KMA_dataset.shape[0]*0.80) \n",
    "val_len = int(KMA_dataset.shape[0]*0.10) \n",
    "test_len = int(KMA_dataset.shape[0]*0.10) \n",
    "\n",
    "# Training set\n",
    "KMA_train_dataset = KMA_dataset[:train_len,:]\n",
    "# Validation set\n",
    "KMA_val_dataset = KMA_dataset[train_len:(train_len+val_len)+1,:]\n",
    "# Test set\n",
    "KMA_test_dataset = KMA_dataset[(train_len+val_len)+1:,:]\n",
    "\n",
    "## For Test set, use generated weather forecast data = x + n; n ~ N(0, 20% of maximum value of weather factors)\n",
    "KMA_w1_test_dataset = pd.read_csv(r'D:\\Workspace\\논문투고용code\\DTTrans_official\\Test dataset(20% noise)/'+str(Location[0])+'_20%_noise.csv')\n",
    "KMA_w2_test_dataset = pd.read_csv(r'D:\\Workspace\\논문투고용code\\DTTrans_official\\Test dataset(20% noise)/'+str(Location[1])+'_20%_noise.csv')\n",
    "KMA_w3_test_dataset = pd.read_csv(r'D:\\Workspace\\논문투고용code\\DTTrans_official\\Test dataset(20% noise)/'+str(Location[2])+'_20%_noise.csv')\n",
    "\n",
    "## Reshape the data dimension\n",
    "input_train_data = KMA_train_dataset.reshape(558,1,-1)\n",
    "input_val_data = KMA_val_dataset.reshape(70,1,-1)\n",
    "input_test_data = np.concatenate((KMA_w1_test_dataset.values.reshape(70,-1), KMA_w2_test_dataset.values.reshape(70,-1), KMA_w3_test_dataset.values.reshape(70,-1)), axis=1).reshape(70,1,-1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output data (PV power generation data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv_single_data_path = r'D:\\Workspace\\Dataset\\태양광 발전 데이터/신재생(시간별)_20191201_20211028/PV_' + test_pv_site_name + '_20191201_20211028.csv'\n",
    "pv_single_data = pd.read_csv(pv_single_data_path)\n",
    "pv_capacity = pv_single_data['계약(설비)용량'].values[0]\n",
    "\n",
    "# 2019.12.01 ~ 2021.06.10 (558) (Training set 80%)\n",
    "pv_single_data_train = pv_single_data.loc[pv_single_data['거래일'] < 20210611]\n",
    "pv_train_output = np.reshape(pv_single_data_train['발전량'].values, (558,24))/pv_capacity\n",
    "\n",
    "# 2021.06.11 ~ 2021.08.19 (70) (val set 10%)\n",
    "pv_single_data_val = pv_single_data.loc[pv_single_data['거래일'] >= 20210611].loc[pv_single_data['거래일'] <= 20210819]\n",
    "pv_val_output = np.reshape(pv_single_data_val['발전량'].values, (70,24))/pv_capacity\n",
    "\n",
    "# 2021.08.20 ~ 2021.10.28 길이 자르기 (70) (test set 10%)\n",
    "pv_single_data_test = pv_single_data.loc[pv_single_data['거래일'] >= 20210820].loc[pv_single_data['거래일'] <= 20211028]\n",
    "pv_test_output = np.reshape(pv_single_data_test['발전량'].values, (70,24))/pv_capacity\n",
    "\n",
    "## Reshape the data dimension\n",
    "pv_train_output = pv_train_output.reshape(558,1,-1)\n",
    "pv_val_output = pv_val_output.reshape(70,1,-1)\n",
    "pv_test_output = pv_test_output.reshape(70,1,-1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TransGRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = 288\n",
    "hidden_size = 64\n",
    "hidden_size_1 = 256 \n",
    "\n",
    "output_size = 24\n",
    "batch_size = 18 \n",
    "learning_rate = 1e-4\n",
    "\n",
    "class TransGRU(nn.Module):\n",
    "    def __init__(self, feature_size = input_size, num_layers=1, dropout=0): # 1\n",
    "        super(TransGRU, self).__init__()\n",
    "        self.encoder_layer = nn.TransformerEncoderLayer(d_model=feature_size, nhead=1, dim_feedforward=512, dropout=dropout, \n",
    "                                                        batch_first=False, norm_first=False, layer_norm_eps=1e-5, activation=\"relu\")\n",
    "        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, num_layers=num_layers)\n",
    "\n",
    "        self.decoder_gru = nn.GRU(input_size=feature_size, hidden_size=hidden_size, num_layers=1, batch_first=False)\n",
    "\n",
    "        self.decoder_fc_h1 = nn.Linear(hidden_size, hidden_size_1)\n",
    "        self.decoder_fc_h2 = nn.Linear(hidden_size_1, hidden_size_1)\n",
    "        self.decoder_fc_out = nn.Linear(hidden_size_1, output_size)\n",
    "\n",
    "        torch.nn.init.xavier_uniform_(self.decoder_fc_h1.weight)\n",
    "        torch.nn.init.xavier_uniform_(self.decoder_fc_h2.weight)\n",
    "        torch.nn.init.xavier_uniform_(self.decoder_fc_out.weight)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.transformer_encoder(x)\n",
    "\n",
    "        x,_ = self.decoder_gru(x)\n",
    "        \n",
    "        x = F.relu(self.decoder_fc_h1(x))\n",
    "        x = F.relu(self.decoder_fc_h2(x))\n",
    "        output = F.relu(self.decoder_fc_out(x))\n",
    "        return output\n",
    "    \n",
    "def train_net(model, batch, optimizer):\n",
    "    x, y = batch[0], batch[1]\n",
    "    loss = F.mse_loss(model.forward(x), y)\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    return loss.item() # training loss"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traning TransGRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best performance at epoch: 1\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 1                 NMAE_train: 7.48%        NMAE_test: 14.42%        \n",
      "Best performance at epoch: 50\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 50                NMAE_train: 5.32%        NMAE_test: 8.74%         \n",
      "Best performance at epoch: 100\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 100               NMAE_train: 4.41%        NMAE_test: 8.73%         \n",
      "Best performance at epoch: 150\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 150               NMAE_train: 4.06%        NMAE_test: 8.38%         \n",
      "epoch: 200               NMAE_train: 3.8%         NMAE_test: 12.15%        \n",
      "epoch: 250               NMAE_train: 3.62%        NMAE_test: 9.33%         \n",
      "epoch: 300               NMAE_train: 3.5%         NMAE_test: 10.08%        \n",
      "epoch: 350               NMAE_train: 3.35%        NMAE_test: 9.28%         \n",
      "epoch: 400               NMAE_train: 3.27%        NMAE_test: 10.32%        \n",
      "epoch: 450               NMAE_train: 3.21%        NMAE_test: 10.06%        \n",
      "Best performance at epoch: 500\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 500               NMAE_train: 3.13%        NMAE_test: 8.27%         \n",
      "epoch: 550               NMAE_train: 3.05%        NMAE_test: 8.39%         \n",
      "epoch: 600               NMAE_train: 3.06%        NMAE_test: 9.87%         \n",
      "epoch: 650               NMAE_train: 2.98%        NMAE_test: 8.47%         \n",
      "epoch: 700               NMAE_train: 2.94%        NMAE_test: 9.16%         \n",
      "epoch: 750               NMAE_train: 2.88%        NMAE_test: 8.94%         \n",
      "epoch: 800               NMAE_train: 2.85%        NMAE_test: 8.65%         \n",
      "epoch: 850               NMAE_train: 2.81%        NMAE_test: 8.33%         \n",
      "Best performance at epoch: 900\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 900               NMAE_train: 2.77%        NMAE_test: 8.18%         \n",
      "epoch: 950               NMAE_train: 2.73%        NMAE_test: 8.83%         \n",
      "epoch: 1000              NMAE_train: 2.69%        NMAE_test: 8.72%         \n"
     ]
    }
   ],
   "source": [
    "total_epoch    = 1000 \n",
    "print_interval = 50\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "model = TransGRU().to(device)\n",
    "\n",
    "# train_len = 558\n",
    "total_batch = int(train_len/batch_size)-1 #+ 1\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "single_val_object = pv_val_output > 0.1 # for NMAE10\n",
    "\n",
    "# early stopping\n",
    "best_loss = 99999\n",
    "PATH = r'D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/'\n",
    "\n",
    "train_predict = []\n",
    "test_predict = []\n",
    "NMAE_train = []\n",
    "NMAE_test  = []\n",
    "\n",
    "train_loss = []\n",
    "val_loss = []\n",
    "for epoch in range(total_epoch):\n",
    "    train_batch_loss = []\n",
    "    for i in range(total_batch):\n",
    "        batch_x = torch.tensor(input_train_data[batch_size*i:batch_size*(i+1),:,:], dtype=torch.float).to(device)\n",
    "        batch_y = torch.tensor(pv_train_output[batch_size*i:batch_size*(i+1),:,:], dtype=torch.float).to(device)\n",
    "        batch = [batch_x, batch_y]\n",
    "        train_batch_loss += [train_net(model, batch, optimizer)]\n",
    "\n",
    "    train_loss += [np.mean(train_batch_loss)]\n",
    "    \n",
    "    val_predict = model.forward(torch.tensor(input_val_data, dtype=torch.float).to(device)).cpu().data.detach().numpy()\n",
    "    val_loss += [np.square(np.subtract(pv_val_output, val_predict)).mean()] # MSE metric\n",
    "\n",
    "    if epoch == 0 or (epoch+1) % print_interval == 0:\n",
    "        train_predict += [model.forward(torch.tensor(input_train_data, dtype=torch.float).to(device)).cpu().data.detach().numpy()]\n",
    "        test_predict  += [model.forward(torch.tensor(input_val_data, dtype=torch.float).to(device)).cpu().data.detach().numpy()]   # Validation data로 바꿔줘야 함!\n",
    "        \n",
    "        NMAE_train += [round(100*np.mean(np.abs(pv_train_output - train_predict)),2)]\n",
    "        NMAE_test += [round(100*np.sum(single_val_object*np.abs(pv_val_output - test_predict[-1]))/np.sum(single_val_object),2)]\n",
    "\n",
    "        # Early Stopping & save model\n",
    "        if NMAE_test[-1] < best_loss:\n",
    "            print(f\"Best performance at epoch: {epoch + 1}\")\n",
    "            print(f\"Save model in {PATH}\")\n",
    "            best_loss = NMAE_test[-1]\n",
    "            # torch.save(model_single, PATH + vpp_names[5] + '_TransGRU_atten_visual.pt')\n",
    "\n",
    "        print(\"epoch: {}\".format(epoch+1).ljust(25), end=\"\")\n",
    "        print(\"NMAE_train: {}%\".format(NMAE_train[-1]).ljust(25), end=\"\")\n",
    "        print(\"NMAE_test: {}%\".format(NMAE_test[-1]).ljust(25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "현대하이텍태양광발전기: 7.93%                  \n"
     ]
    }
   ],
   "source": [
    "# test output\n",
    "test_pred = model.forward(torch.tensor(input_test_data, dtype=torch.float).to(device)).cpu().data.detach().numpy()\n",
    "\n",
    "# NMAE10\n",
    "single_test_object = pv_test_output > 0.1\n",
    "NMAE_test_object = round(100*np.sum(single_test_object*np.abs(pv_test_output - test_pred))/np.sum(single_test_object),2)\n",
    "\n",
    "print(test_pv_site_name + \": {}%\".format(NMAE_test_object).ljust(25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(15,8))\n",
    "x_grid = [i for i in range(total_epoch)]\n",
    "plt.plot(x_grid, train_loss, linewidth=2)\n",
    "plt.plot(x_grid, val_loss, linewidth=2)\n",
    "\n",
    "\n",
    "plt.legend(['TransGRU (training)', 'TransGRU (validation)'],  prop={'size': 25})\n",
    "\n",
    "plt.xticks(fontsize=25)\n",
    "plt.yticks(fontsize=25)\n",
    "\n",
    "plt.xlabel('epoch', fontsize=35)\n",
    "plt.ylabel('loss', fontsize=35)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "skjdeep",
   "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "4277b0448c3042061e5075c8063bd6c5b03f4c493a249e6c19196e29c751fc81"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}