Upload 8 files

Generate.py

@@ -0,0 +1,119 @@
+import sklearn
+import pandas as pd
+from tsai.basics import *
+import config
+from tsai.inference import load_learner
+
+import pandas as pd       
+
+
+
+def get_inputs_from_user():
+    
+    return 0
+
+def preprocess_data(DataFrame:pd.DataFrame):
+    preproc=load_object()        
+    return DataFrame
+
+def preprocess_data_transform_generate_splits_Train(DataFrame:pd.DataFrame):
+    DataFrame=DataFrame.drop(config.DROP_COLOUMNS,axis=1)
+    preproc_pipe=load_object(config.PREPROCESSOR_PATH)
+    exp_pipe=load_object(config.SCALING_DATA)
+    DataFrame=preproc_pipe.fit_transform(DataFrame)
+    
+    print("dataframe processed and ready for splitting")
+    
+    splits=get_forecasting_splits(DataFrame,fcst_history=config.FCST_HISTORY,fcst_horizon=config.FCST_HORIZON,datetime_col=config.DATETIME_COL,
+                                  valid_size=config.VALID_SIZE,test_size=config.TEST_SIZE)
+    
+    X,y=prepare_forecasting_data(DataFrame,fcst_history=config.FCST_HISTORY,fcst_horizon=config.FCST_HORIZON,x_vars=config.COLOUMNS,y_vars=config.COLOUMNS)
+    
+    learn=TSForecaster(X,y,splits=splits,
+        batch_size=16,path='models',
+        arch='InceptionTimePlus',#"PatchTST" when PatchTST is to be used
+        pipelines=[preproc_pipe,exp_pipe],
+        #arch_config=config.ARCH_CONFIG, #uncomment only if PatchTST is used
+        metrics=[mse,mape],
+        cbs=ShowGraph()
+    )
+    
+    lr_max=learn.lr_find().valley
+    
+    learn.fit_one_cycle(n_epoch=config.N_EPOCH,lr_max=lr_max)
+    learn.export("model_in.pt")
+    return 0
+
+#when using PatchTst model use the below function 
+def inference_Aircomp(fcst_date:string,DataFrame:pd.DataFrame):
+    pre=load_object(config.AIR_PREPROCESSOR_PATH)
+    DataFrame=pre.fit_transform(DataFrame)
+    
+    dates=pd.date_range(start=None,end=fcst_date,periods=config.FCST_HISTORY,freq=config.FREQUENCY)
+    new_df=DataFrame[DataFrame[config.AIR_DATETIME_COL].isin(dates)].reset_index(drop=True)
+    
+
+    predict=load_learner(config.MODEL_PATH_ITP_AIR)
+    new_df=predict.transform(new_df)
+    
+    new_x,__=prepare_forecasting_data(new_df,fcst_history=config.FCST_HISTORY,fcst_horizon=0,x_vars=config.AIR_COLOUMNS,y_vars=config.AIR_COLOUMNS)
+    
+    new_scaled_preds, *_ = predict.get_X_preds(new_x)
+
+    new_scaled_preds=to_np(new_scaled_preds).swapaxes(1,2).reshape(-1,len(config.AIR_COLOUMNS))
+    
+    dates=pd.date_range(start=fcst_date, periods=config.FCST_HORIZON+1,freq='1H')[1:]
+    preds_df=pd.DataFrame(dates,columns=[config.AIR_DATETIME_COL])
+    preds_df.loc[:, config.AIR_COLOUMNS]=new_scaled_preds
+    preds_df=predict.inverse_transform(preds_df)
+    
+    return preds_df
+
+def inference_Energy(fcst_date:string,DataFrame:pd.DataFrame):
+    pre=load_object(config.ENER_PREPROCESSOR_PATH)
+    DataFrame[config.ENERGY_DATETIME]=pd.to_datetime(DataFrame[config.ENERGY_DATETIME],format='mixed')   
+    DataFrame=pre.fit_transform(DataFrame)
+    
+    dates=pd.date_range(start=None,end=fcst_date,periods=config.FCST_HISTORY,freq=config.FREQUENCY)
+    new_df=DataFrame[DataFrame[config.ENERGY_DATETIME].isin(dates)].reset_index(drop=True)
+    
+
+    predict=load_learner(config.MODEL_PATH_ITP_ENER)
+    new_df=predict.transform(new_df)
+    
+    new_x,__=prepare_forecasting_data(new_df,fcst_history=config.FCST_HISTORY,fcst_horizon=0,x_vars=config.ENERGY_COLOUMNS,y_vars=config.ENERGY_COLOUMNS)
+    
+    new_scaled_preds, *_ = predict.get_X_preds(new_x)
+
+    new_scaled_preds=to_np(new_scaled_preds).swapaxes(1,2).reshape(-1,len(config.ENERGY_COLOUMNS))
+    
+    dates=pd.date_range(start=fcst_date, periods=config.FCST_HORIZON+1,freq='1H')[1:]
+    preds_df=pd.DataFrame(dates,columns=[config.ENERGY_DATETIME])
+    preds_df.loc[:, config.ENERGY_COLOUMNS]=new_scaled_preds
+    preds_df=predict.inverse_transform(preds_df)
+    
+    return preds_df
+
+def inference_boiler(fcst_date:string,DataFrame:pd.DataFrame):
+    pre=load_object(config.BOILER_PREPROCESSOR_PATH)  
+    DataFrame=pre.fit_transform(DataFrame)
+    
+    dates=pd.date_range(start=None,end=fcst_date,periods=config.FCST_HISTORY,freq=config.FREQUENCY)
+    new_df=DataFrame[DataFrame[config.BOILER_DATETIME].isin(dates)].reset_index(drop=True)
+
+    
+    predict=load_learner(config.MODEL_PATH_ITP_BOIL)
+    new_df=predict.transform(new_df)
+    
+    new_x,__=prepare_forecasting_data(new_df,fcst_history=config.FCST_HISTORY,fcst_horizon=0,x_vars=config.BOILER_COLOUMNS,y_vars=config.BOILER_COLOUMNS)
+    
+    new_scaled_preds, *_ = predict.get_X_preds(new_x)
+
+    new_scaled_preds=to_np(new_scaled_preds).swapaxes(1,2).reshape(-1,len(config.BOILER_COLOUMNS))
+    
+    dates=pd.date_range(start=fcst_date, periods=config.FCST_HORIZON+1,freq='1H')[1:]
+    preds_df=pd.DataFrame(dates,columns=[config.BOILER_DATETIME])
+    preds_df.loc[:, config.BOILER_COLOUMNS]=new_scaled_preds
+    preds_df=predict.inverse_transform(preds_df)
+    
+    return preds_df

app.py

@@ -0,0 +1,66 @@
+import gradio as gr
+import pandas as pd
+import tsai
+import Generate
+
+example_df_aircomp=pd.read_csv('D:/project/aircompressordata.csv')
+example_df_ener=pd.read_csv('D:/project/energymeter.csv')
+example_df_boiler=pd.read_csv('D:/project/Boiler1.csv')
+
+demo=gr.Blocks(title="EcoForecast")
+
+def pred_air(date):
+    preds=Generate.inference_Aircomp(date,example_df_aircomp)
+    return preds
+
+def pred_ener(date):
+    preds=Generate.inference_Energy(date,example_df_ener)
+    return preds
+
+def pred_boiler(date):
+    preds=Generate.inference_boiler(date,example_df_boiler)
+    return preds
+
+def plotgraphs(dataframe):
+    plots=0
+    return plots
+
+with demo:  
+    gr.Markdown("Tool for predicting the next seven days of data in the future using the last 200 points of data incoming")
+    with gr.Tabs():
+        with gr.TabItem("Air compressor data"):
+            with gr.Row():
+                Air_input=gr.Text(placeholder="Enter date and like the example only",show_label=False)
+                air_dataframe_input=gr.Dataframe(example_df_aircomp.head(100))
+                Air_dataframe_output=gr.Dataframe()
+                Air_plots=gr.Plot()
+            with gr.Column():
+                Aircomp_output_btn=gr.Button("Forecast")
+                Air_plot_forecast=gr.Button("Plot")
+                
+        with gr.TabItem("Energymeter data"):
+            with gr.Row():
+                ener_input=gr.Text(placeholder="Enter the date and time in example format only",show_label=False)
+                ener_dataframe_input=gr.Dataframe(example_df_ener.head(100))
+                Ener_dataframe_output=gr.Dataframe()
+                Ener_plots=gr.Plot()
+            with gr.Column():
+                Energy_output_btn=gr.Button("Forecast")
+                Ener_plot_forecast=gr.Button("Plot")
+                
+        with gr.TabItem("Boiler data"):
+            with gr.Row():
+                boiler_input=gr.Text(placeholder="Enter the date and time in example format only",show_label=False)
+                ener_dataframe_input=gr.Dataframe(example_df_boiler.head(100))
+                boiler_dataframe_output=gr.Dataframe()
+                boil_plots=gr.Plot()
+            with gr.Column():
+                Boiler_output_btn=gr.Button("Forecast")
+                boiler_plot_forecast=gr.Button("Plot")
+                
+    Aircomp_output_btn.click(pred_air,inputs=Air_input,outputs=Air_dataframe_output)
+    Energy_output_btn.click(pred_ener,inputs=ener_input,outputs=Ener_dataframe_output)
+    Boiler_output_btn.click(pred_boiler,inputs=boiler_input,outputs=boiler_dataframe_output)
+    Air_plot_forecast.click()
+    
+demo.launch(share=True)

config.py

@@ -0,0 +1,57 @@
+MODEL_PATH_ITP_AIR='/project/Pipline/models/AirInceptionTime.pt'
+MODEL_PATH_ITP_ENER='/project/Pipline/models/EnerInceptionTime.pt'
+MODEL_PATH_ITP_BOIL='/project/Pipline/models/BoilerInceptionTime.pt'
+
+DATA_PATH='/project/Pipline/data'
+AIR_PREPROCESSOR_PATH='/project/Pipline/data/preproc_pipe.pkl'
+AIR_SCALING_DATA='/project/Pipline/data/exp_pipe.pkl'
+
+ENER_PREPROCESSOR_PATH='/project/Pipline/data/Enerpreproc_pipe.pkl'
+ENER_SCALING_DATA='/project/Pipline/data/Ener_exp_pipe.pkl' 
+
+AIR_DATETIME_COL='timestamp'
+#the current model is only for 1 device and of a specific appliance only
+AIR_COLOUMNS=['air_inlet_temp_deg_f', 'average_cfm', 'average_kw',
+       'compressor_room_air_generated_cfm',
+       'compressor_room_energy_cosumed_kwh', 'specific_power_kw_100cfm',
+       'percentage_loading_based_on_air_supplied_design_600cfm']
+
+#the below columns provide no relavant information to the model
+AIR_DROP_COLOUMNS=['data_id','ideal_specific_power_kw_100cfm','device_id']
+
+ENERGY_DATETIME='parameter_timestamp'
+ENERGY_COLOUMNS=['current_ir', 'electrical_energy', 'frequency', 'power', 'powerfactor',
+       'pressure', 'temperature', 'voltage_vb',
+       'voltage_vr', 'voltage_vy']
+ENERGY_DROP_COLOUMNS=["location","current_ib","current_iy","device_1_state","device_2_state","device_id","device_name",'id',"device_type"]
+
+BOILER_PREPROCESSOR_PATH='/project/Pipline/data/boiler_preproc_pipe.pkl'
+BOILER_DATETIME='DateString'
+BOILER_COLOUMNS=['Boiler2_Feed Water Temp (T-4) (°F)','Boiler2_Gas Flow (G-2) (MMBtu)', 'Boiler2_Make Up Flow (W-17) (kGal)','Boiler2_Steam Flow (S-1) (lbs)']
+#Frequency of the incoming data
+FREQUENCY='1H'
+METHOD='ffill'
+VALUE=0
+
+#No. of values needed to be looked back
+FCST_HISTORY=200
+
+#No. of Timestamps predicted in the future
+FCST_HORIZON=168 #1 Week
+VALID_SIZE=0.1
+TEST_SIZE=0.2
+
+#Training Parameters for a new Model
+ARCH_CONFIG=dict(
+    n_layers=3,
+    n_heads=4,
+    d_model=16,
+    d_ff=128,
+    attn_dropout=0.0,
+    dropout=0.3,
+    patch_len=24,
+    stride=2,
+    padding_patch=True,
+)#Only needed when using PatchTst
+
+N_EPOCH=100

forecast.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import sklearn
+from tsai.basics import *
+#my_setup(sklearn)
+
+import pandas as pd
+df=pd.read_csv('D:/project/aircompressordata.csv')
+df=df.drop(['data_id','ideal_specific_power_kw_100cfm','device_id'],axis=1)
+print(df.columns)
+df.head(5)
+
+
+# In[3]:
+
+
+datetime_col="timestamp"
+freq='1H'
+coloumns=df.columns[:7]
+method='ffill'
+value=0
+
+preproc_pipe=sklearn.pipeline.Pipeline([
+    ('shrinker',TSShrinkDataFrame()),
+    ('drop_duplicates',TSDropDuplicates(datetime_col=datetime_col)),
+    ('add_mts',TSAddMissingTimestamps(datetime_col=datetime_col,freq=freq)),
+    ('fill_missing',TSFillMissing(columns=coloumns,method=method,value=value)),
+    ],
+    verbose=True)
+mkdir('data', exist_ok=True,parents=True)
+save_object(preproc_pipe,'data/preproc_pipe.pkl')
+preproc_pipe=load_object('data/preproc_pipe.pkl')
+
+df=preproc_pipe.fit_transform(df)
+
+
+# In[4]:
+
+
+df.head()
+
+
+# In[5]:
+
+
+fcst_history=200
+fcst_horizon=72
+valid_size=0.1
+test_size=0.2
+
+splits=get_forecasting_splits(df,fcst_history=fcst_history,fcst_horizon=fcst_horizon,datetime_col=datetime_col,
+                              valid_size=valid_size,test_size=test_size)
+
+splits
+
+
+# In[6]:
+
+
+coloumns=df.columns[1:]
+train_split=splits[0]
+
+exp_pipe=sklearn.pipeline.Pipeline([
+    ('scaler',TSStandardScaler(columns=coloumns)),
+    ],
+    verbose=True)
+
+save_object(exp_pipe,'data/exp_pipe.pkl')
+exp_pipe=load_object('data/exp_pipe.pkl')
+
+df_scaled=exp_pipe.fit_transform(df,scaler__idxs=train_split)
+
+df_scaled
+
+
+# In[7]:
+
+
+x_vars=df.columns[1:]
+y_vars=df.columns[1:]
+
+
+# In[8]:
+
+
+X,y=prepare_forecasting_data(df,fcst_history=fcst_history,fcst_horizon=fcst_horizon,x_vars=x_vars,y_vars=y_vars)
+X.shape , y.shape
+
+
+# In[9]:
+
+
+arch_config=dict(
+    n_layers=3,
+    n_heads=4,
+    d_model=16,
+    d_ff=128,
+    attn_dropout=0.0,
+    dropout=0.3,
+    patch_len=24,
+    stride=2,
+    padding_patch=True,
+)
+
+
+# In[10]:
+
+
+learn=TSForecaster(X,y,splits=splits,
+                   batch_size=16,path="models",
+                   pipelines=[preproc_pipe,exp_pipe],
+                   arch="PatchTST",
+                   arch_config=arch_config,
+                   metrics=[mse,mae],
+                   cbs=ShowGraph())
+
+
+# In[11]:
+
+
+learn.summary()
+
+
+# In[12]:
+
+
+lr_max=learn.lr_find().valley
+
+
+# In[ ]:
+
+
+n_epochs=100
+
+learn.fit_one_cycle(n_epoch=n_epochs,lr_max=lr_max)
+learn.export('PatchTST.pt')
+
+
+# In[14]:
+
+
+from tsai.inference import load_learner
+from sklearn.metrics import mean_squared_error, mean_absolute_error
+from sklearn.metrics import mean_absolute_percentage_error
+
+learn=load_learner('models/PatchTST.pt')
+y_test_preds, *_=learn.get_X_preds(X[splits[2]])
+y_test_preds=to_np(y_test_preds)
+print(y_test_preds.shape)
+
+y_test=y[splits[2]]
+
+print(mean_squared_error(y_test.flatten(),y_test_preds.flatten()))
+print(mean_absolute_error(y_test.flatten(),y_test_preds.flatten()))
+print(mean_absolute_percentage_error(y_test.flatten(),y_test_preds.flatten()))
+
+
+# In[15]:
+
+
+X_test=X[splits[2]]
+plot_forecast(X_test,y_test,y_test_preds,sel_vars=True)
+
+
+# In[16]:
+
+
+fcst_date="2023-07-31 23:00:00"
+dates=pd.date_range(start=None,end=fcst_date,periods=fcst_history,freq=freq)
+dates
+
+
+# In[17]:
+
+
+#df=pd.read_csv('D:/project/aircompressordata.csv')
+#df=preproc_pipe.fit_transform(df)
+
+new_df=df[df[datetime_col].isin(dates)].reset_index(drop=True)
+new_df
+
+
+# In[18]:
+
+
+from tsai.inference import load_learner
+
+predict=load_learner('models/PatchTST.pt')
+new_df=predict.transform(new_df)
+
+new_df
+
+
+# In[19]:
+
+
+x_feat=new_df.columns[1:]
+new_x,__=prepare_forecasting_data(new_df,fcst_history=fcst_history,fcst_horizon=0,x_vars=x_vars,y_vars=y_vars)
+new_x.shape
+
+
+# In[20]:
+
+
+new_scaled_preds, *_ = learn.get_X_preds(new_x)
+
+new_scaled_preds=to_np(new_scaled_preds).swapaxes(1,2).reshape(-1,len(y_vars))
+dates=pd.date_range(start=fcst_date, periods=fcst_horizon+1,freq='1H')[1:]
+preds_df=pd.DataFrame(dates,columns=[datetime_col])
+preds_df.loc[:, y_vars]=new_scaled_preds
+preds_df=learn.inverse_transform(preds_df)
+
+preds_df
+
+
+# In[1]:
+
+
+from tsai.export import get_nb_name; nb_name=get_nb_name(locals())
+from tsai.imports import  create_scripts; create_scripts(nb_name)
+
+
+# In[ ]:
+
+
+
+

test.py

@@ -0,0 +1,16 @@
+import pandas as pd
+import Generate
+import config
+
+Aircomp_df=pd.read_csv('D:/project/aircompressordata.csv')
+#df=Aircomp_df.drop(config.DROP_COLOUMNS,axis=1)
+Energy_df=pd.read_csv('D:/project/energymeter.csv')
+boiler_df=pd.read_csv('D:/project/Boiler1.csv')
+'''
+preds=Generate.inference_Aircomp("2023-07-31 23:00:00",Aircomp_df)
+print(preds)
+preds=Generate.inference_Energy("2023-07-13 12:00:50",Energy_df)
+print(preds)
+'''
+preds=Generate.inference_boiler("2023-04-30 01:59:00",boiler_df)
+print(preds)