intiial commit

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+# Set home to the user's home directory
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user ./app $HOME/app
+
+
+ENV DASH_DEBUG_MODE False
+#COPY ./app /app
+#WORKDIR /app
+RUN set -ex && \
+    pip install -r requirements.txt
+EXPOSE 8050
+CMD ["gunicorn", "-b", "0.0.0.0:8050", "--reload", "app:server"]

Dockerfile.dev

@@ -0,0 +1,9 @@
+FROM python:3.10
+
+ENV DASH_DEBUG_MODE True
+COPY ./app /app
+WORKDIR /app
+RUN set -ex && \
+    pip install -r requirements.txt
+EXPOSE 8050
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Jucy Technologies, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,11 +1,50 @@
 ---
-title: Smart Shower ATC
-emoji: 📊
-colorFrom: pink
+title: Smart Shower Dashboard
+emoji: 📈
+colorFrom: purple
 colorTo: gray
 sdk: docker
-pinned: false
-license: mit
+app_port: 8050
 ---
+# Docker Dash (Plotly)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Dockerize a Python Dash app for quick prototyping.
+
+## Build and run
+
+`prod` version is served by `gunicorn` instead of the `flask` dev server.
+
+```sh
+# dev
+docker build -f Dockerfile.dev -t docker-dash-example-dev .
+docker run -p 8050:8050 -v "$(pwd)"/app:/app --rm docker-dash-example-dev
+
+# prod
+docker build -f Dockerfile -t docker-dash-example-prod .
+docker run -p 8050:8050 -v "$(pwd)"/app:/app --rm docker-dash-example-prod
+```
+
+## Access the page
+
+Go to `http://localhost:8050` in browser.
+
+## Switch debug mode in Dockerfile
+
+```dockerfile
+ENV DASH_DEBUG_MODE True # False
+```
+
+## Development
+
+Install the app requirements for development to get better editor support.
+
+```sh
+poetry install
+```
+
+Optional: clean initialization of `poetry`:
+
+```sh
+poetry init
+cat app/requirements.txt | xargs poetry add
+```

app/app.py

@@ -0,0 +1,228 @@
+import os
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+from dash import Dash, html, dcc, Input, Output, callback
+import plotly.express as px
+import numpy as np
+import example_data
+import core
+
+
+outside_temp = example_data.ExampleDailyOutsideTemperature
+energy_price = example_data.ExampleDailyEnergyCost
+boiler_temperature = example_data.ExampleBoilerTemperature
+
+
+
+data = pd.DataFrame(columns=['hour', 'energy_consumption', 'confort', 'policy_readable'])
+data = pd.concat([data, pd.DataFrame({'hour': np.arange(0, 24), 'energy_consumption': energy_price.value, 'confort': np.random.rand(24),
+                                       'policy_readable': np.random.choice(['A', 'B', 'C', 'D', 'E'], 24)
+                                       })])
+debug = False
+
+
+external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
+
+app = Dash(__name__, external_stylesheets=external_stylesheets)
+
+app.layout = html.Div([
+    dcc.Location(id='url', refresh=False),
+    html.Div(id='page-content')
+])
+
+server = app.server
+
+
+# SOlution options
+solution_options = [
+    "Discrete Optimization",
+    "Continuous Optimization",
+    "Reinforcement Learning"
+]
+solution_options_default_value = solution_options[0]
+
+# provide a scalar value to enable the slider to select ideal temperature
+ideal_temperature = 50
+
+dashboard_layout =  html.Div([
+    dcc.Link('About this project', href='/wiki'),
+
+    html.H1('System Evaluation'),
+    #small subtitle that says of solution is possible or not
+    html.Div(id='solution-status', children='', style={'color': 'lighrgrey'}),
+    html.Div([
+        html.Div([
+                    html.H3('Solution'),
+                    dcc.Dropdown(
+                        id='solution-dropdown',
+                        options=solution_options,
+                        value=solution_options_default_value,
+                    )
+                ], className='three columns'),
+        html.Div([
+                    html.H3('Ideal Shower Temperature'),
+                    dcc.Slider(
+                        id='ideal-temperature-slider',
+                        min=0,
+                        max=100,
+                        step=1,
+                        value=ideal_temperature,
+                        marks={
+                            0: '0°C',
+                            25: '25°C',
+                            50: '50°C',
+                            75: '75°C',
+                            100: '100°C'
+                        },
+                    )
+                ], className='three columns'),
+
+
+    ], className='row'),
+    html.Div(
+        [
+            html.Div(
+                [
+                    html.H3('Policy'),
+                    dcc.Graph(id='policy_readable-graph')
+                ], className='six columns',
+            ),
+            html.Div(
+                [
+                    html.H3('Energy Consumption'),
+                    dcc.Graph(id='energy-comsumption-graph')
+                ], className='six columns'
+            )
+    ], className='row'),
+    html.Div(
+        [
+            html.Div(
+                [
+                    html.H3('Confort'),
+                    dcc.Graph(id='confort-graph')
+                ], className='six columns'
+            )
+    ], className='row'),
+],
+#add background image from local file and make it transparent
+#, style={'background-image':'url(/assets/background_1.png)'}
+style={'background-color': '#4B5320', 'font-family': 'Fantasy', 'color': '#8F9779', 'padding': '10px'}
+)
+
+
+
+wiki_layout = html.Div([
+    dcc.Link('Dashboard', href='/'),
+
+    html.H1('About this project'),
+
+    html.Div([
+        html.Div([
+                    
+                    html.H3('What is this project about?'),
+
+                    html.P('This project is a simulation of a shower system. The goal is to find the best policy for the boiler to heat the water for the shower. The policy is a function that takes the current hour of the day and the current temperature of the water in the boiler and returns the temperature that the boiler should heat the water to.'),
+                    html.P('The best policy is the one that maximizes the confort of the shower and minimizes the energy consumption of the boiler.'),
+
+                    html.H3('How does it work?'),
+
+                    #Insert image of the system
+
+                    html.H3('\'Bout us'),
+                    html.Img(src='/assets/hackatos.png', style={'width': '40%', 'height': 'auto', 'display': 'block', 'margin-left': 'auto', 'margin-right': 'auto'}),
+                    html.P('This project was developed by a team of 3, in the context of the Aveiro Tech City 2023 hackathon.'),
+                    html.P('The team members are:'),
+                    html.H4('Rui Melo'),
+                    html.P('Rui Melo is a ....'),
+                    html.H4('André Catarino'),
+                    html.P('André Catarino is a ....'),
+                    html.H4('Francisco Petronilho'),
+                    html.P('Francisco Petronilho is a ....'),
+                    html.H4('André Tomás'),
+                    html.P('André Tomás is a ....'),
+                    html.H4('Zé Miguel'),
+                    html.P('Zé Miguel is a ....'),
+
+
+                    html.H3('References'),
+                    html.P('The boiler model was based on the following paper:'),
+
+
+        ], className='six columns'),], className='row'),
+],
+style={'background-color': '#4B5320', 'font-family': 'Fantasy', 'color': '#8F9779', 'padding': '10px'}
+
+)
+
+# Update the index
+@callback(Output('page-content', 'children'), Input('url', 'pathname'))
+def display_page(pathname):
+    if pathname == '/':
+        return dashboard_layout
+    elif pathname == '/wiki':
+        return wiki_layout
+    else:
+        return '404'
+    # You could also return a 404 "URL not found" page here
+
+
+
+@app.callback(
+    Output('policy_readable-graph', 'figure'),
+    Output('energy-comsumption-graph', 'figure'),
+    Output('confort-graph', 'figure'),
+    Output('solution-status', 'children'),
+    Input('solution-dropdown', 'value'),
+    Input('ideal-temperature-slider', 'value')
+)
+def update_graph(solution, ideal_temperature):
+    energy_consumption = data['energy_consumption'].values
+    confort_obtained = data['confort'].values
+
+
+    policy_readable_graph = px.line(data, x='hour', y='policy_readable',
+                                    labels={'hour': 'Hour', 'policy_readable': 'Policy'},
+                                    color_discrete_sequence=['lightgreen'])
+    policy_readable_graph.update_layout(
+        xaxis_title="Hour",
+        yaxis_title="Temperature (°C)",
+        legend_title="Policy"
+    )
+
+    energy_consumption_graph = px.line(data, x='hour', 
+                                       y='energy_consumption', 
+                                       labels={'hour': 'Hour', 'energy_consumption': 'Energy Consumption (kWh)'},
+                                       color_discrete_sequence=['lightgreen'])
+    energy_consumption_graph.update_layout(
+        xaxis_title="Hour",
+        yaxis_title="Energy Consumption (kWh)",
+        legend_title="Energy Consumption",
+    )
+    #add accumulated energy consumption
+    energy_consumption = np.cumsum(energy_consumption)
+    energy_consumption_graph.add_trace(px.line(data, x='hour', 
+                                               y=energy_consumption,
+                                               labels={'y': 'Acc. Energy Consumption (kWh)'},
+                                                color_discrete_sequence=['green']).data[0])
+
+    confort_graph = px.line(data, x='hour', y='confort',
+                            labels={'hour': 'Hour', 'confort': 'Confort Score'},
+                            color_discrete_sequence=['lightgreen'])
+
+    confort_graph.update_layout(
+        xaxis_title="Hour",
+        yaxis_title="Confort Score",
+        legend_title="Confort"
+    )
+    #add accumulated confort
+    confort_obtained = np.cumsum(confort_obtained)
+    confort_graph.add_trace(px.line(data, x='hour', y=confort_obtained,
+                                    labels={'y': 'Acc. Confort Score'},
+                                    color_discrete_sequence=['green']
+                                    ).data[0])
+    result = "No solution found"
+    return policy_readable_graph, energy_consumption_graph, confort_graph, result
+if __name__ == "__main__":
+    app.run_server(host="0.0.0.0", port="8050", debug=debug)
+

app/core.py

@@ -0,0 +1,99 @@
+# Electric cost(Euros) = energy_price(Euros/kWh) * wasted_energy(kWh)
+def custo(energy_price_hour, wasted_energy):
+    return energy_price_hour * wasted_energy
+
+
+# caldeira 20 litros
+def spent_energy(
+    temperatura_inicial_caldeira_t,  # existente na cadeira, t sendo a hora
+    temperatura_objetivo_caldeira_t_plus_1,
+    outside_temp,
+    pressao_caldeira,
+    litros_gastos_no_banho=0,
+    temperatura_entrada_agua_na_caldeira=15,  # Temperatura ambiente da iNOVA
+    capacidade_caldeira=20,  # 20 litros
+):
+    # E = (4.2 kJ/kgoC) ((90 oC) - (20 oC)) (1000 liter) (1 kg/liter)
+    # cp = specific heat of water (kJ/kgoC, Btu/lb oF) (4.2 kJ/kgoC, 1 Btu/lbmoF for water)
+    heat_capacity = 4.2
+    # Energy =  heat_capacity * (temperatura_saida_agua_na_caldeira - outside_temp) * capacidade_caldeira * 1\
+    delta_t = temperatura_objetivo_caldeira_t_plus_1 - temperatura_inicial_caldeira_t
+
+    energy = (
+        heat_capacity
+        * (delta_t - outside_temp)
+        * (capacidade_caldeira - litros_gastos_no_banho)
+        * 1
+    )  # isto vai ser minimo
+
+    delta_t = (
+        temperatura_objetivo_caldeira_t_plus_1 - temperatura_entrada_agua_na_caldeira
+    )
+    energy_incoming_water = (
+        heat_capacity * (delta_t - outside_temp) * litros_gastos_no_banho * 1
+    )
+
+    # 20 Litros totais
+    # Joao gatou 5 litros
+    # Gastar energia em:
+    # 15 litros para manter a temperatura da caldeira -> minimo
+    # 5 litros para aquecer a agua que entra
+
+    total_energy = energy + energy_incoming_water
+
+    # TODO: Correlação entre pressão e temperatura
+    # https://www.engineeringtoolbox.com/boiling-points-water-altitude-d_1344.html
+    # https://www.engineeringtoolbox.com/boiling-point-water-d_926.html
+    """
+    That depends on whether the pressure is held constant during the heating. If there is a relief valve which maintains 
+    constant pressure as the water heats, then no, the 2 samples will heat at the same rate. However, if the pressurised sample 
+    has no pressure relief, then it will heat faster because the pressure will increase, and that increase in pressure will increase 
+    the heat in addition to the heat applied.
+    """
+    # kJ
+
+    # TODO: FIND WHAT SHOULD BE THE RELATION BETWEEN TEMPERATURE OF OUTGOING WATER AND BOILER TEMPERATURE
+    temperatura_saida_agua_na_caldeira = temperatura_objetivo_caldeira_t_plus_1 * 0.87
+
+    return total_energy, temperatura_saida_agua_na_caldeira
+
+
+def calculate_weights_for_all_hours(
+    temperatura_inicial_caldeira,
+    temperatura_objetivo_caldeira,
+    outside_temp,
+    pressao_caldeira,
+    litros_gastos_no_banho,
+    temperatura_entrada_agua_na_caldeira,
+    capacidade_caldeira,
+):
+    weights = []
+    temperatures = []
+    for i in range(len(temperatura_inicial_caldeira)):
+        energy, temperature_water = spent_energy(
+            temperatura_inicial_caldeira_t=temperatura_inicial_caldeira[i],
+            temperatura_objetivo_caldeira_t_plus_1=temperatura_objetivo_caldeira,
+            outside_temp=outside_temp[i],
+            pressao_caldeira=pressao_caldeira[i],
+            litros_gastos_no_banho=litros_gastos_no_banho,
+            temperatura_entrada_agua_na_caldeira=temperatura_entrada_agua_na_caldeira[
+                i
+            ],
+            capacidade_caldeira=capacidade_caldeira,
+        )
+        weights.append(energy)
+        temperatures.append(temperature_water)
+    return weights, temperatures
+    # Output energy wasted
+
+
+def calculate_confort(temperatura_given, temperatura_ideal):
+    return abs(temperatura_given - temperatura_ideal)
+
+
+# create exception for no solution found
+class NoSolutionFound(Exception):
+    pass
+
+class SoltionFoundWithLargerConfortValue(Exception):
+    pass

app/dashboard.ipynb

@@ -0,0 +1,294 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/b4/lwfgccm95kqd2skcwvrt2fr00000gn/T/ipykernel_7355/1062829466.py:19: FutureWarning:\n",
+      "\n",
+      "The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"100%\"\n",
+       "            height=\"650\"\n",
+       "            src=\"http://0.0.0.0:8050/\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "            \n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x28c80a4d0>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import plotly.express as px\n",
+    "import plotly.graph_objects as go\n",
+    "import pandas as pd\n",
+    "from dash import Dash, html, dcc, Input, Output, callback\n",
+    "import plotly.express as px\n",
+    "import numpy as np\n",
+    "import example_data\n",
+    "import core\n",
+    "\n",
+    "\n",
+    "outside_temp = example_data.ExampleDailyOutsideTemperature\n",
+    "energy_price = example_data.ExampleDailyEnergyCost\n",
+    "boiler_temperature = example_data.ExampleBoilerTemperature\n",
+    "\n",
+    "\n",
+    "\n",
+    "data = pd.DataFrame(columns=['hour', 'energy_consumption', 'confort', 'policy_readable'])\n",
+    "data = pd.concat([data, pd.DataFrame({'hour': np.arange(0, 24), 'energy_consumption': energy_price.value, 'confort': np.random.rand(24),\n",
+    "                                       'policy_readable': np.random.choice(['A', 'B', 'C', 'D', 'E'], 24)\n",
+    "                                       })])\n",
+    "debug = False\n",
+    "\n",
+    "\n",
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "app.layout = html.Div([\n",
+    "    dcc.Location(id='url', refresh=False),\n",
+    "    html.Div(id='page-content')\n",
+    "])\n",
+    "\n",
+    "server = app.server\n",
+    "\n",
+    "\n",
+    "# SOlution options\n",
+    "solution_options = [\n",
+    "    \"Discrete Optimization\",\n",
+    "    \"Continuous Optimization\",\n",
+    "    \"Reinforcement Learning\"\n",
+    "]\n",
+    "solution_options_default_value = solution_options[0]\n",
+    "\n",
+    "# provide a scalar value to enable the slider to select ideal temperature\n",
+    "ideal_temperature = 50\n",
+    "\n",
+    "dashboard_layout =  html.Div([\n",
+    "    dcc.Link('About this project', href='/wiki'),\n",
+    "\n",
+    "    html.H1('System Evaluation'),\n",
+    "    #small subtitle that says of solution is possible or not\n",
+    "    html.Div(id='solution-status', children='', style={'color': 'lighrgrey'}),\n",
+    "    html.Div([\n",
+    "        html.Div([\n",
+    "                    html.H3('Solution'),\n",
+    "                    dcc.Dropdown(\n",
+    "                        id='solution-dropdown',\n",
+    "                        options=solution_options,\n",
+    "                        value=solution_options_default_value,\n",
+    "                    )\n",
+    "                ], className='three columns'),\n",
+    "        html.Div([\n",
+    "                    html.H3('Ideal Shower Temperature'),\n",
+    "                    dcc.Slider(\n",
+    "                        id='ideal-temperature-slider',\n",
+    "                        min=0,\n",
+    "                        max=100,\n",
+    "                        step=1,\n",
+    "                        value=ideal_temperature,\n",
+    "                        marks={\n",
+    "                            0: '0°C',\n",
+    "                            25: '25°C',\n",
+    "                            50: '50°C',\n",
+    "                            75: '75°C',\n",
+    "                            100: '100°C'\n",
+    "                        },\n",
+    "                    )\n",
+    "                ], className='three columns'),\n",
+    "\n",
+    "\n",
+    "    ], className='row'),\n",
+    "    html.Div(\n",
+    "        [\n",
+    "            html.Div(\n",
+    "                [\n",
+    "                    html.H3('Policy'),\n",
+    "                    dcc.Graph(id='policy_readable-graph')\n",
+    "                ], className='six columns',\n",
+    "            ),\n",
+    "            html.Div(\n",
+    "                [\n",
+    "                    html.H3('Energy Consumption'),\n",
+    "                    dcc.Graph(id='energy-comsumption-graph')\n",
+    "                ], className='six columns'\n",
+    "            )\n",
+    "    ], className='row'),\n",
+    "    html.Div(\n",
+    "        [\n",
+    "            html.Div(\n",
+    "                [\n",
+    "                    html.H3('Confort'),\n",
+    "                    dcc.Graph(id='confort-graph')\n",
+    "                ], className='six columns'\n",
+    "            )\n",
+    "    ], className='row'),\n",
+    "],\n",
+    "#add background image from local file and make it transparent\n",
+    "#, style={'background-image':'url(/assets/background_1.png)'}\n",
+    "style={'background-color': '#4B5320', 'font-family': 'Fantasy', 'color': '#8F9779', 'padding': '10px'}\n",
+    ")\n",
+    "\n",
+    "\n",
+    "\n",
+    "wiki_layout = html.Div([\n",
+    "    dcc.Link('Dashboard', href='/'),\n",
+    "\n",
+    "    html.H1('About this project'),\n",
+    "\n",
+    "    html.Div([\n",
+    "        html.Div([\n",
+    "                    \n",
+    "                    html.H3('What is this project about?'),\n",
+    "\n",
+    "                    html.P('This project is a simulation of a shower system. The goal is to find the best policy for the boiler to heat the water for the shower. The policy is a function that takes the current hour of the day and the current temperature of the water in the boiler and returns the temperature that the boiler should heat the water to.'),\n",
+    "                    html.P('The best policy is the one that maximizes the confort of the shower and minimizes the energy consumption of the boiler.'),\n",
+    "\n",
+    "                    html.H3('How does it work?'),\n",
+    "\n",
+    "                    #Insert image of the system\n",
+    "\n",
+    "                    html.H3('\\'Bout us'),\n",
+    "                    html.Img(src='/assets/hackatos.png', style={'width': '40%', 'height': 'auto', 'display': 'block', 'margin-left': 'auto', 'margin-right': 'auto'}),\n",
+    "                    html.P('This project was developed by a team of 3, in the context of the Aveiro Tech City 2023 hackathon.'),\n",
+    "                    html.P('The team members are:'),\n",
+    "                    html.H4('Rui Melo'),\n",
+    "                    html.P('Rui Melo is a ....'),\n",
+    "                    html.H4('André Catarino'),\n",
+    "                    html.P('André Catarino is a ....'),\n",
+    "                    html.H4('Francisco Petronilho'),\n",
+    "                    html.P('Francisco Petronilho is a ....'),\n",
+    "                    html.H4('André Tomás'),\n",
+    "                    html.P('André Tomás is a ....'),\n",
+    "                    html.H4('Zé Miguel'),\n",
+    "                    html.P('Zé Miguel is a ....'),\n",
+    "\n",
+    "\n",
+    "                    html.H3('References'),\n",
+    "                    html.P('The boiler model was based on the following paper:'),\n",
+    "\n",
+    "\n",
+    "        ], className='six columns'),], className='row'),\n",
+    "],\n",
+    "style={'background-color': '#4B5320', 'font-family': 'Fantasy', 'color': '#8F9779', 'padding': '10px'}\n",
+    "\n",
+    ")\n",
+    "\n",
+    "# Update the index\n",
+    "@callback(Output('page-content', 'children'), Input('url', 'pathname'))\n",
+    "def display_page(pathname):\n",
+    "    if pathname == '/':\n",
+    "        return dashboard_layout\n",
+    "    elif pathname == '/wiki':\n",
+    "        return wiki_layout\n",
+    "    else:\n",
+    "        return '404'\n",
+    "    # You could also return a 404 \"URL not found\" page here\n",
+    "\n",
+    "\n",
+    "\n",
+    "@app.callback(\n",
+    "    Output('policy_readable-graph', 'figure'),\n",
+    "    Output('energy-comsumption-graph', 'figure'),\n",
+    "    Output('confort-graph', 'figure'),\n",
+    "    Output('solution-status', 'children'),\n",
+    "    Input('solution-dropdown', 'value'),\n",
+    "    Input('ideal-temperature-slider', 'value')\n",
+    ")\n",
+    "def update_graph(solution, ideal_temperature):\n",
+    "    energy_consumption = data['energy_consumption'].values\n",
+    "    confort_obtained = data['confort'].values\n",
+    "\n",
+    "\n",
+    "    policy_readable_graph = px.line(data, x='hour', y='policy_readable',\n",
+    "                                    labels={'hour': 'Hour', 'policy_readable': 'Policy'},\n",
+    "                                    color_discrete_sequence=['lightgreen'])\n",
+    "    policy_readable_graph.update_layout(\n",
+    "        xaxis_title=\"Hour\",\n",
+    "        yaxis_title=\"Temperature (°C)\",\n",
+    "        legend_title=\"Policy\"\n",
+    "    )\n",
+    "\n",
+    "    energy_consumption_graph = px.line(data, x='hour', \n",
+    "                                       y='energy_consumption', \n",
+    "                                       labels={'hour': 'Hour', 'energy_consumption': 'Energy Consumption (kWh)'},\n",
+    "                                       color_discrete_sequence=['lightgreen'])\n",
+    "    energy_consumption_graph.update_layout(\n",
+    "        xaxis_title=\"Hour\",\n",
+    "        yaxis_title=\"Energy Consumption (kWh)\",\n",
+    "        legend_title=\"Energy Consumption\",\n",
+    "    )\n",
+    "    #add accumulated energy consumption\n",
+    "    energy_consumption = np.cumsum(energy_consumption)\n",
+    "    energy_consumption_graph.add_trace(px.line(data, x='hour', \n",
+    "                                               y=energy_consumption,\n",
+    "                                               labels={'y': 'Acc. Energy Consumption (kWh)'},\n",
+    "                                                color_discrete_sequence=['green']).data[0])\n",
+    "\n",
+    "    confort_graph = px.line(data, x='hour', y='confort',\n",
+    "                            labels={'hour': 'Hour', 'confort': 'Confort Score'},\n",
+    "                            color_discrete_sequence=['lightgreen'])\n",
+    "\n",
+    "    confort_graph.update_layout(\n",
+    "        xaxis_title=\"Hour\",\n",
+    "        yaxis_title=\"Confort Score\",\n",
+    "        legend_title=\"Confort\"\n",
+    "    )\n",
+    "    #add accumulated confort\n",
+    "    confort_obtained = np.cumsum(confort_obtained)\n",
+    "    confort_graph.add_trace(px.line(data, x='hour', y=confort_obtained,\n",
+    "                                    labels={'y': 'Acc. Confort Score'},\n",
+    "                                    color_discrete_sequence=['green']\n",
+    "                                    ).data[0])\n",
+    "    result = \"No solution found\"\n",
+    "    return policy_readable_graph, energy_consumption_graph, confort_graph, result\n",
+    "if __name__ == \"__main__\":\n",
+    "    app.run_server(host=\"0.0.0.0\", port=\"8050\", debug=debug)\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "atc-smart-shower-YhjpRjjr-py3.10",
+   "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.10.13"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

app/example_data.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ExampleDailyOutsideTemperature:
+    """Outside temperature in degrees Celsius"""
+
+    value = [
+        9.05,
+        8.38,
+        7.61,
+        6.85,
+        6.41,
+        5.66,
+        5.77,
+        5.02,
+        4.97,
+        5.15,
+        7.26,
+        8.06,
+        8.47,
+        8.59,
+        8.86,
+        8.87,
+        8.86,
+        8.71,
+        8.36,
+        8.11,
+        7.87,
+        7.7,
+        7.98,
+        7.62,
+    ]
+    temperatura_entrada_agua = [x * 0.9 for x in value]
+
+    temperatura_saida_agua = 50
+
+    def temperatura_entrada_no_banho(self, potencia):
+        return [value * potencia for value in self.value]
+
+
+@dataclass
+class ExampleBoilerTemperature:
+    """Boiler temperature in degrees Celsius"""
+
+    value = [
+        9.05,
+        8.38,
+        7.61,
+        6.85,
+        6.41,
+        5.66,
+        5.77,
+        5.02,
+        4.97,
+        5.15,
+        7.26,
+        8.06,
+        8.47,
+        8.59,
+        8.86,
+        8.87,
+        8.86,
+        8.71,
+        8.36,
+        8.11,
+        7.87,
+        7.7,
+        7.98,
+        7.62,
+    ]
+
+    temperature = [x * 2 for x in value]
+
+
+@dataclass
+class ExampleDailyEnergyCost:
+    """Energy cost in eur per kWh"""
+
+    value = [
+        0.5266399999999999,
+        0.45166399999999995,
+        0.34220000000000006,
+        0.32719999999999994,
+        0.3608,
+        0.45879199999999987,
+        0.4177600000000001,
+        0.43716800000000006,
+        0.4400000000000001,
+        0.44004800000000005,
+        0.440016,
+        0.4400000000000001,
+        0.4400000000000001,
+        0.4412,
+        0.4412,
+        0.44480000000000003,
+        0.44160000000000005,
+        0.44160000000000005,
+        0.45439999999999997,
+        0.45439999999999997,
+        0.4512,
+        0.4400000000000001,
+        0.428208,
+        0.49184000000000005,
+    ]
+
+
+@dataclass
+class ExampleBoilerPressure:
+    value = [
+        0.5266399999999999,
+        0.45166399999999995,
+        0.34220000000000006,
+        0.32719999999999994,
+        0.3608,
+        0.45879199999999987,
+        0.4177600000000001,
+        0.43716800000000006,
+        0.4400000000000001,
+        0.44004800000000005,
+        0.440016,
+        0.4400000000000001,
+        0.4400000000000001,
+        0.4412,
+        0.4412,
+        0.44480000000000003,
+        0.44160000000000005,
+        0.44160000000000005,
+        0.45439999999999997,
+        0.45439999999999997,
+        0.4512,
+        0.4400000000000001,
+        0.428208,
+        0.49184000000000005,
+    ]
+
+    pressure = [x * 4.3 for x in value]
+
+
+TEMPERATURA_IDEAL = 40

app/requirements.txt

@@ -0,0 +1,6 @@
+dash
+plotly
+pandas
+gunicorn
+wandb==0.15.5
+scipy

dashboard.py

@@ -0,0 +1,125 @@
+import pandas as pd
+
+data = pd.DataFrame(columns=["Dataset", "Alpha", "Top K", "Recall", "Precision"])
+data = pd.concat(
+    [
+        data,
+        pd.DataFrame(
+            [["ml-100k", 0.1, 20, 0.2, 0.2]],
+            columns=["Dataset", "Alpha", "Top K", "Recall", "Precision"],
+        ),
+    ]
+)
+
+import os
+import plotly.express as px
+import pandas as pd
+from dash import Dash, html, dcc, Input, Output, callback
+import plotly.express as px
+from dataclasses import dataclass
+import json
+
+data = pd.DataFrame(columns=["Dataset", "Alpha", "Top K", "Recall", "Precision"])
+data = pd.concat(
+    [
+        data,
+        pd.DataFrame(
+            [["ml-100k", 0.1, 20, 0.2, 0.2]],
+            columns=["Dataset", "Alpha", "Top K", "Recall", "Precision"],
+        ),
+    ]
+)
+debug = False
+
+
+external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"]
+
+app = Dash(__name__, external_stylesheets=external_stylesheets)
+
+server = app.server
+
+
+dataset_options = [
+    {"label": entry, "value": entry} for entry in data["Dataset"].unique()
+]
+dataset_options_default_value = data["Dataset"].unique()[0]
+
+alpha_options = [{"label": entry, "value": entry} for entry in data["Alpha"].unique()]
+alpha_options_default_value = data["Alpha"].unique()[0]
+
+top_k_options = [{"label": entry, "value": entry} for entry in data["Top K"].unique()]
+top_k_options_default_value = data["Top K"].unique()[0]
+
+app.layout = html.Div(
+    [
+        html.H1("System Evaluation"),
+        html.Div(
+            [
+                html.Div(
+                    [
+                        html.H3("Dataset"),
+                        dcc.Dropdown(
+                            id="dataset-dropdown",
+                            options=dataset_options,
+                            value=dataset_options_default_value,
+                        ),
+                    ],
+                    className="three columns",
+                ),
+                html.Div(
+                    [
+                        html.H3("Alpha"),
+                        dcc.Dropdown(
+                            id="alpha-dropdown",
+                            options=alpha_options,
+                            value=alpha_options_default_value,
+                        ),
+                    ],
+                    className="three columns",
+                ),
+                html.Div(
+                    [
+                        html.H3("Top K"),
+                        dcc.Dropdown(
+                            id="top_k-dropdown",
+                            options=top_k_options,
+                            value=top_k_options_default_value,
+                        ),
+                    ],
+                    className="three columns",
+                ),
+            ],
+            className="row",
+        ),
+        html.Div(
+            [
+                html.Div([dcc.Graph(id="recall-graph")], className="six columns"),
+                html.Div([dcc.Graph(id="precision-graph")], className="six columns"),
+            ],
+            className="row",
+        ),
+    ]
+)
+
+
+@app.callback(
+    Output("recall-graph", "figure"),
+    Output("precision-graph", "figure"),
+    Input("alpha-dropdown", "value"),
+    Input("dataset-dropdown", "value"),
+    Input("top_k-dropdown", "value"),
+)
+def update_graph(alpha, dataset, top_k):
+    filtered_data = data[
+        (data["Alpha"] == alpha)
+        & (data["Dataset"] == dataset)
+        & (data["Top K"] == top_k)
+    ]
+    recall_fig = px.bar(filtered_data, x="Dataset", y="Recall")
+    precision_fig = px.bar(filtered_data, x="Dataset", y="Precision")
+    return recall_fig, precision_fig
+
+
+# Run app and display result inline in the notebook
+if __name__ == "__main__":
+    app.run_server(debug=debug, port=8050)