Входные значения и диапазоны для нейронных сетей

Question

Я не знаю, как выбрать хорошие входные значения (диапазоны) для моей нейронной сети.

Я создал базовую нейронную сеть с 1 слоем из 2 входных нейронов, 1 скрытый слой с 2 ​​нейронами,и вывод.У меня есть вход для одного нейрона как среднее значение, рассчитанное по данным в игре, но я не знаю, правильное ли это значение, и если нет, что мне делать, чтобы получить правильный?

ANN

public class Ann {
    public Neuron neuron;
    public Neuron neuron2;
    public Neuron neuron3;
    public Neuron neuron4;
    public Neuron decisionNode;

    public double e, f;

    Random random;

    public Ann() {
        random = new Random();
        e = 1;
        f = 1;

        //first layer
        neuron1 = new Neuron();
        neuron2 = new Neuron();

        //second layer
        neuron3 = new Neuron();
        neuron4 = new Neuron();

        //decision
        decisionNode = new Neuron();

        //input values for first layer neurons
        neuron2.assignInputValue(random.nextDouble());
        //set this ^ to player's average hit rate

        //neuron connections
        neuron1.connect(0.5, neuron1, neuron3);
        neuron2.connect(0.5, neuron2, neuron4);
        neuron1.connect(0.5, neuron1, neuron4);
        neuron2.connect(0.5, neuron2, neuron3);
        neuron3.connect(0.5, neuron3, decisionNode);
        neuron4.connect(0.5, neuron4, decisionNode);
    }

    //this is called by a different class
    public void assignAverageDamage(int recentlyDelt, int justDelt, int timesDelt) {
        neuron1.assignInputValue(Math.floor((((recentlyDelt+justDelt)/(timesDelt+1)))*0.1));
        calculateOutput();
    }

    public void calculateOutput() {
        neuron1.outputValue = ((neuron1.inputValue*neuron1.connectionWeight[0]) + (neuron2.inputValue*neuron2.connectionWeight[1]));    // <- this is sigma
        e = e * neuron1.outputValue;
        e = (1/(1+Math.pow(e, -neuron1.outputValue)));

        neuron2.outputValue = ((neuron2.inputValue*neuron2.connectionWeight[0]) + (neuron1.inputValue*neuron1.connectionWeight[1]));
        f = f * neuron2.outputValue;
        f = (1/(1+Math.pow(f, -neuron2.outputValue)));

        decisionNode.outputValue = (e*neuron3.connectionWeight[2] ) + (f*neuron4.connectionWeight[2]);
    }
}






public class Neuron {
    public Neuron connections[];
    public double connectionWeight[];
    public double inputValue, outputValue;

    public Neuron() {
        connections = new Neuron[4];    //4 slots incase i add an extra layer for deeper learning
        connectionWeight = new double[4];
    }

    public void connect(double weight, Neuron startingNeuron, Neuron targetNeuron) {
        for(int i = 0; i < connections.length; i++) {
            if(startingNeuron.connections[i] == null) {
                startingNeuron.connections[i] = targetNeuron;
                startingNeuron.connectionWeight[i] = weight;

                if(targetNeuron.connections[i] == null) {
                    connect(0.5,targetNeuron,startingNeuron);
                }

                break;
            }
        }
    }

    public void assignInputValue(double value) {    //only for first layer neurons
        this.inputValue = value;
    }
}

Сейчас он выводит значение, которое позже я буду использовать для обратного распространения.