Add application file

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user .. /app
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,198 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import StreamingResponse
+import lightgbm as lgb
+from pydantic import BaseModel, validator
+from datetime import datetime
+import pandas as pd
+import json
+import io
+import zipfile
+import matplotlib.pyplot as plt
+from data import get_all_features
+
+import warnings
+warnings.filterwarnings("ignore")
+
+
+class DataPoint(BaseModel):
+    timestamp: datetime
+    storage_charge: float
+    heat_pump: float
+    circulation_pump: float
+    air_conditioning: float
+    ventilation: float
+    dishwasher: float
+    washing_machine: float
+    refrigerator: float
+    freezer: float
+    cooling_aggregate: float
+    facility: float
+    total: float
+
+    @validator('timestamp', pre=True)
+    def parse_timestamp(cls, value):
+        if isinstance(value, str):
+            return datetime.fromisoformat(value)
+        return value
+
+
+app = FastAPI()
+
+devices = [ 'storage_charge',
+ 'heat_pump',
+ 'circulation_pump',
+ 'air_conditioning',
+ 'ventilation',
+ 'dishwasher',
+ 'washing_machine',
+ 'refrigerator',
+ 'freezer',
+ 'cooling_aggregate',
+ 'facility']
+models = dict()
+for device in devices:
+    models[device] = lgb.Booster(model_file=f"models/model_{device}.txt")
+
+def lowercase_keys_and_copy_values(list_of_dicts):
+    return [{key.lower(): value for key, value in d.items()} for d in list_of_dicts]
+@app.get("/")
+def greet_json():
+    return {"Hello": str(models)}
+
+
+async def get_data(request: Request):
+    data = await request.json()
+
+    #data = json.loads(data)
+    data = lowercase_keys_and_copy_values(data)
+    data_points = [DataPoint(**item) for item in data]
+    data_dicts = [item.dict() for item in data_points]
+    df = pd.DataFrame(data_dicts)
+
+    predictions = dict()
+    for i in devices:
+        predictions[i] = []
+    return df, predictions
+
+async def get_plots(request: Request, mode):
+    res = await request.json()
+    df = pd.DataFrame(res)
+    print(df)
+    if mode == 1:
+        plt.style.use('dark_background')
+    else:
+        plt.style.use('default')
+
+    plots = []
+    d = devices + ['total']
+    for i in d:
+        buf = io.BytesIO()
+        plt.figure()
+        plt.plot(list(range(1, len(df)+1)), df[i])
+        plt.xticks(rotation=60)
+        plt.xlabel('Hour')
+        plt.ylabel('kWh')
+        plt.title(f'Energy consumption of {i}')
+        plt.savefig(buf, format='png', bbox_inches='tight')
+        buf.seek(0)
+        plots.append(buf)
+
+    zip_buf = io.BytesIO()
+    with zipfile.ZipFile(zip_buf, 'w', zipfile.ZIP_DEFLATED) as z:
+        for i, plot_buf in enumerate(plots):
+            z.writestr(f"{d[i]}.png", plot_buf.getvalue())
+    zip_buf.seek(0)
+
+    return StreamingResponse(zip_buf,
+                     media_type="application/zip",
+                     headers={"Content-Disposition": "attachment; filename=plots.zip"})
+
+async def get_prediction(request, H):
+    df, predictions = await get_data(request)
+    predictions['total'] = []
+    for _ in range(H):
+        res = get_all_features(df, devices)
+        p = dict()
+        predictions['total'].append(0)
+        for i in devices:
+            pred = (models[i].predict(res[i].iloc[-1]) * 0.8)
+            predictions[i].append(pred[0])
+            predictions['total'][-1] += pred[0]
+            p[i] = pred
+        p['timestamp'] = df.iloc[-1]['timestamp'] + pd.to_timedelta(1, unit='h')
+        df = pd.concat([df, pd.DataFrame(p)], ignore_index=True)
+    return {"dataframe": pd.DataFrame(predictions).to_json()}
+
+
+async def get_anomalies(request):
+    df, _ = await get_data(request)
+    res = get_all_features(df, devices)
+    for i in devices:
+        pred = (df[i] - models[i].predict(res[i].iloc[-1]) * 0.8).abs()
+        df[f"is_anomaly_{i}"] = pred > 3
+
+    return {"dataframe": df.to_json(orient='records')}
+
+@app.post("/anomalies")
+async def predict(request: Request):
+    try:
+        res = await get_anomalies(request)
+        return res
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/statistcks")
+async def statistcks(request: Request):
+    try:
+        df, _ = await get_data(request)
+        res = get_all_features(df, devices)
+        json_dict = {key: df.to_json() for key, df in res.items()}
+        json_object = json.dumps(json_dict, indent=4)
+        return {"dataframe": json_object}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/predict/day")
+async def predict(request: Request):
+    try:
+        H = 24
+        res = await get_prediction(request, H)
+        return res
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/predict/three_day")
+async def predict(request: Request):
+    try:
+        H = 24 * 3
+        res = await get_prediction(request, H)
+        return res
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/predict/week")
+async def predict(request: Request):
+    try:
+        H = 24 * 7
+        res = await get_prediction(request, H)
+        return res
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/plots/dark")
+async def predict(request: Request):
+    try:
+        zip_buf = await get_plots(request, 1)
+        return zip_buf
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/plots/light")
+async def predict(request: Request):
+    try:
+        zip_buf = await get_plots(request, 0)
+        return zip_buf
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

data.py

@@ -0,0 +1,78 @@
+import pandas as pd
+import numpy as np
+
+
+def get_time_features(data):
+    df = pd.DataFrame()
+    df['timestamp'] = data['timestamp']
+    df['hour'] = data['timestamp'].dt.hour
+    df['day_of_week'] = data['timestamp'].dt.dayofweek
+    df['day'] = data['timestamp'].dt.day
+    df['month'] = data['timestamp'].dt.month
+
+    season_label = lambda x: 0 if 3 <= x <= 5 else 1 if 6 <= x <= 8 else 2 if 9 <= x <= 11 else 3
+    df['season'] = df['month'].apply(season_label)
+
+    cols = df.columns[1::]
+    for i in cols:
+        max_values = df[i].max()
+        df[f'{i}_sin'] = np.sin(2 * np.pi * df[i] / max_values)
+        df[f'{i}_cos'] = np.cos(2 * np.pi * df[i] / max_values)
+
+    time_label = lambda x: 0 if 6 <= x <= 11 else 1 if 12 <= x <= 17 else 2 if 18 <= x <= 21 else 3
+    df['part_of_day'] = df['hour'].apply(time_label)
+    working_hours_label = lambda x: 1 if 9 <= x < 17 else 0
+    df['is_working_hours'] = df['hour'].apply(working_hours_label)
+
+    is_weekend_label = lambda x: 1 if x >= 5 else 0
+    df['is_weekend'] = df['day_of_week'].apply(is_weekend_label)
+
+    return df
+
+
+def get_ts_features(data, time, column):
+    data = data[['timestamp', column]].copy()
+    data.set_index('timestamp', inplace=True)
+
+    # Create a rolling window with the given time span
+    rolling_window = data[column].rolling(f'{time}H', closed='both')
+
+    # Calculate the desired statistics
+    df = pd.DataFrame(index=data.index)
+    df[f'exact_{time}'] = data[column]
+    df[f'mean_{time}'] = rolling_window.mean()
+    df[f'median_{time}'] = rolling_window.median()
+    df[f'std_{time}'] = rolling_window.std()
+    df[f'min_{time}'] = rolling_window.min()
+    df[f'max_{time}'] = rolling_window.max()
+
+    # Fill NaN values with -1 for consistency with the original code
+    df.fillna(-1, inplace=True)
+
+    return df.reset_index()
+
+
+def get_all_ts_features(data, column):
+    res = pd.DataFrame()
+    res['timestamp'] = data['timestamp']
+    values = [1, 3, 6, 12, 24, 24 * 2, 24 * 4, 24 * 8]
+    for i in values:
+        features_df = get_ts_features(data, i, column)
+        res = res.merge(features_df, on='timestamp', how='left')
+
+    return res
+
+
+def get_all_features(df, devices):
+    res = dict()
+    for i in devices:
+        res[i] = pd.DataFrame()
+
+    f = get_time_features(df)
+    for k in devices:
+        t = get_all_ts_features(df, k)
+        combined = f.merge(t, on='timestamp', how='left')
+        combined['type'] = 0
+        res[k] = pd.concat([res[k], combined.drop(['timestamp'], axis=1)], ignore_index=True)
+
+    return res

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+fastapi==0.111.0
+uvicorn[standard]
+pandas
+numpy
+lightgbm
+matplotlib