Una forma sencilla y rápida de aprender JAVA, observando y deduciendo cómo se comporta el lenguaje a través de ejemplos prácticos.

Archivo del blog

miércoles, 17 de diciembre de 2014

Red neuronal artificial (V): Añadiendo entradas manualmente en tiempo de ejecución.

Añadir entradas en una red neuronal manualmente y en tiempo de ejecución podría ser considerado como el órgano de los sentidos (vista, tacto...). Cuando la neurona recibe la acción directa del "medio externo", el estímulo recibido afectará a los valores de las salidas de la red. Ese cambio se verá reflejado en la gráfica.


Primero añadiré al proyecto un jTable1 de 4 columnas con estas características:

Title    Type     Editable
Act      Boolean     V 
Id       Integer     -
Entrada  Float       V
Salida   Double      -



























Código (RedNeuronalG.java):

package redNeuronalG1;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.Timer;
import javax.swing.table.DefaultTableModel;
import org.jfree.data.xy.XYSeries;

public class RedNeuronalG extends javax.swing.JFrame {

    int nNeuronas;
    int nEnlaces;
    int ciclos = 1;  
    
    ArrayList<Integer>[] E;
    ArrayList<Integer>[] S;
    ArrayList<Double>[] w;     
    double[] y;
    
    Random r1;
    Timer timer;
    
    Grafica g;
    XYSeries[] series;    
    DefaultTableModel model;

    public RedNeuronalG() {
        initComponents();
        model = (DefaultTableModel) jTable1.getModel();
        g = new Grafica(jTable1, jPanelGrafica1, series, false);
        restablecer();
        actualizar();
    }

    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() { ... }// </editor-fold> 

    private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {                                             
        try {
            timer.stop();
        } catch (Exception ex) {
        }
        restablecer();
        jPanelGrafica1.removeAll();
        jPanelGrafica1.repaint();
        g = new Grafica(jTable1, jPanelGrafica1, series, false);
    }
    
    private void jButtonGenerarActionPerformed(java.awt.event.ActionEvent evt) {                                               
        if (jButtonPlay.isEnabled() == false && jButtonDetener.isEnabled() == false) {
            jButtonPlay.setEnabled(true);
            jButtonDetener.setEnabled(true);
            jButtonReset.setEnabled(true);
        }
        actualizar();
        ejecutar();
    }                                              


    private void jButtonPlayActionPerformed(java.awt.event.ActionEvent evt) {                                            
        if (jButtonPlay.isEnabled()) {
            jButtonPlay.setEnabled(false);
            jButtonDetener.setEnabled(true);
        }
        actualizar();
        timer = new Timer(0, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                Calcular();
            }
        });
        timer.start();
    }                                           

    private void jButtonDetenerActionPerformed(java.awt.event.ActionEvent evt) {                                               
        if (jButtonDetener.isEnabled()) {
            jButtonDetener.setEnabled(false);
            jButtonPlay.setEnabled(true);
        }
        timer.stop();
    }                                              

    private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {                                     
        Calcular();
    }                                    

    public static void main(String args[]) {
        
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new RedNeuronalG().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jButtonDetener;
    private javax.swing.JButton jButtonGenerar;
    private javax.swing.JButton jButtonPlay;
    private javax.swing.JButton jButtonReset;
    private javax.swing.JLabel jLabelCiclos;
    private javax.swing.JLabel jLabelNumeroNeuronas;
    private javax.swing.JLabel jLabelNumeroSinapsis;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JPanel jPanelGrafica1;
    private javax.swing.JPanel jPanelTable1;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JSpinner jSpinnerCiclos;
    private javax.swing.JSpinner jSpinnerNumeroEnlaces;
    private javax.swing.JSpinner jSpinnerNumeroNeuronas;
    private javax.swing.JTable jTable1;
    // End of variables declaration                   

    private void actualizar() {

        //Actualizar tamaño del jTable
        int nFilas = (int) jSpinnerNumeroNeuronas.getValue();
        while (nFilas != jTable1.getRowCount()) {
            if (nFilas > jTable1.getRowCount()) {
                model.addRow(new Object[]{false, null, null, null, null, null});
            } else if (nFilas < jTable1.getRowCount()) {
                model.removeRow(jTable1.getRowCount() - 1);
            }
        }

        //Actualizar valores variables de entrada
        nNeuronas = (int) jSpinnerNumeroNeuronas.getValue();
        nEnlaces = (int) jSpinnerNumeroEnlaces.getValue();
        ciclos = (int) jSpinnerCiclos.getValue();

        // Control rango maximos minimos jSpinners
        if (nNeuronas <= 1) {
            jSpinnerNumeroNeuronas.setValue(1);
        } else if (nEnlaces <= 1) {
            jSpinnerNumeroEnlaces.setValue(1);
        } else if (ciclos <= 0) {
            jSpinnerCiclos.setValue(1);
        }

    }

    private void restablecer() {

        //Configuracion inicial por defecto
        jButtonPlay.setEnabled(false);
        jButtonDetener.setEnabled(false);

        jSpinnerNumeroNeuronas.setValue(50);
        jSpinnerNumeroEnlaces.setValue(300);
        jSpinnerCiclos.setValue(100);

        for (int i = 0; i < jTable1.getRowCount(); i++) {
            jTable1.setValueAt(false, i, 0);
            jTable1.setValueAt(null, i, 2);
        }

        jTable1.setValueAt(true, 0, 0);
        jTable1.setValueAt(true, 1, 0);
        jTable1.setValueAt(true, 2, 0);

    }

    private void ejecutar() {

        S = new ArrayList[nNeuronas];
        E = new ArrayList[nNeuronas];

        AleatoriedadCondicionada ac = new AleatoriedadCondicionada();
        r1 = new Random();
        int nSalidas = 1; //una salida como mínimo
        int neurona;

        //Crea red neuronal aleatoria
        for (int i = 0; i < S.length; i++) {
            S[i] = new ArrayList();
            E[i] = new ArrayList();

            //Salidas maxima por neurona            
            nSalidas = r1.nextInt(nEnlaces / nNeuronas) + 1;

            for (int j = 0; j < nSalidas; j++) {

                neurona = r1.nextInt(nNeuronas);

                //Aplicación de la Aleatoriedad Condicionada
                neurona = (int) Math.rint(ac.getSalida((double) nNeuronas, neurona));
                if (r1.nextBoolean()) {
                    //conexión hacia delante
                    neurona = i + neurona;
                    if (neurona > nNeuronas) {
                        neurona = neurona - nNeuronas;
                    }
                } else {
                    //conexión hacia atrás
                    neurona = i - neurona;
                    if (neurona < 0) {
                        neurona = neurona + nNeuronas;
                    }
                }
                //evita repeticiones de enlaces a la misma neurona
                if (S[i].contains(neurona) == false) {
                    S[i].add(neurona);
                }
            }
        }

        //agrega los enlaces que faltan para llegar al número exacto
        int recuento = RecuentoEnlaces();
        while (recuento < nEnlaces) {
            int aux = r1.nextInt(nNeuronas);
            int aux2 = r1.nextInt(nNeuronas);
            S[aux].add(aux2);
            recuento++;
        }

        RecuentoEnlaces();

        //Busqueda enlaces de entrada de cada neurona
        for (int i = 0; i < S.length; i++) {
            for (int j = 0; j < E.length; j++) {
                if (S[i].contains(j)) {
                    E[j].add(i);
                }
            }
        }

        //Añadiendo Pesos (w) a los enlaces
        w = new ArrayList[nNeuronas];
        int aux = 0;
        for (int i = 0; i < E.length; i++) {
            w[i] = new ArrayList();
            aux = E[i].size();
            for (int j = 0; j < aux; j++) {
                //Rango bipolar entre -1 y 1
                int tmp = r1.nextBoolean() ? 1 : -1;
                w[i].add(r1.nextDouble() * tmp);
            }
        }

        //Calculo de salidas     
        //Inicializando valores de salida (y)
        y = new double[nNeuronas];
        for (int i = 0; i < nNeuronas; i++) {
            y[i] = 1;
        }
        Calcular();
    }

    private void Calcular() {
        series = new XYSeries[nNeuronas];

        //Inicializando array de series
        for (int i = 0; i < nNeuronas; i++) {
            series[i] = new XYSeries("" + i);
        }

        int cont = 0;
        while (cont < (int) jSpinnerCiclos.getValue()) {
            for (int i = 0; i < nNeuronas; i++) {
                double tmp = 0;
                for (int j = 0; j < E[i].size(); j++) {
                    tmp += (y[E[i].get(j)] * w[i].get(j));
                }
                
                //entrada manual de datos
                tmp = AgregarEntradas(i, tmp);

                y[i] = Math.tanh(tmp);
                series[i].add(cont, y[i]);
            }
            cont++;
        }
        
        FillTable1(); // Llenar jTable1 con los datos actualizados
        g = new Grafica(jTable1, jPanelGrafica1, series, true);
    }

    private void FillTable1() {
        for (int i = 0; i < nNeuronas; i++) {
            jTable1.setValueAt(i, i, 1); // Id neurona
            jTable1.setValueAt(y[i], i, 3); // Resultado salida
        }
    }

    private int RecuentoEnlaces() {
        int nEnlaces = 0;
        for (ArrayList<Integer> S1 : S) {
            nEnlaces += S1.size();
        }
        return nEnlaces;
    }

    private double AgregarEntradas(int i, double tmp) {
        if (jTable1.getValueAt(i, 2) != null) {
            tmp += (float) jTable1.getValueAt(i, 2);
        }
        return tmp;
    }


}


Código 2 (AleatoriedadCondicionada.java):

package redNeuronalG1;

public class AleatoriedadCondicionada {
    public double getSalida(double x, double y) {
        double c = Math.atan(10);
        return ((Math.atan(((y*100/x)/10)-10)*100/c)+100)*x/100;
    }    
}


Código 3 (Grafica.java):

package redNeuronalG1;

import javax.swing.JPanel;
import javax.swing.JTable;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

public class Grafica {

    public Grafica(JTable jTable1, JPanel jPanel1, XYSeries[] series, boolean x) {

        XYSeriesCollection dataset = new XYSeriesCollection();

        int aux = jTable1.getRowCount();

        if (x) {
            //se agrega a la gráfica las neuronas marcadas con el checkbox del jTable1
            for (int i = 0; i < aux; i++) {
                if ((boolean) jTable1.getValueAt(i, 0)) {
                    dataset.addSeries(series[i]);
                }
            }
        }

        JFreeChart chart = ChartFactory.createXYLineChart(
                "",
                "",
                "",
                dataset,
                PlotOrientation.VERTICAL,
                true,
                false,
                false
        );

        //Mostramos la grafica dentro del jPanel1
        ChartPanel panel = new ChartPanel(chart);
        jPanel1.removeAll();
        jPanel1.setLayout(new java.awt.BorderLayout());
        jPanel1.add(panel);
        jPanel1.validate();
    }


}


lunes, 15 de diciembre de 2014

Red neuronal artificial (IV): Graficando las señales de salida de las neuronas en tiempo de ejecución.

En esta nueva entrada creamos nuestro proyecto con una interface gráfica (GUI) para que sea más fácil tratar de cambiar los parámetros que les vamos poner en tiempo de ejecución.
También trataremos de ver en pantalla mediante una gráfica jFreechart la peculiar conducta de los resultados de las salidas de las neuronas.

Primeramente desde NetBeans y en modo de diseño creamos la siguiente interface gráfica:




Código 1: (RedNeuronalG.java):

package redNeuronalG1;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.Timer;
import org.jfree.data.xy.XYSeries;

public class RedNeuronalG extends javax.swing.JFrame {

    int nNeuronas = 50;
    int nEnlaces = 600;
    int nVer = 5;
    int FrecuenciaRefresco;
    int ciclos = 1;

    ArrayList<Integer>[] E;
    ArrayList<Integer>[] S;
    ArrayList<Double>[] w;
    double[] y;
    Grafica g;
    XYSeries[] series;
    Timer timer;

    public RedNeuronalG() {
        initComponents();
        restablecer();
        actualizar();
    }

    private void initComponents() { ... }// </editor-fold>    
   
    private void jButtonResetActionPerformed(java.awt.event.ActionEvent evt) {                                             
        try {
            timer.stop();
        } catch (Exception ex) { }

        restablecer();
        jPanelGrafica1.removeAll();
        jPanelGrafica1.repaint();
        g = new Grafica(jPanelGrafica1, series, nVer, false);
    }                                             

    private void jButtonCrearRedActionPerformed(java.awt.event.ActionEvent evt) {                                                
        if (jButtonPlay.isEnabled() == false && jButtonPausa.isEnabled() == false) {
            jButtonPlay.setEnabled(true);
            jButtonPausa.setEnabled(true);
            jButtonReset.setEnabled(true);
        }
        actualizar();
        crearRed();
    }                                               


    private void jButtonPlayActionPerformed(java.awt.event.ActionEvent evt) {                                            
        if (jButtonPlay.isEnabled()) {
            jButtonPlay.setEnabled(false);
            jButtonPausa.setEnabled(true);
        }
        actualizar();
        timer = new Timer(FrecuenciaRefresco, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent ae) {
                Calcular();
            }
        });
        timer.start();
    }                                           

    private void jButtonPausaActionPerformed(java.awt.event.ActionEvent evt) {                                             
        if (jButtonPausa.isEnabled()) {
            jButtonPausa.setEnabled(false);
            jButtonPlay.setEnabled(true);
        }
        timer.stop();
    }                                            

    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new RedNeuronalG().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jButtonCrearRed;
    private javax.swing.JButton jButtonPausa;
    private javax.swing.JButton jButtonPlay;
    private javax.swing.JButton jButtonReset;
    private javax.swing.JLabel jLabelEnlaces;
    private javax.swing.JLabel jLabelFrecuenciaRefresco;
    private javax.swing.JLabel jLabelNeuronas;
    private javax.swing.JLabel jLabelNeuronasMostrar;
    private javax.swing.JLabel jLabelTiempo;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JPanel jPanelGrafica1;
    private javax.swing.JSeparator jSeparator1;
    private javax.swing.JSeparator jSeparator2;
    private javax.swing.JSpinner jSpinnerCiclos;
    private javax.swing.JSpinner jSpinnerFrecuenciaRefresco;
    private javax.swing.JSpinner jSpinnerNeuronas;
    private javax.swing.JSpinner jSpinnerNeuronasMostrar;
    private javax.swing.JSpinner jSpinnerNumeroSinapsis;
    // End of variables declaration                   

    private void actualizar() {
        nNeuronas = (int) jSpinnerNeuronas.getValue();
        nEnlaces = (int) jSpinnerNumeroSinapsis.getValue();
        nVer = (int) jSpinnerNeuronasMostrar.getValue();
        ciclos = (int) jSpinnerCiclos.getValue();
        FrecuenciaRefresco = (int) jSpinnerFrecuenciaRefresco.getValue();
        // Control rango maximos minimos jSpinners
        if (nNeuronas <= 1) {
            jSpinnerNeuronas.setValue(1);
        } else if (nEnlaces <= 1) {
            jSpinnerNumeroSinapsis.setValue(1);
        } else if (ciclos <= 0) {
            jSpinnerCiclos.setValue(1);
        } else if (nVer >= nNeuronas){
            jSpinnerNeuronasMostrar.setValue(nNeuronas);
            nVer = nNeuronas;
        }
    }

    private void restablecer() {
        //Configuracion inicial por defecto
        jButtonPlay.setEnabled(false);
        jButtonPausa.setEnabled(false);
        jSpinnerNeuronas.setValue(50);
        jSpinnerNumeroSinapsis.setValue(600);
        jSpinnerCiclos.setValue(100);
        jSpinnerNeuronasMostrar.setValue(5);
    }

    private void crearRed() {
        S = new ArrayList[nNeuronas];
        E = new ArrayList[nNeuronas];
        AleatoriedadCondicionada ac = new AleatoriedadCondicionada();
        Random r1 = new Random();
        int nSalidas = 1; //como minimo debe tener una salida
        int neurona;
        //Crea red neuronal aleatoria
        for (int i = 0; i < S.length; i++) {
            S[i] = new ArrayList();
            E[i] = new ArrayList();
            //Salidas maxima por neurona            
            nSalidas = r1.nextInt(nEnlaces / nNeuronas) + 1;
            for (int j = 0; j < nSalidas; j++) {
                neurona = r1.nextInt(nNeuronas);
                //Aplicación de la Aleatoriedad Condicionada
                neurona = (int) Math.rint(ac.getSalida((double) nNeuronas, neurona));
                if (r1.nextBoolean()) {
                    // Conexion hacia delante
                    neurona = i + neurona;
                    if (neurona > nNeuronas) {
                        neurona = neurona - nNeuronas;
                    }
                } else {
                    // Conexion hacia atras
                    neurona = i - neurona;
                    if (neurona < 0) {
                        neurona = neurona + nNeuronas;
                    }
                }
                //evita repeticiones de enlaces a la misma neurona
                if (S[i].contains(neurona) == false) {
                    S[i].add(neurona);
                }
            }
        }
        //Busqueda enlaces de entrada de cada neurona.
        for (int i = 0; i < S.length; i++) {
            for (int j = 0; j < E.length; j++) {
                if (S[i].contains(j)) {
                    E[j].add(i);
                }
            }
        }
        //Añadiendo Pesos (w) a los enlaces
        w = new ArrayList[nNeuronas];
        int aux = 0;
        for (int i = 0; i < E.length; i++) {
            w[i] = new ArrayList();
            aux = E[i].size();
            for (int j = 0; j < aux; j++) {
                //Rango bipolar entre -1 y 1
                int tmp = r1.nextBoolean() ? 1 : -1;
                w[i].add(r1.nextDouble() * tmp);
            }
        }
        y = new double[nNeuronas];
        //Inicializando valores de salida (y)
        for (int i = 0; i < nNeuronas; i++) {
            y[i] = 1;
        }
        Calcular();
    }

    private void Calcular() {
        series = new XYSeries[nNeuronas];
        //Inicializando array de series
        for (int i = 0; i < nNeuronas; i++) {
            series[i] = new XYSeries("" + i);
        }
        int cont = 0;
        while (cont < (int) jSpinnerCiclos.getValue()) {
            for (int i = 0; i < nNeuronas; i++) {
                double tmp = 0;
                for (int j = 0; j < E[i].size(); j++) {
                    tmp += (y[E[i].get(j)] * w[i].get(j));
                }
                y[i] = Math.tanh(tmp);
                series[i].add(cont, y[i]);
            }
            cont++;
        }
        nVer = (int)jSpinnerNeuronasMostrar.getValue();
        nVer = nVer >= nNeuronas ? nNeuronas:nVer;
        jSpinnerNeuronasMostrar.setValue(nVer);
        g = new Grafica(jPanelGrafica1, series, nVer, true);
    }

}


Código 2 (AleatoriedadCondicionada.java):

package redNeuronalG1;

public class AleatoriedadCondicionada {
    public double getSalida(double x, double y) {
        double c = Math.atan(10);
        return ((Math.atan(((y*100/x)/10)-10)*100/c)+100)*x/100;
    }    
}


Código 3 (Grafica.java):

package redNeuronalG1;

import javax.swing.JPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

public class Grafica {

    public Grafica(JPanel jPanel1, XYSeries[] series, int mostrar, boolean x) {

        XYSeriesCollection dataset = new XYSeriesCollection();

        //Rango maximo y mínimo del eje Y de la grafica (1 a -1)
        series[0].add(0, 0.999);
        series[0].add(0, -0.999);

        if (x) {
            for (int i = 0; i < mostrar; i++) {
                dataset.addSeries(series[i]);
            }
        }

        JFreeChart chart = ChartFactory.createXYLineChart(
                "Gráfica Red Neuronal",
                "Ciclos ->",
                "Amplitud Señal->",
                dataset,
                PlotOrientation.VERTICAL,
                true,
                false,
                false
        );
        //Mostramos la grafica dentro del jPanel1
        ChartPanel panel = new ChartPanel(chart);
        jPanel1.removeAll();
        jPanel1.setLayout(new java.awt.BorderLayout());
        jPanel1.add(panel);
        jPanel1.validate();
    }

}


Resultado:
































viernes, 12 de diciembre de 2014

Red neuronal artificial (III). Añadiendo pesos a los enlaces y cálculo de salidas.

Una vez creada la estructura básica de la red, voy a ir añadiendo valores aleatorios a los enlaces (pesos - w). Hecho esto ya se puede calcular los valores de salida de cada neurona (y).
Las formulas utilizadas para los cálculos son los mismos que ver referencia.


Código 1 (RedNeuronal1.java): 

package redneuronal1;

import java.util.ArrayList;
import java.util.Random;

public class RedNeuronal1 {

    public static void main(String[] args) {

        int nNeuronas = 9;
        int nEnlaces = 50;

        ArrayList<Integer>[] S = new ArrayList[nNeuronas];
        ArrayList<Integer>[] E = new ArrayList[nNeuronas];

        AleatoriedadCondicionada ac = new AleatoriedadCondicionada();
        Random r1 = new Random();        
        int nSalidas = 1;
        int neurona;

        //Crea red neuronal aleatoria
        for (int i = 0; i < S.length; i++) {
            S[i] = new ArrayList();
            E[i] = new ArrayList();

            //Salidas maxima por neurona            
            nSalidas = r1.nextInt(nEnlaces / nNeuronas) + 1;
            for (int j = 0; j < nSalidas; j++) {

                neurona = r1.nextInt(nNeuronas);

                //Aplicación de la Aleatoriedad Condicionada
                neurona = (int) Math.rint(ac.getSalida(nNeuronas, neurona));
                if (r1.nextBoolean()) {
                    //Conexión hacia delante
                    neurona = i + neurona;
                    if (neurona > nNeuronas) {
                        neurona = neurona - nNeuronas;
                    }
                } else {
                    //Conexión hacia atrás
                    neurona = i - neurona;
                    if (neurona < 0) {
                        neurona = neurona + nNeuronas;
                    }
                }
                //Evitar enlaces repetidos a la misma neurona
                if (S[i].contains(neurona) == false) {
                    S[i].add(neurona);
                }
            }
        }

        //Búsqueda enlaces de entrada de cada neurona
        for (int i = 0; i < S.length; i++) {
            for (int j = 0; j < E.length; j++) {
                if (S[i].contains(j)) {
                    E[j].add(i);
                }
            }
        }

        //Añadiendo Pesos (w) a los enlaces
        ArrayList<Double>[] w = new ArrayList[nNeuronas];
        int aux = 0;
        for (int i = 0; i < E.length; i++) {
            w[i] = new ArrayList();
            aux = E[i].size();
            for (int j = 0; j < aux; j++) {
                w[i].add(Math.rint(r1.nextDouble() * 10000) / 10000);
            }
        }

        //Cálculo de salidas (y)
        //Inicializando valores de salida
        double[] y = new double[nNeuronas];
        for (int i = 0; i < nNeuronas; i++) {
            y[i] = 1.0;
        }

        //Realización de los cálculos (y)
        double tmp = 0;
        for (int i = 0; i < nNeuronas; i++) {
            tmp = 0;
            for (int j = 0; j < E[i].size(); j++) {
                tmp += (y[E[i].get(j)] * w[i].get(j));
            }
            y[i] = Math.rint(Math.tanh(tmp) * 10000) / 10000;
        }

        //Mostrar enlaces de Entrada (E)
        System.out.println("\n* Enlaces entrada:");
        for (int i = 0; i < E.length; i++) {
            System.out.println("Enlaces entradas Neurona [" + i + "]: " + E[i].toString());
        }

        //Mostrar enlaces de Salidas (S)
        System.out.println("\n* Enlaces salida:");
        for (int i = 0; i < S.length; i++) {
            System.out.println("Enlaces salidas Neurona [" + i + "]: " + S[i].toString());
        }

        //Mostrar valor Pesos (w)
        System.out.println("\n* Pesos:");
        for (int i = 0; i < E.length; i++) {
            System.out.println("w[" + i + "]: " + w[i].toString());
        }

        //Mostrar Salidas calculadas (y):
        System.out.println("\n* Salidas:");
        for (int i = 0; i < nNeuronas; i++) {
            System.out.println("y[" + i + "] = " + y[i]);
        }

    }

}


Código 2 (AleatoriedadCondicionada.java):

package redneuronal1;
public class AleatoriedadCondicionada {    
    public double getSalida(double x, double num) {
        double c = Math.atan(10);
        return ((Math.atan(((num*100/x)/10)-10)*100/c)+100)*x/100;
    }
}


Resultado:

run:

* Enlaces entrada:
Enlaces entradas Neurona [0]: [2, 4]
Enlaces entradas Neurona [1]: [1]
Enlaces entradas Neurona [2]: [2, 3]
Enlaces entradas Neurona [3]: [3, 7]
Enlaces entradas Neurona [4]: [0, 4, 6]
Enlaces entradas Neurona [5]: [0, 3]
Enlaces entradas Neurona [6]: [2, 7]
Enlaces entradas Neurona [7]: [5, 7]
Enlaces entradas Neurona [8]: [8]

* Enlaces salida:
Enlaces salidas Neurona [0]: [5, 4]
Enlaces salidas Neurona [1]: [1]
Enlaces salidas Neurona [2]: [0, 2, 6]
Enlaces salidas Neurona [3]: [5, 3, 2]
Enlaces salidas Neurona [4]: [0, 4]
Enlaces salidas Neurona [5]: [7]
Enlaces salidas Neurona [6]: [4]
Enlaces salidas Neurona [7]: [6, 3, 7]
Enlaces salidas Neurona [8]: [8]

* Pesos:
w[0]: [0.8555, 0.6536]
w[1]: [0.819]
w[2]: [0.9977, 0.1134]
w[3]: [0.2289, 0.5195]
w[4]: [0.315, 0.3569, 0.5067]
w[5]: [0.9875, 0.9863]
w[6]: [0.5892, 0.3078]
w[7]: [0.5503, 0.1076]
w[8]: [0.3883]

* Salidas:
y[0] = 0.9068
y[1] = 0.6745
y[2] = 0.8045
y[3] = 0.6342
y[4] = 0.8175
y[5] = 0.9089
y[6] = 0.6537
y[7] = 0.5426
y[8] = 0.3699

BUILD SUCCESSFUL (total time: 0 seconds)


Con la tecnología de Blogger.