Aprendizaje automático en el trading: teoría, práctica, operaciones y más - página 2510

Nuevo comentario
 
elibrarius #:

Al parecer, han reservado palabras para los nuevos tipos.

No sólo reservado, algunas cosas ya están funcionando.

void OnStart()
{
  vector v(3);
  v[0] = 1.0;
  v[1] = 2.0;
  v[2] = 3.0;
  matrix m(3, 3);
  m.Random();
  Print("m = ", m);
  Print("m^-1 = ", m.Inverse());
  Print("Det(m) = ", m.Det());
  Print("m * v = ", m * v);
}
 
Aleksey Nikolayev #:

No sólo reservado, algo ya está funcionando.

La búsqueda de ayuda no arroja nada.
Y las matrices serán muy útiles.
La fijación de un tamaño a través de variables funciona

int m1=2; int m2=2;
matriz m(m1, m2);

Antes había que molestarse con las matrices dinámicas.

 
elibrarius #:

La búsqueda de ayuda no da nada.

Sólo tengo información de aquí.

elibrarius #:

Y las matrices serán muy útiles.
Lo siguiente funciona estableciendo el tamaño a través de variables

int m1=2; int m2=2;
matriz m(m1, m2);

Antes, había que utilizar matrices dinámicas.

De hecho, Renat prometió el aprendizaje automático en MQL5, como el soporte de ONNX. Ya veremos)

 
Vladimir Baskakov #:
Nadie ha superado la intersección de los dos mash-ups

... y el retraso puede reducirse con un prefijo NS))

 
elibrarius #:
Si alguien utiliza el paquete de SanSanych https://www.mql5.com/ru/code/17468 para conectarse a R, entonces:

En el archivo R.mqh, los nombres de las variables vectoriales y matriciales comenzaron a dar un error durante la compilación. Renómbralos con otros nombres y todo funcionará. He utilizado vectr y matr.

El editor resalta estas palabras en azul como un tipo de datos como int, double. Palabras aparentemente reservadas para los nuevos tipos.

Hmm, no sabía nada de esta biblioteca. ¿Cómo se utiliza, cuál es su funcionalidad?

 
iwelimorn #:

En definitiva, todo en vano, con MO no se puede engañar al mercado.

Encontramos los rasgos y el objetivo, cuya distribución de clases se muestra en la primera figura.

La precisión de los modelos katbust de prueba y de entrenamiento entrenados con este conjunto de datos fue del 93%.

La segunda figura muestra el gráfico de balance y patrimonio del comercio objetivo:

La tercera figura muestra el gráfico de equilibrio y equidad de la negociación con las señales del modelo katbusta entrenado:

Así que, señoras y señores, dispérsense.

¿Cuál es el objetivo, cómo lo has encontrado?

¿Has probado a añadir un trall?

Si sólo se observa el balance de errores (+1 correcto -1 incorrecto para la clase 1), ¿el resultado es muy diferente?

 
Aleksey Vyazmikin #:

Hmm, no sabía nada de esta biblioteca. ¿Cómo se utiliza, cuál es su funcionalidad?


Transmisión bidireccional de variables y matrices entre MT y R. Hay citas, resultados de vuelta y comandos.
Descripción de la función:
/**
* Devuelve la versión del dll. Los 16 bits superiores del valor de retorno
* son la versión mayor y los 16 bits inferiores la menor. Este
* se utiliza en RInit() para asegurarse de que este archivo de cabecera y
* zzthe dll encajan.
*/
int RGetDllVersion();

/**
* Esto no debe ser llamado directamente, será
* llamado por RInit() después de la comprobación exitosa de la versión.
* Debe llamar a RInit() para iniciar una nueva sesión de R.
*/
long RInit_(string commandline,int debuglevel);

/**
* Teminate the R session. Llame a esto en su función deinit().
* Después de esto, el mango ya no es válido.
*/
void RDeinit(long rhandle);

/**
* devuelve true si la sesión de R perteneciente a este handle está
* todavía en marcha. R terminará ante cualquier error fatal en el código
* que le envíes. Debe comprobarlo al principio
* de su función de inicio y detener todas las acciones. El último comando de
* antes de la caída se encontrará en el registro.
* Si R ya no se está ejecutando, esta biblioteca no emitirá ningún
* mensaje de registro más y silenciosamente ignorará todos los comandos.
*/
bool RIsRunning(long rhandle);

/**
* devuelve true si R sigue ejecutando un comando (resultante
* de una llamada a RExecuteAsync())
*/
bool RIsBusy(long rhandle);

/**
* ejecuta código y no espera. Sin embargo, cualquier llamada posterior
* esperará ya que sólo puede haber un hilo ejecutándose en
* cualquier momento. Utiliza RIsBusy() para comprobar si ha terminado
*/
void RExecuteAsync(long rhandle,string code);

/**
* ejecuta el código y espera a que termine. Esto no
* devolverá nada. Básicamente puede lograr lo mismo con
* las funciones RGet*(), evaluar la expresión es también
* sólo ejecutar código, la única diferencia es que estas
* funciones RGet*() tratarán adicionalmente de analizar y devolver
* la salida mientras que RExecute() sólo ejecutará, esperará e
* ignorará toda la salida.
*/
void RExecute(long rhandle,string code);

/**
* asignar un bool al nombre de la variable. En R este tipo se llama "lógico"
*/
void RAssignBool(long rhandle,string variable,bool value);

/**
* asigna un entero al nombre de la variable.
*/
void RAssignInteger(long rhandle,string variable,int value);

/**
* asignar un doble al nombre de la variable.
*/
void RAssignDouble(long rhandle,string variable,double value);

/**
* asignar una cadena a la variable namd. En R este tipo se llama "carácter"
*/
void RAssignString(long rhandle,string variable,string value);

/**
* asignar un vector al nombre de la variable. Si el tamaño no coincide con
* su tamaño real de la matriz, entonces podrían ocurrir cosas malas.
*/
void RAssignVector(long rhandle,string variable,double &vectr[],int size);

/**
* asignar un vector de caracteres (una matriz de cadenas) a la variable. Si necesita
* un factor, entonces debe ejecutar el código para convertirlo después de este comando. En
* versiones recientes de R un vector de cadenas no necesita más memoria que
* un factor y es más fácil añadirle nuevos elementos.
*/
void RAssignStringVector(long rhandle,string variable,string &vectr[],int size);

/**
* asignar una matriz al nombre de la variable. La matriz debe tener el número de fila como la
* primera dimensión (se utilizará byrow=TRUE en los datos brutos). Esta función es mucho
* más rápida que construir una matriz enorme (cientos de filas) desde cero añadiendo
* nuevas filas al final con RRowBindVector() para cada fila. Esta función está optimizada
* para obtener un gran rendimiento con una sola llamada a la función mediante el uso de file-IO con los
* datos binarios en bruto. Para las matrices y vectores muy pequeños con sólo un puñado de elementos
* esto podría ser demasiada sobrecarga y las otras funciones serán más rápidas. Una vez que
* tenga la matriz con posiblemente miles de filas transferidas a R debería entonces
* sólo utilizar RRowBindVector() para hacerla crecer lentamente a la llegada de nuevos vectores de datos individuales
* en lugar de enviar siempre una nueva copia de toda la matriz.
*/
void RAssignMatrix(long rhandle,string variable,double &matr[],int rows,int cols);

/**
* añadir una fila a una matriz o marco de datos. Esto ejecutará
* variable <- rbind(variable, vector)
* si el tamaño no coincide con el tamaño real de la matriz podrían ocurrir cosas malas.
*/
void RAppendMatrixRow(long rhandle,string variable,double &vectr[],int size);

/**
* devuelve true si la variable existe, false en caso contrario.
*/
bool RExists(long rhandle,string variable);

/**
* evaluar la expresión y devolver un bool. La expresión puede ser cualquier código R
* que se evaluará como lógico. Si se trata de un vector de lógicos entonces sólo se devuelve
* el primer elemento.
*/
bool RGetBool(long rhandle,string expression);

/**
* evaluar la expresión y devolver un entero. Una expresión puede ser cualquier código R
* que se evalúe a un entero. Si es un punto flotante será
* redondeado, si es un vector entonces sólo se devolverá el primer elemento.
*/
int RGetInteger(long rhandle,string expression);

/**
* evalúa la expresión y devuelve un doble. La expresión puede ser cualquier código R
* que se evalúe a un número de punto flotante, si es un vector entonces
* sólo se devuelve el primer elemento.
*/
double RGetDouble(long rhandle,string expression);

/**
* evaluar la expresión y devolver un vector de dobles. La expresión puede
* ser cualquier cosa que se evalúe como un vector de números de punto flotante.
* El valor de retorno es el número de elementos que pueden ser copiados en el array
*. Nunca será mayor que el tamaño, pero podría ser menor.
* Se emiten advertencias en el nivel de depuración 1 si los tamaños no coinciden.
>>> Limitado a 100000 elementos
*/
int RGetVector(long rhandle,string expression,double &vectr[],int size);

/**
* hacer un print(expression) para propósitos de depuración. La salida será
* enviada al monitor de depuración en el nivel de depuración 0.
*/

void RPrint(long rhandle,string expression);

 
elibrarius #:

Transferencia bidireccional de variables y arrays entre MT y R. Hay citas, resultados de vuelta y comandos.
Gracias por la información, estaré al tanto de esta posibilidad. De todos modos, ¿cuál es el retraso de ida y vuelta?
 
Aleksey Vyazmikin #:
Gracias por la información, tendré en cuenta esta posibilidad. ¿Cuánto dura el retraso de ida y vuelta?
Muy rápido. A través del intercambio de memoria. No se trata de archivos ni de pepitas.
 
Vladimir Baskakov #:
Nadie ha superado la intersección de las dos formas de onda.
No te lo vas a creer.
Si se utiliza el promediado, el resultado será idéntico al de los hisopos, y el tiempo de renovación de la señal será el mismo con un margen de segundos.
---
A mí también me sorprendió ;)
1...250325042505250625072508250925102511251225132514251525162517...3399
Nuevo comentario
Razón de la queja: