Invalid frequency:ME when init Alpha360

[DanielKui]

I got this error as below, but my data is 1min

the below code can run succeed in Alpha158, but failed in alpha360

`# Copyright (c) Microsoft Corporation.

Licensed under the MIT License.

"""
Qlib provides two kinds of interfaces.
(1) Users could define the Quant research workflow by a simple configuration.
(2) Qlib is designed in a modularized way and supports creating research workflow by code just like building blocks.

The interface of (1) is qrun XXX.yaml. The interface of (2) is script like this, which nearly does the same thing as qrun XXX.yaml
"""
import itertools
import pandas as pd
import qlib
import time

from qlib.constant import REG_CN
from qlib.data.dataset.loader import QlibDataLoader
from qlib.contrib.data.handler import Alpha360
from qlib.data import D
from qlib.contrib.report import analysis_position
import qlib.contrib.report as qcr
from qlib.data.dataset.handler import DataHandlerLP
from qlib.data.dataset.processor import ZScoreNorm, Fillna
from qlib.data.dataset import DatasetH, TSDatasetH
from qlib.workflow import R
from qlib.workflow.record_temp import SignalRecord, PortAnaRecord, SigAnaRecord
from qlib.utils import init_instance_by_config
from qlib.contrib.eva.alpha import calc_ic, calc_long_short_return
from qlib.utils import flatten_dict
from qlib.contrib.report import analysis_model

from sklearn.linear_model import LinearRegression
import numpy as np

benchmark = "SH510310"
if name == "main":
# 初始化qlib 数据源，默认为日线数据
provider_uri = "~/.qlib/qlib_data/cn_data" # target_dir
qlib.init(provider_uri=provider_uri, region=REG_CN)

data_handler_config = {
    "start_time": "2023-01-04",
    "end_time": "2024-07-15",
    "fit_start_time": "2023-08-04",
    "fit_end_time": "2024-02-15",
    "instruments": "all",
    "freq":"1min"
}

h = Alpha360(**data_handler_config)

#print(h.get_cols())

task = {
"model": {
"class": "HFLGBModel",
"module_path": "qlib.contrib.model.highfreq_gdbt_model",
"kwargs": {
"loss": "mse",
"colsample_bytree": 0.8879,
"learning_rate": 0.0421,
"subsample": 0.8789,
"lambda_l1": 205.6999,
"lambda_l2": 580.9768,
"max_depth": 8,
"num_leaves": 210,
"num_threads": 20,
        },
    },
"dataset": {
"class": "DatasetH",
"module_path": "qlib.data.dataset",
"kwargs": {
"handler": {
"class": "Alpha360",
"module_path": "qlib.contrib.data.handler",
"kwargs": data_handler_config,
            },
"segments": {
"train": ("2023-01-04", "2023-05-30"),
"valid": ("2023-06-01", "2023-10-30"),
"test": ("2023-11-01", "2024-02-15"),
            },
        },
    },
}

# model initiaiton
model = init_instance_by_config(task["model"]) #

dataset = init_instance_by_config(task["dataset"])



# start exp to train model
with R.start(experiment_name="train_model"):
        R.log_params(**flatten_dict(task))
        model.fit(dataset)  #拟合模型
        R.save_objects(trained_model=model)
        rid = R.get_recorder().id


###################################
# prediction, backtest & analysis
###################################
port_analysis_config = {
    "executor": {
        "class": "SimulatorExecutor",
        "module_path": "qlib.backtest.executor",
        "kwargs": {
            "time_per_step": "1min",
            "generate_portfolio_metrics": True,
        },
    },
    "strategy": {
        "class": "TopkDropoutStrategy",
        "module_path": "qlib.contrib.strategy.signal_strategy",
        "kwargs": {
            "model": model,
            "dataset": dataset,
            "topk": 50,
            "n_drop": 5,
        },
    },
    "backtest": {
        "start_time": "2023-01-04",
        "end_time": "2024-02-15",
        "account": 1000,
        "benchmark": benchmark,
        "exchange_kwargs": {
            "freq": "1min",
            "limit_threshold": 0.095,
            "deal_price": "close",
            "open_cost": 0.0005,
            "close_cost": 0.0015,
            "min_cost": 5,
        },
    },
}




# backtest and analysis

with R.start(experiment_name="backtest_analysis"):
    recorder = R.get_recorder(recorder_id=rid, experiment_name="train_model")
    model = recorder.load_object("trained_model")


    # prediction
    recorder = R.get_recorder()

    ba_rid = recorder.id
    recorder = R.get_recorder(recorder_id=ba_rid, experiment_name="backtest_analysis")


    #ba_rid = recorder.id
    sr = SignalRecord(model, dataset, recorder)
    sr.generate()

    #label_df = dataset.prepare("test", col_set="label")
    label_df = dataset.prepare("test")
    #label_df.columns = ["label"]
    print (f"label_df :{(label_df)}")

    TotalDF = pd.DataFrame([],columns=['FactorName','IC'])
    
    while True:
        colname = label_df.columns[0]

        if colname == "LABEL0":
             break
        
        print (f"processing factor:{(colname)}\r\n")

        first_column = label_df.iloc[:, 0]
        last_column = label_df.iloc[:, -1]
        
        one_factor_filterd_label_df = pd.DataFrame({
                                        colname: first_column,
                                        'LABEL0': last_column
                                    })

        #print(one_factor_filterd_label_df)

        pred_df = recorder.load_object("pred.pkl")

        pred_label = pd.concat([one_factor_filterd_label_df, pred_df], axis=1, sort=True).reindex(one_factor_filterd_label_df.index)

        print (f"one_factor_filterd_label_df :{(one_factor_filterd_label_df)}")

        #calc_ic(factorvalue, label)
        icresult,ric = calc_ic(one_factor_filterd_label_df.iloc[:,0],one_factor_filterd_label_df.iloc[:,-1])        

        icresult = icresult.to_frame()
        print(type(icresult))        
        print(icresult)
                
        meanic = icresult.iloc[:,0].mean()
        print(meanic)

        newRow = {'FactorName': colname, 'IC':meanic}
        TotalDF.loc[len(TotalDF)] = newRow

        #break
        label_df = label_df.drop(label_df.columns[0], axis=1)


    print(TotalDF)
    TotalDF.to_csv('Alpha360totalfactor.csv')
    current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    print(current_time)`

[DanielKui]

Seems use freq="day" also met this Exception "Invalid frequency:ME" in alpha360, anyone could help me?