jha_init

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+output_predictions_to_meteo_smape_25.keras filter=lfs diff=lfs merge=lfs -text

input_preprocessor_meteo_to_smape25.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1746e606af1ecd0e65af7f542d9d9153e285ea6d31aa4965f318b402a3c691f2
+size 5676

main.py

@@ -0,0 +1,51 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from datetime import timedelta
+import datetime
+from meteo_functions import get_meteo_data, get_air_quality_data, get_forecast_meteo_data, get_air_quality_forecast
+from predictions import predict 
+import gc
+
+def clear_memory():
+    gc.collect() 
+
+st.title("Predikce výkonu FVE ABA")
+#t.header("this is a header")
+#sst.subheader("subheader")
+#st.markdown("This is **Markdown**")
+#st.caption("small text")
+
+today = datetime.date.today()  
+max_date = today + datetime.timedelta(days=4)
+
+with st.form(key="sample_form"):
+    date_utc = st.date_input("Vyber den", max_value=max_date)
+    submit_button = st.form_submit_button(label="Predikuj")
+
+if submit_button:   
+    previous_day = date_utc - timedelta(days=1) 
+    if date_utc < today - datetime.timedelta(days=1):
+       # st.subheader(f"Predikce výkonu pro: {date_utc}:")
+
+        df_meteo = get_meteo_data(previous_day, date_utc)
+        df_air_quality = get_air_quality_data(previous_day, date_utc)
+
+        data = df_meteo.merge(df_air_quality, on="DT", how="inner")
+        predict(data)
+        clear_memory()
+
+    elif previous_day < date_utc <= today + datetime.timedelta(days=4):
+       # st.header(f"Data pro: {date_utc}:")
+        df_meteo = get_forecast_meteo_data(previous_day, date_utc)
+        df_air_quality = get_air_quality_forecast(previous_day, date_utc)
+        data = df_meteo.merge(df_air_quality, on="DT", how="inner")
+        #st.write("Budouci data:")
+        #st.dataframe(df_meteo)
+        #st.dataframe(df_air_quality)
+        #st.dataframe(data)
+        predict(data)
+        clear_memory()
+
+    else:
+        st.warning("Predikce je dostupná pouze pro následujících 5 dnů.")

meteo_functions.py

@@ -0,0 +1,142 @@
+
+import pandas as pd
+import requests
+import numpy as np
+
+lat = 49.13114
+lon = 15.18067
+
+def get_meteo_data(start_date, end_date):
+    url = f"https://archive-api.open-meteo.com/v1/archive?latitude={lat}&longitude={lon}&start_date={start_date}&end_date={end_date}&hourly=temperature_2m,relative_humidity_2m,surface_pressure,cloudcover,windspeed_10m,wind_direction_10m,direct_normal_irradiance,diffuse_radiation,shortwave_radiation&timezone=UTC"
+
+    response = requests.get(url)
+    if response.status_code == 200:
+        weather_data = response.json()
+
+        if "hourly" in weather_data:
+            df_weather = pd.DataFrame({
+                "DT": pd.to_datetime(weather_data["hourly"]["time"]),
+                "Temperature_2m": weather_data["hourly"].get("temperature_2m", []),
+                "Relative_Humidity_2m": weather_data["hourly"].get("relative_humidity_2m", []),
+                "Surface_Pressure": weather_data["hourly"].get("surface_pressure", []),
+                "Cloud_Cover": weather_data["hourly"].get("cloudcover", []),
+                "Wind_Speed_10m": weather_data["hourly"].get("windspeed_10m", []),
+                "Wind_Direction_10m": weather_data["hourly"].get("wind_direction_10m", []),
+                "RAD": weather_data["hourly"].get("shortwave_radiation", [])
+            })
+
+            df_weather["DT"] = df_weather["DT"].dt.tz_localize(None)
+
+            df_weather["wind_u"] = df_weather["Wind_Speed_10m"] * np.sin(np.radians(df_weather["Wind_Direction_10m"]))
+            df_weather["wind_v"] = df_weather["Wind_Speed_10m"] * np.cos(np.radians(df_weather["Wind_Direction_10m"]))
+
+            df_weather.drop(columns=["Wind_Speed_10m", "Wind_Direction_10m"], inplace=True)
+        else:
+            print("Chyba: Odpověď neobsahuje klíč 'hourly'.")
+
+    else:
+        print(f"Chyba při stahování dat: {response.status_code}, odpověď: {response.text}")
+
+    return df_weather
+
+def get_air_quality_data(start_date, end_date):
+
+    url = f"https://air-quality-api.open-meteo.com/v1/air-quality?latitude={lat}&longitude={lon}&start_date={start_date}&end_date={end_date}&hourly=pm10,ozone&timezone=UTC"
+
+    response = requests.get(url)
+    if response.status_code == 200:
+        air_quality_data = response.json()
+
+        if "hourly" in air_quality_data:
+            df_air_quality = pd.DataFrame({
+                "DT": pd.to_datetime(air_quality_data["hourly"]["time"]),
+                "PM10": air_quality_data["hourly"].get("pm10", []),
+                "Ozone": air_quality_data["hourly"].get("ozone", [])
+            })
+            df_air_quality["DT"] = df_air_quality["DT"].dt.tz_localize(None)
+        else:
+            print("Chyba: Odpověď neobsahuje klíč 'hourly'.")
+    else:
+        print(f"Chyba při stahování dat: {response.status_code}, odpověď: {response.text}")
+    
+    return df_air_quality
+
+def create_time_cycles(weather_dataset):
+    weather_dataset["hour"] = weather_dataset["DT"].dt.hour
+    weather_dataset["day_of_year"] = weather_dataset["DT"].dt.dayofyear
+    weather_dataset["sin_hour"] = np.sin(2 * np.pi * weather_dataset["hour"] / 24)
+    weather_dataset["cos_hour"] = np.cos(2 * np.pi * weather_dataset["hour"] / 24)
+    weather_dataset["sin_day_of_year"] = np.sin(2 * np.pi * weather_dataset["day_of_year"] / 365)
+    weather_dataset["cos_day_of_year"] = np.cos(2 * np.pi * weather_dataset["day_of_year"] / 365)
+    weather_dataset.drop(columns=["hour", "day_of_year"], inplace=True)
+    return weather_dataset
+
+def get_forecast_meteo_data(start_date, end_date):
+    url = f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&start_date={start_date}&end_date={end_date}&hourly=temperature_2m,relative_humidity_2m,surface_pressure,cloudcover,windspeed_10m,wind_direction_10m,direct_normal_irradiance,diffuse_radiation,shortwave_radiation&timezone=UTC"
+
+    # Odeslání požadavku
+    response = requests.get(url)
+    if response.status_code == 200:
+        weather_data = response.json()
+
+        if "hourly" in weather_data:
+            df_weather = pd.DataFrame({
+                "DT": pd.to_datetime(weather_data["hourly"]["time"]),
+                "Temperature_2m": weather_data["hourly"].get("temperature_2m", []),
+                "Relative_Humidity_2m": weather_data["hourly"].get("relative_humidity_2m", []),
+                "Surface_Pressure": weather_data["hourly"].get("surface_pressure", []),
+                "Cloud_Cover": weather_data["hourly"].get("cloudcover", []),
+                "Wind_Speed_10m": weather_data["hourly"].get("windspeed_10m", []),
+                "Wind_Direction_10m": weather_data["hourly"].get("wind_direction_10m", []),
+                "RAD": weather_data["hourly"].get("shortwave_radiation", [])
+            })
+
+            df_weather["DT"] = df_weather["DT"].dt.tz_localize(None)
+
+            df_weather["wind_u"] = df_weather["Wind_Speed_10m"] * np.sin(np.radians(df_weather["Wind_Direction_10m"]))
+            df_weather["wind_v"] = df_weather["Wind_Speed_10m"] * np.cos(np.radians(df_weather["Wind_Direction_10m"]))
+
+            df_weather.drop(columns=["Wind_Speed_10m", "Wind_Direction_10m"], inplace=True)
+        else:
+            print("Chyba: Odpověď neobsahuje klíč 'hourly'.")
+    else:
+        print(f"Chyba při stahování dat: {response.status_code}, odpověď: {response.text}")
+
+    return df_weather
+
+def get_air_quality_forecast(start_date, end_date):
+    url = f"https://air-quality-api.open-meteo.com/v1/air-quality?latitude={lat}&longitude={lon}&start_date={start_date}&end_date={end_date}&hourly=pm10,ozone&timezone=UTC"
+
+    response = requests.get(url)
+    if response.status_code == 200:
+        air_quality_data = response.json()
+
+        if "hourly" in air_quality_data:
+            times = air_quality_data["hourly"].get("time", [])
+            pm10 = air_quality_data["hourly"].get("pm10", [])
+            ozone = air_quality_data["hourly"].get("ozone", [])
+
+            if len(times) == len(pm10) == len(ozone):
+                df_air_quality = pd.DataFrame({
+                    "DT": pd.to_datetime(times),
+                    "PM10": pm10,
+                    "Ozone": ozone
+                })
+                df_air_quality["DT"] = df_air_quality["DT"].dt.tz_localize(None)  
+            else:
+                print("Chyba: Pola mají různé délky!")
+                print(f"Počet časových údajů: {len(times)}, Počet PM10: {len(pm10)}, Počet Ozone: {len(ozone)}")
+                df_air_quality = pd.DataFrame() 
+        else:
+            print("Chyba: Odpověď neobsahuje klíč 'hourly'.")
+            df_air_quality = pd.DataFrame()  
+    else:
+        print(f"Chyba při stahování dat: {response.status_code}, odpověď: {response.text}")
+        df_air_quality = pd.DataFrame()  
+    
+    return df_air_quality
+
+
+
+
+    

output_predictions_to_meteo_smape_25.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:583cbd035b5a57666e362f79581cffd6f15f607bfc20ac57af24d21e6d5adab3
+size 394648365

output_scaler_meteo_to_smape25.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a21576128cba609962c3396a6e7397f4a2765ede43a3e4c89d7481b6269ed1e5
+size 1705

predictions.py

@@ -0,0 +1,60 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from meteo_functions import create_time_cycles
+import joblib
+from preprocessing_functions import create_sequences, plot_solar_power_prediction, load_model, load_transformers
+from tensorflow import keras
+import gc
+
+def predict(data):
+    data = create_time_cycles(data)
+    st.divider()
+
+    # Načtění transformátorů
+    input_preprocessor, output_scaler = load_transformers()
+
+    # transformace vstupnich prom
+    X_dataset = input_preprocessor.transform(data)
+    X_dataset = pd.DataFrame(X_dataset, columns=input_preprocessor.get_feature_names_out(), index=data.index)
+
+    rename_map = {
+        "yeo_minmax__RAD": "RAD",
+        "yeo_minmax__Relative_Humidity_2m": "Relative_Humidity_2m",
+        "yeo_minmax__PM10": "PM10",
+        "yeo_standard__Cloud_Cover": "Cloud_Cover",
+        "minmax__Temperature_2m": "Temperature_2m",
+        "minmax__wind_u": "wind_u",
+        "minmax__wind_v": "wind_v",
+        "minmax__Surface_Pressure": "Surface_Pressure",
+        "minmax__Ozone": "Ozone",
+        "remainder__sin_hour": "sin_hour",
+        "remainder__cos_hour": "cos_hour",
+        "remainder__sin_day_of_year": "sin_day_of_year",
+        "remainder__cos_day_of_year": "cos_day_of_year"
+    }
+    X_dataset = X_dataset.rename(columns=rename_map)
+
+    features = ["RAD", "Relative_Humidity_2m", "Surface_Pressure", 'Cloud_Cover', "Temperature_2m",
+            'sin_hour', 'cos_hour', 'cos_day_of_year', "sin_day_of_year", "wind_u", "wind_v", "Ozone", "PM10"]
+
+    x = create_sequences(X_dataset, window=24, horizon=24, past_features=features, future_features=features)
+
+    model = load_model() 
+
+    y_pred = model.predict(x) # predikce
+
+    y_pred_trans = np.array([output_scaler.inverse_transform(y_pred[:, i].reshape(-1, 1)).flatten() for i in range(y_pred.shape[1])]).T
+
+    y_pred_trans[y_pred_trans < 1] = 0
+    st.write("**Predikované hodnoty výkonu (kW) pro jednotlivé hodiny:**")
+    st.write(y_pred_trans, use_container_width=True)
+
+    my_plt = plot_solar_power_prediction(y_pred_trans)
+    st.pyplot(my_plt)
+
+    del x, y_pred, y_pred_trans
+    keras.backend.clear_session()  # Uvolnění TensorFlow session
+    gc.collect()  
+
+    return None

preprocessing_functions.py

@@ -0,0 +1,105 @@
+import numpy as np
+import tensorflow as tf
+import streamlit as st
+import os
+import requests
+import matplotlib.pyplot as plt
+import joblib
+
+MODEL_URL = "https://github.com/Kuba129cz/FVE_ABA/releases/download/model_FVE/output_predictions_to_meteo_smape_25.keras"
+MODEL_PATH = "model.keras"
+
+def download_model():
+    if not os.path.exists(MODEL_PATH):
+        st.info("Stahuji model, prosím čekejte...")
+        response = requests.get(MODEL_URL, stream=True)
+        
+        if response.status_code == 200:
+            with open(MODEL_PATH, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            st.success("Model byl úspěšně stažen.")
+        else:
+            st.error("Nepodařilo se stáhnout model. Zkontrolujte URL.")
+    else:
+        st.info("Model již je stažen.")
+
+@st.cache_resource
+def load_model():
+    download_model()
+    model = tf.keras.models.load_model(MODEL_PATH)
+    return model
+
+@st.cache_resource 
+def load_transformers():
+    input_preprocessor = joblib.load('input_preprocessor_meteo_to_smape25.pkl')
+    output_scaler = joblib.load('output_scaler_meteo_to_smape25.pkl')
+
+    return input_preprocessor, output_scaler
+
+def create_sequences(data, window, horizon, past_features, future_features):
+    """
+    Vytvoří sekvence vstupních dat a odpovídající cílové hodnoty pro trénování LSTM modelu.
+
+    Parametry:
+    ----------
+    data : pandas.DataFrame
+        DataFrame obsahující časové řady.
+    window : int
+        Počet časových kroků v minulosti.
+    horizon : int
+        Počet časových kroků do budoucnosti.
+    past_features : list
+        Seznam sloupců, které budou použity jako vstupní vlastnosti v minulosti.
+    future_features : list
+        Seznam sloupců, které budou použity jako vstupní vlastnosti v budoucnosti.
+    target : str
+        Název sloupce, který bude použit jako cílová hodnota.
+
+    Návratové hodnoty:
+    -------------------
+    X : numpy.ndarray
+        Pole tvaru (vzorky, window, past_features + future_features), obsahující sekvence vstupních dat.
+    y : numpy.ndarray
+        Pole tvaru (vzorky, horizon), obsahující odpovídající cílové hodnoty.
+    """
+
+    X_past = np.lib.stride_tricks.sliding_window_view(
+        data[past_features].values, (window, len(past_features))
+    )[:-horizon, :, :]
+
+    X_past = np.squeeze(X_past, axis=1)  
+
+    X_future = np.lib.stride_tricks.sliding_window_view(
+        data[future_features].values, (window, len(future_features))
+    )[horizon-1 : len(X_past) + horizon-1, :, :]
+
+    X_future = np.squeeze(X_future, axis=1)  
+
+    X = np.concatenate([X_past, X_future], axis=2)  
+
+    return X
+
+def plot_solar_power_prediction(y_pred_trans):
+    """
+    Vytvoří graf predikce výkonu fotovoltaické elektrárny v průběhu dne.
+    
+    Args:
+        y_pred_trans (numpy.ndarray): Pole s predikovanými hodnotami výkonu (kW) ve tvaru (1, 24).
+    
+    Returns:
+        plt.Figure: Graf pro zobrazení.
+    """
+    hours = np.arange(24)
+    
+    plt.figure(figsize=(10, 6))
+    plt.plot(hours, y_pred_trans.flatten(), marker='o', label='Výkon (kW)')
+    plt.xlabel('Hodiny')
+    plt.ylabel('Výkon (kW)')
+    plt.title('Predikce výkonu fotovoltaické elektrárny v průběhu dne')
+    plt.xticks(hours) 
+    plt.grid(True)
+    plt.legend()
+    
+    return plt
+

requirements.txt

@@ -0,0 +1,9 @@
+streamlit
+pandas
+numpy
+matplotlib
+tensorflow
+joblib
+requests
+scipy
+scikit-learn