Discussão do artigo "Algoritmos de otimização populacionais: Algoritmo de mudas, semeadura e crescimento (SSG)" - página 12
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Sim, um organismo muito interessante)).
Mas a lesma usa apenas 2 dimensões, e até mesmo os AOs mais simples conseguem lidar com 2 dimensões. Como ela se comportará em 1.000 dimensões é uma grande questão, pois a complexidade do problema cresce de forma não linear com o número de dimensões.
O algoritmo de molde de lodo é um método de otimização heurística baseado no comportamento de moldes de lodo. Esse algoritmo foi desenvolvido por Chiaro D'Ambrosio e pertence ao grupo de algoritmos de otimização "naturais".
A essência do algoritmo é colocar uma "lesma" em um ponto específico e observar como ela se espalha em torno desse ponto, em busca do máximo de alimento. No decorrer desse algoritmo, a lesma deixa um rastro que evapora gradualmente. Quanto mais rastros forem deixados em uma área, maior será a probabilidade de outra "lesma" adotar esse rastro como um caminho para uma concentração maior de alimentos.
No contexto da otimização, esse comportamento de lesma é usado para encontrar soluções ideais em espaços de parâmetros. Por exemplo, podemos usar esse algoritmo para encontrar o valor mínimo de uma função dentro de determinados limites de parâmetros.
As vantagens desse algoritmo são sua simplicidade e sua capacidade de convergir rapidamente para soluções ótimas em espaços multidimensionais. Entretanto, ele também pode ter problemas para convergir para a solução ideal em problemas mais complexos e não lineares.
O algoritmo da formiga é o mesmo, mas é generalizado para casos multidimensionais.
A convergência da formiga diminui com o aumento da dimensionalidade, diminui rapidamente. todos os algoritmos se comportam da mesma forma em geral. isso depende da estratégia de busca, e não conhecemos a estratégia da lesma))).
a convergência cai mais lentamente do que o crescimento da complexidade com o aumento da dimensionalidade - considero a escalabilidade AO. a escalabilidade depende do tipo de função, algoritmos diferentes escalam de forma diferente em funções diferentes.
O algoritmo de molde de lodo é um método de otimização heurística baseado no comportamento de moldes de lodo. Esse algoritmo foi desenvolvido por Chiaro D'Ambrosio e pertence ao grupo de algoritmos de otimização "naturais".
A essência do algoritmo é colocar uma "lesma" em um ponto específico e observar como ela se espalha em torno desse ponto, em busca do máximo de alimento. No decorrer desse algoritmo, a lesma deixa um rastro que evapora gradualmente. Quanto mais rastros forem deixados em uma área, maior será a probabilidade de outra "lesma" adotar esse rastro como um caminho para uma concentração maior de alimentos.
No contexto da otimização, esse comportamento de lesma é usado para encontrar soluções ideais em espaços de parâmetros. Por exemplo, é possível usar esse algoritmo para encontrar o valor mínimo de uma função dentro de determinados limites de parâmetros.
As vantagens desse algoritmo são sua simplicidade e sua capacidade de convergir rapidamente para soluções ideais em espaços multidimensionais. Entretanto, ele também pode ter problemas para convergir para a solução ideal em problemas mais complexos e não lineares.
uau, que interessante. vou procurar esse algoritmo, é claro que é interessante desmontá-lo. e montar)))))))
Uau, que interessante. Vou procurar esse algoritmo, é claro que é interessante desmontá-lo. e montar))))))
Aqui está um exemplo de implementação do algoritmo slug na linguagem de programação MQL:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0,1; // rastrear o coeficiente de evaporação
const double stepSize = 0,001; // o tamanho da etapa de movimento da "lesma
double trail[N]; // matriz de rastros de cada partícula
double bestTrail[N]; // matriz do melhor rastro
double bestFitness = DBL_MAX; // valor inicial da função de melhor aptidão
double bestX[N]; // matriz de valores de parâmetros correspondentes à melhor trilha
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; // coloque "slugs" aleatoriamente no intervalo especificado de parâmetros
}
trail[i] = f(x); // calcular o valor da função de adequação para esses parâmetros
if (trail[i] < bestFitness) { // se o valor da função de adequação for melhor que o melhor valor atual, armazene-o como o novo melhor valor
bestFitness = trail[i];
memcpy(bestX, x, sizeof(bestX)); // copie os valores dos parâmetros encontrados para a matriz de melhores valores
memcpy(bestTrail, trail, sizeof(bestTrail)); // copia os valores das funções dos parâmetros encontrados para a matriz dos melhores valores de função
}
}
for (int iter = 0; iter < maxIter; iter++) { // loop pelo número de iterações
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; // vetor de incremento aleatório
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // calcular a largura do passo
x[j] += d[j]; // adiciona um passo ao parâmetro
if (x[j] < LB[j]) { // se o parâmetro estiver fora do intervalo, deixe-o no limite
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // calcular o valor da função para os novos parâmetros
if (newTrail <= trail[i]) { // se o valor da função tiver melhorado ou não tiver mudado, salve os novos parâmetros e o valor da função
memcpy(bestX, x, sizeof(bestX)); // copie os novos parâmetros na matriz dos valores dos melhores parâmetros
memcpy(bestTrail, &newTrail, sizeof(newTrail)); // copia o novo valor da função para a matriz dos melhores valores da função
trail[i] = newTrail; // salvar o valor da função para novos parâmetros na matriz de valores de função para todos os "slugs"
se (bestTrail[i] < bestFitness) { // verificar se a melhor solução atual é melhor do que a melhor solução atual
bestFitness = bestTrail[i];
}
} else { // se os valores da função tiverem se deteriorado, retorne aos parâmetros antigos
memcpy(x, bestX, sizeof(bestX));
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
trail[i] *= (1.0 - k); // evapore a trilha da lesma para evitar ficar preso no máximo local
}
}
return bestFitness;
}
```
Esse código usa valores aleatórios de parâmetros selecionados como ponto de partida e, em seguida, processa cada partícula sequencialmente. Para cada partícula, ele gera um vetor de incremento aleatório, calcula o tamanho da etapa e o adiciona a cada parâmetro. Em seguida, ele calcula o valor da função para os novos parâmetros e o armazena se o valor diminuir ou permanecer o mesmo. No final de cada ciclo, ele evapora o rastro da lesma para evitar ficar preso em um máximo local.
Você provavelmente terá que ajustá-lo 😀 gpt emitido
Você está correto, não existe a função `memcpy` no MQL. Para copiar valores de uma variável para outra, você pode usar o operador de atribuição `=`. Aqui está um exemplo do código modificado sem o uso da função `memcpy`:
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
{
const double k = 0,1; // rastrear o coeficiente de evaporação
const double stepSize = 0,001; // o tamanho da etapa de movimento da "lesma
double trail[N]; // matriz de rastros de cada partícula
double bestTrail[N]; // matriz do melhor rastro
double bestFitness = DBL_MAX; // valor inicial da função de melhor aptidão
double bestX[N]; // matriz de valores de parâmetros correspondentes à melhor trilha
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; // coloque "slugs" aleatoriamente no intervalo especificado de parâmetros
}
trail[i] = f(x); // calcular o valor da função de adequação para esses parâmetros
if (trail[i] < bestFitness) { // se o valor da função de adequação for melhor do que o melhor valor atual, armazene-o como o novo melhor valor
bestFitness = trail[i];
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // copie os valores dos parâmetros encontrados para a matriz de melhores valores
}
bestTrail[i] = trail[i]; // copie o valor da função para os parâmetros encontrados na matriz dos melhores valores de função
}
}
for (int iter = 0; iter < maxIter; iter++) { // percorrer o número de iterações
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; // vetor de incremento aleatório
d[j] = r[j] * stepSize * (UB[j] - LB[j]); // calcular a largura do passo
x[j] += d[j]; // adiciona um passo ao parâmetro
if (x[j] < LB[j]) { // se o parâmetro estiver fora do intervalo, deixe-o no limite
x[j] = LB[j];
} else if (x[j] > UB[j]) {
x[j] = UB[j];
}
}
double newTrail = f(x); // calcular o valor da função para os novos parâmetros
if (newTrail <= trail[i]) { // se o valor da função tiver melhorado ou não tiver mudado, salve os novos parâmetros e o valor da função
for (int j = 0; j < n; j++) {
bestX[j] = x[j]; // copie os novos parâmetros na matriz dos melhores valores de parâmetros
}
bestTrail[i] = newTrail; // copia o novo valor da função na matriz dos melhores valores da função
trail[i] = newTrail; // armazena o valor da função para os novos parâmetros na matriz de valores de função para todos os "slugs"
se (bestTrail[i] < bestFitness) { // verificar se a melhor solução atual é melhor do que a melhor solução atual
bestFitness = bestTrail[i];
}
} else { // se os valores da função tiverem se deteriorado, retorne aos parâmetros antigos
for (int j = 0; j < n; j++) {
x[j] = bestX[j];
}
trail[i] = bestTrail[i];
}
}
for (int i = 0; i < N; i++) {
trail[i] *= (1.0 - k); // vaporize a trilha da lesma para evitar ficar preso no máximo local
}
}
return bestFitness;
}
```
Como você pode ver, estamos simplesmente usando loops para copiar os valores do array elemento por elemento.
esse ferro sabe tudo...))))
No caso geral, provavelmente, você pode confiar no hardware para escolher o algo para a tarefa, mas eu prefiro olhar minha tabela de classificação)))
```
double slimeMouldAlgorithm(double(*f)(double[]), double x[], int n, double LB[], double UB[], int maxIter, int N)
Será necessário dividi-lo em um esquema, como são feitos todos os algoritmos nos artigos.
Será necessário dividi-lo de acordo com o esquema, já que todos os algos nos artigos são feitos.
Tente fazer isso via bate-papo. Será que ele vai dar conta dessa tarefa? Dê a ele um exemplo de artigo e faça-o seguir o estilo. A propósito, uma ótima startup por um centavo é esse bot em um carrinho.
Infelizmente, ou talvez felizmente, o bot não gera novas informações, e as informações disponíveis publicamente costumam ser distorcidas. acho que isso se deve aos mecanismos de interpolação de informações. ele mente, inventa abreviações inexistentes de algoritmos, até mesmo inventa nomes de autores na hora e datas de aparecimento do algoritmo))). você deve ter muito cuidado com essas informações.
Como assistente na edição de textos, correções estilísticas e referência ao escrever artigos - sim, um assistente indispensável.