DTTrans_MLP.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DTTrans: MLP"
   ]
  },
  {
   "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": 3,
   "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": 3,
   "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": 4,
   "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": 4,
   "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": 13,
   "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": 14,
   "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": 15,
   "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": 15,
     "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": 16,
   "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)\n",
    "input_val_data = KMA_val_dataset.reshape(70,-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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output data (PV power generation data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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)\n",
    "pv_val_output = pv_val_output.reshape(70,-1)\n",
    "pv_test_output = pv_test_output.reshape(70,-1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MLP model\n",
    "in_size        = 288\n",
    "hidden_size    = 256\n",
    "\n",
    "out_size       = 24\n",
    "batch_size     = 18\n",
    "learning_rate  = 1e-4\n",
    "\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MLP, self).__init__()\n",
    "        self.fc_in  = nn.Linear(in_size, hidden_size)\n",
    "        self.fc_h1  = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc_h2  = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc_out = nn.Linear(hidden_size, out_size)\n",
    "\n",
    "        torch.nn.init.xavier_uniform_(self.fc_in.weight)\n",
    "        torch.nn.init.xavier_uniform_(self.fc_h1.weight)\n",
    "        torch.nn.init.xavier_uniform_(self.fc_h2.weight)\n",
    "        torch.nn.init.xavier_uniform_(self.fc_out.weight)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc_in(x))\n",
    "        x = F.relu(self.fc_h1(x))\n",
    "        x = F.relu(self.fc_h2(x))\n",
    "        # x = F.relu(self.fc_h3(x))\n",
    "        out = F.relu(self.fc_out(x))\n",
    "        return out\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()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traning MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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: 8.58%        NMAE_test: 17.58%        \n",
      "Best performance at epoch: 50\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 50                NMAE_train: 5.58%        NMAE_test: 10.26%        \n",
      "Best performance at epoch: 100\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 100               NMAE_train: 4.3%         NMAE_test: 8.91%         \n",
      "epoch: 150               NMAE_train: 3.75%        NMAE_test: 9.44%         \n",
      "Best performance at epoch: 200\n",
      "Save model in D:\\Workspace\\논문투고용code\\들로네_삼각분할_태양광예측\\models/\n",
      "epoch: 200               NMAE_train: 3.17%        NMAE_test: 7.9%          \n",
      "epoch: 250               NMAE_train: 2.96%        NMAE_test: 9.78%         \n",
      "epoch: 300               NMAE_train: 2.66%        NMAE_test: 8.16%         \n",
      "epoch: 350               NMAE_train: 2.5%         NMAE_test: 9.24%         \n",
      "epoch: 400               NMAE_train: 2.38%        NMAE_test: 8.84%         \n",
      "epoch: 450               NMAE_train: 2.23%        NMAE_test: 7.99%         \n",
      "epoch: 500               NMAE_train: 2.12%        NMAE_test: 8.18%         \n",
      "epoch: 550               NMAE_train: 2.04%        NMAE_test: 8.62%         \n",
      "epoch: 600               NMAE_train: 1.99%        NMAE_test: 8.95%         \n",
      "epoch: 650               NMAE_train: 1.96%        NMAE_test: 9.6%          \n",
      "epoch: 700               NMAE_train: 1.9%         NMAE_test: 8.21%         \n",
      "epoch: 750               NMAE_train: 1.84%        NMAE_test: 8.31%         \n",
      "epoch: 800               NMAE_train: 1.82%        NMAE_test: 9.07%         \n",
      "epoch: 850               NMAE_train: 1.78%        NMAE_test: 9.44%         \n",
      "epoch: 900               NMAE_train: 1.74%        NMAE_test: 8.95%         \n",
      "epoch: 950               NMAE_train: 1.68%        NMAE_test: 8.15%         \n",
      "epoch: 1000              NMAE_train: 1.67%        NMAE_test: 10.45%        \n"
     ]
    }
   ],
   "source": [
    "total_epoch    = 1000\n",
    "print_interval = 50\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "model = MLP().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": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "현대하이텍태양광발전기: 8.12%                  \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": 25,
   "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(['MLP (training)', 'MLP (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
}