Oscar Sandoval

La revolución de los Guachos!!!

2011-08-26T19:42:00.000-07:00

Educación sin lucro!! dicen los lienzos a las afueras de la Universidad de Chile, pitos y cacerolazos escucho fuera de mi depto y el típico canto “y va caer y va caer la educación de Pinochet” es lo que escucho todos los días aquí en Santiago, y decidí, a pesar de mi poco tiempo libre, documentarme y reflexionar sobre el tema.

El gobierno Militar, con el DFL de 1980, buscó una reforma al sistema educactivo, basándose en incentivos y subsidios a la educación, e impulsando la creación de nuevas universidades, institutos profesionales y centros de formación técnica para ampliar la masa profesional chilena, que sin duda Chile necesitaría en los años venideros.

Hasta aquí todo bien, pero ¿que hubiera pasado si el gobierno militar no hubiera realizado estos cambios en la educación?, probablemente Chile hubiera mantenido por muchos años una tasa de ingreso a la universidad del 5% de la población, cifras de 1973, y por lo tanto, no hubiera existido la masa profesional necesaria para llevar a cabo el desarrollo del país.

Por otro lado, la concertación se dedicó a reafirmar y gobernar esta educación por veinte años y la defendió con uñas y dientes durante la revolución pinguina.

Hoy hay un nuevo gobierno de derecha en Chile, y los estudiantes “por cosas del destino”, eligieron a este gobierno para reclamar por sus derechos, paralizando la educación del país para ser escuchados, piden educación de Estado y de Calidad, como si el apellido Estado fuera simil de calidad, y lo privado de mala calidad. Piden educación gratuita, como si los recursos fueran más que las necesidades, destruyendo toda teoría económica con ello. Pedir lo anterior, es pedir la postergación de necesidades fundamentales de los Chilenos, como Salud, vivienda y alimentación. No me parece que la deuda de los estudiantes sea más urgente que reconstruir las miles de casas que se destruyeron por el terremoto del 27F. No me parece que la deuda de los estudiantes sea más importante que financiar las enfermedades catastróficas de miles de compatriotas, simplemente no me parece que los estudiantes se sientan con el derecho de decidir que es lo urgente o no para los Chilenos.

Sin duda, se debe mejorar el modelo de la educación actual, hay que rebajar los aranceles, hay que aumentar las becas y el acceso a la educación y para ello el gobierno debe dejar su orgullo y sentarse a negociar con los estudiantes.

El presidente Piñera nos pide que cuidemos nuestro querido Chile, y ojala todos nos unamos a esa causa, incluso la concertación y la gente de izquierda que deben aprender a ser oposición en democracia, eso significa una oposición constructiva y unida en los intereses mayores de Chile. Porque les guste o no Piñera ganó y lo hizo legítimamente y si al gobierno le va mal a Chile le irá mal.

Si algo reflejó el terremoto del 27F, es lo fácil que se pierde la moralidad y la decencia en la "gente decente" cuando descubren que robar, saquear o infringir la ley no tiene costo. En esa oportunidad, los militares salieron a poner orden, llamados por el propio pueblo. Hoy nuevamente escucho esas voces, luego de tanto saqueo y delincuencia en las calles, donde los carabineros se ven sobrepasados y la sociedad chilena reclama por mayor dureza contra los delincuentes, como si fuéramos niños necesitando la reprimenda de un padre. Tal vez, la sociedad y la democracia en si no ha madurado lo suficiente y necesitamos de una mano dura que nos diga como comportarnos. Tal vez, echamos de menos a esa mano dura que ya no está y nos convertimos en la generación de los guachos, en guachos del gobierno militar, en guachos de Pinochet. Espero que no sea así......

Y volvi a caer... atrapado por las redes sociales

2011-08-05T17:53:00.000-07:00

Si lo admito, volví a caer, desde hace pocos días tengo una cuenta en FourSquare, y ya son cuatro las redes sociales en las que marco precencia.

Recuerdo que todo empezo para mi con Fotolog, un sitio web en el que se podía compartir fotos con el único fin de recibir posteos “comentarios” y nunca pude entender cúal era el afan de la gente de subir fotos y recibir comentarios con el único fin de aumentar su ego o sentirse aceptado socialmente.

Luego llego Facebook, me inscribi por curisidad, y luego de probarlo un tiempo, no encontraba sentido por qué la gente querría publicar sus fotos, links y “status”, una especie de impulso por exponer su vida. Admito que encontraba ridiculo que alguien escribiera en su status “Tengo hambre”, “Tengo sueño”, “me voy al mall”, etc. Luego de un tiempo, tenía más de cien amigos agregados, la mayoría compañeros de la Universidad, colegio y liceo y ya no me pareció tan aburrido conocer la vida de mis amigos y tener un medio dónde mantener contacto con ellos, y conocer qué fué de sus vidas, recordar con sus fotos las vivencias de la Universidad y las locuras del Liceo, tardes enteras “carreteando” sin nada que nos preocupara. Admito que hay algo de nostalgia también, de una u otra manera siento que al mantener ese contacto, todavía siento que estoy en la Universidad y que nada ha cambiado. Sueño que termina cuando cierro mi cuenta de Facebook.

Luego conocí Twitter. El famoso Twitter. Recuerdo que lo primero que dije al conocerlo fué ¿esto es twitter? Es una especie de Status Facebook de 140 caracteres, no creo que tenga futuro esta aplicación “que ojo tengo”. Descepcionado no ingrese más a mi cuenta. Luego cuando tuve mi primer smartphone, todo fue distinto, le encontre sentido al twitter, no como twittero, ya que no posteo nunca, sino que empece a seguir periodistas, blog, temas de interes, etc. y ahi estoy, con mi galaxy, pendiente de leer como la gente a la que sigo, comparte su visión del mundo en pocos caracteres.

Un dia, “googleando” por interntet conoci Linkedin, una especie de Facebook para profesionales, un medio donde compartir tu CV, mantener contactos y seguir grupos de interes. Un gran espacio para encontrar ofertas laborales, incluso mi primer trabajo en Santiago, fué gracias Linkedin.

Pero no pude resistirme, tres redes no eran suficiente, me cree una cuenta Foursquare, reconozco que todavía no sé muy bien para qué exactamente sirve, sólo me limito a realizar check-in y buscar recomendaciones de los lugares que frecuento, ni siquiera tengo amigos a quién agregar. Si Facebook me conecta con mi amigos, Twitter me conecta con el mundo, Linkedin me conecta con profesionales, Foursquare me mantendrá siempre localizado y no necesitaré otra red rocial a la cual unirme. Decidí que no necesitaba otra red, que ya era suficiente y me prometí no tener una quinta red.

Hace poco tiempo salio Google+. La flamante red social de Google. Reconozco que me pica el bichito, pero ahi estoy, firme. No necesito una quinta red, no la necesito, no caeré....

Simulación de Estados de Procesos

2010-02-25T06:58:00.001-08:00

Introducción

En los procesadores multiprocesos se pueden distinguir 4 estados principales (listo, bloqueado, suspendido y nuevo).

En ese post se analiza los 4 estados de los procesos en el cual se detalla su descripción como ejemplo de uso y análisis del funcionamiento del sistema operativos multiprocesos.

Además un programa en código C que emula el funcionamiento de los estados de los procesos, si quieren la fuente de este programa, sólo tienen que pedirlo...

Estructura de Datos: Los cuatro estados que puede tener un proceso son: nuevo, listo, suspendido, bloqueado cada estado representa una cola única, y estas se manejan a través de una lista enlazada, por tanto se crea una estructura Nodo y una estructura lista a través de los TAD correspondientes, el código es el siguiente.

Estructura de los Nodos

typedef struct ListaNodo

{

int info;

struct ListaNodo *ant, *sig;

} *pListaNodo,ListaNodo;

typedef struct Estructura de las Listas

{

pListaNodo primero, ultimo, ventana;

int longitud;

} TLista, *Lista;

typedef pListaNodo Ventana;

además se crean varias funciones de implementación de la estructura como iniciar lista, anexar lista , primer lista, ultimo lista , siguiente lista, etc., estas funciones están implementadas en la cabecera tadlista.h

Colas: Para el manejo de las colas se crea una cabecera colas.h, la cual ocupa la lista enlazada y generando nuevas funciones para la implementación de la cola, para ello se crea una variable tipo lista de nombre cola.

typedef Lista Cola;

Luego se crean varias funciones de implementación como iniciar Cola, Vaciar Cola, información de la Cola, etc.

Veamos algunos Ejemplos:

La función adicCola sitúa un nuevo elemento de la cola al final de ésta

void adicCola( Cola col, int elem )

{

ultLista(col);

anxLista(col,elem);

}

La función elimCola elimina el primer elemento de la cola

void elimCola( Cola col )

{

primLista(col);

elimLista(col);

}

int longCola( Cola col ) Retorna la longitud de la cola

{

return col->longitud;

}

Estas funciones son muy importantes para facilitar el manejo de las colas y para el buen funcionamiento del programa.

Estructura del Proceso: cada proceso es una estructura con sus propias variables y a cada

Proceso se le asigna una letra única de identificación, los procesos poseen un valor, una linea de instrucción, un estado y una dirección de memoria.

Cada proceso puede tener un máximo de 10 líneas de instrucción y le corresponde una única dirección de memoria de 10 espacios la cual posee en toda su vida activa

El código de la estructura de los procesos es el siguiente

typedef struct est_procesos

{

int n; Valor del proceso

int linea[10]; linea de instrucción

int bcp; dirección del bcp

char estado; estado del proceso

int mem; linea de memoria asignada

} tproceso,*proceso;

Crear proceso: esta función se encarga de crear un proceso e inicia sus valores iniciales

Cada proceso creado se guarda en un vector de procesos PRO [] este vector es muy importante por que sirve para guardar todos los procesos creados y permite al programa recoger información de un proceso en cualquier momento, los valores del proceso es también su dirección en este Vector

proceso crear_proceso(int n,int l,int memoria)

{

Proceso A; Crea el proceso

A = (proceso) malloc (sizeof (tproceso)); asigna memoria

A->n = 1; valor del proceso

A=vaciar_linea(A);

A->linea[l]=1; linea de instrucción leída

A->estado='n'; estado nuevo

A->mem=memoria; espacio de dirección asignada

return A; retorna el proceso al vector PRO[]

}

Asignación de memoria: Cada proceso tiene asignada una porción de porción de memoria fija de 10 celdas y solo puede ocupar esa parte de la memoria

int memoria [200]; este vector simula la memoria del computador en total puede almacenar 20 porciones de memoria para 20 procesos, por ejemplo un proceso X puede tomar una celda de [10 -19]

Para garantizar que este espacio de memoria sea único para cada proceso se encuentra la función vacio_mem.

La variable mem es una dirección aleatoria de memoria, si esta libre el espacio de memoria retornara la misma dirección, en caso que la dirección esté ocupada buscara la próxima dirección siguiente vacía.

El vector Vacio [] se encarga de almacenar las direcciones no ocupadas

mem=vacio_mem(mem,dato); la función vacio_mem retornara la dirección de memoria a

La variable mem que más tarde se le asignara al proceso

Correspondiente.

int vacio_mem(int n,int dato)

{

int i;

if(memoria[n]==0)

{

memoria[n]=dato; si la memoria no esta asignada retorna la misma

Dirección

return n;

}

else

{

for(i=1;i<=20;i++) En caso contrario busca un espacio de memoria

Vacía

{

if(vacio[i]==0)

{

vacio[i]=dato;

return i*10;

}

Return 0; en el caso que no haya memoria disponible

Retornara un valor cero

}

Estados del proceso:

Nuevo: es la cola donde se alojan los procesos que se van generando aleatoria mente

Listo: Son los procesos que interactúan con el procesador y lo hacen hasta terminar sus

Instrucciones

Bloqueado: son los procesos que solicitan un recurso de Entrada y salida

Suspendidos: Son los procesos que no tienen asignada una dirección de memoria

Planificador: Una vez cargados todos los procesos a la cola de tipo nueva se pone en marcha la función Planificador, La función planificador se encarga de de seleccionar el proceso que pasara de su estado nuevo a listo, dependiendo de la antigüedad del proceso, siendo seleccionado el proceso a través de una política FIFO (primero que entra primero que sale)

Aquí llama a la función planificador y retornara a la cola listo

listo=planificador(nuevo,listo);

Lista planificador(Lista col,Lista cola)

{

proceso proces;

proces=pro[infoCola(col)]; se recupera el proceso a través del vector PRO []

Confirma que tiene memoria seleccionada

if(proces->mem!=0)

{

primLista(col); primero de la lista

adicCola(cola,infoCola(col)); adiciona a la cola listo

elimCola(col); elimina el proceso de la cola nuevo

flechas();

}

Return cola; retorna la cola a la cola listo

}

Suspendor: esta función se encarga de seleccionar el proceso que no tiene memoria y lo pasa a la cola de estado suspendido.

Aquí llama a la función suspendor y se devuelve a la cola suspendida

suspendido= suspendor(nuevo,suspendido); procesos que no tienen asignada memoria

Lista suspendor(Lista col,Lista sus)

{

proceso proces;

proces=pro[infoCola(col)];

if(proces->mem==0) confirma que el proceso no tenga asignada

Memoria

{

primLista(col);

adicCola(sus,infoCola(col)); mueve el proceso a la cola de estado

Suspendido

ElimCola (col);

}

Bloqueador: esta función selecciona a los procesos que requieren recursos de entrada y salida y pasa el proceso de la cola listo a la cola de estado Bloqueado

Lista bloqueador(Lista col, Lista blo)

{

proceso proces;

proces=pro[infoCola(col)]; recupera el proceso

if(proces->linea[proces->n]==1) pregunta si es del tipo entrada

Salida (1)

{

adicCola(blo,infoCola(col)); pasa el proceso al estado

bloqueado

if(!vaciaCola(col))elimCola(col);

}

return blo; retorna la cola bloqueado

}

Procesador: el procesador se encarga de leer la linea de instrucción del proceso e incrementa en una unidad, solo es capaz de leer un proceso a la vez, y retorna el proceso al final de la cola tipo listo.

Cuando un proceso llega al límite de instrucción que son 10 instrucciones el proceso se elimina automáticamente liberando su memoria para poder ingresar otro proceso

proceso actualizar_proceso(proceso A) función de procesador que actualiza los

{ Datos del proceso

int j;

j=A->n;

j++;

A>n=j; aumenta en uno la instrucción del proceso

A->estado='l';

return A; retorna el proceso

}

Ejemplo:

Este ejemplo es un procesador ejecutando un proceso M

Informaciones Generales Sobre los procesos

En el programa se muestran dos recuadros que muestran toda la información sobre los procesos en ejecución, el recuadro estadística se muestra los valores que posee el proceso en el instante de su ejecución y el recuadro memoria muestra la porción de memoria asignada a ese proceso.

Cuadro Estadísticas: muestras los datos referentes a cada proceso en ejecución:

Proceso: Letra asignada

Instrucción: número de linea de la instrucción que se esta ejecutando

Linea [6] = tipo de instrucción o [E/S]. Si la instrucción no requiere ningún recurso

Externo, entonces se imprime Instruc. En caso de que requiera una

Instrucción [E/S] entonces se imprime [E/S] y el proceso pasaría a estado

Bloqueado.

Estado = muestra su estado listo

Memoria: muestra la porción de memoria asignada a cada proceso en ejecución, en este caso el proceso solo puede ocupar su porción de memoria de 10 celdas que es de 140 a 149

Políticas Generales del programa

En un sistema operativo se utilizan varias políticas de ejecución de sus tareas como es la asignación de memoria, el tipo de prio ridad de los procesos, etc. El uso de estas políticas define y afecta el comportamiento general del sistema.

En este programa se usan varios manejos de implementación para definir el comportamiento de los procesos como son las políticas de asignación de memoria o políticas de prioridad de los procesos.

Políticas sobre la memoria: se ha creado una memoria de 200 celdas de tamaño fijo, la cual puede albergar a 20 procesos activos, cada proceso tiene asignado 10 celdas de memoria y solo puede ocupar esa porción de memoria asignada.

Procesos	0	1	2	3	4	5	6	7	8	9
A
B
.
.
Y
Z

Políticas de Prioridad: Para el manejo de los procesos se ha asignado la prioridad FIFO

(First in First out), primero que entra primero que sale, por tanto los procesos mas antiguos en la cola son los primeros que se ejecutan en el procesador

Vista general del programa:

Conclusión

Este post ha tratado de los distintos estados que puede tener un proceso a lo largo de su ejecución, la simulación se ha realizado a través de un programa escrito en C++.

En el software de simulación se ha divido en un archivo con extensión CPP y 4 cabeceras header, la cual la cabecera interface contiene todas las interfaces del programa, las cabeceras cola.h y tadlista.h, contienen toda la estructura de datos del programa.

Validar XML con XSD y VB.NET

2010-02-03T13:41:00.000-08:00

En este post, explicaré como un documento XML es validado por un documento XSD y como a través de VB.NET puedo ocupar estos documentos para validar a traves de código.

Bueno empecemos...

El lenguaje XML es un lenguaje de marca muy parecido a un documento HTML, pero hay una diferencia principal y es que el HTML no indica lo que se está representando, tiene datos mal definidos con elementos de formato, mientras que el XML contiene datos que se autodefinen: describe el contenido de lo que etiquetan.

Veamos un ejemplo:

La primera linea sólo nos dice al version del XML y la codificación, esta linea es necesaria en todos los documentos XML.

Después tengo una etiqueta “Documento” con un atributo DocID, esta etiqueta es “compleja”, ya que tiene etiquetas dentro, en nuestro caso Nombre, por lo tanto, una etiqueta es compleja o simple, si tiene o no etiquetas dentro.

Ahora se nos hace necesario validar este docuemento, para ello utilizamos los archivos con extensión XSD.

Cabe aclarar que un documento puede estar bien formado y válido, bien formado es cuando su sintaxis es correcta, por ejemplo todas las etiquetas tienen sus respectivos cierres, y válido cuando pasar por la revisión del XSD.

Acá hay un xsd para el documento xml anterior:

OJO: “este XSD valida que solo exista una etiqueta nombre, si queremos que exista más de una etiqueta Nombre entonces hay que agregar en “element nombre”, el atributo “maxoccurs=10”, de esa manera podrán haber hasta 10 etiquetas Nombre”

La primera línea define el NameSpace, estos se utilizan para proporcionar a los elementos un nombre único, en este caso xsd Después hay una etiqueta element, que representa una etiqueta en un documento XML, en este caso el elemento es "Documento", como la etiqueta es compleja, osea tiene etiquetas dentro, entonces se escribe la linea complextype, para enumerar todas las etiquetas que tiene dentro, en este caso sólo es "Nombre", como "Nombre" es una etiqueta simple, no lleva esta etiqueta. La etiqueta sequence sirve para enumerar los elementos anidados.

Ahora como documentos tiene atributos estos se deben declarar con la etiqueta attribute, donde definimos el nombre, el uso si es requerido o no y el tipo de datos, si es número o texto. Esta etiqueta siempre va luego del cierre de la etiqueta sequence.

Para asociar un documento XML con un XSd se debe agregar una etiqueta xsi:noNamespaceSchemaLocation="DocIngreso.xsd"

Ahora lo más interesante, ¿cómo hago para que mi sistema valide mis documentos XML con los documentos XSD?.

Bueno muy facíl, dare un pequeño ejemplo en VB.NET, si quieren un ejemplo en otro lenguaje sólo tienen que pedirlo.

Ahi va..

Lo primero es importar las librerias necesarias

Imports System.Xml

Imports System.Xml.Schema

Sub Main()

Luego creamos un objeto XmlTextReader, este objeto es un lector de un documento XML

Dim tr As New XmlTextReader("c:\DocIngreso.xml")

Luego cramos un objeto XmlValidatingreader y lo asociamos al objeto XmlTextReader

Dim vr As New XmlValidatingReader(tr)

Abrimos el documento xsd

vr.Schemas.Add("", "c:\DocIngreso.xsd")

y lo validamos por tipo Schema que es el tipo XSD

vr.ValidationType = ValidationType.Schema

luego leemos el documento xml, si se produce un error lo capturamos, sino es porque el documento es valido

AddHandler vr.ValidationEventHandler, AddressOf ValidationHandler

While vr.Read()

End While

Console.WriteLine("Documento es válido")

Console.Read()

End Sub

Haber probemos el codigo!!!

El xsd me dice que el atributo DocID es un numero entero

Entonces probarpe con el DocId con un tipo numero y otro tipo texto.

Primer ejemplo con DocID=”123” (tipo numero)

Como era de esperarse el documento es válido según el xsd.

Segundo ejemplo con DocID=”alguna palabra” (tipo texto)

Acá nos sale el error y el mensaje, que el tipo de datos no es valido para el atributo DocID

Funciona!!!

Bueno espero les sirva…..

Aquí va el codigo completo...........................................

Imports System.Xml

Imports System.Xml.Schema

Module Module1

Sub Main()

Dim tr As New XmlTextReader("c:\DocIngreso.xml")

Dim vr As New XmlValidatingReader(tr)

vr.Schemas.Add("", "c:\DocIngreso.xsd")

vr.ValidationType = ValidationType.Schema

AddHandler vr.ValidationEventHandler, AddressOf ValidationHandler

While vr.Read()

End While

Console.WriteLine("Documento es válido")

Console.Read()

End Sub

Public Sub ValidationHandler(ByVal sender As Object, ByVal args As ValidationEventArgs)

Console.WriteLine("***Validation error")

Console.WriteLine("Severity:{0}", args.Severity)

Console.WriteLine("Message:{0}", args.Message)

Console.Read()

End Sub

End Module

IMPLEMENTACIÓN DE UNA RED NEURONAL UTILIZANDO SOFTWARE TLEARN

2009-10-25T13:18:00.000-07:00

En este Post voy a enseñar como diseñar una red neuronal Feedforward de dos capas.

Vamos a implementar una red neuronal que permita reconocer escrituras de dígitos (0 - 9). Presentemos la red como una malla 3x5, que contiene un dibujo binario del digito.

Cantidad de neuronas de entrada:

La cantidad de neuronas de entrada serán 3x5 = 15 neuronas de entrada.

Esta cantidad se escogió puesto que representa un mejor manera de dibujar el digito en la matriz, y además para no complicar en demasía la estructura de la red.

Cantidad por capas ocultas:

La cantidad de capas ocultas corresponderá a una, la cual contiene 6 neuronas en el nivel intermedio, esto puesto que un nivel intermedio demasiado grande extenderá drásticamente el número de iteraciones requerido para probar la red y reducirá la fiabilidad de la rellamada.

Cantidad de neuronas de salida:

El nivel de salida debe tener 4 neuronas, para darnos la salida de 4 bits, esto porque a los dígitos 8 y 9 le corresponden 4 bits, para poder representarlos de forma binaria.

Estructura de datos utilizada para la neurona:

Construimos red neuronal feedforward multicapas para que cada nivel esté completamente conectado al siguiente. Cada neurona en un nivel mandará su salida a cada neurona del siguiente nivel.

Configuración de la red:

Para configurar la red utilizamos el archivo RED.CF, donde definimos los valores de la red neuronal. En el ejemplo se puede apreciar 10 nodos, 15 patrones de entrada, 4 neuronas de salida definida entre los nodos del 7 al 10.

Las conexiones la establecemos en la etiqueta CONNECTIONS, donde definimos las conexiones de las 15 neuronas de entrada con las 6 neuronas de la capa intermedia y así mismo de las neuronas intermedias a las neuronas de salida.

NODES:

nodes = 10

inputs = 15

outputs = 4

output nodes are 7-10

CONNECTIONS:

groups = 0

1-6 from i1-i15

7-10 from 1-6

SPECIAL:

selected = 1-6

weight_limit = 1.0

Diagrama de red neuronal:

Entrenamiento de la red:

Para configurar la red neuronal utilizamos los archivos DATA y TEACH, que nos permitirán ingresar a la red neuronal los valores de entrada y salida respectivamente.
Configuración archivo DATA:
Para cada digito representado se eligieron 5 ejemplos para el entrenamiento seleccionados de forma aleatoria, cada ejemplo tuvo una distorsión de 1 ó 2 bits como máximo, donde el primer ejemplo de cada digito representa el digito original.

0

1

111101101101111
111101000101111
111101100101111
111101101101110
011101101101111

010110010010010
010110010000010
010010010010010
000110010010010
001011001001001

2

3

111001111100111
111001111100110
111001111000111
011001111100111
111001011100111

111001011001111
011001011001111
111001010001111
101001011001111
110001011001111

4

5

101101111001001
000101111001001
001101111001001
101101101001001
101101111000001

111100111001111
111100111001101
111100111001110
011100111001111
111100110001111

6

7

111100111101111
111100111101101
111100111101110
110100111101111
111100111101011

111001010010010
111001011010010
011001011010010
111001010000010
111001000010010

8

9

111101111101111
111101111101111
101101111101111
111101010101111
111101110101111

111101111001111
111101111001011
011101111001111
111111111001111
111101110001111

Ejemplo de representación grafica de cada digito:

Configuración archivo TEACH:

Cada digito se represento de forma binaria, esto para poder realizar los 5 ejemplos de entrenamiento para cada digito.

0 0 0 0 = 0

0 0 0 1 = 1

0 0 1 0 = 2

0 0 1 1 = 3

0 1 0 0 = 4

0 1 0 1 = 5

0 1 1 0 = 6

0 1 1 1 = 7

1 0 0 0 = 8

1 0 0 1 = 9

Resultado del entrenamiento:

Una vez configurados los archivos DATA y TEACH se procede al entrenamiento de la red, en este caso realizamos entrenamientos de 10000 y 20000 iteraciones, obteniendo como resultado las siguientes graficas y valores correspondientes.

Para el caso de los entrenamientos vamos a considerar los valores arrojados de la siguiente forma: Para valores mayores 0,6 lo consideraremos como valor 1 y para valores menores a 0.6 lo consideraremos 0.

• Entrenamiento de la red con 10000 iteraciones:

Output activations

using red-10000.wts and red.data (Training Set)

0.074 0.000 0.012 0.005

0.035 0.000 0.007 0.062

0.084 0.000 0.009 0.005

0.058 0.001 0.012 0.022

0.075 0.000 0.007 0.032

0.013 0.029 0.000 0.997

0.025 0.002 0.000 0.977

0.041 0.015 0.045 1.000

0.036 0.003 0.000 0.978

0.095 0.000 0.066 0.919

• Entrenamiento de la red con 20000 iteraciones:

Output activations

using red-20000.wts and red.data (Training Set)

0.031 0.001 0.019 0.000

0.031 0.001 0.022 0.001

0.039 0.001 0.014 0.001

0.037 0.001 0.017 0.001

0.039 0.001 0.013 0.001

0.007 0.026 0.000 1.000

0.032 0.001 0.000 1.000

0.000 0.019 0.019 1.000

0.027 0.001 0.000 1.000

0.024 0.017 0.002 0.974

Prueba y verificación del entrenamiento:

Cada digito fue distorsionado de una forma diferente al entrenamiento que fue realizado, esto para verificar si su aprendizaje.

Para el digito cero 111101101101111, se aplico la siguiente nueva configuración:

111101101101100

Obteniendo como resultado los siguientes valores para 10000 y 20000 iteraciones:

Output activations

using red-10000.wts and red.data (Training Set)

0.184 0.007 0.026 0.003

Output activations

using red-20000.wts and red.data (Training Set)

0.009 0.007 0.009 0.004

Lo cual refleja los valores de las cuatro neuronas de salida representan el numero binario: 0 0 0 0 = 0, esto demuestra que para este ejemplo la red neuronal pudo reconocer el digito a pesar de la distorsión impuesta.

Para nuestro 2 ejemplo se utilizo el digito uno, 010110010010010 y se aplico la siguiente nueva configuración:

010110000010010

Obteniendo como resultado los siguientes valores para 10000 y 20000 iteraciones:

Output activations

using red-10000.wts and red.data (Training Set)

0.002 0.010 0.002 1.000

Output activations

using red-20000.wts and red.data (Training Set)

0.013 0.030 0.000 1.000

Lo cual refleja los valores de las cuatro neuronas de salida representan el numero binario: 0 0 0 1 = 1, esto demuestra que para este ejemplo la red neuronal pudo reconocer el digito a pesar de la distorsión impuesta.

De manera similar se realizaron pruebas para los siguientes dígitos obteniendo equivalentes resultados.

IMPLEMENTACIÓN DEL SOFTWARE

Interfaz del Software:
El Software implementado presenta una interfaz, la cual presenta una grilla de entrada, que permite ingresar el digito a evaluar, a su costado presenta la cadena de bit del digito ingresado que representa los valores de los patrones de entrada de la neurona.
Una vez ingresados los datos de entrada y al presionar el botón Reconocer, automáticamente se generan los datos de salida correspondiente al digito evaluado, esto es en la grilla salida.

Código del Software:

Los valores que ocupa el programa se guardaran en las siguientes estructuras

Los valores de entrada se guardan en un vector entrada (1 to 10).

Ls valores de la neuronas se guardaran en una matriz llamada cap1(10,15) , donde el primer índice representa la neurona y el segundo índice representa los pesos de entrada

Estos valores se rescatan del archivo red-20000.wts ingresándolo de la siguiente forma:

' datos entrada neurona 1

cap1(1, 0) = -1.0992292166

cap1(1, 1) = 0.2268614322

cap1(1, 2) = 3.3533549309

‘datos entrada neurona 2.

El cálculo de los valores de las neuronas se realiza mediante la suma de la multiplicación del valor de entrada por el peso de la neurona + el peso del bias

‘sumatoria del las entradas de la neurona

For i = 0 To 6

For j = 1 To 15

valor(i) = valor(i) + cap1(i, j) * entrada(j)

Next j

Next i

‘ suma del bias que se encuentra en la posición 0 del la matriz cap1()

valor(1) = cap1(1, 0) + valor(1)

valor(2) = cap1(2, 0) + valor(2)

valor(3) = cap1(3, 0) + valor(3)

valor(4) = cap1(4, 0) + valor(4)

valor(5) = cap1(5, 0) + valor(5)

valor(6) = cap1(6, 0) + valor(6)

Finalmente se le aplica la función sigmoidea para la salida de cada neurona

For i = 1 To 6

valor(i) = sigmoidea(valor(i))

Next i

Para las neuronas de salida es la suma de la multiplicación de el valor de salida de la capa escondida por el peso de la neurona

For i = 7 To 10

For j = 0 To 6

valor(i) = valor(i) + cap1(i, j) * valor(j)

Next j

Next i

Algoritmo genérico para formulas de aproximación por diferencias

2009-09-27T10:09:00.000-07:00

Bueno este Post es de una tarea que me toco hacer del ramo de Calculo Numérico de Ingeniería civil en Computación de la Universidad Arturo Prat, Iquique, decidí compartirlo ya que lo encuentro muy útil, este algoritmo permite evaluar la derivada de cualquier orden de una función en un punto....aquí va...

Fundamento teórico

Este algoritmo describe un forma general para la obtención de formulas de aproximación por diferencia de una derivada de orden n, estableciendo un número de puntos requeridos m dependiendo de la precisión que se busca.

Si tenemos m puntos en un sub – intervalo, enumerados en , donde y n el orden de la derivada. Las abscisas de los puntos de la retícula son con.

Por tanto la aproximación por diferencias de la derivada de orden n conm puntos se expresa:

O bien.

(1)

En donde hasta son los m coeficientes indeterminados; son las coordenadas que se usarán y E es el máximo error de la aproximación, que se escribe como.

(2)

Una vez obtenido la formula (1) de aproximación por diferencias dado un orden n y m puntos, se sustituye en esta ecuación por los desarrollos de Taylor de, para así calcular los coeficientes indeterminados de forma que el término E sea el máximo orden posible.

Para efectos de este Post simplificaremos la expresión para obtener una mejor conceptualización del desarrollo, supondremos. Entonces la ecuación (1) queda.

(3)

En donde son los tres coeficientes indeterminados y son los puntos de la retícula que se utilizarán. Sustituimos los desarrollos dealrededor de x en la ecuación (3).

Reagrupando…

(4)

La ecuación (4) contiene tres coeficientes indeterminados, los cuales se pueden definir mediante tres condiciones formando un sistema. Para minimizar el error de la ecuación (4), hacemos los coeficientes de iguales a 0, 1, 0 respectivamente, debido a que el único termino existente es , que es la derivada buscada, por tanto el sistema nos queda de la siguiente manera:

(5)

Una vez resuelto el sistema anterior obtendremos los valores de los tres coeficientes indeterminados, los cuales son:

Una vez encontrado estos valores se sustituyen en la ecuación (3) y obtendremos finalmente la ecuación por diferencias para nuestro caso en particular, dondedonde la derivada aproxima a cualquier función f(x) alrededor de x.

Por otro lado, los términos no nulos de la ecuación (4) constituyen el error.

(6)

Al comparar las ecuaciones (2) y (6) obtenemos que:

De lo que se obtiene, sustituyendo

Debido a que el primer término del error no es nulo, ecuación (6), ignoramos el segundo término y escribimos el término del error como:

En el caso en que el primer término del error se anule, el segundo término pasará a representar el error.

Resolución del algoritmo genérico en Maple

Una vez planteado el fundamento teórico del algoritmo genérico para la obtención de formulas de aproximación por diferencia de una derivada de orden n, desarrollaremos un programa basado en Maple que nos permita utilizar dicho método.

Basándonos en m como el número de puntos en la retícula y con n como orden de la derivada, nos basaremos en la siguiente ecuación.

Donde utilizaremos los desarrollos de Taylor para los m términos, donde son los m puntos, estos puntos necesitaremos almacenarlos en un vector que llamaremos V[m] de largo m, quedando:

Donde cada uno de estos elementos se reemplaza por la serie de Taylor correspondiente, donde se almacenaran en una columna de una matriz, quedando de la siguiente manera:

Cada termino de Taylor se truncara hasta el termino m, donde los términos m + 1 y m + 2

Se utilizaran para el cálculo de error, nótese que en la matriz sólo se almacena el término que acompaña a cada derivada de la serie.

Con lo que podemos observar que cada fila corresponde al argumento los cuales corresponden a los argumentos principales, y las columnas corresponden a los a1,…,aL que serán los argumentos a agrupar.

Con esta idea podremos construir nuestro sistema de ecuaciones, multiplicando por el coeficiente propio de la formula anterior y ampliando nuestra matriz a .

Expresada como:

Ahora generaremos el código Maple para poder ingresar estos valores descritos a la matriz MA [ ] Procedimiento para ingresar valores a la matriz MA [].

For i from 1 to m do

For j from 1 to m do

MA [j,i]:=(V[i]*h)^(j-1)/(j-1)!*(1/h^n);

od;

MA [n+1,m+1]:=1;

En donde la matriz que contiene los coeficientes dese expresa:

En donde los términos del error se guardan en un vector e[] de dimensión 2 :

Procedimiento para ingresar los valores al vector e[]

V[1]:=0: V[2]:=1: V[3]:=2;

e[1]:=0;

e[2]:=0;

For i from m+1 to m+2 do

For j from 1 to m do

e[i-m]:=e[i-m]+a[j]*(V[j]*h)^(i-1)/(i-1)!*(1/h^n);

od;

Una vez ingresadas las dos matrices se procede a su cálculo, para calcular la matriz MA[]

utilizaremos el comando LinearSolve, de la siguiente manera

a:=LinearSolve(MA);

Para calcular la expresión del error comprobamos si el primer término es nulo

if e[1]=0 then;
E=e[2]*(D@@L)(f);
else;
E=e[1]*(D@@L)(f);
end if;

Utilización del programa

Para comenzar a utilizar el programa se debe ingresar la instrucción Maplets[Display](maplet), esta instrucción mostrarla pantalla de presentación

Que nos dara la opción de ir a la ventana de entrada de valores, esta ventana nos dara la opción de ingresar los valores de la derivada, los puntos la función, y el valor del h que por defecto es 0.005, luego nos salimos de la ventana de ingreso de valores y con el comando, Maplets[Display](mostrar):, inicializamos la ventana de los resultados,

que mostrara la formula de error y derivada, y la evaluación en los puntos correspondientes.

ahí va el código completo.....

Diferenciación Numérica Polinomios de Taylor

> restart;

> with(LinearAlgebra):

> AproxDiferencia:= proc(p,L,LI,F,X,H)

> local i,j,expresion,E,B,e,a,f,fp,fe,po,po1;

> B:=Matrix(L,L+1);

> e:=Vector(2); # Verctor de coeficientes de error

> for i from 1 to L do

> for j from 1 to L do

> B[j,i]:=(LI[i]*h)^(j-1)/(j-1)!*(1/h^p); # 'LI' es el valor del punto de la reticula

> od;

> B[p+1,L+1]:=1;

> a:=LinearSolve(B);

> f:=unapply(F,x);

> expresion:=sum('a[k]*f(x+LI[k]*h)','k'=1..L)/h^p;

> e[1]:=0;

> e[2]:=0;

> for i from L+1 to L+2 do

> for j from 1 to L do

> e[i-L]:=e[i-L]+a[j]*(LI[j]*h)^(i-1)/(i-1)!*(1/h^p); # 'LI' es el valor del punto de la reticula

> od;

> if e[1]=0 then;

> E:=e[2]*diff(f(x),x$p);;

> else;

> E:=e[1]*diff(f(x),x$p);;

> end if;

> fp:=unapply(expresion,x,h); Maplets:-Tools:-Set( 'visor' = MathML[Export](expresion));

> fe:=unapply(E,x,h); Maplets:-Tools:-Set( 'visor2' = MathML[Export](E));

> po:=fp(X,H);Maplets:-Tools:-Set( 'TF9' = evalf(po) );

> po1:=fe(X,H);Maplets:-Tools:-Set( 'TF10' = evalf(po1) );

> print(evalf(po));

> print(evalf(po1));

> print(E);

> end proc:

> with(Maplets[Elements]):maplet1:= Maplet([["Orden de la Derivada: ", TextField['TF1'](5)],

> ["Numero de Puntos: ", TextField['TF2'](5)],

> ["Puntos: ",TextField['TF3']("\[,\]",10)],

> ["Funcion: ",TextField['TF4'](10)],

> ["Punto a evaluar - x:",TextField['TF5'](8)],

> ["Amplitud h: ",TextField['TF6']("0.005", 10)],

> ["Ecuacion de la Derivada: "],

> [MathMLViewer( 'reference'='visor')],

> ["Error: "],

> [MathMLViewer( 'reference'='visor2')],

> ["Valor Derivada: ",TextField['TF9'](10)],

> ["Valor Eror: ",TextField['TF10'](10)],

> [Button("Derviar por Diferencias", Evaluate('function' = 'AproxDiferencia(TF1,TF2,TF3,TF4,TF5,TF6)')), Button("Salir", Shutdown(['TF1']))

> ]]):

> Maplets[Display](maplet1);

Patrones GRASP y GoF

2009-09-26T12:39:00.000-07:00

Bueno mi primer post lo quiero dedicar a mi memoria de titulo, este trabajo quedo seleccionado para el congreso CISAISI 2009, que se realizará en el mes de Octubre en Arica, link del articulo http://docs.google.com/fileview?id=0B2Jao3HNql2FZTVhNmU2Y2ItOGU0ZS00ZGQ2LWI2MjMtYjMyMWNiNTI1NmJl&hl=en. me pareció interesante compartirlo en mi Blog, este trabajo presenta la integración de patrones de diseño y aplicaciones móviles, en el desarrollo de un software de gestión de placas (SIGEP) que permite apoyar en las soluciones a problemáticas que se presentan en el proceso de mantención de placas de cátodos de cobre de una Compañía Minera, en mi caso para Quebrada Blanca S.A. (CMQB S.A.). Las problemáticas principalmente se relacionan con el escaso control sobre las tareas realizadas en las mantenciones a las placas catódicas, y la carencia de información que conlleva esta práctica, origina una gestión deficiente y no permite tomar decisiones oportunas referente a estos elementos, y por ende no permite proyectar y administrar la vida útil de las placas de cátodos, generando elevados costos asociad o s a este proceso. Al ser el proceso de mantención de placas de cátodo un proceso en constante cambio, con respecto a las estrategias de mantención, en el diseño del sistema SIGEP se valora la flexibilidad y reutilización en el diseño de los componentes del sistema, esto se logra gracias a los patrones de diseño utilizados. La implementación del sistema SIGEP y la incorporación de una aplicación móvil, significó para CMQB S.A. aumentar la fiscalización de las tareas realizadas a las placas de cátodos, permitiendo a la compañía contar con información detallada de las mantenciones de estos elementos, lo que permite entre otras cosas, identificar cuales placas de cátodo son más costosas par a la compañía y por tanto, conocer cuáles deben ser reemplazadas.

INTRODUCCIÓN

Actualmente el proceso productivo de la planta de electrobtención de la Compañía Minera Quebrada Blanca S.A. (CMQB S.A.) trabaja con placas de cátodos de cobre, las cuales a través de un proceso de diferencial de potencial eléctrico, logran la adhesión de las moléculas de cobre que se encuentran en la solución en la cual están sumergidos. La Superintendencia de Planta de CMQB S.A., cuenta con alrededor de 16.000 placas catódicas en operación, las cuales se someten a mantenciones diarias y mensuales, éstas consisten en el pulido y limpieza de las placas de cátodos de cobre. Las placas catódicas a lo largo de su vida útil, muestran variaciones de costos respecto a sus mantenciones, debido a una infinidad de variables, como la calidad de la mantención o el deterioro de éstas. Las placas de cátodos que han excedido su vida útil, son más costosas para la compañía, debido a que requieren ingresar a mantención con mayor frecuencia, por lo tanto, identificar estas placas de cátodos y reemplazarlas por placas nuevas será muy útil para reducir el costo por este concepto.

Asimismo, llevar un adecuado historial y control de estas mantenciones permitirán a la compañía entre otras cosas, anticiparse al término de la vida útil de la placa catódica, conocer que placas demandan mayor costo de mantención y por lo tanto, conocer cuáles deben ser reemplazadas, lo que ahorrará a la compañía tiempo y dinero por concepto de mantenciones de este elemento. Contar con este software que cubra esta necesidad de información, le ha permitido a CMQB S.A., tener información clara, persistente, oportuna y automática para tomar correctas decisiones relacionadas con las mantenciones de las placas catódicas. Se realizan en promedio entre 200 y 250 mantenciones de placas catódicas por día, para asegurar el correcto funcionamiento de este proceso, el operador fiscaliza en terreno estas mantenciones, para ello requiere registrar la información de estos trabajos al instante en que se realiza esta actividad, por este motivo se decide integrar una interfaz móvil del software que permita al operador, realizar la toma de datos en línea en la misma faena, y así asegurar una correcta supervisión de las tareas realizadas a las placas de cátodos de cobre por concepto de mantenciones. El proceso que se lleva a cabo en faena para la mantención de las placas catódicas, comienza cuando el operador placa decide, de acuerdo al estado de las placas, que tipo de tareas de mantención necesita, mantención mayor, para placas muy deterioradas y mantención menor, para placas con menor deterioro. Las placas de cátodo reparadas se almacenan en un stock de placas disponibles a la espera de ingresar a producción, se puede representar este proceso, mediante el siguiente diagrama que muestra la figura 1:

Figura 1. Diagrama del proceso de gestión de mantenciones placas catódicas.

El desarrollo de este software de Gestión de Mantenciones de Placas Catódicas, de ahora en adelante SIGEP, se basa principalmente en el diseño orientado a objetos bajo la asignación de responsabilidades. Uno de los objetivos que se buscan al utilizar esta técnica es conseguir la reutilización de software. Para esto, se han identificado y utilizado patrones de diseño, que hoy son un mecanismo efectivo de reutilización, y se han convertido en una técnica popular para el re-uso de conocimiento en el diseño de software, adicionalmente, para apoyar y agilizar el proceso de control y gestión de mantenciones de las placas de cátodos de cobre en terreno, se han integrado herramientas móviles para facilitar la toma de datos en línea dentro de la faena misma.

DISEÑO DE SIGEP CON PATRONES GRASP

La siguiente sección muestra las elecciones y decisiones tomadas durante el diseño para la realización de los casos de usos con objetos basado en los patrones GRASP [5]. Lo esencial de un diseño de objetos lo constituye el diseño de las interacciones de objetos y la asignación de responsabilidades. Las decisiones que se tome n pueden influir profundamente en la extensibilidad, claridad y mantenimiento del sistema de software de objetos, además en el grado y calidad de los componentes reutilizables. El modelo de dominio, no representa clases de software, pero se puede utilizar para inspirar la presencia y los nombres de algunas clases de software en el modelo de diseño. Por lo tanto, se crea un diseño con una representación más baja entre el diseño del software y la percepción del dominio del mundo real con el que el software está relacionado. Para crear un modelo de dominio de clases conceptuales interesantes o significativas del dominio de interés, en este caso la gestión de placas de cátodos de cobre, la tarea central es, identificar las clases conceptuales relacionadas con el escenario que se está diseñando. A continuación se presenta una lista de categorías de clases conceptuales, la lista está restringida al escenario simplificado de gestionar placas de cátodos y gestionar mantenciones de placas de cátodos.

Placas
Mantención
Tareas
Estados
Empresa
Operador Placa

El modelo de dominio, representado en la figura 2, muestra a Operador Placa, como responsable de gestionar las placas de cáto dos, iniciar una mantención y designar el tipo de tareas a realizar en la mantención de las placas de cátodos.

Figura 2. Modelo de Dominio Gestión Mantenciones Placas

Dado este modelo de dominio restringido al proceso de mantención de placas de cátodos, se identificaron dos casos de usos principales, Gestionar Placas y Gestionar Mantenciones, tal como se puede observar en el siguiente diagrama de casos de uso.

Figura 3. Diagrama de Casos de uso

La primera elección de diseño comprende la elección del controlador para los mensajes de operación del sistema RegistrarNuevaPlaca, Cambiar Posición, Dar Baja Placa, Crear Mantención y Eliminar Mantención.

Es aceptable elegir un controlador de fachada como una única clase, si sólo hay pocas operaciones del sistema y el controlador no está asumiendo demasiadas responsabilidades, en otras palabras, si va a perder la cohesión. Es adecuado elegir un controlador de caso de uso cuando hay muchas operaciones del sistema y deseamos distribuir las responsabilidades con el fin de mantener a cada clase controladora ligera y centrada, es decir cohesiva. En este caso, se utilizará una clase, puesto que sólo hay unas pocas operaciones del sistema.

Consultando el modelo de dominio, OperadorPlaca es un buen candidato para ser la clase controladora. Por tanto, el diagrama de interacción que se muestra en la figura 4 comienza enviando los mensajes Registrar Nueva Placa, Cambio Estado, Dar Baja Placa, Crear Mantención y Eliminar Mantención al objeto software OperadorPlaca.

Figura 4. Aplicación del patrón GRASP Controlador.

Para el diseño de objetos, se debe crear un nuevo objeto software Placa, y el patrón GRASP Creador sugiere la asignación de la responsabilidad de creación a la clase que agrega, contiene o registra el objeto que se va a crear.

Por tanto, el OperadorPlaca es un candidato razonable para crear un objeto Placa. Según el mundo real el Operador Placa es el responsable de registrar, dar de baja y cambiar la posición de un placa de cátodo de cobre, por tanto es un experto en información en estas actividades y sería razonable que el objeto software OperadorPlaca fuera el responsable de estas funcionalidades.

Figura 5. Diagrama de Secuencia Gestionar Placas

Para Gestionar Mantención, se asume la necesidad de crear las instancias: Placas, Tareas y Estados y asociarlas a Mantención. ¿Qué clase debería ser responsable de esto?. Puesto que un operador placa registra una nueva mantención en el domino del mundo real, el patrón Creador sugiere a OperadorPlaca como candidata para la creación de Mantención. La instancia OperadorPlaca podría enviar entonces el mensaje añadir Tareas, añadir Estados, añadir Placa a mantención, pasando la nueva Tarea, Estado y Placa como parámetros. La figura 6 muestra un primer diagrama de secuencia que refleja esto.

Figura 6. Operador Placa crea Placa, Estados y Tareas

Esta asignación de responsabilidades acopla la clase OperadorPlaca con el conocimiento de la clase Placa, Estados y Tareas.

Otra alternativa de diseño sería que la clase Mantención se encargue de crear las instancias Placa, Estados y Tareas, tal como lo muestra la figura 7, que describe esta alternativa.

Figura 7. Mantención crea Placa, Estados y Tareas

¿Qué diseño, basado en la asignación de responsabilidades, soporta bajo acoplamiento?. En ambos casos se asume que la Mantención debe acoplarse con el conocimiento de Placa, Tareas y Estados. El diseño uno, en el que OperadorPlaca crea Placa, Estado y Tareas, añade acoplamiento entre OperadorPlaca y Placa, Estado y Tareas, mientras que el diseño dos, en el que Mantención crea estas instancias, no incrementa el acoplamiento. Desde el punto de vista puramente del acoplamiento, es preferible el diseño dos porque mantiene el acoplamiento global más bajo.

DISEÑO DE SIGEP CON PATRONES GoF

El siguiente problema de diseño a resolver es proporcionar una lógica más compleja para crear una mantención, como crear una mantención de una placa de cátodo de cobre siempre y cuando esta placa no exceda el límite máximo de costos de mantención (punto crítico) o ya tenga una mantención en la misma fecha.

Es probable que más adelante puedan surgir nuevas restricciones al proceso de mantención como por ejemplo, no realizar mantención a placas de cátodo de cobre con estado pandeado[1] u otras variaciones.

Debido a esto, nos plateamos la siguiente cuestión ¿Cómo diseñar los diversos algoritmos de restricciones de mantención?

Una alternativa fue usar el Patrón GoF Estrategia [4], puesto que la restricción de la mantención varía según la estrategia (o algoritmo), se crean múltiples clases EstrategiaCriterio, cada uno con un método polimórfico getCriterio. A cada método getCriterio se le pasa como parámetro el objeto Placa, de manera que el objeto de la estrategia de restricción de mantención pueda encontrar el algoritmo adecuado. La implementación de cada getCriterio será diferente.

Figura 8. Patrón Estrategia

Un objeto estrategia se conecta a un objeto de contexto, el objeto al que se aplica el algoritmo. En este caso, el objeto de contexto es una Placa.

Existen diferentes algoritmos o estrategias de mantención, y cambian con el tiempo, aquí surge la interrogante ¿quién debería crear la estrategia?. Un enfoque directo es aplicar el patrón Factoría. La clase Factoría Singleton, contiene como parámetros de creación el tipo de estrategia a utilizar. La figura 9 muestra esta alternativa de diseño.

Figura 9. Factoría Singleton Mantención

El patrón Estrategia nos lleva al siguiente problema. ¿Cómo gestionar el caso de varias políticas de restricciones de mantención?. Por ejemplo aplicar restricción de fecha y punto crítico a la vez, ó las placas con estado pandeado pueden tener más de una mantención diaria, ó las placas con cierto estado no pueden tener mantención, etc.

¿Hay alguna forma de cambiar el diseño de manera que el objeto Placa no conozca si está tratando con una o más estrategias, y ofrecer también un diseño para la resolución de políticas contradictorias?.

Una buena solución a este problema es agregar al patrón GoF Estrategia, el patrón GoF Composite.

Figura 10. Patrón Estrategia, Composite, Factory y Singleton.

Con el patrón Composite, se ha creado un grupo de diferentes estrategias de restricción de mantención, que para Placa aparecen como una única estrategia.

En la etapa de requerimientos se definieron sólo dos restricciones de mantención de placas de cátodo de cobre, con este diseño se busca que la implementación de nuevos criterios de mantención a distintos elementos del sistema sea de forma fácil y poco traumática para los demás componentes del sistema.

DISEÑO DEL FRAMEWORK

El software SIGEP, requiere que se almacene y recupere la información en mecanismos de almacenamiento persistente, como una base de datos relacional. Por tanto se necesita un servicio de persistencia que se construya con un FrameWork de Persistencia (FWP). Este es un framework simplificado que deberá proporcionar funciones para almacenar y recuperar los objetos en un mecanismo de almacenamiento persistente.

Las características esenciales del diseño de los conversores de base de datos, que constituyen una parte central del FWP, se basan en el patrón de diseño GoF Template Method (método plantilla). Este patrón es una parte esencial del diseño del framework, de manera más específica, los frameworks de caja blanca. Normalmente éstos son frameworks orientados a la definición de subclases y jerarquías de clases, que requieren que los usuarios conozcan algo acerca de su diseño y estructura, de ahí lo de caja blanca [7].

La idea es crear un método (método plantilla) en una superclase que define el esqueleto de un algoritmo, en sus partes variables e invariables. El Método Plantilla invoca otros métodos, algunos de los cuales podrían redefinirse en una subclase. El punto de variación es la manera de crear el objeto a partir del almacenamiento. El método get será el método plantilla en una superclase abstracta ConversorPersistenciaAbstracto que define la plantilla, y utiliza un método “de enganche” en las subclases para la parte que varía, como se ilustra en la figura 11:

Figura 11. Conversor de datos con el Método Plantilla.

ARQUITECTURA LÓGICA CON PATRONES

El sistema SIGEP está compuesto de muchos paquetes lógicos, como un paquete de interfaz de usuario, un paquete de acceso a base de datos, etc. Cada paquete agrupa un conjunto cohesivo de responsabilidades. Esta es la práctica básica de aplicar la modularidad para dar soporte a la separación de intereses.

El patrón Capas se relaciona con la arquitectura lógica, es decir, describe la organización conceptual de los elementos del diseño en grupos, independiente de su empaquetamiento o despliegue físico.

Las capas definen un modelo general de N-niveles para la arquitectura lógica, que produce una arquitectura en capas. Basado en el arquetipo de las capas comunes en una arquitectura lógica de un sistema de información, se ilustra en la figura 12 la arquitectura lógica en capas parcial de la aplicación SIGEP.

Figura 12. Vista lógica de las capas del sistema SIGEP.

El principio de Separación Modelo-Vista, es clave en el patrón Modelo-Vista-Controlador (MVC). Donde el Modelo es la Capa de Dominio, la Vista es la Capa de Presentación, y el Controlador son los objetos del flujo de trabajo en la Capa de Aplicación, que establece que los objetos del dominio no deberían conocer directamente a los objetos de la vista o presentación.

Este principio mantiene que las clases del dominio encapsulan la información y el comportamiento relacionado con la lógica de la aplicación. Las clases de las ventanas son relativamente delgadas, responsables de la entrada y salida, y capturan los eventos del UI (User Interface), pero no mantienen datos ni proporcionan directamente ninguna funcionalidad de la aplicación.

Figura 13. Separación Modelo-Vista.

En el sistema SIGEP las ventanas envían mensajes a la clase operador, consultando sobre la información que luego mostrarán como elementos gráficos, manteniendo así este principio.

INTEGRACIÓN DE HERRAMIENTAS MÓVILES

Para la implementación de SIGEP, se utilizó la plataforma Visual Studio.NET 2003. Este ambiente de desarrollo, tiene un completo conjunto de herramientas para construir aplicaciones Web en ASP, Servicios Web XML, aplicaciones para computadores personales y aplicaciones para dispositivos móviles.

La aplicación móvil se implementó en dispositivos Intermec CK61 (figura 14). Estos equipos móviles son para uso industrial, son terminales recolectores de datos intermec, con gran potencia, fuerza y velocidad: El Terminal portátil CK61 de Intermec cumple todas las exigencias de los entornos más duros, es decir para condiciones climáticas y ambientales más exigentes. La batería tiene capacidad para funcionar durante todo el día y el diseño robusto del Terminal proporciona un funcionamiento fiable durante años. El procesador y el sistema operativo de nueva generación permiten ejecutar aplicaciones complejas. El almacenamiento no volátil protege la información importante.

Figura 14. Equipo Intermec CK61

Estos equipos se configuraron y utilizaron para la toma de datos en línea, dentro de la faena de las mantenciones de las placas catódicas, en este equipo los operadores ingresan los datos de identificación de la placa, empresa que realiza la mantención, el estado en el que llegó la placa y las tareas de mantenciones a realizar (figura 15).

Figura 15. Pantalla ingreso de mantenciones

Para el acceso móvil al sistema, se implementó una red inalámbrica en el taller de reparaciones de las placas de cátodos de cobre, a través de la cual se integran los equipos clientes móviles Ck61 Intermec.

La figura 16 muestra la disposición de las particiones físicas del sistema SIGEP y la asignación de los componentes software a estas particiones, lo cual también permite visualizar la integración de las compenentes móviles al software SIGEP.

Figura 16. Integración de las componentes móviles al SIGEP.

ANALISIS DE RESULTADOS

Desde el punto de vista operacional de gestión, la información muy útil que proporciona SIGEP, es el detalle del historial de las mantenciones de las placas catódicas y conocer cuáles de ellas genera mayores costos para la compañía como se aprecia en la figura 17.

Con SIGEP y su operación en línea del control de las mantenciones, se obtuvo el manejo exhaustivo de todos los datos que se generan en este proceso.

Figura 17. Listado de placas con mayor costo de mantenciones

Desde punto de vista y objetivo de la reducción de los costos, para la empresa, en la operación de seis meses del software la empresa logró reducir sus costos de mantención en comparación con el periodo anterior en el mismo semestre, en cerca de 15%, debido a que el sistema arroja información que permite anticipadamente tomar decisiones acerca del recambio de las placas con mayor deterioro, o seguir una apropiada mantención de estas.

Respecto al desempeño técnico del sistema, se observó un rendimiento óptimo en cuanto a la comunicación y tiempos de respuestas, entre los clientes fijos y móviles, respecto a las interacciones con el servidor y la base de datos, aunque desde un punto de vista solamente cualitativo, porque no se hicieron mediciones al respecto por lo que datos cuantitativos sobre este aspecto no es posible entregar.

CONCLUSIONES

En el desarrollo de este trabajo, se persiguió dar solución a las problemáticas puntuales que tiene la superintendencia de planta de CMQB S.A., respecto a las mantenciones de las placas de cátodos de cobre, en lo que se refiere a llevar un adecuado control y seguimiento de las tareas realizadas a estos elementos y así evitar posibles cobros y costos excesivos debido a la desinformación existente.

En este aspecto SIGEP cumple con el objetivo de entregar información relevante que permite llevar un adecuado control de las tareas realizadas a las placas catódicas, lo que ha permitido hasta el presente, disminuir las tareas realizadas a las placas de cátodo de cobre hasta el punto de reducir en un turno los trabajos realizados por este concepto.

La utilización de patrones de diseño en SIGEP permitió establecer y otorgarle flexibilidad en el diseño, independiente y extensible en el tiempo, al separar la interfaz y el diseño, esta separación hizo más fácil la creación y reutilización de código.

Además, al utilizar patrones se tornó más fácil documentar los detalles del diseño y como reutilizar la aplicación. Así también, se comprobó que son diseños muy efectivos y eficientes, ampliamente demostrados por la experiencia de otras personas y que ayudan a construir software correctamente.

De esta manera, se logró el objetivo de crear una aplicación de fácil entendimiento, modificación o adaptación del diseño por terceras personas, lo cual fue un requerimiento específico de la superintendencia de planta de la CMQB S.A.

El framework construido para SIGEP, es una solución breve a los problemas y soluciones de diseño de un framework y servicios de persistencia. Se han encubierto muchas puntos importantes como: seguridad, acceso multiusuario, estrategias de bloqueo, y gestión de errores.

Para el presente año, se contempla iniciar la renovación de unas cinco mil placas de cátodos para la CMQB S.A., por lo que el sistema SIGEP se convierte en una poderosa herramienta para decidir cuales placas de cátodos son las que deben ser reemplazadas de acuerdo a sus costos de mantención.

REFERENCIAS

[1] G. Booch, J. Rumbaugh, y I. Jacobson. El Lenguaje Unificado de Modelado. Madrid: ddison Wesley Iberoamericana, 1999.

[2] W. R. Greiff. “Paradigma vs Metodología; El caso de la POO (Parte II)”. Soluciones Avanzadas, 1994.

[3] L. Bass, P. Clements y R. Kazman, “Software Architecture in Practice”, Addison- Wesley, 1998.

[4] E. Gamma, R. Helm, R. Johnson y J. Vlissides, “Design Patterns: Elements of Reusable Object-Oriented Software” (Gang of Four, [GoF]). Addison-Wesley Professional Computing Series. [GoF95], 1995.

[5] C. Alexander, S. Murria, M. Jacobson, I. Fiksdahl-King, y S. Angel, “A pattern Language: Towns/Building/Construction”. Oxford University Press, 1977.

[6] C. Larman, “UML y Patrones, Una introducción al análisis y diseño orientado a objetos y al proceso unificado”; Prentice Hall, 2002.

[7] M. Fowler, “Patterns of Enterprise Application Architecture”, Adison Wesley, 2003.

Simplemente yo

2008-10-07T15:33:00.001-07:00

Hola, mi nombre es Oscar Andrés Sandoval Carlos. Me gradué de Ingeniero Civil en Computación en la Universidad Arturo Prat, Iquique, Chile.

Ahora estoy trabajando en ZOFRI S.A para el proyecto SVE. Luego me gustaría estudiar un MBA o un Magister en TI

0	1
111101101101111 111101000101111 111101100101111 111101101101110 011101101101111	010110010010010 010110010000010 010010010010010 000110010010010 001011001001001
2	3
111001111100111 111001111100110 111001111000111 011001111100111 111001011100111	111001011001111 011001011001111 111001010001111 101001011001111 110001011001111
4	5
101101111001001 000101111001001 001101111001001 101101101001001 101101111000001	111100111001111 111100111001101 111100111001110 011100111001111 111100110001111
6	7
111100111101111 111100111101101 111100111101110 110100111101111 111100111101011	111001010010010 111001011010010 011001011010010 111001010000010 111001000010010
8	9
111101111101111 111101111101111 101101111101111 111101010101111 111101110101111	111101111001111 111101111001011 011101111001111 111111111001111 111101110001111