Java NeuralNetwork.calculate方法代码示例

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 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包/类
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 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()));
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Prints network output for the each element from the specified training set.
 * @param neuralNet neural network
 * @param testSet test data set
 */
public static void testNeuralNetwork(NeuralNetwork neuralNet, DataSet testSet) {

    for(DataSetRow testSetRow : testSet.getRows()) {
        neuralNet.setInput(testSetRow.getInput());
        neuralNet.calculate();
        double[] networkOutput = neuralNet.getOutput();

        System.out.print("Input: " + Arrays.toString( testSetRow.getInput() ) );
        System.out.println(" Output: " + Arrays.toString( networkOutput) );
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Prints network output for the each element from the specified training set.
 * @param neuralNet neural network
 * @param trainingSet training set
 */
public static void testNeuralNetwork(NeuralNetwork neuralNet, DataSet testSet) {

    for(DataSetRow testSetRow : testSet.getRows()) {
        neuralNet.setInput(testSetRow.getInput());
        neuralNet.calculate();
        double[] networkOutput = neuralNet.getOutput();

        System.out.print("Input: " + Arrays.toString( testSetRow.getInput() ) );
        System.out.println(" Output: " + Arrays.toString( networkOutput) );
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Prints network output for each element from the specified training set.
 * @param neuralNet neural network
 * @param trainingSet training set
 */
public static void testNeuralNetwork(NeuralNetwork neuralNet, DataSet testSet) {

    for(DataSetRow testSetRow : testSet.getRows()) {
        neuralNet.setInput(testSetRow.getInput());
        neuralNet.calculate();
        double[] networkOutput = neuralNet.getOutput();

        System.out.print("Input: " + Arrays.toString( testSetRow.getInput() ) );
        System.out.println(" Output: " + Arrays.toString( networkOutput) );
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Runs this sample
 */    
public static void main(String[] args) throws FileNotFoundException, IOException {
    
    // create neural network
    //MultiLayerPerceptron neuralNet = new MultiLayerPerceptron(2, 3, 1); 
    
    // use file provided in org.neuroph.sample.data package
    String inputFileName = FileIOSample.class.getResource("data/xor_data.txt").getFile();
    // create file input adapter using specifed file
    FileInputAdapter fileIn = new FileInputAdapter(inputFileName);
    // create file output  adapter using specified file name
    FileOutputAdapter fileOut = new FileOutputAdapter("some_output_file.txt");
          
    NeuralNetwork neuralNet = NeuralNetwork.load("myMlPerceptron.nnet");
    double[] input; // input buffer used for reading network input from file
    // read network input using input adapter
    while( (input = fileIn.readInput()) != null) {
        // feed neywork with input    
        neuralNet.setInput(input);
        // calculate network ...
        neuralNet.calculate();  
        // .. and get network output
        double[] output = neuralNet.getOutput();
        // write network output using output adapter
        fileOut.writeOutput(output);
    }
    
    // close input and output files
    fileIn.close();
    fileOut.close();     
    
    // Also note that shorter way for this is using org.neuroph.util.io.IOHelper class
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Prints network output for the each element from the specified training set.
 * @param neuralNet neural network
 * @param testSet data set used for testing
 */
public static void testNeuralNetwork(NeuralNetwork neuralNet, DataSet testSet) {

    for(DataSetRow trainingElement : testSet.getRows()) {
        neuralNet.setInput(trainingElement.getInput());
        neuralNet.calculate();
        double[] networkOutput = neuralNet.getOutput();

        System.out.print("Input: " + Arrays.toString(trainingElement.getInput()) );
        System.out.println(" Output: " + Arrays.toString(networkOutput) );
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
public static void main(String[] args) {
	// create new perceptron network
	NeuralNetwork neuralNetwork = new Perceptron(3, 1);
	// create training set
	DataSet trainingSet = new DataSet(3, 1);
	// add training data to training set (logical OR function)
	trainingSet.addRow(new DataSetRow(new double[] { 0, 0 ,0}, new double[] { 0 }));
	trainingSet.addRow(new DataSetRow(new double[] { 0, 1 ,0}, new double[] { 1 }));
	trainingSet.addRow(new DataSetRow(new double[] { 1, 0 ,0}, new double[] { 1 }));
	trainingSet.addRow(new DataSetRow(new double[] { 1, 1 ,0}, new double[] { 1 }));
	trainingSet.addRow(new DataSetRow(new double[] { 0, 0 ,1}, new double[] { 1 }));
	trainingSet.addRow(new DataSetRow(new double[] { 0, 1 ,1}, new double[] { 1 }));
	trainingSet.addRow(new DataSetRow(new double[] { 1, 0 ,1}, new double[] { 1 }));
	trainingSet.addRow(new DataSetRow(new double[] { 1, 1 ,1}, new double[] { 1 }));
	// learn the training set
	neuralNetwork.learn(trainingSet);
	// save the trained network into file
	neuralNetwork.save("or_perceptron.nnet");

	// load the saved network
	NeuralNetwork neuralNetwork1 = NeuralNetwork.createFromFile("or_perceptron.nnet");
	// set network input
	neuralNetwork1.setInput(1, 1,1);
	// calculate network
	neuralNetwork1.calculate();
	// get network output
	double[] networkOutput = neuralNetwork1.getOutput();
	System.out.println(Arrays.toString(networkOutput));
}
 

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

	for (DataSetRow testSetRow : testSet.getRows()) {
		neuralNet.setInput(testSetRow.getInput());
		neuralNet.calculate();
		double[] networkOutput = neuralNet.getOutput();

		System.out
				.print("Input: " + Arrays.toString(testSetRow.getInput()));
		System.out.println(" Output: " + Arrays.toString(networkOutput));
	}
}
 

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

		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包/类
/**
 * Feeds specified neural network with data from InputAdapter and writes
 * output using OutputAdapter
 * @param neuralNet neural network
 * @param in input data source
 * @param out output data target  
 */
public static void process(NeuralNetwork neuralNet, InputAdapter in, OutputAdapter out) {
   
    double[] input;
    while( (input = in.readInput()) != null) {
        neuralNet.setInput(input);
        neuralNet.calculate();  
        double[] output = neuralNet.getOutput();
        out.writeOutput(output);
    }
    
    in.close();
    out.close();         
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
public static String predict(int[] dys,String HG) {
	int[] TUNING=YSubCladeUtil.getTuning(HG);
	int[] BITS=YSubCladeUtil.getBits(HG);
	String[] OUTPUT=YSubCladeUtil.getOutput(HG);
	int total_bits=0;
	for(int i=0;i<BITS.length;i++)
		total_bits+=BITS[i];
	
	String[] binary_str=new String[12];
	StringBuffer sb=new StringBuffer();
	for(int i=0;i<12;i++)
	{
		binary_str[i]="00000"+Integer.toBinaryString(dys[i]-TUNING[i]);
		binary_str[i]=binary_str[i].substring(binary_str[i].length()-BITS[i]);
		sb.append(binary_str[i]);
	}
	String input=sb.toString();
	double[] input_normalized=new double[total_bits];
	
	for(int i=0;i<total_bits;i++)
	{
		if(input.charAt(i)=='0')
			input_normalized[i]=0;
		else if(input.charAt(i)=='1')
			input_normalized[i]=1;
		else
			throw new RuntimeException("Error:Input data not normalized.");
	}
	
	NeuralNetwork neuralNetwork = NeuralNetwork.load(YHaploEntryDlg.class.getResourceAsStream("/fc/id/au/haplogroups/"+HG+".nnet"));
	neuralNetwork.setInput(input_normalized);
	neuralNetwork.calculate(); 
	double[] networkOutput = neuralNetwork.getOutput();
	
	sb.setLength(0);
	for(int i=0;i<networkOutput.length;i++)
	{
		sb.append((Math.round(networkOutput[i])));
	}
	String output=sb.toString();	
	int value=Integer.parseInt(output, 2);
	String haplogroup=OUTPUT[value];
	return haplogroup;		
}