def normalize(output, per_asset=False):
    from qnt.data.common import ds
    output = output.where(np.isfinite(output)).fillna(0)
    if ds.TIME in output.dims:
        output = output.transpose(ds.TIME, ds.ASSET)
        output = output.loc[
            np.sort(output.coords[ds.TIME].values),
            np.sort(output.coords[ds.ASSET].values)
        ]
    if per_asset:
        output = xr.where(output > 1, 1, output)
        output = xr.where(output < -1, -1, output)
    else:
        s = abs(output).sum(ds.ASSET)
        if ds.TIME in output.dims:
            s[s < 1] = 1
        else:
            s = 1 if s < 1 else s
        output = output / s
    try:
        output = output.drop_vars(ds.FIELD)
    except ValueError:
        pass
    return output

Example with two assets

import xarray as xr
from qnt.data.common import ds
from qnt.output import normalize

times  = ['2025-06-16']
assets = ['Asset1', 'Asset2']

out1 = xr.DataArray([[1.5, 0.5]],
                    coords={ds.TIME: times, ds.ASSET: assets},
                    dims=[ds.TIME, ds.ASSET])
print(normalize(out1).values)

out2 = xr.DataArray([[0.3, -0.2]],
                    coords={ds.TIME: times, ds.ASSET: assets},
                    dims=[ds.TIME, ds.ASSET])
print(normalize(out2).values)

Console output

[[0.75 0.25]]
[[ 0.3  -0.2 ]]

Example 1: The absolute exposure is 2 > 1, so every weight is divided by 2, yielding 0.75 and 0.25.

Example 2: The exposure is 0.5 < 1, so the scaling factor is set to 1 and the weights stay 0.3 and –0.2.

In short, even if your strategy outputs more than 100 % exposure, normalize always scales it back so the total absolute exposure never exceeds 1—preventing leverage on the Quantiacs platform.

@support Hi, I just checked out qnt 0.0.504 and the problem I mentioned seems to be fixed now, thanks!
Would you perhaps consider to add a leverage check to the check function?
Because one might think "qnout.check says everything is OK, so I have a valid portfolio" while actually having vastly overleveraged like in my 2nd example where weights.sum('asset').values.max() is 505.0.
Adding something like this to check would tell us about it:

log_info("Check max portfolio leverage...")
max_leverage = abs(output).sum(ds.ASSET).values.max()
if max_leverage > 1 + 1e-13: # (give some leeway for rounding errors and such)
    log_err("ERROR! The max portfolio leverage is too high.")
    log_err(f"Max leverage: {max_leverage} Limit: 1.0")
    log_err("Use qnt.output.clean() or normalize() to fix.")
else:
    log_info("Ok.")

I don’t quite understand why you’re calculating the next trading date manually. According to the documentation and this official example, it works like this:

Strategy. Weights allocation
Every day, the algorithm determines how much of each asset should be in the portfolio for the next trading day.
These are called the portfolio weights.
A positive weight means you'll be buying that asset, while a negative weight means you'll be selling it.
These decisions are made at the end of each day and put into effect at the beginning of the next trading day.

There’s a clear visual example in the notebook showing how this works. So there’s no need to manually add or compute the next date — the platform takes care of that automatically.

As for the max weights — I didn’t quite understand what the issue is. If you look at the source code of a function like cut_big_positions, you’ll see something like this:

weights_1 = xr.where(abs(weights) > 0.05, np.sign(weights) * 0.05, weights)

This simply limits all weights that are greater than ±0.05 to exactly ±0.05. So if you’re seeing a value like 0.05882353, it’s likely either before this restriction is applied, or maybe you're looking at a version of the weights before post-processing.

You are absolutely correct, we will fix check() function ASAP. It should only cut weights which exceed 0.1 allocation by asset, and normalize the sum of allocation to maximum 1, on every timestamp. If sum was < 1, and weight of an asset < 0.1, the output remains the same.
Thanks a lot for pointing this out with examples.

I always assumed this would mean the maximum weight for an asset would be 0.1 meaning 10 % of the portfolio. However the exposure calculation suggests the following:
Either we trade no asset or at least 10 assets per trading day, regardless of the actual weights assigned to each asset.

Consider this example:

import qnt.data as qndata
import qnt.output as qnout
from qnt.filter import filter_sharpe_ratio


data = qndata.stocks.load_spx_data(min_date="2005-01-01")

weights = data.sel(field='is_liquid').fillna(0)
weights *= filter_sharpe_ratio(data, weights, 3) * .01 # assign 1 % to each asset using the top 3 assets by sharpe

qnout.check(weights, data, "stocks_s&p500")

which results in an exposure error:

Check max exposure for index stocks (nasdaq100, s&p500)…
ERROR! The max exposure is too high.
Max exposure: [0.         0.         0.         ... 0.33333333 0.33333333 0.33333333] Hard limit: 0.1
Use qnt.output.cut_big_positions() or normalize_by_max_exposure() to fix.

even though the maximum weight per asset is only 0.01

abs(weights).values.max()
0.01

(By the way, the 4 functions mentioned by @Vyacheslav_B also result in weights which dont't pass the exposure check when used with this example, except drop_bad_days which results in empty weights.)

And if we assign 100 % to every liquid asset, the exposure check passes:

weights = data.sel(field='is_liquid').fillna(0)
qnout.check(weights, data, "stocks_s&p500")

Check max exposure for index stocks (nasdaq100, s&p500)…
Ok.

So, does rule 7. o. mean we have to trade at least 10 assets or none at all each trading day to satisfy the exposure check?

1. I checked my code, and I found that I loaded the data by using load_spx_data() instead of load_ndx_data()
   But I added the next trading date to the original data in order to write the latest weight. Does this operation cause the warning?
2. I checked the dataframe of the final weights, and I use the MAX() and the MIN() in excel to check the maximum and the minimum value of the weights, the maximum weight is 0.05, and the minimum weight is -0.05, which is different from the value 0.05882353 showing on the screen.
   

1. Check which dataset you're loading

You might have loaded stocks_nasdaq100, but are checking it as if it were stocks_s&p500.

Incorrect:

import qnt.data as qndata
import qnt.ta as qnta
import qnt.stats as qnstats
import qnt.output as qnout
import xarray as xr

data = qndata.stocks.load_ndx_data(min_date="2005-06-01")
qnout.check(weights, data, kind="stocks_s&p500")

Correct:

data = qndata.stocks.load_spx_data(min_date="2005-06-01")
qnout.check(weights, data, kind="stocks_s&p500")

️ kind must match the actual dataset being used, otherwise some checks (e.g., liquidity or available dates) will not behave correctly.

2. Handling Exposure

If your exposure does exceed the limit on some days, you can fix it using one of the following methods (see the documentation — Applying Exposure Filters:

import qnt.output as qnout
import qnt.exposure as qnexp

weights_1 = qnexp.cut_big_positions(weights=weights, max_weight=0.049)
weights_2 = qnexp.drop_bad_days(weights=weights, max_weight=0.049)
weights_3 = qnexp.normalize_by_max_exposure(weights, max_exposure=0.049)
weights_4 = qnout.clean(weights, data, "stocks_s&p500")

3. Use clean() instead of check() for auto-correction

If you want the system to automatically fix issues like exposure or normalization, replace check() with clean():

import qnt.output as qnout
weights = qnout.clean(weights, data, "stocks_s&p500")

Exposure of 0.0588 is below the hard limit of 0.1, so in this particular case, it does not violate any constraints. The error may have been triggered by other days or higher values elsewhere in the data — it's worth double-checking.