Backtesting programático de la estrategia, incluidas pruebas de robustez

Este artículo es una continuación del anterior Ejecución programática de pruebas retrospectivas de estrategias.

Mostrará cómo ejecutar backtest programáticamente, esta vez incluyendo comprobaciones cruzadas seleccionadas (pruebas de robustez). El principio del backtest programático es el mismo, no lo explicaremos de nuevo aquí.

Explicaremos sólo las cosas nuevas.

Uso de processDatabank() para ejecutar backtest de una estrategia

Al igual que en el ejemplo anterior utilizaremos el snippet CustomAnalysis y su método procesarBancoDeDatos(). Aquí vamos a elegir la primera estrategia de la base de datos y realizar backtest + pruebas de robustez en él.

El código del método processDatabank() es:

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

@Override
public ArrayList processDatabank(String project, String task, String databankName, ArrayList databankRG) throws Exception {
    if(databankRG.size() == 0) {
        return databankRG;
    }

    // obtener la primera estrategia del banco de datos para volver a probarla
    ResultsGroup strategyToRetest = databankRG.get(0);

    //------------------------------------
    // CONFIGURACIÓN PRINCIPAL BACKTEST
    ResultsGroup backtestResultRG = runMainBacktest(strategyToRetest);

    //------------------------------------
    // COMPROBACIONES CRUZADAS
    runAndSaveCrossChecks(backtestResultRG, strategyToRetest.getName());

    // obtener detalles del resultado del backtest
    int trades = backtestResultRG.portfolio().stats(Directions.Both, PlTypes.Money, SampleTypes.FullSample).getInt(StatsKey.NUMBER_OF_TRADES);
    double profit = backtestResultRG.portfolio().stats(Directions.Both, PlTypes.Percent, SampleTypes.FullSample).getDouble(StatsKey.NET_PROFIT);

    // hacer algo con los nuevos resultados del backtest
    // ResultsGroup contiene ahora el backtest principal + todas las comprobaciones cruzadas configuradas.
    // mire en: https://strategyquant.com/doc/programming-for-sq/working-with-resultsgroup/
    // sobre cómo obtener los resultados individuales


    // aquí sólo guardaremos la nueva estrategia backtested en el banco de datos de destino
    Databank targetDatabank = ProjectEngine.get(project).getDatabanks().get("Results");

    targetDatabank.add(backtestResultRG, true);

    return databankRG;
}

Usted puede ver que tenemos dos sub-métodos allí:

• runMainBacktest() ejecutará el backtest principal de la estrategia y producirá Grupo de resultados con el resultado del backtest. Este método es el mismo que en el ejemplo original y no se explicará aquí
• runAndSaveCrosschecks() ejecutará las comprobaciones cruzadas especificadas y las pondrá todas en el mismo Grupo de resultados como resultados separados

A continuación, guardará este nuevo resultado en una base de datos de destino.

Configuración de los controles cruzados

Las comprobaciones cruzadas en SQX se implementan como plugins, y cada comprobación cruzada tiene un método runTest() que ejecutará una comprobación cruzada de la estrategia.

Así, cuando tengamos configuradas las comprobaciones cruzadas, sólo tendremos que llamar a este método en cada comprobación cruzada que queramos realizar.

La creación / configuración de la comprobación cruzada es el reto aquí, se hace en un submétodo configureCrosschecks() - este método devuelve una matriz de comprobaciones cruzadas, que se ejecutan una a una.

Hay más formas de crear configuraciones de comprobación cruzada, pero la más sencilla tanto para programación como para uso normal es simplemente dejar que se creen a partir del formato XML en el que SQX lo almacena. Este es el método que estamos utilizando aquí.

El código de configureCrosschecks() y algunos submétodos:

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

   private ArrayList configureCrosschecks() throws Exception {
       ArrayList crossChecks = new ArrayList();

       crossChecks.add( createFromXml("c:\\RetestWithHigherPrecision.xml") );
       crossChecks.add( createFromXml("c:\MonteCarloManipulation.xml") );
       crossChecks.add( createFromXml("c:\MonteCarloRetest.xml") );

       return crossChecks;
   }

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

   private ICrossCheck createFromXml(String xmlFile) throws Exception {
       Elemento elXml = XMLUtil.fileToXmlElement(new File(xmlFile));

       String ccName = elXml.getName();

       ICrossCheck crossCheck = getCrossCheckPlugin(ccName);
       if(crossCheck != null) {
           crossCheck.readSettings(elXml, null);
       }
       else {
           throw new Exception ("No se puede encontrar el plugin de comprobación cruzada '" + ccName + "'");
       }

       return crossCheck;
   }

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

   private ICrossCheck getCrossCheckPlugin(String name) {
       ArrayList plugins = SQPluginManager.getPlugins(ICrossCheck.class);

       for(int i=0; i<plugins.size(); i++) {
           if(plugins.get(i).getSettingName().equals(name)) {
               return plugins.get(i).clone(null);
           }
       }

       return null;
   }

Puede ver que la configuración de comprobación cruzada se crea mediante el método createFromXml() que recibe un archivo XML como parámetro. Este archivo XML es la definición de la comprobación cruzada dada.

El método obtendrá primero un clon del plugin para la comprobación cruzada correspondiente llamando a getCrossCheckPlugin(pluginName)y luego simplemente llama a readSettings(xml) en el objeto para inicializarlo con la configuración de XML.

Después de esto, el objeto de configuración de comprobación cruzada está listo para ejecutarse.

En nuestro ejemplo vamos a crear tres controles cruzados:

• Repetición de la prueba con un plazo superior
• Manipulación Monte Carlo con algunos métodos seleccionados
• Repetición de pruebas Monte Carlo con métodos seleccionados

Tenemos un archivo XML separado con la configuración para cada uno de ellos.

Cómo preparar el archivo de configuración XML de comprobación cruzada

El método más sencillo es utilizar SQX UI para configurar los parámetros exactos de la comprobación cruzada que desea utilizar en el proyecto Builder o Retester.

A continuación, guarde todo el proyecto Builder/Retester en un archivo .cfx. Este archivo como una extensión .cfx, pero es un archivo ZIP estándar que puede abrir en WinZip o WinRar programa.

Dentro del archivo encontrarás config.xml - este es el documento XML que contiene los ajustes para todo el proyecto.

Aquí encontrará la sección <CrossChecks> y desde ahí copie y pegue el XML de comprobación cruzada que desee en un archivo separado que luego cargará en nuestro fragmento de análisis personalizado.

Un ejemplo de archivo RetestWithHigherPrecision.xml:

2
    3
  
  
    
      
        
          
        
        =" />
        
          
        
      
      
        
          
        
        =" />
        
          
        
      
      
        
          
        
        <Comparador value="

Un ejemplo de archivo MonteCarloManipulation.xml:

muestreo
        
      
      
        
          10
        
      
    
    10
    false

Un ejemplo de archivo MonteCarloRetest.xml:

20
          10
          20</Parámetro
          10
          true
        
      
      
        
          40
        
      
      
        
          0.0
          10.0
        
      
      
        
          0.0
          5.0
        
      
      
        
          1.0
          5.0
        
      
      
        
          100
        
      
      
        
          10
          20
          true
        
      
      
        
          10
          20
          true
          true
          false
          true
          true
          true
          true
          true
          false
          false
          true
        
      
    
    10
    false
    -1

Ejecución de controles cruzados

Cuando tengamos listos los objetos de configuración de las comprobaciones cruzadas, las ejecutaremos simplemente llamando a sus objetos runTest() método.

Código:

private void runAndSaveCrossChecks(ResultsGroup mainResult, String strategyName) throws Exception {
    ArrayList crossChecks = configureCrosschecks();

    StopPauseEngine stopPauseEngine = new StopPauseEngine();

    for(int i=0; i<crossChecks.size(); i++) {

        ICrossCheck crossCheck = crossChecks.get(i);
        crossCheck.setStopPauseEngine(stopPauseEngine);

        try {
            Log.info(String.format("Ejecutando comprobación cruzada %s para %s...", crossCheck.getName(), strategyName));

            boolean ccResult = crossCheck.runTest(mainResult, i, globalATR, null, true, null, strategyName);

            if(!ccResult) {
                // descomente si desea detener la ejecución de otras comprobaciones cruzadas si una de ellas no pasa
                // de lo contrario, se ejecutarán todas las comprobaciones cruzadas de la estrategia
                //devuelve;
            }

        } catch(Exception e) {
            Log.error("Excepción de comprobación cruzada: "+e.getMessage(), e);
        }
    }
}

Ejecución de este fragmento de análisis personalizado

Cuando compilas y ejecutas este snippet el resultado es el siguiente. Toma la primera estrategia de la base de datos, realiza el man backtest y los 3 crosschecks que configuramos en ella y la guarda como un nuevo resultado en la base de datos.

Puede ver que el nuevo resultado contiene también resultados de Monte Carlo