"New Neural" est un projet de moteur de réseau neuronal Open Source pour la plateforme MetaTrader 5. - page 86

 
Serj_Che:

Qu'est-ce qu'il y a de si embarrassant ?

Eh bien, voici une autre preuve - je n'ai pas craché pour rien :) et en fait - le perseptron de Rosenblatt est le meilleur :))
 

Prêt à s'impliquer - avec des solutions prêtes à l'emploi, de l'expérience, et même du codage.

Nous avons besoin d'un fil fermé où nous pouvons discuter de manière adéquate de l'architecture, des perspectives et des orientations.

 
yu-sha:

Prêt à s'impliquer - avec des solutions prêtes à l'emploi, de l'expérience, et même du codage.

Beaucoup de gens sont prêts depuis longtemps. Mais les MetaQuotes ne peuvent pas passer des paroles aux actes, n'est-ce pas ?

yu-sha:

Il faut un fil de discussion fermé où l'on peut discuter de manière adéquate de l'architecture, des perspectives et des orientations.

Combien de discussions pouvons-nous encore avoir ? 86 pages de ce seul fil.

Le fait que tous les inondateurs dans ce fil de discussion se déplaceront vers une branche privée, bien sûr, le reste des visiteurs du forum sera mieux, parce que lire des dizaines de pages d'inondation ne sera pas nécessaire.

En réalité, tout est beaucoup plus facile, car celui qui en a besoin et qui sait comment le faire a depuis longtemps conçu une grille. Le reste d'entre nous a lu 86 pages d'inondations sur ce forum.

Le fait est que quelques visiteurs de ce forum ont également une certaine expérience et un certain savoir-faire en la matière.

Par exemple, j'ai un projet OOP en Java que j'ai créé moi-même. Je ne l'ai pas reconstruit pour mql5, parce que ce n'était pas nécessaire.

Je l'ai fait pour moi-même avec mon propre algorithme d'apprentissage. Le principal avantage est que vous ne savez pas à l'avance combien de neurones sont nécessaires dans une couche cachée. La grille peut supprimer les neurones supplémentaires de la couche cachée et respectivement les coefficients de pondération supplémentaires du neurone de sortie.

Voici à quoi ressemble un neurone artificiel :

package neuronet;
import java.util.*;

/**
 * Искусственный нейрон
 * @author Yury V. Reshetov
 */
public class Neuron {
    /**
     * Весовые коэффициенты
     */
    private double[] weights = null;
    
    /**
     * Пороговое значение
     */
    private double threshold = 0 d;
    
    private int[] result = null; 
    
    /**
     * Конструктор нейрона
     * @param w весовые коэффициенты
     * @param t пороговое значение
     */
    public Neuron(double[] w, double t) {
        this.weights = w;
        this.threshold = t;
    }
    
    /**
     * Конструктор случайного нейрона
     * @param inputs количество весовых коэффициентов
     * @param rand генератор псевдослучайных чисел
     */
    public Neuron(int inputs, Random rand) {
        this.threshold = rand.nextDouble() * 2 d - 1 d;
        this.weights = new double[inputs];
        for (int i = 0; i < inputs; i++) {
            this.weights[i] = rand.nextDouble() * 2 d - 1 d;
        }
    }

    /**
     * Вычисление
     * @param inputs входные значения
     * @return результат на выходе нейрона
     */
    public double getOutput(double[] inputs) {
        double sum = this.threshold;
        for (int i = 0; i < this.weights.length; i++) {
            sum = sum + inputs[i] * this.weights[i];
        }
        return this.getSigmoidValue(sum);
    }
    
    /**
     * Возвращает значения весовых коэффициентов
     * @return весовые коэффициенты
     */
    public double[] getWeights() {
        return this.weights;
    }
    
    /**
     * Возвращает пороговое значение
     * @return пороговое значение
     */
    public double getThreshold() {
        return this.threshold;
    }
    
    /**
     * Возвращает результаты
     * @return результаты
     */
    public int[] getResult() {
        return this.result;
    }
    
    public void changeWeights(double[] w) {
        this.weights = w;
    }
    
    
    /**
     * Обучение нейрона
     * @param samples обучающая выборка. Последний элемент столбца - выходное значение
     */
    public void learning(double[][] samples) {
        // Заменяем выходное значение на обратную функцию сигмоида из этого значения
        for (int i = 0; i < samples.length; i++) {
            samples[i][samples[0].length - 1] = this.getArcSigmoidValue(samples[i][samples[0].length - 1]);
        }
        
        double[][] tempsamples = new double[samples.length][samples[0].length * 2];

        int count = samples[0].length;

        for (int i = 0; i < tempsamples.length; i++) {
            for (int j = 0; j < count; j++) {
                tempsamples[i][j] = samples[i][j]; 
                tempsamples[i][j + count] = - tempsamples[i][j];
            }
        }
        
        // Создаем объект оптимизатора
        Optimizator opt = new Optimizator(new Random());
        
        // Получаем результаты
        this.result = opt.getDataForColls(tempsamples, tempsamples[0].length);
        
        // Переводим результаты в вещественный формат
        double[] res = new double[this.result.length];
        
        for (int i = 0; i < res.length; i++) {
            res[i] = this.result[i];
        }

        
        // Получаем значения количества использований оптимизатором для примеров
        int[] getP = opt.getP();
        // Максимальное значение количества использований
        int maximum = getP[0];
        // Индекс примера с максимальным количеством использований
        int maxindex = 0;
        // Ищем индекс примера с максимальным количеством использований
        for (int i = 1; i < getP.length; i++) {
            if (getP[i] > maximum) {
                maximum = getP[i];
                maxindex = i;
            }
        }
    
    
       // Максимальное значение весового коэффициента
        double maxi = Math.abs(res[0]);
    
        // Ищем максимальное значение весового коэффициента
        for (int i = 1; i < res.length; i++) {
            if (Math.abs(res[i]) > maxi) {
                maxi = Math.abs(res[i]);
            }
        }
        
        // Стабильное абсолютное значение константы 
        double bestsum = 0;
        // Вычисляем стабильное значение константы 
        for (int j = 0; j < samples[0].length; j++) {
            bestsum = bestsum + res[j] * samples[maxindex][j];
        }
        // Получаем стабильное абсолютное значение константы 
        bestsum = Math.abs(bestsum);
    
        // Корректируем результаты на стабильное абсолютное значение константы
        for (int i = 0; i < res.length; i++) {
            res[i] = res[i] / bestsum;
        }
        
        // Вычисляем пороговое значение
        this.threshold = 1 d / res[res.length - 1];
        
        // Вычисляем весовые коэффициенты
        for (int i = 0; i < this.weights.length; i++) {
            this.weights[i] = -res[i] / res[res.length - 1];
        }
        
    }
    
    /**
     * Вычисляет значение сигмоидальной функции
     * @return значение сигмоидальной функции
     */
    private double getSigmoidValue(double x) {
        return Math.atan(x);
    }
    
    /**
     * Вычисляет обратное значение сигмоидальной функции
     * @return обратное значение сигмоидальной функции
     */
    private double getArcSigmoidValue(double x) {
        return Math.tan(x);
    }
}

Voici à quoi ressemble une couche cachée :

package neuronet;

import java.util.*;

/**
 * Скрытый слой 
 * @author Yury V. Reshetov
 */
public class HiddenLayer {
    
    // Массив нейронов скрытого слоя
    private Neuron[] neurons = null;
    
    /**
     * Создание скрытого слоя нейронов
     * @param neuronscount количество нейронов в скрытом слое
     * @param inputscount количество входов у нейронов
     * @param rand генератор склучайных чисел
     */
    public HiddenLayer(int inputscount, Random rand) {
        this.neurons = new Neuron[inputscount * 5];
        System.out.println("Количество нейронов скрытого слоя = " + this.neurons.length);
        for (int i = 0; i < this.neurons.length; i++) {
            this.neurons[i] = new Neuron(inputscount, rand);
        }
    }
    
    /**
     * Возвращает массив нейронов
     * @return массив нейронов скрытого слоя
     */
    public Neuron[] getNeurons() {
        return this.neurons;
    }
    
    /**
     * Возвращает результаты входного слоя
     * @param inputs массив входных значений
     * @return массив результатов
     */
    public double[] getOutputs(double[] inputs) {
        double[] results = new double[this.neurons.length];
        for (int i = 0; i < this.neurons.length; i++) {
            results[i] = this.neurons[i].getOutput(inputs);
        }
        return results;
    }
    
    /**
     * Получает обучающую выборку для следующего нейрона из входной обучающей выборки
     * @param samples обучающая выборка
     * @return обучающая выборка для следующего нейрона
     */
    public double[][] getOutputs(double[][] samples) {
        double[][] results = new double[samples.length][this.neurons.length + 1];
        for (int i = 0; i < samples.length; i++) {
            for (int j = 0; j < this.neurons.length; j++) {
                results[i][j] = this.neurons[j].getOutput(samples[i]);
            }
            results[i][this.neurons.length] = samples[i][samples[0].length - 1];
        }
        return results;
    }
    
    /**
     * Изменение архитектуры скрытого слоя.
     * Удаляет лишние нейроны из скрытого слоя и лишние весовые 
     * коэффициенты из следующего за данным слоем нейрона.
     * @param nextneuron нейрон после скрытого слоя
     */
    public void reorganization(Neuron nextneuron) {
        int counter = 0;
        int[] result = nextneuron.getResult();
        for (int i = 0; i < result.length - 1; i++) {
            if (result[i] != 0) {
                counter++;
            }
        }
        Neuron[] temp = new Neuron[counter];
        double[] weights = new double[counter];
        counter = 0;
        for (int i = 0; i < result.length - 1; i++) {
            if (result[i] != 0) {
                weights[counter] = nextneuron.getWeights()[i];
                temp[counter] = this.neurons[i];
                counter++;
            }
        }
        nextneuron.changeWeights(weights);
        this.neurons = temp;
    }
    
}

C'est ainsi que la grille à trois couches est mise en œuvre :

package neuronet;

import java.util.*;

/**
 * Трехслойная нейронная сеть с одним выходом
 * @author Yury V. Reshetov
 */
public class NN {
    
    private Random rand = null;
    private HiddenLayer hiddenlayer = null;
    private Neuron tailneuron = null;
    
    /**
     * Конструктор нейронной сети
     * @param inputs
     */
    public NN() {
    }
    
    /**
     * Результат нейронной сети
     * @param sample значения входов
     * @return результат
     */
    public double getOutput(double[] sample) {
        double[] sample1 = this.hiddenlayer.getOutputs(sample);
        return this.tailneuron.getOutput(sample1);
    }
    
    /**
     * Обучение нейронной сети
     * @param samples обучающая выборка
     */
    public void learning(double[][] samples) {
        this.rand = new Random();
        this.hiddenlayer = new HiddenLayer(samples[0].length - 1, this.rand);
        double[][] samples1 = this.hiddenlayer.getOutputs(samples);
        this.tailneuron = new Neuron(samples1[0].length - 1, this.rand);
        this.tailneuron.learning(samples1);
        this.hiddenlayer.reorganization(tailneuron);
    }
    
}
 
даже алгоритм сетки уже есть готовый , осталось сформировать это в mqh файлы
 

L'écriture d'un réseau n'est pas un problème

La question principale est de savoir comment et à quelle sauce l'intégrer dans le terminal.

 
Restons simples, sinon nous aurons beaucoup d'erreurs. Je propose de prédire la prochaine barre.
 
camarade:
Ne soyons pas trop compliqués, sinon il y aura beaucoup de flou, je propose de prédire juste la barre suivante.

Ceci étant dit, rayez-moi de la liste)))).

 
Le code que Reshetov a suggéré est plus proche de la théorie à la pratique, mais je ne comprends toujours pas pourquoi des poids aléatoires sont nécessaires alors qu'ils peuvent être déterminés empiriquement
 
yu-sha:

Non, eh bien, si c'est la façon dont la question est posée, alors ne me mentionnez pas)))).

Génération nekst storms neroyproekt :) les mêmes erreurs, le crabe et le brochet.

La pratique montre que les projets Open Source sont développés si et seulement s'il existe une implémentation initiale (core) et dans l'Open Source le polissage (ajout de toutes sortes de babioles et de convivialité) est fait.

 

Ceux qui savent comment "faire" l'ont déjà fait.Pour eux-mêmes, naturellement.

Renat2013.05.04 14:45

Voulez-vous participer directement ?

Nous assurerons le financement et la gestion globale. Nous allons démarrer le projet commun dansMQL5 Storage et nous pouvons commencer.

Il y a deux conditions préalables que nous devons remplir :

- le financement

- gestion commune

Il existe un autre avantage important : l'initiateur du projet est l'"ancien" gestionnaire de MetaQuotes.

Ainsi, les chances que cette entreprise s'effondre avant même d'avoir commencé sont minimes.

P.S.

Qu'il s'agisse d'un logiciel libre, où est le problème ?