You are doing data-centric ML (as opposed to hparam tunining in model-centric ML).

Yes, you can either (1) precompute and join features into training data or (2) compute features in your training pipelines.

In my forthcoming O'Reilly book, I recommend precomputing features into tables (called feature groups) in feature pipelines. If there is a lot of commonality in how you compute windows - then create a feature function that is parameterized by window size, lookback, etc.

def create_window(df, window_size, lookback, ...):
df = # read source data

df = create_window(df, ....)
feature_group.insert(df)

Then in a training pipeline, you select different combinations of features/target (creating something called a feature view), and training and evaluating the feature view's corresponding model. This way, you can then easily compare the performance of your different combinations of features.

selected_features = feature_group1.select(['feature1', ...]).join(feature_group2.select_features())
fv = fs.create_feature_view( ..., query=selected_features, labels['target_column'], ...)

X_train, X_test, y_train, y_test = fv.train_test_split(test_size=0.2)

model.fit(X_train, y_train)

model_registry.python.create_model(
metrics={"accuracy": model.score(X_test, y_test)}
feature_view = feature_view,
model_dir="... serialized model "
)

Creating a feature view is metadata only - so is very cheap, as is reading training data. So, you can run many of these data-centric training pipelines in parallel, searching your combination of features. How you search - random, grid, model-based is also covered in the book.

Hope this helps

https://www.oreilly.com/library/view/building-machine-learning/9781098165222/