Java Code Examples for org.neuroph.core.Layer#getNeurons()

@Override
protected void onStart() {
    super.onStart(); // init all stuff from superclasses

    // create ResilientWeightTrainingtData objects that will hold additional data (resilient specific) during the training 
    for (Layer layer : this.neuralNetwork.getLayers()) {
        for (Neuron neuron : layer.getNeurons()) {
            for (Connection connection : neuron.getInputConnections()) {
                connection.getWeight().setTrainingData(new ResilientWeightTrainingtData());
            }
        }
    }
}
 

@Override
protected void onStart() {
    super.onStart();
    // create MomentumTrainingData objects that will be used during the training to store previous weight value
    for (Layer layer : neuralNetwork.getLayers()) {
        for (Neuron neuron : layer.getNeurons()) {
            for (Connection connection : neuron.getInputConnections()) {
                connection.getWeight().setTrainingData(new MomentumTrainingData());
            }
        } // for
    } // for
}
 

@Override
protected void onStart() {
    super.onStart(); //To change body of generated methods, choose Tools | Templates.
    for (Layer layers : neuralNetwork.getLayers()) {
        for (Neuron neuron : layers.getNeurons()) {
            for (Connection connection : neuron.getInputConnections()) {
                //connection.getWeight().setTrainingData(new QuickPropData());
                Weight<QuickPropData> qpWeight = new Weight<>();
                qpWeight.setTrainingData(new QuickPropData());
                connection.setWeight(qpWeight);                    
            }
        }
    }

}
 

/**
 * Creates full connectivity between the two specified layers
 * 
 * @param fromLayer
 *            layer to connect
 * @param toLayer
 *            layer to connect to
 */
public static void fullConnect(Layer fromLayer, Layer toLayer, boolean connectBiasNeuron) {
	for(Neuron fromNeuron : fromLayer.getNeurons()) {
                   if (fromNeuron instanceof BiasNeuron) {
                       continue;
                   }
                   for (Neuron toNeuron : toLayer.getNeurons()) {
		createConnection(fromNeuron, toNeuron);
                   } 
	} 
}
 

/**
 * Sets default input and output neurons for network (first layer as input,
 * last as output)
 */
public static void setDefaultIO(NeuralNetwork nnet) {
              ArrayList<Neuron> inputNeuronsList = new ArrayList<>();
               Layer firstLayer = nnet.getLayerAt(0);
               for (Neuron neuron : firstLayer.getNeurons() ) {
                   if (!(neuron instanceof BiasNeuron)) {  // dont set input to bias neurons
                       inputNeuronsList.add(neuron);
                   }
               }

	List<Neuron> outputNeurons = ((Layer) nnet.getLayerAt(nnet.getLayersCount()-1)).getNeurons();

	nnet.setInputNeurons(inputNeuronsList);
	nnet.setOutputNeurons(outputNeurons); 
}
 

/**
 * Encode a network to an array.
 * @param network The network to encode.
 */
public static void network2array(NeuralNetwork network, double[] array) {
	int index = 0;

                List<Layer> layers = network.getLayers();
	for (Layer layer : layers) {
		for (Neuron neuron : layer.getNeurons()) {
			for (Connection connection : neuron.getOutConnections()) {
				array[index++] = connection.getWeight().getValue();
			}
		}
	}
}
 

/**
 * Decode a network from an array.
 * @param array The array used to decode.
 * @param network The network to decode into.
 */
public static void array2network(double[] array, NeuralNetwork network) {
	int index = 0;
               
               List<Layer> layers = network.getLayers();
               for (Layer layer : layers) {
		for (Neuron neuron : layer.getNeurons()) {
			for (Connection connection : neuron.getOutConnections()) {
				connection.getWeight().setValue(array[index++]);
				//connection.getWeight().setPreviousValue(array[index++]);
			}
		}
	}
}
 

/**
 * Determine the array size for the given neural network.
 * @param network The neural network to determine for.
 * @return The size of the array necessary to hold that network.
 */
public static int determineArraySize(NeuralNetwork network) {
	int result = 0;

               List<Layer> layers = network.getLayers();
	for (Layer layer : layers) {
		for (Neuron neuron : layer.getNeurons()) {
			result+=neuron.getOutConnections().size();
		}
	}
	return result;
}
 

public static void printWeights(NeuralNetwork<?> neuralNet) {
    for (Layer layer : neuralNet.getLayers()) {
        for (Neuron neuron : layer.getNeurons()) {
            for (Connection connection : neuron.getInputConnections()) {
                System.out.print(connection.getWeight().value + " ");
            }
            System.out.println();
        }
    }
}
 

/**
 * Iterate and randomizes all neurons in specified layer
 *
 * @param layer layer to randomize
 */
protected void randomize(Layer layer) {
    for (Neuron neuron : layer.getNeurons()) {
        randomize(neuron);
    }
}
 

/**
 * Creates full connectivity between the two specified layers
 * 
 * @param fromLayer
 *            layer to connect
 * @param toLayer
 *            layer to connect to
 */
public static void fullConnect(Layer fromLayer, Layer toLayer) {
	for(Neuron fromNeuron : fromLayer.getNeurons()) {
		for (Neuron toNeuron : toLayer.getNeurons()) {
			createConnection(fromNeuron, toNeuron);
		} 
	} 
}
 

/**
 * Creates full connectivity between two specified layers with specified
 * weight for all connections
 * 
 * @param fromLayer
 *            output layer
 * @param toLayer
 *            input layer
        * @param weightVal
        *             connection weight value
 */
public static void fullConnect(Layer fromLayer, Layer toLayer, double weightVal) {
	for(Neuron fromNeuron : fromLayer.getNeurons()) {
		for (Neuron toNeuron : toLayer.getNeurons()) {
			createConnection(fromNeuron, toNeuron, weightVal);
		} 
	} 		
}
 

/**
 * Creates  connectivity between specified neuron and all neurons in specified layer
 * 
 * @param fromNeuron
 *            neuron to connect
 * @param toLayer
 *            layer to connect to
 */        
public static void createConnection(Neuron fromNeuron, Layer toLayer) {
               for (Neuron toNeuron : toLayer.getNeurons()) {
                   ConnectionFactory.createConnection(fromNeuron, toNeuron);
               }
}