301 lines
11 KiB
Python
301 lines
11 KiB
Python
import pandas as pd
|
|
import numpy as np
|
|
import xgboost as xgb
|
|
import mysql.connector
|
|
from mysql.connector import Error
|
|
from datetime import datetime, timedelta
|
|
import holidays
|
|
|
|
# --- NIEUW: Imports voor grafiek en e-mail ---
|
|
import matplotlib.pyplot as plt
|
|
import smtplib
|
|
from email.mime.multipart import MIMEMultipart
|
|
from email.mime.text import MIMEText
|
|
from email.mime.image import MIMEImage
|
|
|
|
# --- NIEUW: Zorgt dat matplotlib werkt zonder GUI (CRUCIAAL op Linux) ---
|
|
plt.switch_backend('Agg')
|
|
|
|
# --- CONFIGURATIE ---
|
|
MODEL_FILE = 'price_forecast_model_1.5.linux.json' # Linux-specifiek model
|
|
TARGET = 'gemiddelde_prijs'
|
|
AANTAL_UUR_VOORSPELLEN = 72
|
|
GRAFIEK_BESTAND = 'prijs_voorspelling_linux.png' # Linux-specifiek bestand
|
|
|
|
# --- NIEUW: E-mail Configuratie ---
|
|
# (Overgenomen uit je Windows-voorbeeld)
|
|
EMAIL_CONFIG = {
|
|
'smtp_server': 'localhost',
|
|
'smtp_port': 587,
|
|
'sender': 'sftpuser@markkors.nl',
|
|
'password': 'Aae8-G9yFU5j', # Wachtwoord is ingevuld
|
|
'receiver': 'mark@markkors.nl'
|
|
}
|
|
|
|
DB_CONFIG = {
|
|
'host': 'localhost',
|
|
'user': 'energy_prices_user',
|
|
'password': 'kS9R*xp17ZwCD@CV&E^N',
|
|
'database': 'energy_prices',
|
|
'port': 3307
|
|
}
|
|
|
|
# --- Model laden ---
|
|
try:
|
|
print(f"Laden van model: {MODEL_FILE}...")
|
|
model = xgb.XGBRegressor()
|
|
model.load_model(MODEL_FILE)
|
|
FEATURES = model.feature_names_in_
|
|
print(f"✅ Model succesvol geladen (verwacht {len(FEATURES)} features).")
|
|
except FileNotFoundError:
|
|
print(f"❌ Fout: Model bestand '{MODEL_FILE}' niet gevonden.")
|
|
print(" Heb je het 'v1_5 (linux)' model al getraind en opgeslagen op Linux?")
|
|
exit()
|
|
except Exception as e:
|
|
print(f"❌ Fout bij laden model: {e}")
|
|
exit()
|
|
|
|
nl_holidays = holidays.Netherlands(years=[datetime.now().year, datetime.now().year + 1])
|
|
|
|
|
|
# --- Functie: haal_data_uit_database (onveranderd) ---
|
|
def haal_data_uit_database(conn):
|
|
print("💾 Data ophalen uit MySQL...")
|
|
|
|
query_hist = """
|
|
SELECT
|
|
w.datum_tijd, w.temperatuur, w.gevoelstemperatuur, w.neerslag,
|
|
w.wind_richting, w.wind_snelheid, w.bewolking, w.luchtdruk, w.luchtvochtigheid,
|
|
p_avg.gemiddelde_prijs
|
|
FROM
|
|
amersfoort_weer_uurlijks AS w
|
|
LEFT JOIN
|
|
(SELECT datetime, AVG(price) AS gemiddelde_prijs
|
|
FROM dynamic_price_data GROUP BY datetime) AS p_avg
|
|
ON w.datum_tijd = p_avg.datetime
|
|
WHERE
|
|
w.datum_tijd BETWEEN (UTC_TIMESTAMP() - INTERVAL 30 HOUR) AND UTC_TIMESTAMP()
|
|
ORDER BY
|
|
w.datum_tijd;
|
|
"""
|
|
|
|
query_toekomst = f"""
|
|
SELECT
|
|
datum_tijd, temperatuur, gevoelstemperatuur, neerslag,
|
|
wind_richting, wind_snelheid, bewolking, luchtdruk, luchtvochtigheid,
|
|
NULL AS gemiddelde_prijs
|
|
FROM
|
|
amersfoort_weer_uurlijks
|
|
WHERE
|
|
datum_tijd BETWEEN UTC_TIMESTAMP() AND (UTC_TIMESTAMP() + INTERVAL {AANTAL_UUR_VOORSPELLEN} HOUR)
|
|
ORDER BY
|
|
datum_tijd;
|
|
"""
|
|
|
|
try:
|
|
hist_df = pd.read_sql(query_hist, conn, index_col='datum_tijd', parse_dates=['datum_tijd'])
|
|
toekomst_df = pd.read_sql(query_toekomst, conn, index_col='datum_tijd', parse_dates=['datum_tijd'])
|
|
|
|
print(f"✅ {len(hist_df)} uur historie geladen.")
|
|
print(f"✅ {len(toekomst_df)} uur toekomstig weer geladen.")
|
|
|
|
hist_df['gemiddelde_prijs'] = hist_df['gemiddelde_prijs'].ffill()
|
|
hist_df['gemiddelde_prijs'] = hist_df['gemiddelde_prijs'].bfill()
|
|
|
|
combined_df = pd.concat([hist_df, toekomst_df])
|
|
|
|
return combined_df.sort_index()
|
|
|
|
except Exception as e:
|
|
print(f"❌ Fout bij ophalen data: {e}")
|
|
return None
|
|
|
|
# --- Functie: maak_features_voor_uur (onveranderd) ---
|
|
def maak_features_voor_uur(df, timestamp):
|
|
features = {}
|
|
data_nu = df.loc[timestamp]
|
|
|
|
features['maand'] = timestamp.month
|
|
features['dag_van_het_jaar'] = timestamp.dayofyear
|
|
features['is_feestdag'] = 1 if timestamp in nl_holidays else 0
|
|
|
|
weer_cols = ['temperatuur', 'gevoelstemperatuur', 'neerslag', 'wind_richting',
|
|
'wind_snelheid', 'bewolking', 'luchtdruk', 'luchtvochtigheid']
|
|
for col in weer_cols:
|
|
features[col] = data_nu[col]
|
|
|
|
features['prijs_1u_geleden'] = df.loc[timestamp - timedelta(hours=1)]['gemiddelde_prijs']
|
|
features['prijs_24u_geleden'] = df.loc[timestamp - timedelta(hours=24)]['gemiddelde_prijs']
|
|
|
|
features['temp_avg_3u'] = df.loc[timestamp - timedelta(hours=2) : timestamp]['temperatuur'].mean()
|
|
features['prijs_avg_6u'] = df.loc[timestamp - timedelta(hours=5) : timestamp]['gemiddelde_prijs'].mean()
|
|
|
|
for dag in range(7):
|
|
features[f'dag_{dag}'] = 1 if timestamp.dayofweek == dag else 0
|
|
|
|
for uur in range(24):
|
|
features[f'uur_{uur}'] = 1 if timestamp.hour == uur else 0
|
|
|
|
return pd.DataFrame([features], columns=FEATURES)
|
|
|
|
# --- NIEUW: Functie om de e-mail te bouwen en te versturen ---
|
|
def send_email_with_graph(image_path, result_df):
|
|
print("\n📬 E-mail opstellen...")
|
|
|
|
msg = MIMEMultipart()
|
|
msg['Subject'] = f"Prijsvoorspelling (Linux) {datetime.now().strftime('%Y-%m-%d')}"
|
|
msg['From'] = EMAIL_CONFIG['sender']
|
|
msg['To'] = EMAIL_CONFIG['receiver']
|
|
|
|
laagste_prijs = result_df['Voorspelde_Prijs'].min()
|
|
hoogste_prijs = result_df['Voorspelde_Prijs'].max()
|
|
# en wanneer deze voorkomen
|
|
laagste_moment = result_df['Voorspelde_Prijs'].idxmin()
|
|
hoogste_moment = result_df['Voorspelde_Prijs'].idxmax()
|
|
|
|
|
|
body = f"""
|
|
De prijsvoorspelling voor de komende {len(result_df)} uur.
|
|
|
|
Laagste prijs: {laagste_prijs:.4f} (op {laagste_moment})
|
|
Hoogste prijs: {hoogste_prijs:.4f} (op {hoogste_moment})
|
|
|
|
Volledige voorspelling:
|
|
{result_df.to_string()}
|
|
"""
|
|
msg.attach(MIMEText(body, 'plain'))
|
|
|
|
try:
|
|
with open(image_path, 'rb') as f:
|
|
img_attach = MIMEImage(f.read(), name='voorspelling_linux.png')
|
|
msg.attach(img_attach)
|
|
print("✅ Grafiek bijgevoegd.")
|
|
except Exception as e:
|
|
print(f"❌ Kon grafiek-bestand niet lezen: {e}")
|
|
return
|
|
|
|
try:
|
|
print(f"Verbinding maken met SMTP server: {EMAIL_CONFIG['smtp_server']}...")
|
|
server = smtplib.SMTP(EMAIL_CONFIG['smtp_server'], EMAIL_CONFIG['smtp_port'])
|
|
|
|
# Probeer STARTTLS (encryptie)
|
|
# Veel servers (zelfs lokaal) vereisen dit
|
|
server.starttls()
|
|
|
|
# Probeer in te loggen
|
|
server.login(EMAIL_CONFIG['sender'], EMAIL_CONFIG['password'])
|
|
|
|
print("Inloggen succesvol. E-mail verzenden...")
|
|
server.sendmail(EMAIL_CONFIG['sender'], EMAIL_CONFIG['receiver'], msg.as_string())
|
|
server.quit()
|
|
print("✅ E-mail succesvol verzonden.")
|
|
except Exception as e:
|
|
print(f"❌ Fout bij verzenden e-mail: {e}")
|
|
print(" Controleer je EMAIL_CONFIG (server, poort, e-mail en wachtwoord)")
|
|
|
|
# --- START VAN HET SCRIPT (Aangepast) ---
|
|
try:
|
|
conn = mysql.connector.connect(**DB_CONFIG)
|
|
werk_df = haal_data_uit_database(conn)
|
|
|
|
if werk_df is not None:
|
|
te_voorspellen_tijden = werk_df[werk_df['gemiddelde_prijs'].isnull()].index
|
|
|
|
if len(te_voorspellen_tijden) == 0:
|
|
print("\nDatabase is al up-to-date. Geen voorspelling nodig.")
|
|
else:
|
|
print(f"\n🧠 Start iteratieve voorspelling voor {len(te_voorspellen_tijden)} uur...")
|
|
voorspellingen = []
|
|
|
|
for timestamp in te_voorspellen_tijden:
|
|
features_nu = maak_features_voor_uur(werk_df, timestamp)
|
|
voorspelde_prijs = model.predict(features_nu)[0]
|
|
werk_df.loc[timestamp, 'gemiddelde_prijs'] = voorspelde_prijs
|
|
voorspellingen.append(voorspelde_prijs)
|
|
|
|
print("\n" + "="*70)
|
|
pd.set_option('display.max_rows', None)
|
|
print(f"--- VOORSPELDE PRIJZEN (komende {len(te_voorspellen_tijden)} uur) ---")
|
|
|
|
resultaat_df = pd.DataFrame({
|
|
'Voorspelde_Prijs': voorspellingen
|
|
}, index=te_voorspellen_tijden)
|
|
|
|
print(resultaat_df)
|
|
print("="*70)
|
|
|
|
# --- NIEUW: Grafiek maken (met 2 Y-assen) en e-mailen ---
|
|
print("\n📊 Grafiek genereren (met temperatuur en wind)...")
|
|
try:
|
|
# Maak de basis-figuur en de EERSTE Y-as (ax1) voor de prijs
|
|
fig, ax1 = plt.subplots(figsize=(15, 8))
|
|
|
|
# Plot de Prijs op de linker-as (ax1)
|
|
ax1.plot(
|
|
resultaat_df.index,
|
|
resultaat_df['Voorspelde_Prijs'],
|
|
color='blue',
|
|
marker='.', # <-- AANPASSING
|
|
linestyle='-', # <-- AANPASSING
|
|
label='Voorspelde Prijs'
|
|
)
|
|
ax1.set_ylabel('Voorspelde Prijs (€)', color='blue')
|
|
ax1.tick_params(axis='y', labelcolor='blue')
|
|
ax1.set_xlabel('Datum en Tijd')
|
|
ax1.grid(True, which='major', axis='x') # Alleen verticale gridlijnen
|
|
|
|
# Maak de TWEEDE Y-as (ax2) die de X-as deelt
|
|
ax2 = ax1.twinx()
|
|
|
|
# Pak de weerdata die bij de voorspelling hoort
|
|
weer_toekomst = werk_df.loc[te_voorspellen_tijden]
|
|
|
|
# Plot Temperatuur op de rechter-as (ax2)
|
|
ax2.plot(
|
|
weer_toekomst.index,
|
|
weer_toekomst['temperatuur'],
|
|
color='red',
|
|
marker='.', # <-- AANPASSING
|
|
linestyle='--', # <-- AANPASSING
|
|
label='Temperatuur (°C)'
|
|
)
|
|
# Plot Windsnelheid op de rechter-as (ax2)
|
|
ax2.plot(
|
|
weer_toekomst.index,
|
|
weer_toekomst['wind_snelheid'],
|
|
color='green',
|
|
marker='x', # <-- AANPASSING
|
|
linestyle=':', # <-- AANPASSING
|
|
label='Windsnelheid (km/u)'
|
|
)
|
|
ax2.set_ylabel('Temperatuur / Windsnelheid', color='black')
|
|
ax2.tick_params(axis='y', labelcolor='black')
|
|
|
|
# Titel en gecombineerde legenda
|
|
plt.title(f'Energieprijs & Weer Voorspelling ({len(resultaat_df)} uur)', fontsize=16)
|
|
|
|
# Voeg legendas van BEIDE assen samen
|
|
lines1, labels1 = ax1.get_legend_handles_labels()
|
|
lines2, labels2 = ax2.get_legend_handles_labels()
|
|
ax2.legend(lines1 + lines2, labels1 + labels2, loc='upper left')
|
|
|
|
# Sla de grafiek op
|
|
plt.savefig(GRAFIEK_BESTAND)
|
|
plt.close(fig) # Geheugen vrijgeven
|
|
print(f"✅ Grafiek opgeslagen als: {GRAFIEK_BESTAND}")
|
|
|
|
# Stuur de e-mail (deze functie is onveranderd)
|
|
send_email_with_graph(GRAFIEK_BESTAND, resultaat_df)
|
|
|
|
except Exception as e:
|
|
print(f"❌ Fout bij genereren van grafiek: {e}")
|
|
# --- EINDE NIEUWE BLOK ---
|
|
|
|
except Error as e:
|
|
print(f"❌ Fout met MySQL verbinding: {e}")
|
|
except Exception as e:
|
|
print(f"❌ Een onverwachte fout is opgetreden: {e}")
|
|
finally:
|
|
if 'conn' in locals() and conn.is_connected():
|
|
conn.close()
|
|
print("\nVerbinding met MySQL gesloten.") |