Modifica programmatica dei parametri della strategia

La richiesta originale:

Esiste un modo per applicare i migliori parametri suggeriti alla strategia durante un'ottimizzazione Walk-Forward passata? (Sto cercando di farlo nel mio flusso di lavoro per eseguire un ultimo OOS con i migliori parametri applicati all'ultimo periodo).

È possibile, vedere l'esempio seguente. Si tratta di uno snippet di CustomAnalysis che può essere eseguito al termine dell'ottimizzazione di WF.

Questo dimostra anche come applicare i parametri alla strategia in modo programmatico in generale.

Si noti che l'impostazione dei parametri alla strategia è piuttosto complessa, per cui abbiamo creato una classe di aiuto speciale StrategiaParametriHelper che viene utilizzato in questo esempio.

Snippet di analisi personalizzato CAApplyOptimParams - l'esempio reale:

pacchetto SQ.CustomAnalysis;

importare com.strategyquant.lib.*;

importare org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

importare org.jdom2.Element;
importare SQ.Utils.StrategyParametersHelper;

public class CAApplyOptimParams extends CustomAnalysisMethod {
    public static final Logger Log = LoggerFactory.getLogger("CAApplyOptimParams");

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    
    public CAApplyOptimParams() {
        super("CAApplyOptimParams", TYPE_FILTER_STRATEGY);
    }
    
    //------------------------------------------------------------------------
    
    @Override
    public boolean filterStrategy(String project, String task, String databankName, ResultsGroup rg) throws Exception {

        // otteniamo il risultato WF dalla strategia (ResultsGroup)
        WalkForwardMatrixResult mwfResult = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        if(mwfResult==null) {
            restituisce true;
        }

        // ottenere il risultato WF scelto in caso di matrice WF
        WalkForwardResult bestWFResult = mwfResult.getWFResult(rg.getBestWFResultKey(), false);
        if(bestWFResult == null) {
            return true;
        }

        // verificare che il risultato WF abbia dei periodi
        if(bestWFResult.wfPeriods == null || bestWFResult.wfPeriods.size() <= 0) {
            return true;
        }

        // scegliere l'ultimo periodo, che è quello con i parametri da utilizzare in futuro
        WalkForwardPeriod lastPeriod = bestWFResult.wfPeriods.get(bestWFResult.wfPeriods.size()-1);

        String lastParameters = lastPeriod.testParameters;
        Log.info("Parametri futuri consigliati: {}", lastParameters);

        // questo verifica solo se utilizziamo variabili simmetriche nella strategia, o separate per Long/Short
        Element lastSettings = XMLUtil.stringToElement(rg.getLastSettings());
        ParametersSettings parametersSettings = new ParametersSettings();
        parametersSettings.setFromXML(lastSettings, rg.getStrategyXml());
        booleano symmetricVariables = parametersSettings.symmetry;

        // impostare nuovi parametri utilizzando questa classe di aiuto
        // i parametri sono nella stringa lastParameters come chiavi=valori separati da virgole
        // per esempio: "FirstPerod=28,SecondPeriod=34,Coef=3.45"
        StrategyParametersHelper.setParameters(rg, lastParameters, symmetricVariables, true);

        restituisce true;
    }
}

StrategiaParametriHelper classe:

pacchetto SQ.Utils;

importare com.strategyquant.lib.SQTime;
importare com.strategyquant.lib.XMLUtil;
import com.strategyquant.tradinglib.*;
importare com.strategyquant.tradinglib.options.TradingOptionsList;
importare com.strategyquant.tradinglib.propertygrid.IPGParameter;
importare com.strategyquant.tradinglib.propertygrid.ParametersTableItemProperties;
importare org.jdom2.Element;
importare org.slf4j.Logger;
import org.slf4j.LoggerFactory;

importare java.util.ArrayList;
importare java.util.HashMap;
importare java.util.List;

public class StrategyParametersHelper {
    public static final Logger Log = LoggerFactory.getLogger(StrategyParametersHelper.class);

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

    /**
     * Classe helper per impostare i parametri alla strategia
     * @param rg - strategia (ResultsGroup) a cui applicare i parametri
     * @param parametri - parametri in stringa come chiavi=valori separati da virgola, esempio: "FirstPerod=28,SecondPeriod=34,Coef=3.45"
     * @param symmetricVariables - vengono utilizzate variabili simmetriche?
     * @param modifyLastSettings - modifica anche l'ultima impostazione memorizzata per questa strategia?
     * @Trova un'eccezione
     */
    public static void setParameters(ResultsGroup rg, String parameters, boolean symmetricVariables, boolean modifyLastSettings) throws Exception {

        //Carica l'XML e aggiorna le variabili
        StrategyBase xmlS = StrategyBase.createXmlStrategy(rg.getStrategyXml());
        xmlS.transformToVariables(symmetricVariables);
        Variabili variabili = xmlS.variables();

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

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

        for(int a=0; a<variables.size(); a++) {
            Variabile variabile = variabili.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, parameters);

        se(modifyLastSettings){
            try {
                Element lastSettings = XMLUtil.stringToElement(rg.getLastSettings());
                Element elParams = lastSettings.getChild("Options").getChild("BuildTradingOptions").getChild("Params");
                List paramElems = elParams.getChildren("Param");

                List tradingOptions = TradingOptionsList.getInstance().getAvailableClasses();

                for(String paramName : paramMap.keySet()) {
                    booleano elaborato = false;

                    //dobbiamo trovare l'opzione di trading giusta
                    for(int i=0; i<tradingOptions.size(); i++) {
                        if(processed) break;

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

                        //scorre i suoi parametri e trova quello con il nome corrispondente
                        for(int z=0; z<optionParams.size(); z++) {
                            if(elaborato) break;

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

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

                            //ora troviamo l'elemento Param giusto nell'XML delle impostazioni e aggiorniamo il suo valore
                            for(int s=0; s<paramElems.size(); s++) {
                                Element elParam = paramElems.get(s);
                                String elParamClass = elParam.getAttributeValue("className");
                                String elParamKey = elParam.getAttributeValue("key");

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

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

                                    elParam.setText(valore);

                                    elaborato = vero;
                                    break;
                                }
                            }
                        }
                    }
                }

                rg.setLastSettings(XMLUtil.elementToString(lastSettings));
            }
            catch(Exception e){
                Log.error("Impossibile applicare i parametri delle opzioni di trading alle ultime impostazioni", e);
            }
        }
    }
}