Mudança programática dos parâmetros estratégicos

O pedido original:

Existe uma maneira de aplicar os melhores parâmetros sugeridos para a estratégia durante uma Otimização de Caminhada para Frente passada? (Procurando fazer isso no meu fluxo de trabalho para executar um último OOS com os melhores parâmetros aplicados ao último período)

É possível, veja o exemplo abaixo. Ele é feito como um snippet CustomAnalysis que pode funcionar após a otimização do WF estar concluída.

Isto também demonstra como aplicar parâmetros programáticos à estratégia em geral.

Observe que definir parâmetros para a estratégia é bastante complexo, criamos uma classe especial de ajudantes EstratégiaParametersHelper que é usado neste exemplo.

Snippet de análise personalizada CAApplyOptimParams - o exemplo real:

pacote SQ.CustomAnalysis;

import com.strategyquant.lib.*;

importação org.slf4j.Logger;
importação org.slf4j.LoggerFactory;

import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.optimization.ParametersSettings;
import com.strategyquant.tradinglib.optimization.WalkForwardMatrixResult;

importação org.jdom2.Element;
importação SQ.Utils.StrategyParametersHelper;

classe pública CAApplyOptimParams estende o CustomAnalysisMethod {
    logger final estático público = LoggerFactory.getLogger("CAApplyOptimParams");

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    
    público CAApplyOptimParams() {
        super("CAApplyOptimParams", TYPE_FILTER_STRATEGY);
    }
    
    //------------------------------------------------------------------------
    
    @Override
    filtro booleano públicoEstratégia (projeto String, tarefa String, banco de dados StringName, ResultsGroup rg) lança Exceção {

        // obter o resultado WF da estratégia (ResultsGroup)
        WalkForwardMatrixResult mwfResult = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        if(mwfResult==nulo) {
            retornar verdadeiro;
        }

        // ser escolhido resultado WF no caso da Matriz WF
        WalkForwardResult bestWFResult = mwfResult.getWFResult(rg.getBestWFResultKey(), falso);
        if(bestWFResult == nulo) {
            retornar verdadeiro;
        }

        // verificar se o resultado da WF tem alguns períodos
        if(bestWFResult.wfPeriods == nulo || bestWFResult.wfPeriods.size() <= 0) {
            retornar verdadeiro;
        }

        // escolha o último período - é aquele com parâmetros a serem utilizados para o futuro
        WalkForwardPeriod lastPeriod = bestWFResult.wfPeriods.get(bestWFResult.wfPeriods.size()-1);

        LastParameters de corda = lastPeriod.testParameters;
        Log.info("Parâmetros futuros recomendados: {}", lastParameters);

        // isto só verifica se usamos variáveis simétricas na estratégia, ou separadas para Long/Short
        Elemento LastSettings = XMLUtil.stringToElement(rg.getLastSettings()));
        ParâmetrosConfiguraçõesParâmetrosConfigurações = novos ParâmetrosConfigurações();
        parametrosSettings.setFromXML(lastSettings, rg.getStrategyXml());
        boolean symmetricVariables = parametersSettings.symmetry;

        // definir novos parâmetros usando a classe helper
        // os parâmetros estão em String lastParameters como chaves=valores separados por vírgula
        // por exemplo: "FirstPerod=28,SecondPeriod=34,Coef=3.45"
        StrategyParametersHelper.setParameters(rg, lastParameters, symmetricVariables, true);

        retornar verdadeiro;
    }
}

EstratégiaParametersHelper classe:

pacote SQ.Utils;

import com.strategyquant.lib.SQTime;
importar com.strategyquant.lib.XMLUtil;
import com.strategyquant.tradinglib.*;
importar com.strategyquant.tradinglib.options.TradingOptionsList;
importar com.strategyquant.tradinglib.propertygrid.IPGParameter;
import com.strategyquant.tradinglib.propertygrid.ParametersTableItemProperties;
import org.jdom2.Element;
importação org.slf4j.Logger;
importação org.slf4j.LoggerFactory;

importação java.util.ArrayList;
importação de java.util.HashMap;
importação java.util.List;

classe pública StrategyParametersHelper {
    logger final estático público = LoggerFactory.getLogger(StrategyParametersHelper.class);

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------

    /**
     * Classe de ajuda para definir parâmetros para a estratégia
     * @param rg - estratégia (ResultsGroup) para aplicar parâmetros
     * @param parameters - parâmetros em String como chaves=valores separados por vírgula, exemplo: "FirstPerod=28,SecondPeriod=34,Coef=3.45"
     * @param symmetricVariables - são usadas variáveis simétricas?
     * @param modifyLastSettings - modifica também a última configuração armazenada para esta estratégia?
     * @throws Exceção
     */
    conjunto de parâmetros estáticos públicosParâmetros estáticos(ResultadosParâmetros de grupo, String, boolean symmetricVariables, boolean modifyLastSettings) lança Exceção {

        //Load XML e atualizar variáveis
        StrategyBase xmlS = StrategyBase.createXmlStrategy(rg.getStrategyXml());
        xmlS.transformToVariables(symmetricVariables);
        Variáveis variáveis = xmlS.variables();

        String[] params = parameters.split(",");
        HashMap paramMap = novo HashMap();

        for(int i=0; i<params.length; i++) {
            String[] values = params[i].split("=");
            paramMap.put(valores[0], valores[1]);
        }

        for(int a=0; a<variables.size(); a++) {
            Variable variable = variables.get(a);
            if(paramMap.containsKey(variable.getName())) {
                variable.setFromString(paramMap.get(variable.getName()));
            }
        }

        xmlS.transformToNumbers();

        rg.portfolio().addStrategyXml(xmlS.getStrategyXml());
        rg.specialValues().setString(StatsKey.OPTIMIZATION_PARAMETERS, parâmetros);

        if(modificarLastSettings){
            tente {
                Elemento LastSettings = XMLUtil.stringToElement(rg.getLastSettings()));
                Element elParams = lastSettings.getChild("Options").getChild("BuildTradingOptions").getChild("Params");
                Lista paramElems = elParams.getChildren("Param");

                ListaOpções Comerciais = TradingOptionsList.getInstance().getAvailableClasses();

                for(String paramName : paramMap.keySet()) {
                    processado booleano = falso;

                    // devemos encontrar a opção comercial correta
                    for(int i=0; i<tradingOptions.size(); i++) {
                        se(processado) quebra;

                        Opção TradingOption = tradingOptions.get(i);
                        String optionClass = option.getClass().getSimpleName();
                        ArrayList optionParams = option.getParams();

                        // passar por seus paramédicos e encontrar aquele com o nome correspondente
                        for(int z=0; z<optionParams.size(); z++) {
                            se(processado) quebra;

                            IPGParameter optionParameter = optionParams.get(z);
                            String paramKey = optionParam.getKey();

                            if(!optionParam.getName().equals(paramName)) continua;

                            //agenda encontrar o elemento de parâmetro correto nas configurações XML e atualizar seu valor
                            for(int s=0; s<paramElems.size(); s++) {
                                Element elParam = paramElems.get(s);
                                String elParamClass = elParam.getAttributeValue("className");
                                String elParamKey = elParam.getAttributeValue("chave");

                                if(elParamClass != null && elParamKey != null && elParamClass.equals(optionClass) && elParamKey.equals(paramKey)) {
                                    String value = paramMap.get(paramName);

                                    if(optionParam.getType() == ParametrosTableItemProperties.TYPE_TIME) {
                                        valor = "" + SQTime.HHMMToMinutes(Integer.parseInt(valor)) * 60;
                                    }

                                    elParam.setText(valor);

                                    processado = verdadeiro;
                                    pausa;
                                }
                            }
                        }
                    }
                }

                rg.setLastSettings(XMLUtil.elementToString(lastSettings));
            }
            catch(Exceção e){
                Log.error("Não é possível aplicar parâmetros de opções comerciais às últimas configurações", e);
            }
        }
    }
}