Discusión sobre el artículo "Aplicación de OpenCL para simular patrones de velas"
Autor, ¡Gracias por el artículo! Creo que has elegido esta TC en particular para la demostración por una razón, ya que es perfectamente paralela. Sin embargo, se trata de un nicho muy estrecho.
En el artículo te has alejado mucho de la universalidad para acercarte a la particularidad. Está claro que el objetivo es demostrar las posibilidades potenciales. Pero hay poco para aplicarlo a las propias necesidades.
Me gustaría ver ejemplos de traducción de diferentes códigos MQL a códigos OpenCL. Quizás esto esté contenido en los artículos enlazados al principio de tu artículo.
¿Falta el archivo OCLDefines.mqh sólo para mí? :-)
Gracias por tu atención) Lo arreglaremos, pero entiendo que ya desde el lunes. Aquí está la fuente:
//+------------------------------------------------------------------+ //| define| //+------------------------------------------------------------------+ //--- estableciendo un error de ejecución #define SET_ERR(c) do {m_last_error.function = __FUNCTION__; \ m_last_error.line =__LINE__; \ m_last_error.code=::GetLastError(); m_last_error.comment=c;} while(0) //--- establecer un error de ejecución pasando el nombre de la función y el número de línea a través del parámetro #define SET_ERRx(c,f,l) do {m_last_error.function = f; m_last_error.line = l; \ m_last_error.code=::GetLastError(); m_last_error.comment=c;} while(0) //--- establecer un error de usuario #define SET_UERR(err,c) do {m_last_error.function = __FUNCTION__; \ m_last_error.line =__LINE__; \ m_last_error.code=ERR_USER_ERROR_FIRST+err; m_last_error.comment=c;} while(0) //--- establecer un error de usuario pasando el nombre de la función y el número de línea a través del parámetro #define SET_UERRx(err,c,f,l) do {m_last_error.function = f; m_last_error.line = l; \ m_last_error.code=ERR_USER_ERROR_FIRST+err; m_last_error.comment=c;} while(0) //--- llamadas a funciones para trabajar con OpenCL #define _BufferFromArray(buffer_index,data,data_array_offset,data_array_count,flags) \ if(BufferFromArray(buffer_index,data,data_array_offset,data_array_count,flags,__FUNCTION__,__LINE__)==false) return false #define _BufferCreate(buffer_index,size_in_bytes,flags) \ if(BufferCreate(buffer_index,size_in_bytes,flags,__FUNCTION__,__LINE__)==false) return false #define _BufferRead(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count) \ if(BufferRead(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count,__FUNCTION__,__LINE__)==false) return false #define _BufferWrite(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count) \ if(BufferWrite(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count,__FUNCTION__,__LINE__)==false) return false #define _Execute(kernel_index,work_dim,work_offset,work_size) \ if(Execute(kernel_index,work_dim,work_offset,work_size,__FUNCTION__,__LINE__)==false) return false #define _SetArgument(kernel_index,arg_index,value) \ if(SetArgument(kernel_index,arg_index,value,__FUNCTION__,__LINE__)==false) return false #define _SetArgumentBuffer(kernel_index,arg_index,buffer_index) \ if(SetArgumentBuffer(kernel_index,arg_index,buffer_index,__FUNCTION__,__LINE__)==false) return false #define _KernelCreate(k,src) \ if(KernelCreate(k,src,__FUNCTION__,__LINE__)==false) break //--- Errores de usuario #define UERR_NONE 0 // No hay error #define UERR_NO_OCL 1 // El objeto COpenCL no existe #define UERR_GET_MEMORY_SIZE 2 // Error al obtener el tamaño de la memoria #define UERR_KERNEL_CREATE 3 // Error al crear un núcleo #define UERR_SET_BUF_COUNT 4 // Error al establecer el número de buffers #define UERR_DOUBLE_NOT_SUPP 5 // No compatible con double #define UERR_BUFFER_CREATE 6 // Error de creación de búfer #define UERR_BUFFER_FROM_ARRAY 7 // Error al crear buffer a partir de array #define UERR_BUFFER_READ 8 // Error de lectura del búfer #define UERR_BUFFER_WRITE 9 // Error de escritura en el búfer #define UERR_SET_ARGUMENT 10 // Error de configuración de argumentos #define UERR_SET_ARGUMENT_BUFFER 11 // Error al establecer buffer como argumento #define UERR_EXECUTE 12 // Error de ejecución del kernel #define UERR_NO_ENOUGH_MEM 13 // No hay memoria libre //--- Errores de comprobación #define UERR_TESTER_ERROR_FIRST 256 #define SET_UERRt(err,c) SET_UERR(UERR_TESTER_ERROR_FIRST+err,c) //+------------------------------------------------------------------+
Los símbolos personalizados pueden ayudar a librarse de los intercambios y las comisiones al comparar los resultados de los probadores.
Sí, pero eso está aún más lejos del mundo real. A menos que sea para depurar.
Enhorabuena, ¡ha escrito un gran artículo!
El código del artículo será citado y has puesto el listón muy alto para tus colegas que vayan a escribir artículos sobre computación paralela en el comercio.
En el artículo, te has alejado mucho de lo universal para acercarte a lo particular.
Eso es sólo el principio. La universalidad está por delante. El mensaje oculto del artículo es que no todo es tan sencillo. No basta con convertir código serie en código paralelo. Hay que escribir en paralelo desde el principio.
Si la comunidad está interesada, publicaré mis desarrollos posteriores en esta dirección.
Esto es sólo el principio. La versatilidad está por llegar. El mensaje oculto del artículo es que no todo es tan sencillo. No basta con convertir código serie en código paralelo. Hay que escribir código paralelo desde el principio.
Si la comunidad está interesada, publicaré mis futuros desarrollos en este sentido.
la comunidad está muy interesada, "Afftar fishi ischo!!!1111".
un tema muy importante en términos de acelerar la optimización/pruebas, especialmente para algoritmos de aprendizaje automático
¡Artículo muy útil!
Por supuesto, me gustaría ver más ejemplos sencillos de traducción de código MQL ordinario en código OpenCL, en forma de funciones listas con comentarios para dummies.
Y otra pregunta, ¿cuánto tiempo se tarda en transferir / preparar los datos para una tarjeta de vídeo, he oído una opinión que OpenCL para una tarjeta de vídeo no tiene sentido utilizar para el comercio real debido a la pérdida de tiempo en la transferencia de datos para el procesamiento, ¿es realmente así?
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso
Artículo publicado Aplicación de OpenCL para simular patrones de velas:
En este artículo analizaremos el algoritmo de implementación de un simulador de patrones de velas en el lenguaje OpenCL en el modo "OHLC en M1". Asimismo, compararemos su rapidez con el simulador de estrategias incorporado en el modo de optimización rápida y lenta.
Para asegurarnos de que la implementación del simulador en OpenCL funciona correctamente, debemos apoyarnos en algo. Por eso, para comenzar, vamos a escribir un experto en MQL5, y después compararemos los resultados de su simulación y optimización con el simulador estándar con los resultados correspondientes del simulador implementado en OpenCL.
El objeto de la simulación será un experto sencillo que comercia según los siguientes patrones de velas (en los sucesivo denominados patrones).La estrategia será sencilla:
La presencia de un patrón se comprueba con las barras completamente cerradas. En otras palabras, en el momento de aparición de una nueva barra, buscaremos el patrón en la tres anteriores.
Los niveles de detección de patrones son los siguientes:
Autor: Serhii Shevchuk