Visualizzazione e modifica dei parametri della strategia - versione 2

Questa è una versione migliorata dell'esempio: https://strategyquant.com/doc/programming-for-sq/changing-strategy-parameters-programmatically/

L'originale StrategiaParametriHelper La classe aveva un solo metodo per modificare i valori dei parametri, ma non era facile ottenere l'elenco dei parametri effettivi della strategia.

Abbiamo quindi creato una nuova versione - StrategyParametersHelperV2 che ha anche metodi per ottenere l'elenco dei parametri e i loro valori.

Entrambe le classi sono disponibili per il download come allegati a questo articolo.

Nota! A causa di un piccolo problema in SQ, è necessario importare e compilare prima il file StrategyParametersHelperV2 e solo dopo importare e compilare la classe Parametri della strategia classe.
Questo problema sarà risolto nella prossima build 136 di SQ.

StrategyParametersHelperV2 ha questi metodi:

• setParameters() - imposta (modifica) i parametri
• getParameterNames() - restituisce un elenco di nomi di parametri
• getParameterValues() - restituisce un elenco di nomi e valori dei parametri
• toString() - converte l'elenco dei parametri del metodo precedente in una stringa leggibile.

Possiamo vedere come può essere utilizzato nell'esempio dello snippet della banca dati:

pacchetto SQ.Columns.Databanks;

importare SQ.Utils.StrategyParametersHelperV2;
import com.strategyquant.lib.L;
import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.optimization.WalkForwardMatrixResult;
import com.strategyquant.lib.ValuesMap;

public class StrategyParameters extends DatabankColumn {

    public StrategyParameters() {
        super(L.tsq("Parametri della strategia"), DatabankColumn.Text, ValueTypes.Maximize, 0, 0, 1);

        setWidth(200);
    }
    
    //------------------------------------------------------------------------

    @Override
    public double getNumericValue(ResultsGroup results, String resultKey, byte direction, byte plType, byte sampleType) throws Exception {
        return 0;
    }

    //------------------------------------------------------------------------
    
    @Override
    public String getValue(ResultsGroup results, String resultKey, byte direction, byte plType, byte sampleType) throws Exception {
        try {
            ValuesMap parameterTypes = new ValuesMap();
            parameterTypes.set(ParametrizationTypes.ParamTypePeriod, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeShift, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeConstant, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeOtherParam, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLevel, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLogic, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUsed, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUnused, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeBoolean, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeTradingOptions, false);

            booleano sameVariablesForLongShort = true;

            return StrategyParametersHelperV2.toString(StrategyParametersHelperV2.getParameterValues(results, parameterTypes, sameVariablesForLongShort));
        } catch(Exception e) {
            restituisce "Errore: " + e.getMessage();
        }
    }
}

Si può notare che usiamo il metodo helper per ottenere i parametri e poi per convertirli in stringa.

Il risultato (nuova colonna della banca dati) avrà il seguente aspetto: elencherà i parametri specificati della strategia data:

Si noti che è possibile definire quali tipi di parametri si desidera visualizzare e anche se si desidera utilizzare la stessa variabile per il lato lungo e per quello corto, come si può fare in Optimizer o in altre impostazioni dei parametri.

Il codice completo di StrategyParametersHelperV2 classe è:

pacchetto SQ.Utils;

importare com.strategyquant.datalib.TradingException;
importare com.strategyquant.lib.SQTime;
importare com.strategyquant.lib.ValuesMap;
importare com.strategyquant.lib.XMLUtil;
importare 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;
importare java.util.Map;

public class StrategyParametersHelperV2 {

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

    public static final String ValueDelimiter = "=";
    public static final String ParamDelimiter = ",";

    /**
     * Applica i valori dei parametri nella strategia
     * @param rg
     * @param parameters - elenco delimitato dai due punti dei parametri e dei loro valori - ad esempio param1=123,param2=25.4
     * @param variabili simmetriche
     * @param modifyLastSettings
     * @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 strategyBase = getStrategyBase(rg, symmetricVariables);
        Variabili variabili = strategyBase.variables();

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

        for(int i=0; i<params.length; i++) {
            String[] values = params[i].split(ValueDelimiter);
            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());
            }
        }

        strategyBase.transformToNumbers();

        rg.portfolio().addStrategyXml(strategyBase.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();

                        //scorrere i suoi parametri e trovare 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);
            }
        }
    }

    /**
     * Restituisce un ArrayList di nomi di parametri di strategia.
     * @param rg
     * @param parameterTypes
     * @param variabili simmetriche
     * @Ritorno
     * @Trova un'eccezione
     */
    public static ArrayList getParameterNames(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        HashMap paramsMap = getParameterValues(rg, parameterTypes, symmetricVariables);

        ArrayList list = new ArrayList();
        list.addAll(paramsMap.keySet());

        restituire l'elenco;
    }

    /**
     * Restituisce una mappa contenente i nomi e i valori dei parametri della strategia.
     * @param rg
     * @param parameterTypes - ValuesMap che specifica i ParametrizationTypes da controllare. Se nullo, vengono utilizzati i tipi di parametri consigliati.
     * @param symmetricVariables
     * @Ritorno
     * @Trova un'eccezione
     */
    public static HashMap getParameterValues(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variabili variabili = strategyBase.variables();

        HashMap paramsList = new HashMap();

        booleano useRecommended = parameterTypes == null || parameterTypes.getBoolean(ParametrizationTypes.ParamTypeRecommended, false);

        if(useRecommended){
            parameterTypes = new ValuesMap();
            parameterTypes.set(ParametrizationTypes.ParamTypePeriod, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLevel, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUsed, true);
        }

        for(int a=0; a<variables.size(); a++) {
            Variabile variabile = variabili.get(a);
            String variableType = variable.getParamType();

            String varName = variable.getName();
            if(varName.equals("LongEntrySignal") || varName.equals("ShortEntrySignal") || varName.equals("LongExitSignal") || varName.equals("ShortExitSignal") || varName.equals("MagicNumber")) {
                // salta i parametri che non devono essere impostati qui
                continua;
            }

            if(variableType == null || parameterTypes.getBoolean(variableType, false)){
                paramsList.put(variable.getName(), variable.getValue());
            }
        }

        return paramsList;
    }

    /**
     * Restituisce il valore del parametro selezionato
     * @param rg
     * @param symmetricVariables
     * @param parameterName
     * @Ritorno
     * @Trova un'eccezione
     */
    public static String getParameterValue(ResultsGroup rg, boolean symmetricVariables, String parameterName) throws Exception {
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variabili variabili = strategyBase.variables();
        Variabile variabile = variables.get(parameterName);

        if(variabile == null) return null;

        return variabile.getValue();
    }

    /**
     * Converte la mappa dei parametri in stringa
     * @param parametersMap
     * @Ritorno
     */
    public static String toString(HashMap parametersMap){
        if(parametersMap == null) return null;

        StringBuilder sb = new StringBuilder();

        for(String name : parametersMap.keySet()){
            sb.append(ParamDelimiter);
            sb.append(nome);
            sb.append(ValueDelimiter);
            sb.append(parametersMap.get(name));
        }

        return sb.length() > ParamDelimiter.length() ? sb.substring(ParamDelimiter.length()) : sb.toString();
    }

    private static StrategyBase getStrategyBase(ResultsGroup rg, boolean symmetricVariables) throws Exception {
        StrategyBase xmlS = StrategyBase.createXmlStrategy(rg.getStrategyXml());
        xmlS.transformToVariables(symmetricVariables);
        return xmlS;
    }

}