Java NeuralNetwork.load方法代码示例

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包/类
@Override
public void doRun() {
    try {
        //Bypass network reload during comeback through home button
        if (nnet == null) {
            File NNetwork = new File(ConstantObjects.neuralNetworkPath);
            System.out.println("Nueral network loaded = " + NNetwork.getAbsolutePath());
            if (!NNetwork.exists()) {
                notifyUser();
                return;
            }
            nnet = NeuralNetwork.load(new FileInputStream(NNetwork)); // load trained neural network saved with Neuroph Studio
            System.out.println("Learning Rule = " + nnet.getLearningRule());
            imageRecognition = (ImageRecognitionPlugin) nnet.getPlugin(ImageRecognitionPlugin.class); // get the image recognition plugin from neural network
        }
        HashMap<String, Double> output = imageRecognition.recognizeImage(image);
        if (output == null) {
            System.err.println("Image Recognition Failed");
        }
        System.out.println(output.toString());
        listener.neuralnetProcessCompleted(output);

    } catch (Exception ex) {
        Logger.getLogger(NeuralNetProcessor.class.getName()).log(Level.SEVERE, null, ex);
        listener.neuralnetProcessCompleted(null);
    }
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Runs this sample
 */
public void run() {
	
    // 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.TANH, 2, 3, 1);
    // enable batch if using MomentumBackpropagation
    if( myMlPerceptron.getLearningRule() instanceof MomentumBackpropagation ){
    	((MomentumBackpropagation)myMlPerceptron.getLearningRule()).setBatchMode(true);
    	((MomentumBackpropagation)myMlPerceptron.getLearningRule()).setMaxError(0.00001);
    }

    LearningRule learningRule = myMlPerceptron.getLearningRule();
    learningRule.addListener(this);
    
    // learn the training set
    System.out.println("Training neural network...");
    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.load("myMlPerceptron.nnet");

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

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包/类
public FIDNetworkAnalyser(String nSourceFile) throws FileNotFoundException {
    nnet = NeuralNetwork.load(new FileInputStream(nSourceFile)); // load trained neural network saved with Neuroph Studio
}
 

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

		// create training set (extending XOR sample)
		DataSet trainingSet = new DataSet(2, 1);
		trainingSet.addRow(new DataSetRow(new double[]{0, 0}, new double[]{1}));
		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}));
		trainingSet.addRow(new DataSetRow(new double[]{2, 2}, new double[]{-1}));
		trainingSet.addRow(new DataSetRow(new double[]{1, 2}, new double[]{-1}));
		trainingSet.addRow(new DataSetRow(new double[]{1, 3}, new double[]{-1}));
		trainingSet.addRow(new DataSetRow(new double[]{2, 2}, new double[]{-1}));
		trainingSet.addRow(new DataSetRow(new double[]{2, 42}, new double[]{-1}));

		// create multi layer perceptron
		MultiLayerPerceptron myMlPerceptron = new MultiLayerPerceptron(TransferFunctionType.TANH, 2, 9, 1);
		// learn the training set

		long start = System.currentTimeMillis();

		myMlPerceptron.learn(trainingSet);

		long time = System.currentTimeMillis()-start;

		System.out.println("It took: "+time+" ms");

		// test perceptron
		System.out.println("Testing trained neural network");
		testNeuralNetwork(myMlPerceptron, trainingSet);

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

		// load saved neural network
		
		FileInputStream stream;
		
		try {
			
			stream = new FileInputStream("myMlPerceptron.nnet");
			
			NeuralNetwork loadedMlPerceptron = NeuralNetwork.load(stream);
		
			// test loaded neural network
			System.out.println("Testing loaded neural network");
			testNeuralNetwork(loadedMlPerceptron, trainingSet);
			
			System.out.println("Testing unknown input");
			testNeuralNetwork(loadedMlPerceptron, new DataSetRow(new double[]{2, 30}));
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
 

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;		
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
public static String predictHaplogroup(int[] dys) {
	try
	{
	//int[] dys={13, 21, 15, 10, 13, 17, 11, 13, 12, 14, 11, 30};//felix
	//int[] dys={13,22,15,10,12,17,11,13,12,12,11,29}; //E
	/*
	System.out.print("12 Marker STR Values:\t");
	for(int i=0;i<dys.length;i++)
	{
		System.out.print(dys[i]+" ");
	}
	System.out.println();
	*/
	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();
	//System.out.println("Normalized Input:\t"+input);
	
	double[] input_normalized=new double[48];
	
	for(int i=0;i<48;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/HapNN72.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();
	//System.out.println("Normalized Output:\t"+output);
	
	int value=Integer.parseInt(output, 2)+65;
	String haplogroup=((char)value)+"";
	//System.out.println("Predicted Haplogroup:\t"+haplogroup);
	return haplogroup;
	}
	catch (Exception e)
	{
		JOptionPane.showMessageDialog(null, "Error:"+e.getMessage(),"Error",JOptionPane.ERROR_MESSAGE);
		return "?";			
	}
}
 

import org.neuroph.core.NeuralNetwork; //导入方法依赖的package包/类
/**
 * Load network.
 *
 * @param name the name
 */
public void loadNetwork(String name){
	animal_network=NeuralNetwork.load(name);
	System.out.println("load is completed");
}