predicting last forecast_length (not tested yet)

app.py

@@ -19,116 +19,18 @@ model: ForecastModel = load_model("NX-AI/TiRex",device='cuda')
 
 def model_forecast(input_data, forecast_length=256, file_name=None):
     if os.path.basename(file_name) == "loop.csv":
-        _forecast_tensor = torch.load("data/loop_forecast_512.pt")
+        _forecast_tensor = torch.load("data/loop_forecast_256.pt")
         return _forecast_tensor[:,:forecast_length,:]
     elif os.path.basename(file_name) == "ett2.csv":
-        _forecast_tensor = torch.load("data/ett2_forecast_512.pt")
+        _forecast_tensor = torch.load("data/ett2_forecast_256.pt")
         return _forecast_tensor[:,:forecast_length,:]
     elif os.path.basename(file_name) == "air_passangers.csv":
-        _forecast_tensor = torch.load("data/air_passengers_forecast_512.pt")
+        _forecast_tensor = torch.load("data/air_passengers_forecast_48.pt")
         return _forecast_tensor[:,:forecast_length,:]
     else:
         forecast = model.forecast(context=input_data, prediction_length=forecast_length)
         return forecast[0]
 
-    
-
-def plot_forecast_plotly(timeseries, quantile_predictions, timeseries_name):
-    """
-    - timeseries: 1D list/array of historical values.
-    - quantile_predictions: 2D array of shape (pred_len, n_q),
-      with quantiles sorted left→right.
-    - timeseries_name: string label.
-    """
-    fig = go.Figure()
-
-    # 1) Plot historical data (blue line, no markers)
-    x_hist = list(range(len(timeseries)))
-    fig.add_trace(go.Scatter(
-        x=x_hist,
-        y=timeseries,
-        mode="lines",  # no markers
-        name=f"{timeseries_name} – Given Data",
-        line=dict(color="blue", width=2),
-    ))
-
-    # 2) X-axis indices for forecasts
-    pred_len = quantile_predictions.shape[0]
-    x_pred = list(range(len(timeseries) - 1, len(timeseries) - 1 + pred_len))
-
-    # 3) Extract lower, upper, and median quantiles
-    lower_q = quantile_predictions[:, 0]
-    upper_q = quantile_predictions[:, -1]
-    n_q = quantile_predictions.shape[1]
-    median_idx = n_q // 2
-    median_q = quantile_predictions[:, median_idx]
-
-    # 4) Lower‐bound trace (invisible line, still shows on hover)
-    fig.add_trace(go.Scatter(
-        x=x_pred,
-        y=lower_q,
-        mode="lines",
-        line=dict(color="rgba(0, 0, 0, 0)", width=0),
-        name=f"{timeseries_name} – 10% Quantile",
-        hovertemplate="Lower: %{y:.2f}<extra></extra>"
-    ))
-
-    # 5) Upper‐bound trace (shaded down to lower_q)
-    fig.add_trace(go.Scatter(
-        x=x_pred,
-        y=upper_q,
-        mode="lines",
-        line=dict(color="rgba(0, 0, 0, 0)", width=0),
-        fill="tonexty",
-        fillcolor="rgba(128, 128, 128, 0.3)",
-        name=f"{timeseries_name} – 90% Quantile",
-        hovertemplate="Upper: %{y:.2f}<extra></extra>"
-    ))
-
-    # 6) Median trace (orange) on top
-    fig.add_trace(go.Scatter(
-        x=x_pred,
-        y=median_q,
-        mode="lines",
-        name=f"{timeseries_name} – Median Forecast",
-        line=dict(color="orange", width=2),
-        hovertemplate="Median: %{y:.2f}<extra></extra>"
-    ))
-
-    # 7) Layout: title on left (y=0.95), legend on right (y=0.95)
-    fig.update_layout(
-        template="plotly_dark",
-        title=dict(
-            text=f"Timeseries: {timeseries_name}",
-            x=0.10,                     # left‐align
-            xanchor="left",
-            y=0.90,                  # near top
-            yanchor="bottom",
-            font=dict(size=18, family="Arial", color="white")
-        ),
-        xaxis=dict(
-                rangeslider=dict(visible=True),  # <-- put rangeslider here
-                fixedrange=False
-            ),
-        xaxis_title="Time",
-        yaxis_title="Value",
-        hovermode="x unified",
-        margin=dict(
-            t=120,  # increase top margin to fit title+legend comfortably
-            b=40,
-            l=60,
-            r=40
-        ),
-        # height=plot_height,
-        # width=plot_width,
-        autosize=True,
-    )
-
-    return fig
-
-
-
-
 
 def load_table(file_path):
     ext = file_path.split(".")[-1].lower()
@@ -225,13 +127,19 @@ def display_filtered_forecast(file, preset_filename, selected_names, forecast_le
                 df = pd.concat([ df.iloc[:, [0]], df.iloc[:, -2048:] ], axis=1)
                 gr.Info("Maximum of 2048 steps per timeseries (row) is allowed, hence last 2048 kept. ℹ️", duration=5)
             all_names = df.iloc[:, 0].tolist()
-            data_only = df.iloc[:, 1:].astype(float)
+            data_only_full = df.iloc[:, 1:].astype(float)
         else:
             if df.shape[1]>2048:
                 df = df.iloc[:, -2048:]
                 gr.Info("Maximum of 2048 steps per timeseries (row) is allowed, hence last 2048 kept. ℹ️", duration=5)
             all_names = [f"Series {i}" for i in range(len(df))]
-            data_only = df.astype(float)
+            data_only_full = df.astype(float)
+        
+        # ** Cut timeseries into 2 series, context and prediction
+        if data_only_full.shape[1]<forecast_length+10:
+            raise gr.Error("Timeseries should have the minimum length of (forecast_length+10)!", duration=5)
+        y_true = data_only_full.iloc[:, -forecast_length:]
+        data_only = data_only_full.iloc[:, :-forecast_length]
 
         # 4) Build mask from selected_names
         mask = [name in selected_names for name in all_names]
@@ -239,6 +147,8 @@ def display_filtered_forecast(file, preset_filename, selected_names, forecast_le
             return None, "No timeseries chosen to plot."
 
         filtered_data = data_only.iloc[mask, :].values   # shape = (n_selected, seq_len)
+        filtered_data_only_full = data_only_full.iloc[mask, :].values # ** Added to show prediction accuracy
+        
         filtered_names = [all_names[i] for i, m in enumerate(mask) if m]
         n_selected = filtered_data.shape[0]
         if n_selected>30:
@@ -251,6 +161,7 @@ def display_filtered_forecast(file, preset_filename, selected_names, forecast_le
         # Now pick only the rows we actually filtered
         out = full_out[mask, :, :]    # shape = (n_selected, pred_len, n_q)
         inp = torch.tensor(filtered_data)
+        inp_full = torch.tensor(filtered_data_only_full) # ** Added to show prediction accuracy
 
         # 6) Create one subplot per selected series, with vertical spacing
         subplot_height_px = 350  # px per subplot
@@ -270,15 +181,16 @@ def display_filtered_forecast(file, preset_filename, selected_names, forecast_le
 
         for idx in range(n_selected):
             ts = inp[idx].numpy().tolist()
+            ts_full = inp_full[idx].numpy().tolist()
             qp = out[idx].numpy()
             series_name = filtered_names[idx]
 
             # a) plot historical data (blue line)
-            x_hist = list(range(len(ts)))
+            x_hist = list(range(len(ts_full)))
             fig.add_trace(
                 go.Scatter(
                     x=x_hist,
-                    y=ts,
+                    y=ts_full,
                     mode="lines",
                     name=f"{series_name} – Given Data",
                     line=dict(color="blue", width=2),
@@ -290,6 +202,8 @@ def display_filtered_forecast(file, preset_filename, selected_names, forecast_le
             # b) compute forecast indices
             pred_len = qp.shape[0]
             x_pred = list(range(len(ts) - 1, len(ts) - 1 + pred_len))
+            #x_pred = list(range(len(ts), len(ts) + pred_len))
+
 
             lower_q = qp[:, 0]
             upper_q = qp[:, -1]
@@ -340,6 +254,7 @@ def display_filtered_forecast(file, preset_filename, selected_names, forecast_le
                 ),
                 row=idx + 1, col=1
             )
+            
 
             # f) label axes for each subplot
             fig.update_xaxes(title_text="Time", row=idx + 1, col=1)
@@ -498,5 +413,5 @@ with gr.Blocks(fill_width=True,theme=gr.themes.Ocean()) as demo:
 '''
 gradio app.py
 ssh -L 7860:localhost:7860 nikita_blago@oracle-gpu-controller -t \
-   ssh -L 7860:localhost:7860 compute-permanent-node-83 
+   ssh -L 7860:localhost:7860 compute-permanent-node-368
 '''

data/air_passengers_forecast_48.pt

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

data/ett2_forecast_256.pt

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

data/loop_forecast_256.pt

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

test_app.py

@@ -1,39 +0,0 @@
-import gradio as gr
-import time # Import time to make logs more distinct
-
-def greet(name):
-    """
-    This function takes a name as input and returns a personalized greeting string.
-    It now includes print statements for logging with flush=True to ensure
-    logs appear immediately in container environments like Hugging Face Spaces.
-    """
-    # Log the function entry
-    # The flush=True argument is crucial for logs to appear in real-time in Docker.
-    print(f"[{time.ctime()}] - Function 'greet' was called.", flush=True)
-
-    if name:
-        # Log the received input
-        print(f"[{time.ctime()}] - Received input name: '{name}'", flush=True)
-        return f"Hello, {name}! Welcome to your first Gradio app."
-    else:
-        # Log that the input was empty
-        print(f"[{time.ctime()}] - No input name received.", flush=True)
-        return "Hello! Please enter your name."
-
-# Create the Gradio interface
-app = gr.Interface(
-    fn=greet,
-    inputs=gr.Textbox(
-        lines=1, 
-        placeholder="Please enter your name here...", 
-        label="Your Name"
-    ),
-    outputs=gr.Text(label="Greeting"),
-    title="Simple Greeting App with Logging",
-    description="Enter your name to receive a greeting. Check the Hugging Face logs to see the output from the print() statements."
-)
-
-# Launch the application
-if __name__ == "__main__":
-    print(f"[{time.ctime()}] - Starting Gradio server...", flush=True)
-    app.launch(server_name="0.0.0.0", server_port=7860)