Java NeuralNetwork类代码示例

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testNeuralNet(NeuralNetwork nnet, DataSet dataSet, String setName) {
    int counter = 0;
    for (DataSetRow row : dataSet.getRows()) {
        nnet.setInput(row.getInput());
        nnet.calculate();
        double[] networkOutput = nnet.getOutput();
        if (isOutputSame(networkOutput, row.getDesiredOutput())) {
            counter++;
        } else {
            for (int i = 0; i < row.getDesiredOutput().length; i++) {
                if (row.getDesiredOutput()[i] == 1) {
                    Integer d = errorMap.get(i);
                    if (d == null) {
                        errorMap.put(i, 1);
                    } else {
                        errorMap.put(i, ++d);
                    }
                    break;
                }
            }
        }
    }

    System.out.println(setName + " success rate: " + (counter / (double) dataSet.size()));
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testLearnedNeuralNet(DataSet trainingSet, DataSet testSet) {
    NeuralNetwork nnet = NeuralNetwork.createFromFile(NNET_NAME);
    System.out.println("Testing loaded neural network");
    //testNeuralNet(nnet, trainingSet, "Training set");
    testNeuralNet(nnet, testSet, "Test set");
    for(Map.Entry<Integer, Integer> entry : errorMap.entrySet()) {
        //System.out.println(entry.getKey() + " " + entry.getValue());
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testNeuralNet(NeuralNetwork nnet, DataSet dataSet, String setName) {
    int counter = 0;
    for (DataSetRow row : dataSet.getRows()) {
        nnet.setInput(row.getInput());
        nnet.calculate();
        double[] networkOutput = nnet.getOutput();

        if (isOutputSame(networkOutput, row.getDesiredOutput())) {
            counter++;
        } else {
            for (int i = 0; i < row.getDesiredOutput().length; i++) {
                if (row.getDesiredOutput()[i] == 1) {
                    Integer d = errorMap.get(i);
                    if (d == null) {
                        errorMap.put(i, 1);
                    } else {
                        errorMap.put(i, ++d);
                    }
                    break;
                }
            }
        }
    }

    System.out.println(setName + " success rate: " + (counter / (double) dataSet.size()));
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
@FXML
private void startCheck(ActionEvent event) throws IOException {
    if (nnetSrc == null || imgSrc == null) {
        Calert.showAlert("Invalid Data", "Select Required Files", Alert.AlertType.ERROR);
        return;
    }
    try {
        nnet = NeuralNetwork.load(new FileInputStream(nnetSrc)); // load trained neural network saved with Neuroph Studio
        System.out.println("Learning Rule = " + nnet.getLearningRule());
        ImageRecognitionPlugin imageRecognition = (ImageRecognitionPlugin) nnet.getPlugin(ImageRecognitionPlugin.class); // get the 
        HashMap<String, Double> output = imageRecognition.recognizeImage(ImageIO.read(imgSrc));
        if (output == null) {
            System.err.println("Image Recognition Failed");
        }
        double real = output.get("real");
        double fake = output.get("faked");
        System.out.println(output.toString());
        Calert.showAlert("Result", "Real = " + real + "\nFake = " + fake, Alert.AlertType.INFORMATION);
    } catch (FileNotFoundException ex) {
        Logger.getLogger(SingleImageAnalyzerController.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
public static void main(String[] args) {
    try {
        System.out.println("usage java -jar nn.jar image_to_be_processed file_of_neural_network");
        System.out.println("Loading Image....");
        image = ImageIO.read(new File(args[0]));
        System.out.println("Loading NN....");
        File NNetwork = new File(args[1]);
        if (!NNetwork.exists()) {
            System.err.println("Cant Find NN");
            return;
        }
        nnet = NeuralNetwork.load(new FileInputStream(NNetwork)); // load trained neural network saved with Neuroph Studio
        System.out.println("Load Image Recog Plugin....");
        imageRecognition = (ImageRecognitionPlugin) nnet.getPlugin(ImageRecognitionPlugin.class); // get the image recognition plugin from neural network
        System.out.println("Recognize Image....");
        HashMap<String, Double> output = imageRecognition.recognizeImage(image);
        System.out.println("Output is....");
        System.out.println(output.toString());
    } catch (IOException ex) {
        Logger.getLogger(NeuralNetProcessor.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
@Override
public void doRun() {
    try {
        System.out.println("Starting training thread....." + sampleDimension.toString() + " and " + imageLabels.toString());

        HashMap<String, BufferedImage> imagesMap = new HashMap<String, BufferedImage>();
        for (File file : srcDirectory.listFiles()) {
            imageLabels.add(FilenameUtils.removeExtension(file.getName()));
            if (sampleDimension.getWidth() > 0 && sampleDimension.getHeight() > 0) {
                Double w = sampleDimension.getWidth();
                Double h = sampleDimension.getHeight();
                imagesMap.put(file.getName(), ImageUtilities.resizeImage(ImageUtilities.loadImage(file), w.intValue(), h.intValue()));
            }
        }
        Map<String, FractionRgbData> imageRgbData = ImageUtilities.getFractionRgbDataForImages(imagesMap);
        DataSet learningData = ImageRecognitionHelper.createRGBTrainingSet(imageLabels, imageRgbData);

        nnet = NeuralNetwork.load(new FileInputStream(nnFile)); //Load NNetwork
        MomentumBackpropagation mBackpropagation = (MomentumBackpropagation) nnet.getLearningRule();
        mBackpropagation.setLearningRate(learningRate);
        mBackpropagation.setMaxError(maxError);
        mBackpropagation.setMomentum(momentum);

        System.out.println("Network Information\nLabel = " + nnet.getLabel()
                + "\n Input Neurons = " + nnet.getInputsCount()
                + "\n Number of layers = " + nnet.getLayersCount()
        );

        mBackpropagation.addListener(this);
        System.out.println("Starting training......");
        nnet.learn(learningData, mBackpropagation);
        //Training Completed
        listener.batchImageTrainingCompleted();
    } catch (FileNotFoundException ex) {
        System.out.println(ex.getMessage() + "\n" + ex.getLocalizedMessage());
    }

}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
/**
 * Runs this sample
 */
public static void main(String args[]) {
 
        // create training set (logical AND function)
        DataSet trainingSet = new DataSet(2, 1);
        trainingSet.addRow(new DataSetRow(new double[]{0, 0}, new double[]{0}));
        trainingSet.addRow(new DataSetRow(new double[]{0, 1}, new double[]{0}));
        trainingSet.addRow(new DataSetRow(new double[]{1, 0}, new double[]{0}));
        trainingSet.addRow(new DataSetRow(new double[]{1, 1}, new double[]{1}));

        // create perceptron neural network
        NeuralNetwork myPerceptron = new Perceptron(2, 1);
        // learn the training set
        myPerceptron.learn(trainingSet);
        // test perceptron
        System.out.println("Testing trained perceptron");
        testNeuralNetwork(myPerceptron, trainingSet);
        // save trained perceptron
        myPerceptron.save("mySamplePerceptron.nnet");
        // load saved neural network
        NeuralNetwork loadedPerceptron = NeuralNetwork.load("mySamplePerceptron.nnet");
        // test loaded neural network
        System.out.println("Testing loaded perceptron");
        testNeuralNetwork(loadedPerceptron, trainingSet);

}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
/**
 * Construct a simulated annleaing trainer for a feedforward neural network.
 * 
 * @param network
 *            The neural network to be trained.
 * @param startTemp
 *            The starting temperature.
 * @param stopTemp
 *            The ending temperature.
 * @param cycles
 *            The number of cycles in a training iteration.
 */
public SimulatedAnnealingLearning(final NeuralNetwork network,
		final double startTemp, final double stopTemp, final int cycles) {
	this.network = network;
	this.temperature = startTemp;
	this.startTemperature = startTemp;
	this.stopTemperature = stopTemp;
	this.cycles = cycles;

	this.weights = new double[NeuralNetworkCODEC
			.determineArraySize(network)];
	this.bestWeights = new double[NeuralNetworkCODEC
			.determineArraySize(network)];

	NeuralNetworkCODEC.network2array(network, this.weights);
	NeuralNetworkCODEC.network2array(network, this.bestWeights);
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
/**
 * 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<Neuron>();
               Layer firstLayer = nnet.getLayerAt(0);
               for (Neuron neuron : firstLayer.getNeurons() ) {
                   if (!(neuron instanceof BiasNeuron)) {  // dont set input to bias neurons
                       inputNeuronsList.add(neuron);
                   }
               }

               Neuron[] inputNeurons = new Neuron[inputNeuronsList.size()];
               inputNeurons = inputNeuronsList.toArray(inputNeurons);
	Neuron[] outputNeurons = ((Layer) nnet.getLayerAt(nnet.getLayersCount()-1)).getNeurons();

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

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testLearnedNeuralNet(DataSet trainingSet, DataSet testSet) {
    NeuralNetwork nnet = NeuralNetwork.createFromFile(NNET_NAME);
    System.out.println("Testing loaded neural network");
    //testNeuralNet(nnet, trainingSet, "Training set");
    testNeuralNet(nnet, testSet, "Test set");
    for(Map.Entry<Integer, Integer> entry : errorMap.entrySet()) {
        System.out.println(entry.getKey() + " " + entry.getValue());
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
public static void main(String[] args) {

// create training set (logical XOR function)
        DataSet trainingSet = new DataSet(2, 1);
        trainingSet.addRow(new DataSetRow(new double[]{0, 0}, new double[]{0}));
        trainingSet.addRow(new DataSetRow(new double[]{0, 1}, new double[]{1}));
        trainingSet.addRow(new DataSetRow(new double[]{1, 0}, new double[]{1}));
        trainingSet.addRow(new DataSetRow(new double[]{1, 1}, new double[]{0}));


// create multi layer perceptron
        MultiLayerPerceptron myMlPerceptron = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, 2, 3, 1);
        myMlPerceptron.setLearningRule(new BackPropagation());
// learn the training set
        myMlPerceptron.learn(trainingSet);
// test perceptron
        System.out.println("Testing trained neural network");
        testNeuralNetwork(myMlPerceptron, trainingSet);

// save trained neural network
        myMlPerceptron.save("myMlPerceptron.nnet");

// load saved neural network
        NeuralNetwork loadedMlPerceptron = NeuralNetwork.createFromFile("myMlPerceptron.nnet");

// test loaded neural network
        System.out.println("Testing loaded neural network");
        testNeuralNetwork(loadedMlPerceptron, trainingSet);

    }
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
public static void testNeuralNetwork(NeuralNetwork nnet, DataSet testSet) {

        for(DataSetRow dataRow : testSet.getRows()) {
            nnet.setInput(dataRow.getInput());
            nnet.calculate();
            double[ ] networkOutput = nnet.getOutput();
            System.out.print("Input: " + Arrays.toString(dataRow.getInput()) );
            System.out.println(" Output: " + Arrays.toString(networkOutput) );
        }

    }
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testLearnedNeuralNet(DataSet trainingSet, DataSet testSet) {
        NeuralNetwork nnet = NeuralNetwork.createFromFile(NNET_NAME);
        System.out.println("Testing loaded neural network");
        //testNeuralNet(nnet, trainingSet, "Training set");
        testNeuralNet(nnet, testSet, "Test set");
//        for(Map.Entry<Integer, Integer> entry : errorMap.entrySet()) {
//            System.out.println(entry.getKey() + " " + entry.getValue());
//        }
    }
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testNeuralNet(NeuralNetwork nnet, DataSet dataSet, String setName) {
    int counter = 0;
    for (DataSetRow row : dataSet.getRows()) {
        nnet.setInput(row.getInput());
        nnet.calculate();
        double[] networkOutput = nnet.getOutput();

       // System.out.println(Arrays.toString(networkOutput));

        if (isOutputSame(networkOutput, row.getDesiredOutput())) {
            counter++;
        } else {
            for (int i = 0; i < row.getDesiredOutput().length; i++) {
                if (row.getDesiredOutput()[i] == 1) {
                    Integer d = errorMap.get(i);
                    if (d == null) {
                        errorMap.put(i, 1);
                    } else {
                        errorMap.put(i, ++d);
                    }
                    break;
                }
            }
        }
    }

    System.out.println(setName + " success rate: " + (counter / (double) dataSet.size()));
}
 

import org.neuroph.core.NeuralNetwork; //导入依赖的package包/类
private static void testNeuralNet(NeuralNetwork nnet, DataSet dataSet, String setName) {
    int counter = 0;
    for (DataSetRow row : dataSet.getRows()) {
        nnet.setInput(row.getInput());
        nnet.calculate();
        double[] networkOutput = nnet.getOutput();
        //System.out.println(Arrays.toString(networkOutput));

        if (isOutputSame(networkOutput, row.getDesiredOutput())) {
            counter++;
        } else {
            for (int i = 0; i < row.getDesiredOutput().length; i++) {
                if (row.getDesiredOutput()[i] == 1) {
                    Integer d = errorMap.get(i);
                    if (d == null) {
                        errorMap.put(i, 1);
                    } else {
                        errorMap.put(i, ++d);
                    }
                    break;
                }
            }
        }
    }

    System.out.println(setName + " success rate: " + (counter / (double) dataSet.size()));
}