Código de Java - neurona artificial 1 0 -1, trinaria

Imágen de perfil
Val: 491
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

neurona artificial 1 0 -1, trinariagráfica de visualizaciones


Java

Publicado el 24 de Septiembre del 2017 por Rafael Angel
986 visualizaciones desde el 24 de Septiembre del 2017. Una media de 14 por semana
Neurona artificial con tres salidas diferentes.
Le he hecho una actualización a la neurona artificial normal; la actualización incluye la habilidad de ser trinaria y no binaria. O sea tiene el poder de lanzar: 1, 0, -1.
Ademas no pierde la habilidad de aprender.
Recuerden nosotros como humanos no somos binarios, somos trinarios o más todavía, nosotros usamos, si, no, talvez. Ya es hora que la computación tenga ese talvez, eso que nos hace humanos.

1.0

Actualizado el 03 de Noviembre del 2017 (Publicado el 24 de Septiembre del 2017)gráfica de visualizaciones de la versión: 1.0
987 visualizaciones desde el 24 de Septiembre del 2017. Una media de 14 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
//Neurona artificial basica.
//Autor Rafael Angel Montero Fernández.
 
public class NRA
{
	private Mensajes msj=new Mensajes();
	private double vPeso1, vPeso2, vPeso3;//Lo correcto es usar un vector o una matriz, ya que los pesos son las sinapsis de la neurona y una neurona puede tener N cantidad de sinapsis. Pero para este ejemplo y como aun no domino las matrices en Java, mejor algo basico.
	private double vTasa_de_aprendizaje;//Es el nivel de aprendizage de la neurona artificial.
	private double vUmbral_de_activacion;//El umbral o maximo o minimo nivel de activacion de la neurona al recivir algun estimulo.
	private int vRespuesta_a_devolver;
 
 
   public NRA(double nuevo_peso1,double  nuevo_peso2,double  nuevo_peso3, int devolver)
   {//En caso de usarse un vector para los pesos entonces, el parametro del cosntructor debe ser un vector llamado Vector mPesos.
 
		vRespuesta_a_devolver=devolver;//Puede ser cargado con 1, 2, 3
      //Valores predefinidos para arrancar pero si conoces más de la tecnologia Neuroredes Artificiales puedes poner otros valores.
      this.vPeso1=nuevo_peso1;
      this.vPeso2=nuevo_peso2;
      this.vPeso3=nuevo_peso3;
 
      this.vUmbral_de_activacion=1.5;//Valor original cero
 
	if(vRespuesta_a_devolver==2)
	{
		this.vUmbral_de_activacion=-0.1;
	}//if
 
      this.vTasa_de_aprendizaje=0.1;
   }//Fin del constructor.
 
 
 
   public int salida (double nueva_entrada1,double  nueva_entrada2,double  nueva_entrada3)//Por nomenclatura se ha usado la f para indicar que se trata de una funcion capaz de retornar datos.
   {
      double vSumatoria=  (nueva_entrada1 * this.vPeso1) + (nueva_entrada2 * this.vPeso2) +  (nueva_entrada3 * this.vPeso3);
 
//Finalmente he logrado hacer que la neurona artificial sea capaz de devolver 3 valores diferentes y que sea capaz de aprender.
	if(vRespuesta_a_devolver==1)//Para devolver cero
	{
		return (vSumatoria > this.vUmbral_de_activacion ? 1:0);
	 }
	 else if(vRespuesta_a_devolver==3)//Para devolver menos uno
	 {
		return (vSumatoria > this.vUmbral_de_activacion ? -1:1);
	 }
	 else if(vRespuesta_a_devolver==2)//Para devolver 1
	 {
		return (vSumatoria > this.vUmbral_de_activacion ? 1:0);
	 }
 
	 return (vSumatoria > this.vUmbral_de_activacion ? 1:0);
   }//Fin de fSalida
 
 
   //Funcion principal de esta neurona. Aunque cuando se quiere hacer una red, se conecta una primera fila con las entradas para el usuario y las filas secundarias tienen su entrada conectada con la salida de la primera fila, la neurona de salida tiene su salida libre para mostrar los datos en pantalla.
 
 
   private double entrenando (double nueva_entrada1,double  nueva_entrada2,double  nueva_entrada3)//
   //Se usa en fEntrenamiento_supervisado
   {
      double vSumatoria=  (nueva_entrada1 * this.vPeso1) + (nueva_entrada2 * this.vPeso2) +  (nueva_entrada3 * this.vPeso3);
      return (vSumatoria > this.vUmbral_de_activacion ? 1:0);
   }//Fin de entrenando
 
 
   public int fEntrenamiento_supervisado(double nueva_entrada1,double  nueva_entrada2,double  nueva_entrada3, int nueva_salida_deseada_por_el_usuario)
   {//Las neuronas solo se programan una vez y cada vez que se quiera que realice una tarea diferente entonces se le entrena. La red si debe ser configurada de acuerdo a la tarea pero eso se puede definir para que sea realizable durante la ejecucion del programa.
      double vResultado = salida ( nueva_entrada1,  nueva_entrada2, nueva_entrada3);
 
      int vRespuesta=0;//Salida de la funcion.
 
      if (vResultado != nueva_salida_deseada_por_el_usuario)
      {
 
         if (vResultado > nueva_salida_deseada_por_el_usuario)
         {
            //Actualizacion de los pesos (Sinapsis)
            this.vPeso1 = this.vPeso1 - (this.vTasa_de_aprendizaje * nueva_entrada1);
            this.vPeso2= this.vPeso2 - (this.vTasa_de_aprendizaje * nueva_entrada2);
            this.vPeso3= this.vPeso3 - (this.vTasa_de_aprendizaje * nueva_entrada3);
            //--------------------------------------------------------
 
            //Actualizacion del umbral de activacion
            this.vUmbral_de_activacion +=  this.vTasa_de_aprendizaje;
 
         }//Fin del if >
         else
         {
            //Actualizacion de los pesos (Sinapsis)
            this.vPeso1 = this.vPeso1 + (this.vTasa_de_aprendizaje * nueva_entrada1);
            this.vPeso2= this.vPeso2 + (this.vTasa_de_aprendizaje * nueva_entrada2);
            this.vPeso3= this.vPeso3 + (this.vTasa_de_aprendizaje * nueva_entrada3);
            //--------------------------------------------------------  
            //Actualizacion del umbral de activacion
            this.vUmbral_de_activacion -=  this.vTasa_de_aprendizaje;
 
         }//Fin del else anidado >
 
		//No es igual
		if ( (vRespuesta_a_devolver==3) || (vRespuesta_a_devolver==1) )
		{
			vRespuesta=1;//Neurona activada y respuesta positiva.
 
		}
		else
		{ vRespuesta=0;}
 
       }//Fin del if !=
       else
       {//Si es igual a la repuesta deseada.
	   //Mostrar un mensaje que muestre el valor de los pesos.
 
		    if (vRespuesta_a_devolver==2)
		    {
				vRespuesta=1;//Neurona desactivada y respuesta negativa.
				//System.out.println(getUmbral_de_activacion());
			}
			else if (vRespuesta_a_devolver==3)
			{
				vRespuesta=-1;
			}
			else if (vRespuesta_a_devolver==1)
			{
				vRespuesta=0;
			}
 
         }//Fin del else !=
 
      return vRespuesta;
   }//Fin de fEntrenamiento_supervisado
 
   public double getUmbral_de_activacion()
   {
      return this.vUmbral_de_activacion;
   }//Fin de getUmbral_de_activacion
 
   public double getTasa_de_aprendizaje()
   {
      return this.vTasa_de_aprendizaje;
   }//Fin de getTasa_de_aprendizaje
 
   public String getPesos()
   {
      /*
       * Se ha usado un String para retornar los tres valores de los pesos ceparados con
       * saltos de linea.
       * Pero en lugar del String para quienes dominen los vectores, va un vector.
       * Quedaría así:
       * public Vector getPesos(){...}
       */
      return "" +  this.vPeso1 + "\n" + this.vPeso2 + "\n" + this.vPeso3;
   }//Fin de getPesos
 
   //Conclusiones: Esta neurona artificial es parte de una red más grande con diferentes diseños de neuronas.
}//Fin del class



Comentarios sobre la versión: 1.0 (0)


No hay comentarios
 

Comentar la versión: 1.0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s4211
Revisar política de publicidad