I'm using my multivariate forecasting model through a function to make future…
- User
I'm using my multivariate forecasting model through a function to make future predictions the forecast windows back and to the future is 40 and thus the future prediction function is outputting a tensor of (50, 48, 19) my test data is (145, 19). My function is as below, what do I have to do to maybe average -out the overlapping values in the future predictions to get something that aligns and I can plot with (x,19) shape similar to the test data# Function to make predictions with the model def make_predictions(model, data, input_seq_length, output_seq_length): model.eval() device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') predictions = []
with torch.no_grad(): for i in range(len(data) - input_seq_length - output_seq_length + 1): # Convert DataFrame slice to numpy array first, then to tensor x = torch.tensor(data.iloc[i:i+input_seq_length].values, dtype=torch.float32).unsqueeze(0).to(device) # If input is univariate, add feature dimension if len(x.shape) == 2: x = x.unsqueeze(-1) batch_size = x.size(0) decoder_input = torch.zeros(batch_size, 1, x.size(2)).to(device) decoder_input[:, 0, :] = x[:, -1, :] # Initial input to decoder is last input of encoder outputs = [] for * in range(output*seq_length): # Fixed the syntax error in the loop out = model(x, decoder_input) next_input = out[:, -1:, :] # Take the last time step outputs.append(next_input) decoder_input = torch.cat([decoder_input, next_input], dim=1) outputs = torch.cat(outputs, dim=1) predictions.append(outputs.squeeze(0).cpu().numpy()) return np.array(predictions)I want to write a function to take the predictions from the function make_predictions() and the new function -should be called average_overlapping_predictions()- should accumulate the overlapping predictions and return data in the shape of (x, number of features) def average_overlapping_predictions(predictions, input_seq_length, output_seq_length, total_length) and should return: averaged_overlapping_predictions, (start_idx, end_idx)
- Assistant
To address your need for averaging overlapping predictions from your multivariate forecasting model, you can implement the
average_overlapping_predictionsfunction as follows. This function will accumulate the overlapping predictions and average them to align with your test data shape(145, 19).Here's a step-by-step implementation:
-
Initialize Aggregation Arrays: Create two arrays, one for accumulating prediction sums and another for counting the number of overlaps at each time step.
-
Map Predictions to the Total Sequence: Iterate through each prediction window and add its values to the corresponding positions in the aggregation array. Simultaneously, increment the counts to keep track of how many predictions overlap at each time step.
-
Compute the Average: After accumulating all predictions, divide the aggregated sums by the counts to obtain the averaged predictions.
-
Handle Edge Cases: Ensure that divisions by zero are handled gracefully and determine the start and end indices of the valid prediction range.
Here's the complete implementation:
import numpy as np def average_overlapping_predictions(predictions, input_seq_length, output_seq_length, total_length): """ Averages overlapping predictions to align with the total sequence length. Parameters: - predictions (np.ndarray): Array of shape (num_windows, output_seq_length, num_features) - input_seq_length (int): Length of the input sequence used by the model - output_seq_length (int): Length of the output sequence predicted by the model - total_length (int): Total length of the sequence to align predictions with Returns: - averaged_predictions (np.ndarray): Averaged predictions of shape (aligned_length, num_features) - (start_idx, end_idx) (tuple): Indices indicating the range of the aligned predictions """ num_windows, pred_length, num_features = predictions.shape # Initialize arrays to accumulate sums and counts aggregated = np.zeros((total_length, num_features)) counts = np.zeros(total_length) for i in range(num_windows): # Calculate the start and end indices in the total sequence start = i end = i + pred_length # Adjust if the prediction window exceeds the total length if end > total_length: end = total_length pred_slice = predictions[i, :end - start, :] else: pred_slice = predictions[i] # Accumulate the sums aggregated[start:end] += pred_slice # Count the number of overlaps counts[start:end] += 1 # Avoid division by zero by setting zero counts to one temporarily counts_with_no_zeros = np.where(counts == 0, 1, counts) # Compute the averaged predictions averaged = aggregated / counts_with_no_zeros[:, None] # Optionally, identify the range of indices that have been predicted covered = counts > 0 if np.any(covered): start_idx = np.argmax(covered) end_idx = total_length - np.argmax(covered[::-1]) averaged_predictions = averaged[start_idx:end_idx] else: # If no predictions cover any part, return an empty array averaged_predictions = np.empty((0, num_features)) start_idx, end_idx = 0, 0 return averaged_predictions, (start_idx, end_idx)How to Use the Function
-
Ensure Proper Alignment: The function assumes that the first prediction corresponds to the time steps starting at index
0. If your predictions start after some initial input sequence (input_seq_length), adjust thestartindex accordingly. -
Call the Function with Appropriate Parameters:
# Example usage predictions = make_predictions(model, test_data, input_seq_length=105, output_seq_length=40) total_length = 145 # Length of your test data averaged_preds, (start, end) = average_overlapping_predictions( predictions=predictions, input_seq_length=105, output_seq_length=40, total_length=total_length ) print("Averaged Predictions Shape:", averaged_preds.shape) print("Covered Indices:", start, "to", end)- Plotting the Results: Now,
averaged_predswill have a shape close to(x, 19), aligning with your test data. You can plot it alongside your test data for comparison.
Important Considerations
-
Overlapping Strategy: This function assumes that each prediction window starts one time step after the previous one. If your windows have a different stride, adjust the
startindex accordingly. -
Edge Predictions: Predictions that extend beyond the
total_lengthare truncated to fit within the bounds. Ensure that your model's predictions align well with the intended time steps. -
Input Sequence Offset: If your predictions start after an
input_seq_length, you might need to offset thestartindex byinput_seq_lengthto align with the test data correctly.
Example with Offset
If your first prediction corresponds to the time step immediately after the input sequence, modify the loop as follows:
for i in range(num_windows): # Adjust start by input_seq_length start = i + input_seq_length end = start + pred_length # Rest of the loop remains the sameThen, call the function accordingly:
averaged_preds, (start, end) = average_overlapping_predictions( predictions=predictions, input_seq_length=105, output_seq_length=40, total_length=145 )This adjustment ensures that predictions are placed correctly relative to the input sequence in your test data.
Conclusion
By using the
average_overlapping_predictionsfunction, you can effectively average out overlapping predictions from your model, resulting in a coherent and aligned prediction sequence that matches the shape of your test data. This method ensures that the overlapping parts are smoothed by averaging, reducing potential inconsistencies between prediction windows. -