rbf.java

RBF java file, complete

package es.uvigo.ei.aibench.analysis.rbf;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Date;
import java.util.Hashtable;
import java.util.List;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.Vector;

import org.apache.log4j.Logger;

import es.uvigo.ei.sing.datatypes.data.Data;

/** ****************************************************** */
// CLASE CLUSTERS
/**
 * @author Rub�n Dom�nguez Carbajales 13-feb-2006 - 2006
 */
class NodoGCS {
	float[]	w;

	float	contVictorias;

	Vector	nodosVecinos;

	Vector	distNodosVecinos;

	Vector	casosAgrupados;

	void setW(String cad) {
		StringTokenizer tokens;

		tokens = new StringTokenizer(cad, ",", false);
		w = new float[tokens.countTokens()];
		for (int x = 0; x < w.length; x++)
			w[x] = new Float(tokens.nextToken().trim()).floatValue();
	}

	/**
	 * @return Returns the w.
	 */
	String getW() {
		String result = "";
	
		for (int x = 0; x < w.length; x++)
			result += w[x] + ", ";
		result = result.substring(0, result.lastIndexOf(","));
		return result;
	}

	void setNodosVecinos(String cad) {
		String vecino;
		nodosVecinos = new Vector();
		StringTokenizer tokens = new StringTokenizer(cad, ",", false);
		while (tokens.hasMoreTokens())
			nodosVecinos.addElement(new Integer(tokens.nextToken().trim()));
	}

	/**
	 * @return Returns the nodosVecinos.
	 */
	String getNodosVecinos() {
		return nodosVecinos.toString();
	}

	void setDistNodosVecinos(String cad) {
		distNodosVecinos = new Vector();
		StringTokenizer tokens = new StringTokenizer(cad, ",", false);
		while (tokens.hasMoreTokens())
			distNodosVecinos.addElement(new Float(tokens.nextToken().trim()));
	}

	/**
	 * @return Returns the distNodosVecinos.
	 */
	String getDistNodosVecinos() {
		return distNodosVecinos.toString();
	}

	void setCasosAgrupados(String cad) {
		casosAgrupados = new Vector();
		StringTokenizer tokens = new StringTokenizer(cad, ",", false);
		while (tokens.hasMoreTokens())
			casosAgrupados.addElement(new Integer(tokens.nextToken().trim()));
	}

	/**
	 * @return Returns the casosAgrupados.
	 */
	String getCasosAgrupados() {
		return casosAgrupados.toString();
	}
}

/** ****************************************************** */
// NEURONA DE ENTRADA O SALIDA
/** ****************************************************** */
class NeuronaSimple {
	float	valor;

	float	error;
}

/** ****************************************************** */

/** ****************************************************** */
// NEURONA DE LA CAPA INTERMEDIA
/** ****************************************************** */
class NeuronaCentro extends NeuronaSimple {
	Vector	kNN;

	float	sigma;

	int		patronRaiz;

	float[]	vectorValores;

	float	errorAcumulado;

	public NeuronaCentro(int numValores) {
		vectorValores = new float[numValores];
		kNN = new Vector();
		errorAcumulado = 0;
		sigma = 1;
	}
}

/** ****************************************************** */

/** ****************************************************** */
// CONECTOR
/** ****************************************************** */
class Conector {
	float			pesoActual;

	float			incrementoPeso;

	static float	momento;

	static Date		dt;

	static Random	rnd;

	static {
		Date dt = new Date();
		rnd = new Random(dt.getTime());
		momento = 0;
	}

	public Conector(float min_val_inic, float max_val_inic, float momento) {
		// Valor aleatorio en el intervalo [MIN_VAL_INIC, MAX_VAL_INIC]
		pesoActual = rnd.nextFloat() * Math.abs(max_val_inic - min_val_inic) + min_val_inic;
		incrementoPeso = 0;
		this.momento = momento;
	}

	public Conector(float peso_inic, float momento) {
		// Inicializa el conector con un valor dado
		pesoActual = peso_inic;
		incrementoPeso = 0;
		this.momento = momento;
	}

	public void establecerPeso(float nuevoPeso) {
		pesoActual = nuevoPeso;
	}

	public void actualizarPeso(float incrementoPeso) {
		pesoActual += incrementoPeso + (momento * incrementoPeso);
		incrementoPeso = incrementoPeso;
	}
}

/** ****************************************************** */

/** ****************************************************** */
// CLASE PRINCIPAL DE LA APLICACION
/**
 * @author Rub�n Dom�nguez Carbajales 13-feb-2006 - 2006
 */
public class RBF {

	private Vector<IRBFListener>	listeners			= new Vector<IRBFListener>();

	static Logger					logger				= Logger.getLogger(RBF.class.getName());

	// Definicion de constantes
	static final int				MAX					= 1;

	static final int				MIN					= -1;

	// Manejo de E/S
	static final String				SEPARADOR			= ",";

	static final String				endl				= "\n";

	String							valorAct;

	BufferedReader					teclado;

	String							nomFichero;

	String							nomFichTraza;

	DataOutputStream				fichLog;

	// Formato decimal y generacion de numeros aleatorios
	Random							rnd;

	Vector							patrones;

	DecimalFormatSymbols			dfs					= new DecimalFormatSymbols();

	DecimalFormat					formato				= new DecimalFormat("0.00000");

	// Variables del fichero de datos:
	int								numAtributos		= 0;

	int								numCasos			= 0;

	String[]						nomAtrib;

	float[][]						valAtrib;

	float[][]						valAtribTrn;

	int								numCasosTrn;

	float[][]						valAtribTest;

	int								numCasosTest;

	float[][]						valAtribSim;

	int								numCasosSim;

	// Topologia:
	int								numNeuronasEntrada;

	int								numNeuronasCentro;

	int								numNeuronasSalida;

	/**
	 */
	NeuronaSimple[]					neuronasEntrada;

	/**
	 */
	NeuronaCentro[]					neuronasCentro;

	/**
	 */
	Conector[][]					conectorCS;

	/**
	 */
	Conector[]						conectorBS;

	/**
	 */
	NeuronaSimple[]					neuronasSalida;

	// Parametros de entrenamiento:
	float							RATIO_APRENDIZAJE	= 0.05F;

	// Parametros de entrenamiento:
	float							ratioAprendizaje;

	float							ratioNuevoCentro	= 15.0F;

	float							momento				= 0.0F;

	int								RATIO_ITERAC_LIMITE	= 75;										// El x

	// por
	// cien
	// del
	// total
	// de
	// las

	// iteraciones [0, 100]

	float							LAMBDA1				= 0.01F;

	// iteraciones [0, 100]

	float							deltaLambda1;

	// iteraciones [0, 100]

	float							lambda1Act;

	float							LAMBDA2				= 0.0025F;

	float							deltaLambda2;

	float							lambda2Act;

	float							pesoConectorMin		= -0.00001F;

	float							pesoConectorMax		= 0.00001F;

	int								MIN_CENTROS;

	int								MAX_CENTROS;

	int								deltaCentros;

	boolean							BIAS				= false;

	boolean							SALIDA_NORMALIZADA	= true;

	// Seguimiento del entrenamiento
	boolean[]						centroInsertado;

	float[]							errorIteracion;

	float[]							errorPatron;

	// Condiciones de parada
	float							TOLERANCIA			= 0.01F;

	float							MIN_ERROR_MED		= 0.0005F;

	float							errorTotal;

	int								MAX_ITERACIONES;

	int								iteracion;

	// Clustering GCS
	Vector							Nodos				= null;

	private boolean					train				= false;

	private boolean					forecast			= false;

	// RBF
	public RBF() throws FileNotFoundException {
		nomFichTraza = System.getProperty("user.home") + File.separator + "RBF.log";
		fichLog = new DataOutputStream(new FileOutputStream(nomFichTraza));

		teclado = new BufferedReader(new InputStreamReader(System.in));

		dfs.setDecimalSeparator('.');
		formato.setDecimalFormatSymbols(dfs);
	}

	protected void loadData_(Data data, String conCopia) {
		int x, y, fila = 0;
		Vector[] colAtrib = null;

		logger.info("RBF: Loaded data " + data.getName());

		log("(-)(-)(-) LOADDATA: " + data.getName() + " (-)(-)(-)");

		numAtributos = data.getNumVariables();

		nomAtrib = new String[numAtributos];
		colAtrib = new Vector[numAtributos];

		for (x = 0; x < numAtributos; x++) {
			nomAtrib[x] = data.getVariableAt(x).getName();
			colAtrib[x] = new Vector();
		}
		for (int i = 0; i < data.getCountSamples(); i++) {
			for (x = 0; x < numAtributos; x++) {
				colAtrib[x].addElement((Float) data.getSampleAt(i).getValorAt(x));
			}
		}
		
		numCasos = data.getCountSamples();

		// Se genera la matriz bidimensional de float con los valores
		valAtrib = new float[numCasos][numAtributos];
		for (y = 0; y < numCasos; y++)
			for (x = 0; x < numAtributos; x++)
				valAtrib[y][x] = ((Float) colAtrib[x].elementAt(y)).floatValue();

		// Se realiza copia de los datos donde corresponda
		if (conCopia.equals("TRN")) {
			valAtribTrn = new float[numCasos][numAtributos];
			for (y = 0; y < numCasos; y++)
				for (x = 0; x < numAtributos; x++)
					valAtribTrn[y][x] = valAtrib[y][x];
			numCasosTrn = numCasos;
		} else if (conCopia.equals("TEST")) {
			valAtribTest = new float[numCasos][numAtributos];
			for (y = 0; y < numCasos; y++)
				for (x = 0; x < numAtributos; x++)
					valAtribTest[y][x] = valAtrib[y][x];
			numCasosTest = numCasos;
		}

		log("\t" + numAtributos + " atributos.");
		log("\t" + numCasos + " casos.");
	
		
		/*System.out.println(endl + endl + "-----");
		System.out.println(numAtributos + " atributos.");
		System.out.println(numCasos + " casos.");
		System.out.println("-----");*/


	}

	// SAVECFG
	protected void saveCFG_(String nomFich) {
		if (noHayConfiguracion())
			return;

		int y, x;
		DataOutputStream cout;
		String linActual = "", valorAct, nomFicheroCFG;

		try {
			if (nomFich.length() == 0) {
				nomFicheroCFG = nomFichero.substring(0, nomFichero.lastIndexOf(".")) + "_RBF.cfg";
				System.out.println("");
				System.out.print("Introduce el nombre del fichero, [" + nomFicheroCFG + "]: ");
				valorAct = teclado.readLine();
				nomFicheroCFG = (valorAct.length() == 0) ? nomFicheroCFG : valorAct;