"New Neural"은 MetaTrader 5 플랫폼용 신경망 엔진의 오픈 소스 프로젝트입니다. - 페이지 86

[TheXpert]

체 세르 :

여기서 부끄러운게 뭐야?

글쎄, 더 많은 증거-그가 침을 뱉은 것이 헛되지 않았습니다 :) 그리고 일반적으로-Rosenblatt의 퍼셉트론 규칙))

[yu-sha]

참여 준비 완료 - 기성 솔루션, 경험, 코딩까지.

아키텍처, 관점 및 방향을 적절하게 논의할 수 있는 닫힌 스레드가 필요합니다.

[Yury Reshetov]

유샤 :

가입 준비 완료 - 기성 솔루션, 경험 및 코딩.

많은 것들이 이미 준비되어 있습니다. 그러나 MetaQuotes가 말에서 행동으로 옮길 수 없는 것이 있습니까?

유샤 :

아키텍처, 관점 및 방향을 적절하게 논의할 수 있는 닫힌 스레드가 필요합니다.

얼마나 논의할 수 있습니까? 이 스레드에서만 86페이지의 지속적인 토론이 가능합니다.

이 주제의 모든 플러더가 닫힌 스레드로 이동한다는 사실에서 물론 다른 포럼 방문자에게는 더 쉬울 것입니다. 수십 개의 플러드 페이지를 읽을 필요가 없습니다.

실제로는 모든 것이 훨씬 간단합니다. 누가 그것을 필요로 하고 누가 어떻게 하는지 알고 있는 그는 오랫동안 자신을 위한 그리드를 설계해 왔습니다. 나머지는 포럼에서 86페이지를 넘겼습니다.

결론은 이 포럼의 여러 방문자가 해당 주제에 대한 경험과 경험이 있다는 것입니다.

예를 들어, Java로 자체 제작한 OOP 프로젝트 가 있습니다. mql5에서 리메이크하지 않았기 때문에 필요가 없었습니다.

저만의 학습 알고리즘으로 직접 해보았습니다. 주요 이점은 은닉층에 얼마나 많은 뉴런이 필요할지 미리 알 수 없다는 것입니다. 그리드는 은닉층에서 추가 뉴런을 제거하고 그에 따라 출력 뉴런에서 추가 가중치를 제거할 수 있습니다.

인공 뉴런은 다음과 같습니다.

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);
    }
}

은닉층은 이렇게 생겼습니다.

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;
    }
    
}

3층 그리드가 구현되는 방식은 다음과 같습니다.

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);
    }
    
}

[fellow]

그리드 알고리즘이 이미 준비되어 있어도 mqh 파일로 구성해야 합니다.

[yu-sha]

네트워크를 작성하는 것은 문제가 되지 않습니다

주요 질문은 이것을 터미널에 통합하는 방법과 소스입니다.  

[fellow]

복잡하지 말자. 그렇지 않으면 범람의 바다가 제공되며 다음 막대 만 예측할 것을 제안합니다.

[yu-sha]

동료 :
복잡하지 말자. 그렇지 않으면 범람의 바다가 제공되며 다음 막대 만 예측할 것을 제안합니다.

이 질문을 하면 저를 스트라이크하세요 ;)  

[fellow]

Reshetov가 제안한 코드는 이미 이론에서 실제에 가깝지만 경험적으로 결정할 수 있다면 왜 무작위 가중치를 사용하는지 이해하지 못합니다.

[Mykola Demko]

유샤 :

아니, 글쎄, 질문의 공식이 정확히 이것이라면 나 없이는)))  

다음 세대는 nero-roproject :)를 습격하고 있습니다. 같은 실수, 암 백조 및 파이크.

실습에 따르면 오픈 소스 프로젝트 는 초기 구현(코어)이 있을 때만 개발되고 오픈 소스에 연마가 제공됩니다(모든 종류의 작은 것들 및 사용자 편의를 거는 것).

[yu-sha]

"하는" 방법을 아는 사람들은 이미 수행했습니다. 물론 나 자신을 위해.

레나트 2013.05.04 14:45 #

참여할 의사가 있으신가요?

우리와 함께 자금 조달 및 일반 관리. MQL5 Storage 에서 공통 프로젝트를 시작하고 시작할 수 있습니다.

두 가지 필수 조건이 충족됩니다.

- 자금 조달

- 일반 관리

또 다른 중요한 장점이 있습니다. 이 프로젝트의 개시자는 MetaQuotes의 "이전" 관리자입니다.

저것. 이 벤처가 시작되기 전에 무너질 가능성은 미미합니다.

추신

오픈 소스가 있습니다 - 문제는 무엇입니까?