Visualización y modificación de los parámetros de la estrategia - versión 2

Se trata de una versión mejorada de este ejemplo: https://strategyquant.com/doc/programming-for-sq/changing-strategy-parameters-programmatically/

El original StrategyParametersHelper sólo tenía un método para cambiar los valores de los parámetros, pero no era fácil obtener la lista de parámetros reales que tiene la estrategia.

Así que creamos una nueva versión - StrategyParametersHelperV2 que también tiene métodos para obtener la lista de parámetros y sus valores.

Ambas clases pueden descargarse como archivos adjuntos a este artículo.

Nota Debido a un pequeño problema en SQ, primero debe importar y compilar el archivo StrategyParametersHelperV2 y sólo después importar y compilar la clase ParámetrosEstratégicos clase.
Este problema se resolverá en la próxima SQ Build 136.

StrategyParametersHelperV2 tiene estos métodos:

• setParameters() - establece (modifica) los parámetros
• getParameterNames() - devuelve una lista de nombres de parámetros
• getParameterValues() - devuelve una lista de nombres y valores de parámetros
• toString() - convierte la lista de parámetros del método anterior en una cadena legible

Podemos ver cómo se puede utilizar en el fragmento de ejemplo del banco de datos:

paquete SQ.Columns.Databanks;

import 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("ParámetrosEstrategia"), 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);

            boolean sameVariablesForLongShort = true;

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

Puedes ver que usamos el método helper para obtener parámetros y luego convertirlos a cadena.

El resultado (nueva columna del banco de datos) tendrá este aspecto: enumerará los parámetros especificados de la estrategia dada:

Tenga en cuenta que puede definir los tipos de parámetros que desea ver, y también si desea utilizar la misma variable para el lado largo y corto - al igual que puede hacer en Optimizer u otros ajustes de parámetros.

El código completo de StrategyParametersHelperV2 clase es:

paquete SQ.Utils;

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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List
import 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 = ",";

    /**
     *Aplica los valores de los parámetros en la estrategia
     * @param rg
     * @param parameters - lista delimitada por dos puntos de parámetros y sus valores - e.g. param1=123,param2=25.4
     * @param symmetricVariables
     * @param modifyLastSettings
     * @throws Exception
     */
    public static void setParameters(ResultsGroup rg, String parameters, boolean symmetricVariables, boolean modifyLastSettings) throws Exception {

        //Cargar XML y actualizar variables
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variables variables = strategyBase.variables();

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

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

        strategyBase.transformToNumbers();

        rg.portfolio().addStrategyXml(strategyBase.getStrategyXml());
        rg.specialValues().setString(StatsKey.OPTIMIZATION_PARAMETERS, parámetros);

        if(modifyLastSettings){
            try {
                Elemento 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()) {
                    boolean procesado = false;

                    //debemos encontrar la opción de negociación correcta
                    for(int i=0; i<tradingOptions.size(); i++) {
                        if(procesado) break;

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

                        //recorrer sus parámetros y encontrar el que coincida con el nombre
                        for(int z=0; z<optionParams.size(); z++) {
                            if(procesado) break;

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

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

                            //busque ahora el elemento Param correcto en el XML de configuración y actualice su valor
                            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(valor);

                                    procesado = true;
                                    break;
                                }
                            }
                        }
                    }
                }

                rg.setLastSettings(XMLUtil.elementToString(lastSettings));
            }
            catch(Exception e){
                Log.error("No se pueden aplicar los parámetros de las opciones de negociación a la última configuración", e);
            }
        }
    }

    /**
     * Devuelve un ArrayList de nombres de parámetros de estrategia
     * @param rg
     * @param parameterTypes
     * @param symmetricVariables
     * @return
     * @throws Exception
     */
    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());

        return list;
    }

    /**
     * Devuelve un mapa que contiene los nombres y valores de los parámetros de la estrategia
     * @param rg
     * @param parameterTypes - ValuesMap especificando ParametrizationTypes a comprobar. Si es nulo, se utilizan los tipos de parámetros recomendados.
     * @param symmetricVariables
     * @return
     * @throws Exception
     */
    public static HashMap getParameterValues(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variables variables = strategyBase.variables();

        HashMap paramsList = new HashMap();

        boolean 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++) {
            Variable variable = variables.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")) {
                // omitir parámetros que no es necesario establecer aquí
                continuar;
            }

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

        return paramsList;
    }

    /**
     * Devuelve un valor del parámetro seleccionado
     * @param rg
     * @param symmetricVariables
     * @param parameterName
     * @return
     * @throws Exception
     */
    public static String getParameterValue(ResultsGroup rg, boolean symmetricVariables, String parameterName) throws Exception {
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variables variables = strategyBase.variables();
        Variable variable = variables.get(parameterName);

        if(variable == null) return null;

        return variable.getValue();
    }

    /**
     * Convierte el mapa de parámetros a cadena
     * @param parametersMap
     * @return
     */
    public static String toString(HashMap parametersMap){
        if(parametersMap == null) return null;

        StringBuilder sb = new StringBuilder();

        for(String nombre : parametersMap.keySet()){
            sb.append(ParamDelimiter);
            sb.append(nombre);
            sb.append(DelimitadorValor);
            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;
    }

}