Моя простая нейронная сеть на java, зацените :)

Денис

Пользователь
#1
Итак как и обещал выставляю на всеобщее ̶о̶с̶м̶е̶я̶н̶и̶е̶ обозрение свою нейронную сеть на Java, которую написал сам, собирая информацию по крупицам в интернете, это моя первая НС, так что не бейте сильно, но если есть замечания по улучшению то буду рад услышать.

Админам: не нашел в инструментарии как выделить код в тексте, если такое возможно - подредактируйте пожалуйста.
Хотел оформить интерфейс но всё руки не доходят, поэтому сборка встретит вас окном с хеловорлдом :) не пинайтесь пожалуйста.
Классы ошибок выставлять не стал, они примитивные, можете просто создать пустой собственный.
При создании сети ей в качестве параметров даются количество сенсорных дендритов (входной слой) , вторым параметром будет массив чисел -
Количество чисел в массиве соответствует количеству слоёв включая выходной слой (последний).
Каждое число (массива) соответствует количеству нейронов в слое.
Сеть поддерживает любое количество выходных нейронов.
Тренирующий метод (trainNeuralNetwork(double[][] task, double[][] answ, double learnCoef, double shureness)) принимает на вход:
1. массив заданий.
2. массив ответов (правильных)
3. коефициент обучения.
4. уверенность сети.

Класс нейрона:
Java:
package neyralnetwork;
/**
*
* @author user
*/
public class Neuron {
 
    /**
     * Взвешенная сумма сигналов дендритов
     */
    private double e;
 
    /**
     * Веса дендритов
     */
    private double[] dendritWeights;
 
    /**
     * Количество дендритов
     */
    private int dendritCount;
 
    /**
     * Ошибка нейрона
     */
    private double error;
 
    /**
     * Сохраненные сигмоидные сигналы
     */
    private double[] sigmIn;
 
    /**
     * Входящий сигнал нейрона смещения
     */
    private double biasIn;
    /**
     * Создание нейрона
     * @param dendCoun количество дендритов с учетом нейрона смещения
     */
    public Neuron(int dendCoun) {
        e=0.0;
        dendritCount = dendCoun;
        dendritWeights = new double[dendritCount];
        error=0.0;
        initiateDenritWeights();
    }
 
    /**
     * Начальная инициализация весов дендритов
     */
    private void initiateDenritWeights(){
        for (int i = 0; i < dendritWeights.length; i++) {
            //dendritWeights = Math.random()<0.5 ? Math.random()*0.3+0.6 : -Math.random()*0.3-0.6;
            dendritWeights = Math.random()<0.5 ? Math.random()*0.3+(15/dendritCount) : -Math.random()*0.3-(15/dendritCount);
        }
    }
  
    /**
     * Получает сигналы на дендриты с нейронов предыдущего слоя
     * @param dendSygn сигмоидные сигналы на дендриты
     * @param bias сигнал нейрона смещения
     */
    public void takeDendSygnals(double[] dendSygn,double bias){
        //+1 тому що сигнали дендритів надсилаються без врахування нейрону зміщення
        if(dendSygn.length+1!=dendritCount)throw new NotMatchSygnDendCount();
        sigmIn=dendSygn;
        biasIn=bias;
        e=0.0;
        //важливо щоб перебирались вхідні сигнали
        for (int i = 0; i < dendSygn.length; i++) {
            e+=dendSygn*dendritWeights;
        }
        e+=bias*dendritWeights[dendritCount-1];
    }
  
    /**
     * Сигмоидный сигнал
     * @return сигмоиду взвешенной суммы сигналов с дендритов
     */
    public double giveSigmSignal(){
        return 1/(1+Math.exp(-e));
    }
  
    /**
     * Принимает ошибку
     * @param err ошибка
     */
    public void takeError(double err){
        error=err;
    }
  
    /**
     * Раздаёт ошибки
     * @return ошибки
     */
    public double[] giveErrors(){
        //-1 нейрону зміщення не потрібна помилка
        double[] errors = new double[dendritCount-1];
        //-1 нейрону зміщення не потрібна помилка
        for (int i = 0; i < dendritCount-1; i++) {
            errors = error*dendritWeights;
        }
        return errors;
    }
  
    /**
     * Исправление веса
     * @param learnCoef коефициент обучения
     */
    public void fixWeight(double learnCoef){
        //-1 потому что нейрон смещения исправляется отдельно
        for (int i = 0; i < dendritCount-1; i++) {
            dendritWeights+=sigmIn*learnCoef*giveSigmSignal()*(1-giveSigmSignal())*error;
        }
        dendritWeights[dendritCount-1]+=biasIn*learnCoef*giveSigmSignal()*(1-giveSigmSignal())*error;
    }
  
  
    /**
     * Распечатывает состояние дендритов нейрона
     */
    public void printNeyron(){
        System.out.println("Dendrit count - "+dendritCount);
        int cnt = 0;
        for (double dendritWeight : dendritWeights) {
            System.out.println("dnd #"+cnt+" - "+dendritWeight);
            cnt++;
        }
    }
}
 
Последнее редактирование модератором:

Денис

Пользователь
#2
Класс слоя нейронов:
Java:
package neyralnetwork;

/**
 *
 * @author user
 */
public class Layer {
    
    /**
     * Массив нейронов слоя
     */
    private Neuron[] neyrons;
    
    /**
     * Нейрон смещения
     */
    private double bias;
    
    /**
     * Количество нейронов в слое
     */
    private int neyronCount;
    
    /**
     * Количество нейронов в предыдущем слое
     */
    private int prewNeuronCount;

    /**
     * Конструктор слоя
     * @param neuCount количество нейронов в слое
     * @param prewNeyCount количество нейронов в предыдущем слое
     */
    public Layer(int neuCount, int prewNeyCount) {
        neyronCount = neuCount;
        prewNeuronCount = prewNeyCount;
        neyrons = new Neuron[neyronCount];
        initiateNeyrons(prewNeyCount);
        bias = Math.random() < 0.5 ? -1.0 : 1.0;
    }
    
    /**
     * Инициализация нейронов
     * @param prewNeyCount количество нейронов в предыдущем слое
     */
    private void initiateNeyrons(int prewNeyCount){
        for (int i = 0; i < neyronCount; i++) {
            //+1 дендрит на нейрон зміщення
            neyrons[i] = new Neuron(prewNeyCount+1);
        }
    }
    
    /**
     * Возвращает сигналы нейронов
     * @return сигналы нейронов
     */
    public double[] giveSygnals(){
        double[] sygnals = new double[neyronCount];
        for (int i = 0; i < neyronCount; i++) {
            sygnals[i] = neyrons[i].giveSigmSignal();
        }
        /*int count=0;
        for (double sygnal : sygnals) {
            System.out.println("neyron #"+count+" sygn - "+sygnal);
            count++;
        }*/
        return sygnals;
    }
    
    /**
     * Принимает сигналы от предыдущего слоя
     * @param sygnals сигналы предыдущего слоя
     */
    public void acceptSygnals(double[] sygnals){
        //if(sygnals.length!=neyrons.length) throw new NotMatchNeyronSygnCount();
        for (Neuron neyron : neyrons) {
            neyron.takeDendSygnals(sygnals, bias);
        }
    }
    
    /**
     * Получает ошибки
     * @param errs ошибки
     */
    public void acceptErrors(double[] errs){
        if(neyrons.length!=errs.length) throw new NotMatchNeyronSygnCount();
        for (int i = 0; i < neyronCount; i++) {
            neyrons[i].takeError(errs[i]);
        }
    }
    
    /**
     * Передаёт ошибки следующему слою
     * @return ошибки
     */
    public double[] giveErrors(){
        /*double[][] layErr = new double[neyronCount][];
        for (int i = 0; i < neyronCount; i++) {
            layErr[i]=neyrons[i].giveErrors();
        }
        return layErr;*/
        double[] layErrs = new double[prewNeuronCount];
        for (int i = 0; i < prewNeuronCount; i++) {
            for (int j = 0; j < neyronCount; j++) {
                layErrs[i]+=neyrons[j].giveErrors()[i];
            }
        }
        return layErrs;
    }
    
    /**
     * Исправляет веса
     * @param learnCoef коэффициент обучения
     */
    public void fixWeights(double learnCoef){
        for (Neuron neyron : neyrons) {
            neyron.fixWeight(learnCoef);
        }
    }
    
    /**
     * Распечатать слой
     */
    public void printLayer(){
        System.out.println("neyCount - "+neyronCount);
        System.out.println("bias - "+bias);
        int cnt=0;
        for (Neuron neyron : neyrons) {
            System.out.println("");
            System.out.println("Neyron #"+cnt);
            neyron.printNeyron();
            cnt++;
        }
    }
    
}
 
Последнее редактирование:

Денис

Пользователь
#3
Класс нейросети:
Java:
package neyralnetwork;

/**
    *
    * @author user
    */
public class NeuralNetwork {

    /**
    * Количество слоёв
    */
    private int layersCount;

    /**
    * Количество сенсорных дендритов
    */
    private double[] sensors;

    /**
    * Массив слоёв
    */
    private Layer[] layers;

    /**
    * Конструктор нейронной сети
    * @param sens количество сенсорных нейронов
    * @param networkMap карта нейронной сети
    */
    public NeuralNetwork(int sens,int[] networkMap) {
        sensors=new double[sens];
        layersCount=networkMap.length;
        layers = new Layer[networkMap.length];
        initiateLayers(networkMap);
    }

    /**
    * Инициализирует слои
    * @param networkMap карта слоёв
    */
    private void initiateLayers(int[] networkMap) {
        layers[0] = new Layer(networkMap[0], sensors.length);//винести окремо змінну?
        for (int i = 1; i < layersCount; i++) {
            layers = new Layer(networkMap, networkMap[i-1]);
        }
    }

    /**
    * Даёт сети задание и получает ответ
    * @param task задание
    * @return ответ
    */
    public double[] setTask(double[] task){
        if(task.length!=sensors.length) throw new NotMatchNeyronSygnCount();
        sensors=task;
        /*for (int i = 0; i < sensors.length; i++) {//винести окремо змінну?
    sensors=task;
    }*/
        return goTask();
    }

    /**
    * Получает ответ от сети по заданому заданию
    * @return ответ
    */
    public double[] goTask(){
        layers[0].acceptSygnals(sensors);
        for (int i = 1; i < layersCount; i++) {
            layers.acceptSygnals(layers[i-1].giveSygnals());
        }
        return layers[layers.length-1].giveSygnals();
    }

    /**
    * Тренировка нейронной сети
    * @param task подборка заданий (вопросов)
    * @param answ подборка ответов (правильных)
    * @param learnCoef коефициент обучения
    * @param shureness уверенность сети
    */
    public void trainNeuralNetwork(double[][] task, double[][] answ, double learnCoef, double shureness){
        if(task.length!=answ.length) throw new NotMatchTaskAnswCount();

        boolean glError;
        //int cykles = 0;
        double totalErr;
        do{
            totalErr=0;
            glError=false;
            for (int i = 0; i < task.length; i++) {
                if(task.length!=sensors.length) throw new NotMatchTaskAnswCount();
                double[] errors = getErrors(answ, setTask(task));
                totalErr+=getTotalError(errors);
                //System.out.println("isError - "+isError(shureness, errors));
                //System.out.println("sygnal - "+goTask()[0]);
                if(isError(shureness, errors)){
                    //System.out.println("fixing error");
                    backpropagateAndFix(errors,learnCoef);
                    glError=true;
                }
            }
            System.out.println("total error - "+totalErr);
            //if(cykles%100==0)System.out.println("cykle - "+cykles);
            //cykles++;
        }while(glError);
        //System.out.println("cykle - "+cykles);
    }

    /**
    * Возвращает ошибки
    * @param rigthAnswers Правильные ответы
    * @param answers ответ сети
    * @return ошибки
    */
    public double[] getErrors(double[] rigthAnswers, double[] answers){
        if(rigthAnswers.length!=answers.length) throw new NotMatchTaskAnswCount();
        double[] errs = new double[rigthAnswers.length];
        for (int i = 0; i < rigthAnswers.length; i++) {
            errs = rigthAnswers-answers;
        }
        return errs;
    }

    /**
    * Подщитывает общую ошибку эпохи
    * @param err все ошибки
    * @return общая ошибка
    */
    public double getTotalError(double[] err){
        double totalErr=0;
        for (double d : err) {
            totalErr+=Math.abs(d);
        }
        return totalErr;
    }

    /**
    * Выясняет есть ли ошибка в ответе сети
    * @param shureness увереность сети
    * @param errors ошибки
    * @return ответ есть ли ошибка
    */
    public boolean isError(double shureness,double[] errors){
        boolean isErr=false;
        for (double error : errors) {
            isErr = isErr ? true : Math.abs(error)>shureness;
        }
        return isErr;
    }

    /**
    * Обратное распространение ошибок
    * @param errs ошибки
    */
    private void backPropagateErrors(double[] errs){
        layers[layersCount-1].acceptErrors(errs);
        for (int i = layersCount-1; i > 0; i--) {
            layers[i-1].acceptErrors(layers.giveErrors());
        }
    }

    /**
    * Исправление весов
    * @param learnCoef коефициент обучения
    */
    private void fixWeights(double learnCoef){
        for (int i = layers.length-1; i > -1; i--) {
            layers.fixWeights(learnCoef);
        }
    }

    /**
    * Обратное распространение ошибок и исправление весов
    * @param errs ошибки
    * @param learnCoef коефициент обучения
    */
    private void backpropagateAndFix(double[] errs, double learnCoef){
        backPropagateErrors(errs);
        fixWeights(learnCoef);
    }

    /**
    * Распечатывает нейронную сеть
    */
    public void printNN(){
        System.out.println("Layers count - "+layersCount);
        System.out.println("sensors count - "+sensors.length);
        int count = 0;
        for (Layer layer : layers) {
            System.out.println("");
            System.out.println("Layer #"+count);
            layer.printLayer();
            count++;
        }
    }
}
 
Последнее редактирование модератором:

Денис

Пользователь
#4
Главный класс
Java:
package neyralnetwork;

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

/**
    *
    * @author user
    */
public class NeyralNetworkApp extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction((ActionEvent event) -> {
            System.out.println("Hello World!");
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 250);

        primaryStage.setTitle("Hello World!");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    /**
    * @param args the command line arguments
    */
    public static void main(String[] args) {
        /*Neuron n1 = new Neuron(5);
    n1.printNeyron();

    Layer lr1 = new Layer(4, 5);

    lr1.printLayer();*/

        NeuralNetwork nn1 = new NeuralNetwork(4, new int[]{3,2,1});

        nn1.printNN();

        //выборка с определённой логикой (я уже забыл условия но сеть всеравно даёт правильный ответ :)))
        //МОЖЕТЕ ЗАКОММЕНТИРОВАТЬ НА СВОЙ ВКУС ЛЮБЫЕ ОДНУ ИЛИ ДВЕ ПАРЫ (ОТВЕТ-ВОПРОС), СЕТЬ СПРАВЛЯЕТСЯ.
        double[][] task1 = {
            {1.0,0.0,0.0,0.0},
            {0.0,1.0,0.0,0.0},
            {1.0,1.0,0.0,0.0},
            {0.0,0.0,1.0,0.0},
            {1.0,0.0,1.0,0.0},
            {0.0,1.0,1.0,0.0},
            {1.0,1.0,1.0,0.0},
            {0.0,0.0,0.0,1.0},
            //тестовые вопросы намеренно изымаются из обучающей выборки
            //чтобы создать ситуацию в которой сеть будет сама делать выводы
            //{1.0,0.0,0.0,1.0},
            //{0.0,1.0,0.0,1.0},
            {1.0,1.0,0.0,1.0},
            {0.0,0.0,1.0,1.0},
        };

        //ответы
        double[][] answ1 = {
            {1.0},
            {0.0},
            {0.0},
            {0.0},
            {0.0},
            {1.0},
            {1.0},
            {1.0},
            //ответы сеть должна угадать сама
            //{1.0},//ожидаемый ответ 1
            //{0.0},//ожидаемый ответ 2
            {0.0},
            {0.0},
        };


        nn1.trainNeuralNetwork(task1, answ1, 0.5, 0.05);

        System.out.println("Ожидаемый ответ 1 - 1");
        System.out.println("Ожидаемый ответ 2 - 0");
        System.out.println("Ответ 1 - "+nn1.setTask(new double[]{1.0,0.0,0.0,1.0})[0]);
        System.out.println("Ответ 2 - "+nn1.setTask(new double[]{0.0,1.0,0.0,1.0})[0]);

        /*nn1.printNN();

    NeuralNetwork nn2 = new NeuralNetwork(2, new int[]{3,1});

    double[][] task2 = {
    {0.0,0.0},
    {0.0,1.0},
    {1.0,0.0},
    {1.0,1.0},
    };

    double[][] answ2 = {
    {0.0},
    {1.0},
    {1.0},
    {0.0},
    };

    nn2.trainNeuralNetwork(task2, answ2, 0.9, 0.2);

    System.out.println("nn2 - "+nn2.setTask(task2[0])[0]);
    System.out.println("nn2 - "+nn2.setTask(task2[1])[0]);
    System.out.println("nn2 - "+nn2.setTask(task2[2])[0]);
    System.out.println("nn2 - "+nn2.setTask(task2[3])[0]);*/

        /*NeuralNetwork nn3 = new NeuralNetwork(7, new int[]{5,1});

    double[][] task3 = {
    {0.0,0.4,0.0,0.1,0.0,0.0,0.8},
    {0.7,0.0,0.4,0.0,0.1,0.0,0.0},
    {0.0,0.7,0.0,0.4,0.0,0.1,0.0},
    {1.0,0.0,0.7,0.0,0.4,0.0,0.1},
    {0.0,1.0,0.0,0.7,0.0,0.4,0.0},
    {0.0,0.0,1.0,0.0,0.7,0.0,0.4},
    {0.3,0.0,0.0,1.0,0.0,0.7,0.0},
    {0.0,0.3,0.0,0.0,1.0,0.0,0.7},
    {0.6,0.0,0.3,0.0,0.0,1.0,0.0},
    {0.0,0.6,0.0,0.3,0.0,0.0,1.0},
    {0.9,0.0,0.6,0.0,0.3,0.0,0.0},
    {0.0,0.9,0.0,0.6,0.0,0.3,0.0},
    {0.0,0.0,0.9,0.0,0.6,0.0,0.3},
    {0.2,0.0,0.0,0.9,0.0,0.6,0.0},
    {0.0,0.2,0.0,0.0,0.9,0.0,0.6},
    {0.5,0.0,0.2,0.0,0.0,0.9,0.0},
    {0.0,0.5,0.0,0.2,0.0,0.0,0.9},
    {0.8,0.0,0.5,0.0,0.2,0.0,0.0},
    {0.0,0.8,0.0,0.5,0.0,0.2,0.0},
    {0.0,0.0,0.8,0.0,0.5,0.0,0.2},
    {0.1,0.0,0.0,0.8,0.0,0.5,0.0},
    {0.0,0.1,0.0,0.0,0.8,0.0,0.5},
    {0.4,0.0,0.1,0.0,0.0,0.8,0.0},
    };

    double[][] answ3 = {
    {0.0},{0.8},{0.0},{0.0},{0.1},{0.0},{0.4},{0.0},{0.7},{0.0},{1.0},{0.0},{0.0},{0.3},{0.0},{0.6},{0.0},{0.9},{0.0},{0.0},{0.2},{0.0},{0.5}
    };


    nn3.trainNeuralNetwork(task3, answ3, 0.6, 0.02);

    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[0])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[1])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[2])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[3])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[4])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[5])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[6])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[7])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[8])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[9])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[10])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[11])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[12])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[13])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[14])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[15])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[16])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[17])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[18])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[19])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[20])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[21])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[22])[0]));*/


        launch(args);
    }
    public static String takeTime(double d){
        int tm = (int)Math.round(d*10);
        if(tm==0)return "no events";
        return ""+(6*tm)+" min";
    };
}
Извиняюсь за сумбурность, если есть вопросы - задавайте.
 
Последнее редактирование модератором:

CMTV

Администратор
Команда форума
#6
Правда, лучше вам еще раз перепроверить, правильно ли сохранился код. Возможно, при редактировании сообщений что-то могло испортиться.
 
#7
Главный класс
Java:
package neyralnetwork;

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

/**
    *
    * @author user
    */
public class NeyralNetworkApp extends Application {

    @Override
    public void start(Stage primaryStage) {
        Button btn = new Button();
        btn.setText("Say 'Hello World'");
        btn.setOnAction((ActionEvent event) -> {
            System.out.println("Hello World!");
        });

        StackPane root = new StackPane();
        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 250);

        primaryStage.setTitle("Hello World!");
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    /**
    * @param args the command line arguments
    */
    public static void main(String[] args) {
        /*Neuron n1 = new Neuron(5);
    n1.printNeyron();

    Layer lr1 = new Layer(4, 5);

    lr1.printLayer();*/

        NeuralNetwork nn1 = new NeuralNetwork(4, new int[]{3,2,1});

        nn1.printNN();

        //выборка с определённой логикой (я уже забыл условия но сеть всеравно даёт правильный ответ :)))
        //МОЖЕТЕ ЗАКОММЕНТИРОВАТЬ НА СВОЙ ВКУС ЛЮБЫЕ ОДНУ ИЛИ ДВЕ ПАРЫ (ОТВЕТ-ВОПРОС), СЕТЬ СПРАВЛЯЕТСЯ.
        double[][] task1 = {
            {1.0,0.0,0.0,0.0},
            {0.0,1.0,0.0,0.0},
            {1.0,1.0,0.0,0.0},
            {0.0,0.0,1.0,0.0},
            {1.0,0.0,1.0,0.0},
            {0.0,1.0,1.0,0.0},
            {1.0,1.0,1.0,0.0},
            {0.0,0.0,0.0,1.0},
            //тестовые вопросы намеренно изымаются из обучающей выборки
            //чтобы создать ситуацию в которой сеть будет сама делать выводы
            //{1.0,0.0,0.0,1.0},
            //{0.0,1.0,0.0,1.0},
            {1.0,1.0,0.0,1.0},
            {0.0,0.0,1.0,1.0},
        };

        //ответы
        double[][] answ1 = {
            {1.0},
            {0.0},
            {0.0},
            {0.0},
            {0.0},
            {1.0},
            {1.0},
            {1.0},
            //ответы сеть должна угадать сама
            //{1.0},//ожидаемый ответ 1
            //{0.0},//ожидаемый ответ 2
            {0.0},
            {0.0},
        };


        nn1.trainNeuralNetwork(task1, answ1, 0.5, 0.05);

        System.out.println("Ожидаемый ответ 1 - 1");
        System.out.println("Ожидаемый ответ 2 - 0");
        System.out.println("Ответ 1 - "+nn1.setTask(new double[]{1.0,0.0,0.0,1.0})[0]);
        System.out.println("Ответ 2 - "+nn1.setTask(new double[]{0.0,1.0,0.0,1.0})[0]);

        /*nn1.printNN();

    NeuralNetwork nn2 = new NeuralNetwork(2, new int[]{3,1});

    double[][] task2 = {
    {0.0,0.0},
    {0.0,1.0},
    {1.0,0.0},
    {1.0,1.0},
    };

    double[][] answ2 = {
    {0.0},
    {1.0},
    {1.0},
    {0.0},
    };

    nn2.trainNeuralNetwork(task2, answ2, 0.9, 0.2);

    System.out.println("nn2 - "+nn2.setTask(task2[0])[0]);
    System.out.println("nn2 - "+nn2.setTask(task2[1])[0]);
    System.out.println("nn2 - "+nn2.setTask(task2[2])[0]);
    System.out.println("nn2 - "+nn2.setTask(task2[3])[0]);*/

        /*NeuralNetwork nn3 = new NeuralNetwork(7, new int[]{5,1});

    double[][] task3 = {
    {0.0,0.4,0.0,0.1,0.0,0.0,0.8},
    {0.7,0.0,0.4,0.0,0.1,0.0,0.0},
    {0.0,0.7,0.0,0.4,0.0,0.1,0.0},
    {1.0,0.0,0.7,0.0,0.4,0.0,0.1},
    {0.0,1.0,0.0,0.7,0.0,0.4,0.0},
    {0.0,0.0,1.0,0.0,0.7,0.0,0.4},
    {0.3,0.0,0.0,1.0,0.0,0.7,0.0},
    {0.0,0.3,0.0,0.0,1.0,0.0,0.7},
    {0.6,0.0,0.3,0.0,0.0,1.0,0.0},
    {0.0,0.6,0.0,0.3,0.0,0.0,1.0},
    {0.9,0.0,0.6,0.0,0.3,0.0,0.0},
    {0.0,0.9,0.0,0.6,0.0,0.3,0.0},
    {0.0,0.0,0.9,0.0,0.6,0.0,0.3},
    {0.2,0.0,0.0,0.9,0.0,0.6,0.0},
    {0.0,0.2,0.0,0.0,0.9,0.0,0.6},
    {0.5,0.0,0.2,0.0,0.0,0.9,0.0},
    {0.0,0.5,0.0,0.2,0.0,0.0,0.9},
    {0.8,0.0,0.5,0.0,0.2,0.0,0.0},
    {0.0,0.8,0.0,0.5,0.0,0.2,0.0},
    {0.0,0.0,0.8,0.0,0.5,0.0,0.2},
    {0.1,0.0,0.0,0.8,0.0,0.5,0.0},
    {0.0,0.1,0.0,0.0,0.8,0.0,0.5},
    {0.4,0.0,0.1,0.0,0.0,0.8,0.0},
    };

    double[][] answ3 = {
    {0.0},{0.8},{0.0},{0.0},{0.1},{0.0},{0.4},{0.0},{0.7},{0.0},{1.0},{0.0},{0.0},{0.3},{0.0},{0.6},{0.0},{0.9},{0.0},{0.0},{0.2},{0.0},{0.5}
    };


    nn3.trainNeuralNetwork(task3, answ3, 0.6, 0.02);

    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[0])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[1])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[2])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[3])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[4])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[5])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[6])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[7])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[8])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[9])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[10])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[11])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[12])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[13])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[14])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[15])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[16])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[17])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[18])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[19])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[20])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[21])[0]));
    System.out.println("time is 12 hours "+takeTime(nn3.setTask(task3[22])[0]));*/


        launch(args);
    }
    public static String takeTime(double d){
        int tm = (int)Math.round(d*10);
        if(tm==0)return "no events";
        return ""+(6*tm)+" min";
    };
}
Извиняюсь за сумбурность, если есть вопросы - задавайте.

Не могу понять, что именно делает эта НС
 

Денис

Пользователь
#8
Не могу понять, что именно делает эта НС
Говоря простыми словами, она делает выводы, это простейшая feed forward нейронная сеть - скармливаешь ей кучу примеров с правильными ответами, даёшь ей вопрос (задание которое она не знала заранее) получаешь ответ (вывод на основе загруженных в неё ранее примеров.
Такие НС могут предсказывать колебания курсов валют, распознавать изображения, в комбинации с генетическим алгоритмом могут управлять например мышцами скелета для хотьбы, проходить игры, водить автомобиль, и т. д.
 
Последнее редактирование: