Discusión sobre el artículo "Algoritmos de optimización de la población: Algoritmo de siembra y crecimiento de árboles (Saplings Sowing and Growing up — SSG)" - página 12
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Sí, un organismo muy interesante)).
pero, la babosa utiliza sólo 2 dimensiones, e incluso los AOs más simples pueden hacer frente a 2 dimensiones. cómo se comportará en 1000 dimensiones es una gran pregunta, porque la complejidad del problema crece no linealmente con el número de dimensiones.
El Algoritmo del Moho de Baba es un método heurístico de optimización basado en el comportamiento de los mohos de baba. Este algoritmo fue desarrollado por Chiaro D'Ambrosio y pertenece al grupo de algoritmos de optimización "naturales".
La esencia del algoritmo consiste en colocar una "babosa" en un punto concreto y observar cómo se propaga alrededor de ese punto, en busca del máximo alimento. En el transcurso de este algoritmo, la babosa va dejando un rastro que se evapora poco a poco. Cuanto mayor sea el rastro dejado en una zona, más probable será que otra "babosa" adopte ese rastro como camino hacia una mayor concentración de alimento.
En el contexto de la optimización, este comportamiento de las babosas se utiliza para encontrar soluciones óptimas en espacios de parámetros. Por ejemplo, podemos utilizar este algoritmo para hallar el valor mínimo de una función dentro de unos límites de parámetros dados.
Las ventajas de este algoritmo son su sencillez y su capacidad para converger rápidamente a soluciones óptimas en espacios multidimensionales. Sin embargo, también puede tener problemas para converger a la solución óptima en problemas más complejos y no lineales.
El algoritmo de la hormiga es el mismo, pero generalizado a casos multidimensionales.
La convergencia de la hormiga disminuye con el aumento de la dimensionalidad, disminuye rápidamente. todos los algoritmos se comportan de la misma manera en general. depende de la estrategia de búsqueda, y no conocemos la estrategia de la babosa))).
la convergencia disminuye más lentamente que el crecimiento de la complejidad con el aumento de la dimensionalidad - lo considero como escalabilidad AO. la escalabilidad depende del tipo de función, diferentes algoritmos escalan de manera diferente en diferentes funciones.
El Algoritmo del Moho de Baba es un método heurístico de optimización basado en el comportamiento de los mohos de baba. Este algoritmo fue desarrollado por Chiaro D'Ambrosio y pertenece al grupo de algoritmos de optimización "naturales".
La esencia del algoritmo consiste en colocar una "babosa" en un punto concreto y observar cómo se propaga alrededor de ese punto, en busca del máximo alimento. En el transcurso de este algoritmo, la babosa va dejando un rastro que se evapora poco a poco. Cuanto mayor sea el rastro dejado en una zona, más probable será que otra "babosa" adopte ese rastro como camino hacia una mayor concentración de alimento.
En el contexto de la optimización, este comportamiento de las babosas se utiliza para encontrar soluciones óptimas en espacios de parámetros. Por ejemplo, podemos utilizar este algoritmo para hallar el valor mínimo de una función dentro de unos límites de parámetros dados.
Las ventajas de este algoritmo son su sencillez y su capacidad para converger rápidamente a soluciones óptimas en espacios multidimensionales. Sin embargo, también puede tener problemas para converger a la solución óptima en problemas más complejos y no lineales.
wow, que interesante. buscare este algo, claro que es interesante desmontarlo. y ensamblar)))))))
wow, que interesante. voy a buscar este algo, por supuesto es interesante desmontarlo. y ensamblar))))))
He aquí un ejemplo de implementación del algoritmo slug en lenguaje de programación MQL:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0.1; // coeficiente de evaporación de trazas
const double stepSize = 0.001; // tamaño del paso de movimiento de la "babosa
double trail[N]; // array de trazas de cada partícula
double bestTrail[N]; // array de la mejor traza
double bestFitness = DBL_MAX; // valor inicial de la función best fitness
double bestX[N]; // matriz de valores de los parámetros correspondientes al mejor rastro
for (int i = 0; i < N; i++) {
for (int j = 0; j < n; j++) {
x[j] = LB[j] + (UB[j] - LB[j]) * (double)rand() / RAND_MAX; // colocar "slugs" aleatoriamente en el rango especificado de parámetros
}
trail[i] = f(x); // calcula el valor de la función fitness para estos parámetros
if (trail[i] < bestFitness) { // si el valor de la función fitness es mejor que el mejor valor actual, guárdalo como nuevo mejor valor
bestFitness = ruta[i];
memcpy(bestX, x, sizeof(bestX)); // copia los valores de los parámetros encontrados en el array de mejores valores
memcpy(bestTrail, trail, sizeof(bestTrail)); // copia los valores de las funciones para los parámetros encontrados en la matriz de los mejores valores de las funciones
}
}
for (int iter = 0; iter < maxIter; iter++) { // bucle por el número de iteraciones
for (int i = 0; i < N; i++) {
double r[n], d[n];
for (int j = 0; j < n; j++) {
r[j] = (double)rand() / RAND_MAX - 0.5; // vector de incremento aleatorio
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // calcula el ancho del paso
x[j] += d[j]; // añade un paso al parámetro
if (x[j] < LB[j]) { // si el parámetro está fuera de rango, déjalo en el límite
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // calcula el valor de la función para los nuevos parámetros
if (newTrail <= trail[i]) { // si el valor de la función ha mejorado o no ha cambiado, guarda los nuevos parámetros y el valor de la función
memcpy(bestX, x, sizeof(bestX)); // copia los nuevos parámetros en la matriz de los mejores valores de los parámetros
memcpy(bestTrail, &newTrail, sizeof(newTrail)); // copia el nuevo valor de la función en la matriz de los mejores valores de la función
trail[i] = newTrail; // guardar el valor de la función para los nuevos parámetros en la matriz de valores de la función para todos los "slugs"
if (bestTrail[i] < bestFitness) { // comprueba si la mejor solución actual es mejor que la mejor solución actual
bestFitness = bestTrail[i];
}
} else { // si los valores de la función se han deteriorado, volver a los parámetros antiguos
memcpy(x, mejorX, sizeof(mejorX));
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
rastro[i] *= (1.0 - k); // evapora el rastro de la babosa para evitar quedarse atascado en el máximo local
}
}
return bestFitness;
}
```
Este código utiliza valores aleatorios de los parámetros seleccionados como punto de partida, luego procesa cada partícula secuencialmente. Para cada partícula, genera un vector de incremento aleatorio, calcula el tamaño del paso y lo añade a cada parámetro. A continuación, calcula el valor de la función para los nuevos parámetros y lo almacena si el valor disminuye o permanece igual. Al final de cada ciclo, evapora el rastro de babosa para evitar quedarse atascado en un máximo local.
Probablemente tendrás que retocarlo ahí 😀 gpt emitido.
Tienes razón, no hay función `memcpy` en MQL. Para copiar valores de una variable a otra, puede utilizar el operador de asignación `=`. He aquí un ejemplo del código modificado sin utilizar la función `memcpy`:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0.1; // coeficiente de evaporación de trazas
const double stepSize = 0.001; // tamaño del paso de movimiento de la "babosa
double trail[N]; // array de trazas de cada partícula
double bestTrail[N]; // array de la mejor traza
double bestFitness = DBL_MAX; // valor inicial de la función best fitness
double bestX[N]; // matriz de valores de los parámetros correspondientes al mejor rastro
for (int i = 0; i < N; i++) {
for (int j = 0; j < n; j++) {
x[j] = LB[j] + (UB[j] - LB[j]) * (double)rand() / RAND_MAX; // colocar "slugs" aleatoriamente en el rango especificado de parámetros
}
trail[i] = f(x); // calcula el valor de la función fitness para estos parámetros
if (trail[i] < bestFitness) { // si el valor de la función fitness es mejor que el mejor valor actual, guárdalo como nuevo mejor valor
bestFitness = ruta[i];
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // copia los valores de los parámetros encontrados en la matriz de mejores valores
}
bestTrail[i] = trail[i]; // copia el valor de la función para los parámetros encontrados en la matriz de los mejores valores de la función
}
}
for (int iter = 0; iter < maxIter; iter++) { // bucle a través del número de iteraciones
for (int i = 0; i < N; i++) {
double r[n], d[n];
for (int j = 0; j < n; j++) {
r[j] = (double)rand() / RAND_MAX - 0.5; // vector de incremento aleatorio
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // calcula el ancho del paso
x[j] += d[j]; // añade un paso al parámetro
if (x[j] < LB[j]) { // si el parámetro está fuera de rango, déjalo en el límite
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // calcula el valor de la función para los nuevos parámetros
if (newTrail <= trail[i]) { // si el valor de la función ha mejorado o no ha cambiado, guarda los nuevos parámetros y el valor de la función
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // copia los nuevos parámetros en la matriz de los mejores valores de los parámetros
}
bestTrail[i] = newTrail; // copia el nuevo valor de la función en la matriz de los mejores valores de la función
trail[i] = newTrail; // almacenar el valor de la función para los nuevos parámetros en la matriz de valores de función para todos los "slugs"
if (bestTrail[i] < bestFitness) { // comprueba si la mejor solución actual es mejor que la mejor solución actual
bestFitness = bestTrail[i];
}
} else { // si los valores de la función se han deteriorado, volver a los parámetros antiguos
for (int j = 0; j < n; j++) {
x[j] = mejorX[j];
}
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
rastro[i] *= (1.0 - k); // vaporiza el rastro de la babosa para evitar quedarte atascado en el máximo local
}
}
return bestFitness;
}
```
Como puedes ver, simplemente estamos usando bucles para copiar los valores del array elemento a elemento.
este hierro lo sabe todo...))))
en el caso general, probablemente, usted puede confiar en el hardware para elegir el algo para la tarea, pero prefiero mirar en mi tabla de clasificación)))
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
Habrá que descomponerlo en un esquema, como se hacen todos los algos de los artículos.
En esta forma es inútil.
Pruébalo por chat, me pregunto si se encargará de semejante tarea :) Me he quedado sin fichas, así que a veces hago mis pinitos. Aliméntalo con un artículo de muestra y haz que siga el estilo. Por cierto, una gran startup para un centavo es un bot de este tipo en un carro.
Desafortunadamente, o tal vez afortunadamente, el bot no genera nueva información, y la información que está disponible públicamente es a menudo distorsionada. creo que esto se debe a los mecanismos de interpolación de información. miente, inventa abreviaturas inexistentes de algoritmos, incluso inventa nombres de autores sobre la marcha y fechas de aparición del algoritmo))). hay que tener mucho cuidado con dicha información.
Como ayudante en la edición de textos, correcciones estilísticas y referencia a la hora de redactar artículos... sí, un ayudante indispensable.