Posts made by Vyacheslav_B

@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

Hello.

Here's an example of the load_data and window functions.

import qnt.data as qndata

def load_data(period):
    index_data = qndata.index.load_data(tail=period)
    stocks  = qndata.stocks.load_ndx_data(tail=period, assets=["NAS:AAPL", "NAS:AMZN"])
    return {"index_data": index_data, "stocks": stocks}, stocks.time.values
    
    #     futures = qndata.futures.load_data(tail=period, assets=["F_DX"]).isel(asset=0)



def window(data, max_date: np.datetime64, lookback_period: int):
    min_date = max_date - np.timedelta64(lookback_period, "D")
    return {
        "index_data": data["index_data"].sel(time=slice(min_date, max_date)),
        "stocks":  data["stocks"].sel(time=slice(min_date, max_date)),
    }

weights = qnbt.backtest_ml(
    load_data= load_data,
    window= window,
    ...
)

Inside the functions, for accessing the data, use
data["stocks"] instead of data.

You can check out an example of Machine Learning - predicting BTC futures using IMF Commodity Data at
https://github.com/quantiacs/strategy-ml-predict-BTC-use-IMF/blob/master/strategy.ipynb

If you modify the Machine Learning with a Voting Classifier example at
https://github.com/quantiacs/strategy-ml-voting-crypto/blob/master/strategy.ipynb

The use of functions will look like this.

import qnt.data as qndata
import qnt.ta as qnta

def load_data(period):
    index_data = qndata.index.load_data(tail=period)
#     futures = qndata.futures.load_data(tail=period, assets=["F_DX"]).isel(asset=0)
    stocks  = qndata.stocks.load_ndx_data(tail=period, assets=["NAS:AAPL", "NAS:AMZN"])
    return {"index_data": index_data, "stocks": stocks}, stocks.time.values



def window(data, max_date: np.datetime64, lookback_period: int):
    min_date = max_date - np.timedelta64(lookback_period, "D")
    return {
        "index_data": data["index_data"].sel(time=slice(min_date, max_date)),
        "stocks":  data["stocks"].sel(time=slice(min_date, max_date)),
    }

def create_and_train_models(data):
    """Create and train the models working on an asset-by-asset basis."""
    
    asset_name_all = data["stocks"].coords['asset'].values

    data_scile = data["stocks"].sel(time=slice('2013-05-01',None)) # cut the noisy data head before 2013-05-01

    features_all = get_features(data_scile)
    target_all = get_target_classes(data_scile)

    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')

        # align features and targets:
        target_for_learn_df, feature_for_learn_df = xr.align(target_cur, features_cur, join='inner')
        
        if len(features_cur.time) < 10:
            # not enough points for training
            continue

        model = create_model()
        
        try:
            model.fit(feature_for_learn_df.values, target_for_learn_df)
            models[asset_name] = model
        except KeyboardInterrupt as e:
            raise e
        except:
            logging.exception('model training failed')

    return models

def predict(models, data):
    close_index = data["index_data"].sel(asset ="SPX")
    close_stocks  = data["stocks"].sel(field="close")
    sma20 = qnta.sma(close_index, 20)
    sma40 = qnta.sma(close_index, 40)
    weights_index = xr.where(sma20 < sma40, 1, 0)
    
    asset_name_all = data["stocks"].coords['asset'].values
    weights = xr.zeros_like(data["stocks"].sel(field='close'))
    
    for asset_name in asset_name_all:
        if asset_name in models:
            model = models[asset_name]
            features_all = get_features(data["stocks"])
            features_cur = features_all.sel(asset=asset_name).dropna('time','any')
            if len(features_cur.time) < 1:
                continue
            try:
                weights.loc[dict(asset=asset_name,time=features_cur.time.values)] = model.predict(features_cur.values)
            except KeyboardInterrupt as e:
                raise e
            except:
                logging.exception('model prediction failed')
    
                
    return weights * weights_index



weights = qnbt.backtest_ml(
    load_data= load_data,
    window= window,
    train=create_and_train_models,
    predict=predict,
    train_period=10*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='stocks_nasdaq100',  # competition type
    lookback_period=365,      # how many calendar days are needed by the predict function to generate the output
    start_date='2020-01-01',  # backtest start date
    build_plots=True          # do you need the chart?
)

@theflyingdutchman

it can help you. See topic 3) Not enough bid information.

https://github.com/quantiacs/strategy-q20-nasdaq100-quick-start/blob/master/strategy.ipynb

def get_enough_bid_for(data_, weights_):
    time_traded = weights_.time[abs(weights_).fillna(0).sum('asset') > 0]
    is_strategy_traded = len(time_traded)
    if is_strategy_traded:
        return xr.where(weights_.time < time_traded.min(), data_.sel(field="is_liquid"), weights_)
    return weights_


weights_new = get_enough_bid_for(data, weights)
weights_new = weights_new.sel(time=slice("2006-01-01",None))

@eddiee

Hello.

This code looks to the future.
It is needed to train the model.
Pay attention to the name of the variable.

@theflyingdutchman

Hello. try to execute in a separate cell the code which saves weights. This should help.
As far as I understand, this can happen when there is no data for the first day.
The cell where the error occurs will be ignored and the next one will be executed.

qnout.check(weights, data, "stocks_nasdaq100")
qnout.write(weights)

@magenta-kabuto

Compare the two versions of the code.

def regime_trade(series):
    return ""


def strategy(data):
    result = regime_trade(data)
    return result


backtest(strategy=strategy)

in the first case, the available data for a specific date are used.

def regime_trade(series):
    return ""


result = regime_trade(data)

def strategy(data):
    return result


backtest(strategy=strategy)

in the second case, all data is used.

I see that you have a very large Sharpe ratio, I think that you are using something similar to the second option.

@magenta-kabuto

Hello

I see that you are using precheck, this is the fastest way to check the strategy
https://github.com/quantiacs/toolbox/blob/main/qnt/precheck.ipynb

if the strategy statistics are different, your algorithm looks into the future.

does your algorithm calculate the weights to trade every day?

or do you calculate all the weights using all the data in one pass and then use them for a specific date? like cache

@magenta-kabuto

Hello

An example using pandas
One can work with pandas DataFrames at intermediate steps and at the end convert them to xarray data structures:

def get_price_pct_change(prices):
    prices_pandas = prices.to_pandas()
    assets = data.coords["asset"].values
    for asset in assets:
        prices_pandas[asset] = prices_pandas[asset].pct_change()
    return prices_pandas

prices = data.sel(field="close") * 1.0
prices_pct_change = get_price_pct_change(prices).unstack().to_xarray()

@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")

@eddiee

This code works for me. I can give you ideas on what to try.

1. Update the qnt library or reinstall.

2. If it doesn't help, clone the repository

https://github.com/quantiacs/toolbox

git clone https://github.com/quantiacs/toolbox.git

run
qnt/examples/005-01-optimizer.py
and other examples.

You may need to specify API_KEY

You might be able to see exactly where the error occurs in the code.
And you can modify the library code by adding logging for optimize_strategy

@eddiee

Hello. Try to run with other ranges

result = qnop.optimize_strategy(
    data,
    single_pass_strategy,
    qnop.full_range_args_generator(
        wma_period=range(10, 20, 5), # min, max, step
        roc_period=range(5, 15, 5)   # min, max, step
    ),
    workers=1 # you can set more workers when you run this code on your local PC to speed it up
)

Hello colleagues.

The solution in case of predicting one financial instrument can be the following (train_period changed)

def load_data(period):
    return qndata.cryptodaily_load_data(tail=period, assets=['BTC'])


def train_model(data):
    """
        train the LSTM network
    """

    asset_name = 'BTC'

    features_all = get_features(data)
    target_all = get_target_classes(data)

    model = get_model()

    # 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')

    # align features and targets:
    target_for_learn_df, feature_for_learn_df = xr.align(target_cur, features_cur, join='inner')

    criterion = nn.MSELoss()  # define loss function

    optimiser = optim.LBFGS(model.parameters(), lr=0.08)  # we use an LBFGS solver as optimiser
    epochs = 1  # how many epochs 
    for i in range(epochs):
        def closure():  # reevaluates the model and returns the loss (forward pass)
            optimiser.zero_grad()

            # input tensor
            in_ = torch.zeros(1, len(feature_for_learn_df.values))
            in_[0, :] = torch.tensor(np.array(feature_for_learn_df.values))

            # output
            out = model(in_)

            # target tensor
            target = torch.zeros(1, len(target_for_learn_df.values))
            target[0, :] = torch.tensor(np.array(target_for_learn_df.values))

            # evaluate loss
            loss = criterion(out, target)
            loss.backward()

            return loss

        optimiser.step(closure)  # updates weights

    return model


weights = qnbt.backtest_ml(
    load_data=load_data,
    train=train_model,
    predict=predict,
    train_period=1 * 365,  # the data length for training in calendar days
    retrain_interval=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
    build_plots=True  # do you need the chart?
)

@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?
)

@nosaai Hello

Spyder should be run under conda environment

conda activate qntdev
conda install spyder
spyder

an alternative way is to clone the library from https://github.com/quantiacs/toolbox
and develop strategies inside qnt. But I recommend using the approach from the documentation.

@cortezkwan

Hello

I think these examples can help you.

https://quantiacs.com/documentation/en/examples/quick_start.html#an-example-using-pandas

def get_price_pct_change(prices):
    prices_pandas= prices.to_pandas()
    assets= data.coords["asset"].values
    for asset in assets:
        prices_pandas[asset]= prices_pandas[asset].pct_change()
    return prices_pandas


prices= data.sel(field="close") * 1.0
prices_pct_change= get_price_pct_change(prices).unstack().to_xarray()

How to create a dataset yourself

import pandas as pd
import xarray as xr
import numpy as np


class Fields:
    OPEN = "open"
    LOW = "low"
    HIGH = "high"
    CLOSE = "close"
    VOL = "vol"
    DIVS = "divs"
    SPLIT = "split"
    SPLIT_CUMPROD = "split_cumprod"
    IS_LIQUID = 'is_liquid'


f = Fields


class Dimensions:
    TIME = 'time'
    FIELD = 'field'
    ASSET = 'asset'


ds = Dimensions

dims = (ds.FIELD, ds.TIME, ds.ASSET)


def get_base_df():
    try_result = {"schema": {"fields": [{"name": "time", "type": "datetime"}, {"name": "open", "type": "integer"},
                                        {"name": "close", "type": "integer"}, {"name": "low", "type": "integer"},
                                        {"name": "high", "type": "integer"}, {"name": "vol", "type": "integer"},
                                        {"name": "divs", "type": "integer"}, {"name": "split", "type": "integer"},
                                        {"name": "split_cumprod", "type": "integer"},
                                        {"name": "is_liquid", "type": "integer"}], "primaryKey": ["time"],
                             "pandas_version": "0.20.0"}, "data": [
        {"time": "2021-01-30T00:00:00.000Z", "open": 1, "close": 2, "low": 1, "high": 2, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
        {"time": "2021-01-31T00:00:00.000Z", "open": 2, "close": 3, "low": 2, "high": 3, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
        {"time": "2021-02-01T00:00:00.000Z", "open": 3, "close": 4, "low": 3, "high": 4, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
        {"time": "2021-02-02T00:00:00.000Z", "open": 4, "close": 5, "low": 4, "high": 5, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
        {"time": "2021-02-03T00:00:00.000Z", "open": 5, "close": 6, "low": 5, "high": 6, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
        {"time": "2021-02-04T00:00:00.000Z", "open": 6, "close": 7, "low": 6, "high": 7, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
        {"time": "2021-02-05T00:00:00.000Z", "open": 7, "close": 8, "low": 7, "high": 8, "vol": 1000, "divs": 0,
         "split": 0, "split_cumprod": 0, "is_liquid": 1},
    ]}
    columns = [Dimensions.TIME, f.OPEN, f.CLOSE, f.LOW, f.HIGH, f.VOL, f.DIVS, f.SPLIT, f.SPLIT_CUMPROD,
               f.IS_LIQUID]
    rows = try_result['data']
    for r in rows:
        r['time'] = np.datetime64(r['time'])
    pandas = pd.DataFrame(columns=columns, data=rows)
    pandas.set_index(Dimensions.TIME, inplace=True)
    prices_array = pandas.to_xarray().to_array(Dimensions.FIELD)
    prices_array.name = "BTC_TEST"
    prices_array_r = xr.concat([prices_array], pd.Index(['BTC'], name='asset'))
    return prices_array_r


weights = get_base_df()
print(weights)

@magenta-grimer

Hello. Try this

import xarray as xr
import numpy as np

import qnt.backtester as qnbt
import qnt.data as qndata
import qnt.ta as qnta

import qnt.data as qndata
import qnt.ta as qnta
import qnt.output as qnout
import qnt.stats as qns
import qnt.log as qnlog
import qnt.optimizer as qnop
import qnt.backtester as qnbt

import xarray as xr


def align_data_by_time(data, data_for_align):
    data_for_outer = xr.align(data.time, data_for_align, join='outer')[1]
    ff = data_for_outer.ffill(dim='time')
    r = ff.sel(time=data.time)
    return r


min_date = '2014-01-01'
cryptofutures = qndata.cryptofutures.load_data(min_date=min_date)

futures = align_data_by_time(
    data=cryptofutures,
    data_for_align=qndata.futures.load_data(min_date=min_date, assets=["F_DX"]))

data = {"futures": futures, "cryptofutures": cryptofutures}


def strategy(data, param1=20, param2=20):
    close_futures = data["futures"].sel(field="close").drop('asset')
    close_crypto = data["cryptofutures"].sel(field="close")
    sma20 = qnta.sma(close_futures, param1)
    sma20_crypto = qnta.sma(close_crypto, param2)
    a = xr.where(sma20 < sma20_crypto, 1, -1)
    return a


def stats_function(data, output):
    start_date = qns.get_default_is_start_date_for_type('cryptofutures')
    stat = qns.calc_stat(data['cryptofutures'], output.sel(time=slice(start_date, None)))
    return stat.isel(time=-1).to_pandas().to_dict()


result = qnop.optimize_strategy(
    data,
    strategy,
    qnop.full_range_args_generator(
        param1=range(5, 150, 15),  # min, max, step
        param2=range(5, 100, 15)  # min, max, step
    ),
    workers=1,  # you can set more workers on your PC
    stats_function=stats_function,
)

qnop.build_plot(result)

print("---")
print("Best iteration:")
print(result['best_iteration'])

@spancham Hello. Try this

import xarray as xr

import qnt.backtester as qnbt
import qnt.data as qndata
import numpy as np
import pandas as pd
import logging


def load_data(period):
    return qndata.cryptofutures.load_data(tail=period)


def predict_weights(market_data):

    def get_ml_model():
        # you can use any machine learning model
        from sklearn.linear_model import RidgeClassifier
        model = RidgeClassifier(random_state=18)
        return model

    def get_features_dict(data):
        def get_features_for(asset_name):
            data_for_instrument = data.copy(True).sel(asset=[asset_name])

            # Feature 1
            price = data_for_instrument.sel(field="close").ffill('time').bfill('time').fillna(0)  # fill NaN
            price_df = price.to_dataframe()

            # Feature 2
            vol = data_for_instrument.sel(field="vol").ffill('time').bfill('time').fillna(0)  # fill NaN
            vol_df = vol.to_dataframe()

            # Merge dataframes
            for_result = pd.merge(price_df, vol_df, on='time')
            for_result = for_result.drop(['field_x', 'field_y'], axis=1)

            return for_result

        features_all_assets = {}

        asset_all = data.asset.to_pandas().to_list()
        for asset in asset_all:
            features_all_assets[asset] = get_features_for(asset)

        return features_all_assets

    def get_target_classes(data):
        # for classifiers, you need to set classes
        # if 1 then the price will rise tomorrow

        price_current = data.sel(field="close").dropna('time')  # rm NaN
        price_future = price_current.shift(time=-1).dropna('time')

        class_positive = 1
        class_negative = 0

        target_is_price_up = xr.where(price_future > price_current, class_positive, class_negative)
        return target_is_price_up.to_pandas()

    data = market_data.copy(True)

    asset_name_all = data.coords['asset'].values
    features_all_df = get_features_dict(data)
    target_all_df = get_target_classes(data)

    predict_weights_next_day_df = data.sel(field="close").isel(time=-1).to_pandas()

    for asset_name in asset_name_all:
        target_for_learn_df = target_all_df[asset_name]
        feature_for_learn_df = features_all_df[asset_name][:-1]  # last value reserved for prediction

        # align features and targets
        target_for_learn_df, feature_for_learn_df = target_for_learn_df.align(feature_for_learn_df, axis=0,
                                                                              join='inner')

        model = get_ml_model()
        try:
            model.fit(feature_for_learn_df.values, target_for_learn_df)

            feature_for_predict_df = features_all_df[asset_name][-1:]

            predict = model.predict(feature_for_predict_df.values)
            predict_weights_next_day_df[asset_name] = predict
        except:
            logging.exception("model failed")
            # if there is exception, return zero values
            return xr.zeros_like(data.isel(field=0, time=0))

    return predict_weights_next_day_df.to_xarray()


weights = qnbt.backtest(
    competition_type="cryptofutures",
    load_data=load_data,
    lookback_period=18,
    start_date='2014-01-01',
    strategy=predict_weights,
    analyze=True,
    build_plots=True
)

Here is an example with indicators (Sharpe Ratio = 0.8)

 def get_features_for(asset_name):
    data_for_instrument = data.copy(True).sel(asset=[asset_name])

    # Feature 1
    price = data_for_instrument.sel(field="close")
    price = qnt.ta.roc(price, 1)
    price = price.ffill('time').bfill('time').fillna(0)
    price_df = price.to_pandas()

    # Feature 2
    vol = data_for_instrument.sel(field="vol")
    vol = vol.ffill('time').bfill('time').fillna(0)  # fill NaN
    vol_df = vol.to_pandas()

    # Merge dataframes
    for_result = pd.merge(price_df, vol_df, on='time')

    return for_result

Hello.

Can you make a template showing how to optimize the strategy parameters?
In the legacy version of Quantciacs, there was an opportunity to optimize parameters, now I probably need to write loops myself.

Hello.

Why is there a difference in the strategy results on the legacy version of the Quantciacs and on the new version?
The strategy is the same.

Please add a strategy template that trades based on machine learning.