Hopfield

package hoppfield;

/**
* @author GILBERT ADRIAN
*/

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class Hpfield_java extends JFrame implements ActionListener {
/**
* El numero de neuronas en la red neuronal
*/
public static final int NETWORK_SIZE = 8;

/**
* Los pesos de la matriz para las ocho
* neuronas conectadas.
*/
JTextField matrix[][] =
new JTextField[NETWORK_SIZE][NETWORK_SIZE];

/**
* El patron de entrada, usado en cada
* entrenamiento o corrida de la red neuronal
* cuando la red neuronal ha sido corrida
* ha sido ingresado el patron
*/
JComboBox input[] = new JComboBox[NETWORK_SIZE];

/**
* La salida de cada una de las 8 neuronas.
*/
JTextField output[] = new JTextField[NETWORK_SIZE];
/**
* El boton clear utilizado para limpiar los pesos
* de la matriz.
*/
JButton btnClear = new JButton("Clear");
/**
* El boton entrenar, Usado para ejecutar el boton train.
*/
JButton btnTrain = new JButton("Train");
/**
* Para correr es boton untilizado en la red neuronal
*/
JButton btnRun = new JButton("Run");
/**
* Crea todos los conponentes y su posicion
*/
public Hpfield_java()
{
setTitle("Hopfield Neural Network");

// Crea conecciones en el panel
JPanel connections = new JPanel();
connections.setLayout(
new GridLayout(NETWORK_SIZE,NETWORK_SIZE) );
for ( int row=0; row < NETWORK_SIZE;row++ ) {
for ( int col=0; col < NETWORK_SIZE;col++ ) {
matrix[row][col] = new JTextField(3);
matrix[row][col].setText("0") ;
connections.add(matrix[row][col]);
}
}

Container content = getContentPane();

GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
content.setLayout(gridbag);

c.fill = GridBagConstraints.NONE;
c.weightx = 1.0;

// Peso del label de la matriz
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.NORTHWEST;
content.add(
new JLabel(
"Weight Matrix for the Hopfield Neural Network:"),c);

// Tamanio de la matriz
c.anchor = GridBagConstraints.CENTER;
c.gridwidth = GridBagConstraints.REMAINDER; //end row
content.add(connections,c);
c.gridwidth = 1;

// Entrada del label del patron
c.anchor = GridBagConstraints.NORTHWEST;
c.gridwidth = GridBagConstraints.REMAINDER; //end row
content.add(
new JLabel(
"Click \"Train\" to train the following pattern:"),c);

// Input pattern

String options[] = { "0","1"};

JPanel inputPanel = new JPanel();
inputPanel.setLayout(new FlowLayout());
for ( int i=0 ; i < NETWORK_SIZE;i++ ) {
input[i] = new JComboBox(options);
inputPanel.add(input[i]);

}

c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.CENTER;
content.add(inputPanel,c);

// Salida del label del patron
c.anchor = GridBagConstraints.NORTHWEST;
c.gridwidth = GridBagConstraints.REMAINDER; //end row
content.add(
new JLabel("Click \"Run\" to see output pattern:"),c);

// Salida del patron

JPanel outputPanel = new JPanel();
outputPanel.setLayout(new FlowLayout());
for ( int i=0; i < NETWORK_SIZE;i++ ) {
output[i] = new JTextField(3);
output[i].setEditable(false);
outputPanel.add(output[i]);
}
c.gridwidth = GridBagConstraints.REMAINDER; //end row
c.anchor = GridBagConstraints.CENTER;
content.add(outputPanel,c);

// Botones

JPanel buttonPanel = new JPanel();
btnClear = new JButton("Clear");
btnTrain = new JButton("Train");
btnRun = new JButton("Run");
btnClear.addActionListener(this);
btnTrain.addActionListener(this);
btnRun.addActionListener(this);
buttonPanel.setLayout(new FlowLayout());
buttonPanel.add(btnClear);
buttonPanel.add(btnTrain);
buttonPanel.add(btnRun);
content.add(buttonPanel,c);

// Ajustar tamanio y posicion
pack();
Toolkit toolkit = Toolkit.getDefaultToolkit();
Dimension d = toolkit.getScreenSize();
setLocation(
(int)(d.width-this.getSize().getWidth())/2,
(int)(d.height-this.getSize().getHeight())/2 );
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
setResizable(false);
}
/**
* Usado para disparar los eventos de los botones
* y manejar los metodos
*/
public void actionPerformed(ActionEvent e)
{
if ( e.getSource()==btnRun )
run();
else if ( e.getSource()==btnClear )
clear();
else if ( e.getSource()==btnTrain )
train();
}

/**
* Llamado cuando la red neuronal ha sido corrida en contra
* la entrada
*/
protected void run()
{
boolean pattern[] = new boolean[NETWORK_SIZE];
int wt[][] = new int[NETWORK_SIZE][NETWORK_SIZE];

for ( int row=0;row < NETWORK_SIZE;row++ )
for ( int col=0; col < NETWORK_SIZE;col++ )
wt[row][col]=Integer.parseInt(matrix[row][col].getText());
for ( int row=0;row < NETWORK_SIZE;row++ ) {
int i = input[row].getSelectedIndex();
if ( i==0 )
pattern[row] = false;
else
pattern[row] = true;
}

Layer net = new Layer(wt);
net.activation(pattern);

for ( int row=0; row < NETWORK_SIZE;row++ ) {
if ( net.output[row] )
output[row].setText("1");
else
output[row].setText("0");
if ( net.output[row]==pattern[row] )
output[row].setBackground(java.awt.Color.green);
else
output[row].setBackground(java.awt.Color.red);
}
}
/**
* LLamado para eliminar los pesos de la matriz
*/
protected void clear()
{
for ( int row=0; row < NETWORK_SIZE;row++ )
for ( int col=0; col < NETWORK_SIZE;col++ )
matrix[row][col].setText("0");
}

/**
* Llamada para entrenar los pesos de la matriz base
* con el patron ingresado
*/
protected void train()
{
int work[][] = new int[NETWORK_SIZE][NETWORK_SIZE];
int bi[] = new int[NETWORK_SIZE];

for ( int x=0 ; x < NETWORK_SIZE;x++ ) {
if ( input[x].getSelectedIndex()==0 )
bi[x] = -1;
else
bi[x] = 1;
}

for ( int row=0; row < NETWORK_SIZE;row++ )
for ( int col=0; col < NETWORK_SIZE;col++ ) {
work[row][col] = bi[row]*bi[col];
}

for ( int x=0; x < NETWORK_SIZE;x++ )
work[x][x] =0;

for ( int row=0; row < NETWORK_SIZE;row++ )
for ( int col=0; col < NETWORK_SIZE;col++ ) {
int i = Integer.parseInt(matrix[row][col].getText());
matrix[row][col].setText( "" + (work[row][col]));
}
}
}

***********************
*******************************************
package hoppfield;
/**
* @author GILBERT ADRIAN
*/
public class Neuron {
/**
* Los pesos entre esta neurona y otra esta en el metodo Layer
*/
public int weightv[];
/**
* Activacion de resultados de esta neurona
*/
public int activation;
/**
* El constructor. Los pesos entre esta neurona y las otras
* incluida ella misma es pasada en un array. Usualmente los pesos
* entre esta neurona y ella misma es cero.
*/
public Neuron(int in[])
{
weightv = in;
}
/**
* Metodo llamado para determinar si la nerurona podria ser activada
*/
public int act(boolean x[] )
{
int i;
int a=0;

for ( i=0; i < x.length;i++ )
if ( x[i] )
a+=weightv[i];
return a;
}
}
******************************
********************************
package hoppfield;
/**
* @author GILBERT ADRIAN
*/
public class Layer {
/**
* El Array de neuronas
*/
protected Neuron neuron[] = new Neuron[8];

/**
* Salida de las neuronas
*/
protected boolean output[] = new boolean[8];

/**
* El numero de neuronas en esta capa. Puesto a q esta es una capa
* de neurona simple, este es tambien el numero de neuronas en la red.
*/
protected int neurons;

/**
* Una constante se multiplica a la funcion threshold
*/
public static final double lambda = 1.0;

/**
* EL constructor. El peso de la matriz por las
* neuronas debe ser pasado aqui.
* Puesto a que es una capa simple de red el peso de
* del array debe ser siempre un cuadrado perfecto estos
* pesos son utilizados para inicializar la neurona.
*/
Layer(int weights[][])
{
neurons = weights[0].length;

neuron = new Neuron[neurons];
output = new boolean[neurons];

for ( int i=0;i neuron[i]=new Neuron(weights[i]);
}

/**
* El metodo threshold es usado para determinar si la red de neuronas
* sera disparada al dar un patron. Este threshold utiliza
* una tangente Hyperbolica (tanh).
*/
public boolean threshold(int k)
{
double kk = k * lambda;
double a = Math.exp( kk );
double b = Math.exp( -kk );
double tanh = (a-b)/(a+b);
return(tanh>=0);
}

/**
* Este metodo es corrido pacorrer la red neuronal
*/
void activation(boolean pattern[])
{
int i,j;
for ( i=0;i<8;i++ ) {
neuron[i].activation = neuron[i].act(pattern);
output[i] = threshold(neuron[i].activation);
}
}
}
*************************
*********************************************
package hoppfield;

import javax.swing.JFrame;

/**
* @author GILBERT ADRIAN
*/
public class Main {
public static void main(String[] args) {
JFrame f = new Hpfield_java();
f.show();
}
}