diff --git a/challenge1/analysis/tur/ch1.html b/challenge1/analysis/tur/ch1.html new file mode 100644 index 000000000..13221695d --- /dev/null +++ b/challenge1/analysis/tur/ch1.html @@ -0,0 +1,13532 @@ + + + + +ch1 + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
In [18]:
+
+
+
import pandas as pd
+import numpy as np
+df = pd.read_csv('../../data/training_dataset_500.csv')
+
+ +
+
+
+ +
+
+
+
In [19]:
+
+
+
from sklearn.preprocessing import PolynomialFeatures, LabelEncoder, MinMaxScaler
+df = df.drop(columns=['ID','Label'])
+#df = df[df.Month.isin([4,5,6,7,8])]
+df.corr()
+
+ +
+
+
+ +
+
+ + +
+ +
Out[19]:
+ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HouseYearMonthTemperatureDaylightEnergyProduction
House1.000000e+000.000000-1.816873e-180.0008810.001583-0.008303
Year0.000000e+001.000000-6.340757e-01-0.3568000.5246030.267481
Month-1.816873e-18-0.6340761.000000e+000.353837-0.276307-0.232748
Temperature8.810764e-04-0.3568003.538369e-011.000000-0.0533630.272789
Daylight1.582656e-030.524603-2.763068e-01-0.0533631.0000000.531577
EnergyProduction-8.302696e-030.267481-2.327484e-010.2727890.5315771.000000
+
+
+ +
+ +
+
+ +
+
+
+
In [20]:
+
+
+
def preprocessing(df):
+    #from keras.utils import np_utils
+    X = df[['House','Month','Temperature','Daylight']]
+    #X = X[X.Month.isin([4,5,6,7,8])]
+    y = df[['EnergyProduction']]
+    #enc = LabelEncoder()
+    #house = X.House.values.reshape(-1,1)
+    #X['House'] = enc.fit(house).transform(house).toarray()
+    #sc = MinMaxScaler()
+    #X = sc.fit_transform(X)
+    return np.array(X), np.array(y).reshape(len(y),)
+    
+
+ +
+
+
+ +
+
+
+
In [21]:
+
+
+
def MAPE(y_true, y_pred): 
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    return np.mean(np.abs((y_true - y_pred) / y_true))*100
+
+ +
+
+
+ +
+
+
+
In [22]:
+
+
+
from sklearn import linear_model
+from sklearn import svm
+reg = linear_model.LinearRegression()
+#reg = svm.SVR(kernel='rbf', C=8, gamma=5e-5)
+X, y = preprocessing(df)
+reg.fit(X, y)
+
+ +
+
+
+ +
+
+ + +
+ +
Out[22]:
+ + + + +
+
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)
+
+ +
+ +
+
+ +
+
+
+
In [23]:
+
+
+
dft = pd.read_csv('../../data/test_dataset_500.csv')
+Xt, yt = preprocessing(dft)
+
+ +
+
+
+ +
+
+
+
In [24]:
+
+
+
MAPE(yt, reg.predict(Xt))
+
+ +
+
+
+ +
+
+ + +
+ +
Out[24]:
+ + + + +
+
14.450698807918974
+
+ +
+ +
+
+ +
+
+
+
In [25]:
+
+
+
def individual(houseId, df=df):
+    X = df[['House','Month','Temperature','Daylight']]
+    X = X[X.House==houseId].drop(columns=['House'])
+    y = df[['House','EnergyProduction']]
+    y = y[y.House==houseId].drop(columns=['House'])
+    return np.array(X), np.array(y)
+
+ +
+
+
+ +
+
+
+
In [52]:
+
+
+
# individual prognoses
+ireg = linear_model.LinearRegression()
+y_pred, y_true = [],[]
+with open('predicted_energy_production.csv','w') as f:
+    f.write('House, EnergyProduction\n')
+    for i in set(dft.House.values):
+        x,y = individual(i)
+        ireg.fit(x,y)
+        p = ireg.predict(individual(i,dft)[0])[0][0]
+        y_pred.append(p)
+        y_true.append((individual(i,dft)[1])[0][0])
+        f.write('{}, {}\n'.format(i,p))
+with open('mape.txt','w') as f:
+    f.write(str(MAPE(y_true, y_pred)))
+
+ +
+
+
+ +
+
+
+
In [27]:
+
+
+
# neural network
+
+ +
+
+
+ +
+
+
+
In [29]:
+
+
+
from keras.models import Sequential
+from keras.layers import Dense, Dropout, Activation
+
+ +
+
+
+ +
+
+
+
In [40]:
+
+
+
model = Sequential()
+model.add(Dense(units=40, activation='relu', input_dim=4))
+model.add(Dense(units=20, activation='relu'))
+model.add(Dense(1))
+model.compile(optimizer='adam',
+              loss='mse',
+              metrics=['mape'])
+
+X, y = preprocessing(df)
+model.fit(X, y, epochs=12, verbose=3)
+
+Xt, yt = preprocessing(dft)
+model.evaluate(Xt, yt)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Epoch 1/12
+Epoch 2/12
+Epoch 3/12
+Epoch 4/12
+Epoch 5/12
+Epoch 6/12
+Epoch 7/12
+Epoch 8/12
+Epoch 9/12
+Epoch 10/12
+Epoch 11/12
+Epoch 12/12
+500/500 [==============================] - 0s 138us/step
+
+
+
+ +
+ +
Out[40]:
+ + + + +
+
[21690.6206796875, 17.908103942871094]
+
+ +
+ +
+
+ +
+
+
+
In [787]:
+
+
+
#LTSE
+
+ +
+
+
+ +
+
+
+ + + + + + diff --git a/challenge1/analysis/tur/ch1.ipynb b/challenge1/analysis/tur/ch1.ipynb new file mode 100644 index 000000000..2dd82fa2a --- /dev/null +++ b/challenge1/analysis/tur/ch1.ipynb @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "df = pd.read_csv('../../data/training_dataset_500.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HouseYearMonthTemperatureDaylightEnergyProduction
House1.000000e+000.000000-1.816873e-180.0008810.001583-0.008303
Year0.000000e+001.000000-6.340757e-01-0.3568000.5246030.267481
Month-1.816873e-18-0.6340761.000000e+000.353837-0.276307-0.232748
Temperature8.810764e-04-0.3568003.538369e-011.000000-0.0533630.272789
Daylight1.582656e-030.524603-2.763068e-01-0.0533631.0000000.531577
EnergyProduction-8.302696e-030.267481-2.327484e-010.2727890.5315771.000000
\n", + "
" + ], + "text/plain": [ + " House Year Month Temperature Daylight \\\n", + "House 1.000000e+00 0.000000 -1.816873e-18 0.000881 0.001583 \n", + "Year 0.000000e+00 1.000000 -6.340757e-01 -0.356800 0.524603 \n", + "Month -1.816873e-18 -0.634076 1.000000e+00 0.353837 -0.276307 \n", + "Temperature 8.810764e-04 -0.356800 3.538369e-01 1.000000 -0.053363 \n", + "Daylight 1.582656e-03 0.524603 -2.763068e-01 -0.053363 1.000000 \n", + "EnergyProduction -8.302696e-03 0.267481 -2.327484e-01 0.272789 0.531577 \n", + "\n", + " EnergyProduction \n", + "House -0.008303 \n", + "Year 0.267481 \n", + "Month -0.232748 \n", + "Temperature 0.272789 \n", + "Daylight 0.531577 \n", + "EnergyProduction 1.000000 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import PolynomialFeatures, LabelEncoder, MinMaxScaler\n", + "df = df.drop(columns=['ID','Label'])\n", + "#df = df[df.Month.isin([4,5,6,7,8])]\n", + "df.corr()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocessing(df):\n", + " #from keras.utils import np_utils\n", + " X = df[['House','Month','Temperature','Daylight']]\n", + " #X = X[X.Month.isin([4,5,6,7,8])]\n", + " y = df[['EnergyProduction']]\n", + " #enc = LabelEncoder()\n", + " #house = X.House.values.reshape(-1,1)\n", + " #X['House'] = enc.fit(house).transform(house).toarray()\n", + " #sc = MinMaxScaler()\n", + " #X = sc.fit_transform(X)\n", + " return np.array(X), np.array(y).reshape(len(y),)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def MAPE(y_true, y_pred): \n", + " y_true, y_pred = np.array(y_true), np.array(y_pred)\n", + " return np.mean(np.abs((y_true - y_pred) / y_true))*100" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import linear_model\n", + "from sklearn import svm\n", + "reg = linear_model.LinearRegression()\n", + "#reg = svm.SVR(kernel='rbf', C=8, gamma=5e-5)\n", + "X, y = preprocessing(df)\n", + "reg.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "dft = pd.read_csv('../../data/test_dataset_500.csv')\n", + "Xt, yt = preprocessing(dft)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14.450698807918974" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MAPE(yt, reg.predict(Xt))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def individual(houseId, df=df):\n", + " X = df[['House','Month','Temperature','Daylight']]\n", + " X = X[X.House==houseId].drop(columns=['House'])\n", + " y = df[['House','EnergyProduction']]\n", + " y = y[y.House==houseId].drop(columns=['House'])\n", + " return np.array(X), np.array(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "# individual prognoses\n", + "ireg = linear_model.LinearRegression()\n", + "y_pred, y_true = [],[]\n", + "with open('predicted_energy_production.csv','w') as f:\n", + " f.write('House, EnergyProduction\\n')\n", + " for i in set(dft.House.values):\n", + " x,y = individual(i)\n", + " ireg.fit(x,y)\n", + " p = ireg.predict(individual(i,dft)[0])[0][0]\n", + " y_pred.append(p)\n", + " y_true.append((individual(i,dft)[1])[0][0])\n", + " f.write('{}, {}\\n'.format(i,p))\n", + "with open('mape.txt','w') as f:\n", + " f.write(str(MAPE(y_true, y_pred)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# neural network" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from keras.models import Sequential\n", + "from keras.layers import Dense, Dropout, Activation" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/12\n", + "Epoch 2/12\n", + "Epoch 3/12\n", + "Epoch 4/12\n", + "Epoch 5/12\n", + "Epoch 6/12\n", + "Epoch 7/12\n", + "Epoch 8/12\n", + "Epoch 9/12\n", + "Epoch 10/12\n", + "Epoch 11/12\n", + "Epoch 12/12\n", + "500/500 [==============================] - 0s 138us/step\n" + ] + }, + { + "data": { + "text/plain": [ + "[21690.6206796875, 17.908103942871094]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = Sequential()\n", + "model.add(Dense(units=40, activation='relu', input_dim=4))\n", + "model.add(Dense(units=20, activation='relu'))\n", + "model.add(Dense(1))\n", + "model.compile(optimizer='adam',\n", + " loss='mse',\n", + " metrics=['mape'])\n", + "\n", + "X, y = preprocessing(df)\n", + "model.fit(X, y, epochs=12, verbose=3)\n", + "\n", + "Xt, yt = preprocessing(dft)\n", + "model.evaluate(Xt, yt)" + ] + }, + { + "cell_type": "code", + "execution_count": 787, + "metadata": {}, + "outputs": [], + "source": [ + "#LTSE" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/challenge1/analysis/tur/ch1.pdf b/challenge1/analysis/tur/ch1.pdf new file mode 100644 index 000000000..d4ab185c8 Binary files /dev/null and b/challenge1/analysis/tur/ch1.pdf differ diff --git a/challenge1/analysis/tur/mape.txt b/challenge1/analysis/tur/mape.txt new file mode 100644 index 000000000..c01ef14f9 --- /dev/null +++ b/challenge1/analysis/tur/mape.txt @@ -0,0 +1 @@ +7.955755908782016 \ No newline at end of file diff --git a/challenge1/analysis/tur/predicted_energy_production.csv b/challenge1/analysis/tur/predicted_energy_production.csv new file mode 100644 index 000000000..4893024cc --- /dev/null +++ b/challenge1/analysis/tur/predicted_energy_production.csv @@ -0,0 +1,501 @@ +House, EnergyProduction +1, 687.0174261575678 +2, 530.3444190625836 +3, 590.8002375607111 +4, 453.8176939437037 +5, 453.8176939437037 +6, 632.6977799064587 +7, 619.1590327350106 +8, 557.6035213567822 +9, 447.4445690000405 +10, 468.52501322175533 +11, 468.52501322175533 +12, 632.6977799064587 +13, 552.994400490235 +14, 468.52501322175533 +15, 687.0174261575678 +16, 530.3444190625836 +17, 570.683232629798 +18, 526.0472289246759 +19, 530.3444190625836 +20, 468.4281746926613 +21, 604.5579768651442 +22, 557.6035213567822 +23, 466.34944741029875 +24, 632.6977799064587 +25, 466.34944741029875 +26, 610.4350665050231 +27, 619.1590327350106 +28, 658.2059382829704 +29, 530.3444190625836 +30, 520.5252635362156 +31, 658.2059382829704 +32, 520.5252635362156 +33, 658.2059382829704 +34, 428.96705163894575 +35, 428.96705163894575 +36, 552.994400490235 +37, 590.8002375607111 +38, 619.1590327350106 +39, 526.0472289246759 +40, 590.8002375607111 +41, 520.5252635362156 +42, 466.34944741029875 +43, 604.5579768651442 +44, 590.8002375607111 +45, 610.4350665050231 +46, 454.5619513742437 +47, 468.52501322175533 +48, 466.34944741029875 +49, 468.52501322175533 +50, 610.4350665050231 +51, 468.52501322175533 +52, 604.5579768651442 +53, 530.3444190625836 +54, 447.4445690000405 +55, 590.8002375607111 +56, 466.34944741029875 +57, 502.413662522524 +58, 519.4788140842029 +59, 530.3444190625836 +60, 658.2059382829704 +61, 600.0757343407197 +62, 520.5252635362156 +63, 632.6977799064587 +64, 468.52501322175533 +65, 447.4445690000405 +66, 552.994400490235 +67, 687.0174261575678 +68, 520.5252635362156 +69, 468.4281746926613 +70, 552.994400490235 +71, 468.4281746926613 +72, 570.683232629798 +73, 454.5619513742437 +74, 502.413662522524 +75, 519.4788140842029 +76, 530.3444190625836 +77, 632.6977799064587 +78, 519.4788140842029 +79, 468.4281746926613 +80, 519.4788140842029 +81, 687.0174261575678 +82, 632.6977799064587 +83, 530.3444190625836 +84, 530.3444190625836 +85, 600.0757343407197 +86, 773.0362154359623 +87, 468.52501322175533 +88, 468.52501322175533 +89, 471.12374438217637 +90, 632.6977799064587 +91, 552.994400490235 +92, 453.8176939437037 +93, 453.8176939437037 +94, 658.2059382829704 +95, 610.4350665050231 +96, 773.0362154359623 +97, 468.4281746926613 +98, 428.96705163894575 +99, 447.4445690000405 +100, 519.4788140842029 +101, 526.0472289246759 +102, 467.36728762210385 +103, 604.5579768651442 +104, 590.8002375607111 +105, 570.683232629798 +106, 658.2059382829704 +107, 468.4281746926613 +108, 447.4445690000405 +109, 773.0362154359623 +110, 687.0174261575678 +111, 453.8176939437037 +112, 557.6035213567822 +113, 447.4445690000405 +114, 530.3444190625836 +115, 467.36728762210385 +116, 466.34944741029875 +117, 471.12374438217637 +118, 632.6977799064587 +119, 453.8176939437037 +120, 453.8176939437037 +121, 548.1147135882954 +122, 604.5579768651442 +123, 520.5252635362156 +124, 570.683232629798 +125, 557.6035213567822 +126, 502.413662522524 +127, 447.4445690000405 +128, 619.1590327350106 +129, 557.6035213567822 +130, 530.3444190625836 +131, 548.1147135882954 +132, 604.5579768651442 +133, 502.413662522524 +134, 519.4788140842029 +135, 552.994400490235 +136, 548.1147135882954 +137, 466.34944741029875 +138, 453.8176939437037 +139, 600.0757343407197 +140, 502.413662522524 +141, 619.1590327350106 +142, 520.5252635362156 +143, 468.4281746926613 +144, 526.0472289246759 +145, 552.994400490235 +146, 526.0472289246759 +147, 548.1147135882954 +148, 468.4281746926613 +149, 519.4788140842029 +150, 548.1147135882954 +151, 557.6035213567822 +152, 773.0362154359623 +153, 610.4350665050231 +154, 519.4788140842029 +155, 466.34944741029875 +156, 463.44905890683685 +157, 530.3444190625836 +158, 552.994400490235 +159, 454.5619513742437 +160, 773.0362154359623 +161, 658.2059382829704 +162, 447.4445690000405 +163, 570.683232629798 +164, 467.36728762210385 +165, 468.4281746926613 +166, 604.5579768651442 +167, 447.4445690000405 +168, 467.36728762210385 +169, 552.994400490235 +170, 557.6035213567822 +171, 548.1147135882954 +172, 471.12374438217637 +173, 632.6977799064587 +174, 658.2059382829704 +175, 468.52501322175533 +176, 466.34944741029875 +177, 687.0174261575678 +178, 519.4788140842029 +179, 658.2059382829704 +180, 519.4788140842029 +181, 530.3444190625836 +182, 548.1147135882954 +183, 502.413662522524 +184, 610.4350665050231 +185, 687.0174261575678 +186, 454.5619513742437 +187, 658.2059382829704 +188, 526.0472289246759 +189, 590.8002375607111 +190, 687.0174261575678 +191, 519.4788140842029 +192, 590.8002375607111 +193, 530.3444190625836 +194, 502.413662522524 +195, 619.1590327350106 +196, 548.1147135882954 +197, 468.4281746926613 +198, 466.34944741029875 +199, 526.0472289246759 +200, 619.1590327350106 +201, 447.4445690000405 +202, 468.4281746926613 +203, 453.8176939437037 +204, 557.6035213567822 +205, 557.6035213567822 +206, 468.52501322175533 +207, 467.36728762210385 +208, 619.1590327350106 +209, 463.44905890683685 +210, 590.8002375607111 +211, 466.34944741029875 +212, 687.0174261575678 +213, 467.36728762210385 +214, 447.4445690000405 +215, 604.5579768651442 +216, 454.5619513742437 +217, 454.5619513742437 +218, 519.4788140842029 +219, 468.52501322175533 +220, 468.52501322175533 +221, 658.2059382829704 +222, 619.1590327350106 +223, 557.6035213567822 +224, 454.5619513742437 +225, 526.0472289246759 +226, 468.4281746926613 +227, 463.44905890683685 +228, 520.5252635362156 +229, 471.12374438217637 +230, 658.2059382829704 +231, 453.8176939437037 +232, 530.3444190625836 +233, 520.5252635362156 +234, 610.4350665050231 +235, 520.5252635362156 +236, 590.8002375607111 +237, 447.4445690000405 +238, 428.96705163894575 +239, 526.0472289246759 +240, 447.4445690000405 +241, 468.52501322175533 +242, 453.8176939437037 +243, 526.0472289246759 +244, 468.4281746926613 +245, 467.36728762210385 +246, 454.5619513742437 +247, 519.4788140842029 +248, 557.6035213567822 +249, 548.1147135882954 +250, 520.5252635362156 +251, 557.6035213567822 +252, 467.36728762210385 +253, 520.5252635362156 +254, 520.5252635362156 +255, 468.52501322175533 +256, 570.683232629798 +257, 526.0472289246759 +258, 604.5579768651442 +259, 467.36728762210385 +260, 557.6035213567822 +261, 447.4445690000405 +262, 687.0174261575678 +263, 463.44905890683685 +264, 468.52501322175533 +265, 590.8002375607111 +266, 590.8002375607111 +267, 468.52501322175533 +268, 468.52501322175533 +269, 548.1147135882954 +270, 468.52501322175533 +271, 619.1590327350106 +272, 658.2059382829704 +273, 552.994400490235 +274, 468.52501322175533 +275, 463.44905890683685 +276, 557.6035213567822 +277, 773.0362154359623 +278, 552.994400490235 +279, 520.5252635362156 +280, 590.8002375607111 +281, 687.0174261575678 +282, 530.3444190625836 +283, 610.4350665050231 +284, 520.5252635362156 +285, 447.4445690000405 +286, 548.1147135882954 +287, 463.44905890683685 +288, 520.5252635362156 +289, 658.2059382829704 +290, 604.5579768651442 +291, 590.8002375607111 +292, 453.8176939437037 +293, 454.5619513742437 +294, 466.34944741029875 +295, 552.994400490235 +296, 468.52501322175533 +297, 502.413662522524 +298, 428.96705163894575 +299, 610.4350665050231 +300, 600.0757343407197 +301, 471.12374438217637 +302, 468.4281746926613 +303, 557.6035213567822 +304, 590.8002375607111 +305, 548.1147135882954 +306, 552.994400490235 +307, 530.3444190625836 +308, 552.994400490235 +309, 467.36728762210385 +310, 471.12374438217637 +311, 557.6035213567822 +312, 447.4445690000405 +313, 619.1590327350106 +314, 632.6977799064587 +315, 600.0757343407197 +316, 447.4445690000405 +317, 600.0757343407197 +318, 600.0757343407197 +319, 600.0757343407197 +320, 471.12374438217637 +321, 467.36728762210385 +322, 502.413662522524 +323, 502.413662522524 +324, 530.3444190625836 +325, 619.1590327350106 +326, 519.4788140842029 +327, 552.994400490235 +328, 526.0472289246759 +329, 600.0757343407197 +330, 520.5252635362156 +331, 632.6977799064587 +332, 468.52501322175533 +333, 658.2059382829704 +334, 610.4350665050231 +335, 468.4281746926613 +336, 530.3444190625836 +337, 548.1147135882954 +338, 687.0174261575678 +339, 600.0757343407197 +340, 619.1590327350106 +341, 687.0174261575678 +342, 658.2059382829704 +343, 520.5252635362156 +344, 453.8176939437037 +345, 468.4281746926613 +346, 453.8176939437037 +347, 570.683232629798 +348, 658.2059382829704 +349, 428.96705163894575 +350, 604.5579768651442 +351, 590.8002375607111 +352, 466.34944741029875 +353, 570.683232629798 +354, 520.5252635362156 +355, 600.0757343407197 +356, 502.413662522524 +357, 463.44905890683685 +358, 502.413662522524 +359, 463.44905890683685 +360, 658.2059382829704 +361, 468.4281746926613 +362, 590.8002375607111 +363, 600.0757343407197 +364, 610.4350665050231 +365, 773.0362154359623 +366, 610.4350665050231 +367, 468.4281746926613 +368, 468.52501322175533 +369, 467.36728762210385 +370, 526.0472289246759 +371, 590.8002375607111 +372, 530.3444190625836 +373, 526.0472289246759 +374, 604.5579768651442 +375, 632.6977799064587 +376, 604.5579768651442 +377, 502.413662522524 +378, 600.0757343407197 +379, 468.52501322175533 +380, 520.5252635362156 +381, 590.8002375607111 +382, 619.1590327350106 +383, 466.34944741029875 +384, 604.5579768651442 +385, 570.683232629798 +386, 687.0174261575678 +387, 552.994400490235 +388, 619.1590327350106 +389, 610.4350665050231 +390, 454.5619513742437 +391, 687.0174261575678 +392, 557.6035213567822 +393, 619.1590327350106 +394, 428.96705163894575 +395, 773.0362154359623 +396, 530.3444190625836 +397, 428.96705163894575 +398, 447.4445690000405 +399, 590.8002375607111 +400, 454.5619513742437 +401, 530.3444190625836 +402, 468.52501322175533 +403, 552.994400490235 +404, 530.3444190625836 +405, 530.3444190625836 +406, 453.8176939437037 +407, 632.6977799064587 +408, 604.5579768651442 +409, 610.4350665050231 +410, 453.8176939437037 +411, 619.1590327350106 +412, 502.413662522524 +413, 600.0757343407197 +414, 548.1147135882954 +415, 502.413662522524 +416, 519.4788140842029 +417, 590.8002375607111 +418, 548.1147135882954 +419, 604.5579768651442 +420, 520.5252635362156 +421, 502.413662522524 +422, 604.5579768651442 +423, 590.8002375607111 +424, 468.52501322175533 +425, 468.4281746926613 +426, 632.6977799064587 +427, 610.4350665050231 +428, 454.5619513742437 +429, 454.5619513742437 +430, 520.5252635362156 +431, 557.6035213567822 +432, 447.4445690000405 +433, 570.683232629798 +434, 619.1590327350106 +435, 454.5619513742437 +436, 453.8176939437037 +437, 600.0757343407197 +438, 463.44905890683685 +439, 463.44905890683685 +440, 428.96705163894575 +441, 463.44905890683685 +442, 557.6035213567822 +443, 773.0362154359623 +444, 471.12374438217637 +445, 502.413662522524 +446, 454.5619513742437 +447, 687.0174261575678 +448, 570.683232629798 +449, 471.12374438217637 +450, 428.96705163894575 +451, 454.5619513742437 +452, 530.3444190625836 +453, 604.5579768651442 +454, 658.2059382829704 +455, 502.413662522524 +456, 519.4788140842029 +457, 600.0757343407197 +458, 658.2059382829704 +459, 610.4350665050231 +460, 454.5619513742437 +461, 687.0174261575678 +462, 466.34944741029875 +463, 468.52501322175533 +464, 453.8176939437037 +465, 530.3444190625836 +466, 467.36728762210385 +467, 552.994400490235 +468, 548.1147135882954 +469, 463.44905890683685 +470, 519.4788140842029 +471, 658.2059382829704 +472, 453.8176939437037 +473, 466.34944741029875 +474, 428.96705163894575 +475, 454.5619513742437 +476, 548.1147135882954 +477, 604.5579768651442 +478, 548.1147135882954 +479, 471.12374438217637 +480, 502.413662522524 +481, 447.4445690000405 +482, 502.413662522524 +483, 466.34944741029875 +484, 526.0472289246759 +485, 610.4350665050231 +486, 557.6035213567822 +487, 530.3444190625836 +488, 502.413662522524 +489, 557.6035213567822 +490, 428.96705163894575 +491, 519.4788140842029 +492, 632.6977799064587 +493, 658.2059382829704 +494, 453.8176939437037 +495, 468.52501322175533 +496, 463.44905890683685 +497, 600.0757343407197 +498, 619.1590327350106 +499, 590.8002375607111 +500, 570.683232629798 diff --git a/challenge1/analysis/tur/readme.md b/challenge1/analysis/tur/readme.md new file mode 100644 index 000000000..10b972516 --- /dev/null +++ b/challenge1/analysis/tur/readme.md @@ -0,0 +1 @@ +by Will Turbayevsky; it's a little tricky because I used three methods and the best result (expectedly) show the model with limited number of month and to be trained for each house respectively; LSTM will show better result, if needed will extend it diff --git a/challenge2/analysis/tur/30min.png b/challenge2/analysis/tur/30min.png new file mode 100644 index 000000000..7247c6647 Binary files /dev/null and b/challenge2/analysis/tur/30min.png differ diff --git a/challenge2/analysis/tur/ch2.html b/challenge2/analysis/tur/ch2.html new file mode 100644 index 000000000..c9bb55afd --- /dev/null +++ b/challenge2/analysis/tur/ch2.html @@ -0,0 +1,13356 @@ + + + + +ch2 + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
In [1]:
+
+
+
import pandas as pd
+
+ +
+
+
+ +
+
+
+
In [21]:
+
+
+
df = pd.read_csv('../../data/total_watt.csv', header=None)
+df.columns=['datetime','consumption']
+df = df.set_index('datetime')
+
+ +
+
+
+ +
+
+
+
In [35]:
+
+
+
%matplotlib inline
+plt.figure()
+df.plot(title='Energy Consumption for every 30 min', figsize=(16, 6))
+plt.xticks(rotation=30)
+plt.ylabel('Energy Consumption, W')
+plt.xlabel('Date')
+
+ +
+
+
+ +
+
+ + +
+ +
Out[35]:
+ + + + +
+
Text(0.5, 0, 'Date')
+
+ +
+ +
+ +
+ + + + +
+
<Figure size 432x288 with 0 Axes>
+
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
In [87]:
+
+
+
import datetime as dt
+df = pd.read_csv('../../data/total_watt.csv', header=None, parse_dates=[0], \
+                 date_parser=lambda x: pd.datetime.strptime(x, '%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%d'))
+df.columns=['datetime','consumption']
+plt.figure()
+df = df.groupby(by=df.datetime.dt.date).sum()
+df.plot.bar(title='Energy Consumption per day', figsize=(16, 6))
+plt.xticks(rotation=30)
+plt.ylabel('Energy Consumption, W')
+plt.xlabel('Date')
+
+ +
+
+
+ +
+
+ + +
+ +
Out[87]:
+ + + + +
+
Text(0.5, 0, 'Date')
+
+ +
+ +
+ +
+ + + + +
+
<Figure size 432x288 with 0 Axes>
+
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
In [143]:
+
+
+
# Plot clusters
+labels = KMeans(3, random_state=0).fit_predict(df)
+plt.figure()
+plt.scatter(df.index, df.consumption, c=labels, s=50, cmap='viridis')
+plt.title('Clustering Energy Consumption')
+plt.figsize=(16, 6)
+plt.xticks(rotation=30)
+plt.ylabel('Energy Consumption, W')
+plt.xlabel('Date')
+
+ +
+
+
+ +
+
+ + +
+ +
Out[143]:
+ + + + +
+
Text(0.5, 0, 'Date')
+
+ +
+ +
+ +
+ + + + +
+ +
+ +
+ +
+
+ +
+
+
+
In [ ]:
+
+
+
 
+
+ +
+
+
+ +
+
+
+ + + + + + diff --git a/challenge2/analysis/tur/ch2.ipynb b/challenge2/analysis/tur/ch2.ipynb new file mode 100644 index 000000000..a1f915ee4 --- /dev/null +++ b/challenge2/analysis/tur/ch2.ipynb @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv('../../data/total_watt.csv', header=None)\n", + "df.columns=['datetime','consumption']\n", + "df = df.set_index('datetime')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Date')" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "plt.figure()\n", + "df.plot(title='Energy Consumption for every 30 min', figsize=(16, 6))\n", + "plt.xticks(rotation=30)\n", + "plt.ylabel('Energy Consumption, W')\n", + "plt.xlabel('Date')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Date')" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import datetime as dt\n", + "df = pd.read_csv('../../data/total_watt.csv', header=None, parse_dates=[0], \\\n", + " date_parser=lambda x: pd.datetime.strptime(x, '%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%d'))\n", + "df.columns=['datetime','consumption']\n", + "plt.figure()\n", + "df = df.groupby(by=df.datetime.dt.date).sum()\n", + "df.plot.bar(title='Energy Consumption per day', figsize=(16, 6))\n", + "plt.xticks(rotation=30)\n", + "plt.ylabel('Energy Consumption, W')\n", + "plt.xlabel('Date')" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Date')" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot clusters\n", + "labels = KMeans(3, random_state=0).fit_predict(df)\n", + "plt.figure()\n", + "plt.scatter(df.index, df.consumption, c=labels, s=50, cmap='viridis')\n", + "plt.title('Clustering Energy Consumption')\n", + "plt.figsize=(16, 6)\n", + "plt.xticks(rotation=30)\n", + "plt.ylabel('Energy Consumption, W')\n", + "plt.xlabel('Date')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/challenge2/analysis/tur/clusters.png b/challenge2/analysis/tur/clusters.png new file mode 100644 index 000000000..9980596e1 Binary files /dev/null and b/challenge2/analysis/tur/clusters.png differ diff --git a/challenge2/analysis/tur/dayly.png b/challenge2/analysis/tur/dayly.png new file mode 100644 index 000000000..eca1df2a6 Binary files /dev/null and b/challenge2/analysis/tur/dayly.png differ diff --git a/challenge2/analysis/tur/readme.md b/challenge2/analysis/tur/readme.md new file mode 100644 index 000000000..76a42d758 --- /dev/null +++ b/challenge2/analysis/tur/readme.md @@ -0,0 +1 @@ +made pretty simple charts because using of the ggplot in pandas and matplotlib is easiest way; personally, I do prefer ggplot, plotly and seaborn diff --git a/challenge3/webapp/tur/readme.md b/challenge3/webapp/tur/readme.md new file mode 100644 index 000000000..273bbbc9a --- /dev/null +++ b/challenge3/webapp/tur/readme.md @@ -0,0 +1,2 @@ +http://18.223.15.140:8000/energySimulator/default/index +I have added very simple chart only - do prefer using google charts instead diff --git a/challenge3/webapp/tur/web2py.app.energySimulator.w2p b/challenge3/webapp/tur/web2py.app.energySimulator.w2p new file mode 100644 index 000000000..20be321fe Binary files /dev/null and b/challenge3/webapp/tur/web2py.app.energySimulator.w2p differ diff --git a/challenge4/webapp/tur/readme.md b/challenge4/webapp/tur/readme.md new file mode 100644 index 000000000..dc107dd3c --- /dev/null +++ b/challenge4/webapp/tur/readme.md @@ -0,0 +1,17 @@ +http://18.223.15.140:8000/energySimulator/default/index + +the code is the same as in challenge 4 + +Two different APIs created: +1. http://18.223.15.140:8000/energySimulator/default/form - you can upload input and plan files and see the result at the screen; files will be added to 'uploads' directory and accessible by link in the DB + +2.a. GET http://18.223.15.140:8000/energySimulator/default/api/1.json?raw=No to calculate baseing on link 1 in the DB + +2.b. GET http://18.223.15.140:8000/energySimulator/default/api/4.json?raw=raw to calculate using raw data (id=4) from DB + +3 POST in format + +payload = {'plan': p, 'input': c} +r = requests.post("http://127.0.0.1:8000/energySimulator/default/api/tarif.json", data=payload) + +to add raw data into DB diff --git a/challenge4/webapp/tur/web2py.app.energySimulator.w2p b/challenge4/webapp/tur/web2py.app.energySimulator.w2p new file mode 100644 index 000000000..20be321fe Binary files /dev/null and b/challenge4/webapp/tur/web2py.app.energySimulator.w2p differ