INSTITUTO POLITÉCNICO NACIONAL · 2017. 2. 9. · con soporte vectorial” en la plataforma...
196
INSTITUTO POLITÉCNICO NACIONAL ESCUELA SUPERIOR DE CÓMPUTO Trabajo Terminal “INTEGRACIÓN DE ALGORITMOS DE CLASIFICACIÓN EN LA PLATAFORMA WEKA” 2013-A012 Que para cumplir con la opción de titulación curricular en la carrera de: “Ingeniería en Sistemas Computacionales” Presentan Chavez Lara Abraham Ortiz Ochoa Irvin Directores Dr. Cornelio Yáñez Márquez Dr. Luis Octavio López Leyva México, D.F. Mayo 2014
Transcript of INSTITUTO POLITÉCNICO NACIONAL · 2017. 2. 9. · con soporte vectorial” en la plataforma...
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE CÓMPUTO
Trabajo Terminal
“INTEGRACIÓN DE ALGORITMOS DE
CLASIFICACIÓN EN LA PLATAFORMA
WEKA”
2013-A012
Que para cumplir con la opción de titulación curricular en la carrera de:
“Ingeniería en Sistemas Computacionales”
Presentan
Chavez Lara Abraham
Ortiz Ochoa Irvin
Directores
Dr. Cornelio Yáñez Márquez Dr. Luis Octavio López Leyva
México, D.F. Mayo 2014
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE CÓMPUTO
No. Registro: TT 2013-A012 Serie: Amarilla Mayo de 2014
Documento técnico
“INTEGRACIÓN DE ALGORITMOS DE CLASIFICACIÓN EN LA
PLATAFORMA WEKA”
Presentan:
Chavez Lara Abraham1
Ortiz Ochoa Irvin2
Directores
Dr. Cornelio Yáñez Márquez Dr. Luis Octavio López Leyva
Resumen
Este proyecto plantea integrar el algoritmo de clasificación “Máquinas asociativas Alfa-Beta
con soporte vectorial” en la plataforma Waikato Environment for Knowledge Analysis
(WEKA), además de comparar el rendimiento del algoritmo con otros incluidos en la misma.
WEKA recolecta una serie de algoritmos que sirven de apoyo a los profesionales en el área
del aprendizaje automático.
Palabras clave – Análisis de algoritmos, Memorias asociativas, Reconocimiento de patrones,
Programación, WEKA.
1Email: [email protected] 2Email: [email protected]
Advertencia
“Este documento contiene información desarrollada por la
Escuela Superior de Cómputo del Instituto Politécnico Nacional,
a partir de datos y documentos con derecho de propiedad y por
lo tanto, su uso queda restringido a las aplicaciones que
explícitamente se convengan.”
La aplicación no convenida exime a la escuela su responsabilidad técnica y da
lugar a las consecuencias legales que para tal efecto se determinen.
Información adicional sobre este reporte técnico podrá obtenerse en:
La Subdirección Académica de la Escuela Superior de Cómputo del Instituto
Politécnico Nacional, situada en Av. Juan de Dios Bátiz s/n esquina Miguel Othón
de Mendizábal. Unidad Profesional Adolfo López Mateos.
Teléfono: 57296000 Extensión: 52000.
Agradecimientos
El presente trabajo pudo llevarse a cabo gracias al apoyo de nuestros directores el Dr.
Cornelio Yáñez Márquez y el Dr. Luis Octavio López Leyva, les agradecemos la confianza y los
consejos brindados para poder culminar con éxito este proyecto.
De igual forma queremos agradecer al Dr. Mario Aldape Pérez y al Dr. Amadeo José
Argüelles Cruz por resolver algunas dudas que se presentaron y los consejos que nos dieron.
Agradecemos al Dr. Rolando Flores Carapia, al Dr. José Francisco Solís Villarreal y al M.
en C. Edgar Armando Catalán Salgado por el apoyo brindado en la implementación del algoritmo
AlfaBetaSVM. Agradecemos al M. en C. Marco Antonio Valencia Reyes por el apoyo otorgado
en la fase de pruebas de este trabajo terminal.
También agradecemos a toda la comunidad docente de la Escuela Superior de Cómputo por
guiarnos para obtener los conocimientos para nuestra formación integral.
En primer lugar y como parte fundamental en cada logro de mi vida quiero agradecer a mi
padre por todo lo que ha hecho por mí y por mis hermanos para que nunca faltara ningún recurso
en el hogar, siempre dando prioridad a nuestro bienestar y salud antes que a la suya. También
quiero agradecer a mi madre que desde un lugar lejano siempre está al pendiente de mi bienestar
y dándome fuerzas cuando las cosas van mal.
A mi abuela Victoria porque me hizo ser la persona que soy ahora con sus consejos y la
manera en que siempre trata de mostrarnos lo moralmente bueno y malo de la vida. Le agradezco
su apoyo a lo largo de toda la vida porque nunca falto alimento listo en el hogar. También
agradezco a mis hermanos Rodrigo, Eduardo y Carina porque siempre estar ahí cuidando uno del
otro, por tener paciencia cuando realizaba mis actividades académicas.
Agradezco también a mis tíos Antonio, Martín, Estela, Salvador y Elena porque siempre
estuvieron al pendiente de mí, apoyándome y procurando mi bienestar. A mi tía Marisela por
siempre cuidar de mí, procurar mi bienestar en todo momento y siempre escucharme. A Ivonne
por ser mi gran amiga, siempre mostrándome su apoyo y paciencia en los momentos difíciles.
El presente trabajo es la consolidación de más de veinte años de mi vida llenos de
esfuerzo y dedicación, un esfuerzo que hubiera sido insignificante e infructuoso sin el apoyo de
ustedes.
Agradezco también a Omar, Francisco, Leonardo, Aldo, Ezequiel, David, Mario, Diego,
Samantha y mis demás compañeros de la Escuela Superior de Cómputo por apoyarme en cada
semestre de esta carrera; que no fue fácil pero que con su apoyo pude lograr.
A mi compañero de trabajo terminal Irvin por su trabajo y esfuerzo para sacar este
proyecto adelante. Agradezco el mostrarme que no hay que darse por vencido nunca y siempre
dar lo mejor. Un honor trabajar contigo.
Este es el resultado de muchos años de esfuerzo y dedicación y son parte primordial de
ello. Gracias a todos. Este no es el final, sino el principio de muchos éxitos futuros.
Atentamente
Abraham Chavez Lara
Papá, Mamá les agradezco infinitamente todo el apoyo que me han brindado, soy quien soy
gracias a ustedes. Este logro también es suyo. Los amo.
Jhosua, Kevin y Sandy les quiero agradecer por toda su ayuda, no hubiera podido concluir esto
sin ustedes.
Abraham, gracias por tu colaboración en la realización de este proyecto.
Dr. Luis Octavio, gracias por la confianza de permitirme trabajar con usted.
Atentamente
Irvin Ortiz Ochoa
Resumen
Este proyecto plantea la integración del algoritmo de clasificación “Máquinas asociativas
Alfa-Beta con Soporte Vectorial” en la plataforma Waikato Environment for Knowledge Analysis
(WEKA), además de comparar el rendimiento del algoritmo con otros incluidos en la misma.
WEKA recolecta una serie de algoritmos que sirven de apoyo a los profesionales en el área del
Aprendizaje automático.
El algoritmo se encuentra ubicado dentro del enfoque Asociativo de Reconocimiento de
Patrones.
Índice general
Simbología ....................................................................................................................................... 1
Glosario ........................................................................................................................................... 2
Capítulo 1. Introducción ................................................................................................................ 4
Antecedentes ..........................................................................................................................................4
Justificación del Trabajo Terminal ......................................................................................................5
Marco teórico.........................................................................................................................................6
Minería de datos .................................................................................................................................6
Problemas de la Minería de datos..................................................................................................6
Aplicaciones de la Minería de datos ..............................................................................................7
Comparativa de algoritmos en herramientas de Minería de datos .................................................7
WEKA ...............................................................................................................................................8
Historia .........................................................................................................................................8
Explorer ...................................................................................................................................... 11
Memorias Asociativas ...................................................................................................................... 18
Memorias Asociativas Alfa-Beta ..................................................................................................... 19
Máquinas de Soporte Vectorial ........................................................................................................ 21
Memorias Asociativas Alfa-Beta con Soporte Vectorial .................................................................. 22
Modelo de las Máquinas Asociativas Alfa-Beta con Soporte Vectorial ...................................... 22
Algoritmo de las Máquinas Asociativas Alfa-Beta con Soporte Vectorial .................................. 25
Codificación Binaria ........................................................................................................................ 27
Algoritmo mejorado para la obtención del código Johnson-Möbius modificado ........................ 29
Ejemplo 1 ............................................................................................................................ 30
Ejemplo 2 ............................................................................................................................ 31
Memorias Asociativas Alfa-Beta con Soporte Vectorial empleando el código Johnson-Möbius
modificado abreviado ....................................................................................................................... 35
Algoritmo de las Máquinas Asociativas Alfa-Beta con Soporte Vectorial sin codificación binaria
.................................................................................................................................................... 35
Problema .............................................................................................................................................. 39
Objetivos .............................................................................................................................................. 39
Objetivo general ............................................................................................................................... 39
Objetivos específicos ....................................................................................................................... 39
Contexto de desarrollo ........................................................................................................................ 39
Proyecto ............................................................................................................................................... 40
Recursos ........................................................................................................................................... 40
Organización del documento ............................................................................................................ 41
Capítulo 2. Inicio .......................................................................................................................... 42
Sección 2.1. Gestión del proyecto ....................................................................................................... 42
Planificación del proyecto ................................................................................................................ 42
Diario de ejecución .......................................................................................................................... 43
Sección 2.2. Modelado del proyecto ................................................................................................... 45
Clasificación en WEKA ................................................................................................................... 45
Requisitos para integrar un algoritmo en WEKA ............................................................................. 45
Paquetes de preprocesamiento en WEKA ........................................................................................ 47
Requisitos para integrar un algoritmo de preprocesamiento en WEKA ........................................... 48
Integración de un algoritmo a WEKA .............................................................................................. 49
Estructura de un paquete para publicación .................................................................................. 50
El archivo de descripción ............................................................................................................ 51
Integración del paquete ............................................................................................................... 53
Diagramas de Casos de uso .............................................................................................................. 54
Casos de usos de WEKA............................................................................................................. 54
Casos de usos de Explorer ........................................................................................................... 55
Especificación de Casos de usos ................................................................................................. 56
CU1: Explorer ..................................................................................................................... 56
CU1.1: Preprocess .............................................................................................................. 58
CU1.1.1: Open file............................................................................................................... 59
CU1.1.2: Filter .................................................................................................................... 60
CU1.2: Classify ................................................................................................................... 61
CU1.2.1: Choose classifier .................................................................................................. 62
CU1.2.2: Start classifier ...................................................................................................... 64
CU1.2.3: Visualize classifier output .................................................................................... 65
Capítulo 3. Elaboración ............................................................................................................... 66
Sección 3.1. Análisis y Diseño ............................................................................................................. 66
Diagramas de Clases ........................................................................................................................ 66
Algoritmo AlfaBetaSVM ............................................................................................................ 66
Clase Classifier en WEKA .......................................................................................................... 67
Diagramas de paquetes ..................................................................................................................... 68
Diagrama de paquetes de WEKA ................................................................................................ 68
Diagrama de paquetes de Classifiers en WEKA ......................................................................... 68
Capítulo 4. Construcción ............................................................................................................. 69
Sección 4.1. Análisis y Diseño ............................................................................................................. 69
Diagramas de Clases ........................................................................................................................ 69
Clase AlfaBetaSVM .................................................................................................................... 69
Clase JohnsonMobiusModifiedCode........................................................................................... 70
Diagramas de paquetes ..................................................................................................................... 71
Diagrama de paquetes de Classifiers en WEKA ......................................................................... 71
Sección 4.2. Implementación .............................................................................................................. 71
Codificador Johnson-Möbius modificado ........................................................................................ 71
Clasificador AlfaBetaSVM .............................................................................................................. 73
Capítulo 5. Transición .................................................................................................................. 77
Sección 5.1. Implementación .............................................................................................................. 77
Construcción del paquete para WEKA ............................................................................................. 77
Sección 5.2. Pruebas .......................................................................................................................... 104
Pruebas de Integración de los algoritmos a WEKA................................................................... 104
Evaluación del rendimiento del clasificador AlfaBetaSVM ...................................................... 107
Base de datos MNIST ............................................................................................................... 108
Resultados ................................................................................................................................. 108
Base de datos Iris Plant ............................................................................................................. 113
Resultados ................................................................................................................................. 114
Conclusiones ............................................................................................................................... 116
Trabajo a futuro ......................................................................................................................... 117
Referencias .................................................................................................................................. 118
Apéndices .................................................................................................................................... 120
Apéndice 1. Ejercicio práctico de Memorias Asociativas Alfa-Beta con Soporte Vectorial ........ 120
Apéndice 2. Ejercicio práctico de Memorias Asociativas Alfa-Beta con Soporte Vectorial
empleando la codificación binaria Johnson-Möbius modificada ................................................... 135
Apendice 3. Ejercicio práctico de Memorias asociativas Alfa-Beta con Soporte Vectorial sin
codificación binaria ........................................................................................................................... 158
Apéndice 4. Compilación y ejecución de WEKA en Netbeans ....................................................... 166
Índice de Tablas
Tabla 1. Resultados de comparación de las plataformas .................................................................. 8
Tabla 2. Definición de los operadores Alfa y Beta ........................................................................ 20
Tabla 3. Propiedades de la operación binaría α .............................................................................. 20
Tabla 4. Propiedades de la operación β .......................................................................................... 20
Tabla 5. Propiedades de la aplicación combinada de los operadores α y β ................................... 20
Tabla 6. Código Johnson-Möbius .................................................................................................. 27
Tabla 7. Códigos Johnson-Möbius modificado .............................................................................. 28
Tabla 8. Resultados de código Johnson-Möbius modificado ......................................................... 30
Tabla 9. Parte del dataset Iris Plant ................................................................................................ 31
Tabla 10. Código Johnson-Möbius modificado para sepallength .................................................. 33
Tabla 11. Código Johnson-Möbius modificado para sepalwidth ................................................... 33
Tabla 12. Código Johnson-Möbius modificado para petallength................................................... 34
Tabla 13. Código Johnson-Möbius modificado para petalwidth ................................................... 34
Tabla 14. Código Johnson-Möbius modificado abreviado para sepallength ................................. 34
Tabla 15. Código Johnson-Möbius modificado abreviado para sepalwidth .................................. 34
Tabla 16. Código Johnson-Möbius modificado abreviado para petallength .................................. 34
Tabla 17. Código Johnson-Möbius modificado abreviado para petalwidth ................................... 34
Tabla 18. Planificación del proyecto .............................................................................................. 43
Tabla 19. Diario de ejecución......................................................................................................... 44
Tabla 20. Código del método convert ............................................................................................ 72
Tabla 21. Código del método buildClassifier ................................................................................. 76
Tabla 22. Contenido del archivo Description.props ....................................................................... 98
Tabla 23. Contenido del archivo GenericPropertiesCreator.props................................................. 99
Tabla 24. Resultados arrojados por WEKA ................................................................................. 111
Tabla 25. Matriz de confusión arrojada por WEKA .................................................................... 112
Tabla 26. Porcentajes de instancias para MNIST ........................................................................ 112
Tabla 27. Resultados entrenamiento y prueba con el mismo conjunto de datos de entrenamiento
...................................................................................................................................................... 112
Tabla 28. Resultados entrenamiento con conjunto de entrenamiento y prueba con el conjunto de
prueba ........................................................................................................................................... 113
Tabla 29. Resultados finales ......................................................................................................... 113
Índice de Diagramas
Diagrama 1. Casos de usos de WEKA ........................................................................................... 54
Diagrama 2. Casos de uso para Clasificación usando Explorer ..................................................... 55
Diagrama 3. Clases del Algoritmo AlfaBetaSVM ......................................................................... 66
Diagrama 4. Clases de Classifier en WEKA .................................................................................. 67
Diagrama 5. Paquetes de la plataforma WEKA ............................................................................. 68
Diagrama 6. Paquetes del paquete Classifiers en WEKA .............................................................. 68
Diagrama 7. Diagrama de clases AlfaBetaSVM ............................................................................ 69
Diagrama 8. Diagrama de clases Johnson-Möbius modificado ..................................................... 70
Diagrama 9. Paquetes del paquete Classifiers en WEKA .............................................................. 71
Índice de Ilustraciones
Ilustración 1. Representación gráfica de un dataset ......................................................................... 9
Ilustración 2. Contenido de un archivo .arff ................................................................................... 10
Ilustración 3. Interfaz gráfica inicial de WEKA............................................................................. 11
Ilustración 4. Interfaz gráfica de la aplicación Explorer ................................................................ 12
Ilustración 5. Preprocesamiento de los datos en WEKA................................................................ 14
Ilustración 6. Clase del dataset weather ......................................................................................... 15
Ilustración 7. Menú Classify de la aplicación Explorer ................................................................. 16
Ilustración 8. Clasificación empleando el algoritmo ID3 .............................................................. 17
Ilustración 9. Concepto de hiperplano de las SVM ........................................................................ 21
Ilustración 10. Concepto de Vector de soporte de las SVM .......................................................... 21
Ilustración 11. Conjunto fundamental. ........................................................................................... 22
Ilustración 12. Patrón con la información presente repetida, Vector de soporte............................ 22
Ilustración 13. Conjunto fundamental con la información presente en todos los patrones
fundamentales eliminada ................................................................................................................ 23
Ilustración 14. Conjunto fundamental de información ausente ...................................................... 23
Ilustración 15. Patrón con la información ausente repetida, Vector de soporte ............................. 23
Ilustración 16. Conjunto fundamental de información ausente, con la información ausente
repetida eliminada .......................................................................................................................... 24
Ilustración 17. Patrón desconocido ................................................................................................ 24
Ilustración 18. Patrón desconocido al que se le ha eliminado la información presente repetida ... 24
Ilustración 19. Patrón de información ausente del patrón desconocido ......................................... 24
Ilustración 20. Patrón de información ausente del patrón desconocido, al que se le ha eliminado la
información ausente repetida.......................................................................................................... 25
Ilustración 21. Patrón de salida ...................................................................................................... 25
Ilustración 22. Repositorio WEKA ................................................................................................ 77
Ilustración 23. Contenido del directorio weka de WEKA.............................................................. 78
Ilustración 24. Contenido del directorio trunk/packages/templates de WEKA ............................. 79
Ilustración 25. IDE NetBeans ......................................................................................................... 79
Ilustración 26. Selección de menú .................................................................................................. 80
Ilustración 27. URL del respositorio de WEKA ............................................................................ 80
Ilustración 28. Conexión al respositorio de WEKA ....................................................................... 81
Ilustración 29. Menú de repositorio ............................................................................................... 81
Ilustración 30. Contenido de los directorios del repositorio de WEKA ......................................... 82
Ilustración 31. Configuración de copia de repositorio ................................................................... 83
Ilustración 32. Copia de repositorio concluida ............................................................................... 83
Ilustración 33. Selección de proyecto a abrir ................................................................................. 84
Ilustración 34. Proyecto listo en el IDE NetBeans ......................................................................... 84
Ilustración 35. Creación de nuevo proyecto ................................................................................... 85
Ilustración 36. Selección del tipo de proyecto ............................................................................... 85
Ilustración 37. Localización para almacenar el proyecto ............................................................... 86
Ilustración 38. Configuración de nuevo proyecto .......................................................................... 87
Ilustración 39. Proyecto creado correctamente en NetBeans ......................................................... 87
Ilustración 40. Borrado de clases innecesarias ............................................................................... 88
Ilustración 41. Mensaje de confirmación de borrado ..................................................................... 88
Ilustración 42. Proyecto vacío y listo para copia de código fuente ................................................ 89
Ilustración 43. Creación de un nuevo paquete ............................................................................... 90
Ilustración 44. Estableciendo el nombre para el nuevo paquete .................................................... 90
Ilustración 45. Configurando nuevo paquete ................................................................................. 91
Ilustración 46. Resultado final de la creación de paquetes ............................................................ 91
Ilustración 47. Copiando el código fuente al IDE NetBeans ......................................................... 92
Ilustración 48. Errores encontrados por NetBeans ......................................................................... 93
Ilustración 49. Dependencias encontradas ..................................................................................... 93
Ilustración 50. Proyecto sin errores en NetBeans .......................................................................... 94
Ilustración 51. Edición del archivo de proyecto pom.xml ............................................................. 95
Ilustración 52. Contenido de la copia local del repositorio packages/templates ............................ 96
Ilustración 53. Adición de los archivos copiados desde el repositorio .......................................... 96
Ilustración 54. Nodo make_package .............................................................................................. 97
Ilustración 55. Edición del archivo props ....................................................................................... 97
Ilustración 56. Edición del archivo GenericPropertiesCreator.props ............................................. 99
Ilustración 57. Adición de carpeta lib ............................................................................................ 99
Ilustración 58. Extracción del contenido del archivo apache-ant.zip ........................................... 100
Ilustración 59. Agregar la ruta de instalación a la variable Path .................................................. 100
Ilustración 60. Ejecución de la herramienta ant ........................................................................... 101
Ilustración 61. Construcción del proyecto weka-dev ................................................................... 101
Ilustración 62. Salida de NetBeans acerca de la construcción del proyecto weka-dev ................ 102
Ilustración 63. Ubicación en consola del directorio del proyecto weka ....................................... 102
Ilustración 64. Ejecución de la herramienta ant para compilar el paquete ................................... 103
Ilustración 65. Ejecución de la herramienta ant para la generación del paquete.......................... 103
Ilustración 66. Resultado de la creación del paquete ................................................................... 104
Ilustración 67. Resultados de pruebas del filtro JohnsonMobiusModifiedCode.......................... 105
Ilustración 68. Resultados de pruebas del clasificador AlfaBetaSVM ........................................ 105
Ilustración 69. Ejecución de la herramienta CheckGOE para JohnsonMobiusModifiedCode .... 105
Ilustración 70. Ejecución de la herramienta CheckGOE para AlfaBetaSVM .............................. 106
Ilustración 71. Pruebas JUnit del codificador y del clasificador .................................................. 107
Ilustración 72. Sobre carga de trabajo a un solo procesador ........................................................ 109
Ilustración 73. Prueba de ejecución del algoritmo AlfaBetaSVM ............................................... 109
Ilustración 74. Ejecución concurrente, todos los procesadores se encuentran trabajando ........... 110
Ilustración 75. Comparación de resultados .................................................................................. 113
Ilustración 76. Comparativa de resultados con Iris Plant ............................................................. 114
1
Simbología
Memorias 𝛼𝛽 Las memorias asociativas Alfa-Beta
𝛼, 𝛽 Operadores en que se basan las memorias Alfa-Beta
𝚳 Memoria asociativa
⋁ Operador Máximo
⋀ Operador Mínimo
𝐴 Conjunto de elementos
𝐴𝑛 𝑛 Dimensión del conjunto 𝐴
𝒙𝜇 Vector columna
∈ Pertenencia de un elemento a un conjunto
∃𝑥 Existe por lo menos un elemento 𝑥
∀𝑥 Para todos los elementos 𝑥
ℤ+ Conjunto de los números enteros positivos
{(𝑥𝜇 , 𝑦𝜇) | 𝜇 = 1,2, … , 𝑝} Conjunto fundamental
𝟎 Vector Cero
𝟏 Vector Uno
𝝉 Transformada Tau
𝜃 Transformada Theta
2
Glosario
Análisis de conocimiento: Modelado de una fuente de conocimiento para analizar las utilidades
de esta información.
Ant: Herramienta de generación o automatización de código escrita en JAVA.
Cardinalidad: Medida numérica que expresa la cantidad de elementos existentes en un conjunto.
Clase: Identificador de un conjunto de patrones que comparten características semejantes.
Clasificación: Asignar un vector de características a grupos o clases, basándose en las
características extraídas.
Clasificador: Sistema que asigna un vector de características a grupos o clases, basándose en las
características extraídas.
Código: Tratamiento abstracto y sistemático para manejar la información entre un receptor y
emisor, éstos deben codificar y decodificar.
Conjunto fundamental: Es un conjunto finito de asociaciones, a cada entrada le corresponde una
salida, es decir,{(𝒙𝜇|𝒚𝜇) | 𝜇 = 1,2,3, … , 𝑝}, donde 𝑝 es igual a la cardinalidad del conjunto.
Dataset: Conjunto de datos estructurados.
IDE: Integrated Development Environment, IDE por sus siglas en inglés. Es un entorno de
desarrollo integrado, compuesto por todo un conjunto dedicado de herramientas de programación
para uno o más lenguajes de programación.
JAVA: Lenguaje de programación multiplataforma.
Memoria asociativa: Una memoria asociativa se representa por una máquina con una entrada y
con una salida, la entrada se representa con un vector columna 𝒙 y la salida con un vector
columna 𝒚.
Patrón: Representación abstracta que describe a un objeto.
Plataforma: Sistema que sirve como base para hacer funcionar determinados módulos de
hardware o de software con los que es compatible.
Reconocimiento de Patrones: Proceso por el cual se pueden clasificar los datos de entrada en
clases identificables.
Relación: Vínculo entre dos o más atributos.
Software libre: Software en el cual los usuarios tienen la libertad de copiar, distribuir, estudiar,
modificar y mejorar dicho software.
3
Tester: Usuario que analiza el funcionamiento de software a finales de la etapa de desarrollo.
URL: Localizador de recursos uniforme.
Vector de características: Vector donde los componentes representan características. Es una
forma de representar un patrón.
Wiki: Foro dedicado a un tema en particular, el contenido está compuesto por contribuciones de
expertos en el tema, administradores del foro y usuarios interesados.
4
Capítulo 1. Introducción
WEKA (Waikato Environment for Knowledge Analysis), es una colección de algoritmos
de Aprendizaje automático para tareas de Minería de datos. Contiene herramientas de Pre-
procesamiento, Clasificación, Regresión, Clustering, Reglas de asociación, Visualización,
Reconocimiento de patrones, Inteligencia artificial y Aprendizaje automático [1]. Esta plataforma
fue desarrollada en la universidad de Waikato en Nueva Zelanda en 1992 y es financiada por el
gobierno de Nueva Zelanda desde 1993 [2].
La integración de algoritmos a esta plataforma permite incrementar la colección de éstos,
de manera que sirve como herramienta de apoyo a las actividades de áreas de investigación en el
Aprendizaje automático tales como Minería de datos e Inteligencia Artificial.
Esto nos abre el camino con el fin de introducir nuevos algoritmos para aquellos
profesionales dedicados al Aprendizaje automático y Minería de datos. En un inicio se integrará
el algoritmo de “Maquinas Asociativas Alfa-Beta con Soporte Vectorial”, desarrollado por el Dr.
Luis Octavio López Leyva en su tesis de doctorado [3].
Este algoritmo surge al tomar elementos de dos ramas importantes del Reconocimiento de
Patrones: el modelo de memorias asociativas Alfa-Beta y la teoría de las Máquinas de Soporte
Vectorial (Support Vector Machines, SVM, por sus siglas en inglés) [3] y presenta resultados
competitivos aplicados al reconocimiento de dígitos escritos a mano.
Antecedentes
A continuación se presenta un listado de proyectos con alto grado de similitud.
Trabajos similares
1. Integración del algoritmo CTC en la plataforma WEKA. Fernando López Pajarón
(Ingeniería Técnica en informática de sistemas, Universidad del País Vasco/EHU).
Algoritmo implementado: CTC (Consolidated Trees Construction) [4].
2. Writing New Learning Schemes. Ian H. Witten, Eibe Frank, Mark A. Hall.
Data Mining, Practical Machine Learning, Tools and Techniques.
Algoritmo implementado: Arboles de decisión ID3 [5].
5
El listado anterior sirve como base para conocer requisitos de integración, pero ninguno de
estos trabajos integra memorias asociativas, por tal motivo este proyecto presenta originalidad.
Justificación del Trabajo Terminal
Los diferentes sectores de la sociedad tales como los Negocios, Ciencia, Medicina,
Economía, Geografía, Deportes, Medio ambiente, etcétera; producen una inmensa cantidad de
datos, los cuales deben ser manipulados por ciertas técnicas para extraer información. Este campo
de las ciencias de la computación recibe el nombre de Minería de datos.
Estas técnicas extraen información implícita, previamente desconocida y potencialmente
útil; pero en ocasiones muchas de ellas requieren bastantes recursos, por lo que es necesario
desarrollar programas de cómputo para facilitar esta tarea.
En el Grupo de Investigación Alfa-Beta del Centro de Investigación en Computación del
Instituto Politécnico Nacional se han desarrollado algoritmos de clasificación que pueden ser
aplicados a investigaciones que involucren la clasificación y recuperación de patrones. Los
algoritmos presentan resultados competentes ante otros de la literatura científica actual; por lo
que en este trabajo terminal se plantea la integración de uno de éstos en una plataforma que sirve
como herramienta para la Minería de datos mediante el Aprendizaje Automático.
La integración de algoritmos de clasificación a dicha plataforma aumentará el catálogo de
éstos y las posibilidades de que los profesionales dedicados a la Minería de datos, obtengan
mejores resultados en la búsqueda de patrones con información útil en sus conjuntos de datos y
éstos a su vez puedan ser usados para predecir el resultado de una situación.
6
Marco teórico
Minería de datos
Debido a las grandes bases de datos que se manejan día a día en distintos sectores de la
sociedad; de las cuales se pueden extraer recursos potencialmente valiosos si se logra extraer
información útil de ellas
La Minería de datos es un campo de las ciencias de la computación que busca patrones de
información en grandes cantidades de datos. Para encontrar dichos patrones emplea técnicas de
Inteligencia Artificial, Aprendizaje automático y Estadística.
Por ejemplo en la fertilización in vitro se tiene un conjunto de datos con registros
históricos de embriones, cada embrión está descrito por 60 características y dependiendo de los
valores de cada característica se tiene un resultado de supervivencia de cada embrión, en este
caso con la Minería de datos podríamos encontrar patrones de información que nos ayuden a
predecir que embriones son los que sobrevivirán.
Debido a que se manejan inmensos conjuntos de datos que deben ser analizados
minuciosamente para encontrar dichos patrones, fue necesario realizar programas de cómputo
que detecten dichos patrones y regularidades en los datos.
Este campo incluye varias disciplinas tales como las Bases de datos, las Máquinas de
aprendizaje, el Reconocimiento de patrones, estadística y visualización de los datos.
Problemas de la Minería de datos
Los problemas con los que se enfrenta este campo son los siguientes:
La mayoría de los patrones no son interesantes
Los patrones pueden ser inexactos o falsos
Los datos pueden ser confusos o ausentes
7
Aplicaciones de la Minería de datos
El resultado del aprendizaje es utilizado en las siguientes aplicaciones prácticas:
Procesamiento de préstamos bancarios
Procesamiento digital de imágenes para encontrar derrames petroleros
Predicción del abastecimiento de electricidad
Diagnóstico de fallas mecánicas
Ventas y marketing
Aplicaciones científicas
Etcétera
Comparativa de algoritmos en herramientas de Minería de datos
En Agosto de 2010, la empresa española Stratebi desarrolló un estudio de comparación
entre distintos Software de para Minería de Datos [6], tales como:
RapidMiner[7]
WEKA
Tanagra[8]
KMINE[9]
PASW[10]
R and Data Mining[11]
Los resultados de la comparación entre las diversas plataformas se aprecian en la Tabla 1.
WEKA 3.7.2 R and Data
Mining Tanagra KNIME PASW RapidMiner
Algoritmos
implementados de
forma nativa
168
24
13
9
10
34
Algoritmos
importados desde
WEKA
0
0
0
102
0
101
Total de
algoritmos
implementados
168
24
13
111
10
135
8
Porcentaje de
algoritmos nativos
100%
100%
100%
8.1%
100%
25.2%
Porcentaje de
algoritmos nativos
sobre el total
84.8%
12.1%
6.6%
4.5%
5.1%
17.2%
Tabla 1. Resultados de comparación de las plataformas
WEKA, aparece con mayor número de algoritmos en su plataforma, en comparación con
otras herramientas (ver Tabla 1), además de ser una herramienta multiplataforma y software libre,
por lo tanto se decidió integrar el algoritmo de clasificación a esta herramienta.
WEKA
Historia
En 1993, la Universidad de Waikato ubicada en Nueva Zelanda inició el desarrollo de la
primera implementación para analizar datos provenientes de la agricultura, la cual fue la primera
versión original de WEKA (Waikato Enviroment for Knowledge Analysis); dicha versión estaba
desarrollada en los lenguajes TCL/TK (Tool Command Language) y C [12], [13].
En 1997, se reescribió el código en lenguaje JAVA agregando otros algoritmos.
En el año 2005, WEKA recibe el galardón “Data Mining and Knowledge Discovery
Service” [14], por parte de Special Interest Group on Knowledge Discovery and Data Mining
[15].
En 2006 Pentaho Corporation [16], adquirió una licencia para utilizar WEKA hacia la
inteligencia de negocio dando lugar al componente de Minería de datos y análisis predictivo del
paquete de software Pentaho Business Intelligence, conocido actualmente como Pentaho
Business Analytics.
WEKA es llamada así, debido al nombre de un ave de Nueva Zelanda; la cual es famosa
por su curiosidad y agresividad.
9
Características
Es una plataforma de software libre que posee una colección de algoritmos de Aprendizaje
automático usados en la Minería de datos; la cual posee una interfaz gráfica para poder acceder a
todas las herramientas disponibles en la misma.
Escrita en lenguaje JAVA.
Es de software libre publicada bajo la licencia GNU/GPLv3 [17], por lo que nos permite
modificar el código fuente del mismo.
Funcionamiento
El funcionamiento general de WEKA se hace a través de un conjunto de datos (dataset), el
cual es un conjunto de datos estructurado y contendrá la información para nuestro proceso de
Minería de datos.
En la Ilustración 1 se muestra un ejemplo de un dataset:
Ilustración 1. Representación gráfica de un dataset
10
La introducción de un dataset, se realiza mediante un archivo de texto plano con extensión
*.arff que posee la siguiente estructura:
Encabezado: Debe especificar el nombre de la relación denotándola con la etiqueta
@relation.
Atributos: Definiremos los atributos, que pueden ser numéricos o nominales, con la
etiqueta @attribute antes de cada atributo.
Instancias: Por último se escribirán las instancias anteponiendo la etiqueta @data,
se debe colocar el valor de cada atributo separado por comas y un salto de línea
como separación entre instancias.
El contenido a detalle de un archivo .arff se aprecia en la Ilustración 2.
Ilustración 2. Contenido de un archivo .arff
En la Ilustración 2 definimos una relación llamada weather con 5 atributos los cuales son:
outlook que es un atributo nominal, ya que únicamente puede tener los valores de sunny, overcast
y rainy. Los atributos temperature y humidity son de tipo numérico. El atributo windy es nominal
y toma los valores de true y false y por último el atributo play que determina la clase a la que
pertenece. WEKA utiliza de forma predeterminada el último atributo como la clase la instancia.
11
Al iniciar WEKA en la interfaz gráfica inicial (ver Ilustración 3) permite elegir entre cuatro
aplicaciones las cuales son:
Explorer
KnowledgeFlow
Experimenter
Simple CLI
También muestra en la barra de menú 4 opciones las cuales son: Program, que muestra la
memoria que se utiliza en el programa; Visualization, que permite graficar árboles; Tools, que
permite visualizar archivos *.arff y Help que muestra información sobre la plataforma.
Ilustración 3. Interfaz gráfica inicial de WEKA
La manera más común de utilizar WEKA es mediante la aplicación Explorer, por lo que
nos enfocaremos en esta aplicación para describir el funcionamiento.
Explorer
Esta aplicación permite trabajar sobre un solo dataset y es fácil de utilizar debido a su
interfaz gráfica sencilla (ver Ilustración 4). Ésta cuenta con un menú con las siguientes opciones:
Preprocess
12
Classify
Cluster
Associate
Select attributes
Visualize
A continuación se detallan de manera más extensa los menús Preprocess y Classify. Es
importante detallar estos menús porque son pasos importantes en la prueba de un clasificador.
Ilustración 4. Interfaz gráfica de la aplicación Explorer
En la sección Preprocess (ver Ilustración 4), definiremos nuestro dataset de entrada el cual
podremos visualizar en esta sección y en caso de ser necesario aplicarle un filtro para eliminar
datos innecesarios o modificar su contenido.
13
A continuación se explica la funcionalidad de los botones que se pueden apreciar en la
Ilustración 4:
El botón Open file ofrece la capacidad de seleccionar un archivo con alguna de las
siguientes extensiones: *.arff, *.arff.gz, *.names, *.data , *.csv ,*.libsvm y *dat. En este trabajo
terminal se explica únicamente el archivo *.arff debido a que es el más utilizado.
El botón Open URL permite obtener un dataset desde un URL.
El botón OpenDB sirve para obtener un dataset desde una Base de datos relacional.
EL botón Generate sirve para generar un dataset.
El botón Undo sirve para deshacer los cambios realizados al dataset.
El botón Edit permite editar los valores del dataset.
El botón Save guarda el dataset modificado.
El botón Choose permite filtrar los datos con los algoritmos de filtrado de la plataforma de
los cuales se hablará detalladamente más adelante.
El botón Log muestra un registro de las actividades llevadas a cabo en la aplicación.
Al seleccionar un archivo de este tipo la ventana de Preprocess muestra los datos de
entrada obteniendo los siguientes datos: nombre de la relación, número de atributos, y el número
de instancias (ver Ilustración 5).
Al seleccionar cada atributo nos indicará cuantas instancias hay de cada atributo.
14
Ilustración 5. Preprocesamiento de los datos en WEKA
En la Ilustración 5, la relación weather utilizada anteriormente con información extraída del
archivo: Nombre de la relación: weather, Instancias: 14 y Atributos: 5.
Para el atributo outlook se tienen 5 instancias con el valor de sunny, 2 instancias con el
valor de overcast y 3 instancias con el valor de rainy.
15
Ilustración 6. Clase del dataset weather
Para el atributo play que define la clase, se tienen 9 instancias con el valor de yes, 5
instancias con el valor de no (ver Ilustración 6).
El menú Classify (ver Ilustración 7), nos permitirá crear un modelo de clasificación en base
a nuestro conjunto de datos y probarlo para evaluar su desempeño. Este apartado es importante
debido a que el objetivo de este trabajo terminal es la integración un algoritmo de clasificación.
16
Ilustración 7. Menú Classify de la aplicación Explorer
En la interfaz de Classify (ver Ilustración 7), el botón Choose nos mostrará una colección
de algoritmos de clasificación de entre los cuales podemos elegir uno para clasificar el dataset.
En el menú de Test Options podemos evaluar el modelo de clasificación construido y probarlo
con el dataset (Use training set), con un dataset nuevo (Supplied test set), mediante el modelo de
evaluación llamado K-fold cross-validation y tomando un porcentaje del dataset para el
entrenamiento y otro para la prueba (Percentage Split). Más adelante se describirán a detalle
estos evaluadores.
En la Ilustración 8 mostramos un ejemplo de clasificación utilizando un árbol ID3 y su
respectiva evaluación con el algoritmo K-fold cross-validation con 𝑘 = 10:
17
Ilustración 8. Clasificación empleando el algoritmo ID3
El modelo de clasificación ID3 toma al atributo outolook por ser el atributo que ofrece
información más útil en la construcción del modelo. Al evaluar el rendimiento del modelo,
clasificó correctamente 12 instancias y erróneamente 2 instancias.
El menú Cluster permite agregar un dataset y formar grupos de instancias de éste (ver
Ilustración 7).
El menú Associate contiene reglas de asociación para los datos y encontrar patrones
frecuentes de un dataset (ver Ilustración 7).
El menú Select attributes permite seleccionar los atributos más relevantes del dataset (ver
Ilustración 7).
El menú Visualize permite visualizar los datos en forma bidimensional (ver Ilustración 7).
A continuación se presentan los conceptos básicos relacionados con las Memorias
Asociativas, Memorias Asociativas Alfa-Beta, Máquinas de Soporte Vectorial y Memorias
Asociativas Alfa-Beta con Soporte Vectorial.
18
Memorias Asociativas
La información presentada en esta sección se ha tomado de las referencias más
representativas [3], [18-27].
El propósito fundamental de una Memoria asociativa es recuperar patrones completos a
partir de patrones de entrada que pueden estar alterados por ruido aditivo, sustractivo o
combinado. De acuerdo con esta afirmación, una memoria asociativa 𝚳 puede formularse como
un sistema de entrada y salida; esta idea se esquematiza a continuación.
𝒙 → 𝚳 → 𝒚
Los patrones de entrada y de salida se representan por vectores columna, la entrada
denotada por 𝒙 y la salida denotada por 𝒚. Cada uno de los patrones de entrada forma una
asociación con el correspondiente patrón de salida, la cual es similar a una pareja ordenada; por
ejemplo, los patrones 𝒙 y 𝒚 del esquema anterior forma la asociación (𝒙, 𝒚). A un patrón de
entrada 𝒙1 le corresponderá el patrón de salida 𝒚1 y ambos formarán la asociación (𝒙1, 𝒚1); del
mismo modo, para un número entero positivo 𝑘 específico, la asociación correspondiente es
(𝒙𝑘, 𝒚𝑘).
La memoria asociativa 𝚳 se representa mediante una matriz, la cual se genera a partir de un
conjunto finito de asociaciones conocidas de antemano: este es el conjunto fundamental de
aprendizaje, o simplemente conjunto fundamental. El conjunto fundamental se representa de la
siguiente manera:
{(𝒙𝜇 | 𝒚𝜇) | 𝜇 = 1,2,3, … , 𝑝}
Donde 𝑝 es un número entero positivo que representa la cardinalidad del conjunto fundamental.
A los patrones que conforman las asociaciones del conjunto fundamental se les llama patrones
fundamentales. La naturaleza del conjunto fundamental proporciona un importante criterio para
clasificar las memorias asociativas:
Una Memoria es Autoasociativa si se cumple que 𝒙𝜇 = 𝒚𝜇 ∀ 𝜇 ∈ {1,2,… , 𝑝}, por lo
que uno de los requisitos que se debe cumplir es que 𝑛 = 𝑚.
Una Memoria Heteroasociativa es aquella en donde ∃ 𝜇 ∈ {1,2,… , 𝑝} para el que se
cumple que 𝒙𝜇 ≠ 𝒚𝜇 . Nótese que puede haber memorias heteroasociativas con 𝑛 =
𝑚.
19
En los problemas donde intervienen las Memorias asociativas, se consideran dos fases
importantes: La fase de aprendizaje, que es donde se genera la Memoria asociativa a partir de las
𝑝 asociaciones del conjunto fundamental, idea que se puede apreciar en el siguiente esquema:
𝒙 → 𝚳 ← 𝒚
y la fase de recuperación que es donde la Memoria asociativa opera sobre un patrón de entrada,
idea que se esquematiza a continuación:
𝒙 → 𝚳 → 𝒚
A fin de especificar las componentes de los patrones, se requiere la notación para dos
conjuntos a los que llamaremos arbitrariamente 𝐴 y 𝐵. Las componentes de los vectores columna
que representan a los patrones, tanto de entrada como de salida, serán elementos del conjunto 𝐴,
y las entradas de la matriz 𝚳 serán elementos del conjunto 𝐵.
No hay requisitos previos ni limitaciones respecto de la elección de estos dos conjuntos, por
lo que no necesariamente deben ser diferentes o poseer características especiales.
Po convención, cada vector columna que representa a un patrón de entrada tendrá 𝑛
componentes cuyos valores pertenecen al conjunto 𝐴, y cada vector columna que representa a un
patrón de salida tendrá 𝑚 componentes cuyos valores pertenecen también al conjunto 𝐴; es decir:
𝒙𝜇 ∈ 𝐴𝑛 y 𝒚𝜇 ∈ 𝐴𝑚 ∀ 𝜇 ∈ {1,2,… , 𝑝}. La 𝑗-ésima componente de un vector columna se indicará
con la misma letra del vector, pero sin negrilla, colocando a 𝑗 como subíndice: la 𝑗 -ésima
componente del vector columna 𝒙𝜇 se representa por 𝑥𝑗𝜇
.
𝒙𝝁 =
{
𝑥1𝜇
𝑥2𝜇
⋮𝑥𝑛𝜇}
∈ 𝐴𝑛, 𝒚𝝁 =
{
𝑦1𝜇
𝑦2𝜇
⋮𝑦𝑚𝜇}
∈ 𝐴𝑚
Memorias Asociativas Alfa-Beta
Las Memorias Asociativas Alfa-Beta, por su parte, son de dos tipos y pueden operar en dos
modos diferentes. El operador 𝛼 es utilizado en la fase de aprendizaje, mientras que el operador 𝛽
es útil durante la fase de recuperación. Estos dos operadores fueron definidos de manera tabular y
20
sus propiedades demostradas fueron demostradas [18]; a continuación se muestran las tablas que
representan a los operadores 𝛼 y 𝛽; dados los conjuntos 𝐴 = {0,1} y 𝐵 = {0,1,2}.
La definición de los operadores Alfa-Beta se pueden apreciar en la tabla 1.
𝛼 ∶ 𝐴 × 𝐴 → 𝐵 𝛽 ∶ 𝐵 × 𝐴 → 𝐴
𝑥 𝑦 𝛼(𝑥, 𝑦) 𝑥 𝑦 𝛽(𝑥, 𝑦) 0 0 1 0 0 0
0 1 0 0 1 0
1 0 2 1 0 0
1 1 1 1 1 1
2 0 1
2 1 1
Tabla 2. Definición de los operadores Alfa y Beta
La operación binaria 𝛼 exhibe propiedades algebraicas expuestas en la tabla 2.
𝛼(𝑥, 𝑥) = 1
(𝑥 ≤ 𝑦) ↔ 𝛼(𝑥, 𝑦) ≤ 𝛼(𝑦, 𝑥) (𝑥 ≤ 𝑦) ↔ [𝛼(𝑥, 𝑧) ≤ 𝛼(𝑦, 𝑧)] (𝑥 ≤ 𝑦) ↔ [𝛼(𝑧, 𝑥) ≤ 𝛼(𝑧, 𝑦)] 𝛼[(𝑥 ⋁ 𝑦), 𝑧] = 𝛼(𝑥, 𝑧) ⋁ 𝛼(𝑦, 𝑧) 𝛼[(𝑥 ⋀ 𝑦), 𝑧] = 𝛼(𝑥, 𝑧) ⋀ 𝛼(𝑦, 𝑧)
Tabla 3. Propiedades de la operación binaría α
En la tabla 2 se muestran propiedades algebraicas de la operación binaria 𝛽.
𝛽(1, 𝑥) = 𝑥
𝛽(𝑥, 𝑥) = 𝑥 ∀𝑥 ∈ 𝐴
(𝑥 ≤ 𝑦) ↔ [𝛽(𝑥, 𝑧) ≤ 𝛽(𝑦, 𝑧)] (𝑥 ≤ 𝑦) ↔ [𝛽(𝑧, 𝑥) ≤ 𝛽(𝑧, 𝑦)] 𝛽[(𝑥 ⋁ 𝑦), 𝑧] = 𝛽(𝑥, 𝑧) ⋁ 𝛽(𝑦, 𝑧) 𝛽[(𝑥 ⋀ 𝑦), 𝑧] = 𝛽(𝑥, 𝑧) ⋀ 𝛽(𝑦, 𝑧) 𝛽[𝑥, (𝑦 ⋁ 𝑧)] = 𝛽(𝑥, 𝑦) ⋁ 𝛽(𝑥, 𝑧) 𝛽[𝑥, (𝑦 ⋀ 𝑧)] = 𝛽(𝑥, 𝑦) ⋀ 𝛽(𝑥, 𝑧)
Tabla 4. Propiedades de la operación β
En la tabla 4 se presentan las propiedades algebraicas de la aplicación combinada de los
operadores 𝛼 y 𝛽.
𝛽[𝛼(𝑥, 𝑦), 𝑦] = 𝑥
𝛽[𝛼(𝑥, 𝑦), 𝑥] = 𝑥
𝛽[𝛼(𝑥, 𝑥), 𝑦] = 𝑦
Tabla 5. Propiedades de la aplicación combinada de los operadores α y β
21
Máquinas de Soporte Vectorial
Las Máquinas de Soporte Vectorial (Support Vector Machines, SVM por sus siglas en
inglés), funcionan como un clasificador biclase que minimiza simultáneamente el error empírico
de clasificación y maximiza algunas características de las métricas involucradas [3]. El problema
básico en el que se desarrolla este modelo es el de separar un hiperplano 𝑛-dimensional en dos
clases, por medio de un hiperplano 𝑛 − 1-dimensional. Sin embargo pueden llegar a existir más
de un hiperplano que logre este objetivo. El objetivo de las SVM es encontrar el hiperplano
óptimo que mejor generalice la clasificación. Para ello se utiliza el concepto de vector de soporte,
que se refiere a los patrones más cercanos al hiperplano buscado; dichos patrones se encuentran
en la frontera de las clases [3]. En la Ilustración 9 se puede apreciar de manera gráfica el
concepto de hiperplano [28] y en la Ilustración 10 se exhibe de manera gráfica el concepto de
vector de soporte [28].
Ilustración 9. Concepto de hiperplano de las SVM
Ilustración 10. Concepto de Vector de soporte de las SVM
22
Memorias Asociativas Alfa-Beta con Soporte Vectorial
Las Memorias Asociativas Alfa-Beta con Soporte Vectorial (AlfaBetaSVM), nacen de la
fusión de dos modelos; por una lado se utilizan los operadores 𝛼 y 𝛽 de las memorias asociativas
Alfa-Beta y por otro, se toma la idea del vector de soporte de las SVM, cabe mencionar que el
concepto de vector de soporte desarrollado en las AlfaBetaSVM es totalmente diferente al
concepto en SVM [3]. La idea principal de este modelo es aprovechar aquella información
repetida en todos los patrones del conjunto fundamental.
Modelo de las Máquinas Asociativas Alfa-Beta con Soporte Vectorial
A continuación se presenta la descripción gráfica del modelo AlfaBetaSVM.
Sea el conjunto fundamental mostrado en la Ilustración 11, llevar a cabo las fases de
Aprendizaje y Recuperación [3].
Ilustración 11. Conjunto fundamental.
Fase de aprendizaje.
Se obtiene el vector de soporte, conformado por la intersección de todos los patrones, es
decir, la información presente repetida en todo el conjunto fundamental. El resultado se puede ver
en la Ilustración 12.
Ilustración 12. Patrón con la información presente repetida, Vector de soporte
23
Ahora se elimina del conjunto fundamental la información presente redundante. El
resultado se puede apreciar en la Ilustración 13.
Ilustración 13. Conjunto fundamental con la información presente en todos los patrones fundamentales eliminada
Por otro lado se debe tratar la información ausente, esto se logra negando al conjunto
fundamental. Resultado mostrado en la Ilustración 14.
Ilustración 14. Conjunto fundamental de información ausente
Se necesita calcular el vector de soporte para la información ausente. Es decir toda la
información repetida ausente en el conjunto fundamental. Ver Ilustración 15.
Ilustración 15. Patrón con la información ausente repetida, Vector de soporte
Eliminar el vector de soporte de la información ausente, al conjunto fundamental de
información ausente, para obtener el conjunto fundamental de información ausente, con
información ausente presente en todos los patrones, eliminada. El resultado se muestra en la
Ilustración 16.
24
Ilustración 16. Conjunto fundamental de información ausente, con la información ausente repetida eliminada
Fase de recuperación.
Se tiene el siguiente patrón desconocido, ver Ilustración 17.
Ilustración 17. Patrón desconocido
Se elimina la información repetida del conjunto fundamental, ver Ilustración 18.
Ilustración 18. Patrón desconocido al que se le ha eliminado la información presente repetida
Se obtiene la información ausente del patrón desconocido, ver Ilustración 19.
Ilustración 19. Patrón de información ausente del patrón desconocido
Se restringe la información ausente del patrón desconocido con el vector de soporte del
conjunto fundamental de información ausente, ver Ilustración 20.
25
Ilustración 20. Patrón de información ausente del patrón desconocido, al que se le ha eliminado la información ausente repetida
Se compara el patrón desconocido al que se le ha eliminado la información presente
repetida en todo el conjunto fundamental (ver Ilustración 18), con los patrones del conjunto
fundamental sin la información presente repetida (ver Ilustración 13); y por otro lado, se compara
el patrón desconocido de información ausente al que se le ha eliminado la información ausente
repetida en todo el conjunto fundamental con información ausente (ver Ilustración 20), con los
patrones del conjunto fundamental de información ausente sin la información ausente repetida
(ver Ilustración 16); podemos observar que el patrón fundamental que menos diferencias presenta
es el tercero mostrado en la Ilustración 13.
Como resultado del modelo de las máquinas asociativas Alfa-Beta se obtiene el patrón
mostrado en la ilustración 21.
Ilustración 21. Patrón de salida
Algoritmo de las Máquinas Asociativas Alfa-Beta con Soporte Vectorial
El algoritmo AlfaBetaSVM ataca problemas de Reconocimiento de Patrones en los cuales
el conjunto fundamental debe expresarse de la siguiente forma {(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝} con
𝒙𝜇 ∈ 𝐴𝑛 ∀ 𝜇 ∈ {1,2,3, … , 𝑝}, siendo 𝑛, 𝑝 ∈ ℤ+ y 𝐴 = {0,1}.
La ejecución de AlfaBetaSVM se divide en dos fases principales; la primera es la fase de
aprendizaje, donde el algoritmo será entrenado con un conjunto de datos dado; la segunda es la
26
fase de recuperación donde al presentarle un patrón desconocido al algoritmo, éste asociará
dicho patrón al patrón más similar con los que fue entrenado [3].
Fase de aprendizaje
1. A partir del conjunto fundamental calcular el vector de soporte 𝑺, que se puede interpretar
como la intersección de todos los patrones pertenecientes al conjunto fundamental.
La componente 𝑖-ésima del vector 𝑺, se calcula de acuerdo a la siguiente expresión:
𝑺𝑖 =
{
⋀𝛽(𝒙𝑖
2𝑘−1, 𝒙𝑖2𝑘)
𝑝2
𝑘=1
𝑠𝑖 𝑝 𝑒𝑠 𝑝𝑎𝑟
𝛽
[
⋀𝛽(𝒙𝑖2𝑘−1, 𝒙𝑖
2𝑘)
𝑝−12
𝑘=1
, 𝒙𝑖𝑝
]
𝑠𝑖 𝑝 𝑒𝑠 𝑛𝑜𝑛
2. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝} , obtener 𝒙𝜇|𝑺 , que es eliminar la información redundante
existente en el conjunto fundamental.
A partir de estos resultados formar el conjunto fundamental restringido
{(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}
3. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝒙𝜇, el vector negado de 𝒙𝜇.
Con los 𝑝 vectores negados se forma el conjunto fundamental negado
{(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}
4. A partir del conjunto fundamental negado, calcular el vector de soporte 𝑺.
5. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝒙𝜇|�̂�.
A partir de estos resultados formar el conjunto fundamental negado restringido
{(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}
Fase de recuperación
Sea �̃� ∈ 𝐴𝑛 cuyo patrón asociado 𝒙𝜇 se desconoce de antemano.
1. Obtener la Restricción �̃�|𝑺.
2. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺)
3. Encontrar 𝜓 𝜖 {1,2,3, … , 𝑝} tal que
𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) =⋀𝜃(�̃�|𝑺 , 𝒙
𝜇|𝑺)
𝑝
𝜇=1
27
4. Obtener �̃�, el vector negado de �̃�.
5. Obtener la Restricción �̃�|�̂�.
6. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)
7. Encontrar 𝜑 𝜖 {1,2,3, … , 𝑝} tal que
𝜃 (�̃�|�̂� , 𝒙𝜑|
�̂�) =⋀𝜃(�̃�|
�̂� , 𝒙𝜇|
�̂�)
𝑝
𝜇=1
8. Si 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) ≤ 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�), realizar la asignación 𝜔 = 𝜓; de otro modo, realizar la
asignación 𝜔 = 𝜑.
9. Obtener (𝒙𝜔|𝑺)|𝑺, que es precisamente el vector 𝒙𝜔.
Si �̃� es un vector del conjunto fundamental se garantiza que la recuperación es correcta.
Para adentrar con mayor profundidad al algoritmo AlfaBetaSVM revise el Apéndice 1
donde se desarrolla un caso práctico completamente detallado.
Codificación Binaria
El modelo AlfaBetaSVM funciona con patrones binarios, la codificación binaria que mejor
se adapta al modelo de las Memorias Asociativas Alfa-Beta es la de Johnson-Möbius modificada,
codificación propuesta en [19].
Para generar el código Johnson-Möbius de un número que se encuentra en el rango de 0 a
𝑛 − 1, es necesario 𝑛/2 bits. Ver tabla 6.
Número 𝑏0 𝑏1 𝑏2 𝑏3 0 0 0 0 0 1 1 0 0 0 2 1 1 0 0 3 1 1 1 0 4 1 1 1 1 5 0 1 1 1 6 0 0 1 1 7 0 0 0 1
Tabla 6. Código Johnson-Möbius
28
El código Johnson-Möbius modificado utiliza sólo los códigos entre 0 y 𝑛/2 , donde 𝑛/2 es
el número máximo (𝑛𝑚𝑎𝑥) a representar y además se invierte el orden de los bits, los bits más
significativos pasan a ser los menos significativos y viceversa. Para representar un número que se
encuentre en el rango de 0 a 𝑛𝑚𝑎𝑥 serán necesarios 𝑛𝑚𝑎𝑥 bits.
Por ejemplo [19]:
Si 𝑛𝑚𝑎𝑥 es 20 y queremos representar los números 3, 7, 11, 17, 19 en el código Johnson-
Möbius modificado tendremos:
Cada código tendrá 20 bits.
Para el número 3 se tendrán 20 − 3 = 17 ceros seguidos de 3 unos.
Para el número 7 se tendrán 20 − 7 = 13 ceros seguidos de 7 unos
Para el número 11 se tendrán 20 − 11 = 9 ceros seguidos de 11 unos
Para el número 17 se tendrán 20 − 17 = 3 ceros seguidos de 17 unos
Para el número 19 se tendrán 20 − 19 = 1 ceros seguidos de 19 unos
Los códigos correspondientes se muestran en la tabla 7.
Número Código Johnson-Möbius modificado
3 00000000000000000111
7 00000000000001111111
11 00000000011111111111
17 00011111111111111111
19 01111111111111111111
Tabla 7. Códigos Johnson-Möbius modificado
La limitante principal que presenta el algoritmo de codificación Johnson-Möbius
modificado es que no contempla un rango de valores, es decir, supongamos que tenemos patrones
en el conjunto de entrenamiento con valores máximos de 15 pero en el conjunto de prueba
existen patrones con valores máximos de 20, la codificación no coincidirá.
Para resolver este problema nosotros modificamos el algoritmo original agregando la
opción de establecer intervalos de conversión, así podemos proponer el rango de valores que
puede abarcar nuestro conjunto de datos.
29
Algoritmo mejorado para la obtención del código Johnson-Möbius modificado
1. Sea un conjunto de números reales
{𝑟1, 𝑟2, … , 𝑟𝑖 , … , 𝑟𝑛| 𝑛𝑚𝑖𝑛 ≤ 𝑟 ≤ 𝑛𝑚𝑎𝑥}
donde 𝑛 es un número entero positivo fijo.
Nota:
Si 𝑛𝑚𝑖𝑛 y 𝑛𝑚𝑎𝑥 no están establecidos, 𝑛𝑚𝑖𝑛 será el valor mas pequeño del
conjunto, y 𝑛𝑚𝑎𝑥 será el valor más grande del conjunto.
2. Se crea un nuevo conjunto transformado a través de la operación “restar 𝑛𝑚𝑖𝑛 a
cada uno de los 𝑛 números y a los límites 𝑛𝑚𝑖𝑛 y 𝑛𝑚𝑎𝑥”.
{𝑡1, 𝑡2, … , 𝑡𝑖 , … , 𝑡𝑛}
donde:
𝑡𝑗 = {
𝑛𝑚𝑖𝑛, 𝑠𝑖 𝑟𝑗 < 𝑛𝑚𝑖𝑛
𝑟𝑗 − 𝑛𝑚𝑖𝑛, 𝑠𝑖 𝑛𝑚𝑖𝑛 ≤ 𝑟𝑗 ≤ 𝑛𝑚𝑎𝑥
𝑛𝑚𝑎𝑥, 𝑠𝑖 𝑟𝑗 > 𝑛𝑚𝑎𝑥 , ∀𝑗 ∈ {1,2,… , 𝑛}
El nuevo valor de 𝑛𝑚𝑖𝑛 será 𝑛𝑚𝑖𝑛 = 𝑛𝑚𝑖𝑛 − 𝑛𝑚𝑖𝑛 = 0.
El nuevo valor de 𝑛𝑚𝑎𝑥 será 𝑛𝑚𝑎𝑥 = 𝑛𝑚𝑎𝑥 − 𝑛𝑚𝑖𝑛.
3. Escoger un número fijo 𝑑 de decimales y truncar cada uno de los números del
conjunto transformado (los cuales son no negativos) precisamente a 𝑑 decimales.
4. Realizar un escalamiento de 10𝑑 en el conjunto del paso 3, para que finalmente nos
quede un conjunto de 𝑛 enteros no negativos.
{𝑒1, 𝑒2, … , 𝑒𝑖 , … , 𝑒𝑛}
5. El código Johnson-Möbius modificado para cada 𝑗 = 1,2, … , 𝑛 se obtiene al generar
(𝑛𝑚𝑎𝑥 − 𝑒𝑗) ceros concatenados por la derecha con 𝑒𝑗 unos.
30
Ejemplo 1
Paso 1
𝑟 = {0.2,1.25, −0.3,2.147}
𝑛𝑚𝑖𝑛 = −0.3
𝑛𝑚𝑎𝑥 = 2.147
Paso 2
Se obtiene el conjunto transformado
𝑡 = {0.5,1.55,0.0,2.447}
𝑛𝑚𝑎𝑥 = 2.447
Paso 3
Se escoge el número fijo 𝑑 = 1 para obtener
𝑡 = {0.5,1.5,0.0,2.4}
𝑛𝑚𝑎𝑥 = 2.4
Paso 4
Se realiza el escalamiento de 10𝑑 para obtener
𝑒 = {5,15,0,24}
𝑛𝑚𝑎𝑥 = 24
Paso 5
Para cada número 𝑒𝑖 del conjunto 𝑒, se generan (𝑛𝑚𝑎𝑥 − 𝑒𝑖) ceros concatenados con 𝑒𝑖
unos.
Los resultados se muestran en la tabla 8.
5 000000000000000000011111 15 000000000111111111111111 0 000000000000000000000000 24 111111111111111111111111
Tabla 8. Resultados de código Johnson-Möbius modificado
31
Ejemplo 2
Codificación de 3 instancias del dataset Iris.
El contenido que se aprecia en la tabla 9, fue extraído del dataset Iris:
@RELATION iris
@ATTRIBUTE sepallength REAL @ATTRIBUTE sepalwidth REAL
@ATTRIBUTE petallength REAL @ATTRIBUTE petalwidth REAL @ATTRIBUTE class {Iris-setosa,Iris-versicolor,Iris-virginica}
@DATA 5.1,3.5,1.4,0.2,Iris-setosa
7.0,3.2,4.7,1.4,Iris-versicolor 6.3,3.3,6.0,2.5,Iris-virginica
Tabla 9. Parte del dataset Iris Plant
Paso 1
Se tienen 5 conjuntos de datos, para los primeros 4 cada conjunto de datos representa a
cada uno de los atributos y un último conjunto de datos que representa a la clase del dataset Iris
[31]. La codificación se aplicará solo a los atributos.
El rango de valores para el atributo sepallength es de 4.3 ≤ 𝑥 ≤ 7.9.
El rango de valores para el atributo sepalwidth es de 2.0 ≤ 𝑥 ≤ 4.4.
El rango de valores para el atributo petallength es de 1.0 ≤ 𝑥 ≤ 6.9.
El rango de valores para el atributo petalwidth es de 0.1 ≤ 𝑥 ≤ 2.5.
𝑟1 = {5.1,7.0,6.3}
𝑛𝑚𝑖𝑛1 = 4.3
𝑛𝑚𝑎𝑥1 = 7.9
𝑟2 = {3.5,3.2,3.3}
𝑛𝑚𝑖𝑛2 = 2.0
𝑛𝑚𝑎𝑥2 = 4.4
32
𝑟3 = {1.4,4.7,6.0}
𝑛𝑚𝑖𝑛3 = 1.0
𝑛𝑚𝑎𝑥3 = 6.9
𝑟4 = {0.2,1.4,2.5}
𝑛𝑚𝑖𝑛4 = 0.1
𝑛𝑚𝑎𝑥4 = 2.5
Paso 2
Se obtiene el conjunto transformado
𝑡1 = {0.8,2.7,2.0}
𝑛𝑚𝑎𝑥1 = 3.6
𝑡2 = {1.5,1.2,1.3}
𝑛𝑚𝑎𝑥2 = 2.4
𝑡3 = {0.4,3.7,5.0}
𝑛𝑚𝑎𝑥3 = 5.9
𝑡4 = {0.1,1.3,2.4}
𝑛𝑚𝑎𝑥4 = 2.4
Paso 3
Se escoge el número fijo 𝑑 = 1 para los 4 atributos.
𝑡1 = {0.8,2.7,2.0}
𝑛𝑚𝑎𝑥1 = 3.6
𝑡2 = {1.5,1.2,1.3}
𝑛𝑚𝑎𝑥2 = 2.4
𝑡3 = {0.4,3.7,5.0}
33
𝑛𝑚𝑎𝑥3 = 5.9
𝑡4 = {0.1,1.3,2.4}
𝑛𝑚𝑎𝑥4 = 2.4
Paso 4
Se realiza el escalamiento de 10𝑑 para obtener
𝑒1 = {8,27,20}
𝑛𝑚𝑎𝑥1 = 36
𝑒2 = {15,12,13}
𝑛𝑚𝑎𝑥2 = 24
𝑒3 = {4,37,50}
𝑛𝑚𝑎𝑥3 = 59
𝑒4 = {1,13,24}
𝑛𝑚𝑎𝑥4 = 24
Paso 5
Para cada número 𝑒𝑖𝑗 del conjunto 𝑒𝑖, se generan (𝑛𝑚𝑎𝑥 − 𝑒𝑖𝑗) ceros concatenados con 𝑒𝑖𝑗
unos. Los resultados se muestran en las tablas 10-13.
sepallength Código Johnson-Möbius modificado
5.1 000000000000000000000000000011111111 7.0 000000000111111111111111111111111111 6.3 000000000000000011111111111111111111
Tabla 10. Código Johnson-Möbius modificado para sepallength
sepalwidth Código Johnson-Möbius modificado
3.5 000000000111111111111111 3.2 000000000000111111111111 3.3 000000000001111111111111
Tabla 11. Código Johnson-Möbius modificado para sepalwidth
34
petallength Código Johnson-Möbius modificado
1.4 00000000000000000000000000000000000000000000000000000001111 4.7 00000000000000000000001111111111111111111111111111111111111 6.0 00000000011111111111111111111111111111111111111111111111111
Tabla 12. Código Johnson-Möbius modificado para petallength
petalwidth Código Johnson-Möbius modificado
0.2 000000000000000000000001 1.4 000000000001111111111111 2.5 111111111111111111111111
Tabla 13. Código Johnson-Möbius modificado para petalwidth
Dado que es de vital importancia reducir el consumo de recursos, es necesario utilizar una
representación abreviada para la codificación Johnson-Möbius modificada, para esto basta con
definir dos valores separados por una diagonal (/)
𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑐𝑒𝑟𝑜𝑠 / 𝑐𝑎𝑛𝑡𝑖𝑑𝑎𝑑 𝑑𝑒 𝑢𝑛𝑜𝑠
Utilizando la representación abreviada con los códigos resultantes del ejemplo anterior, es
posible reducir considerablemente la cadena representativa de un código Johnson-Möbius
modificado, la forma abreviada se muestra a continuación en las tablas 14-17.
sepallength Código Johnson-Möbius modificado
5.1 28/8 7.0 9/27 6.3 16/20
Tabla 14. Código Johnson-Möbius modificado abreviado para sepallength
sepalwidth Código Johnson-Möbius modificado
3.5 9/15 3.2 12/12 3.3 11/13
Tabla 15. Código Johnson-Möbius modificado abreviado para sepalwidth
petallength Código Johnson-Möbius modificado
1.4 55/4 4.7 23/37 6.0 9/50
Tabla 16. Código Johnson-Möbius modificado abreviado para petallength
petalwidth Código Johnson-Möbius modificado
0.2 23/1 1.4 11/13 2.5 0/24
Tabla 17. Código Johnson-Möbius modificado abreviado para petalwidth
35
Para adentrar con mayor profundidad al algoritmo AlfaBetaSVM empleando la
codificación Binaria revise el Apéndice 2 donde se desarrolla un caso práctico completamente
detallado.
Memorias Asociativas Alfa-Beta con Soporte Vectorial
empleando el código Johnson-Möbius modificado abreviado
El modelo AlfaBetaSVM original se aplica a los patrones codificados con Johnson-Möbius
modificado y dado el comportamiento del código podemos visualizar que la codificación binaria
no es necesaria para poder llevar a cabo la fase de entrenamiento y de recuperación, basta con
emplear la codificación Johnson-Möbius modificada en su forma abreviada.
Algoritmo de las Máquinas Asociativas Alfa-Beta con Soporte Vectorial sin
codificación binaria
El algoritmo ABSVM sin codificación binaria ataca problemas de reconocimiento de
patrones en los cuales el conjunto fundamental debe expresarse de la siguiente forma
{(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝} con 𝒙𝜇 ∈ 𝐴𝑛 ∀ 𝜇 ∈ {1,2,3, … , 𝑝}, siendo 𝑛, 𝑝, 𝐴 ∈ ℤ+.
Cada componente del vector está expresada con el código Johnson-Möbius modificado,
ejemplo:
𝒙𝜇 = (𝑤/𝑥⋮𝑦/𝑧
)
Entonces el conjunto fundamental se construirá empleando el segundo valor en cada
componente como se muestra a continuación
𝒙𝜇 = (𝑥⋮𝑧
)
36
Fase de aprendizaje
1. A partir del conjunto fundamental calcular el vector de soporte 𝑺, que se puede interpretar
como la intersección de todos los patrones pertenecientes al conjunto fundamental.
La componente 𝑖-ésima del vector 𝑺, se calcula de acuerdo a la siguiente expresión:
𝑺𝑖 = min(𝒙𝑖𝑘, … , 𝒙𝑖
𝑝) , 𝑘 = 1,2,… , 𝑝
2. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝒙𝜇|𝑺
La componente 𝑖-ésima del vector 𝒙𝜇|𝑺, se calcula de acuerdo a la siguiente expresión:
[𝒙|𝑺]𝑖 = 𝒙𝑖 − 𝑺𝑖
A partir de estos resultados formar el conjunto fundamental restringido
{(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}
3. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝒙𝜇, el vector negado de 𝒙𝜇.
Como los patrones están expresados con el código Johnson-Möbius modificado el
conjunto fundamental negado será generado empleando el primer valor de cada
componente como se expresa a continuación
𝒙𝜇 = (𝑤⋮𝑦
)
Con los 𝑝 vectores negados se forma el conjunto fundamental negado
{(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}
4. A partir del conjunto fundamental negado, calcular el vector de soporte 𝑺.
La componente 𝑖-ésima del vector 𝑺, se calcula de acuerdo a la siguiente expresión:
𝑺𝑖 = min (𝒙𝑘𝑖 , … , 𝒙𝑝𝑖) , 𝑘 = 1,2, … , 𝑝
5. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝒙𝜇|�̂�.
La componente 𝑖-ésima del vector 𝒙𝜇|𝑺, se calcula de acuerdo a la siguiente expresión:
[𝒙𝜇|�̂�]𝑖= 𝒙𝜇𝑖 − 𝑺𝑖
A partir de estos resultados formar el conjunto fundamental negado restringido
{(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}
37
Fase de recuperación
Sea �̃� ∈ 𝐴𝑛 cuyo patrón asociado 𝒙𝜇 se desconoce de antemano.
�̃� = (𝑠/𝑡⋮𝑢/𝑣
)
Dado que el patrón está expresado con el código Johnson-Möbius modificado, debemos
tratarlo como se muestra a continuación
�̃� = (𝑡⋮𝑣
)
1. Obtener la Restricción �̃�|𝑺.
La componente 𝑖-ésima del vector �̃�|𝑺, se calcula de acuerdo a la siguiente expresión:
[�̃�|𝑺]𝑖 = �̃�𝑖 − 𝑺𝑖
2. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺)
El valor escalar 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) se define como
𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) =∑𝐴𝑏𝑠(�̃�|𝑺𝑖 − 𝒙
𝜇|𝑺𝑖)
𝑛
𝑖=1
3. Encontrar 𝜓 𝜖 {1,2,3, … , 𝑝} tal que
𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) =⋀𝜃(�̃�|𝑺 , 𝒙
𝜇|𝑺)
𝑝
𝜇=1
4. Obtener �̃�, el vector negado de �̃�.
Como los patrones están expresados con el código Johnson-Möbius modificado el patrón
negado será generado empleando el primer valor de cada componente como se expresa a
continuación
�̃� = (𝑠⋮𝑢
)
5. Obtener la Restricción �̃�|�̂�.
38
La componente 𝑖-ésima del vector �̃�|�̂�, se calcula de acuerdo a la siguiente expresión:
[�̃�|�̂�]𝑖= �̃�𝑖 − 𝑺𝑖
6. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)
El valor escalar 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�) se define como
𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�) =∑𝐴𝑏𝑠 (�̃�|
�̂�𝑖− 𝒙𝜇|
�̂�𝑖)
𝑛
𝑖=1
7. Encontrar 𝜑 𝜖 {1,2,3, … , 𝑝} tal que
𝜃 (�̃�|�̂� , 𝒙𝜑|
�̂�) =⋀𝜃(�̃�|
�̂� , 𝒙𝜇|
�̂�)
𝑝
𝜇=1
8. Si 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) ≤ 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�), realizar la asignación 𝜔 = 𝜓; de otro modo, realizar la
asignación 𝜔 = 𝜑.
9. Obtener (𝒙𝜔|𝑺)|𝑺, que es precisamente el vector 𝒙𝜔.
Nota. Si �̃� es un vector del conjunto fundamental se garantiza que la recuperación es
correcta.
Para adentrar con mayor profundidad al algoritmo AlfaBetaSVM sin usar codificación
binaria revise el Apéndice 3 donde se desarrolla un caso práctico completamente detallado.
39
Problema
El problema es claro, se pretende incrementar el catálogo actual de la plataforma WEKA,
con el algoritmo de clasificación del grupo Alfa-Beta; con el propósito de ofrecer más
herramientas en el proceso de clasificación dentro de la Minería de datos. En un inicio
analizaremos la plataforma de WEKA, funcionamiento, composición y extensión; para añadir el
algoritmo AlfaBetaSVM.
Objetivos
Objetivo general
Implementar en JAVA el algoritmo de clasificación AlfaBetaSVM e integrarlo en WEKA
para aplicarse al Reconocimiento de Patrones.
Objetivos específicos
Dominar el algoritmo AlfaBetaSVM.
Conocer a fondo la composición en cuanto a clasificadores en la plataforma WEKA.
Identificar los requerimientos esenciales para la integración de un nuevo algoritmo
de clasificación.
Integrar el algoritmo AlfaBetaSVM a WEKA
Pruebas del correcto funcionamiento del algoritmo AlfaBetaSVM en WEKA.
Contexto de desarrollo
Este proyecto se desarrolla en el contexto de las materias Trabajo Terminal I y II, diseñadas
expresamente para efectos de titulación con modalidad curricular, de la licenciatura Ingeniería en
40
Sistemas Computacionales de la Escuela Superior de Cómputo del Instituto Politécnico Nacional,
bajo la supervisión del Dr. Cornelio Yánez Márquez y el Dr. Luis Octavio López Leyva.
El equipo de desarrollo que lleva a cabo este proyecto es el siguiente:
Líder de proyecto: Irvin Ortiz Ochoa
Arquitecto de Software: Abraham Chavez Lara, Irvin Ortiz Ochoa
Analista/Desarrollo: Abraham Chavez Lara, Irvin Ortiz Ochoa
Programador: Abraham Chavez Lara, Irvin Ortiz Ochoa
Tester: Abraham Chavez Lara, Irvin Ortiz Ochoa
Usuario final: Profesionales en el área de Aprendizaje Automático.
Proyecto
El proyecto se desarrollará bajo el lenguaje de programación JAVA, que es el lenguaje en
el cual esta implementado WEKA. El ambiente de desarrollo será Netbeans 7.3.1, usando el JDK
(Java Development Kit) versión 1.7. Se trabajará bajo el sistema operativo Windows 8 x64.
El equipo de desarrollo demuestra contar con las capacidades necesarias para la finalización
del proyecto en tiempo y forma.
Recursos
A continuación se listan lo recursos necesarios para el desarrollo del sistema.
2 PC o laptop con los siguientes requerimientos:
o Hardware
2 Gb de memoria RAM o superior.
3 Gb de memoria en disco duro o superior.
Procesador de 2.0 GHz o superior.
o Software
Windows 8 x64.
AltovaUModel 2013
Netbeans 7.3.1
WEKA 3.6.10
WEKA 3.7.10 (Versión de desarrollo)
Paquetería Microsoft Office 2013
41
Se usará NetBeans como ambiente de desarrollo, debido a que ofrece comodidad en el
desarrollo de proyectos, el equipo de trabajo está familiarizado con esta plataforma por el uso que
le ha dado a lo largo de la estancia en ESCOM, existe soporte en la Wiki de WEKA y el amplio
dominio del IDE con el que el equipo cuenta.
Utilizaremos la aplicación AltovaUModel en la sección de análisis y diseño debido a que
nos ofrece herramientas de ingeniería inversa a partir del código fuente JAVA. AltovaUModel
actualiza el modelo UML con los cambios realizados en el código fuente, y viceversa, actualiza el
código fuente con los cambios realizados en el modelo. Es ideal para procesos de desarrollo
iterativo y permite distribuir tareas a los miembros del equipo.
Organización del documento
La organización del documento está dividida por capítulos de acuerdo a las fases de la
metodología RUP [29].
En la fase de Inicio, se proporciona una visión del proyecto, también se identifican las
planificaciones y los alcances para cada una de las siguientes fases.
La fase de Elaboración abarca el modelado del proyecto, la identificación de los requisitos
y el diseño del proyecto.
En la fase de Construcción, se desarrolla la construcción del proyecto se afinan requisitos y
se proponen mejoras al proyecto.
La fase de Transición, verifica que el software desarrollado cumpla con los requerimientos
definidos previamente aplicando las pruebas pertinentes.
42
Capítulo 2. Inicio
Sección 2.1. Gestión del proyecto
Planificación del proyecto
La Tabla 18, muestra la planificación de actividades previstas para llevar a cabo el
desarrollo del proyecto.
Actividad a desarrollar
Junta con los integrantes del equipo para iniciar
organización
Planificación de actividades
Lectura de material sobre funcionamiento de WEKA
Lectura de material sobre composición de WEKA
Lectura de material sobre extensión de WEKA
Lectura de material del algoritmo AlfaBetaSVM
Práctica teórica del algoritmo AlfaBetaSVM
Programación del algoritmo AlfaBetaSVM
Lectura de material del algoritmo Código Johnson
Möbius Modificado
Práctica teórica del algoritmo Código Johnson Möbius
Modificado
Programación del algoritmo Código Johnson Möbius
Modificado
Identificar los requerimientos para la integración de un
algoritmo de clasificación y preprocesamiento
Clasificar el algoritmo AlfaBetaSVM dentro del catálogo
de algoritmos de la plataforma WEKA
Clasificar el algoritmo Código Johnson Möbius
Modificado dentro del catálogo de algoritmos de la
plataforma WEKA
Diseño del diagrama de casos de uso de WEKA
Diseño de diagramas de secuencia de algoritmo
AlfaBetaSVM
Diseño del diagrama de clases de WEKA
Diseño del diagrama de clase AlfaBetaSVM
Diseño del diagrama de clase Código Johnson Möbius
43
Modificado
Programación de los métodos necesarios para integrar el
algoritmo de clasificación en WEKA
Programación de los métodos necesarios para integrar el
algoritmo de preprocesmiento en WEKA
Integración local de los algoritmos AlfaBetaSVM
Pruebas de correcto funcionamiento
Construir el paquete para publicación
Tabla 18. Planificación del proyecto
Diario de ejecución
En la Tabla 19, se detallan las fechas en las que las actividades fueron desarrolladas y el
tiempo invertido.
Día Actividad desarrollada
Dedicación
estimada (Horas
de trabajo)
12/agosto/2013 Junta con los integrantes del equipo para iniciar
organización 2
13/agosto/2013 Planificación de actividades 16
19/agosto/2013 Lectura de material sobre funcionamiento de WEKA 20
26/agosto/2013 Lectura de material sobre composición de WEKA 20
2/septiembre/2013 Lectura de material sobre extensión de WEKA 20
9/septiembre/2013 Lectura de material del algoritmo AlfaBetaSVM 40
23/septiembre/2013 Práctica teórica del algoritmo AlfaBetaSVM 20
30/septiembre/2013 Programación del algoritmo AlfaBetaSVM 12
14/octubre/2013 Lectura de material del algoritmo Código Johnson
Möbius Modificado 40
21/octubre/2013 Práctica teórica del algoritmo Código Johnson Möbius
Modificado 20
28/octubre/2013 Programación del algoritmo Código Johnson Möbius
Modificado 12
4/noviembre/2013 Identificar los requerimientos para la integración de un
algoritmo de clasificación y preprocesamiento 8
7/noviembre/2013 Clasificar el algoritmo AlfaBetaSVM dentro del
catálogo de algoritmos de la plataforma WEKA 6
11/noviembre/2013
Clasificar el algoritmo Código Johnson Möbius
Modificado dentro del catálogo de algoritmos de la
plataforma WEKA
6
18/noviembre/2013 Diseño del diagrama de casos de uso de WEKA 4
44
19/noviembre/2013 Diseño de diagramas de secuencia de algoritmo
AlfaBetaSVM 4
21/noviembre/2013 Diseño del diagrama de clases de WEKA 4
26/noviembre/2013 Diseño del diagrama de clase AlfaBetaSVM 4
27/noviembre/2013 Diseño del diagrama de clase Código Johnson Möbius
Modificado 4
21/enero/2014 Programación de los métodos necesarios para integrar
el algoritmo de clasificación en WEKA 120
21/febrero/2014 Programación de los métodos necesarios para integrar
el algoritmo de preprocesamiento en WEKA 120
21/marzo/2014 Integración local del algoritmo AlfaBetaSVM 40
5/abril/2014 Pruebas de correcto funcionamiento 60
14/abril/2014 Construir el paquete para publicación 10
Total de horas dedicadas al proyecto 612
Tabla 19. Diario de ejecución
45
Sección 2.2. Modelado del proyecto
Clasificación en WEKA Para integrar un nuevo clasificador debemos clasificarlo dentro de las familias de
algoritmos con los que cuenta WEKA que se encuentran en paquete weka.classifiers y se
mencionan a continuación:
bayes. Clasificadores bayesianos.
functions. Redes neuronales.
lazy. Clasificadores de lento aprendizaje.
meta. Clasificadores que usan uno o más clasificadores como base.
mi. Clasificadores que manejan datos de varias instancias
misc. Clasificadores que no encajan en ninguna otra categoría
rules. Clasificadores basados en reglas de aprendizaje.
trees. Clasificadores que utilizan árboles de decisión.
WEKA no contiene familia alguna de clasificadores usando Memorias Asociativas, por lo
que se creará una nueva familia denominada Associative Memories (Memorias Asociativas),
empleando una abreviatura “am”.
Dentro de la familia “am” se almacenarán los algoritmos de la familia Alfa-Beta.
Todos los algoritmos que empleen las Memorias Asociativas Alfa-Beta, deberán ser
identificados bajo un nombre iniciado por “AlfaBeta” seguido de una o más palabras
características del algoritmo, en este trabajo terminal en particular se integrarán las Memorias
Asociativas Alfa-Beta con Soporte Vectorial, el nombre que identificará este algoritmo en
WEKA será: AlfaBetaSVM.
Requisitos para integrar un algoritmo en WEKA
Todos los clasificadores en WEKA implementan la interfaz Classifier, ubicada en el
paquete weka.classifiers.
Para integrar un nuevo clasificador se debe implementar esta interfaz con el fin de que la
clase GenericObjectEditor se encargue de hacerla funcionar con todas las interfaces de WEKA.
Con el fin de hacer que las implementaciones de nuevos clasificadores sean más fáciles, WEKA
46
viene con una colección de otras interfaces y clases abstractas que implementan a su vez la
interfaz Classifier. A continuación se muestra una descripción de las clases mencionadas:
Clasificador simple
o AbstractClassifier. No genera números aleatorios.
o RandomizableClassifier. Genera números aleatorios.
Clasificador meta
o Con base en un clasificador.
SingleClassifierEnhancer. No genera números aleatorios y no es
iterativo.
RandomizableSingleClassifierEnhancer. Genera números aleatorios
y no es iterativo.
IteratedSingleClassifierEnhancer. No genera números aleatorios y
es iterativo.
RandomizableIteratedSingleClassifierEnhancer. Genera números
aleatorios y es iterativo.
o Con base en múltiples clasificadores.
MultipleClassifiersCombiner. No genera números aleatorios.
RandomizableMultipleClassifiersCombiner. Genera números
aleatorios.
Podemos agregar funcionalidad al algoritmo utilizando alguna de las siguientes interfaces:
weka.core.UpdateableClassifier. Permite al algoritmo poder trabajar de manera
incremental.
weka.core,AdditionalMeasureProducer . Regresa información acerca del clasificador.
weka.core.WeightedInstanceHandler. Permite al algoritmo trabajar con datasets con
ponderaciones específicas de cada atributo.
weka.core.TechnicalInformationHandler. Regresa información acerca de publicaciones
en las que está basada la implementación.
Con la información anterior, el algoritmo AlfaBetaSVM hereda de la superclase
AbstractClassifier e implementa la interfaz TechnicalInformationHandler.
47
Para integrar el algoritmo son obligatorios los siguientes métodos.
globalInfo(). En este método se debe dar una breve explicación del algoritmo.
listOptions().Debe devolver un vector con los parámetros del propio algoritmo.
setOptions(String[]). Guarda los parámetros en variables globales del programa.
getOptions(). Debe devolver un vector con las opciones del algoritmo. Debe coincidir con
las opciones del método setOptions(String[]).
buildClassifier(Instances).Genera el modelo del clasificador.
toString(). Devuelve el modelo construido.
getCapabilities(). Devolverá el tipo de datos que el clasificador podrá manejar.
distributionForInstance(Instance). Este método debe devolver un array de probabilidades
de la predicción dado un objeto Instance.
classifyInstance(Instance).Clasificar una instancia dada.
getTechnicalInformation(). Devuelve información técnica acerca del algoritmo.
main(String[]). Se utilizará para ejecutar el algoritmo desde línea de comandos.
La correcta implementación del algoritmo podrá visualizarse dentro de las 4
funcionalidades que ofrece WEKA:
Explorer
Experimenter
Knowledge Flow
CLI
Paquetes de preprocesamiento en WEKA
Para integrar un nuevo algoritmo de preprocesamiento debemos clasificarlo dentro de las
familias de algoritmos con los que cuenta WEKA que se encuentran en paquete weka.filters y se
mencionan a continuación:
supervised. Algoritmos que tienen en cuenta el atributo de clase.
o attribute. Algoritmos que procesan columna por columna el dataset.
o instance. Algoritmos que procesan fila por fila el dataset.
48
unsupervised. Algoritmos que no tienen en cuenta el atributo de clase.
o attribute. Algoritmos que procesan columna por columna el dataset.
o instance. Algoritmos que procesan fila por fila el dataset.
El codificador Johnson Möbius Modificado será colocado en el paquete
weka.filters.unsupervised.attribute. Debido a que no es necesario tomar en cuenta el atributo de
clase y procesará atributo por atributo el dataset.
Requisitos para integrar un algoritmo de preprocesamiento en
WEKA
En WEKA, se debe distinguir entre dos tipos principales de algoritmos de
preprocesamiento:
batch filters. Ven la estructura e información del dataset antes de comenzar su
proceso.
stream filters. Procesan la salida de inmediato y la información va pasando
conforme se está procesando.
Se debe implementar una clase que sobrescriba los métodos abstractos de las siguientes
clases abstractas, dependiendo de lo que el algoritmo realice:
weka.filters.SimpleBatchFilter
weka.filters.SimpleStreamFilter
Para integrar un nuevo algoritmo de preprocesamiento de cualquiera de las dos clases
abstractas es necesario implementar los siguientes métodos abstractos, teniendo en cuenta las
diferencias de cada clase:
globalInfo().Devuelve una descripción de lo que hace el algoritmo.
determineOutputFormat(Instances). Genera el nuevo formato basado en el dataset
de entrada.
process(Instances).Procesa el dataset.
getRevision().Devuelve información sobre la revisión del algoritmo.
listOptions().Devuelve una enumeración de las opciones disponibles.
49
setOptions(String[]).Analiza y registra el conjunto de opciones especificado.
getOptions().Devuelve las opciones actuales del algoritmo.
De lo anterior, definimos que el codificador Johnson Möbius Modificado implementará la
clase SimpleBatchFilter debido a el algoritmo necesita obtener información del dataset antes de
comenzar a procesarlo.
La correcta implementación del algoritmo podrá visualizarse dentro de las 4
funcionalidades que ofrece WEKA:
Explorer
Experimenter
Knowledge Flow
CLI
Integración de un algoritmo a WEKA
En este apartado se describe cómo se puede integrar el paquete que contiene el algoritmo
AlfaBetaSVM, para su publicación a través del sistema de gestión de paquetes de WEKA.
Debido a este sistema de gestión, es fácil compartir un paquete con otros usuarios.
De forma predeterminada, WEKA en su versión para desarrolladores; almacena paquetes y
demás información en “C:\Users\NombreUsuario\wekafiles”. Dicha ubicación se puede cambiar
estableciendo ésta como una variable de entorno para su plataforma.
Para agregar la variable de entorno:
Dirigirse al Panel de control, en la opción “Sistema y Seguridad” seleccionar la opción
“Sistema”. En esta ventana presionar la opción “Configuración avanzada del sistema” se abrirá la
ventana “Propiedades del Sistema”, en esta ventana presionar “Variables de entorno”, en la
sección “Variables del sistema”, editar la variable “Path”, agregando al final de la lista de valores
“C:\Users\NombreUsuario\wekafiles” separándolo por “;” y presionar el botón “Aceptar”.
En el interior de “C:\Users\NombreUsuario\wekafiles” se encuentra el archivo de registro
principal (weka.log) y los siguientes directorios:
Packages
50
Contiene los paquetes instalados. Cada paquete está contenido en su propio
subdirectorio.
Props
Mantiene varios archivos de propiedades JAVA utilizados por WEKA.
repCache
Contiene la copia en caché de los metadatos del repositorio del paquete central. Si el
contenido de este directorio se dañara, puede ser eliminado con seguridad y WEKA
volverá a crear en el siguiente reinicio.
systemDialogs
Contiene los archivos de marcadores, que se crean cuando se marca la casilla "No
volver a mostrar este mensaje " en varios cuadros de diálogo emergentes del
sistema. La eliminación de este directorio o su contenido hará que WEKA muestre
los avisos de nuevo.
Estructura de un paquete para publicación
Un paquete WEKA es un archivo zip.
El paquete que contiene el algoritmo AlfaBetaSVM,que contiene un clasificador y el
algoritmo de preprocesamiento Código Johnson Möbius Modificado; se entrega en un archivo
llamado AlfaBetaSVM.zip. Al descomprimir el archivo zip crea la siguiente estructura de
directorios:
<Directorio actual>
+-AlfaBetaSVM.jar
+-Description.props
+-build_package.xml
+-src
| +-main
| | +-java
| | +-weka
| | +-classifiers
| | +-am
| | +-AlfaBetaSVM.java
51
| | +-filters
| | +-unsupervised
| | +-attribute
| | +- JohnsonMobiusModifiedCode.java
| +-test
| +-java
| +-weka
| +-classifiers
| +-am
| +-AlfaBetaSVMTest.java
| | +-filters
| | +-unsupervised
| | +-attribute
| | +- JohnsonMobiusModifiedCodeTest.java
+-lib
+-doc
Durante la instalación, el gestor de paquetes de WEKA utiliza el valor del campo
"PackageName" en el archivo Description.props para crear un directorio en
“C:\Users\NombreUsuario\wekafiles\packages” y mantener el contenido del paquete. El
contenido del directorio doc contiene el javadoc para las clases AlfaBetaSVM y
JohnsonMobiusModifiedCode.
Un paquete debe tener un archivo Description.props y contener al menos un archivo JAR
con las clases Java compiladas. El gestor de paquetes cargará todos los archivos con extensión
*.jar que se encuentran en el directorio raíz y el directorio lib. Otros archivos son opcionales,
pero si el paquete es de código abierto, entonces se debe incluir el código fuente y un archivo ant
de construcción que se pueda utilizar para compilar el código.
El archivo de descripción
Como se mencionó anteriormente un paquete WEKA debe contener el archivo
Description.props que proporciona los metadatos en el paquete. El gestor de paquetes utiliza
estos archivos para comparar lo que se instala, lo que está disponible y resolver dependencias.
A continuación se muestra en el archivo Description.props:
52
# Package name (required)
PackageName= AlfaBetaSVM
# Version (required)
Version=1.0.0
#Date (year-month-day)
Date=2014-04-14
# Title (required)
Title= AlfaBeta Associtive Memories with Support Vector Machine
# Category (recommended)
Category=Classification
# Author (required)
Author= Irvin Ortiz <[email protected]>, Abraham Chavez <[email protected]>
# Maintainer (required)
Maintainer= Irvin Ortiz <[email protected]>, Abraham Chavez
# License (required)
License= GPL v3.0
# Description (required)
Description= This package contains the AlfaBetaSVM Classifer that performs
prediction applied to handwritten digits recognition, namely in the MNIST
database.
# Package URL for obtaining the package archive (required)
PackageURL= https://www.dropbox.com/s/sbhz6t7bseuupwz/AlfaBetaSVM.zip
# URL for further information
URL= http://www.repositoriodigital.ipn.mx/handle/123456789/7047
# Dependencies
Depends=weka (>=3.7.10)
A continuación describiremos los campos de este archivo.
Las líneas que comienzan con “#” son comentarios.
53
Los campos PackageName, Version, Title, Category, Autor, Maintainer, Description y
PackageURL son obligatorios, los demás campos son opcionales.
Los campos PackageName y Version dan el nombre del paquete y la versión,
respectivamente. El nombre puede contener letras, números o punto. No debe comenzar con un
punto y no debe contener espacios. El número de versión es una secuencia de tres números
enteros no negativos separados por “.” o “-“.
El campo Title debe dar una descripción del paquete con una frase. El campo Description
puede dar una descripción más larga del paquete, este campo puede incluir referencias técnicas y
puede utilizar el formato HTML.
El campo Category es muy recomendable ya que esta información se muestra tanto en la
página web de repositorio y en el cliente de gestor de paquetes GUI. En este último, el usuario
puede ordenar los paquetes sobre la base del campo de categoría. Se recomienda que se asigne a
una categoría existente. Algunos ejemplos incluyen (Classification, Text classification, Ensemble
learning, Regression, Clustering, Associations, Preprocessing, Visualization, Explorer,
Experimenter, KnowledgeFlow).
El campo Author indica el autor que escribió el paquete y puede incluir varios nombres
(separados por comas), direcciones de correo electrónico (se pueden dar entre paréntesis
angulares después de cada nombre). Este para los lectores y ninguna dirección de correo
electrónico se extrae automáticamente.
El campo Maintainer indica quién dará mantenimiento al paquete y debe incluir una sola
dirección de correo electrónico entre corchetes angulares, para enviarle informes de errores.
El campo License muestra la licencia o licencias que se aplican al paquete. Este campo
puede contener la especificación de una licencia. La palabra Unlimited indica que no hay
restricciones en la distribución o el uso.
El campo PackageURL indica la URL válida que apunta al archivo zip del paquete. Esta
URL será utilizada por el gestor de paquetes para descargar e instalar el paquete.
Integración del paquete
Es posible integrar el paquete am en WEKA de dos maneras, en ambas el hospedaje del
paquete zip es responsabilidad del contribuidor.
54
La primera y oficial, es ponerse en contacto con la persona que da mantenimiento a
WEKA (normalmente también el administrador de la página principal WEKA) y el suministrarle
el archivo Description.props de su paquete. El equipo WEKA descargará y usará el paquete para
asegurarse de que no hay problemas con lo que se ha especificado en el archivo
Description.props, además de verificar que el software se ejecuta, verifica que no contenga
ningún código malicioso. Si todo está bien, entonces el paquete se convertirá en un paquete
WEKA "oficial” y los metadatos del repositorio de paquetes centrales se actualizarán con el
archivo Description.props del paquete. La responsabilidad de mantener y apoyar el paquete
reside en el contribuidor.
Diagramas de Casos de uso
Casos de usos de WEKA
Diagrama 1. Casos de usos de WEKA
55
Casos de usos de Explorer
Diagrama 2. Casos de uso para Clasificación usando Explorer
56
Especificación de Casos de usos
CU1: Explorer
Resumen: El usuario selecciona la aplicación Explorer de la plataforma WEKA. Podrá
interactuar con las principales componentes que ofrece WEKA:
Preprocess. Importación del dataset, tratamiento de la información con la
aplicación de Filtros.
Classify. Aplicar algoritmos de clasificación al dataset seleccionados.
Cluster. Aplicación de técnicas de clustering y agrupamiento.
Associate. Aplicación de reglas de asociación.
Select attributes. Aplicación de procedimientos para identificar los atributos más
relevantes.
Visualize. Muestra gráficas de puntos dispersos para ser analizado en mayor detalle.
Autor: Irvin Ortiz Ochoa
Revisado por: Abraham Chavez Lara
Caso de Uso: CU1
Resumen de atributos
Actor Usuario
Propósito Interacción con las principales componentes que ofrece WEKA
Entradas Ninguna
Salidas Ninguna
Precondiciones Plataforma WEKA iniciada
Postcondiciones Aplicación Explorer iniciada
Tipo Primario
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Oprime el botón Explorer en la interfaz Weka GUI Chooser de la plataforma
WEKA.
2. Sistema. Muestra la pantalla de Weka Explorer, con el panel Preprocess seleccionado y
habilitado. Los paneles Classify, Cluster, Associate, Select attributes y Visualize se
muestran deshabilitados. Trayectoria 1.
Fin de trayectoria.
57
Trayectoria Alternativa 1
El usuario cierra la aplicación Explorer.
Condición: El actor presiona el botón Cerrar.
1. Sistema. Cierra la pantalla Weka Explorer.
2. Sistema. Muestra la pantalla Weka GUI Chooser.
Fin de trayectoria.
58
CU1.1: Preprocess
Resumen: El usuario selecciona el dataset y decide si filtrarlo o no.
Autor: Abraham Chavez Lara
Revisado por: Irvin Ortiz Ochoa
Caso de Uso: CU1.1
Resumen de atributos
Actor Usuario
Propósito Preprocesamiento de datos
Entradas Ninguna
Salidas Dataset
Precondiciones Aplicación Explorer ejecutada
Postcondiciones Control sobre un dataset
Tipo Secundario. Viene del caso de uso CU1
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Ejecuta el CU1.1.1. Trayectoria 1
2. Sistema. Se representa el resultado de CU1.1.1. Trayectoria 2
Fin de trayectoria.
Trayectoria Alternativa 1
Condición: El actor no ejecuta el CU1.1.1
1. Sistema. Permanece desactivada cualquier acción.
Fin de trayectoria.
Trayectoria Alternativa 2
Condición: El actor ejecuta el CU1.1.2.
1. Sistema. Representa el resultado de CU1.1.2.
Fin de trayectoria
59
CU1.1.1: Open file
Resumen: El usuario podrá abrir un dataset para manipularlo en la aplicación Explorer.
Autor: Irvin Ortiz Ochoa
Revisado por: Abraham Chavez Lara
Caso de Uso: CU1.1.1
Resumen de atributos
Actor Usuario
Propósito Manipulación de un dataset
Entradas Ruta de ubicación del dataset
Salidas Ninguna
Precondiciones El dataset debe existir
Postcondiciones Dataset listo para manipulación
Tipo Secundario. Viene del caso de uso CU1.1
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Presiona el botón Open file en el panel Preprocess de la pantalla Weka Explorer.
2. Sistema. Muestra una ventana con la estructura de directorios del usuario actual.
3. Actor. Selecciona la ubicación del dataset.
4. Actor. Selecciona el dataset.
5. Actor. Presiona el botón Open. Trayectoria 1.
6. Sistema. Muestra: Nombre de la relación, número de instancias y número de atributos del
dataset seleccionado.
7. Sistema. Lista todos los atributos existentes en el dataset seleccionado, en la sección
Attributes.
8. Sistema. Para cada atributo de la relación del dataset, en la sección Selected attribute
muestra el valor mínimo, el valor máximo, el valor promedio y la desviación estándar de
todas las instancias.
Fin de trayectoria
Trayectoria Alternativa 1
El usuario cancela la carga del dataset.
Condición: EL usuario presiona el botón Cancel.
1. Sistema. Cierra la ventana con la estructura de directorios del usuario actual.
2. Sistema. Ejecuta caso de uso CU1.1
Fin de trayectoria
60
CU1.1.2: Filter
Resumen: El usuario filtra un dataset.
Autor: Abraham Chavez Lara
Revisado por: Irvin Ortiz Ochoa
Caso de Uso: CU1.1.2
Resumen de atributos
Actor Usuario
Propósito Filtrado de datos
Entradas Dataset
Salidas Dataset filtrado
Precondiciones Dataset cargado en la aplicación
Postcondiciones Dataset filtrado
Tipo Secundario. Viene del caso de uso CU1.1
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Presiona el botón Choose en la sección Filters. Trayectoria 1.
2. Sistema. Muestra una colección de algoritmos de filtrado de datos.
3. Actor. Selecciona un algoritmo
4. Sistema. Muestra información general del algoritmo en la sección filters.
5. Actor. Presiona el botón Apply.
6. Sistema. Filtra los datos y representa la información en la pestaña Preprocess.
Fin de trayectoria.
Trayectoria Alternativa 1
Condición: El usuario no desea filtrar los datos
3. Sistema. Mantiene la representación de datos.
4. Actor. Se direcciona al CU1.2
Fin de trayectoria.
61
CU1.2: Classify
Resumen: El usuario podrá aplicar algoritmos de clasificación al dataset seleccionado.
Autor: Irvin Ortiz Ochoa
Revisado por: Abraham Chavez Lara
Caso de Uso: CU1.2
Resumen de atributos
Actor Usuario
Propósito Iniciar la configuración para la clasificación de la información de un
dataset
Entradas Ninguna
Salidas Ninguna
Precondiciones Dataset cargado en la aplicación
Postcondiciones Catálogo de algoritmos disponible para su aplicación
Tipo Secundario. Viene del caso de uso CU1
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Presiona la pestaña Classify de la pantalla Weka Explorer.
2. Sistema. Habilita el catálogo de algoritmos de clasificación en el panel de Classify.
Fin de trayectoria.
62
CU1.2.1: Choose classifier
Resumen: El usuario selecciona un algoritmo clasificador.
Autor: Abraham Chavez Lara
Revisado por: Irvin Ortiz Ochoa
Caso de Uso: CU1.2.1
Resumen de atributos
Actor Usuario
Propósito Configuración de un modelo de clasificación
Entradas Dataset
Salidas Configuración de un modelo de clasificación
Precondiciones Dataset cargado en la aplicación
Postcondiciones Un modelo de clasificación configurado
Tipo Secundario. Viene del caso de uso CU1.2
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Presiona el botón Choose en la sección Classifier.
2. Sistema. Muestra una colección de algoritmos de clasificación de patrones.
3. Actor. Selecciona un algoritmo. Trayectoria 1.
4. Sistema. Muestra información general del algoritmo en la sección Classifier. Trayectoria
2, Trayectoria 3.
5. Actor. Presiona el botón Start.
6. Sistema. Ejecuta el CU1.2.2
Fin de la trayectoria.
Trayectoria Alternativa 1
Condición: El usuario no selecciona un clasificador.
1. Sistema. Mantiene la representación de datos.
Fin de trayectoria.
Trayectoria Alternativa 2
Condición: El usuario desea configurar las opciones del clasificador.
1. Actor. Presiona el botón More options.
2. Sistema. Muestra la ventana Classifier evaluation options.
3. Actor. Configura las opciones del clasificador y presiona el botón Ok.
4. Sistema. Establece la configuración del modelo clasificador.
Fin de trayectoria.
63
Trayectoria Alternativa 3
Condición: El usuario desea configurar la evaluación del rendimiento del clasificador
1. Actor. Selecciona una opción del panel Test options. Las opciones disponibles son: Use
training set, Supplied test set, Cross-validation y Percentage split.
2. Sistema. Establece la configuración de evaluación de rendimiento para el modelo de
clasificación.
Fin de trayectoria.
64
CU1.2.2: Start classifier
Resumen: El usuario podrá aplicar uno de los algoritmos de clasificación al dataset
seleccionado.
Autor: Irvin Ortiz Ochoa
Revisado por: Abraham Chavez Lara
Caso de Uso: CU1.2.2
Resumen de atributos
Actor Usuario
Propósito Clasificación de la información de un dataset
Entradas Dataset
Salidas Resultados de la ejecución y evaluación del algoritmo clasificador.
Precondiciones Dataset cargado en la aplicación
Postcondiciones Modelo de clasificación ejecutado
Tipo Secundario. Viene del caso de uso CU1.2
Trayectorias del caso de uso
Trayectoria principal
1. Actor. Presiona el botón Start de la pantalla Weka Explorer.
2. Sistema. Ejecuta el modelo de clasificación.
Fin de trayectoria.
65
CU1.2.3: Visualize classifier output
Resumen: El sistema muestra el resultado de la ejecución y evaluación del modelo de
clasificación de manera textual.
Autor: Abraham Chavez Lara
Revisado por: Irvin Ortiz Ochoa
Caso de Uso: CU1.2.3
Resumen de atributos
Actor Sistema
Propósito Visualizar el resultado de la ejecución y evaluación del modelo
clasificador de forma textual
Entradas Resultados de la ejecución y evaluación del clasificador
Salidas Resultados de la ejecución y evaluación del clasificador de forma
textual
Precondiciones Ejecución y evaluación de un modelo clasificador
Postcondiciones Visualización de resultados
Tipo Secundario. Viene del caso de uso CU1.2
Trayectorias del caso de uso
Trayectoria principal
1. Sistema. Muestra los resultados de la ejecución y evaluación de un modelo clasificador
de manera textual en la pestaña Classify.
Fin de trayectoria.
66
Capítulo 3. Elaboración
Sección 3.1. Análisis y Diseño
Diagramas de Clases
Algoritmo AlfaBetaSVM
Diagrama 3. Clases del Algoritmo AlfaBetaSVM
67
Clase Classifier en WEKA
Diagrama 4. Clases de Classifier en WEKA
68
Diagramas de paquetes
Diagrama de paquetes de WEKA
Diagrama 5. Paquetes de la plataforma WEKA
Diagrama de paquetes de Classifiers en WEKA
Diagrama 6. Paquetes del paquete Classifiers en WEKA
Es recomendable revisar el Apéndice 4, para continuar con la fase de Construcción.
69
Capítulo 4. Construcción
Sección 4.1. Análisis y Diseño
Diagramas de Clases
Clase AlfaBetaSVM
Diagrama 7. Diagrama de clases AlfaBetaSVM
70
Clase JohnsonMobiusModifiedCode
Diagrama 8. Diagrama de clases Johnson-Möbius modificado
71
Diagramas de paquetes
Diagrama de paquetes de Classifiers en WEKA
Diagrama 9. Paquetes del paquete Classifiers en WEKA
Sección 4.2. Implementación
El código aquí presentado es solo el más importante en la creación del codificador y
clasificador.
Codificador Johnson-Möbius modificado
/**
* Returns the Johnson-Möbius modified code of the value.
*
* @param value the value to convert
* @param min the min value of the range for conversion
* @param max the max value of the range for conversion
* @param nDecimals the number of decimal places
* @return Johnson-Möbius modified code of the value
*/
72
private String convert(double value, BigDecimal min, BigDecimal max, int nDecimals) {
BigDecimal bdValue = new BigDecimal("" + value);
if (bdValue.compareTo(min) == -1) {
bdValue = new BigDecimal("" + min);
} else if (bdValue.compareTo(max) == 1) {
bdValue = new BigDecimal("" + max);
}
BigDecimal maxValue;
BigDecimal tmpValue;
BigDecimal maxTruncated;
BigDecimal tmpTruncated;
BigDecimal tmpScaled;
BigDecimal maxScaled;
StringBuilder result = new StringBuilder();
maxValue = max.subtract(min);
tmpValue = bdValue.subtract(min);
// Truncate value to nDecimals decimals places//
tmpTruncated = truncate(tmpValue, nDecimals);
maxTruncated = truncate(maxValue, nDecimals);
// Scale number to 10^nDecimals //
tmpScaled = scale(tmpTruncated, nDecimals);
maxScaled = scale(maxTruncated, nDecimals);
// For each number t, concatenate maxValue-tmpValue times '0' with tmpValue times '1'
//
result.append(maxScaled.subtract(tmpScaled).intValue()).append("/").append(tmpScaled.intValue());
return result.toString();
}
Tabla 20. Código del método convert
73
Clasificador AlfaBetaSVM
/**
* Generates the classifier.
*
* @param data the data to train the classifier with
* @throws IllegalArgumentException if num-slots is lower than 1
* @throws Exception if classifier can't be built successfully
*/
@Override
public void buildClassifier(Instances data) throws Exception {
if (m_numExecutionSlots < 1) {
throw new IllegalArgumentException("Number of execution slots needs to be >= 1!");
}
m_attributeIndex = new int[data.numAttributes()-1];
/**
* This snippet code fills an array of indices of attributes ignoring the class.
*/
int tmpIndex = 0;
for (int i = 0; i < data.numAttributes(); i++) {
if( i != data.classIndex() ){
m_attributeIndex[tmpIndex++] = i;
}
}
m_instanceClass = new double[data.size()];
if (m_useJMMC) {
// <editor-fold defaultstate="collapsed" desc="buildClassifier() using AlfaBetaSVM
Real">
m_maxValueAttribute = new double[m_attributeIndex.length];
double[] tmpBounds;
for (int i = 0; i < m_attributeIndex.length; i++) {
tmpBounds = parseAttribute(data.firstInstance().toString(m_attributeIndex[i]));
m_maxValueAttribute[i] = tmpBounds[0]+tmpBounds[1];
}
double[][] jmm_fundamentalSet = new double[m_attributeIndex.length][data.size()];
double[][] jmm_deniedFundamentalSet = new
double[m_attributeIndex.length][data.size()];
m_jmm_S = new double[m_attributeIndex.length];
m_jmm_nS = new double[m_attributeIndex.length];
74
int tmpIndex_S = 0;
int tmpIndex_nS = 0;
for( int i = 0 ; i < m_attributeIndex.length ; i++ ){
for (int j = 0; j < data.size(); j++) {
tmpBounds = parseAttribute(data.instance(j).stringValue(m_attributeIndex[i]));
jmm_fundamentalSet[i][j] = tmpBounds[1];
jmm_deniedFundamentalSet[i][j] = tmpBounds[0];
if( jmm_fundamentalSet[i][j] < jmm_fundamentalSet[i][tmpIndex_S]){
tmpIndex_S = j;
}
if( jmm_deniedFundamentalSet[i][j] < jmm_deniedFundamentalSet[i][tmpIndex_nS]){
tmpIndex_nS = j;
}
m_instanceClass[j] = data.instance(j).value(data.classIndex());
}
m_jmm_S[i] = jmm_fundamentalSet[i][tmpIndex_S];
m_jmm_nS[i] = jmm_deniedFundamentalSet[i][tmpIndex_nS];
}
m_jmm_restrictedFundamentalSet_S = new double[m_attributeIndex.length][data.size()];
m_jmm_restrictedDeniedFundamentalSet_nS = new
double[m_attributeIndex.length][data.size()];
for( int i = 0 ; i < m_attributeIndex.length ; i++ ){
for (int j = 0; j < data.size(); j++) {
m_jmm_restrictedFundamentalSet_S[i][j] = jmm_fundamentalSet[i][j] - m_jmm_S[i];
m_jmm_restrictedDeniedFundamentalSet_nS[i][j] = jmm_deniedFundamentalSet[i][j] -
m_jmm_nS[i];
}
}
// </editor-fold>
} else {
// <editor-fold defaultstate="collapsed" desc="buildClassifier() using AlfaBetaSVM
Original">
m_attributeLength = new int[m_attributeIndex.length];
m_instanceLength = 0;
for (int i = 0; i < m_attributeIndex.length; i++) {
m_attributeLength[i] = data.firstInstance().toString(m_attributeIndex[i]).length();
m_instanceLength += m_attributeLength[i];
}
75
Bits[] binary_fundamentalSet = new Bits[data.size()];
// Convert instances to Bits and save index class for each pattern //
for (int i = 0; i < data.size(); i++) {
binary_fundamentalSet[i] = instanceToBits(data.instance(i));
m_instanceClass[i] = data.instance(i).value(data.classIndex());
}
m_binary_restrictedFundamentalSet_S = new Bits[binary_fundamentalSet.length];
Bits[] binary_deniedFundamentalSet = new Bits[binary_fundamentalSet.length];
m_binary_restrictedDeniedFundamentalSet_nS = new Bits[binary_fundamentalSet.length];
// Learning phase of AlfaBetaSVM //
// 1 Calculate the Support Vector S from fundamental set //
m_binary_S = supportVector(binary_fundamentalSet);
m_executor = Executors.newFixedThreadPool(m_numExecutionSlots);
ArrayList<Future<Bits>> futureTask = new
ArrayList<Future<Bits>>(binary_fundamentalSet.length);
// 2 Obtain the restricted version of all the fundamental patterns by S //
for (int i = 0; i < binary_fundamentalSet.length; i++) {
futureTask.add(m_executor.submit(new Restriction(this, m_binary_S,
binary_fundamentalSet[i])));
}
m_executor.shutdown();
while (!m_executor.isTerminated());
for (int i = 0; i < binary_fundamentalSet.length; i++) {
m_binary_restrictedFundamentalSet_S[i] = futureTask.get(i).get();
}
futureTask.clear();
// 3 Obtain the denied version of all the fundamental patterns //
for (int i = 0; i < binary_fundamentalSet.length; i++) {
binary_deniedFundamentalSet[i] = binary_fundamentalSet[i].deny();
}
// 4 Obtain the Support Vector ¬S from restricted fundamental set //
m_binary_nS = supportVector(binary_deniedFundamentalSet);
m_executor = Executors.newFixedThreadPool(m_numExecutionSlots);
76
// 5 Obtain the denied restricted fundamental set by ¬S //
for (int i = 0; i < binary_deniedFundamentalSet.length; i++) {
futureTask.add(m_executor.submit(new Restriction(this, m_binary_nS,
binary_deniedFundamentalSet[i])));
}
m_executor.shutdown();
while (!m_executor.isTerminated());
for (int i = 0; i < binary_fundamentalSet.length; i++) {
m_binary_restrictedDeniedFundamentalSet_nS[i] = futureTask.get(i).get();
}
futureTask.clear();
// </editor-fold>
}
}
Tabla 21. Código del método buildClassifier
77
Capítulo 5. Transición
Sección 5.1. Implementación
Construcción del paquete para WEKA
Al tener la codificación de manera local y con la intención de hacer público el algoritmo
AlfaBetaSVM debemos seguir una serie de pasos para configurar otro proyecto en el IDE
NetBeans que nos permitirá la generación del paquete para WEKA en formato zip.
Para poder llevar a cabo este procedimiento debemos utilizar el repositiorio SVN de
WEKA y obtener la última versión de la distribución de la plataforma.
La URL del repositorio es https://svn.cms.waikato.ac.nz/svn/weka/, al ingresar desde un
navegador podremos visualizar el contenido del repositorio, ver Ilustración 22.
Ilustración 22. Repositorio WEKA
78
Del repositorio WEKA vamos a realizar una copia de los directorios /trunk/weka y
/trunk/packages, ver Ilustración 22.
El objetivo de obtener una copia del directorio /trunk/weka es para tener en primer lugar la
referencia del proyecto WEKA y en segundo para utilizar el archivo ant build.xml que trae todas
las definiciones de los comandos para la compilación y creación del paquete. Ver ilustración 23.
Ilustración 23. Contenido del directorio weka de WEKA
Al hacer una copia del directorio /trunk/packages podremos visualizar la organización de
los paquetes que utilizan los desarrolladores de WEKA, además de que podremos emplear los
archivos build_package.xml y Description.props contenidos en /trunk/packages/templates, que
son necesarios para llevar a cabo la construcción del paquete. Ver Ilustración 24.
79
Ilustración 24. Contenido del directorio trunk/packages/templates de WEKA
Conociendo los directorios que necesitamos del repositorio SVN de WEKA, podremos
llevar a cabo la construcción del paquete en el IDE NetBeans.
1. Abrir el IDE Netbeans. Ver Ilustración 25.
Ilustración 25. IDE NetBeans
80
2.- Seleccionar el menú Team – Subversion – Checkout. Ver Ilustración 26.
Ilustración 26. Selección de menú
3. En la ventana de la herramienta Checkout, pondremos la URL del repositorio SVN de
WEKA. Presionar el botón Next. Ver Ilustración 27.
Ilustración 27. URL del respositorio de WEKA
81
Al presionar el botón Next, el IDE NetBeans intentará conectarse con el repositorio SVN.
Ver Ilustración 28.
Ilustración 28. Conexión al respositorio de WEKA
4. De ser exitosa la conexión, en la ventana de la Ilustración 29 presionaremos el botón
Browse de la opción Repository Folder(s).
Ilustración 29. Menú de repositorio
82
5. En la ventana emergente (ver Ilustración 30), podremos visualizar el árbol de directorios
del repositorio SVN WEKA, aquí seleccionaremos los directorios /trunk/packages/templates y
/trunk/weka. Presionamos el botón OK.
Ilustración 30. Contenido de los directorios del repositorio de WEKA
6. Al haber seleccionado los directorios que queremos importar, regresaremos a la
Ilustración 29, aquí por ultimo seleccionaremos el directorio donde se situará la descarga del
contenido de los directorios seleccionados. Para este caso nosotros elegimos una carpeta en la
raíz del disco C, llamándola WekaSVN. Dejamos tildada la opción Scan for NetBeans Projects
after Checkout. Presionar el botón Finish. Ver Ilustración 31.
83
Ilustración 31. Configuración de copia de repositorio
7. Después de esperar un momento a que concluya la descarga del repositorio SVN de
WEKA, el IDE NetBeans nos avisará de que se encontraron proyectos y si deseamos abrirlos.
Seleccionamos Open Project…, ver Ilustración 32.
Ilustración 32. Copia de repositorio concluida
8. Ordenamos la lista de proyectos dando click en el encabezado de columnas Nodes y
buscamos el proyecto weka-dev, lo seleccionamos y presionamos Open. Ver Ilustración 33.
84
Ilustración 33. Selección de proyecto a abrir
9. Podremos visualizar el proyecto weka-dev en la lista de proyectos del IDE NetBeans (ver
Ilustración 34), que nos permitirá tener lista nuestra dependencia y poder ser usada como
referencia en la construcción de nuestro paquete.
Ilustración 34. Proyecto listo en el IDE NetBeans
85
10. Ahora debemos crear nuestro proyecto AlfaBetaSVM. Seleccionamos el menú File –
New Project…, ver Ilustración 35.
Ilustración 35. Creación de nuevo proyecto
11. El tipo de proyecto que crearemos será Maven Java Application, para lograr esto de la
lista de categorías seleccionamos Maven y de la lista de proyectos seleccionamos Java
Application. Presionamos Next. Ver Ilustración 36.
Ilustración 36. Selección del tipo de proyecto
86
12. Al proyecto lo denotaremos AlfaBetaSVM, la ubicación del proyecto será en
C:\WekaSVN\packages\external dado que el algoritmo que se quiere integrar en la plataforma
WEKA es externo al desarrollo que realizan los programadores de WEKA, ver Ilustracion 37.
Ilustración 37. Localización para almacenar el proyecto
En Group Id, pondremos mx.ipn.escom.tt2013a012, en Versión pondremos 1.0-
SNAPSHOT y el campo de Package quedará vacío. Presionamos Finish. Ver Ilustración 38.
87
Ilustración 38. Configuración de nuevo proyecto
Con esto tendremos listo nuestro proyecto para poder ser utilizado en el IDE NetBeans. Ver
Ilustración 39.
Ilustración 39. Proyecto creado correctamente en NetBeans
88
13. Expandimos la carpeta Source Packages y Test Packages, seleccionamos y borramos
los paquetes que nos genera automáticamente el IDE NetBeans, usando click derecho sobre los
paquetes y seleccionando la opción Delete lograremos esta acción, ver Ilustración 40. Por
seguridad nos aparecerá una ventana de confirmación acerca del borrado múltiple, seleccionamos
Yes, ver Ilustración 41. Y tendremos un proyecto limpio y listo para el siguiente paso. Ver
ilustración 42.
Ilustración 40. Borrado de clases innecesarias
Ilustración 41. Mensaje de confirmación de borrado
89
Ilustración 42. Proyecto vacío y listo para copia de código fuente
14. Debemos generar los paquetes necesarios para situar nuestro código fuente.
14.1 Presionamos click derecho sobre el directorio Source Packages y seleccionamos el
menú New – Java Package…, ver Ilustración 43. Nombramos al paquete weka.classifiers.am.
Presionamos Finish, ver Ilustración 44.
14.2 Volvemos a seleccionar Source Packages y creamos un nuevo paquete esta vez lo
llamaremos weka.filters.unsupervised.attribute, ver Ilustración 45.
Repetimos los pasos 14.1 y 14.2 pero en el directorio Test Packages.
El resultado final se aprecia en la Ilustración 46.
90
Ilustración 43. Creación de un nuevo paquete
Ilustración 44. Estableciendo el nombre para el nuevo paquete
91
Ilustración 45. Configurando nuevo paquete
Ilustración 46. Resultado final de la creación de paquetes
15. Debemos copiar de nuestra codificación local los archivos necesarios para el algoritmo
AlfaBetaSVM. Ver Ilustración 47.
92
En el directorio Source Packages:
Los archivos para el clasificador son:
o weka.classifiers.am.Bits.java
o weka.classifiers.am.AlfaBetaSVM.java
o weka.classifiers.am.Restriction.java
o weka.classifiers.am.Theta.java
Los archivos para el codificador son:
o weka.filters.unsupervised.attribute.JohnsonMobiusModifiedCode.java
En el directorio Test Packages:
Los archivos para el clasificador son:
o weka.classifiers.am.AlfaBetaSVMTest.java
Los archivos para el codificador son:
o weka.filters.unsupervised.attribute.JohnsonMobiusModifiedCodeTest.java
Ilustración 47. Copiando el código fuente al IDE NetBeans
Al terminar de pegar los archivos como se muestra en la Ilustración 47, podremos observar
que el IDE NetBeans nos muestra que existen errores. Esto se debe a que aún no hemos agregado
la referencia del proyecto WEKA. Para solucionar los errores abrimos el archivo AlfaBetaSVM y
93
en el primer error que observemos (cannot find symbol class AbstractClassifier), damos click
izquierdo y seleccionamos Search Dependency at Maven Repositories, ver Ilustración 48.
Ilustración 48. Errores encontrados por NetBeans
Nos saldrá una ventana emergente que listará las dependencias disponibles para la clase
AbstractClassifier, buscaremos la dependencia weka-dev y la seleccionaremos el archivo jar,
presionamos Add. Ver Ilustración 49.
Ilustración 49. Dependencias encontradas
94
Con esto nos desharemos de todos los errores que el IDE NetBeans muestra, ver Ilustración
50.
Ilustración 50. Proyecto sin errores en NetBeans
16. Editaremos el archivo pom.xml situado en el directorio Project Files, ver Ilustración 51.
Agregaremos las siguientes líneas:
<name>AlfaBetaSVM</name>
<description>
AlfaBeta Associative Memories with Support Vector
Machines.
</description>
<url>https://sourceforge.net/projects/alfabetasvm/</url>
<organization>
<name>ESCOM – IPN, D.F., México</name>
<url>http://www.escom.ipn.mx/</url>
</organization>
<licenses>
<license>
<name>GNU General Public License 3</name>
<url>http://www.gnu.org/licenses/gpl-3.0.txt</url>
<distribution>repo</distribution>
</license>
95
</licenses>
<developers>
<developer>
<id>irvin</id>
<name>Irvin Ortiz Ochoa</name>
<email>[email protected]</email>
</developer>
<developer>
<id>abraham</id>
<name>Abraham Chavez Lara</name>
<email>[email protected]</email>
</developer>
</developers>
Ilustración 51. Edición del archivo de proyecto pom.xml
17. Nos ubicaremos en la carpeta templates que descargamos del repositorio para copiar
dos archivos al proyecto, en ese caso la ruta es: C:\WekaSVN\packages\templates. Ver Ilustración
52. Los archivos a copiar son: build_package.xml y Description.props. Estos archivos los
agregaremos a la raíz de nuestro proyecto, ver Ilustración 53.
96
Ilustración 52. Contenido de la copia local del repositorio packages/templates
Ilustración 53. Adición de los archivos copiados desde el repositorio
18. Editaremos el archivo build_package.xml, ubicaremos el nodo denominado
"make_package" ver Ilustración 54. En este caso el nodo inicia en la línea 160, agregaremos la
línea de código: “<include name="*.props"/>”, exactamente después de la línea 190 ver
Ilustración 55.
97
Ilustración 54. Nodo make_package
Ilustración 55. Edición del archivo props
19. El contenido del archivo Description.props será sustituido por el contenido en la tabla
22.
# Package name (required)
98
PackageName=AlfaBetaSVM
# Version (required)
Version=1.0.0
#Date (year-month-day)
Date=2014-04-14
# Title (required)
Title=AlfaBeta Associtive Memories with Support Vector Machine
# Category (recommended)
Category=Classification
# Author (required)
Author=Abraham Chavez Lara <[email protected]>, Irvin Ortiz
ochoa <[email protected]>
# Maintainer (required)
Maintainer=Abraham Chavez Lara <[email protected]>, Irvin
Ortiz ochoa <[email protected]>
# License (required)
License=GPL v3.0
# Description (required)
Description=This package contains the AlfaBetaSVM Classifer that
performs prediction applied to handwritten digits recognition,
namely in the MNIST database.
# Package URL for obtaining the package archive (required)
PackageURL=https://www.dropbox.com/s/sbhz6t7bseuupwz/AlfaBetaSVM.
zip
# URL for further information
URL=http://www.repositoriodigital.ipn.mx/handle/123456789/7047
# Dependencies
Depends=weka (>=3.7.10)
Tabla 22. Contenido del archivo Description.props
20. Crearemos un archivo llamado GenericPropertiesCreator.props el contenido de este
archivo será el que se aprecia en la tabla 23. El resultado se observa en la Ilustración 56.
99
# Customises the list of options given by the
GenericObjectEditor
# for various superclasses.
# Lists the Classifiers-Packages I want to choose from
weka.classifiers.Classifier=\
weka.classifiers.am
Tabla 23. Contenido del archivo GenericPropertiesCreator.props
Ilustración 56. Edición del archivo GenericPropertiesCreator.props
21. En la raíz del proyecto AlfaBetaSVM crearemos una carpeta vacía llamada “lib”. Ver
Ilustración 57.
Ilustración 57. Adición de carpeta lib
100
22. Instalar la herramienta Ant.
22.1 Descargar de: http://apache.claz.org//ant/binaries/apache-ant-1.9.3-bin.zip
Ubicar el archivo en el directorio deseado para instalarlo y descomprimir. Ver Ilustración
58.
Ilustración 58. Extracción del contenido del archivo apache-ant.zip
22.2 Agregar la ubicación de la herramienta Ant a la variable de entorno Path, ver
Ilustración 59.
Ilustración 59. Agregar la ruta de instalación a la variable Path
22.3 Probar la instalación de Ant. Ejecutar en una consola el comando ant y si no existe
ningún archivo build.xml aparecerá el mensaje de error: “Buildfile: build.xml does not exist!”.
Ver Ilustración 60.
101
Ilustración 60. Ejecución de la herramienta ant
23. Construir el proyecto weka-dev, seleccionamos el proyecto weka-dev, presionamos
click derecho y seleccionamos la opción Build with Dependencies. Las ejecuciones de las pruebas
fueron deshabilitadas. Ver Ilustración 61.
Ilustración 61. Construcción del proyecto weka-dev
Al finalizar de construir el proyecto veremos un mensaje de éxito en la ventana Output del
IDE NetBeans. Ver Ilustración 62.
102
Ilustración 62. Salida de NetBeans acerca de la construcción del proyecto weka-dev
24. Abriremos una consola y nos situaremos en la raíz del proyecto WEKA para emplear la
herramienta Ant y el archivo build.xml para la construcción del paquete AlfaBetaSVM. Ver
Ilustración 63.
Ilustración 63. Ubicación en consola del directorio del proyecto weka
25. Ejecutar el comando: “ant -DpackageName=AlfaBetaSVM compile_external” para
compilar el paquete. Ver Ilustración 64.
103
Ilustración 64. Ejecución de la herramienta ant para compilar el paquete
26. Ejecutar el comando: “ant -DpackageName=AlfaBetaSVM make_external” para
generar el paquete. Ver Ilustración 65.
Ilustración 65. Ejecución de la herramienta ant para la generación del paquete
104
Al concluir esta serie de pasos podremos visualizar en la carpeta del proyecto una carpeta
llamada dist que contiene nuestro paquete WEKA en formato zip, ver Ilustración 66.
Ilustración 66. Resultado de la creación del paquete
Sección 5.2. Pruebas
Pruebas de Integración de los algoritmos a WEKA
En este apartado se muestran los resultados de cada una de las pruebas que realizamos al
codificador y al clasificador.
La primera prueba a la que se sometieron las implementaciones de ambos algoritmos fue a
la correcta integración de la cada una de estas en WEKA. Para esta sección WEKA posee un
Framework de pruebas que determina la correcta funcionalidad de un algoritmo de
preprocesamiento y un clasificador. Es importante que el algoritmo de clasificación AlfaBetaSVM
y el codificador JohnsonMobiusModifiedCode superen estás pruebas para garantizar que el
objetivo de este proyecto se ha alcanzado.
La primera prueba es el verificador de configuración del codificador
JohnsonMobiusModifiedCode, para verificar esta prueba se debe introducir el siguiente comando
desde la línea de comandos:
weka.core.CheckOptionHandler -W <classname>
Todas las pruebas deben devolver yes. En la Ilustración 67 se muestran los resultados.
105
Ilustración 67. Resultados de pruebas del filtro JohnsonMobiusModifiedCode
Ejecutaremos la misma prueba con el clasificador. Los resultados se muestran en la
Ilustración 68.
Ilustración 68. Resultados de pruebas del clasificador AlfaBetaSVM
La siguiente prueba verifica si todas las propiedades disponibles en la interfaz gráfica de
usuario tienen información. Esto se verifica con la clase CheckGOE como se muestra en la
Ilustración 69 para el codificador JohnsonMobiusModifiedCode.
Ilustración 69. Ejecución de la herramienta CheckGOE para JohnsonMobiusModifiedCode
En la Ilustración 70 se muestra el resultado de la prueba con el clasificador AlfaBetaSVM.
106
Ilustración 70. Ejecución de la herramienta CheckGOE para AlfaBetaSVM
Las últimas pruebas que se realizaron fueron las pruebas unitarias con el fin de asegurarse
de que el algoritmo se adapta a la estructura de WEKA. Se deben probar los métodos del
algoritmo con el Framework JUnit mediante la creación de una clase de prueba.
La superclase para las pruebas unitarias del codificador es weka.filters.AbstractFilterTest y
la superclase para las pruebas unitarias del clasificador es weka.filters.AbstractClassifierTest.
En la Ilustración 71 se muestran los resultados de las pruebas unitarias del codificador y
clasificador.
107
Ilustración 71. Pruebas JUnit del codificador y del clasificador
Como se observa en esta sección el algoritmo y el codificador cumplen con las normas que
establece WEKA para integrar algoritmos a la plataforma.
Evaluación del rendimiento del clasificador AlfaBetaSVM
En este capítulo presentaremos los resultados de los experimentos realizados a la
integración del algoritmo AlfaBetaSVM. Estos experimentos se realizaron con las bases de datos
MNIST [30] e Iris Plant[31].
La evaluación del rendimiento del algoritmo se puede hacer de dos formas, la primera se
presenta en la tesis del Dr. Luis Octavio López Leyva [3] que evalúa en la recuperación y la
segunda puede ser el método Hold-Out o el método de K-Fold Cross-Validation para evaluar la
clasificación [5].
108
Base de datos MNIST
La base de datos MNIST es una recopilación de dígitos escritos a mano que está
conformada por un total de 70,000 imágenes en escala de grises, la información de cada imagen
está normalizada en cuanto a tamaño y centrada en un tamaño fijo de 28x28 pixeles; la base de
datos se divide en 2, un conjunto de entrenamiento con 60,000 imágenes y un conjunto de prueba
de 10,000 imágenes. En la tesis doctoral del Dr. Luis Octavio López Leyva reportó un
desempeño del 99.48% al aplicar el algoritmo AlfaBetaSVM a la base de datos MNIST usando la
codificación Johnson-Möbius modificada.
Resultados
En un principio se realizaron pruebas en una PC con procesador Intel Core i7 (12 núcleos)
a 3.2 GHz, 32 GB de memoria RAM DDR3 y un disco duro de 500GB y se utilizó la base de
datos MNIST y el Software WEKA Developer en la versión 3.7.
Se integró el algoritmo funcionando linealmente, pudimos observar que sólo se ejecutaba el
programa en un solo núcleo del procesador (ver Ilustración 72) y la ejecución del programa en su
fase de entrenamiento y recuperación tardaría alrededor de 29 días aproximadamente (ver
Ilustración 73).
109
Ilustración 72. Sobre carga de trabajo a un solo procesador
Ilustración 73. Prueba de ejecución del algoritmo AlfaBetaSVM
Por lo que se planteó utilizar programación concurrente para que mediante hilos, se
ejecuten tareas simultáneamente y se puedan utilizar los núcleos del procesador que el usuario
decida. Por lo que en la siguiente fase del proyecto se hicieron pruebas de funcionamiento con
esta opción y utilizamos los 12 núcleos del procesador y con estas modificaciones la ejecución
110
del programa en su fase de entrenamiento y recuperación tardó alrededor de 7 días
aproximadamente. Ver Ilustración 74.
Ilustración 74. Ejecución concurrente, todos los procesadores se encuentran trabajando
Ante estos resultados se planteó optimizar el algoritmo AlfaBetaSVM y así fue como se
desarrolló el algoritmo AlfaBetaSVM Real el cual tiene un costo computacional mucho menor al
original y la ejecución del programa en su fase de entrenamiento tardó 20 segundos y en la fase
de prueba tardó 30 minutos respectivamente, presentó la misma cantidad de instancias
correctamente clasificadas en un tiempo mucho menor. Ver tabla 24.
=== Run information ===
Scheme: weka.classifiers.am.AlfaBetaSVM -JMMC -num-slots 1
Relation: DATA=train-images.idx3-ubyte-LABELS=train-labels.idx1-ubyte-
weka.filters.unsupervised.attribute.ModifiedJohnsonMobiusCode-A1-784-R[0:255]-N0
Instances: 60000 Attributes: 785
=== Classifier model (full training set) ===
Máquinas Asociativas AlfaBeta con Soporte Vectorial (AlfaBetaSVM).
Copyright (c) 2008 by Luis Octavio López Levya ([email protected]).
Java port to Weka by Abraham Chavez Lara & Irvin Ortiz Ochoa
([email protected],[email protected]).
Time taken to build model: 18.01 seconds
=== Evaluation on test set ===
Time taken to test model on supplied test set: 1746.95 seconds
=== Summary ===
Correctly Classified Instances 9631 96.31 %
Incorrectly Classified Instances 369 3.69 %
Kappa statistic 0.959
Mean absolute error 0.0074
111
Root mean squared error 0.0859
Relative absolute error 4.1014 %
Root relative squared error 28.6407 %
Coverage of cases (0.95 level) 96.31 %
Mean rel. region size (0.95 level) 10 %
Total Number of Instances 10000
=== Detailed Accuracy By Class ===
TP Rate FP Rate Precision Recall F-Measure MCC ROC Area PRC Area
Class
0.993 0.003 0.973 0.993 0.983 0.981 0.995 0.967 0
0.995 0.006 0.954 0.995 0.974 0.971 0.994 0.950 1
0.956 0.002 0.980 0.956 0.968 0.965 0.977 0.942 2
0.955 0.006 0.948 0.955 0.952 0.946 0.975 0.910 3
0.954 0.003 0.971 0.954 0.963 0.959 0.976 0.931 4
0.951 0.006 0.943 0.951 0.947 0.942 0.973 0.901 5
0.984 0.002 0.978 0.984 0.981 0.979 0.991 0.964 6
0.962 0.005 0.956 0.962 0.959 0.955 0.979 0.924 7
0.918 0.001 0.986 0.918 0.951 0.946 0.958 0.913 8
0.957 0.006 0.944 0.957 0.951 0.945 0.976 0.908 9
Weighted Avg. 0.963 0.004 0.963 0.963 0.963 0.959 0.979 0.931
=== Confusion Matrix ===
a b c d e f g h i j <-- classified as
973 2 1 0 0 1 2 1 0 0 | a = 0
0 1129 3 0 1 1 1 0 0 0 | b = 1
9 8 987 6 1 0 2 17 2 0 | c = 2
0 2 4 965 1 21 0 9 4 4 | d = 3
1 9 0 0 937 0 3 4 1 27 | e = 4
2 1 0 17 2 848 9 1 5 7 | f = 5
5 2 1 0 2 5 943 0 0 0 | g = 6
0 20 4 2 4 0 0 989 0 9 | h = 7
9 5 6 21 4 18 3 4 894 10 | i = 8
1 5 1 7 13 5 1 9 1 966 | j = 9
Tabla 24. Resultados arrojados por WEKA
Los resultados arrojados por WEKA, empleando el algoritmo AlfaBetaSVM usando la
codificación Johnson-Möbius modificada, se pueden apreciar en la tabla 25. Para esta prueba, se
entrenó al algoritmo AlfaBetaSVM con las 60,000 instancias de entrenamiento y se hizo la prueba
con las 10,000 instancias restantes.
=== Summary ===
Correctly Classified Instances 9631 96.31 %
Incorrectly Classified Instances 369 3.69 %
=== Confusion Matrix ===
a b c d e f g h i j <-- classified as
973 2 1 0 0 1 2 1 0 0 | a = 0
0 1129 3 0 1 1 1 0 0 0 | b = 1
9 8 987 6 1 0 2 17 2 0 | c = 2
0 2 4 965 1 21 0 9 4 4 | d = 3
1 9 0 0 937 0 3 4 1 27 | e = 4
2 1 0 17 2 848 9 1 5 7 | f = 5
5 2 1 0 2 5 943 0 0 0 | g = 6
112
0 20 4 2 4 0 0 989 0 9 | h = 7
9 5 6 21 4 18 3 4 894 10 | i = 8
1 5 1 7 13 5 1 9 1 966 | j = 9
Tabla 25. Matriz de confusión arrojada por WEKA
El resultado de WEKA corresponde a la evaluación del rendimiento con respecto a la
clasificación de patrones y en la tesis del Dr. Luis Octavio López Leyva se evaluó el rendimiento
con respecto a la recuperación de patrones, por lo que para corroborar el resultado reportado
debemos tomar en cuenta que el resultado arrojado por WEKA es solo sobre 10,000 instancias,
sabiendo que el algoritmo AlfaBetaSVM tiene un factor de olvido del 0%, debemos incluir el
porcentaje sobre el conjunto de entrenamiento y prueba con el conjunto de entrenamiento, en
otras palabras ver si el modelo recuerda todo lo que aprendió.
Instancias totales 70,000 100%
Instancias de
entrenamiento
60,000 85.7142%
Instancias de prueba 10,000 14.2857%
Tabla 26. Porcentajes de instancias para MNIST
En la tabla 26 podemos observar que el total del imágenes es de 70,000, lo que equivale al
100%, el conjunto de entrenamiento equivale a 85.7142% y el conjunto de prueba es el
14.2857%.
La tabla 27 muestra que se entrenó con 60,000 instancias y se probó con las mismas 60,000
instancias y se recuperaron en su totalidad, lo que equivale sólo a 85.7142%. Por otro lado la
tabla 28 muestra que se entrenó con 60,000 instancias y se probó con las 10,000 instancias
restantes, los resultados obtenidos equivalen al 96.31% del 14.2857% de la base de datos;
entonces para obtener el rendimiento total, se sumaron los porcentajes recuperados en cada
prueba, el resultado mostrado en la tabla 29 es el mismo reportado en la tesis doctoral.
Entrenamiento con 60,000 instancias y
prueba con las mismas 60,000 instancias
Prueba 60,000 100% 85.7142%
Resultados 60,000 100%
Tabla 27. Resultados entrenamiento y prueba con el mismo conjunto de datos de entrenamiento
Entrenamiento con 60,000 instancias y
prueba con las 10,000 instancias restantes
Prueba 10,000 100% 14.2857%
113
Resultados 9,631 96.31% 13.7585%
Tabla 28. Resultados entrenamiento con conjunto de entrenamiento y prueba con el conjunto de prueba
Instancias correctamente clasificadas 85.7142%+13.7385% = 99.4727%
Error 0.5272%
Tabla 29. Resultados finales
Ahora bien comparando los resultados del clasificador con algunos otros algoritmos
aplicados a la base de datos MNIST [30] son los que se muestran en la Ilustración 75.
Ilustración 75. Comparación de resultados
De lo anterior se puede observar que el algoritmo AlfaBetaSVM presenta resultados
competitivos con respecto a otros algoritmos dentro de literatura actual.
Base de datos Iris Plant
La base de datos Iris Plant [31], esta es quizás una de las bases de datos más conocidas que
se encuentran en la literatura de reconocimiento de patrones. El conjunto de datos contiene 3
clases de 50 instancias cada uno, donde cada clase se refiere a un tipo de planta de iris. Una clase
es linealmente separables de las otras 2; Éstas últimas no son linealmente separables entre sí.
La base de datos contiene 4 tipos de atributos numéricos y el atributo que clase. El primer
atributo contiene el largo del sépalo en centímetros, el segundo atributo el ancho del sépalo , el
tercer atributo indica el largo del pétalo , el cuarto atributo indica el ancho del pétalo y por último
Classifier Preprocessing Error (%) Year
boosted stumps none 7.7 2009
products of boosted stumps (3 terms) none 1.26 2009
boosted trees (17 leaves) none 1.53 2009
stumps on Haar features Haar features 1.02 2009
product of stumps on Haar f. Haar features 0.87 2009
committee of 25 NN 784-800-10 [elastic distortions] width normalization, deslanting 0.39 2011
deep convex net, unsup pre-training [no distortions] none 0.83 2010
large conv. net, unsup pretraining [no distortions] none 0.53 2009
committee of 7 conv. net [elastic distortions] width normalization 0.27 +-0.022011
committee of 35 conv. net [elastic distortions] width normalization 0.23 2012
AlfaBetaSVM (Dr. Luis Octavio López Leyva) Modified Johnson Möbius Code 0.52 2008
AlfaBetaSVM (10-Fold Cross-Validation) Modified Johnson Möbius Code 3.69 2008
114
el quinto atributo indica la clase a la que la instancia pertenece (Iris Setosa, Iris Versicolor, Iris
Virginica) .
Evaluamos el rendimiento del clasificador con el método K-fold Cross-Validation con un
valor de K=10.Posteriormente comparamos los resultados con otros algoritmos de clasificación
que se encuentran en la plataforma. Los resultados se aprecian en la Ilustración 76.
Resultados
Ilustración 76. Comparativa de resultados con Iris Plant
99.30%
97.33%
96.00%
96.00%
96.00%
96.00%
95.33%
95.33%
95.33%
95.33%
94.66%
94.66%
94.00%
94.00%
94.00%
94.00%
94.00%
94.00%
94.00%
93.33%
92.66%
92.66%
92.00%
92.00%
ALFABETASVM(CODIFICACIÓN BINARIA)
MULTILAYER PERCEPTRON
NAIVE BAYES
LOGISTIC
SMO
J48
ALFABETASVM(JMMC)
NAIVE BAYES MULTINOMINAL
IBK
ADABOOSTM1
KSTAR
RANDOMFOREST
SIMPLE LOGISTIC
BAGGING
CLASSIFICATION VIA REGRESSION
LOGIC BOOST
PART
LMT
REPTREE
LWL
BAYES NET
RANDOMCOMMITTEE
ONER
RANDOMTREE
Evaluación del rendimiento
115
Cabe mencionar que de la tabla anterior se evaluaron clasificadores con diferentes
enfoques, donde el algoritmo AlfaBetaSVM con una codificación binaria clásica muestra el
mayor porcentaje en la evaluación. Este resultado se obtuvo al aplicar la misma metodología de
evaluación que en el punto anterior con la base de datos MNIST y coincide con el resultado
reportado en la tesis del Dr. Luis Octavio López Leyva.
Por otro lado el algoritmo AlfaBetaSVM utilizando la codificación de Johnson Möbius
Modificado presenta resultados que compiten con los clasificadores de la plataforma WEKA.
116
Conclusiones
En este capítulo se presentan las conclusiones de este trabajo terminal, las cuales fueron
obtenidas del análisis de la plataforma de WEKA y su extensión; también son resultado del
análisis al algoritmo AlfaBetaSVM y el codificador Johnson Möbius Modificado.
A continuación se listan las conclusiones:
En este trabajo terminal se define una guía para la integración del algoritmo de
preprocesamiento, el codificador Johnson Möbius Modificado en la plataforma
WEKA y que a su vez puede funcionar para la integración de otros algoritmos de
preprocesamiento.
Define una guía para la integración de las Máquinas Asociativas Alfa-Beta con
Soporte Vectorial a WEKA y que a su vez funciona para la integración de
Memorias asociativas Alfa-Beta en la plataforma.
Se define el modelo AlfaBetaSVM Real, el cual reduce el costo computacional del
algoritmo AlfaBetaSVM clásico.
Implementa el algoritmo AlfaBetaSVM de manera concurrente para que mediante la
ejecución de hilos se ejecuten tareas de manera simultánea.
Define una forma de representar el resultado obtenido por el codificador Johnson
Möbius Modificado para reducir el número de dígitos para un valor.
Se compararon los resultados obtenidos de aplicar el algoritmo AlfaBetaSVM a la
base de datos MNIST y la base de datos Iris Plant, con otros clasificadores,
presentando resultados competitivos con los clasificadores de la literatura actual.
El presente trabajo terminal rebasó las expectativas que se tenían como objetivo
inicial.
117
Trabajo a futuro
Como a trabajo a futuro se consideran los siguientes puntos:
Realizar más experimentos con otras bases de datos para conocer en que otra área
puede sobresalir el algoritmo AlfaBetaSVM.
Integrar nuevos algoritmos que empleen las Memorias Asociativas Alfa Beta.
Crear un repositorio de algoritmos que empleen las Memorias Asociativas Alfa
Beta.
118
Referencias
[1] “Weka 3 - Data Mining with Open Source Machine Learning Software in Java”. [Online].
Available: http://www.cs.waikato.ac.nz/ml/weka/
[2] Mark Hall, Eibe Frank, Geoffrey Holmes, Bernhard Pfahringer, Peter Reutemann, Ian H.
Witten (2009); The WEKA Data Mining Software: An Update; SIGKDD Explorations,
Volume 11, Issue 1.
[3] L. O. López-Leyva. “Maquinas asociativas Alfa-Beta con soporte vectorial” Tesis
doctoral. Centro de Investigación en Computación, IPN. México 2008.
[4] F. López P. “Integración del algoritmo CTC en la plataforma WEKA”. Ingeniería Técnica
en informática de Sistemas, Universidad del País Vasco - Euskal Herriko Unibertsitatea,
San Sebastián – Donostia, España, 2011.
[5] Ian H.Witten, Eibe Frank y Mark A.Hall. Data Mining Practical Learning Tools and
Techniques. Morgan Kaufmann, 2011.
[6] “Stratebi”. [Online]. Available: http://www.stratebi.com/
[7] “RapidMiner”. [Online]. Available: http://rapid-i.com/
[8] “Tanagra”. [Online]. Available: http://eric.univ-lyon2.fr/~ricco/tanagra/en/tanagra.html
[9] “KMINE”. [Online]. Available: http://www.knime.org/
[10] “PASW”. [Online]. Available: http://www.spss.com.hk/statistics/
[11] “R and Data Mining”. [Online]. Available: http://www.rdatamining.com/
[12] “Tool command language”. [Online]. Available: http://www.tcl.tk/
[13] “Lenguaje C”. [Online]. Available: http://cm.bell-labs.com/cm/cs/who/dmr/chist.html
[14] “Data Mining and Knowledge Discovery Service”. [Online]. Available:
http://www.kdnuggets.com/news/2005/n13/2i.html
[15] “Special Interest Group on Knowledge Discovery and Data Mining”. [Online]. Available:
http://www.kdd.org/
[16] “Pentaho corporation”.[Online].Available: http://www.pentaho.com/
[17] “GNU/GPLv3”.Online. Available: http://www.gnu.org/licenses/gpl-3.0.html
[18] C. Yáñez-Márquez. “Memorias Asociativas basadas en Relaciones de Orden y
Operaciones binarias”. Tesis doctoral, Centro de Investigación en Computación, IPN.
México 2002.
[19] R. Flores-Carapia. “Memorias asociativas Alfa-Beta en el código Johson-Möbius
modificado” Tesis de maestría, Centro de Investigación en Computación, IPN. México
2006.
[20] M. Aldape-Pérez. “Implementación de los modelos Alfa-Beta con lógica reconfigurable”.
Tesis de maestría. Centro de Investigación en Computación, IPN. México 2007.
[21] M. Aldape-Pérez. “Enfoque asociativo para la selección de rasgos”. Tesis doctoral. Centro
de Investigación en Computación, IPN. México 2011.
119
[22] I. Román-Godínez. “Aplicación de los modelos asociativos Alfa-Beta a la
Bioinformática”. Tesis de maestría. Centro de Investigación en Computación, IPN.
México 2007.
[23] E. A. Catalan-Salgado. “Memorias Asociativas Alfa-Beta Simplificadas”. Tesis de
maestría. Centro de Investigación en Computación, IPN. México 2007.
[24] J. F. Solís-Villareal. “Un modelo de procesamiento de voz para clasificación de estados”.
Tesis doctoral. Centro de Investigación en Computación, IPN. México 2011.
[25] C. Yáñez-Márquez, I. López-Yáñez y M. Aldape-Pérez. “Modelos Asociativos Alfa-Beta:
génesis, conceptos básicos y aplicaciones”. 14ª Convención Científica de Ingeniería y
Arquitectura. Habana, Cuba 2008
[26] L. López-Leyva, C. Yáñez-Márquez, R. Flores-Carapia, and O. Camacho-Nieto,
“Handwritten Digit Classification Based on Alpha-Beta Associative Model,” in Progress
in Pattern Recognition, Image Analysis and Applications. LNCS 5197, Proc. 13th
Iberoamerican Congress on Pattern Recognition CIARP 2008. Havana, Cuba. 2008.
[27] L. López-Leyva, C. Yáñez-Márquez, and I. López-Yáñez, “A new efficient model of
support vector machines: ALFA–BETA SVM,” in 23rd ISPE International Conference on
CAD/CAM, Robotics and Factories of the Future. Bogotá, Colombia. 2007.
[28] “Suppor Vector Machines” [Online]. Available: http://cnx.org/content/m13131/latest/
[29] “IBM Rational Unified Process (RUP)”. [Online] Available: http://www-
01.ibm.com/software/rational/rup/
[30] “THE MNIST DATABASE of handwritten digits”. [Online] Available:
http://yann.lecun.com/exdb/mnist/
[31] “Iris Data Set”. [Online] Available: http://archive.ics.uci.edu/ml/datasets/Iris
120
Apéndices
Apéndice 1. Ejercicio práctico de Memorias Asociativas
Alfa-Beta con Soporte Vectorial
Sean 𝒙1, 𝒙2, 𝒙3, 𝒙4, 𝒙5 ∈ 𝐴𝑛, con dimensión 𝑛 = 5 y con cardinalidad 𝑝 = 5, los vectores que
conforman el conjunto fundamental.
𝒙1 =
(
10101)
, 𝒙2 =
(
01011)
, 𝒙3 =
(
11001)
, 𝒙4 =
(
00001)
, 𝒙5 =
(
11111)
Fase de aprendizaje
1. A partir del conjunto fundamental anterior calcularemos el vector de soporte 𝑺.
Debido a que la cardinalidad del conjunto fundamental es impar con 𝑝 = 5 usaremos la
siguiente expresión
𝑺𝑖 = 𝛽
[
⋀𝛽 (𝒙𝑖2𝑘−1, 𝒙𝑖
2𝑘)
𝑝−12
𝑘=1
, 𝒙𝑖𝑝
]
Por lo tanto cada componente del vector de soporte se calculará así
𝑺𝑖 = 𝛽[𝛽(𝒙𝑖1, 𝒙𝑖
2) ⋀ 𝛽 (𝒙𝑖3, 𝒙𝑖
4), 𝒙𝑖5]
𝑺1 = 𝛽[𝛽(1,0) ⋀ 𝛽(1,0), 1] = 𝛽[(0 ⋀ 0), 1] = 𝛽[0, 1] = 0
𝑺2 = 𝛽[𝛽(0,1) ⋀ 𝛽(1,0), 1] = 𝛽[(0 ⋀ 0), 1] = 𝛽[0, 1] = 0
𝑺3 = 𝛽[𝛽(1,0) ⋀ 𝛽(0,0), 1] = 𝛽[(0 ⋀ 0), 1] = 𝛽[0, 1] = 0
𝑺4 = 𝛽[𝛽(0,1) ⋀ 𝛽(0,0), 1] = 𝛽[(0 ⋀ 0), 1] = 𝛽[0, 1] = 0
𝑺5 = 𝛽[𝛽(1,1) ⋀ 𝛽(1,1), 1] = 𝛽[(1 ⋀ 1), 1] = 𝛽[1, 1] = 1
121
Finalmente el vector de soporte para el conjunto fundamental es 𝑺 =
(
00001)
2. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, obtener 𝒙𝜇|𝑺. A partir de estos resultados formar el conjunto
fundamental restringido {(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}.
Para el vector 𝒙1 =
(
10101)
la Restricción de 𝒙1 por 𝑺 es 𝒙1|𝑺 = (
1010
).
Para el vector 𝒙2 =
(
01011)
la Restricción de 𝒙2 por 𝑺 es 𝒙2|𝑺 = (
0101
).
Para el vector 𝒙3 =
(
11001)
la Restricción de 𝒙3 por 𝑺 es 𝒙3|𝑺 = (
1100
).
Para el vector 𝒙4 =
(
00001)
la Restricción de 𝒙4 por 𝑺 es 𝒙4|𝑺 = (
0000
).
Para el vector 𝒙5 =
(
11111)
la Restricción de 𝒙5 por 𝑺 es 𝒙5|𝑺 = (
1111
).
Con estos resultados formamos el conjunto fundamental restringido
{(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}.
122
𝒙1|𝑺 = (
1010
) , 𝒙2|𝑺 = (
0101
) , 𝒙3|𝑺 = (
1100
) , 𝒙4|𝑺 = (
0000
) , 𝒙5|𝑺 = (
1111
)
3. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝} , obtener 𝒙𝜇 , el vector negado de 𝒙𝜇 . Con los 𝑝 vectores
negados se forma el conjunto fundamental negado {(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}.
𝒙1 =
(
10101)
, 𝒙1 =
(
01010)
, 𝒙2 =
(
01011)
, 𝒙2 =
(
10100)
, 𝒙3 =
(
11001)
, 𝒙3 =
(
00110)
,
𝒙4 =
(
00001)
, 𝒙4 =
(
11110)
, 𝒙5 =
(
11111)
, 𝒙5 =
(
00000)
.
Con estos resultados formamos el conjunto fundamental negado
{(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}.
𝒙1 =
(
01010)
, 𝒙2 =
(
10100)
, 𝒙3 =
(
00110)
, 𝒙4 =
(
11110)
, 𝒙5 =
(
00000)
.
4. A partir del conjunto fundamental negado, calcular el vector de soporte 𝑺.
Debido a que la cardinalidad del conjunto fundamental negado es impar con 𝑝 = 5
usaremos la siguiente expresión.
𝑺𝑖 = 𝛽
[
⋀𝛽 (𝒙𝑖2𝑘−1, 𝒙𝑖
2𝑘)
𝑝−12
𝑘=1
, 𝒙𝑖𝑝
]
Por lo tanto cada componente del vector de soporte se calculará así
𝑺𝑖 = 𝛽[𝛽(𝒙𝑖1, 𝒙𝑖
2) ⋀ 𝛽 (𝒙𝑖3, 𝒙𝑖
4), 𝒙𝑖5]
𝑺1 = 𝛽[𝛽(0,1) ⋀ 𝛽(0,1), 0] = 𝛽[(0 ⋀ 0), 0] = 𝛽[0, 0] = 0
𝑺2 = 𝛽[𝛽(1,0) ⋀ 𝛽(0,1), 0] = 𝛽[(0 ⋀ 0), 0] = 𝛽[0, 0] = 0
123
𝑺3 = 𝛽[𝛽(0,1) ⋀ 𝛽(1,1), 0] = 𝛽[(0 ⋀ 1), 0] = 𝛽[0, 0] = 0
𝑺4 = 𝛽[𝛽(1,0) ⋀ 𝛽(1,1), 0] = 𝛽[(0 ⋀ 1), 0] = 𝛽[0, 0] = 0
𝑺5 = 𝛽[𝛽(0,0) ⋀ 𝛽(0,0), 0] = 𝛽[(0 ⋀ 0), 0] = 𝛽[0, 0] = 0
Por lo que el vector de soporte para el conjunto fundamental negado es 𝑺 =
(
00000)
.
5. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, obtener 𝒙𝜇|�̂�. A partir de estos resultados formar el conjunto
fundamental negado restringido {(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}.
Para el vector 𝒙1 =
(
01010)
la Restricción de 𝒙1 por 𝑺 es 𝒙1|�̂�=
(
01010)
.
Para el vector 𝒙2 =
(
10100)
la Restricción de 𝒙2 por 𝑺 es 𝒙2|�̂�=
(
10100)
.
Para el vector 𝒙3 =
(
00110)
la Restricción de 𝒙3 por 𝑺 es 𝒙3|�̂�=
(
00110)
.
Para el vector 𝒙4 =
(
11110)
la Restricción de 𝒙4 por 𝑺 es 𝒙4|
�̂�=
(
11110)
.
Para el vector 𝒙5 =
(
00000)
la Restricción de 𝒙5 por 𝑺 es 𝒙5|�̂�=
(
00000)
.
124
Con estos resultados formamos el conjunto fundamental negado restringido
{(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}
𝒙1|�̂�=
(
01010)
, 𝒙2|
�̂�=
(
10100)
, 𝒙3|
�̂�=
(
00110)
, 𝒙4|
�̂�=
(
11110)
, 𝒙5|
�̂�=
(
00000)
Fase de recuperación
Presentaremos el patrón �̃�, el cual está contenido en el conjunto fundamental.
�̃� =
(
11001)
1. Obtener la Restricción �̃�|𝑺.
Para el vector �̃� =
(
11001)
la Restricción de �̃� por 𝑺 es �̃�|𝑺 = (
1100
).
2. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺).
Dado que la transformada 𝜃(𝒙 , 𝒚) está definida de la siguiente forma
𝜃(𝒙 , 𝒚) = 𝜎𝑛[𝝉(𝒙 , 𝒚)] + 𝜎𝑛[𝝉(𝒚 , 𝒙)]
Primero desarrollaremos la transformada 𝝉(�̃�|𝑺 , 𝒙𝜇|𝑺), donde cada componente del vector
𝝉 se calcula
[𝝉(𝒙, 𝒚)]𝑖 = 𝛽[𝒙𝑖, 𝛼(0, 𝒚𝑖)]
Para 𝜇 = 1.
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
1|𝑺1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
1|𝑺2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
1|𝑺3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
1|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
125
Para 𝜇 = 2.
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
2|𝑺1)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
2|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
2|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
2|𝑺4)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
Para 𝜇 = 3.
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
3|𝑺1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
3|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
3|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
3|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 4.
[𝝉(�̃�|𝑺 , 𝒙4|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
4|𝑺1)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙4|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
4|𝑺2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙4|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
4|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙4|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
4|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 5.
[𝝉(�̃�|𝑺 , 𝒙5|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
5|𝑺1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙5|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
5|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙5|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
5|𝑺3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙5|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
5|𝑺4)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
Ahora desarrollaremos la transformada 𝝉(𝒙𝜇|𝑺 , �̃�|𝑺)
Para 𝜇 = 1.
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙1|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙1|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙1|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙1|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 2.
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙2|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙2|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙2|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙2|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
Para 𝜇 = 3.
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙3|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
126
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙3|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙3|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙3|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 4.
[𝝉(𝒙4|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙4|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙4|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙4|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙4|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙4|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙4|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙4|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 5.
[𝝉(𝒙5|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙5|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙5|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙5|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙5|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙5|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙5|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙5|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
A continuación debemos calcular el valor de 𝜎𝑛(𝝉) con 𝑛 = 4 , para las
transformadas 𝝉 calculadas previamente.
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎4[𝝉(�̃�|𝑺 , 𝒙𝜇|𝑺)] son:
Para 𝜇 = 1.
𝝉(�̃�|𝑺 , 𝒙1|𝑺) = (
0100
) → 𝜎4[𝝉(�̃�|𝑺 , 𝒙1|𝑺)] = 1
Para 𝜇 = 2.
𝝉(�̃�|𝑺 , 𝒙2|𝑺) = (
1000
) → 𝜎4[𝝉(�̃�|𝑺 , 𝒙2|𝑺)] = 1
Para 𝜇 = 3.
𝝉(�̃�|𝑺 , 𝒙3|𝑺) = (
0000
) → 𝜎4[𝝉(�̃�|𝑺 , 𝒙3|𝑺)] = 0
Para 𝜇 = 4.
𝝉(�̃�|𝑺 , 𝒙4|𝑺) = (
1100
) → 𝜎4[𝝉(�̃�|𝑺 , 𝒙4|𝑺)] = 2
Para 𝜇 = 5.
127
𝝉(�̃�|𝑺 , 𝒙5|𝑺) = (
0000
) → 𝜎4[𝝉(�̃�|𝑺 , 𝒙5|𝑺)] = 0
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎4[𝝉(𝒙𝜇|𝑺 , �̃�|𝑺)] son:
Para 𝜇 = 1.
𝝉(𝒙1|𝑺 , �̃�|𝑺) = (
0010
) → 𝜎4[𝝉(𝒙1|𝑺 , �̃�|𝑺)] = 1
Para 𝜇 = 2.
𝝉(𝒙2|𝑺 , �̃�|𝑺) = (
0001
) → 𝜎4[𝝉(𝒙2|𝑺 , �̃�|𝑺)] = 1
Para 𝜇 = 3.
𝝉(𝒙3|𝑺 , �̃�|𝑺) = (
0000
) → 𝜎4[𝝉(𝒙3|𝑺 , �̃�|𝑺)] = 0
Para 𝜇 = 4.
𝝉(𝒙4|𝑺 , �̃�|𝑺) = (
0000
) → 𝜎4[𝝉(𝒙4|𝑺 , �̃�|𝑺)] = 0
Para 𝜇 = 5.
𝝉(𝒙5|𝑺 , �̃�|𝑺) = (
0011
) → 𝜎4[𝝉(𝒙5|𝑺 , �̃�|𝑺)] = 2
Al haber realizado todos los cálculos necesarios para la transformada 𝜃 ,
obtendremos los valores escalares de 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) para cada 𝜇 𝜖 {1,2,3, … , 𝑝} y con 𝑛 =
4, como se muestra a continuación.
Para 𝜇 = 1.
𝜃(�̃�|𝑺 , 𝒙1|𝑺) = 𝜎4[𝝉(�̃�|𝑺 , 𝒙
1|𝑺)] + 𝜎4[𝝉(𝒙1|𝑺 , �̃�|𝑺)] = 1 + 1 = 2
Para 𝜇 = 2.
𝜃(�̃�|𝑺 , 𝒙2|𝑺) = 𝜎4[𝝉(�̃�|𝑺 , 𝒙
2|𝑺)] + 𝜎4[𝝉(𝒙2|𝑺 , �̃�|𝑺)] = 1 + 1 = 2
Para 𝜇 = 3.
𝜃(�̃�|𝑺 , 𝒙3|𝑺) = 𝜎4[𝝉(�̃�|𝑺 , 𝒙
3|𝑺)] + 𝜎4[𝝉(𝒙3|𝑺 , �̃�|𝑺)] = 0 + 0 = 0
128
Para 𝜇 = 4.
𝜃(�̃�|𝑺 , 𝒙4|𝑺) = 𝜎4[𝝉(�̃�|𝑺 , 𝒙
4|𝑺)] + 𝜎4[𝝉(𝒙4|𝑺 , �̃�|𝑺)] = 2 + 0 = 2
Para 𝜇 = 5.
𝜃(�̃�|𝑺 , 𝒙5|𝑺) = 𝜎4[𝝉(�̃�|𝑺 , 𝒙
5|𝑺)] + 𝜎4[𝝉(𝒙5|𝑺 , �̃�|𝑺)] = 0 + 2 = 2
3. Encontrar 𝜓 𝜖 {1,2,3, … , 𝑝} tal que 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) = ⋀ 𝜃(�̃�|𝑺 , 𝒙
𝜇|𝑺)𝑝𝜇=1 .
A 𝜓 se le asignará el valor del índice 𝑖 del vector donde se encuentre la primera aparición
del mínimo.
𝜓 = [2 ⋀ 2 ⋀ 0 ⋀ 2 ⋀ 2] = 3
4. Obtener �̃� , el vector negado de �̃�.
�̃� =
(
11001)
, �̃� =
(
00110)
5. Obtener la Restricción �̃�|�̂�.
Para el vector �̃� =
(
00110)
la Restricción de �̃� por 𝑺 es �̃�|�̂�=
(
00110)
.
6. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)
Dado que la transformada 𝜃(𝒙 , 𝒚) está definida de la siguiente forma
𝜃(𝒙 , 𝒚) = 𝜎𝑛[𝝉(𝒙 , 𝒚)] + 𝜎𝑛[𝝉(𝒚 , 𝒙)]
Primero desarrollaremos la transformada 𝝉 (�̃�|�̂� , 𝒙𝜇|
�̂�) , donde cada componente del
vector 𝝉 se calcula
[𝝉(𝒙, 𝒚)]𝑖 = 𝛽[𝒙𝑖, 𝛼(0, 𝒚𝑖)]
Para 𝜇 = 1.
129
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙1|
�̂�1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙1|
�̂�2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙1|
�̂�3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙1|
�̂�4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙1|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 2.
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙2|
�̂�1)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙2|
�̂�2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙2|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙2|
�̂�4)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙2|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 3.
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙3|
�̂�1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙3|
�̂�2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙3|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙3|
�̂�4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙3|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 4.
[𝝉 (�̃�|�̂� , 𝒙4|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙4|
�̂�1)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙4|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙4|
�̂�2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙4|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙4|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙4|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙4|
�̂�4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙4|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙4|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
130
Para 𝜇 = 5.
[𝝉 (�̃�|�̂� , 𝒙5|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙5|
�̂�1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙5|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙5|
�̂�2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙5|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙5|
�̂�3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙5|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙5|
�̂�4)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙5|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙5|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Ahora desarrollaremos la transformada 𝝉 (𝒙𝜇|�̂� , �̃�|
�̂�)
Para 𝜇 = 1.
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙1|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙1|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙1|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙1|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙1|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 2.
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙2|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙2|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙2|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙2|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙2|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 3.
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙3|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙3|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙3|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
131
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙3|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙3|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 4.
[𝝉 (𝒙4|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙4|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙4|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙4|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙4|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙4|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙4|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙4|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙4|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙4|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 5.
[𝝉 (𝒙5|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙5|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙5|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙5|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙5|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙5|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙5|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙5|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙5|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙5|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
A continuación debemos calcular el valor de 𝜎𝑛(𝝉) con 𝑛 = 5 , para las
transformadas 𝝉 calculadas previamente.
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎5 [𝝉 (�̃�|�̂� , 𝒙𝜇|�̂�)] son:
Para 𝜇 = 1.
𝝉 (�̃�|�̂� , 𝒙1|
�̂�) =
(
00100)
→ 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
1|�̂�)] = 1
Para 𝜇 = 2.
𝝉 (�̃�|�̂� , 𝒙2|
�̂�) =
(
00010)
→ 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
2|�̂�)] = 1
132
Para 𝜇 = 3.
𝝉 (�̃�|�̂� , 𝒙3|
�̂�) =
(
00000)
→ 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
3|�̂�)] = 0
Para 𝜇 = 4.
𝝉 (�̃�|�̂� , 𝒙4|
�̂�) =
(
00000)
→ 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
4|�̂�)] = 0
Para 𝜇 = 5.
𝝉 (�̃�|�̂� , 𝒙5|
�̂�) =
(
00110)
→ 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
5|�̂�)] = 2
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎5 [𝝉 (𝒙𝜇|�̂� , �̃�|�̂�)] son:
Para 𝜇 = 1.
𝝉 (𝒙1|�̂� , �̃�|
�̂�) =
(
01000)
→ 𝜎5 [𝝉 (𝒙1|
�̂� , �̃�|
�̂�)] = 1
Para 𝜇 = 2.
𝝉 (𝒙2|�̂� , �̃�|
�̂�) =
(
10000)
→ 𝜎5 [𝝉 (𝒙2|
�̂� , �̃�|
�̂�)] = 1
Para 𝜇 = 3.
𝝉 (𝒙3|�̂� , �̃�|
�̂�) =
(
00000)
→ 𝜎5 [𝝉 (𝒙3|
�̂� , �̃�|
�̂�)] = 0
Para 𝜇 = 4.
133
𝝉 (𝒙4|�̂� , �̃�|
�̂�) =
(
11000)
→ 𝜎5 [𝝉 (𝒙4|
�̂� , �̃�|
�̂�)] = 2
Para 𝜇 = 5.
𝝉 (𝒙5|�̂� , �̃�|
�̂�) =
(
00000)
→ 𝜎5 [𝝉 (𝒙5|
�̂� , �̃�|
�̂�)] = 0
Al ya haber realizado todos los cálculos necesarios para la transformada 𝜃 ,
obtendremos los valores escalares de 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)para cada 𝜇 𝜖 {1,2,3, … , 𝑝} y con 𝑛 =
5, como se muestra a continuación.
Para 𝜇 = 1.
𝜃 (�̃�|�̂� , 𝒙1|
�̂�) = 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
1|�̂�)] + 𝜎5 [𝝉 (𝒙
1|�̂� , �̃�|
�̂�)] = 1 + 1 = 2
Para 𝜇 = 2.
𝜃 (�̃�|�̂� , 𝒙2|
�̂�) = 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
2|�̂�)] + 𝜎5 [𝝉 (𝒙2|
�̂� , �̃�|
�̂�)] = 1 + 1 = 2
Para 𝜇 = 3.
𝜃 (�̃�|�̂� , 𝒙3|
�̂�) = 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
3|�̂�)] + 𝜎5 [𝝉 (𝒙3|
�̂� , �̃�|
�̂�)] = 0 + 0 = 0
Para 𝜇 = 4.
𝜃 (�̃�|�̂� , 𝒙4|
�̂�) = 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
4|�̂�)] + 𝜎5 [𝝉 (𝒙
4|�̂� , �̃�|
�̂�)] = 0 + 2 = 2
Para 𝜇 = 5.
𝜃 (�̃�|�̂� , 𝒙5|
�̂�) = 𝜎5 [𝝉 (�̃�|�̂� , 𝒙
5|�̂�)] + 𝜎5 [𝝉 (𝒙5|
�̂� , �̃�|
�̂�)] = 2 + 0 = 2
7. Encontrar 𝜑 𝜖 {1,2,3, … , 𝑝} tal que 𝜃 (�̃�|�̂� , 𝒙𝜑|
�̂�) = ⋀ 𝜃 (�̃�|
�̂� , 𝒙𝜇|
�̂�)𝑝
𝜇=1 .
A 𝜑 se le asignará el valor del índice 𝑖 del vector donde se encuentre la primera aparición
del mínimo.
𝜑 = [2 ⋀ 2 ⋀ 0 ⋀ 2 ⋀ 2] = 3
8. Si 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) ≤ 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�), realizar la asignación 𝜔 = 𝜓 ; de otro modo, realizar
la asignación 𝜔 = 𝜑.
134
Para 𝜓 = 3, se tiene 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) = 0 y para 𝜑 = 3, se tiene 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�) = 0; por lo
tanto
𝜔 = 𝜓 = 3
9. Obtener (𝒙𝜔|𝑺)|𝑺, que es precisamente el vector 𝒙𝜔.
(𝒙3|𝑺)|𝑺 = 𝒙3 =
(
11001)
Como 𝒙3 pertenece al conjunto fundamental, se puede decir que el patrón fue
correctamente recuperado.
135
Apéndice 2. Ejercicio práctico de Memorias Asociativas
Alfa-Beta con Soporte Vectorial empleando la
codificación binaria Johnson-Möbius modificada
Sean 𝑥1, 𝑥2, 𝑥3, los patrones pertenecientes al conjunto fundamental.
𝑥1 = 2, 5, 3
𝑥2 = 4, 3, 2
𝑥3 = 5, 2, 4
donde el rango de valores para todos los atributos va desde 1 hasta 6.
Codificación empleando el código Johnson-Möbius modificado
1. Para cada uno de los atributos de los patrones crear un conjunto de datos para ser
codificado.
𝑟1 = {2, 4, 5} 𝑟2 = {5, 3, 2} 𝑟3 = {3, 2, 4} 𝑛𝑚𝑖𝑛 = 1
𝑛𝑚𝑎𝑥 = 6
2. Crear los conjuntos transformados.
𝑡1 = {1, 3, 4} 𝑡2 = {4, 2, 1} 𝑡3 = {2, 1, 3} 𝑛𝑚𝑎𝑥 = 5
3. Se escoge el número fijo 𝑑 = 0 para los atributos.
𝑡1 = {1, 3, 4} 𝑡2 = {4, 2, 1} 𝑡3 = {2, 1, 3} 𝑛𝑚𝑎𝑥 = 5
4. Se realiza el escalamiento de 10𝑑.
𝑡1 = {1, 3, 4} 𝑡2 = {4, 2, 1} 𝑡3 = {2, 1, 3} 𝑛𝑚𝑎𝑥 = 5
5. Generar el código Johnson-Möbius modificado.
𝑒11 = 00001 𝑒21 = 01111 𝑒31 = 00011
136
𝑒12 = 00111
𝑒13 = 01111
𝑒22 = 00011
𝑒23 = 00001
𝑒32 = 00001
𝑒33 = 00111
Para representar los patrones del conjunto fundamental empleando el código Johnson-Möbius
modificado debemos expresar los códigos resultantes en forma de vector, como se muestra a
continuación. Para poder distinguir cada uno de los códigos se separaron con el símbolo guion
(−).
𝒙1 =
(
00001−01111−00011)
, 𝒙2 =
(
00111−00011−00001)
, 𝒙3 =
(
01111−00001−00111)
.
Reconocimiento de patrones empleado el algoritmo AlfaBetaSVM
Sean 𝒙1, 𝒙2, 𝒙3 ∈ 𝐴𝑛 , con dimensión 𝑛 = 15 y con cardinalidad 𝑝 = 3 , los vectores que
conforman el conjunto fundamental.
137
𝒙1 =
(
000010111100011)
, 𝒙2 =
(
001110001100001)
, 𝒙3 =
(
011110000100111)
.
Fase de aprendizaje
1. A partir del conjunto fundamental anterior calcularemos el vector de soporte 𝑺.
Debido a que la cardinalidad del conjunto fundamental es impar con 𝑝 = 3 usaremos la
siguiente expresión
𝑺𝑖 = 𝛽
[
⋀𝛽 (𝒙𝑖2𝑘−1, 𝒙𝑖
2𝑘)
𝑝−12
𝑘=1
, 𝒙𝑖𝑝
]
Por lo tanto cada componente del vector de soporte se calculará así
𝑺𝑖 = 𝛽[𝛽(𝒙𝑖1, 𝒙𝑖
2), 𝒙𝑖3]
𝑺1 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
𝑺2 = 𝛽[(0 , 0) , 1] = 𝛽[0, 1] = 0
𝑺3 = 𝛽[(0 , 1) , 1] = 𝛽[0, 1] = 0
𝑺4 = 𝛽[(0 , 1) , 1] = 𝛽[0, 1] = 0
𝑺5 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
𝑺6 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
𝑺7 = 𝛽[(1 , 0) , 0] = 𝛽[0, 0] = 0
𝑺8 = 𝛽[(1 , 0) , 0] = 𝛽[0, 0] = 0
𝑺9 = 𝛽[(1 , 1) , 0] = 𝛽[1, 0] = 0
𝑺10 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
𝑺11 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
138
𝑺12 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
𝑺13 = 𝛽[(0 , 0) , 1] = 𝛽[0, 1] = 0
𝑺14 = 𝛽[(1 , 0) , 1] = 𝛽[0, 1] = 0
𝑺15 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
Finalmente el vector de soporte para el conjunto fundamental es 𝑺 =
(
000010000100001)
.
2. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, obtener 𝒙𝜇|𝑺. A partir de estos resultados formar el conjunto
fundamental restringido {(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}.
Para el vector 𝒙1 =
(
000010111100011)
la Restricción de 𝒙1 por 𝑺 es 𝒙1|𝑺 =
(
000001110001)
.
139
Para el vector 𝒙2 =
(
001110001100001)
la Restricción de 𝒙2 por 𝑺 es 𝒙2|𝑺 =
(
001100010000)
.
Para el vector 𝒙3 =
(
011110000100111)
la Restricción de 𝒙3 por 𝑺 es 𝒙3|𝑺 =
(
011100000011)
.
Con estos resultados formamos el conjunto fundamental restringido
{(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}.
140
𝒙1|𝑺 =
(
000001110001)
, 𝒙2|𝑺 =
(
001100010000)
, 𝒙3|𝑺 =
(
011100000011)
.
3. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝} , obtener 𝒙𝜇 , el vector negado de 𝒙𝜇 . Con los 𝑝 vectores
negados se forma el conjunto fundamental negado {(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}.
𝒙1 =
(
000010111100011)
, 𝒙1 =
(
111101000011100)
, 𝒙2 =
(
001110001100001)
, 𝒙2 =
(
110001110011110)
, 𝒙3 =
(
011110000100111)
, 𝒙3 =
(
100001111011000)
.
Con estos resultados formamos el conjunto fundamental negado
{(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}.
141
𝒙1 =
(
111101000011100)
, 𝒙2 =
(
110001110011110)
, 𝒙3 =
(
100001111011000)
.
4. A partir del conjunto fundamental negado, calcular el vector de soporte 𝑺.
Debido a que la cardinalidad del conjunto fundamental negado es impar con 𝑝 = 3
usaremos la siguiente expresión.
𝑺𝑖 = 𝛽
[
⋀𝛽 (𝒙𝑖2𝑘−1, 𝒙𝑖
2𝑘)
𝑝−12
𝑘=1
, 𝒙𝑖𝑝
]
Por lo tanto cada componente del vector de soporte se calculará así
𝑺𝑖 = 𝛽[𝛽(𝒙𝑖1, 𝒙𝑖
2), 𝒙𝑖3]
𝑺1 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
𝑺2 = 𝛽[(1 , 1) , 0] = 𝛽[1, 0] = 0
𝑺3 = 𝛽[(1 , 0) , 0] = 𝛽[0, 0] = 0
𝑺4 = 𝛽[(1 , 0) , 0] = 𝛽[0, 0] = 0
𝑺5 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
𝑺6 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
𝑺7 = 𝛽[(0 , 1) , 1] = 𝛽[0, 1] = 0
𝑺8 = 𝛽[(0 , 1) , 1] = 𝛽[0, 1] = 0
𝑺9 = 𝛽[(0 , 0) , 1] = 𝛽[0, 1] = 0
𝑺10 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
𝑺11 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
𝑺12 = 𝛽[(1 , 1) , 1] = 𝛽[1, 1] = 1
𝑺13 = 𝛽[(1 , 1) , 0] = 𝛽[1, 0] = 0
𝑺14 = 𝛽[(0 , 1) , 0] = 𝛽[0, 0] = 0
142
𝑺15 = 𝛽[(0 , 0) , 0] = 𝛽[0, 0] = 0
Por lo que el vector de soporte para el conjunto fundamental negado es 𝑺 =
(
100001000011000)
.
5. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, obtener 𝒙𝜇|�̂�. A partir de estos resultados formar el conjunto
fundamental negado restringido {(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}.
Para el vector 𝒙1 =
(
111101000011100)
la Restricción de 𝒙1 por 𝑺 es 𝒙1|�̂�=
(
11100000100)
.
143
Para el vector 𝒙2 =
(
110001110011110)
la Restricción de 𝒙2 por 𝑺 es 𝒙2|�̂�=
(
10001100110)
.
Para el vector 𝒙3 =
(
100001111011000)
la Restricción de 𝒙3 por 𝑺 es 𝒙3|�̂�=
(
00001110000)
.
Con estos resultados formamos el conjunto fundamental negado restringido
{(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}
144
𝒙1|�̂�=
(
11100000100)
, 𝒙2|�̂�=
(
10001100110)
, 𝒙3|�̂�=
(
00001110000)
.
Fase de recuperación
Presentaremos el patrón �̃�, el cual está contenido en el conjunto fundamental.
�̃� =
(
000010111100011)
1. Obtener la Restricción �̃�|𝑺.
145
Para el vector �̃� =
(
000010111100011)
la Restricción de �̃� por 𝑺 es �̃�|𝑺 =
(
000001110001)
.
2. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺).
Dado que la transformada 𝜃(𝒙 , 𝒚) está definida de la siguiente forma
𝜃(𝒙 , 𝒚) = 𝜎𝑛[𝝉(𝒙 , 𝒚)] + 𝜎𝑛[𝝉(𝒚 , 𝒙)]
Primero desarrollaremos la transformada 𝝉(�̃�|𝑺 , 𝒙𝜇|𝑺), donde cada componente del vector
𝝉 se calcula
[𝝉(𝒙, 𝒚)]𝑖 = 𝛽[𝒙𝑖, 𝛼(0, 𝒚𝑖)]
Para 𝜇 = 1.
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
1|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
1|𝑺2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
1|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
1|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]5 = 𝛽[�̃�|𝑺5, 𝛼(0, 𝒙
1|𝑺5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]6 = 𝛽[�̃�|𝑺6, 𝛼(0, 𝒙
1|𝑺6)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]7 = 𝛽[�̃�|𝑺7, 𝛼(0, 𝒙
1|𝑺7)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]8 = 𝛽[�̃�|𝑺8, 𝛼(0, 𝒙
1|𝑺8)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]9 = 𝛽[�̃�|𝑺9, 𝛼(0, 𝒙
1|𝑺9)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]10 = 𝛽[�̃�|𝑺10, 𝛼(0, 𝒙
1|𝑺10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]11 = 𝛽[�̃�|𝑺11, 𝛼(0, 𝒙
1|𝑺11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙1|𝑺)]12 = 𝛽[�̃�|𝑺12, 𝛼(0, 𝒙
1|𝑺12)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
Para 𝜇 = 2.
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
2|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
146
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
2|𝑺2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
2|𝑺3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
2|𝑺4)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]5 = 𝛽[�̃�|𝑺5, 𝛼(0, 𝒙
2|𝑺5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]6 = 𝛽[�̃�|𝑺6, 𝛼(0, 𝒙
2|𝑺6)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]7 = 𝛽[�̃�|𝑺7, 𝛼(0, 𝒙
2|𝑺7)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]8 = 𝛽[�̃�|𝑺8, 𝛼(0, 𝒙
2|𝑺8)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]9 = 𝛽[�̃�|𝑺9, 𝛼(0, 𝒙
2|𝑺9)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]10 = 𝛽[�̃�|𝑺10, 𝛼(0, 𝒙
2|𝑺10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]11 = 𝛽[�̃�|𝑺11, 𝛼(0, 𝒙
2|𝑺11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙2|𝑺)]12 = 𝛽[�̃�|𝑺12, 𝛼(0, 𝒙
2|𝑺12)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
Para 𝜇 = 3.
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]1 = 𝛽[�̃�|𝑺1, 𝛼(0, 𝒙
3|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]2 = 𝛽[�̃�|𝑺2, 𝛼(0, 𝒙
3|𝑺2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]3 = 𝛽[�̃�|𝑺3, 𝛼(0, 𝒙
3|𝑺3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]4 = 𝛽[�̃�|𝑺4, 𝛼(0, 𝒙
3|𝑺4)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]5 = 𝛽[�̃�|𝑺5, 𝛼(0, 𝒙
3|𝑺5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]6 = 𝛽[�̃�|𝑺6, 𝛼(0, 𝒙
3|𝑺6)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]7 = 𝛽[�̃�|𝑺7, 𝛼(0, 𝒙
3|𝑺7)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]8 = 𝛽[�̃�|𝑺8, 𝛼(0, 𝒙
3|𝑺8)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]9 = 𝛽[�̃�|𝑺9, 𝛼(0, 𝒙
3|𝑺9)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]10 = 𝛽[�̃�|𝑺10, 𝛼(0, 𝒙
3|𝑺10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]11 = 𝛽[�̃�|𝑺11, 𝛼(0, 𝒙
3|𝑺11)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(�̃�|𝑺 , 𝒙3|𝑺)]12 = 𝛽[�̃�|𝑺12, 𝛼(0, 𝒙
3|𝑺12)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
Ahora desarrollaremos la transformada 𝝉(𝒙𝜇|𝑺 , �̃�|𝑺)
Para 𝜇 = 1.
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙1|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙1|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙1|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙1|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙1|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙1|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙1|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
147
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙1|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙1|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙1|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙1|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙1|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙1|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
Para 𝜇 = 2.
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙2|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙2|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙2|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙2|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]5 = 𝛽[𝒙2|𝑺5, 𝛼(0, �̃�|𝑺5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]6 = 𝛽[𝒙2|𝑺6, 𝛼(0, �̃�|𝑺6)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]7 = 𝛽[𝒙2|𝑺7, 𝛼(0, �̃�|𝑺7)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]8 = 𝛽[𝒙2|𝑺8, 𝛼(0, �̃�|𝑺8)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]9 = 𝛽[𝒙2|𝑺9, 𝛼(0, �̃�|𝑺9)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]10 = 𝛽[𝒙2|𝑺10, 𝛼(0, �̃�|𝑺10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]11 = 𝛽[𝒙2|𝑺11, 𝛼(0, �̃�|𝑺11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙2|𝑺 , �̃�|𝑺)]12 = 𝛽[𝒙2|𝑺12, 𝛼(0, �̃�|𝑺12)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
Para 𝜇 = 3.
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]1 = 𝛽[𝒙3|𝑺1, 𝛼(0, �̃�|𝑺1)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]2 = 𝛽[𝒙3|𝑺2, 𝛼(0, �̃�|𝑺2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]3 = 𝛽[𝒙3|𝑺3, 𝛼(0, �̃�|𝑺3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]4 = 𝛽[𝒙3|𝑺4, 𝛼(0, �̃�|𝑺4)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]5 = 𝛽[𝒙3|𝑺5, 𝛼(0, �̃�|𝑺5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]6 = 𝛽[𝒙3|𝑺6, 𝛼(0, �̃�|𝑺6)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]7 = 𝛽[𝒙3|𝑺7, 𝛼(0, �̃�|𝑺7)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]8 = 𝛽[𝒙3|𝑺8, 𝛼(0, �̃�|𝑺8)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]9 = 𝛽[𝒙3|𝑺9, 𝛼(0, �̃�|𝑺9)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]10 = 𝛽[𝒙3|𝑺10, 𝛼(0, �̃�|𝑺10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]11 = 𝛽[𝒙3|𝑺11, 𝛼(0, �̃�|𝑺11)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉(𝒙3|𝑺 , �̃�|𝑺)]12 = 𝛽[𝒙3|𝑺12, 𝛼(0, �̃�|𝑺12)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
A continuación debemos calcular el valor de 𝜎𝑛(𝝉) con 𝑛 = 12, para las transformadas 𝝉
calculadas previamente.
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎12[𝝉(�̃�|𝑺 , 𝒙𝜇|𝑺)] son:
148
Para 𝜇 = 1.
𝝉(�̃�|𝑺 , 𝒙1|𝑺) =
(
000000000000)
→ 𝜎12[𝝉(�̃�|𝑺 , 𝒙1|𝑺)] = 0
Para 𝜇 = 2.
𝝉(�̃�|𝑺 , 𝒙2|𝑺) =
(
000001100001)
→ 𝜎12[𝝉(�̃�|𝑺 , 𝒙2|𝑺)] = 3
Para 𝜇 = 3.
𝝉(�̃�|𝑺 , 𝒙3|𝑺) =
(
000001110000)
→ 𝜎12[𝝉(�̃�|𝑺 , 𝒙3|𝑺)] = 3
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎12[𝝉(𝒙𝜇|𝑺 , �̃�|𝑺)] son:
Para 𝜇 = 1.
149
𝝉(𝒙1|𝑺 , �̃�|𝑺) =
(
000000000000)
→ 𝜎12[𝝉(𝒙1|𝑺 , �̃�|𝑺)] = 0
Para 𝜇 = 2.
𝝉(𝒙2|𝑺 , �̃�|𝑺) =
(
001100000000)
→ 𝜎12[𝝉(𝒙2|𝑺 , �̃�|𝑺)] = 2
Para 𝜇 = 3.
𝝉(𝒙3|𝑺 , �̃�|𝑺) =
(
011100000010)
→ 𝜎12[𝝉(𝒙3|𝑺 , �̃�|𝑺)] = 4
Al ya haber realizado todos los cálculos necesarios para la transformada 𝜃, obtendremos
los valores escalares de 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) para cada 𝜇 𝜖 {1,2,3, … , 𝑝} y con 𝑛 = 12, como se
muestra a continuación.
Para 𝜇 = 1.
𝜃(�̃�|𝑺 , 𝒙1|𝑺) = 𝜎12[𝝉(�̃�|𝑺 , 𝒙
1|𝑺)] + 𝜎12[𝝉(𝒙1|𝑺 , �̃�|𝑺)] = 0 + 0 = 0
150
Para 𝜇 = 2.
𝜃(�̃�|𝑺 , 𝒙2|𝑺) = 𝜎12[𝝉(�̃�|𝑺 , 𝒙
2|𝑺)] + 𝜎12[𝝉(𝒙2|𝑺 , �̃�|𝑺)] = 3 + 2 = 5
Para 𝜇 = 3.
𝜃(�̃�|𝑺 , 𝒙3|𝑺) = 𝜎12[𝝉(�̃�|𝑺 , 𝒙
3|𝑺)] + 𝜎12[𝝉(𝒙3|𝑺 , �̃�|𝑺)] = 3 + 4 = 7
3. Encontrar 𝜓 𝜖 {1,2,3, … , 𝑝} tal que 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) = ⋀ 𝜃(�̃�|𝑺 , 𝒙
𝜇|𝑺)𝑝𝜇=1 .
A 𝜓 se le asignará el valor del índice 𝑖 del vector donde se encuentre la primera aparición
del mínimo.
𝜓 = [0 ⋀ 5 ⋀ 7] = 1
4. Obtener �̃� , el vector negado de �̃�.
�̃� =
(
000010111100011)
, �̃� =
(
111101000011100)
.
5. Obtener la Restricción �̃�|�̂�.
151
Para el vector �̃� =
(
111101000011100)
la Restricción de �̃� por 𝑺 es �̃�|�̂�=
(
11100000100)
.
6. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)
Dado que la transformada 𝜃(𝒙 , 𝒚) está definida de la siguiente forma
𝜃(𝒙 , 𝒚) = 𝜎𝑛[𝝉(𝒙 , 𝒚)] + 𝜎𝑛[𝝉(𝒚 , 𝒙)]
Primero desarrollaremos la transformada 𝝉 (�̃�|�̂� , 𝒙𝜇|
�̂�) , donde cada componente del
vector 𝝉 se calcula
[𝝉(𝒙, 𝒚)]𝑖 = 𝛽[𝒙𝑖, 𝛼(0, 𝒚𝑖)]
Para 𝜇 = 1.
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙1|
�̂�1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙1|
�̂�2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙1|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙1|
�̂�4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙1|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]6= 𝛽 [�̃�|
�̂�6, 𝛼 (0, 𝒙1|
�̂�6)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]7= 𝛽 [�̃�|
�̂�7, 𝛼 (0, 𝒙1|
�̂�7)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]8= 𝛽 [�̃�|
�̂�8, 𝛼 (0, 𝒙1|
�̂�8)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
152
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]9= 𝛽 [�̃�|
�̂�9, 𝛼 (0, 𝒙1|
�̂�9)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]10= 𝛽 [�̃�|
�̂�10, 𝛼 (0, 𝒙1|
�̂�10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙1|
�̂�)]11= 𝛽 [�̃�|
�̂�11, 𝛼 (0, 𝒙1|
�̂�11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 2.
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙2|
�̂�1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙2|
�̂�2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙2|
�̂�3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙2|
�̂�4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙2|
�̂�5)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]6= 𝛽 [�̃�|
�̂�6, 𝛼 (0, 𝒙2|
�̂�6)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]7= 𝛽 [�̃�|
�̂�7, 𝛼 (0, 𝒙2|
�̂�7)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]8= 𝛽 [�̃�|
�̂�8, 𝛼 (0, 𝒙2|
�̂�8)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]9= 𝛽 [�̃�|
�̂�9, 𝛼 (0, 𝒙2|
�̂�9)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]10= 𝛽 [�̃�|
�̂�10, 𝛼 (0, 𝒙2|
�̂�10)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙2|
�̂�)]11= 𝛽 [�̃�|
�̂�11, 𝛼 (0, 𝒙2|
�̂�11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 3.
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]1= 𝛽 [�̃�|
�̂�1, 𝛼 (0, 𝒙3|
�̂�1)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]2= 𝛽 [�̃�|
�̂�2, 𝛼 (0, 𝒙3|
�̂�2)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]3= 𝛽 [�̃�|
�̂�3, 𝛼 (0, 𝒙3|
�̂�3)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]4= 𝛽 [�̃�|
�̂�4, 𝛼 (0, 𝒙3|
�̂�4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]5= 𝛽 [�̃�|
�̂�5, 𝛼 (0, 𝒙3|
�̂�5)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]6= 𝛽 [�̃�|
�̂�6, 𝛼 (0, 𝒙3|
�̂�6)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]7= 𝛽 [�̃�|
�̂�7, 𝛼 (0, 𝒙3|
�̂�7)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
153
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]8= 𝛽 [�̃�|
�̂�8, 𝛼 (0, 𝒙3|
�̂�8)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]9= 𝛽 [�̃�|
�̂�9, 𝛼 (0, 𝒙3|
�̂�9)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]10= 𝛽 [�̃�|
�̂�10, 𝛼 (0, 𝒙3|
�̂�10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (�̃�|�̂� , 𝒙3|
�̂�)]11= 𝛽 [�̃�|
�̂�11, 𝛼 (0, 𝒙3|
�̂�11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Ahora desarrollaremos la transformada 𝝉 (𝒙𝜇|�̂� , �̃�|
�̂�)
Para 𝜇 = 1.
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙1|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙1|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙1|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙1|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙1|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]6= 𝛽 [𝒙1|
�̂�6, 𝛼 (0, �̃�|
�̂�6)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]7= 𝛽 [𝒙1|
�̂�7, 𝛼 (0, �̃�|
�̂�7)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]8= 𝛽 [𝒙1|
�̂�8, 𝛼 (0, �̃�|
�̂�8)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]9= 𝛽 [𝒙1|
�̂�9, 𝛼 (0, �̃�|
�̂�9)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]10= 𝛽 [𝒙1|
�̂�10, 𝛼 (0, �̃�|
�̂�10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙1|�̂� , �̃�|
�̂�)]11= 𝛽 [𝒙1|
�̂�11, 𝛼 (0, �̃�|
�̂�11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 2.
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙2|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙2|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙2|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙2|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
154
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙2|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]6= 𝛽 [𝒙2|
�̂�6, 𝛼 (0, �̃�|
�̂�6)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]7= 𝛽 [𝒙2|
�̂�7, 𝛼 (0, �̃�|
�̂�7)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]8= 𝛽 [𝒙2|
�̂�8, 𝛼 (0, �̃�|
�̂�8)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]9= 𝛽 [𝒙2|
�̂�9, 𝛼 (0, �̃�|
�̂�9)] = 𝛽[1, 𝛼(0,1)] = 𝛽[1,0] = 0
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]10= 𝛽 [𝒙2|
�̂�10, 𝛼 (0, �̃�|
�̂�10)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙2|�̂� , �̃�|
�̂�)]11= 𝛽 [𝒙2|
�̂�11, 𝛼 (0, �̃�|
�̂�11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
Para 𝜇 = 3.
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]1= 𝛽 [𝒙3|
�̂�1, 𝛼 (0, �̃�|
�̂�1)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]2= 𝛽 [𝒙3|
�̂�2, 𝛼 (0, �̃�|
�̂�2)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]3= 𝛽 [𝒙3|
�̂�3, 𝛼 (0, �̃�|
�̂�3)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]4= 𝛽 [𝒙3|
�̂�4, 𝛼 (0, �̃�|
�̂�4)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]5= 𝛽 [𝒙3|
�̂�5, 𝛼 (0, �̃�|
�̂�5)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]6= 𝛽 [𝒙3|
�̂�6, 𝛼 (0, �̃�|
�̂�6)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]7= 𝛽 [𝒙3|
�̂�7, 𝛼 (0, �̃�|
�̂�7)] = 𝛽[1, 𝛼(0,0)] = 𝛽[1,1] = 1
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]8= 𝛽 [𝒙3|
�̂�8, 𝛼 (0, �̃�|
�̂�8)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]9= 𝛽 [𝒙3|
�̂�9, 𝛼 (0, �̃�|
�̂�9)] = 𝛽[0, 𝛼(0,1)] = 𝛽[0,0] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]10= 𝛽 [𝒙3|
�̂�10, 𝛼 (0, �̃�|
�̂�10)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
[𝝉 (𝒙3|�̂� , �̃�|
�̂�)]11= 𝛽 [𝒙3|
�̂�11, 𝛼 (0, �̃�|
�̂�11)] = 𝛽[0, 𝛼(0,0)] = 𝛽[0,1] = 0
A continuación debemos calcular el valor de 𝜎𝑛(𝝉) con 𝑛 = 11, para las transformadas 𝝉
calculadas previamente.
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎11 [𝝉 (�̃�|�̂� , 𝒙𝜇|�̂�)] son:
Para 𝜇 = 1.
155
𝝉 (�̃�|�̂� , 𝒙1|
�̂�) =
(
00000000000)
→ 𝜎11 [𝝉 (�̃�|�̂� , 𝒙1|�̂�)] = 0
Para 𝜇 = 2.
𝝉 (�̃�|�̂� , 𝒙2|
�̂�) =
(
01100000000)
→ 𝜎11 [𝝉 (�̃�|�̂� , 𝒙2|�̂�)] = 2
Para 𝜇 = 3.
𝝉 (�̃�|�̂� , 𝒙3|
�̂�) =
(
11100000100)
→ 𝜎11 [𝝉 (�̃�|�̂� , 𝒙3|�̂�)] = 4
Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, los valores escalares 𝜎11 [𝝉 (𝒙𝜇|�̂� , �̃�|�̂�)] son:
Para 𝜇 = 1.
156
𝝉 (𝒙1|�̂� , �̃�|
�̂�) =
(
00000000000)
→ 𝜎11 [𝝉 (𝒙1|�̂� , �̃�|
�̂�)] = 0
Para 𝜇 = 2.
𝝉 (𝒙2|�̂� , �̃�|
�̂�) =
(
00001100010)
→ 𝜎11 [𝝉 (𝒙2|�̂� , �̃�|
�̂�)] = 3
Para 𝜇 = 3.
𝝉 (𝒙3|�̂� , �̃�|
�̂�) =
(
00001110000)
→ 𝜎11 [𝝉 (𝒙3|�̂� , �̃�|
�̂�)] = 3
Al ya haber realizado todos los cálculos necesarios para la transformada 𝜃, obtendremos
los valores escalares de 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)para cada 𝜇 𝜖 {1,2,3, … , 𝑝} y con 𝑛 = 11, como se
muestra a continuación.
Para 𝜇 = 1.
𝜃 (�̃�|�̂� , 𝒙1|
�̂�) = 𝜎11 [𝝉 (�̃�|�̂� , 𝒙
1|�̂�)] + 𝜎11 [𝝉 (𝒙
1|�̂� , �̃�|
�̂�)] = 0 + 0 = 0
Para 𝜇 = 2.
157
𝜃 (�̃�|�̂� , 𝒙2|
�̂�) = 𝜎11 [𝝉 (�̃�|�̂� , 𝒙
2|�̂�)] + 𝜎11 [𝝉 (𝒙2|
�̂� , �̃�|
�̂�)] = 2 + 3 = 5
Para 𝜇 = 3.
𝜃 (�̃�|�̂� , 𝒙3|
�̂�) = 𝜎11 [𝝉 (�̃�|�̂� , 𝒙
3|�̂�)] + 𝜎11 [𝝉 (𝒙3|
�̂� , �̃�|
�̂�)] = 4 + 3 = 7
7. Encontrar 𝜑 𝜖 {1,2,3, … , 𝑝} tal que 𝜃 (�̃�|�̂� , 𝒙𝜑|
�̂�) = ⋀ 𝜃 (�̃�|
�̂� , 𝒙𝜇|
�̂�)𝑝
𝜇=1 .
A 𝜑 se le asignará el valor del índice 𝑖 del vector donde se encuentre la primera aparición
del mínimo.
𝜑 = [0 ⋀ 5 ⋀ 7] = 1
8. Si 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) ≤ 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�), realizar la asignación 𝜔 = 𝜓 ; de otro modo, realizar
la asignación 𝜔 = 𝜑.
Para 𝜓 = 1, se tiene 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) = 0 y para 𝜑 = 1, se tiene 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�) = 0; por lo
tanto
𝜔 = 𝜓 = 1
9. Obtener (𝒙𝜔|𝑺)|𝑺, que es precisamente el vector 𝒙𝜔.
(𝒙1|𝑺)|𝑺 = 𝒙1 =
(
000010111100011)
Como 𝒙1 pertenece al conjunto fundamental, se puede decir que el patrón fue
correctamente recuperado.
158
Apendice 3. Ejercicio práctico de Memorias asociativas
Alfa-Beta con Soporte Vectorial sin codificación binaria
En el ejercicio del Apéndice 2 del algoritmo AlfaBetaSVM se empleó la codificación binaria
Johnson-Möbius modificada y durante el desarrollo del ejercicio se puede notar un
comportamiento interesante que nos beneficiará reduciendo considerablemente las operaciones
bit a bit necesarias para poder llevar a cabo este modelo; y que podemos evitar el uso de la
codificación binaria como tal. Para poder definir la operación del AlfaBetaSVM utilizando el
código Johnson-Möbius modificado pero sin los códigos binarios, emplearemos la expresión
abreviada del código. Revisemos el mismo ejemplo.
Sean 𝑥1, 𝑥2, 𝑥3, los patrones pertenecientes al conjunto fundamental.
𝑥1 = 2, 5, 3
𝑥2 = 4, 3, 2
𝑥3 = 5, 2, 4
Donde el rango de valores para todos los atributos va desde 1 hasta 6.
Codificación empleando el código Johnson-Möbius modificado en su forma abreviada
1. Para cada uno de los atributos de los patrones crear un conjunto de datos para ser
codificado.
𝑟1 = {2, 4, 5} 𝑟2 = {5, 3, 2} 𝑟3 = {3, 2, 4} 𝑛𝑚𝑖𝑛 = 1
𝑛𝑚𝑎𝑥 = 6
2. Crear los conjuntos transformados.
𝑡1 = {1, 3, 4} 𝑡2 = {4, 2, 1} 𝑡3 = {2, 1, 3} 𝑛𝑚𝑎𝑥 = 5
3. Se escoge el número fijo 𝑑 = 0 para los atributos.
𝑡1 = {1, 3, 4} 𝑡2 = {4, 2, 1} 𝑡3 = {2, 1, 3} 𝑛𝑚𝑎𝑥 = 5
4. Se realiza el escalamiento de 10𝑑.
159
𝑡1 = {1, 3, 4} 𝑡2 = {4, 2, 1} 𝑡3 = {2, 1, 3} 𝑛𝑚𝑎𝑥 = 5
5. Generar el código Johnson-Möbius modificado expresado en forma abreviada.
𝑒11 = 4/1
𝑒12 = 2/3
𝑒13 = 1/4
𝑒21 = 1/4
𝑒22 = 3/2
𝑒23 = 4/1
𝑒31 = 3/2
𝑒32 = 4/1
𝑒33 = 2/3
Para representar los patrones del conjunto fundamental empleando el código Johnson-Möbius
modificado en su forma abreviada debemos expresar los códigos resultantes en forma de vector,
como se muestra a continuación. Para poder distinguir cada uno de los códigos se separaron con
el símbolo guion (−).
𝒙1 =
(
4/1−1/4−3/2)
, 𝒙2 =
(
2/3−3/2−4/1)
, 𝒙3 =
(
1/4−4/1−2/3)
.
Reconocimiento de patrones empleado el algoritmo AlfaBetaSVM
Sean 𝒙1, 𝒙2, 𝒙3 ∈ 𝑍𝑛 , con dimensión 𝑛 = 3 y con cardinalidad 𝑝 = 3 , los vectores que
conforman el conjunto fundamental. Para formar este conjunto debemos utilizar solo el número
que indica la cantidad unos de la representación abreviada (el segundo número), como se muestra
a continuación.
𝒙1 = (142) , 𝒙2 = (
321) , 𝒙3 = (
413).
Fase de aprendizaje
1. A partir del conjunto fundamental anterior calcularemos el vector de soporte 𝑺.
El vector de soporte se calculará de otra forma porque no estamos empleando la
codificación binaria.
Para generar el vector de soporte la 𝑖-ésima componente del vector 𝑺 , se calcula de
acuerdo a la siguiente expresión:
160
𝑺𝑖 = min(𝒙𝑖𝑘, … , 𝒙𝑖
𝑝) , 𝑘 = 1,2,… , 𝑝
𝑺1 = min(1, 3, 4) = 1
𝑺2 = min(4, 2, 1) = 1
𝑺3 = min(2, 1, 3) = 1
Finalmente el vector de soporte para el conjunto fundamental es 𝑺 = (111).
2. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, obtener 𝒙𝜇|𝑺. A partir de estos resultados formar el conjunto
fundamental restringido {(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}.
De acuerdo al ejemplo presentado en el Apéndice 2 en el paso 2, se puede apreciar que la
operación restricción es una resta. Por lo tanto la operación 𝒙|𝑺 empleando el código
Johnson-Möbius modificado se expresa como [𝒙|𝑺]𝑖 = 𝒙𝑖 − 𝑺𝑖.
Para el vector 𝒙1 = (142) la Restricción de 𝒙1 por 𝑺 es 𝒙1|𝑺 = (
031).
Para el vector 𝒙2 = (321) la Restricción de 𝒙2 por 𝑺 es 𝒙2|𝑺 = (
210).
Para el vector 𝒙3 = (413) la Restricción de 𝒙3 por 𝑺 es 𝒙3|𝑺 = (
302).
Con estos resultados formamos el conjunto fundamental restringido
{(𝒙𝜇|𝑺 | 𝒙𝜇|𝑺) | 𝜇 = 1,2,3, … , 𝑝}.
𝒙1|𝑺 = (031) , 𝒙2|𝑺 = (
210) , 𝒙3|𝑺 = (
302).
3. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝} , obtener 𝒙𝜇 , el vector negado de 𝒙𝜇 . Con los 𝑝 vectores
negados se forma el conjunto fundamental negado {(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}.
Para formar este conjunto debemos utilizar solo el número que indica la cantidad ceros de
la representación abreviada (el primer número), como se muestra a continuación.
161
𝒙1 = (413) , 𝒙2 = (
234) , 𝒙3 = (
142).
Con estos resultados formamos el conjunto fundamental negado
{(𝒙𝜇 | 𝒙𝜇) | 𝜇 = 1,2,3, … , 𝑝}.
𝒙1 = (413) , 𝒙2 = (
234) , 𝒙3 = (
142).
4. A partir del conjunto fundamental negado, calcular el vector de soporte 𝑺.
Como lo observamos en el paso 1, para generar el vector de soporte la 𝑖 -ésima
componente del vector 𝑺, se calcula de acuerdo a la siguiente expresión:
𝑺𝑖 = min(𝒙𝑖𝑘, … , 𝒙𝑖
𝑝) , 𝑘 = 1,2,… , 𝑝
𝑺1 = min(4, 2, 1) = 1
𝑺2 = min(1, 3, 4) = 1
𝑺3 = min(3, 4, 2) = 2
Por lo que el vector de soporte para el conjunto fundamental negado es 𝑺 = (112).
5. Para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, obtener 𝒙𝜇|�̂�. A partir de estos resultados formar el conjunto
fundamental negado restringido {(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}.
La operación 𝒙|𝑺 empleando el código Johnson-Möbius modificado se expresa como
[𝒙|𝑺]𝑖 = 𝒙𝑖 − 𝑺𝑖.
Para el vector 𝒙1 = (413) la Restricción de 𝒙1 por 𝑺 es 𝒙1|
�̂�= (
301).
Para el vector 𝒙2 = (234) la Restricción de 𝒙2 por 𝑺 es 𝒙2|
�̂�= (
122).
Para el vector 𝒙3 = (142) la Restricción de 𝒙3 por 𝑺 es 𝒙3|
�̂�= (
030).
162
Con estos resultados formamos el conjunto fundamental negado restringido
{(𝒙𝜇|�̂� | 𝒙𝜇|
�̂�) | 𝜇 = 1,2,3, … , 𝑝}
𝒙1|�̂�= (
301) , 𝒙2|
�̂�= (
122) , 𝒙3|
�̂�= (
030).
Fase de recuperación
Presentaremos el patrón �̃�, el cual está contenido en el conjunto fundamental.
�̃� =
(
4/1−1/4−3/2)
El patrón se presenta usando el código Johnson-Möbius modificado, las componentes del vector
serán los valores que indican la cantidad de unos (el segundo valor), entonces el patrón queda
como:
�̃� = (142)
1. Obtener la Restricción �̃�|𝑺.
Para el vector �̃� = (142) la Restricción de �̃� por 𝑺 es �̃�|𝑺 = (
031).
2. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺).
Dado que la transformada 𝜃(𝒙 , 𝒚) está definida de la siguiente forma
𝜃(𝒙 , 𝒚) = 𝜎𝑛[𝝉(𝒙 , 𝒚)] + 𝜎𝑛[𝝉(𝒚 , 𝒙)]
La operación 𝝉(𝒙 , 𝒚) busca las diferencias entre las componentes de los vectores 𝒙 con
respecto de 𝒚, la operación 𝜎𝑛(𝒙) regresa la cantidad de componentes con valor uno del
vector 𝒙 y la operación 𝜃(𝒙 , 𝒚) regresa el número de diferencias en ambas direcciones.
La transformada 𝜃(𝒙 , 𝒚) aplicada a vectores que empleen el código Johnson-Möbius
modificado presenta el mismo comportamiento que el valor absoluto de una resta. Por lo
163
tanto la operación 𝜃(𝒙 , 𝒚) empleando el código Johnson-Möbius modificado se define
como 𝜃(𝒙 , 𝒚) = ∑ 𝐴𝑏𝑠(𝒙𝑖 − 𝒚𝑖)𝑛𝑖=1 .
Obtendremos los valores escalares de 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, como se
muestra a continuación.
Para 𝜇 = 1.
𝜃(�̃�|𝑺 , 𝒙1|𝑺) = 𝐴𝑏𝑠(�̃�|𝑺1 − 𝒙
1|𝑺1) + 𝐴𝑏𝑠(�̃�|𝑺2 − 𝒙1|𝑺2) + 𝐴𝑏𝑠(�̃�|𝑺3 − 𝒙
1|𝑺3)
= 𝐴𝑏𝑠(0 − 0) + 𝐴𝑏𝑠(3 − 3) + 𝐴𝑏𝑠(1 − 1)
= 𝐴𝑏𝑠(0) + 𝐴𝑏𝑠(0) + 𝐴𝑏𝑠(0) = 0 + 0 + 0 = 0
Para 𝜇 = 2.
𝜃(�̃�|𝑺 , 𝒙2|𝑺) = 𝐴𝑏𝑠(�̃�|𝑺1 − 𝒙
2|𝑺1) + 𝐴𝑏𝑠(�̃�|𝑺2 − 𝒙2|𝑺2) + 𝐴𝑏𝑠(�̃�|𝑺3 − 𝒙
2|𝑺3)
= 𝐴𝑏𝑠(0 − 2) + 𝐴𝑏𝑠(3 − 1) + 𝐴𝑏𝑠(1 − 0)
= 𝐴𝑏𝑠(−2) + 𝐴𝑏𝑠(2) + 𝐴𝑏𝑠(1) = 2 + 2 + 1 = 5
Para 𝜇 = 3.
𝜃(�̃�|𝑺 , 𝒙3|𝑺) = 𝐴𝑏𝑠(�̃�|𝑺1 − 𝒙
3|𝑺1) + 𝐴𝑏𝑠(�̃�|𝑺2 − 𝒙3|𝑺2) + 𝐴𝑏𝑠(�̃�|𝑺3 − 𝒙
3|𝑺3)
= 𝐴𝑏𝑠(0 − 3) + 𝐴𝑏𝑠(3 − 0) + 𝐴𝑏𝑠(1 − 2)
= 𝐴𝑏𝑠(−3) + 𝐴𝑏𝑠(3) + 𝐴𝑏𝑠(−1) = 3 + 3 + 1 = 7
3. Encontrar 𝜓 𝜖 {1,2,3, … , 𝑝} tal que 𝜃(�̃�|𝑺 , 𝒙𝜇|𝑺) = ⋀ 𝜃(�̃�|𝑺 , 𝒙
𝜇|𝑺)𝑝𝜇=1 .
A 𝜓 se le asignará el valor del índice 𝑖 del vector donde se encuentre la primera aparición
del mínimo.
𝜓 = [0 ⋀ 5 ⋀ 7] = 1
4. Obtener �̃� , el vector negado de �̃�.
Dado que el patrón se presenta usando el código Johnson-Möbius modificado, las
componentes del vector serán los valores que indican la cantidad de ceros (el primer
valor), entonces el patrón queda como:
�̃� = (142) , �̃� = (
413).
5. Obtener la Restricción �̃�|�̂�.
164
Para el vector �̃� = (413) la Restricción de �̃� por 𝑺 es �̃�|
�̂�= (
301).
6. Para cada 𝜇 𝜖 {1,2,3,… , 𝑝}, obtener 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�)
La operación 𝜃(𝒙 , 𝒚) empleando el código Johnson-Möbius modificado se define como
𝜃(𝒙 , 𝒚) = ∑ 𝐴𝑏𝑠(𝒙𝑖 − 𝒚𝑖)𝑛𝑖=1 .
Obtendremos los valores escalares de 𝜃 (�̃�|�̂� , 𝒙𝜇|
�̂�) para cada 𝜇 𝜖 {1,2,3, … , 𝑝}, como se
muestra a continuación.
Para 𝜇 = 1.
𝜃 (�̃�|�̂� , 𝒙1|
�̂�) = 𝐴𝑏𝑠 (�̃�|
�̂�1− 𝒙3|
�̂�1) + 𝐴𝑏𝑠 (�̃�|
�̂�2− 𝒙3|
�̂�2) + 𝐴𝑏𝑠 (�̃�|
�̂�3− 𝒙3|
�̂�3)
= 𝐴𝑏𝑠(3 − 3) + 𝐴𝑏𝑠(0 − 0) + 𝐴𝑏𝑠(1 − 1)
= 𝐴𝑏𝑠(0) + 𝐴𝑏𝑠(0) + 𝐴𝑏𝑠(0) = 0 + 0 + 0 = 0
Para 𝜇 = 2.
𝜃 (�̃�|�̂� , 𝒙2|
�̂�) = 𝐴𝑏𝑠 (�̃�|
�̂�1− 𝒙3|
�̂�1) + 𝐴𝑏𝑠 (�̃�|
�̂�2− 𝒙3|
�̂�2) + 𝐴𝑏𝑠 (�̃�|
�̂�3− 𝒙3|
�̂�3)
= 𝐴𝑏𝑠(3 − 1) + 𝐴𝑏𝑠(0 − 2) + 𝐴𝑏𝑠(1 − 2)
= 𝐴𝑏𝑠(2) + 𝐴𝑏𝑠(−2) + 𝐴𝑏𝑠(−1) = 2 + 2 + 1 = 5
Para 𝜇 = 3.
𝜃 (�̃�|�̂� , 𝒙3|
�̂�) = 𝐴𝑏𝑠 (�̃�|
�̂�1− 𝒙3|
�̂�1) + 𝐴𝑏𝑠 (�̃�|
�̂�2− 𝒙3|
�̂�2) + 𝐴𝑏𝑠 (�̃�|
�̂�3− 𝒙3|
�̂�3)
= 𝐴𝑏𝑠(3 − 0) + 𝐴𝑏𝑠(0 − 3) + 𝐴𝑏𝑠(1 − 0)
= 𝐴𝑏𝑠(3) + 𝐴𝑏𝑠(−3) + 𝐴𝑏𝑠(1) = 3 + 3 + 1 = 7
7. Encontrar 𝜑 𝜖 {1,2,3, … , 𝑝} tal que 𝜃 (�̃�|�̂� , 𝒙𝜑|
�̂�) = ⋀ 𝜃 (�̃�|
�̂� , 𝒙𝜇|
�̂�)𝑝
𝜇=1 .
A 𝜑 se le asignará el valor del índice 𝑖 del vector donde se encuentre la primera aparición
del mínimo.
𝜑 = [0 ⋀ 5 ⋀ 7] = 1
8. Si 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) ≤ 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�), realizar la asignación 𝜔 = 𝜓 ; de otro modo, realizar
la asignación 𝜔 = 𝜑.
165
Para 𝜓 = 1, se tiene 𝜃 (�̃�|𝑺 , 𝒙𝜓|𝑺) = 0 y para 𝜑 = 1, se tiene 𝜃 (�̃�|
�̂� , 𝒙𝜑|
�̂�) = 0; por lo
tanto
𝜔 = 𝜓 = 1
9. Obtener (𝒙𝜔|𝑺)|𝑺, que es precisamente el vector 𝒙𝜔.
La operación 𝒙|𝑺 empleando el código Johnson-Möbius modificado presenta el
comportamiento de una suma, por lo tanto la operación 𝒙|𝑺 se expresa como [𝒙|𝑺]𝑖 =
𝒙𝑖 + 𝑺𝑖.
(𝒙1|𝑺)|𝑺 = (
0 + 13 + 11 + 1
) = (142)
Como 𝒙1 pertenece al conjunto fundamental, se puede decir que el patrón fue
correctamente recuperado.
166
Apéndice 4. Compilación y ejecución de WEKA en
Netbeans
En este apartado se explicará cómo compilar y ejecutar el código fuente de WEKA en
Netbeans 7.3.1.
Paso 1.
Descargar la última versión de la plataforma WEKA desde el sitio oficial:
http://www.cs.waikato.ac.nz/ml/weka/downloading.html
En este caso se utilizará la versión de WEKA para sistemas Windows x64. En la captura
de pantalla 1, se observa remarcada la versión que se utilizará.
Captura de pantalla 1. Versión de WEKA
Paso 2.
Instalar WEKA.
Paso 2.1.
Iniciar el asistente de instalación de WEKA. Presionar el botón Next. Ver captura de pantalla 2.
Captura de pantalla 2. Inicio del asistente de instalación de WEKA
167
Paso 2.2
Aceptar la licencia de acuerdo de WEKA, presionar el botón I agree. Ver captura de pantalla 3.
Captura de pantalla 3. Licencia de acuerdo de WEKA
Paso 2.3
Seleccionar el tipo de instalación Full. Presionar el botón Next. Ver la captura de pantalla 4.
Captura de pantalla 4. Tipo de instalación de WEKA
Paso 2.4
Seleccionar la ruta de instalación, para este caso usaremos directamente una carpeta situada en la
raíz del disco duro C, presionar el botón Next. Ver la captura de pantalla 5.
168
Captura de pantalla 5. Carpeta de instalación de WEKA
Paso 2.5
Iniciar la instalación, presionar el botón Install. Ver la captura de pantalla 6.
Captura de pantalla 6. Instalación de WEKA
Paso 2.6
Esperar a que la instalación termine, presionar el botón Next. Ver captura de pantalla 7.
169
Captura de pantalla 7. Instalación finalizada de WEKA
Paso 2.7
Salir del asistente de instalación, desactivar la casilla Start Weka, presionar el botón Finish. Ver
captura de pantalla 8.
Captura de pantalla 8. Fin del asistente de instalación de WEKA
Paso 3
Obtención del código fuente de WEKA.
Paso 3.1
Tras la instalación podremos observar el contenido de la carpeta donde se instaló WEKA.
Ver captura de pantalla 9.
170
Captura de pantalla 9. WEKA, contenido de la carpeta de instalación
Paso 3.2
Extraer el contenido de weka-src.jar. Ver captura de pantalla 10.
Captura de pantalla 10. Extracción del contenido del archivo weka-src.jar
Paso 3.3
Tras la extracción podremos observar el contenido del archivo weka-src.jar. Dentro de la
carpeta del contenido del archivo weka-src.jar, observaremos las carpetas src y lib; src, contiene
el código fuente de WEKA, lib, contiene el conjunto de librerías necesarias para su correcta
ejecución. Ver captura de pantalla 11.
171
Captura de pantalla 11. Contenido del archivo weka-src.jar
Paso 4
Creación del proyecto en Netbeans.
Paso 4.1
Iniciar el ambiente de desarrollo Netbeans. Ver captura de pantalla 12.
Captura de pantalla 12. Iniciando IDE Netbeans
Paso 4.2
Seleccionar el menú File – New Project. Ver captura de pantalla 13.
172
Captura de pantalla 13. Menú para la creación de un nuevo proyecto en Netbeans
Paso 4.3
Seleccionar la categoría de proyectos Java, seleccionar el tipo de proyecto Java
Application, presionar el botón Next. Ver captura de pantalla 14.
Captura de pantalla 14. Tipo de proyecto para la compilación de WEKA
173
Paso 4.4
Escribir como nombre de proyecto weka. Seleccionar la carpeta del proyecto, para este
caso usaremos directamente una carpeta situada en la raíz del disco duro C, WekaTT. Habilitar la
opción para la creación de una clase Main, weka.gui.Main. Presionar el botón Finish. Ver captura
de pantalla 15.
Captura de pantalla 15. Nombre y localización del proyecto WEKA
Paso 4.5
El proyecto ha sido configurado correctamente. Ver captura de pantalla 16.
174
Captura de pantalla 16. Proyecto correctamente configurado y listo para su uso
Paso 4.6
Copiar el código fuente que se extrajo del archivo weka-src.jar a la carpeta del proyecto
en Netbeans.
Paso 4.6.1
Para iniciar la copia del código fuente, debemos situarnos en “C:\Weka-3-6\weka-
src\src\main\java”, seleccionar la carpeta weka y Copiar. Ver captura de pantalla 17.
175
Captura de pantalla 17. Carpeta con el código fuente de WEKA
Paso 4.6.2
Ahora debemos situarnos en la carpeta del código fuente del proyecto de Netbeans en
“C:\WekaTT\weka\src” y Pegar. Ver captura de pantalla 18.
Captura de pantalla 18. Código fuente del proyecto Netbeans
Seleccionar Reemplazar el archivo en el destino. Ver captura de pantalla 19.
Captura de pantalla 19. Reemplazo del archivo existente Main.java
176
Paso 4.7
Agregar las librerías Java para el correcto funcionamiento.
Paso 4.7.1
Localizar el proyecto weka en Netbeans en la pestaña de proyectos, presionar click
derecho en la carpeta Libraries y dar click en Add JAR/Folder…. Ver captura de pantalla 20.
Captura de pantalla 20. Menú para agregar librerías Java al proyecto WEKA
Paso 4.7.2
Ubicarnos en la carpeta “C:\WekaTT\weka\lib” y seleccionar las librerías java-cup.jar,
JFlex.jar y junit.jar, Seleccionar la opción de References as, Absolute Path. Ver captura de
pantalla 21.
177
Captura de pantalla 21. Agregando las librerías Java al proyecto WEKA
Paso 4.8
Proyecto en Netbeans correctamente configurado. Ver captura de pantalla 22.
Captura de pantalla 22. Proyecto WEKA configurado correctamente
Paso 5
Compilación y ejecución del proyecto weka.
178
Paso 5.1
Expandir el arbol de paquetes, entrar en weka.gui. Ver captura de pantalla 23.
Captura de pantalla 23. Localización de weka.gui en los paquetes del proyecto weka
Paso 5.2
Correr el archivo ejecutable GUIChooser.java, dar click derecho sobre el archivo y
seleccionar Run File. Ver Captura de pantalla 24.
179
Captura de pantalla 24. Menú para la ejecución del archivo GUIChooser.java
Paso 5.3
Podremos visualizar la pantalla inicial de la aplicación WEKA. Ver captura de pantalla
25.
Captura de pantalla 25. Pantalla inicial de la aplicación WEKA
Con esta serie de pasos podremos modificar el proyecto WEKA para poder agregar
algoritmos de clasificación en el paquete weka.classifiers. Ver captura de pantalla 26.
180
Captura de pantalla 26. Localización del paquete para agregar Algoritmos de clasificación
