@support Thank you so much. I have resolved this error

@multi_byte-wildebeest Hello. I don't use machine learning models in trading.

@support Got it, thanks a lot!

@dark-pidgeot Yes, of course. Please note that we do not implement leverage, and the sum of the absolute values of the weights has to be equal or smaller than 1. If it is larger, they will be rescaled down.

@support Thank you!

@support Thanks for ur help

@auxiliary-snail Hi,

unfortunately, this is not allowed and in accordance with the rules. Using hard-coded time periods in which trading algorithm will work differently, is not a quantitative method (just like manual asset selection, e.g. "trade only Apple or Microsoft"). We still haven't implemented a mechanism for automatic recognition of such behaviors in trading strategies, and even though a strategy could be successfully submitted, it will not be eligible for prize winning.
What we are searching for, is well performing strategy over entire in_sample period (SR>0.7), robust to all market movements 2006-2025, so we can expect it will perform well in future, too.

Thanks !

@support yes coarse heuristics work well as long as you are conservative. For shorter term models I have started using minute bars despite the computational hit, because it helps in a lot of other ways.

I may enter this contest, I am pretty rusty on predictive modelling and I am not sure I can do a good job using just daily prices, there is not a lot of data. I used to work at a CTA and I feel like we wasted a lot of man years using only prices, hoping better models would acheive more alpha. in the end the sharpe is similar to the S&P but uncorrelated, but you have gotten there with some simpler models and enjoyed life.

I have some other questions about the platform and the contest that I will post here.

Best
P.M.

@support Ok, I see, thanks

@cespadilla Hello.

The reason is in "train_model" function.

def train_model(data): asset_name_all = data.coords['asset'].values features_all = get_features(data) target_all = get_target_classes(data) models = dict() for asset_name in asset_name_all: # drop missing values: target_cur = target_all.sel(asset=asset_name).dropna('time', 'any') features_cur = features_all.sel(asset=asset_name).dropna('time', 'any') target_for_learn_df, feature_for_learn_df = xr.align(target_cur, features_cur, join='inner') if len(features_cur.time) < 10: continue model = get_model() try: model.fit(feature_for_learn_df.values, target_for_learn_df) models[asset_name] = model except: logging.exception('model training failed') return models

If there are less than 10 features for training the model, then the model is not created (if len(features_cur.time) < 10).

This condition makes sense. I would not remove it.

The second thing that can affect is the retraining interval of the model ("retrain_interval").

weights = qnbt.backtest_ml( train=train_model, predict=predict_weights, train_period=2 *365, # the data length for training in calendar days retrain_interval=10 *365, # how often we have to retrain models (calendar days) retrain_interval_after_submit=1, # how often retrain models after submission during evaluation (calendar days) predict_each_day=False, # Is it necessary to call prediction for every day during backtesting? # Set it to true if you suspect that get_features is looking forward. competition_type='crypto_daily_long_short', # competition type lookback_period=365, # how many calendar days are needed by the predict function to generate the output start_date='2014-01-01', # backtest start date analyze = True, build_plots=True # do you need the chart? )

@captain-nidoran Fixed, sorry for issue

@cyan-gloom

Hello. The provided code is insufficient to understand the problem.

I assume that a certain function might not be returning the required value (for instance, the function where your model is being created).

I recommend that you check all return values of functions, using tools like display or print. Then, compare them with what is returned in properly working examples.

The state allows you to use data from previous iterations. You can find an example here:
https://github.com/quantiacs/toolbox/blob/2f4c42e33c7ce789dfad5d170444fd542e28c8ae/qnt/examples/004-strategy-futures-multipass-stateful.py

@johback

Hello

More examples are here https://github.com/quantiacs/toolbox/blob/main/qnt/tests/test_fundamental_data.py

This is a simple example.

import qnt.data as qndata import datetime as dt import qnt.data.secgov_indicators import qnt.data as qndata import qnt.stats as qns assets = qndata.stocks.load_ndx_list(tail=dt.timedelta(days=5 * 365)) assets_names = [i["id"] for i in assets] data = qndata.stocks.load_ndx_data(tail=dt.timedelta(days=5 * 365), dims=("time", "field", "asset"), assets=assets_names, forward_order=True) facts_names = ['operating_expense'] # 'assets', 'liabilities', 'ivestment_short_term' and other fundamental_data = qnt.data.secgov_load_indicators(assets, time_coord=data.time, standard_indicators=facts_names) # Operating expenses include marketing, noncapitalized R&D, # travel and entertainment, office supply, rent, salary, cogs... weights = fundamental_data.sel(field='operating_expense') is_liquid = data.sel(field="is_liquid") weights = weights * is_liquid # calc stats stats = qns.calc_stat(data, weights.sel(time=slice("2006-01-01", None))) display(stats.to_pandas().tail()) # graph performance = stats.to_pandas()["equity"] import qnt.graph as qngraph qngraph.make_plot_filled(performance.index, performance, name="PnL (Equity)", type="log")

Thanks for the answer!

I still think something is wrong with this correlation checker. I even used this function to randomize the weights a few times, and I got the same correlation error:

def add_random_noise(weights, noise_level=0.01): noise = np.random.uniform(-noise_level, noise_level, size=weights.shape) return weights + noise

I am pretty sure it's impossible to have 90% correlation in this case.

@buyers_are_back Hello.
Here is a new example of stock prediction using index data.
I recommend using the single-pass version.
https://quantiacs.com/documentation/en/data/indexes.html

@vyacheslav_b Apologies for the late response. Thanks for the assistance, all is now well. Cheers

@cross_platform-zebra Hi, there is no other limitation regarding local development. It is already configured to be exactly the same datasets for Nasdaq100 stocks, and returns the same statistics for trading system running locally or online.

@support
Thanks a lot !

@theflyingdutchman Hello,

Another option is to rewrite your strategy for a single-pass version before submitting it. This approach will significantly speed up the calculations. However, it's important to note that the actual statistical values can only be tracked after submitting the strategy to the competition.

For example:
https://github.com/quantiacs/strategy-ml-crypto-long-short/blob/master/strategy.ipynb

To adapt this strategy for a single-pass version, follow these steps:

Comment out or delete the line where qnbt.backtest_ml is used. Insert the following code: import xarray as xr import qnt.ta as qnta import qnt.data as qndata import qnt.output as qnout import qnt.stats as qnstats retrain_interval = 3*365 + 1 data = qndata.stocks.load_ndx_data(tail=retrain_interval) models = train_model(data) weights = predict(models, data) In a new cell, insert code to save the weights: qnout.write(weights)

To view the strategy's statistics, use the following code in a new cell:

# Calculate stats stats = qnstats.calc_stat(data, weights) display(stats.to_pandas().tail()) # Graph performance = stats.to_pandas()["equity"] import qnt.graph as qngraph qngraph.make_plot_filled(performance.index, performance, name="PnL (Equity)", type="log")

The qnbt.backtest_ml function is a unique tool for evaluating machine learning strategies, which stands out from what is offered on other platforms. It allows users to set retraining intervals and analyze statistical metrics of the strategy, as opposed to the traditional evaluation of the machine learning model. This provides a deeper understanding of the strategy's effectiveness under various market conditions.