redes neuronales artificiales aplicadas a las vigas rectangulares de hormigón armado

Universidad Mayor de San Andrés Facultad de Ciencias Puras y Naturales Postgrado en Informática Redes Neuronales

“Desarrollo de una Aplicación Web 2.0 para la Simulación de Redes Neuronales Artificiales - Modelo Multilayer Perceptron Algoritmo Backpropagation aplicadas a la Predicción del Tipo de Falla en Vigas Rectangulares de Hormigón Armado”

Presentado a:

Dr. Carlos Morató A.

Presentado por:

Roger Saravia A., R. A. y M. C.

LP – Abril de 2008

Resumen En este trabajo de investigación se diseña y programa un software Web 2.0 para simular redes neuronales artificiales multi-capa con un algoritmo de retro-alimentación. Dicho software es aplicado a la predicción de uno de los aspectos del diseño de vigas de hormigón armado.

Primero, se hace el planteamiento del problema y se establecen los objetivos específicos. Luego, una revisión sustancial del marco teórico para esta investigación. Se desarrollan conceptos sobre redes neuronales artificiales, sus modelos, funciones de activación y algoritmos. Inmediatamente, se presenta la teoría sobre programación de aplicaciones Web 2.0. Y por supuesto, un apartado sobre el hormigón armado de la ingeniería civil.

El desarrollo práctico se divide en cuatro etapas: 1) diseño, programación y pruebas del software, 2) preparación de los patrones de entrada del problema de aplicación, 3) aprendizaje y validación del problema de aplicación mediante la ejecución del software.

Palabras Clave INTELIGENCIA ARTIFICIAL, NEURONA BIOLÓGICA, REDES NEURONALES ARTIFICIALES, PESO NUMÉRICO, TOPOLOGÍA, FUNCIÓN DE ACTIVACIÓN, BIAS, UMBRAL, PERCEPTRON, ADALINE, UMBRAL DURO, SIGMOIDE, TANGENTE HIPERBÓLICA, PERCEPTRON MULTI-CAPA, PASO HACIA DELANTE, GRADIENTE DESCENDENTE, ALGORITMO BACKPROPAGATION, GENERALIZACIÓN, REDES ESTÁTICAS, REDES DINÁMICAS, RBF, SOFM, HOPFIELD, MODELADO Y/O PREDICCIÓN, FILTRO NO LINEAL, PROCESO DE APRENDIZAJE, APRENDIZAJE SUPERVISADO, PROCESO DE EVALUACIÓN, NEURONAS OCULTAS, CAPAS OCULTAS, ERROR MEDIO, ÉPOCAS, AJUSTE DE PESOS, PATRONES ENTRADA/SALIDA, NORMALIZACIÓN, WEB 2.0, HTML, CSS, JAVASCRIPT, PHP, HORMIGÓN ARMADO, VIGA SIMPLEMENTE REFORZADA.

Contenido 1

INTRODUCCIÓN.......................................................................................................................................................... 2 1.1 1.2

ESCENARIO .............................................................................................................................................................. 2 PROBLEMA IDENTIFICADO Y ABORDAJE DEL PROBLEMA ........................................................................................ 2

2

OBJETIVOS ESPECÍFICOS ....................................................................................................................................... 2

3

MARCO TEÓRICO ...................................................................................................................................................... 3 3.1 REDES NEURONALES NATURALES ........................................................................................................................... 3 3.2 NEURONA BIOLÓGICA ............................................................................................................................................. 3 3.3 REDES NEURONALES ARTIFICIALES ........................................................................................................................ 3 3.4 MODELO DE UNA NEURONA .................................................................................................................................... 4 3.4.1 Modelo simplificado (McCulloch & Pitts, 1943) ............................................................................................... 4 3.5 FUNCIONES DE ACTIVACIÓN.................................................................................................................................... 5 3.6 PERCEPTRON MULTICAPA (MLP)............................................................................................................................ 6 3.6.1 Algoritmo Backpropagation - Perceptron Multicapa ........................................................................................ 7 3.7 GENERALIZACIÓN.................................................................................................................................................... 7 3.8 REDES ESTÁTICAS Y REDES DINÁMICAS ................................................................................................................. 7 3.9 APRENDIZAJE .......................................................................................................................................................... 8 3.10 APLICACIONES ........................................................................................................................................................ 8 3.11 ÁREAS RELACIONADAS ........................................................................................................................................... 9 3.12 PROGRAMACIÓN WEB 2.0 ....................................................................................................................................... 9 3.12.1 Web 2.0 ......................................................................................................................................................... 9 3.12.2 HTML ............................................................................................................................................................ 9 3.12.3 CSS ................................................................................................................................................................ 9 3.12.4 JavaScript ................................................................................................................................................... 10 3.12.5 PHP ............................................................................................................................................................. 10 3.13 HORMIGÓN ARMADO - RAMA ESTRUCTURAL DE LA INGENIERÍA CIVIL ............................................................... 10 3.13.1 Vigas Simplemente Reforzadas ................................................................................................................... 11 3.13.2 Diseño de Vigas Simplemente Reforzadas .................................................................................................. 12

4

DESARROLLO PRÁCTICO...................................................................................................................................... 12 4.1 4.2 4.3

5

ETAPA 1: PROGRAMACIÓN DEL SOFTWARE PARA RNA ......................................................................................... 13 ETAPA 2: PREPARACIÓN DE LOS PATRONES DE ENTRADA/SALIDA ........................................................................ 19 ETAPA 3: EJECUCIÓN DEL SOFTWARE: APRENDIZAJE Y VALIDACIÓN.................................................................... 21

CONCLUSIONES ........................................................................................................................................................ 23

REFERENCIAS..................................................................................................................................................................... 24 APÉNDICES .......................................................................................................................................................................... 25 APÉNDICE A. LISTADOS DEL CÓDIGO FUENTE .................................................................................................................... 25 A.1 Listado de la Página Web Inicial: Fichero “index.php” ................................................................................. 25 A.2 Listado de la Página Web de Cálculo: Fichero “page02.php” ....................................................................... 27 A.3 Listado del Código Fuente Embebido: Fichero “subs01.js” ........................................................................... 30 A.4 Listado de la Hoja de Estilos: Fichero “esti01.css” ....................................................................................... 34 APÉNDICE B. CONJUNTO DE ENTRENAMIENTO ............................................................................................................. 35 B.1 Versión Simplificada del Conjunto de Ejemplos del Problema de Aplicación ................................................ 35

1

Introducción

1.1

Escenario Este trabajo de investigación se extiende en el área de la inteligencia artificial de las ciencias de la computación; específicamente en la programación y aplicación de las redes neuronales artificiales con campo de servicio en el hormigón armado de la ingeniería civil.

1.2

Problema Identificado y Abordaje del Problema Un problema en el cálculo de vigas de hormigón armado es la difícil determinación del tipo de falla de las mismas dada su configuración no homogénea. Una viga reforzada puede fallar inmediatamente, por fluencia del acero o por aplastamiento del concreto. Para un diseño seguro, es necesario conocer el tipo de falla asociado al elemento.

Se abordará el problema mediante la programación de un software Web 2.0 para el entrenamiento y validación de redes neuronales artificiales modelo MLP Backpropagation. Este software podrá ser usado para clasificar el tipo de falla de una viga de hormigón de configuración específica.

2

Objetivos Específicos 

Programar un software Web 2.0 para el entrenamiento y evaluación de redes neuronales artificiales MLP Backpropagation.



Determinar los patrones de entrada /salida para el problema de aplicación.



Establecer la topología de la red neuronal a ser usada para el problema.



Ejecutando el software, entrenar la red neuronal artificial (RNA) a partir del conjunto de entrenamiento.



Validar el aprendizaje de la RNA a partir del conjunto de prueba.



Aplicar la RNA entrenada a la solución de casos de estudios.

2

3

Marco Teórico

3.1

Redes Neuronales Naturales El cerebro humano contiene alrededor de 15 billones de células llamadas neuronas. Una neurona se conecta con cientos de otras neuronas formando una red neuronal. El cerebro puede ser visto como un equipo integrado por aproximadamente 10 billones de elementos de procesamiento (neuronas) cuya velocidad de cálculo es lenta pero que trabajan en paralelo y con este paralelismo logran alcanzar una alta potencia de procesamiento.

3.2

Neurona Biológica

Ilustración 1. Neurona biológica.

3.3

Sinapsis:

la conexión entre neuronas.

Dendritas:

reciben las señales eléctricas.

Axón:

envía señales de salida.

Núcleo:

se ejecutan las funciones principales.

Redes Neuronales Artificiales Una red neuronal es un modelo computacional que pretende simular el funcionamiento del cerebro a partir del desarrollo de una arquitectura que toma rasgos del funcionamiento de este órgano sin llegar a desarrollar una réplica del mismo.

3

A partir de esta visión del cerebro el modelo computacional desarrollado consiste de un conjunto de elementos computacionales simples (llamados también unidades o celdas), las cuales constituyen neuronas artificiales unidas por arcos dirigidos que les permiten comunicarse. Cada arco tiene asociado un peso numérico Wij que indica la significación de la información que llega por este arco, o sea, la influencia que tiene la activación alcanzada por la unidad Ui sobre la unidad Uj. Cada celda Ui calcula una activación a partir de las activaciones de las celdas conectadas directamente a ellas, de los pesos de los arcos a través del que llega cada activación y usando un algoritmo que generalmente es el mismo para todas las unidades.

Grupos de neuronas artificiales pueden ser interconectadas en una variedad de maneras para formar redes neuronales artificiales. A la organización de las neuronas en la red se le conoce como topología de la red.

3.4

Modelo de una Neurona N  dy i    yi  w jiu j  v j  dt j 1   u  ( yi ) i 



yi  estado interno de la neurona ui  activación (salida) de la neurona w ji  sinapsis (excitación o inhibición) entre la neurona j y la neurona i  ()  función de activación (no lineal)

Las excitaciones (inhibiciones) de otras neuronas que llegan a través de las sinapsis son integradas y si superan un umbral, la neurona “dispara” una señal de excitación.

3.4.1 Modelo simplificado (McCulloch & Pitts, 1943)

McCulloch

Pitts

El modelo simplificado también es conocido como PERCEPTRON (Rosenblatt, 1957) o ADALINE (Widrow,1960)

4

Ilustración 2. Modelo simplificado de una neurona.

 p    yk   uk  θk     wkj x j  θk   j 1   



3.5

 ()

Función de activación.

k

Es el umbral o término de bias.

Funciones de Activación

 (u )  sig (u ) Umbral duro

 (u ) 

1 1  exp(  au )

Sigmoide

5

 (u )  tanhau  Tangente hiperbólica

Empleando estas funciones de activación, una neurona (PERCEPTRÓN) permite la separación del espacio de entrada en dos clases mediante un hiperplano.

3.6

Perceptron Multicapa (MLP)

Ilustración 3. Modelo MLP

Es una red neuronal muy usada y conocida.

Dado un conjunto conocido de patrones entrada/salida, la red es capaz de “aprender” mediante un algoritmo de entrenamiento.

El “conocimiento” se almacena y distribuye en los pesos de la red.

Es una estructura de computación robusta ante fallos.

Ideal para problemas de gran cantidad de datos entrada/salida pero difíciles de formular y solucionar mediante estrategias convencionales.

6

Paso hacia delante: cálculo del error cuadrático medio (diferencia cuadrática entre la salida deseada y la obtenida por la red).

Paso hacia atrás: actualización de los pesos para disminuir el error en la próxima ejecución (algoritmo Backpropagation)

3.6.1 Algoritmo Backpropagation - Perceptron Multicapa Su característica: la modificación de los pesos utilizando la gradiente descendente.

1) Inicializar los pesos y los umbrales de cada neurona. Hay varias posibilidades de inicialización siendo lo más común con valores aleatorios pequeños.

2) Para cada patrón del conjunto de los datos de entrenamiento: a. Obtener la respuesta de la red ante ese patrón propagando la entrada hacia adelante. Las salidas de una capa sirven como entrada a las neuronas de la capa siguiente. b. Calcular los errores asociados. c. Calcular el incremento total de los pesos y los umbrales. d. Actualizar pesos y umbrales. e. Calcular el error actual y volver al paso “a” si no es satisfactorio.

3.7

Generalización Una red neuronal no se limita a memorizar sobre los datos de entrenamiento. Una red neuronal es capaz de generalizar.

La generalización consiste en que la salida proporcionada por la red es correcta o razonable en puntos diferentes a los dados durante el entrenamiento.

La generalización se relaciona con la suavidad de la función a modelar.

3.8

Redes Estáticas y Redes Dinámicas El MLP es una red estática porque las ecuaciones de las neuronas no cambian con el tiempo una vez realizado el entrenamiento.

7

Redes estáticas: Perceptron Multicapa (MLP) Red de Funciones de Base Radial (RBF) Mapas de Kohonen o Autoorganizados (SOFM)

Redes dinámicas: Redes Recurrentes Red de Hopfield

3.9

Aprendizaje El MLP es una red entrenada con un algoritmo de aprendizaje supervisado; es decir, es necesario un conjunto de patrones de entrada y salida.

Aprendizaje supervisado: MLP Redes Recurrentes Red de Hopfield

Aprendizaje no-supervisado: Mapas de Kohonen (SOFM)

Híbridos: Red de Funciones de Base Radial (RBF)

3.10 Aplicaciones Comunicaciones:

conmutación, enrutamiento, etcétera.

Tratamiento de voz:

reconocimiento, codificación, etcétera.

Tratamiento de imagen:

reconocimiento de formas y patrones como huellas dactilares, etcétera.

Modelado y/o predicción:

predicción de series en función del tiempo (consumo eléctrico, etc.)

Control:

robots, vehículos, etcétera.

8

3.11 Áreas relacionadas Una red neuronal puede ser concebida como: Un filtro no lineal.

Un sistema dinámico no lineal.

Un aproximador funcional.

Un modelo neurofisiológico (véase al principio del marco teórico).

3.12 Programación Web 2.0 3.12.1

Web 2.0

La Web 2.0 es lo que está sucediendo en la actualidad; es decir, un paso revolucionario que incluye no solo sitios de presentación sino sitios de interacción y fuentes de contenido.

Una de las ideas claves detrás de la Web 2.0 es la usabilidad. Las aplicaciones Web 2.0 se parecen más a aplicaciones de escritorio que a páginas Web. Más allá de lo vistosas, proveen una riqueza en su interacción previamente encontrada solamente en aplicaciones de escritorio.

3.12.2

HTML

El HTML (Hyper Text Markup Language) es un sistema para estructurar documentos. Estos documentos pueden ser mostrados por los exploradores de páginas Web en Internet como Netscape o Explorer.

Existen diferentes revisiones o niveles de estandarización como ser el 1.0, el 2.0, el 3.0 y 4.0.

Básicamente, el HTML consta de una serie de órdenes o directivas que indican al explorador la forma de representar los elementos (texto, gráficos, etc.) que contenga el documento.

3.12.3

CSS

(Cascade Style Sheet) Una hoja de estilo es un conjunto de instrucciones que definen la apariencia de diversos elementos de un documento HTML. Una hoja de estilo permite indicar por ejemplo el tamaño de la fuente o el color y formato de cierto párrafo. Las hojas de estilo son la innovación más importante para la combinación con el HTML (también se usan en otros lenguajes como XML y SGML) ya que brindan muchas capacidades.

9

3.12.4

JavaScript

El JavaScript es un lenguaje independiente de la plataforma orientado a objetos y del tipo scripting para aplicaciones lado del cliente y también lado del servidor.

El JavaScript permite crear aplicaciones que se ejecutan a través del Internet. Usando JavaScript se puede crear el HTML dinámico que procesa la entrada del usuario y que mantiene la persistencia de los datos mediante objetos, archivos y bases de datos relacionales.

3.12.5

PHP

PHP es un lenguaje de script del lado del servidor. Los scripts PHP están incrustados en los documentos HTML y el servidor los interpreta y ejecuta antes de servir las páginas al cliente. El cliente no ve el código PHP sino los resultados que se producen.

Es un módulo que se añade al servidor Web y que fue concebido inicialmente para Apache. Es potente, fácil de aprender, de libre distribución, permite el acceso a bases de datos, es orientado a objetos y perfecto para una integración con Apache y MySQL.

Ilustración 4. Modelo cliente-servidor para la Web.

3.13 Hormigón Armado - Rama Estructural de la Ingeniería Civil El hormigón es un material semejante a la piedra obtenido mediante una mezcla de cemento, arena, grava y agua; mezcla que se endurece en encofrados con la forma y dimensiones del elemento deseado.

La mayor parte consta de agregado fino y grueso. El refuerzo conformado usualmente por barras circulares de acero con deformaciones superficiales apropiadas para proporcionar anclaje, se coloca en los moldes antes de vaciar la mezcla.

10

3.13.1

Vigas Simplemente Reforzadas

Ilustración 5. Vistas de la configuración de la sección de dos vigas de hormigón armado

Las vigas de hormigón armado no son homogéneas debido a que están hechas de dos materiales completamente diferentes: hormigón y acero. Los métodos usados en el diseño son distintos a los de vigas elaboradas completamente de acero, madera o cualquier otro material estructural.

Las vigas de solo hormigón son ineficientes como elementos sometidos a flexión debido a que la resistencia a flexión es muy limitada. En consecuencia, estas fallan por tensión a cargas bajas. Por esta razón, se colocan barras de acero de refuerzo en el lado sometido a tensión y tan cerca como sea posible de la cara inferior. En una viga de hormigón así reforzada, la tensión causada por los momentos flectores es resistida principalmente por el acero de refuerzo mientras que el solo hormigón es capaz de resistir la compresión correspondiente. Esta acción conjunta de los dos materiales se garantiza si se impide su deslizamiento relativo mediante la utilización de barras corrugadas de acero.

Cuando en algún momento se alcance la capacidad de carga de la viga, la falla se puede presentar principalmente de dos maneras. Cuando se emplea una cantidad de refuerzo de acero relativamente moderada, el acero alcanza su punto de fluencia para determinada carga y el acero fluye alargándose considerablemente. La falla por fluencia es gradual y está precedida por signos visibles de peligro como presentación de las grietas y notoria deformación.

De otra parte, cuando se emplean grandes cantidades de refuerzo, la resistencia del hormigón puede agotarse antes de que el acero empiece a fluir. El hormigón falla por aplastamiento cuando sus deformaciones unitarias son tan grandes que destruyen su integridad. La falla por aplastamiento es repentina, explosiva y sin ningún aviso. Por esta razón, es aconsejable calcular las dimensiones de las vigas de tal manera que en caso de sobrecarga, la falla sea por fluencia del acero en vez del aplastamiento del concreto.

Otra modalidad de falla puede ocurrir en vigas ligeramente reforzadas. Si la cantidad de acero es menor que un determinado valor mínimo (conocido como cuantía mínima de acero), la viga va a fallar inmediatamente y sin ningún aviso una vez que se forme la primera grieta de flexión.

11

Ilustración 6. Vista lateral de una viga de hormigón armado cargada (As = Acero)

Ilustración 7. Vista lateral de una viga de hormigón armado cargada y en estado inicial de falla.

3.13.2

Diseño de Vigas Simplemente Reforzadas

Los problemas de flexión se clasifican en problemas de revisión y en problemas de diseño. En los problemas de revisión, se conocen las dimensiones de la sección, el refuerzo y las resistencias de los materiales y se calcula la capacidad a momento además de la determinación del tipo de falla. En los problemas de diseño, se conocen la capacidad requerida a momento y las resistencias de los materiales, y deben calcularse las dimensiones de la sección y el refuerzo.

4

Desarrollo Práctico Una vez realizada la revisión del marco teórico sobre los fundamentos de las redes neuronales artificiales, además de los acápites necesarios del campo de aplicación, se tiene el desarrollo de la parte práctica de la investigación constituida por las siguientes etapas:

Etapa 1:

Programación y pruebas de un software Web 2.0 para RNA.

Etapa 2:

Preparación de los patrones entrada/salida.

Etapa 3:

Ejecución del software: procesos de aprendizaje y evaluación.

12

4.1

Etapa 1: Programación del Software para RNA Haciendo uso de tecnologías emergentes, se ha codificado una aplicación interactiva Web 2.0 para la simulación de redes neuronales artificiales tipo MLP Backpropagation.

Este software Web se desglosa en dos partes: en la primera, se ingresan todos los parámetros iniciales del modelo, y la segunda está orientada al proceso de aprendizaje supervisado y validación.

El software ha sido codificado combinando las tecnologías necesarias para una aplicación Web 2.0; es decir: lenguaje de marcado XHTML 1.0, hojas de estilo CSS, lenguaje embebido lado del servidor PHP y lenguaje embebido lado del cliente JavaScript. La interacción de estás tecnologías se basa en el siguiente modelo:

Explorador JScript

POST HTML + CSS

Evento

Interfaz Usuario

HTTP (AJAX)

Servidor Web PHP (Apache)

TXT

Patrones Entrada/Salida

Lado del Servidor

Ilustración 8. Interacción de tecnologías de la aplicación Web 2.0.

En la práctica, una primera página Web exige se introduzcan los parámetros de entrada para el proceso de inicialización de la red neuronal:

Neuronas de entrada:

valor asociado con la cantidad de rasgos o patrones de entrada.

Neuronas ocultas:

debe graduarse según la naturaleza del problema (muchas veces de forma empírica).

Capas ocultas:

según la teoría, para un modelo MLP, 2 capas ocultas son suficientes para la mayoría de los problemas.

Neuronas de salida:

valor asociado al número de clases o patrones de salida.

Error permitido:

parámetro de parada para el aprendizaje de la red; valor a ser comparado con el error medio.

Tasa de aprendizaje:

valor asociado al paso (step) para las iteraciones del aprendizaje.

13

De entrenamiento:

cantidad de ejemplos para el aprendizaje.

De prueba:

cantidad de problemas para la validación del aprendizaje.

Épocas:

una época es un ciclo de aprendizaje que cubre todos los ejemplos.

Ilustración 9. Captura de pantalla de la página inicial de la aplicación Web 2.0.

La segunda página Web presenta el aprendizaje supervisado y validación. En ella, deben ingresarse todos los ejemplos con sus patrones de entrada/salida además del conjunto de validación a ser utilizado.

En la ilustración 10 se puede apreciar que ésta página presenta también el error obtenido en la última época de aprendizaje así como la cantidad y porcentaje de aciertos en la validación del aprendizaje.

14

Ilustración 10. Captura de pantalla de la página del proceso de aprendizaje de la aplicación Web 2.0.

El algoritmo Backpropagation se programó enteramente en JavaScript de acuerdo al siguiente conjunto de ecuaciones:

Ecuaciones

Detalles

h  1 : L

Neto hj   Yi h 1W ji

(1)

Y jh  f ( Neto hj )

(2)

i 1

h:

índice de capa oculta.

j:

índice de neurona oculta.

L:

número de neuronas ocultas.

Neto:

sumatoria “pesada”.

Y:

función de activación.

Wji:

peso de la neurona j que llega de la neurona i.

15

h  q : L

Neto   Y Wkj o k

j 1

h j

(3)

Y  f ( Neto )

(4)

 ko  (d k  Yko )(Yko )

(5)

o k

o k

h  q : 



m

 jh     koWkj (Y jh )  k 1



(6)

h  q :  L   jh     kh 1Wkj (Y jh )  k 1 

(7)

h  1 : W ji ( t 1) W

 jh xi *

ji ( t )

(8)

h  1 :

q:

número de capas ocultas.

k:

índice de neurona de salida.

o:

capa de neuronas de salida.

:

ajuste requerido a partir del error obtenido.

d:

salida deseada.

h:

índice de capa oculta.

q:

número de capas ocultas.

m:

número de neuronas de salida.

h:

índice de capa oculta.

q:

número de capas ocultas.

L:

número de neuronas ocultas.

t:

iteración actual.

:

tasa de aprendizaje o paso (step).

x:

parámetro de entrada.

i:

índice de neurona de entrada.

j:

índice de neurona oculta.

W ji ( t 1)  W ji ( t )   jhYi h 1

(9)

:

ajuste requerido a partir del error.

Wkj ( t 1)  Wkj (t )   koY jh

(10)

t+1:

iteración siguiente.

err:

error medio obtenido.

d:

salida deseada.

m:

número de neuronas de salida

errT:

error total en una época.

P:

número de ejemplos de aprendizaje.



m

err  ½  d k  Y k 1

errT 



o 2 k

(11)

P

1 P

 errz z

(12)

Las ecuaciones (1) a la (4) se usan para la propagación hacia delante partiendo de las neuronas de entrada con la información de entrada.

Las ecuaciones (5) a la (7) se usan para el cálculo del ajuste sobre la base del error obtenido pero partiendo de las neuronas de salida y en dirección hacia las neuronas de entrada.

Las ecuaciones (8) a la (10) se usan para el ajuste de los pesos partiendo de las neuronas de entrada y hacia delante. Nota: Estas ecuaciones están basadas en el descenso de la gradiente (concepto matemático de cálculo basado en derivadas parciales).

16

La ecuación (11) se usa para calcular el error obtenido en cada neurona de salida y la (12) para hallar el error total por época de aprendizaje.

Es importante señalar que la función de activación utilizada y programada fue la función sigmoide presentada en el marco teórico.

El listado completo del código fuente en JavaScript a partir de las anteriores ecuaciones se muestra en un apéndice al final de este documento; no obstante, a continuación se presenta un fragmento (subrutina) de código correspondiente a la propagación hacia delante:

function p01() { // propagación h=1; for (j=1; j<=l; j++) { su=0; for (i=1; i<=n; i++) su+=x[i]*neh[h][j].w[i]; neh[h][j].nt=su; neh[h][j].y=fnt(neh[h][j].nt); } for (h=2; h<=q; h++) { for (j=1; j<=l; j++) { su=0; for (i=1; i<=l; i++) su+=neh[h-1][i].y*neh[h][j].w[i]; neh[h][j].nt=su; neh[h][j].y=fnt(neh[h][j].nt); } } h=q; for (k=1; k<=m; k++) { su=0; for (j=1; j<=l; j++) su+=neh[h][j].y*neo[k].w[j]; neo[k].nt=su; neo[k].y=fnt(neo[k].nt); } } Pruebas

Se ha probado la aplicación Web 2.0 con una red neuronal de cierta configuración como para resolver una operación lógica. Los valores iniciales se muestran en la ilustración 9.

17

Se han introducido los patrones de entrada/salida correspondientes a la operación lógica del XOR y se ha ejecutado el proceso de aprendizaje. La ilustración 10 muestra todo esto.

Finalmente, se ha ejecutado la validación del aprendizaje y se ha obtenido un 100% de aciertos con relación al error permitido. La pantalla se muestra a continuación:

Ilustración 11. Captura de pantalla para la validación del aprendizaje de la prueba del XOR.

Atención La versión al público de este software está disponible en: http://www.rgusarav_respaldo.t35.com/rna

18

4.2

Etapa 2: Preparación de los Patrones de Entrada/Salida La preparación de los patrones entrada/salida se llevó acabo según el problema de aplicación. La tabla de a continuación muestra la configuración simplificada de la sección de una viga rectangular simplemente reforzada de hormigón armado.

Tipo

Notación

Descripción

Rango

Entrada

b

Ancho

20-40cm

Entrada

d

Altura efectiva

30-50cm

Entrada

C

Cantidad de barras de As

1-5

Entrada

n

No. de la barra de As.

3-10

Salida

-

Tipo de falla

“Inmediata”, “Fluencia”, “Aplastamiento”

Sección de una viga rectangular de hormigón armado (As = acero de refuerzo)

Para trabajar con valores en la escala de 0 al 1 se realizó el pre-procesamiento de datos iniciales o normalización de todos los valores involucrados en cada patrón. Puesto que la función de activación usada en la red neuronal es una función tipo aplastada, se consideró conveniente normalizar los patrones para adecuarlos a le estructura de la red. Las tablas guía de normalización son las siguientes:

Base (b) 40 35 30 25 20

1 0.75 0.5 0.25 0

Cantidad de Barras (C) 5 1 4 0.75 3 0.5 2 0.25 1 0

Altura Efectiva (d) 50 1 45 0.75 40 0.5 35 0.25 30 0

No. de la Barra (n) 8 7 6 5 4 3

1 0.8 0.6 0.4 0.2 0

19

Tipo de Falla de la Viga INMEDIATA 1 FLUENCIA 0 APLASTAMIENTO 0

0 1 0

0 0 1

Nótese en la última tabla que, a cada probable tipo de falla de la viga, se le ha asignado exclusivamente un patrón de salida; esto, para lograr una discriminación más clara en los resultados del proceso de aprendizaje y validación...

Los ejemplos para el proceso de aprendizaje y para el proceso de validación se han generado sobre la base de consultas bibliográficas especializadas acerca de vigas rectangulares de hormigón armado. De acuerdo al rango establecido mostrado anteriormente en la tabla de configuración de patrones, se han reunido 750 ejemplos para el aprendizaje y 188 para la validación; siendo este último, el 25% del total de ejemplos para el aprendizaje. A continuación se muestran algunos de los ejemplos ya normalizados para el entrenamiento de la red:

Algunos ejemplos para el aprendizaje:

(continuación de la columna izquierda)

0,0,0,0,,1,0,0 0,0,0,.2,,1,0,0 0,0,0,.4,,1,0,0 0,0,0,.6,,0,1,0 0,0,0,.8,,0,1,0 0,0,0,1,,0,1,0 0,0,.25,0,,1,0,0 0,0,.25,.2,,0,1,0 0,0,.25,.4,,0,1,0 0,0,.25,.6,,0,1,0 0,0,.25,.8,,0,1,0 0,0,.25,1,,0,1,0 0,0,.5,0,,0,1,0 0,0,.5,.2,,0,1,0 0,0,.5,.4,,0,1,0 0,0,.5,.6,,0,1,0 0,0,.5,.8,,0,1,0 0,0,.5,1,,0,0,1 0,0,.75,0,,0,1,0 0,0,.75,.2,,0,1,0 0,0,.75,.4,,0,1,0 0,0,.75,.6,,0,1,0 0,0,.75,.8,,0,0,1 0,0,.75,1,,0,0,1

0,0,1,0,,0,1,0 0,0,1,.2,,0,1,0 0,0,1,.4,,0,1,0 0,0,1,.6,,0,0,1 0,0,1,.8,,0,0,1 0,0,1,1,,0,0,1 0,.25,0,0,,1,0,0 0,.25,0,.2,,1,0,0 0,.25,0,.4,,1,0,0 0,.25,0,.6,,0,1,0 0,.25,0,.8,,0,1,0 0,.25,0,1,,0,1,0 0,.25,.25,0,,1,0,0 0,.25,.25,.2,,0,1,0 0,.25,.25,.4,,0,1,0 0,.25,.25,.6,,0,1,0 0,.25,.25,.8,,0,1,0 0,.25,.25,1,,0,1,0 0,.25,.5,0,,1,0,0 0,.25,.5,.2,,0,1,0 0,.25,.5,.4,,0,1,0 0,.25,.5,.6,,0,1,0 0,.25,.5,.8,,0,1,0 0,.25,.5,1,,0,0,1

En un apéndice de este trabajo, se presenta un listado más completo de los ejemplos para el proceso de aprendizaje y evaluación.

20

4.3

Etapa 3: Ejecución del Software: Aprendizaje y Validación Topología y valores iniciales

Parámetro

Valor

Neuronas de entrada (N)

4

Capas ocultas (Q)

2

Neuronas de salida (3)

3

Error permitido (MEP)

0.0001

Tasa de aprendizaje (α)

0.25

De entrenamiento

144

De prueba

36

Consideraciones para el entrenamiento y validación

Selección de ejemplos de aprendizaje:

secuencial.

Criterio de parada:

número de épocas.

Conjunto de evaluación:

distinto al de entrenamiento, aleatorio y 25% del de entrenamiento.

Entrenamiento:

aprendizaje supervisado por ejemplo y hasta aprender (entrenamiento incremental). El aprendizaje por ejemplo concluye cuando no hay modificación en los pesos.

La ejecución del proceso de aprendizaje de la red se llevó acabo en el hardware de computadoras IBM compatibles tecnología Pentium III y Pentium IV con procesadores de la familia Intel x86 de velocidad superior a 1 GHz. En la tabla 1 de a continuación se muestran las variaciones en la configuración de la red durante las pruebas realizadas.

Atención La versión del software para este trabajo de investigación está disponible en: http://www.rgusarav_respaldo.t35.com/bp02

21

N. Ocultas 2 4 6 8

5

10

30

61% 33% 33% 58%

61% 33% 33% 58%

61% 33% 33% 58%

Epocas 50 100 61% 61% 61% 58%

61% 66% 61% 58%

200

300

1000

61% 66% 61% 58%

61% 61% 61% 58%

61% 61% 66% 58%

Tabla 1. Resultados del proceso de validación del aprendizaje neuronal.

Observaciones obtenidas durante la ejecución del aprendizaje de la red

El cumplimiento de las pruebas de aprendizaje de la red demoró casi 10 días.

Para las pruebas que incluían un número de épocas igual o mayor a 100 se tuvo que dejar trasnochando los computadores empleados.

En algunas pruebas parciales y preliminares no expuestas en la anterior tabla, el proceso de aprendizaje entraba en un bucle infinito cuando la iteración no convergía para cumplir el error medio exigido.

Se apreciaba aceleración en el aprendizaje una vez que la red asimilaba un grupo de ejemplos de características relativamente similares.

Se apreciaba desaceleración en la velocidad del aprendizaje sobre todo cuando la red abordaba ejemplos diametralmente distintos.

La ilustración 13 muestra la gráfica comparativa a partir de los resultados del proceso de validación del aprendizaje de la red.

Observaciones sobre los resultados del proceso de validación

Para la mayor parte de las configuraciones de red probadas, se puede apreciar que, a mayor número de épocas, mejor aprendizaje neuronal.

Así mismo, puede notarse que, los resultados obtenidos varían notablemente con el número de neuronas ocultas empleado en cada configuración de la red.

Para las configuraciones de 4 y 6 neuronas se obtuvieron los mejores resultados de aprendizaje llegando a 66% de aciertos para 200 y 1000 épocas; no obstante, se aprecia un sobre-aprendizaje a partir de las 300 épocas para el caso de 4 neuronas. Esto permite adelantar sobre la probabilidad de que el 100% de aprendizaje pueda estar en un número de épocas intermedio antes de abordar el sobre-aprendizaje.

Las curvas podrían servir para hacer algunas estimaciones o interpolaciones del número de épocas necesario para lograr un determinado porcentaje de aciertos.

22

Proceso de Validación del Aprendizaje de la Red 70% 60%

Aciertos

50% 40% 30% 20% 10% 0% 0

200

400

600

800

1000

Épocas NO=2

NO=4

NO=6

NO=8

Ilustración 13. Gráfica Comparativa del Resultado del Proceso de Evaluación

5

Conclusiones Las redes neuronales son estructuras paralelas y no lineales capaces de resolver gran cantidad de problemas. Ofrecen soluciones a problemas multi-variable y difíciles de formalizar. Y capaces de aprender y generalizar. Las RNA son valiosas; sin embargo, no resuelven todos los problemas y no siempre de la mejor manera.

Las redes neuronales pueden aplicarse a la ingeniería civil para resolver problemas estructurales de hormigón armado multi-variable y de difícil determinación.

La programación de un software Web 2.0 para redes neuronales es factible pero requiere la interacción de hasta cuatro lenguajes o códigos de programación; razón por la cuál, no es un asunto sencillo.

La identificación de los patrones entrada/salida requiere de un buen conocimiento del problema de aplicación. El pre-procesamiento inicial de estos patrones juega un papel importante para la correcta respuesta del modelo neuronal. Una de las estrategias de pre-procesamiento puede ser la normalización de valores que no es otra cosa que la transformación lineal entre escalas.

23

Una proporcionada selección representativa de los ejemplos de aprendizaje es de vital importancia para el aprendizaje no desviado de la red neuronal. Sin embargo, la selección de los ejemplos de validación puede incluir estrategias aleatorias y no necesariamente representativas.

A causa de que no se conoce el funcionamiento interno de las neuronas (“son una caja negra”), no se tienen estrategias formales para la elección de una u otra determinada topología. La mejor opción es hacer pruebas sobre el caso en cuestión y hacer interpolaciones a partir de los resultados obtenidos para procurar dar con la mejor estrategia.

El proceso de aprendizaje de las redes neuronales ha demostrado un comportamiento similar al del cerebro del ser humano. Para un número de épocas muy pequeño, “memorizan” como para responder cuestiones parecidas a los últimos ejemplos aprendidos. Por otra parte, para ejemplos muy similares, requieren bastante esfuerzo reflejado en la necesidad de mayor número de neuronas ocultas y épocas.

La programación Web de redes neuronales ha demostrado ser muy útil sobre todo porque permite cualquier cantidad computadoras conectadas a un mismo caso de estudio para ejecutar todas las pruebas pertinentes diferentes; además, de la no-necesidad de compartir un mismo espacio físico. Pero es justo reconocer que, la velocidad ofrecida por los lenguajes embebidos para la Web 2.0 no es tan alta como la que ofrecen lenguajes típicos de aplicaciones de escritorio como el C/C++ y otros.

Referencias 

CARLOS MORATO A. (2008)

"Introducción a las Redes Neuronales". Postgrado en Informática. UMSA. LP-BOL.



YAILE CABALLERO (2008)

"Redes Neuronales Artificiales". Postgrado en Informática.

Universidad de Camaguey. Cuba.



ANDRES BELLO (1995)

“Redes Neuronales: Su Empleo en la Búsqueda Asociativa de información”. Cuba.



MARÍA JESUS DÍAZ (2006).

“Introducción a las Redes Neuronales Artificiales”. Cuba.



N. WINTER (1997)

“Diseño de Estructuras de Concreto”. Undécima edición.

McGraw-Hill. México.



W3 CONSORTIUM (2008)

“Introduction to HTML 4 “. [En red]. Disponible en: http://www.w3.org



NETSCAPE (1997)

“JavaScript Reference”. Netscape Communications Corporation.

USA.



PHP DOC. GROUP (2007)

“PHP Manual”. [En red]. Disponible en: http://www.php.net/manual/en/chm.about.php

24

Apéndices Apéndice A. Listados del Código Fuente A.1

Listado de la Página Web Inicial: Fichero “index.php” <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> <title>RNA - Backpropagation</title> <link href="esti01.css" rel="stylesheet" type="text/css" /> </head> <body> <h2>RNA - Backpropagation</h2> <br /> <?php $e1=file("/c_entr.txt"); $li=count($e1); for ($i=0; $i<$li; $i++) { $m4=0; $m5=0; // ojo $c=""; for ($k=0; $k<strlen($e1[$i]); $k++) { if ($e1[$i][$k]==',') { if ($e1[$i][$k+1]==',') { $m5=$m4; $k++; } $a1[$i][$m4]=$c; $m4++; $c=""; } else { $c=$c.$e1[$i][$k]; } } $a1[$i][$m4]=$c; $m4++; $c=""; } $e2=file("/c_prue.txt"); $l2=count($e2); ?>

25

<form action="page02.php" method="post" name="f01"> <table> <tr> <td class="c0"><label>Neuronas de entrada (N):&nbsp;</label></td> <td><input name="N" type="text" value="<?= $m5+1 ?>" /></td> </tr> <tr> <td class="c0"><label>Neuronas ocultas (L):&nbsp;</label></td> <td><input name="L" type="text" value="2" /></td> </tr> <tr> <td class="c0"><label>Capas ocultas (Q):&nbsp;</label></td> <td><input name="Q" type="text" value="2" /></td> </tr> <tr> <td class="c0"><label>Neuronas de salida (M):&nbsp;</label></td> <td><input name="M" type="text" value="<?= $m4-$m5-1 ?>" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td>&nbsp;</td> </tr> <tr> <td class="c0"><label>Error permitido (MEP):&nbsp;</label></td> <td><input name="MEP" type="text" value="0.0001" /></td> </tr> <tr> <td class="c0"><label>Tasa de aprendizaje (&alpha;):&nbsp;</label></td> <td><input name="alfa" type="text" value="0.25" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td>&nbsp;</td> </tr> <tr> <td class="c0"><label>De entrenamiento:&nbsp;</label></td> <td><input name="P" type="text" value="<?= $li ?>" /></td> </tr> <tr> <td class="c0"><label>De prueba:&nbsp;</label></td> <td><input name="U" type="text" value="<?= $l2 ?>" /></td> </tr>

26

<tr> <td class="c0"><label>Epocas:&nbsp;</label></td> <td><input name="O" type="text" value="3" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td>&nbsp;</td> </tr> <tr> <td class="c0">&nbsp;</td> <td class="c1"><input type="submit" value="Aceptar" class="b1" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td class="c1"><input type="reset" class="b1" /></td> </tr> </table> </form> </body> </html>

A.2

Listado de la Página Web de Cálculo: Fichero “page02.php” <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> <title>RNA - Backpropagation</title> <link href="esti01.css" rel="stylesheet" type="text/css" /> </head> <body> <h2>RNA - Backpropagation</h2> <br /> <?php $e1=file("/c_entr.txt"); $li=count($e1); for ($i=0; $i<$li; $i++) { $m4=0; $m5=0; // ojo

27

$c=""; for ($k=0; $k<strlen($e1[$i]); $k++) { if ($e1[$i][$k]==',') { if ($e1[$i][$k+1]==',') { $m5=$m4; $k++; } $a1[$i][$m4]=$c; $m4++; $c=""; } else { $c=$c.$e1[$i][$k]; } } $a1[$i][$m4]=$c; $m4++; $c=""; } $e2=file("/c_prue.txt"); $l2=count($e2); ?> <form action="page02.php" method="post" name="f01"> <table> <tr> <td class="c0"><label>Neuronas de entrada (N):&nbsp;</label></td> <td><input name="N" type="text" value="<?= $m5+1 ?>" /></td> </tr> <tr> <td class="c0"><label>Neuronas ocultas (L):&nbsp;</label></td> <td><input name="L" type="text" value="2" /></td> </tr> <tr> <td class="c0"><label>Capas ocultas (Q):&nbsp;</label></td> <td><input name="Q" type="text" value="2" /></td> </tr> <tr> <td class="c0"><label>Neuronas de salida (M):&nbsp;</label></td> <td><input name="M" type="text" value="<?= $m4-$m5-1 ?>" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td>&nbsp;</td> </tr> <tr> <td class="c0"><label>Error permitido (MEP):&nbsp;</label></td>

28

<td><input name="MEP" type="text" value="0.0001" /></td> </tr> <tr> <td class="c0"><label>Tasa de aprendizaje (&alpha;):&nbsp;</label></td> <td><input name="alfa" type="text" value="0.25" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td>&nbsp;</td> </tr> <tr> <td class="c0"><label>De entrenamiento:&nbsp;</label></td> <td><input name="P" type="text" value="<?= $li ?>" /></td> </tr> <tr> <td class="c0"><label>De prueba:&nbsp;</label></td> <td><input name="U" type="text" value="<?= $l2 ?>" /></td> </tr> <tr> <td class="c0"><label>Epocas:&nbsp;</label></td> <td><input name="O" type="text" value="3" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td>&nbsp;</td> </tr> <tr> <td class="c0">&nbsp;</td> <td class="c1"><input type="submit" value="Aceptar" class="b1" /></td> </tr> <tr> <td class="c0">&nbsp;</td> <td class="c1"><input type="reset" class="b1" /></td> </tr> </table> </form> </body> </html>

29

A.3

Listado del Código Fuente Embebido: Fichero “subs01.js” function Neu01(nt, y, w, i, e) { this.w = new Array(); this.nt=nt; this.y=y; this.w[i]=w; this.e=e; } var mx01 = 50; var n, m, l, q, ep, al, p, u, o, sw; var neh = new Array(); for (i=1; i<=mx01; i++) neh[i] = new Array(); var neo = new Array(); var x = new Array(); var d = new Array(); function rcl(id,fi,co) { z0=id+sw+fi+"_"+co; return document.getElementById(z0).value; } function sto(id,fi,co,va) { z0=id+sw+fi+"_"+co; document.getElementById(z0).value=va; } function s00() { n=parseInt(document.f01.n.value); l=parseInt(document.f01.l.value); q=parseInt(document.f01.q.value); m=parseInt(document.f01.m.value); ep=parseFloat(document.f01.ep.value); al=parseFloat(document.f01.al.value); p=parseInt(document.f01.p.value); u=parseInt(document.f01.u.value); o=parseInt(document.f01.o.value); } function s01(u7) { for (i=1; i<=n; i++) { x[i]=rcl("x",u7,i); } for (k=1; k<=m; k++) { d[k]=rcl("d",u7,k); }

30

} function r01(u7) { for (k=1; k<=m; k++) { sto("y",u7,k,neo[k].y) } } function fnt(v) { // funciรณn sigmoide return (1/(1+Math.exp(-v))); } function fntp(v) { // derivada de la funciรณn dh=1e-8; return ((fnt(v+dh)-fnt(v))/dh); } function e01() { su=0; for (k=1; k<=m; k++) su+=Math.pow(d[k]-neo[k].y, 2); return (su/2); } function ini01() { // iniciar pesos h=1; for (j=1; j<=l; j++) { neh[h][j] = new Neu01(); for (i=1; i<=n; i++) { neh[h][j].w[i] = Math.random()-0.5; } } for (h=2; h<=q; h++) for (j=1; j<=l; j++) { neh[h][j] = new Neu01(); for (i=1; i<=l; i++) { neh[h][j].w[i] = Math.random()-0.5; } } for (k=1; k<=m; k++) { neo[k] = new Neu01(); for (j=1; j<=l; j++) { neo[k].w[j] = Math.random()-0.5; } } } function p01() { // propagaciรณn h=1; for (j=1; j<=l; j++) {

31

su=0; for (i=1; i<=n; i++) su+=x[i]*neh[h][j].w[i]; neh[h][j].nt=su; neh[h][j].y=fnt(neh[h][j].nt); } for (h=2; h<=q; h++) { for (j=1; j<=l; j++) { su=0; for (i=1; i<=l; i++) su+=neh[h-1][i].y*neh[h][j].w[i]; neh[h][j].nt=su; neh[h][j].y=fnt(neh[h][j].nt); } } h=q; for (k=1; k<=m; k++) { su=0; for (j=1; j<=l; j++) su+=neh[h][j].y*neo[k].w[j]; neo[k].nt=su; neo[k].y=fnt(neo[k].nt); } } function p02() { // aprender et = new Array(); sw=""; s00(); ini01(); for (z5=1; z5<=o; z5++) { et[z5]=0; for (z6=1; z6<=p; z6++) { s01(z6); p01(); eo=e01(); while (eo>ep) { for (k=1; k<=m; k++) neo[k].e=(d[k]-neo[k].y)*fntp(neo[k].y); h=q; for (j=1; j<=l; j++) { su=0; for (k=1; k<=m; k++) su+=neo[k].e*neo[k].w[j]; neh[h][j].e=su*fntp(neh[h][j].y);

32

} for (h=q-1; h>=1; h--) { for (j=1; j<=l; j++) { su=0; for (k=1; k<=l; k++) su+=neh[h+1][k].e*neh[h+1][k].w[j]; neh[h][j].e=su*fntp(neh[h][j].y); } } h=1; for (j=1; j<=l; j++) for (i=1; i<=n; i++) { neh[h][j].w[i]=neh[h][j].w[i]+(al*neh[h][j].e*x[i]); } for (h=2; h<=q; h++) for (j=1; j<=l; j++) for (i=1; i<=l; i++) { neh[h][j].w[i]=neh[h][j].w[i]+(al*neh[h][j].e*neh[h-1][i].y); } h=q; for (k=1; k<=m; k++) for (j=1; j<=l; j++) { neo[k].w[j]=neo[k].w[j]+(al*neo[k].e*neh[h][j].y); } p01(); eo=e01(); } et[z5]+=eo; r01(z6); } et[z5]=et[z5]/p; } r02(); } function p03() { // evaluar sw="e"; ac=0; for (z6=1; z6<=u; z6++) { s01(z6); p01(); eo=e01(); if (eo<=ep) { ac++; } r01(z6); } pa=100*ac/u; r03();

33

} function r03() { document.getElementById("AC").value=ac; document.getElementById("PA").value=pa; } function r02() { mi=et[1]; ma=et[1]; for (i=2; i<=o; i++) { if (et[i]<mi) mi=et[i]; if (et[i]>ma) ma=et[i]; } for (i=1; i<=o; i++) { sto("e",i,i,et[i]); k0=Math.round((et[i]-mi)*40/(ma-mi))+1; d4=""; for (j=1; j<=k0; j++) d4+="*"; if (et[i]>=ma) d4+=" max"; if (et[i]<=mi) d4+=" min"; sto("g",i,i,d4); } }

A.4

Listado de la Hoja de Estilos: Fichero â&#x20AC;&#x153;esti01.cssâ&#x20AC;? body { background-color: #F4F4F4; font-family: Arial, Helvetica, sans-serif; font-size: small; color: #000066; } table { border-style: solid; border-width: 0; font-family: Arial, Helvetica, sans-serif; font-size: small; } td { border-style: solid; border-width: thin; font-family: Arial, Helvetica, sans-serif; font-size: small;

34

text-align: left; } .c0 { width: 4cm; } .c1 { text-align: right; } .t1 { width: 8cm; } .t2 { width: 1cm; } .b1 { width: 4cm; }

Apéndice B. B.1

Conjunto de Entrenamiento

Versión Simplificada del Conjunto de Ejemplos del Problema de Aplicación 0,0,0,0,,1,0,0 0,0,0,.333333333333333,,1,0,0 0,0,0,.666666666666667,,1,0,0 0,0,0,1,,0,1,0 0,0,.333333333333333,0,,1,0,0 0,0,.333333333333333,.333333333333333,,0,1,0 0,0,.333333333333333,.666666666666667,,0,1,0 0,0,.333333333333333,1,,0,1,0 0,0,.666666666666667,0,,0,1,0 0,0,.666666666666667,.333333333333333,,0,1,0 0,0,.666666666666667,.666666666666667,,0,1,0 0,0,.666666666666667,1,,0,1,0

35

0,0,1,0,,0,1,0 0,0,1,.333333333333333,,0,1,0 0,0,1,.666666666666667,,0,1,0 0,0,1,1,,0,1,0 0,.5,0,0,,1,0,0 0,.5,0,.333333333333333,,1,0,0 0,.5,0,.666666666666667,,1,0,0 0,.5,0,1,,0,1,0 0,.5,.333333333333333,0,,1,0,0 0,.5,.333333333333333,.333333333333333,,0,1,0 0,.5,.333333333333333,.666666666666667,,0,1,0 0,.5,.333333333333333,1,,0,1,0 0,.5,.666666666666667,0,,1,0,0 0,.5,.666666666666667,.333333333333333,,0,1,0 0,.5,.666666666666667,.666666666666667,,0,1,0 0,.5,.666666666666667,1,,0,1,0 0,.5,1,0,,0,1,0 0,.5,1,.333333333333333,,0,1,0 0,.5,1,.666666666666667,,0,1,0 0,.5,1,1,,0,1,0 0,1,0,0,,1,0,0 0,1,0,.333333333333333,,1,0,0 0,1,0,.666666666666667,,1,0,0 0,1,0,1,,0,1,0 0,1,.333333333333333,0,,1,0,0 0,1,.333333333333333,.333333333333333,,1,0,0 0,1,.333333333333333,.666666666666667,,0,1,0 0,1,.333333333333333,1,,0,1,0 0,1,.666666666666667,0,,1,0,0 0,1,.666666666666667,.333333333333333,,0,1,0 0,1,.666666666666667,.666666666666667,,0,1,0 0,1,.666666666666667,1,,0,1,0 0,1,1,0,,0,1,0

36

0,1,1,.333333333333333,,0,1,0 0,1,1,.666666666666667,,0,1,0 0,1,1,1,,0,1,0 .5,0,0,0,,1,0,0 .5,0,0,.333333333333333,,1,0,0 .5,0,0,.666666666666667,,1,0,0 .5,0,0,1,,0,1,0 .5,0,.333333333333333,0,,1,0,0 .5,0,.333333333333333,.333333333333333,,0,1,0 .5,0,.333333333333333,.666666666666667,,0,1,0 .5,0,.333333333333333,1,,0,1,0 .5,0,.666666666666667,0,,1,0,0 .5,0,.666666666666667,.333333333333333,,0,1,0 .5,0,.666666666666667,.666666666666667,,0,1,0 .5,0,.666666666666667,1,,0,1,0 .5,0,1,0,,0,1,0 .5,0,1,.333333333333333,,0,1,0 .5,0,1,.666666666666667,,0,1,0 .5,0,1,1,,0,1,0 .5,.5,0,0,,1,0,0 .5,.5,0,.333333333333333,,1,0,0 .5,.5,0,.666666666666667,,1,0,0 .5,.5,0,1,,1,0,0 .5,.5,.333333333333333,0,,1,0,0 .5,.5,.333333333333333,.333333333333333,,1,0,0 .5,.5,.333333333333333,.666666666666667,,0,1,0 .5,.5,.333333333333333,1,,0,1,0 .5,.5,.666666666666667,0,,1,0,0 .5,.5,.666666666666667,.333333333333333,,0,1,0 .5,.5,.666666666666667,.666666666666667,,0,1,0 .5,.5,.666666666666667,1,,0,1,0 .5,.5,1,0,,1,0,0 .5,.5,1,.333333333333333,,0,1,0

37

.5,.5,1,.666666666666667,,0,1,0 .5,.5,1,1,,0,1,0 .5,1,0,0,,1,0,0 .5,1,0,.333333333333333,,1,0,0 .5,1,0,.666666666666667,,1,0,0 .5,1,0,1,,1,0,0 .5,1,.333333333333333,0,,1,0,0 .5,1,.333333333333333,.333333333333333,,1,0,0 .5,1,.333333333333333,.666666666666667,,0,1,0 .5,1,.333333333333333,1,,0,1,0 .5,1,.666666666666667,0,,1,0,0 .5,1,.666666666666667,.333333333333333,,0,1,0 .5,1,.666666666666667,.666666666666667,,0,1,0 .5,1,.666666666666667,1,,0,1,0 .5,1,1,0,,1,0,0 .5,1,1,.333333333333333,,0,1,0 .5,1,1,.666666666666667,,0,1,0 .5,1,1,1,,0,1,0 1,0,0,0,,1,0,0 1,0,0,.333333333333333,,1,0,0 1,0,0,.666666666666667,,1,0,0 1,0,0,1,,1,0,0 1,0,.333333333333333,0,,1,0,0 1,0,.333333333333333,.333333333333333,,1,0,0 1,0,.333333333333333,.666666666666667,,0,1,0 1,0,.333333333333333,1,,0,1,0 1,0,.666666666666667,0,,1,0,0 1,0,.666666666666667,.333333333333333,,0,1,0 1,0,.666666666666667,.666666666666667,,0,1,0 1,0,.666666666666667,1,,0,1,0 1,0,1,0,,1,0,0 1,0,1,.333333333333333,,0,1,0 1,0,1,.666666666666667,,0,1,0

38

1,0,1,1,,0,1,0 1,.5,0,0,,1,0,0 1,.5,0,.333333333333333,,1,0,0 1,.5,0,.666666666666667,,1,0,0 1,.5,0,1,,1,0,0 1,.5,.333333333333333,0,,1,0,0 1,.5,.333333333333333,.333333333333333,,1,0,0 1,.5,.333333333333333,.666666666666667,,0,1,0 1,.5,.333333333333333,1,,0,1,0 1,.5,.666666666666667,0,,1,0,0 1,.5,.666666666666667,.333333333333333,,0,1,0 1,.5,.666666666666667,.666666666666667,,0,1,0 1,.5,.666666666666667,1,,0,1,0 1,.5,1,0,,1,0,0 1,.5,1,.333333333333333,,0,1,0 1,.5,1,.666666666666667,,0,1,0 1,.5,1,1,,0,1,0 1,1,0,0,,1,0,0 1,1,0,.333333333333333,,1,0,0 1,1,0,.666666666666667,,1,0,0 1,1,0,1,,1,0,0 1,1,.333333333333333,0,,1,0,0 1,1,.333333333333333,.333333333333333,,1,0,0 1,1,.333333333333333,.666666666666667,,1,0,0 1,1,.333333333333333,1,,0,1,0 1,1,.666666666666667,0,,1,0,0 1,1,.666666666666667,.333333333333333,,1,0,0 1,1,.666666666666667,.666666666666667,,0,1,0 1,1,.666666666666667,1,,0,1,0 1,1,1,0,,1,0,0 1,1,1,.333333333333333,,0,1,0 1,1,1,.666666666666667,,0,1,0 1,1,1,1,,0,1,0

39