maincontroller.java

利用Java实现的神经网络工具箱

/*
 * $RCSfile: MainController.java,v $
 * $Revision: 1.8 $
 * $Date: 2005/04/26 21:31:04 $
 *
 * NeuralNetworkToolkit
 * Copyright (C) 2004 Universidade de Brasília
 *
 * This file is part of NeuralNetworkToolkit.
 *
 * NeuralNetworkToolkit is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * NeuralNetworkToolkit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with NeuralNetworkToolkit; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 - USA.
 */
package neuralnetworktoolkit.gui.controller;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Vector;

import neuralnetworktoolkit.NetworkController;
import neuralnetworktoolkit.NetworkControllerException;
import neuralnetworktoolkit.NeuralModel;
import neuralnetworktoolkit.StatisticalResults;
import neuralnetworktoolkit.architectures.ArchitectureParameters;
import neuralnetworktoolkit.datamanager.textfilemanager.*;
import neuralnetworktoolkit.methods.ITrainingMethod;
import neuralnetworktoolkit.methods.TrainingParameters;
import neuralnetworktoolkit.modelstorage.ModelSerializer;
import neuralnetworktoolkit.modelstorage.ModelSerializerException;
import neuralnetworktoolkit.normalization.NormalizationParameters;

/**
 * 
 * 
 * @version $Revision: 1.8 $ - $Date: 2005/04/26 21:31:04 $
 * 
 * @author <a href="mailto:[e-mail]">Rodrigo C. M. Coimbra</a>
 * @author <a href="mailto:[e-mail]">Hugo Iver V. Gonçalves</a>
 */
public class MainController implements IMainController {
	
	private	ITrainingMethod method = null;
	private NetworkController networkController = null;
	private StatisticalResults results = null;
	
	/**
	 * 
	 * @param file
	 */
	public void loadDataFromFile(File file, String separator)
			throws LoadFromFileException {
		LoadFromFile loader = new LoadFromFile(file, separator);
		
		networkController = new NetworkController();
		
		networkController.setCompleteDataHeader(loader.getDataHeader());
		networkController.setTrainingData(loader.getDataValues());
		
	} //loadDataFromFile()
	
	/**
	 * 
	 * @param file
	 * @param separator
	 * @throws LoadFromFileException
	 */
	public void loadInferenceDataFromFile(File file, String separator)
			throws LoadFromFileException {
		LoadFromFile loader = new LoadFromFile(file, separator);
		
		networkController.setInferenceData(loader.getDataValues());
		
	} //loadInferenceDataFromFile()
	
	/* 
	 * @see neuralnetworktoolkit.controller.IMainController#loadDataFromArff(java.io.File)
	 */
	public void loadDataFromArff(File arffFile) {
		// TODO Auto-generated method stub
		
	} //loadDataFromArff()

	/* 
	 * @see neuralnetworktoolkit.controller.IMainController#loadDataFromDatabase()
	 */
	public void loadDataFromDatabase() {
		// TODO Auto-generated method stub
		
	} //loadDataFromDatabase()
	
	/**
	 * 
	 * @return
	 */
	public Vector getDisplayData() {
		Vector displayData;
		Vector row;
		double[][] data;
		
		displayData = new Vector();
		data = networkController.getCompleteData();
		for (int i = 0; i < data.length; i++) {
			row = new Vector();
			for (int j = 0; j < data[0].length; j++) {
				row.add(new Double(data[i][j]));
			}
			displayData.add(row);

		}
		return displayData;
		
	} //getDisplayData()
	
	/**
	 * 
	 * @return
	 */
	public Vector getDataHeader() {
		String[] header;
		Vector dataHeader;
		
		dataHeader = new Vector();
		header = networkController.getCompleteDataHeader();
		for(int i = 0; i < header.length; i++) {
			dataHeader.add(header[i]);
			
		}
		return dataHeader;
		
	} //getInputHeader()
	
	/**
	 * 
	 */
	public Vector getInferenceDataHeader() {
		String[] header;
		Vector inferenceDataHeader;
		
		header = networkController.getInferenceDataHeader();
		inferenceDataHeader = new Vector(header.length);
		for(int i = 0; i < header.length; i++) {
			inferenceDataHeader.add(header[i]);
			
		}
		return inferenceDataHeader;
		
	} //getInferenceDataHeader()
	
	/**
	 * 
	 */
	public Vector getInferedDataHeader() {
		String[] header;
		Vector inferedDataHeader;
		
		inferedDataHeader = new Vector();
		header = networkController.getInferedDataHeader();
		for(int i = 0; i < header.length; i++) {
			inferedDataHeader.add(header[i]);
			
		}
		return inferedDataHeader;
		
	} //getInferenceDataHeader()
	
	/**
	 * 
	 * @return
	 */
	public Vector getInferenceData() {
		double[][] data;
		Vector inferenceData;
		Vector row;
		
		data = networkController.getInferenceData();
		inferenceData = new Vector();
		
		for(int i = 0; i < data.length; i++) {
			row = new Vector(data[0].length);
			for(int j = 0; j < data[0].length; j++) {
				row.add(new Double(data[i][j]));
				
			}
			inferenceData.add(row);
			
		}
		return inferenceData;
		
	} //getInferenceData()
	
	/* (non-Javadoc)
	 * @see neuralnetworktoolkit.gui.controller.IMainController#getInferedData()
	 */
	public Vector getInferedData() {
		double[][] data;
		Vector inferedData;
		Vector row;
		
		data = networkController.getInferedData();
		inferedData = new Vector();
		
		for(int i = 0; i < data.length; i++) {
			row = new Vector(data[0].length);
			for(int j = 0; j < data[0].length; j++) {
				row.add(new Double(data[i][j]));
				
			}
			inferedData.add(row);
			
		}
		return inferedData;
		
	} //getInferedData()
	
	/**
	 * @throws NetworkControllerException
	 * 
	 *
	 */
	public void createNetwork(int[] outputIndex,
			ArchitectureParameters parameters,
			TrainingParameters trainingParameters,
			NormalizationParameters normalizationParameters)
			throws NetworkControllerException {

		networkController.setOutputIndex(outputIndex);
		networkController.splitDataValues();
		networkController.createNeuralNetwork(parameters);
		networkController.setNormalization(normalizationParameters);
		results = networkController.trainNeuralNetwork(trainingParameters);
		
	} //createNetwork()

	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#saveNetwork(String)
	 */
	public void saveNetwork(String fileName) throws ModelSerializerException {
		ModelSerializer.serializeModelToFile(
				networkController.getNeuralModel(), fileName);
		
	} //saveNetwork()

	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#infereWithNetwork()
	 */
	public void infereWithNetwork() throws NetworkControllerException {
		networkController.infereWithNetwork();
		
	} //infereWithNetwork()
	
	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#infereWithNetwork(double[][])
	 */
	public void infereWithNetwork(Vector inferenceData)
			throws NetworkControllerException {
		
		double[][] data;
		String datum;
		Vector row;
		
		data = new double[inferenceData.size()][((Vector) inferenceData.get(0))
				.size()];
		
		for(int i = 0; i < data.length; i++) {
			row = (Vector) inferenceData.get(i);
			for(int j = 0; j < data[0].length; j++) {
				datum = (String) row.get(j);
				if(datum != null) {
					data[i][j] = Double.parseDouble(datum);
				
				} else {
					data[i][j] = 0;
					
				}
				
			}
			
		}
		networkController.setInferenceData(data);
		networkController.infereWithNetwork();
		
	} //infereWithNetwork()

	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#saveInferedData(java.io.File)
	 */
	public void saveInferedData(File file) throws IOException {
		String[] inferenceHeader;
		String[] inferedHeader;
		double[][] inferenceData;
		double[][] inferedData;
		
		BufferedWriter writer;
		
		inferenceHeader = networkController.getInferenceDataHeader();
		inferedHeader = networkController.getInferedDataHeader();
		inferenceData = networkController.getInferenceData();
		inferedData = networkController.getInferedData();
		
		writer = new BufferedWriter(new FileWriter(file));
		
		for(int i = 0; i < inferenceHeader.length; i++) {
			writer.write(inferenceHeader[i] + "	");
			
		}
		for(int i = 0; i < inferedHeader.length - 1; i++) {
			writer.write(inferedHeader[i] + "	");
			
		}
		writer.write(inferedHeader[inferedHeader.length - 1] + "\n");
		
		for(int i = 0; i < inferenceData.length; i++) {
			for(int j = 0; j < inferenceData[0].length; j++) {
				writer.write(inferenceData[i][j] + "	");
				
				
			}
			for(int k = 0; k < inferedData[0].length - 1; k++) {
				writer.write(inferedData[i][k] + "	");
				
				
			}
			writer.write(inferedData[i][inferedData[0].length - 1] + "\n");
			
		}
		writer.close();
		
	} //saveInferedData()

	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#getStatiscalResults()
	 */
	public StatisticalResults getStatiscalResults() {
		return networkController.getStatisticalResults();
		
	} //getStatiscalResults()

	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#loadNetwork(java.io.File)
	 */
	public void loadNetwork(File selectedFile) throws ModelSerializerException,
			NetworkControllerException {
		NeuralModel model;
		
		model = ModelSerializer.retrieveSerializedModel(selectedFile);
		networkController = new NetworkController();
		networkController.createNeuralNetwork(model);
		
	} //loadNetwork()

	/* 
	 * @see neuralnetworktoolkit.gui.controller.IMainController#getInputSize()
	 */
	public int getInputSize() {
		return networkController.getInputSize();
		
	} //getInputSize()
	
} //MainController