Porqué a los Motores de Persistencia se les llama así

Un motor de persistencia es un tipo de software especial que entra dentro de la categoría de software de mapeo de variables. La función de estos tipos de software puede ser comparada a un dibujante en escala que ubica los elementos del dibujo cuadrado a cuadrado en dos tamaños proporcionales diferentes.

Aunque los llamados "motores de persistencia" pueden aplicarse o no a la  programación orientada a objetos, usualmente es con esta última que se les suele asociar. De esa forma, se entiende un motor de persistencia como un intermediario cuya función es convertir los datos almacenados en una estructura de datos en memoria temporal (objeto en RAM) en una estructura de datos en memoria permanente (base de datos en disco duro). Donde los valores de los campos de una base son equivalentes a los valores de las propiedades del objeto y viceversa.

La siguiente figura ilustra lo anterior:

A propósito del significado del nombre "motor de persistencia" valga recordar que en informática el vocabulario técnico está asociado en ocasiones con símiles de la vida no informática (red, web,  registro, etc). El término "motor de persistencia" es una traducción del referente "persistence engine" donde:

Engine (Motor): Hace referencia al hecho que un motor "convierte" en forma contínua la energía generada por la combustión interna en movimiento mecánico.

Persistence (Persistencia): El verbo "persistir" se puede asociar también al verbo "mantener". Precisamente porque, como ya se explicó anteriormente, un motor de persistencia convierte en "permanentes" los datos almacenados en un objeto de memoria temporal.

Si juntamos ambos significados interpretamos que este tipo de software permite almacenar "ipso facto" los datos nuevos que lleguen al objeto mientras el programa que lo genera está en ejecución.

Blog Docente - Investigativo by Ing. Joaquín Bolaños is licensed under a Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported License.
Creado a partir de la obra en http://blogdocente-investigativo.blogspot.com.

Objetos Virtuales de Aprendizaje y la Herencia de Métodos

Los objetos virtuales de aprendizaje (LVA por sus siglas en inglés) se han convertido en una opción alternativa al portafolio de cátedra que los docentes utilizaban y aún ocupan. Es un hecho que dentro de una sesión de clase se utilizan diversas estrategias y herramientas, algunas han sabido mantenerse a través del tiempo como lo son la exposición oral, las demostraciones en vivo, los exámenes de palabra o escritos. 

Por otra parte, dichas técnicas y herramientas han hallado uso independientemente del área del conocimiento del cual se trate la clase. Por ejemplo la clase expositivo puede ser abordada ya sea en una clase de matemática como en una de filosofía o informática. Otras técnicas quizá se apeguen más a la naturaleza de la asignatura como es la litigación oral en la carrera jurídica y las guías de ejercicios en las materias numéricas. 

A partir de lo anterior, es posible hacer un símil con los conceptos de herencia y sobreescritura de métodos del paradigma de orientación a objetos de desarrollo de software: 

Si todas las asignaturas aplica técnicas:

     La asignatura A aplica técnicas comunes y propias. 

     La asignatura B aplica técnicas comunes y propias. 

Lo anterior puede representarse en UML como sigue: 

Y colocando nombres a las clases a manera de ejemplo: 

Los LVA aprovechan esta idea para incluir en unidades encapsuladas: 

 - Programación del curso y objetivos 

 - Contenidos 

 - Técnicas y Herramientas 

 - Evaluaciones 

Es decir, estamos ante una aplicación de la reutilización de software. ¿Podríamos llamarlo también reutilización de la enseñanza-aprendizaje?

Blog Docente - Investigativo by Ing. Joaquín Bolaños is licensed under a Creative Commons Reconocimiento-NoComercial-SinObraDerivada 3.0 Unported License.
Creado a partir de la obra en http://blogdocente-investigativo.blogspot.com.

El Logaritmo

Se le llama logaritmo base n de un número A a la potencia a la cual debe elevarse dicha base n para obtener el número A. Es la operación inversa de la potenciación.

Si nos preguntaran: ¿Cuánto es 4 elevado al cuadrado, es decir, 4^2. Mentalmente multiplicamos 4 dos veces por sí mismo y respondemos: 16.

En cambio, si nos preguntaran: ¿A qué número debemos elevar 4 para que nos dé como resultado 16?, la operación comúnmente es un poco más difícil, ya que implica que el cerebro debe pensar a la inversa. Aunque para este ejemplo, es sencillo: Lo que nos preguntan es el logaritmo base 4 de 16, la respuesta como ya sabemos, es 2; porque 4^2 = 16.

Un empleo común de los logaritmos se da cuando se trabaja con fórmulas de interés compuesto, anualidades, pago a plazos, donde se necesita encontrar valores de exponentes. Antes que las calculadores científicas de bolsillo alcanzaran popularidad, los logaritmos se encontraban con ayuda de tablas, las cuales podían abarcar varias páginas.

Las calculadoras científicas actuales incluyen obligatoriamente la funcionalidad de c6aacute;lculo de logaritmos. Por lo general, permiten calcular dos tipos:

1) El logaritmo cuando la base es 10. Por ejemplo, el logaritmo de 100 base 10 es 2 porque 10^2 = 100.
2) El logaritmo cuando la base es el número irracional "e", el cual tiene un valor aproximado de 2.7183. Esta base es util en diversas aplicaciones de ingeniería y comercio. Es llamada tambien base de los logaritmos naturales o neperianos en honor al matematico escocés John Neper, reconocido como el primero en definir el concepto de logaritmo.

Obviamente, la base 10 y la base e no son las unicas bases posibles, en realidad hay tantas bases como números reales existan; sin embargo, la calculadora electrónica tiene un espacio limitado de teclas; pero es posible extraer un logaritmo de una base n utilizando la siguiente equivalencia:

Logb (n) = Log10(n) / Log10(b)

Donde Logb es el logaritmo base b; n es el numero del cual queremos obtener el logaritmo; Log10 es el logaritmo base 10 que por lo general traen las calculadoras. (Puede ser que la tecla este etiquetada simplemente con la palabra Log y sigue siendo el logaritmo base 10).

Ejemplo: Para calcular logaritmo base 2 de 8, tecleamos: Log 8 / Log 2

La calculadora arrojará como respuesta 3 por que la base 2 elevada a 3 es 8.

Entrenamiento de red perceptrón simple para compuerta AND de dos entradas

Sean los patrones siguientes, los cuales responden al comportamiento de una compuerta AND de dos entradas:

x1	x2	s
0	0	0
0	1	0
1	0	0
1	1	1

Y la arquitectura de perceptrón simple siguiente:

Parámetros de la red:

Pesos iniciales: w1 = 0.5 w2 = 0.5 w3 = 0.5

Definición de la salida: s = f(y) = 1 si y >= 0; 0 si y < 0

El entrenamiento de la red neuronal se lleva a cabo como se muestra en los siguientes cálculos:

0 – 0 – 0
y = (0)(0.5) + (0)(0.5) + 0.5 = 0.5 f(y) = 1
e = 0 – 1 = -1
w1 = 0.5 + -1 * 0 = 0.5
w2 = 0.5 + -1 * 0 = 0.5
w0 = 0.5 + (-1) = -0.5


0 – 0 – 0
y = 0*0.5 + 0*0.5 + (-0.5) = -0.5 f(y) = 0
0 – 1 – 0
y = 0*0.5 + 1*0.5 + (-0.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 0.5 + -(-1) * 0 = 0.5
w2 = 0.5 + -(-1) * 1 = -0.5
w0 = -0.5 + (-1) = -1.5


0 – 0 – 0
y = 0*0.5 + 0*-0.5 + (-1.5) = -1.5 f(y) = 0
0 – 1 – 0
y = 0*0.5 + 1*-0.5 + (-1.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*0.5 + 0*-0.5 + (-1.5) = -1 f(y) = 0
1 – 1 – 1
y = 1*0.5 + 1*-0.5 + (-1.5) = -1.5 f(y) = 0
e = 1 – 0 = 1
w1 = 0.5 + (1) * 1 = 1.5
w2 = -0.5 + (1) * 1 = 0.5
w0 = -1.5 + (1) = -0.5


0 – 0 – 0
y = 0*1.5 + 0*0.5 + (-0.5) = -0.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*0.5 + (-0.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 1.5 + (-1) * 0 = 1.5
w2 = 0.5 + (-1) * 1 = -0.5
w0 = -0.5 + (-1) = -1.5


0 – 0 – 0
y = 0*1.5 + 0*-0.5 + (-1.5) = -1.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*-0.5 + (-1.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*1.5 + 0*-0.5 + (-1.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 1.5 + (-1) * 1 = 0.5
w2 = -0.5 + (-1) * 0 = -0.5
w0 = -1.5 + (-1) = -2.5


0 – 0 – 0
y = 0*0.5 + 0*-0.5 + (-2.5) = -2.5 f(y) = 0
0 – 1 – 0
y = 0*0.5 + 1*-0.5 + (-2.5) = -3 f(y) = 0
1 – 0 – 0
y = 1*0.5 + 0*-0.5 + (-2.5) = -2 f(y) = 0
1 – 1 – 1
y = 1*0.5 + 1*-0.5 + (-2.5) = -2.5 f(y) = 0
e = 1 – 0 = 1
w1 = 0.5 + (1) * 1 = 1.5
w2 = -0.5 + (1) * 1 = 0.5
w0 = -2.5 + (-1) = -1.5


0 – 0 – 0
y = 0*1.5 + 0*0.5 + (-1.5) = -1.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*0.5 + (-1.5) = -1 f(y) = 0
1 – 0 – 0
y = 1*1.5 + 0*0.5 + (-1.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 1.5 + (-1) * 1 = 0.5
w2 = 0.5 + (-1) * 0 = 0.5
w0 = -1.5 + (-1) = -2.5


0 – 0 – 0
y = 0*0.5 + 0*0.5 + (-2.5) = -2.5 f(y) = 0
0 – 1 – 0
y = 0*0.5 + 1*0.5 + (-2.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*0.5 + 0*0.5 + (-2.5) = -2 f(y) = 0
1 – 1 – 1
y = 1*0.5 + 1*0.5 + (-2.5) = -1.5 f(y) = 0
e = 1 – 0 = 1
w1 = 0.5 + (1) * 1 = 1.5
w2 = 0.5 + (1) * 1 = 1.5
w0 = -2.5 + (1) = -1.5


0 – 0 – 0
y = 0*1.5 + 0*1.5 + (-1.5) = -1.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*1.5 + (-1.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 1.5 + (-1) * 0 = 1.5
w2 = 1.5 + (-1) * 1 = 0.5
w0 = -1.5 + (-1) = -2.5


0 – 0 – 0
y = 0*1.5 + 0*0.5 + (-2.5) = -2.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*0.5 + (-2.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*1.5 + 0*0.5 + (-2.5) = -1 f(y) = 0
1 – 1 – 1
y = 1*1.5 + 1*0.5 + (-2.5) = -0.5 f(y) = 0
e = 1 – 0 = 1
w1 = 1.5 + (1) * 1 = 2.5
w2 = 0.5 + (1) * 1 = 1.5
w0 = -2.5 + (1) = -1.5


0 – 0 – 0
y = 0*2.5 + 0*1.5 + (-1.5) = -1.5 f(y) = 0
0 – 1 – 0
y = 0*2.5 + 1*1.5 + (-1.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 2.5 + (-1) * 0 = 2.5
w2 = 1.5 + (-1) * 1 = 0.5
w0 = -1.5 + (-1) = -2.5


0 – 0 – 0
y = 0*2.5 + 0*0.5 + (-2.5) = -2.5 f(y) = 0
0 – 1 – 0
y = 0*2.5 + 1*0.5 + (-2.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*2.5 + 0*0.5 + (-2.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 2.5 + (-1) * 1 = 1.5
w2 = 0.5 + (-1) * 0 = 0.5
w0 = -2.5 + (-1) = -3.5


0 – 0 – 0
y = 0*1.5 + 0*0.5 + (-3.5) = -3.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*0.5 + (-3.5) = -3 f(y) = 0
1 – 0 – 0
y = 1*1.5 + 0*0.5 + (-3.5) = -2 f(y) = 0
1 – 1 – 1
y = 1*1.5 + 1*0.5 + (-3.5) = -1.5 f(y) = 0
e = 1 – 0 = 1
w1 = 1.5 + (1) * 1 = 2.5
w2 = 0.5 + (1) * 1 = 1.5
w0 = -3.5 + (1) = -2.5


0 – 0 – 0
y = 0*2.5 + 0*1.5 + (-2.5) = -2.5 f(y) = 0
0 – 1 – 0
y = 0*2.5 + 1*1.5 + (-2.5) = -1 f(y) = 0
1 – 0 – 0
y = 1*2.5 + 0*1.5 + (-2.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 2.5 + (-1) * 1 = 1.5
w2 = 1.5 + (-1) * 0 = 1.5
w0 = -2.5 + (-1) = -3.5


0 – 0 – 0
y = 0*1.5 + 0*1.5 + (-3.5) = -3.5 f(y) = 0
0 – 1 – 0
y = 0*1.5 + 1*1.5 + (-3.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*1.5 + 0*1.5 + (-3.5) = -2 f(y) = 0
1 – 1 – 1
y = 1*1.5 + 1*1.5 + (-3.5) = -0.5 f(y) = 0
e = 1 – 0 = 1
w1 = 1.5 + (1) * 1 = 2.5
w2 = 1.5 + (1) * 1 = 2.5
w0 = -3.5 + (1) = -2.5


0 – 0 – 0
y = 0*2.5 + 0*2.5 + (-2.5) = -2.5 f(y) = 0
0 – 1 – 0
y = 0*2.5 + 1*2.5 + (-2.5) = 0 f(y) = 1
e = 0 – 1 = -1
w1 = 2.5 + (-1) * 0 = 2.5
w2 = 2.5 + (-1) * 1 = 1.5
w0 = -2.5 + (-1) = -3.5


0 – 0 – 0
y = 0*2.5 + 0*1.5 + (-3.5) = -3.5 f(y) = 0
0 – 1 – 0
y = 0*2.5 + 1*1.5 + (-3.5) = -2 f(y) = 0
1 – 0 – 0
y = 1*2.5 + 0*1.5 + (-3.5) = -1 f(y) = 0
1 – 1 – 1
y = 1*2.5 + 1*1.5 + (-3.5) = 0.5 f(y) = 1


Pesos finales de la red:
w1 = 2.5
w2 = 1.5
w0 = -3.5

Cálculo de la entropía por método de frecuencias

Sea la siguiente tabla de reglas:

Atención al cliente	Productividad	Clasificación
A	B	Segunda
A	A	Primera
B	A	Segunda
B	B	Segunda

Calculando la entropía inicial:

Ei = -(3/4)log2((3/4) - (1/4)log2(1/4)

Calculando entropía de cada atributo por separado:

Tabla de frecuencias para el atributo Atención al cliente:

	A	B
Primera	1	0
Segunda	1	2
Suma	2	2	4

E1 = (-1log2(1) - 1log2(1) - 2log2(2) + 2log2(2) + 2log2(2)) / 4

Tabla de frecuencias para el atributo Productividad:

	A	B
Primera	1	0
Segunda	1	2
Suma	2	2	4

E2 = (-1log2(1) - 1log2(1) - 2log2(2) + 2log2(2) + 2log2(2)) / 4

Ganancia de información para Atención al cliente: G1 = Ei - E1

Ganancia de información para Productividad: G2 = Ei - E2

El atributo con la mayor ganancia es considerado como el raíz. En caso de empate, cualquiera de ellos puede ser considerado raíz.

Método de Coeficiente de Gini:

Calculamos primero el Gini inicial (de la tabla completa):
Gi = 1 - ((3/4)^2 + (1/4)^2)

Luego, utilizando las tablas de frecuencia respectivas, calculamos Gini para cada atributo por separado:

Gini de atención al cliente:
Nota = A --> (1^2 + 1^2) / 2 = 1
Nota = B --> (0^2 + 2^2) / 2 = 2
G1 = 1 - ((1 + 2) / 4) = 1 - 3/4 = 1/4

Gini de productividad:
Nota = A --> (1^2 + 1^2) / 2 = 1
Nota = B --> (0^2 + 2^2) / 2 = 2
G2 = 1 - ((1 + 2) / 4) = 1 - 3/4 = 1/4

Calculamos ahora, las reducciones del coeficiente de Gini:

Reducción en atención al cliente:
R1 = Gi - G1

Reducción en productividad:
R2 = Gi - G2

El atributo que presente la mayor reducción sera el escogido como raíz. En caso de que ambos presenten igual reducción, ambos pueden ser igualmente escogidos.

Algoritmo de Entrenamiento Backpropagation

Sea la siguiente tabla de patrones:

x1	x2	s1	s2
1	0	0	1
0	1	1	0

Y sea la siguiente arquitectura:

En donde:
x1 y x2: Entradas según la tabla de entrenamiento.
w1, w2, w3, w4, w5 y w6: Pesos de la capa de entrada.
w7, w8, w9, w10,w11 y w12: Pesos de la capa oculta.
y1 y y2: Acumuladores de la capa oculta.
s3 y s4: Salidas de la capa oculta.
y3, y4: Acumuladores de la capa de salida.
s1 y s2: Salidas de la red según la tabla de entrenamiento.
e1 y e2: Errores de la capa de salida
e3 y e4: Errores de la capa oculta


Antes de empezar, inicializamos todos los pesos con valores aleatorios:

Ciclo 1 - Patrón 1: 1 - 0 - 0 - 1

Paso 1: Calcular los acumuladores de la capa oculta:

y1 = w1*x1 + w4*x2 + w3
y2 = w2*x1 + w5*x2 + w6

Paso 2: Calcular las salidas de la capa oculta:

s3 = 1 / (1 + (base e)^(-y1))
s4 = 1 / (1 + (base e)^(-y1))

Paso 3: Calcular los acumuladores de la capa de salida:

y3 = s3 * w7 + s4 * w8 + w9
y4 = s3 * w10 + s4 * w11 + w12

Paso 4: Calcular las salidas de la red:

s1 = 1 / (1 + (base e)^(-y3))
s2 = 1 / (1 + (base e)^(-y4))

Paso 5: Calcular los errores de la capa de salida:

e1 = (s1 deseado - s1)(s1)(1 - s1) = (0 - s1)(s1)(1 - s1)
e2 = (s2 deseado - s2)(s2)(1 - s2) = (1 - s2)(s2)(1 - s2)

Paso 6: Calcular los errores de la capa oculta:

e3 = (s3)(1 - s3)(e1 * w7 + e1 * w10)
e4 = (s4)(1 - s4)(e2 * w8 + e2 * w11)

Paso 7: Con los errores de la capa de salida, ajustamos los pesos de la capa oculta:

w7nuevo = w7 + (e1 * s3)
w8nuevo = w8 + (e1 * s4)
w9nuevo = w9 + e1
w10nuevo = w10 + (e2 * s3)
w11nuevo = w11 + (e2 * s4)
w12uevo = w12 + e2

Paso 8: Con los errores de la capa oculta, ajustamos los pesos de la capa de entrada:

w1nuevo = w1 + (e3 * x1)
w2nuevo = w2 + (e4 * x1)
w3nuevo = w3 + e3
w4nuevo = w4 + (e3 * x2)
w5nuevo = w5 + (e4 * x2)
w6nuevo = w6 + e4

Ciclo 2 - Patrón 2: 0 - 1 - 1 - 0

En este ciclo, volvemos a repetir los ocho pasos anteriores; pero utilizando los pesos nuevos:

y también los nuevos valores de entradas (x1 y x2) y de salidas (s1 y s2). Al finalizar el ciclo 2 finaliza la primera época:
Calculamos los errores cuadráticos medios de la primera época:

Esalida1 = (1/2) * ((e1 del primer ciclo)^2 + (e1 del segundo ciclo)^2)
Esalida2 = (1/2) * ((e2 del primer ciclo)^2 + (e2 del segundo ciclo)^2)

En caso de que los errores no sean lo suficientemente aceptables (cercanos a 0), se inicia otra época utilizando siempre los últimos pesos que se tengan. Caso contrario, termina el entrenamiento y los pesos finales de la red serán los últimos que se encontraron.

Antipatrones de Diseño

Definición: Un antipatrón es una solución negativa a un problema de desarrollo de software. Existen antipatrones de administración, diseño, programación, gestión de proyectos.