Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Prepara tus exámenes
Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity
Prepara tus exámenes con los documentos que comparten otros estudiantes como tú en Docsity
Encuentra los documentos específicos para los exámenes de tu universidad
Estudia con lecciones y exámenes resueltos basados en los programas académicos de las mejores universidades
Responde a preguntas de exámenes reales y pon a prueba tu preparación
Consigue puntos base para descargar
Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium
Comunidad
Pide ayuda a la comunidad y resuelve tus dudas de estudio
Ebooks gratuitos
Descarga nuestras guías gratuitas sobre técnicas de estudio, métodos para controlar la ansiedad y consejos para la tesis preparadas por los tutores de Docsity
Proyecto de red neuronal Avanzadas
Tipo: Apuntes
1 / 17
Esta página no es visible en la vista previa
¡No te pierdas las partes importantes!
FACULTAD DE INGENIERÍA
Integrantes:
Leal Giorguli Andrés
Melgar Peral Ricardo
Trejo Linares Alfonso
Materia: Aprendizaje
Proyecto Final
México CDMX. 11/junio/
En los últimos años la inteligencia artificial viene brindando soluciones en muchos aspectos del quehacer humano, por ejemplo en economía, administración, medicina, física, arte, etc. Uno de los temas de la IA que ha alcanzado trascendental importancia es redes neuronales artificiales y en dicho tema, una de las aplicaciones más importantes es el reconocimiento de patrones. En este proyecto presentaremos un modelo de una red neuronal artificial para el reconocimiento de patrones utilizando el lenguaje de programación java.
Estructura de los modelos RNA
McCulloch y Pitts en 1943 construyeron un modelo abstracto y simple de una neurona artificial, que es una unidad de cálculo que modela el comportamiento de una neurona natural. Este modelo es elemento básico y esencial de procesamiento y construcción de una red neuronal artificial. Generalmente el comportamiento de las neuronas biológicas es de tipo no lineal, y esto lo hace interesante, porque no se resuelven con las técnicas convencionales, aunque existe algún comportamiento de tipo lineal.
Características de la neurona i
Una neurona tiene cinco partes fundamentales que se describen a continuación (Bonifacio Martin, Alfredo Sanz):
Conjunto de entradas
xj (t) (x1, x2,x3, ... xn)
Conjunto de Pesos, denominado pesos sinápticos de la neurona i, denotado por wij (wi1, wi2, ... win) , es la intensidad de interacción entre cada neurona presináptica j y la neurona postsinápíica i.
Función de propagación (también se denomina función de excitación). Representa el valor del potencial postsináptico:
Por otro lado, si el peso es positivo, la conexión se llama excitatoria, quiere decir, que tendera a excitar a la neurona postsináptica. Si es negativo se llama inhibitoria, tendera a inhibirla
Función de activación Proporciona el estado de la activación actual
ai(t) = fi(ai(t-1), hi(t))
Existen varias funciones de activación, para la investigación se utilizara la función escalón y la función sigmoidal.
En nuestro proyecto utilizamos 4 clases llamadas:
Neuron
RedNeuronal
RedNeuronal
Sigmoide
Todas en el lenguaje java.
Neuron
package redneuronal;
public class Neuron {
double activacionu;
double [] entradas;
double [] pesos;
double errorNodo;
static Sigmoide sigmoide;
public Neuron(int nentradas){
pesos=new double[nentradas];
entradas=new double[nentradas];
sigmoide= new Sigmoide();
errorNodo=0;
}
public void activacion(){
double suma=0;
for (int i = 0; i <entradas.length; i++){
suma+=entradas[i]*pesos[i];
}
activacionu=sigmoide.funcion(suma);
}
public double getActivacion(){
return activacionu;
}
public double getError(){
return (errorNodo);
}
public void setError(double Error){
errorNodo=Error;
}
}
RedNeuronal
package redneuronal;
public class RedNeuronal {
static int nodosk=4;
static int nodosj=7;
static RedNeuronal1 redNeuronal = new RedNeuronal1(nodosk,nodosj,9,43);
static double balance=-1;
0,1,1,1,1,0,balance},//
{0,0,1,0,1,0,
0,1,0,0,1,0,
0,1,0,0,1,0,
1,1,1,1,1,1,
0,0,0,0,1,0,
0,0,0,0,1,0,
0,0,0,0,1,0,balance},//
{1,1,1,1,1,1,
1,0,0,0,0,0,
1,1,1,1,1,0,
0,0,0,0,1,0,
0,0,0,0,0,1,
0,0,0,0,1,0,
1,1,1,1,1,0,balance},//
{0,0,1,1,1,0,
0,1,0,0,0,1,
1,0,0,0,0,0,
1,0,1,1,1,0,
1,1,0,0,0,1,
0,1,0,0,0,1,
0,0,1,1,1,0,balance},//
{1,1,1,1,1,1,
1,0,0,0,1,0,
0,0,0,1,1,0,
0,0,0,1,0,0,
0,0,1,1,0,0,
0,0,1,0,0,0,
0,0,1,0,0,0,balance},//
0,1,1,1,1,0,balance},//
{0,1,1,1,1,0,
1,0,0,0,0,1,
1,0,0,0,0,1,
0,1,1,1,1,1,
0,0,0,0,0,1,
1,0,0,0,0,1,
0,1,1,1,1,0,balance}//
};
static double aprender[][]={
//valores binarios de manera vertical 0000, 0001,0010,...,
//compara renglón de capaI con columna aprender
{0,0,0,0,0,0,0,0,1,1,1},
{0,0,0,0,1,1,1,1,0,0,0},
{0,0,1,1,0,0,1,1,0,0,1},
{0,1,0,1,0,1,0,1,0,1,0}
};
public int Verificar(double capaI[][]){
int epoca=0;
redNeuronal.entradasJ(capaI[epoca]);
for (int c = 0; c <7; c++) {
System.out.print(""+Math.round(capaI[epoca][c])+",");
}
System.out.print(" Aprender ");
for (int c = 0; c < nodosk; c++) {
System.out.print(""+Math.round(aprender[c][epoca])+",");
}
System.out.print(" Salida ");
redNeuronal.entradasJ(capaI[epoca]);
redNeuronal.activacionJ();
redNeuronal.entradasK();
redNeuronal.activacionK();
redNeuronal.errorCapaK(aprender, epoca);
for (int c = 0; c < nodosk; c++) {
System.out.print(" "+Math.round(redNeuronal.getActivacionk(c))+",");
}
double decimal=0;
int t=0;
for (int c = nodosk-1; c >=0; c--) {
decimal+=redNeuronal.getActivacionk(c)*Math.pow(2,t);
t++;
}
System.out.println(" decimal "+decimal);
noigual=false;
for (int c = 0; c < nodosk; c++) {
if (redNeuronal.getActivacionk(c)==aprender[c][epoca]) {
}else{
noigual=true;
}
if (noigual) {
i=-1;
redNeuronal.pesos_JK();
redNeuronal.errorCapaJ();
redNeuronal.pesos_IJ();
}
i++;
k++;
}
RedNeuronal
package redneuronal;
public class RedNeuronal1 {
int nodosCapaK;
int entCapak;
int nodosCapaJ;
int entCapaj;
double L=0.5;
double [] entradas;
Neuron [] neuronK,neuronJ;
static double balance=-1;
public void entradasJ(double capaI[]){
for (int j = 0; j < nodosCapaJ; j++) {
for (int i = 0; i < capaI.length; i++) {
neuronJ[j].entradas[i]=capaI[i];
}
}
}
public void activacionJ(){
for (int j = 0; j < nodosCapaJ; j++) {
neuronJ[j].activacion();
}
}
public void activacionK(){
for (int k = 0; k < nodosCapaK; k++) {
neuronK[k].activacion();
}
}
public void entradasK(){
int j;
for (int k = 0; k < nodosCapaK; k++) {
for (j = 0; j < nodosCapaJ; j++) {
neuronK[k].entradas[j]=neuronJ[j].getActivacion();
}
neuronK[k].entradas[j]=balance;
System.out.println(""+neuronK[k].entradas[j]);
public void errorCapaK(double aprender[][],int epoca){
double errorl=0;
for (int k = 0; k < nodosCapaK; k++) {
errorl=(aprender[k][epoca]- neuronK[k].getActivacion())neuronK[k].getActivacion()(1-neuronK[k].getActivacion());
neuronK[k].setError(errorl);
}
}
public void pesos_JK(){
for (int k = 0; k < nodosCapaK; k++) {
for (int i = 0; i < entCapak; i++) {
neuronK[k].pesos[i]+=(LneuronK[k].getError()neuronK[k].entradas[i]);
}
}
}
public void errorCapaJ(){
double suma, errj;
for (int j = 0; j < nodosCapaJ; j++) {
suma=0;
for (int k = 0; k < nodosCapaK; k++) {
suma+=(neuronK[k].getError()*neuronK[k].pesos[j]);
}
errj=(neuronJ[j].getActivacion()(1-neuronJ[j].getActivacion())suma);
neuronJ[j].setError(errj);
Sigmoide
package redneuronal;
**/****
*** @author Ricardo Melgar**
*/
public class Sigmoide {
double e;
double p;
public Sigmoide(){
e=Math.E; p=1;
}
public double funcion(double a){
return(1/(1+(Math.pow(e, -a/p))));
}
}
El programa funciona de manera gráfica con cajas de texto, en las cuales vamos a indicar los valores que se iteraran, para posteriormente realizar el aprendizaje.
El usuario generara los patrones a analizar en la matriz 6X7, el aprendizaje se realiza y ejecuta las iteraciones hasta que sea detenido.
Se ejecuta la red neuronal mostrando el resultado del análisis (el digito si lo reconoció o un signo de interrogación si no le fue posible reconocerlo).
Andrés
Fue un proyecto bastante interesante, los modelos matemáticos en que han sido desarrollados los tipos de redes son modelos sencillos, y aunque exigen ciertos conocimientos de cálculo diferencial, pueden ser implementados en cualquier lenguaje de programacion.
Ricardo
Las redes neuronales son una teoría relativamente nueva, que junto a otras técnicas de IA ha generado soluciones confiables a problemas que se presentan en ingeniería, las redes les dan una solución mas fácil y dinámica que la que proporcionan los métodos tradicionales.
Alfonso
Las redes neuronales artificiales presentan grandes ventajas para la resolución de problemas de ingeniería ya que al estar inspirados en modelos biológicos del funcionamiento del cerebro, facilita el estudio y lo hace hasta cierto punto más interesante y dinámico.
http://disi.unal.edu.co/~lctorress/RedNeu/LiRna008.pdf
http://bibing.us.es/proyectos/abreproy/12166/fichero/Volumen+1+- +Memoria+descriptiva+del+proyecto%252F3+-+Perceptron+multicapa.pdf
