Visualisation et modification des paramètres de la stratégie - version 2

Il s'agit d'une version améliorée de cet exemple : https://strategyquant.com/doc/programming-for-sq/changing-strategy-parameters-programmatically/

L'original StrategyParametersHelper n'avait qu'une seule méthode pour modifier les valeurs des paramètres, mais il n'était pas facile d'obtenir la liste des paramètres réels de la stratégie.

Nous avons donc créé une nouvelle version - StrategyParametersHelperV2 qui possède également des méthodes permettant d'obtenir la liste des paramètres et leurs valeurs.

Les deux classes peuvent être téléchargées en tant que pièces jointes à cet article.

Remarque ! En raison d'un petit problème dans SQ, vous devez d'abord importer et compiler le fichier StrategyParametersHelperV2 et ce n'est qu'ensuite que l'on importe et que l'on compile la classe Paramètres de stratégie classe.
Ce problème sera résolu dans le prochain SQ Build 136.

StrategyParametersHelperV2 dispose de ces méthodes :

• setParameters() - définit (modifie) les paramètres
• getParameterNames() - renvoie une liste de noms de paramètres
• getParameterValues() - renvoie une liste de noms et de valeurs de paramètres
• toString() - convertit la liste des paramètres de la méthode précédente en une chaîne lisible

Nous pouvons voir comment il peut être utilisé dans l'exemple de la banque de données :

package 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("Strategy Parameters"), 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 {
        renvoie 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 "Erreur : " + e.getMessage() ;
        }
    }
}

Vous pouvez voir que nous utilisons la méthode d'aide pour obtenir des paramètres et les convertir en chaînes de caractères.

Le résultat (nouvelle colonne de la banque de données) ressemblera à ceci - il énumérera les paramètres spécifiés de la stratégie donnée :

Notez que vous pouvez définir les types de paramètres que vous voulez voir, et aussi si vous voulez utiliser la même variable pour le côté long et le côté court - comme vous pouvez le faire dans l'Optimizer ou dans d'autres paramètres.

Le code complet de StrategyParametersHelperV2 est la classe :

paquet 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 = "," ;

    /**
     * Applique les valeurs des paramètres à la stratégie
     * @param rg
     * @param parameters - liste de paramètres et de leurs valeurs, délimitée par deux points - par exemple 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 {

        /Charge de XML et mise à jour des variables
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables) ;
        Variables variables = 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(values[0], values[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, parameters) ;

        if(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()) {
                    boolean processed = false ;

                    //nous devons trouver la bonne option de négociation
                    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() ;

                        //se promène dans ses paramètres et trouve celui qui a le nom correspondant
                        for(int z=0 ; z<optionParams.size() ; z++) {
                            if(processed) break ;

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

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

                            //retrouve maintenant le bon élément Param dans le XML des paramètres et met à jour sa valeur
                            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(value) ;

                                    processed = true ;
                                    break ;
                                }
                            }
                        }
                    }
                }

                rg.setLastSettings(XMLUtil.elementToString(lastSettings)) ;
            }
            catch(Exception e){
                Log.error("Cannot apply trading options params to last settings", e) ;
            }
        }
    }

    /**
     * Renvoie une liste de tableaux (ArrayList) de noms de paramètres de stratégie
     * @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 ;
    }

    /**
     * Retourne une carte contenant les noms et les valeurs des paramètres de la stratégie
     * @param rg
     * @param parameterTypes - Carte de valeurs spécifiant les types de paramétrage à vérifier. Si null, les types de paramètres recommandés sont utilisés.
     * @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")) {
                // sauter les paramètres qui n'ont pas besoin d'être définis ici
                continuer ;
            }

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

        return paramsList ;
    }

    /**
     * Retourne une valeur du paramètre sélectionné
     * @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() ;
    }

    /**
     * Convertit la carte des paramètres en chaîne de caractères
     * @param parametersMap
     * @return
     */
    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(name) ;
            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 ;
    }

}