2. Tecnologías y Herramientas

Tabla de contenidos
1. Introducción ........................................................................................................................... 1
2. Tecnologías y Herramientas .................................................................................................. 4
2.1 Base de datos .................................................................................................................. 4
2.1.1 Datawarehouse .......................................................................................................... 5
2.1.2 Operational datastore ODS ........................................................................................ 5
2.1.3 Datamart .................................................................................................................... 6
2.2 Proceso ETL..................................................................................................................... 7
2.2.1 Extracción de datos.................................................................................................... 7
2.2.2 Transformaciones de información .............................................................................. 7
2.2.3 Carga de repositorios ................................................................................................. 8
2.3 Weka ................................................................................................................................ 9
2.4 Algoritmos de aprendizaje supervisados..........................................................................10
2.4.1 Naive Bayes ..............................................................................................................11
2.4.2 Vecinos más cercanos (k-means) .............................................................................16
2.4.3 Redes neuronales (Perceptrón multicapa) ................................................................24
2.5 Algoritmos de aprendizaje no supervisados.....................................................................30
2.5.1 Teoría de la Resonancia Adaptativa..........................................................................31
2.5.2 Redes Bayesianas ....................................................................................................34
2.5.3 Cadenas de Markov ..................................................................................................38
2.6 Algoritmos de ensamble ..................................................................................................42
2.7 Python .............................................................................................................................51
3. Sistemas dinámicos ..............................................................................................................54
3.1 Teoría del Caos ...........................................................................................................55
3.2 Geometría Fractal ........................................................................................................57
4. Construcción de la Heurística Modelo de flor ........................................................................59
4.1 Proceso ETL Conjunto de Prueba ...................................................................................59
4.1.1 Extracción del conjunto de prueba ............................................................................59
4.1.2 Transformación del conjunto de prueba ....................................................................59
4.1.3 Carga conjunto de prueba .........................................................................................59
4.2 Construcción ...................................................................................................................59
4.2.1 Diseño.......................................................................................................................60
4.2.2 Codificación ..............................................................................................................61
4.2.3 Implementación .........................................................................................................64
4.3 Pruebas ...........................................................................................................................64
4.3.1 Cambio del tamaño fractal ........................................................................................64
4.3.2 Cambio de conjunto de entrenamiento ......................................................................67
4.4 Conclusiones de la heurística ..........................................................................................74
5. Conclusiones ........................................................................................................................75
6. Bibliografía ............................................................................................................................76
1. Introducción
En la vida cotidiana encontramos un sinfín de fenómenos en los cuales nuestra
percepción de orden parece pasar por alto el detalle de lo contemplado, tal
es el caso de la forma de las plantas, esparcimiento un virus, crecimiento de
poblaciones urbanas, el comportamiento del clima, la interferencia en las
señales de telecomunicaciones, trata de personas y fluctuaciones en la bolsa
de valores, etc. En estos casos podemos hacer una analogía con un fractal
(objeto cuya estructura básica, fragmentada o irregular, se repite a
diferentes escalas). Gracias a matemáticos como Mandelbrot podemos crear de
manera artificial recreaciones de la naturaleza con detalles asombrosos. Y
para el caso de los comportamientos aparentemente caóticos hay ya una gama de
artefactos matemáticos que permiten hacer análisis y predicción. Por ejemplo
la ecuación logística para el crecimiento de poblaciones sujeta a diferentes
parámetros y condiciones iníciales.
De manera natural es difícil encontrar líneas rectas o circulares sin embargo
las siluetas complejas, pliegues, espirales y
el aparente desorden parece
más casual. El imaginario de series fractales con cierto grado de
fluctuaciones permite modelar árboles, mapas, texturas, virus, modelos
atómicos. De manera que los caprichos de la naturaleza nos sugieren una pista
dentro de sus elaborados diseños.
Por otra parte nos encontramos en un punto histórico donde tenemos la
capacidad de procesar enormes cantidades de información (procesos ETL y Big
Data) y disponemos de algoritmos que empiezan a servir las veces de expertos
en temas específicos. No sería raro que la siguiente década los expertos en
enfermedades sean sistemas programados para tal función. Lo que nos lleva a
la premisa de este trabajo. ¿Existe una relación fractal dentro de sistemas
caóticos?
Para contestar la pregunta es conveniente analizar los algoritmos de
aprendizaje supervisado en especial Bayes ingenuo que permite hacer un cambio
entre las clasificaciones a post priori y las predicciones a priori. Y en
general los algoritmos supervisados nos permiten dar un vistazo al
comportamiento caótico así como a los sistemas de procesamiento de datos
robustos y procesos ETL.
La
información
recolectada
con
los
algoritmos
de
aprendizaje
supervisado nos socorrerán a contestar la pregunta, los algoritmos de
aprendizaje no supervisado nos pueden ayudar con los múltiples problemas que
se presentan con los datos estáticos. Más tarde haremos uso de los algoritmos
de Inteligencia Artificial para capturar la esencia de la geometría fractal y
con ella hacer que los datos de creen cúmulos de datos de manera que se
comporten como entidades fractales.
La teoría del caos es una denominación popular de la rama de las matemáticas
que trata ciertos tipos de sistemas dinámicos que son muy susceptibles a las
Proyecto de Investigación II Inteligencia Artificial
Pag 1
variaciones en las condiciones iníciales. Pequeñas variaciones en dichas
condiciones pueden implicar grandes diferencias en el comportamiento futuro
imposibilitando la predicción a largo plazo. La mayoría de los movimientos
mencionados en la teoría anterior suceden alrededor de atractores simples,
tales como puntos y curvas circulares llamados ciclos límite. Los atractores
son similares al centro de una circunferencia y sucede que encontrando un
atractor se puede describir al menos parcialmente el comportamiento del
fenómeno. El primero de éstos fue hallado, por casualidad, por el meteorólogo
Edward Lorenz cuando trataba de encontrar un modelo matemático que permitiera
predecir el comportamiento de grandes masas de aire. Consiguió ajustar el
modelo a sólo tres variables que indican cómo cambian la velocidad y la
temperatura del aire a lo largo del tiempo (atractor de Lorenz). Después de
haber estudiado el modelo, volvió a introducir los datos iniciales esta vez
con menos decimales y el resultado que obtuvo fue completamente diferente del
anterior. Cuando reflexionó sobre los resultados se dio cuenta que el sistema
era
extremadamente
sensible
a
las
condiciones
iníciales:
pequeñas
perturbaciones en los datos de partida tienen una gran influencia sobre el
resultado final. Sus ecuaciones captaban la esencia de la verdadera
atmósfera. “Aquel primer día (invierno de 1961) decidió que los pronósticos
amplios estaban condenados a la extinción”. Pero vio más que azar en su
modelo del tiempo: una fina estructura geométrica, orden disfrazado de
casualidad.
Benoit Mandelbrot es el padre de la denominada Geometría Fractal, una nueva
rama de la geometría que podemos decir que estudia los objetos tal como son.
Mandelbrot pensó que las cosas en la realidad no son tan perfectas como las
muestra la geometría euclidiana: las esferas no son realmente esferas, las
líneas no son perfectamente rectas, las superficies no son uniformes… Ello le
llevó a estudiar estas imperfecciones, derivando estos estudios en la
creación de esta nueva rama de la geometría. Las primeras ideas sobre
fractales de Mandelbrot fueron publicadas en la revista Science en 1967 a
través de su artículo ¿Cuánto mide la costa de Gran Bretaña? En él da ciertas
evidencias empíricas de que la longitud de una línea geográfica (como por
ejemplo, la costa de Gran Bretaña) depende de la regla con la que la midamos.
En líneas generales, la costa tendrá mayor longitud cuanto menor sea la
unidad de medida utilizada, esto es, cuanto más cerca estemos mirando a la
costa mayor longitud tendrá.
Ian Hacking y la domesticación del azar. Probabilidad y normalidad son los
temas que trata en su obra, en la cual detalla el desarrollo de la disciplina
de la probabilidad y como la normalidad afecta los fenómenos sociales. La
probabilidad como herramienta de encauzamiento registrando datos históricos
ha creado descripciones matemáticas que bajo condiciones de estabilidad y
acotada en todos los posibles resultados puede ser reproducida. La idea de
saber de antemano un resultado sólo citando los parámetros iniciales parece
ser irresponsable, sin embargo al disminuir el espacio de resultados se
pueden discriminar ciertos resultados lo cual permite avanzar en el proceso
de toma de decisiones. Una ley es una ecuación. Y la ecuación tiene que ver
con las mediciones que claramente difieren según mostró Mandelbrot lo cual
Proyecto de Investigación II Inteligencia Artificial
Pag 2
nos lleva a la normalidad. Esperar lo inesperado sin tratar de controlar
sistemas indeterminables. Usar las herramientas matemáticas convencionales
conlleva el riesgo de caer en vicios del mundo plano del que parece la
naturaleza no se siente atraída. Tratemos entonces de usar sistemas no
convencionales.
Nada más grande que el universo. El teorema del límite central o teorema
central del límite indica que, en condiciones muy generales, si Sn es la suma
de n variables aleatorias independientes y de varianza no nula pero finita,
entonces la función de distribución de Sn «se aproxima bien» a una
distribución normal (también llamada distribución gaussiana). Así pues, el
teorema asegura que esto ocurre cuando la suma de estas variables aleatorias
e independientes es lo suficientemente grande
Modelo Humano. Las herramientas que la raza humana ha desarrollado en el paso
del tiempo siempre son una extensión de su propio cuerpo o una emulación del
mismo, en la actualidad no es raro que se intenten producir herramientas
usando el cerebro como meta. La capacidad de transferir el intelecto y las
capacidades cognitivas es un reto que ahora ya tiene avances favorables.
Hablemos entonces de los expertos. Se cree que un experto puede, gracias a su
entrenamiento, educación, profesión, trabajos realizados o experiencia, tener
un conocimiento sobre un cierto tema que excede el nivel de conocimiento de
una persona común, de manera tal que otros puedan confiar en la opinión del
individuo en forma oficial y legal. Un sistema experto una aplicación
informática capaz de solucionar un conjunto de problemas que exigen un gran
conocimiento sobre un determinado tema. Un sistema experto (SE) es un
conjunto de programas que, sobre una base de conocimientos, posee información
de uno o más expertos en un área específica. Se puede entender como una rama
de la inteligencia artificial, donde el poder de resolución de un problema en
un programa de computadora viene del conocimiento de un dominio específico.
Estos sistemas imitan las actividades de un humano para resolver problemas de
distinta índole (no necesariamente tiene que ser de inteligencia artificial).
También se dice que un Sistema Experto se basa en el conocimiento declarativo
(hechos sobre objetos, situaciones) y el conocimiento de control (información
sobre el seguimiento de una acción).
Para el proceso de adquirir conocimiento nos auxiliamos de el aprendizaje
supervisado es una técnica para deducir una función a partir de datos de
entrenamiento. Los datos de entrenamiento consisten de pares de objetos
(normalmente vectores): una componente del par son los datos de entrada y el
otro, los resultados deseados. La salida de la función puede ser un valor
numérico (como en los problemas de regresión) o una etiqueta de clase (como
en los de clasificación). El objetivo del aprendizaje supervisado es el de
crear una función capaz de predecir el valor correspondiente a cualquier
objeto de entrada válida después de haber visto una serie de ejemplos, los
datos de entrenamiento. Para ello, tiene que generalizar a partir de los
datos presentados a las situaciones no vistas previamente.
Proyecto de Investigación II Inteligencia Artificial
Pag 3
2. Tecnologías y Herramientas
2.1 Base de datos
Las bases de datos son compendios de información en los cuales se almacenan
detalles específicos de alguna abstracción de utilidad para un negocio o
proceso. Existen diferentes modelos de bases de datos.
El modelo relacional en el cual se crean modelos de entidades puntuales
representados por tuplas y agrupados por relaciones, dependiendo de la
cantidad de detalle se crean diferentes niveles a los cuales se accede usando
consultas (lógica de predicados de primer orden). Las relaciones vienen dadas
de las asociaciones entre entidades, PE Una mochila con cuantas libretas está
relacionada, siendo las posibles respuestas: Una, ninguna o muchas. Se debe
de notar que en el caso anterior se debe especificar de qué mochila se está
señalando por tal motivo se debe de agregar un identificador único a cada
mochila con la que contemos. En el caso en que no existe relación directa
entre dos objetos de una misma base de datos puede crearse una clave
subrogada de manera que la relación se vuelve artificial. De esta manera el
modelo es muy sencillo para relaciones directas y se puede volver más
complejo para relaciones indirectas o recursivas.
Es conveniente describir los elementos que contiene una base de datos:
*Datos: Se trata de abstracciones de números, series, palabras, atributos o
cuantificaciones de ellos. Dentro de las diferentes bases de datos se
encuentran los datos de tipo Entero Números sin punto decimal, Flotante
Números con punto decimal, Char Series de letras, pueden formar palabras,
Date Para mostrar fechas, varían según la implementación, Time Para mostrar
el tiempo, varía según la implementación, Enumeraciones Son colecciones de
datos que por su naturaleza no son candidatos a volverse catálogos PE
{„Norte‟, ‟Sur‟, ‟Este‟, ‟Oeste‟}
*Atributos: Se trata de los posibles estados posibles para un dato, como su
longitud, si se permite que esté vacío o se trata de una llave.
*Tabla: Es el agrupamiento ordenado para un conjunto de datos, sujeta a
campos que definen las columnas
*Campo: Se trata de una columna la cual indica el tipo de datos y sus
atributos PE si se permite que el contenido del campo esté vacío o el tipo de
dato que contendrá
*Registro: Es un renglón de la tabla se identifica por la llave que puede
estar compuesta por uno o más campos
*Llave: Se trata del identificador único de cada renglón, no se permite que
este vacío se recomienda que sea numérico o secuencial.
Proyecto de Investigación II Inteligencia Artificial
Pag 4
*Manejador de Base de datos. El manejador de bases de datos es un programa
que realiza diferentes funciones como cuidar que se respeten las relaciones
de la información, acceder a la información de la base, gestionar las
modificaciones de la base, además de otorgar y revocar permisos para los
usuarios existen diferentes marcas entre las cuales destacan MySQL, Oracle
Sql, DB2, Informix, Progress, etc.
Existe además el modelo de Big data en el cual los datos no se almacenan en
estructuras fijas como tablas y por consiguiente no se requiere usar
consultas de cruce lo cual le resta atomicidad a la información pero agrega
valor al escalar y optimizar el rendimiento de los modelos de datos.
Las características de los datos nos permiten elegir el tipo de modelo que
utilizaremos, para este ejercicio vamos a ocupar dos bases de datos del
repositorio de aprendizaje maquinal
de la universidad de California,
primeramente usaré la base IRIS como ejemplo típico para algoritmos
supervisados. Posteriormente usaré una base con problemas de datos faltantes.
2.1.1 Datawarehouse
Según la teoría de la información propuesta por el matemático Shannon la
información contenida en un mensaje es proporcional a la cantidad de bits que
se requieren como mínimo para representar al mensaje. El concepto de
información puede entenderse más fácilmente si consideramos un ejemplo.
Supongamos que estamos leyendo un mensaje y hemos leído "cadena de c"; la
probabilidad de que el mensaje continúe con "aracteres" es muy alta. Así,
cuando efectivamente recibimos a continuación "aracteres" la cantidad de
información que nos llega es muy baja pues estábamos en condiciones de
predecir qué era lo que iba a ocurrir. La ocurrencia de mensajes de alta
probabilidad de aparición aporta menos información que la ocurrencia de
mensajes menos probables. Si luego de "cadena de c" leemos "himichurri" la
cantidad de información que estamos recibiendo es mucho mayor.
Bajo este postulado los almacenes de datos buscan poner al alcance del
usuario información de diversas fuentes para el fácil acceso y análisis de la
información sin permitir el acceso a las bases locales lo que permite un
vistazo general de la información agrupada convenientemente para fines de
explotación.
2.1.2 Operational datastore ODS
En el ODS, los datos pueden ser lavados, resueltos por la redundancia y
verificados para el cumplimiento de las reglas de negocio correspondientes.
Un ODS se puede utilizar para integrar datos dispares de múltiples fuentes
para que las operaciones de negocio, análisis y presentación de informes se
puedan llevar a cabo mientras que las operaciones comerciales se están
produciendo. Este es el lugar donde la mayoría de los datos utilizados en la
Proyecto de Investigación II Inteligencia Artificial
Pag 5
operación actual se aloja antes de que sea transferido al datawarehouse para
el almacenamiento o el archivado a largo plazo.
Un ODS está diseñado para consultas relativamente simples en pequeñas
cantidades de datos (tales como encontrar el estado de un pedido del
cliente), en lugar de las complejas consultas en grandes cantidades de datos
típicos del almacén de datos. Un ODS es similar a su memoria a corto plazo en
el que almacena información sólo muy reciente; en comparación, el almacén de
datos se parece más a la memoria a largo plazo en la que almacena información
relativamente permanente.
2.1.3 Datamart
La diferencia entre un datawarehouse y un datamart puede ser confusa porque
los dos términos se utilizan a veces incorrectamente como sinónimos. Un
almacén de datos es un repositorio central para todos los datos de una
organización. El objetivo de un mercado de datos, sin embargo, es para
satisfacer las demandas particulares de un grupo específico de usuarios
dentro de la organización, como la gestión de recursos humanos (HRM). En
general, los mercados de datos de una organización son subconjuntos de
almacén de datos de la organización.
Debido a que los mercados de datos están optimizados para ver los datos de
una manera única, el proceso de diseño tiende a comenzar con un análisis de
las necesidades del usuario. En contraste, el proceso de diseño de un almacén
de datos tiende a comenzar con un análisis de lo que ya existen datos y cómo
puede ser recogida y gestionados de una manera tal que puede ser utilizado
más adelante. Un datawarehouse tiende a ser un concepto estratégico pero algo
sin terminar; un datamart tiende a ser táctico y orientado a satisfacer una
necesidad inmediata.
Hoy en día, el software de vitalización de datos puede utilizarse para crear
datamarts virtuales, la extracción de datos de fuentes dispares y combinarla
con otros datos que sean necesarios para satisfacer las necesidades
específicas de los usuarios.
Proyecto de Investigación II Inteligencia Artificial
Pag 6
2.2 Proceso ETL
ETL por sus siglas en inglés (Extract, Transform, Load) es un proceso
mediante el cual se realiza la integración de datos de un esquema (Estructura
que describe una base de datos) a otro esquema usando una misma herramienta
con el fin de crear datamart y datawarehouses.
Se conforma de tres pasos obligatorios:
1.- Extracción (Extract). Es el proceso de adquisición de los datos de la
base o bases.
2.- Transformación (Transform) Es el proceso donde se convierten los datos
extraídos del esquema anterior al nuevo esquema. Las transformaciones que se
realizan están regidas por reglas, indexaciones, combinaciones de datos con
otros datos.
3.- Carga (Load). Es el proceso de escribir la información en un repositorio
bajo el nuevo esquema.
2.2.1 Extracción de datos
La extracción de datos es el proceso de conectar los modelos de datos con la
herramienta ETL, facilita la combinación de fuentes heterogéneas en un
repositorio central. Las fuentes de datos pueden ser archivos planos,
documentos bases de datos de diferentes formatos. Habitualmente la meta es
extraer el sistema sin modificaciones sin pasar por alto las restricciones
para asegurar que se mantiene la naturaleza de los datos en el caso de
información sensible.
2.2.2 Transformaciones de información
En este paso se identifican los datos incompletos, incorrectos, inexactos
para sustituir, modificar o eliminar, es diferente de una validación ya que
además de rechazar los datos erróneos, corrige las incidencias de acuerdo a
un criterio. La meta es crear consistencia entre los diferentes sistemas y
entre las operaciones más comunes se incluye:
La estandarización. Los datos son sustituidos de acuerdo a un vector
asociativo por ejemplo: (México, Mex, MX, Mexico) todos mapeados de acuerdo
al estándar de nombrado de país
Limpieza. Se realizan diferentes validaciones para remover o modificar datos
conflictivos
Llaves subrogadas. Se crea una nueva llave para diferentes conjuntos de datos
previniendo inconsistencias entre las llaves existentes además de agregar el
soporte para referencias cruzadas.
Proyecto de Investigación II Inteligencia Artificial
Pag 7
Transposición. Se organizan los datos de manera que se optimiza el proceso de
reportería lo cual conlleva un proceso de desnormalización y reorganización
en un modelo dimensional por ejemplo:
clave
x
x
x
x
y
y
y
y
z
z
z
z
idcta
1
2
3
4
1
2
3
4
1
2
3
4
valor
23
45
2
-54
68
84
98
-97
92
44
91
-37
En este ejemplo se tienen 3 grupos lo cual se puede representar como una
matriz:
idcta
1
2
3
4
x
23
45
2
-54
y
68
84
98
-97
z
92
44
91
-37
2.2.3 Carga de repositorios
Los datos transformados son escritos a un Datamart o a un datawarehouse. La
herramienta escogida para el desarrollo ETL, realiza las cargas a las bases
de datos generalmente sin la necesidad de crear los scripts propios del
manejador de bases de datos
Proyecto de Investigación II Inteligencia Artificial
Pag 8
2.3 Weka
Se trata de una extensa colección de algoritmos de Máquinas de conocimiento
desarrollados por la universidad de Waikato (Nueva Zelanda) implementados en
Java; útiles para ser aplicados sobre datos mediante los interfaces que
ofrece o para embeberlos dentro de cualquier aplicación. Además Weka contiene
las herramientas necesarias para realizar transformaciones sobre los datos,
tareas de clasificación, regresión, clustering, asociación y visualización.
Weka está diseñado como una herramienta orientada a la extensibilidad por lo
que añadir nuevas funcionalidades es una tarea sencilla.
Sin embargo, y pese a todas las cualidades que Weka posee, tiene un gran
defecto y éste es la escasa documentación orientada al usuario que tiene
junto a una usabilidad bastante pobre, lo que la hace una herramienta difícil
de comprender y manejar sin información adicional.
Aquí haremos pruebas del algoritmo de Bayes ingenuo, Redes bayesianas y el
algoritmo de ensamble usando la base datos Iris
Proyecto de Investigación II Inteligencia Artificial
Pag 9
2.4 Algoritmos de aprendizaje supervisados
El aprendizaje supervisado es una técnica para deducir una función a partir
de datos de entrenamiento. Los datos de entrenamiento consisten de pares de
objetos (normalmente vectores): un componente del par son los datos de
entrada y el otro, los resultados deseados. La salida de la función puede ser
un valor numérico (como en los problemas de regresión) o una etiqueta de
clase (como en los de clasificación). El objetivo del aprendizaje supervisado
es el de crear una función capaz de predecir el valor correspondiente a
cualquier objeto de entrada válida después de haber visto una serie de
ejemplos, los datos de entrenamiento. Para ello, tiene que generalizar a
partir de los datos presentados a las situaciones no vistas previamente.
Proyecto de Investigación II Inteligencia Artificial
Pag 10
2.4.1 Naive Bayes
El teorema de Bayes nos permite unir dos eventos disjuntos en los
cuales sabiendo que pasa el evento A dado B podemos saber si pasa B
dado A. se expresa a través de la formula:
Donde
son una serie de eventos mutuamente excluyentes y donde
la ocurrencia de otro evento.
es
Un clasificador bayesiano ingenuo (Naive Bayes classifier) es un
clasificador probabilístico que se fundamenta en el teorema de Bayes y
algunas hipótesis simplificadas adicionales. Es decir que realiza la
clasificación ignorando la relación que puedan guardar los atributos
entre ellos. Por ejemplo una fruta, si sabemos que es roja podríamos
asumir que es una manzana, por otra parte si sabemos que su diámetro
es de 1 cm entonces podemos suponer que se trata de una fresa, de esta
manera cada atributo individual contribuye a la adquisición del
conocimiento de clasificación. Del ejemplo anterior nos dirigimos de
inmediato a la siguiente observación, no tenemos una regla con la cual
decidir la clase a la que pertenece el ejemplo anteriormente
enumerado. La siguiente parte del clasificador
se puede dividir en
dos partes, por una parte tenemos el conjunto de entrenamiento y por
otra parte tenemos las reglas de decisión que se deben de aplicar a
cada entidad dispuesta a clasificar. La regla de decisión se tomara
del modelo generado de la información extraída del conjunto de
entrenamiento, dado el proceso por el cual tomaremos como la
información del conjunto de entrenamiento como modelo a seguir por
parte del clasificador y la regla se define como:
Donde F es la clasificación que dio el algoritmo comparada con la
clase del entrenamiento para cada terna y se toma la mayor de las
selecciones.
Observaciones.
-Se deben de conocer el número de clases con antelación.
-El conjunto de entrenamiento depende de la cantidad de información
relevante que pueda aportar cada terna.
Proyecto de Investigación II Inteligencia Artificial
Pag 11
Proyecto de Investigación II Inteligencia Artificial
Pag 12
Proyecto de Investigación II Inteligencia Artificial
Pag 13
=== Run information ===
Scheme:weka.classifiers.bayes.NaiveBayes
Relation:
iris
Instances:
150
Attributes:
5
sepallength
sepalwidth
petallength
petalwidth
class
Test mode:split 75.0% train, remainder test
=== Classifier model (full training set) ===
Naive Bayes Classifier
Class
Attribute
Iris-setosa Iris-versicolor Iris-virginica
(0.33)
(0.33)
(0.33)
===============================================================
sepallength
mean
4.9913
5.9379
6.5795
std. dev.
0.355
0.5042
0.6353
weight sum
50
50
50
precision
0.1059
0.1059
0.1059
sepalwidth
mean
std. dev.
weight sum
precision
3.4015
0.3925
50
0.1091
2.7687
0.3038
50
0.1091
2.9629
0.3088
50
0.1091
petallength
mean
std. dev.
weight sum
precision
1.4694
0.1782
50
0.1405
4.2452
0.4712
50
0.1405
5.5516
0.5529
50
0.1405
petalwidth
mean
std. dev.
weight sum
precision
0.2743
0.1096
50
0.1143
1.3097
0.1915
50
0.1143
2.0343
0.2646
50
0.1143
Time taken to build model: 0.01 seconds
Proyecto de Investigación II Inteligencia Artificial
Pag 14
=== Evaluation on test split ===
=== Summary ===
Correctly Classified Instances
Incorrectly Classified Instances
Kappa statistic
Mean absolute error
Root mean squared error
Relative absolute error
Root relative squared error
Total Number of Instances
35
2
0.9187
0.0462
0.1763
10.3886 %
37.3672 %
37
94.5946 %
5.4054 %
=== Detailed Accuracy By Class ===
TP Rate
FP Rate
Precision
Recall
F-Measure
ROC Area
Class
1
0
1
1
1
1
1
0.083
0.867
1
0.929
0.981
0.846
0
1
0.846
0.917
0.981
Iris-setosa
Iris-versicolor
Iris-virginica
Weighted Avg.
0.946
0.029
0.953
0.946
0.946
0.986
=== Confusion Matrix ===
a b c
<-- classified as
11 0 0 | a = Iris-setosa
0 13 0 | b = Iris-versicolor
0 2 11 | c = Iris-virginica
Proyecto de Investigación II Inteligencia Artificial
Pag 15
2.4.2 Vecinos más cercanos (k-means)
El algoritmo de k-means hace una separación de n elementos en k
particiones (Clases) usando la lógica del más cercano, es decir si un
punto es el más cercano a otro. Primeramente se escogen k elementos
que servirán como pivote y después se entrara en un ciclo en el cual
se calcula la distancia entre cada uno los puntos con los pivotes y
cada conjunto se formara de los elementos más cercanos al pivote. Se
escoge un nuevo pivote que minimice la distancia entre todos los
elementos del conjunto hasta que no se pueda escoger otro pivote.
Puede estar incluso en el conjunto
Es conveniente recordar que la norma euclidiana se calcula usando la
siguiente formula
Que se generaliza para n dimensiones.
El paso de actualización se da con
Cuando ya no cambian las asignaciones el algoritmo termina.
Observaciones.
-La
-El
dos
-El
elección de pivotes no asegura una distribución adecuada.
algoritmo puede presentar problemas con los puntos equidistantes a
centros.
algoritmo no funciona con clases ensimismadas.
Proyecto de Investigación II Inteligencia Artificial
Pag 16
Proyecto de Investigación II Inteligencia Artificial
Pag 17
#!/usr/bin/python
import
import
import
import
import
import
os
cx_Oracle
csv
random
math
time
SQL="SELECT * FROM iris"
con = cx_Oracle.connect('root/root@localhost:1521/xe')
cursor = con.cursor()
cursor.execute(SQL)
#Crear lista
iris = []
for renglon in cursor:
terna = []
for i in range(0,5):
terna.append(renglon[i])
iris.append(terna)
#Escoger k elementos aleatorios
entrenamiento = []
por = int(math.ceil((150 *60)/100)) #60%
print 'el cojunto de entrenaminento tiene ',por, ' elementos'
for a in range(por):
temp = random.randint(0,150) % len(iris)
entrenamiento.append(iris[temp])
iris.remove(entrenamiento[a])
#Escoger k elementos aleatorios del conjunto de entrenamiento
kmeans = []
for a in range(4):
temp = (random.randint(0,por)) % len(entrenamiento)
kmeans.append(entrenamiento[temp])
entrenamiento.remove(kmeans[a])
#Separacion
con1 = []
Proyecto de Investigación II Inteligencia Artificial
Pag 18
con2 = []
con3 = []
con4 = []
#Distancias
distancia1 =
distancia2 =
distancia3 =
distancia4 =
[]
[]
[]
[]
for a in entrenamiento:#x in range(0,4):
dis1 = 0
dis2 = 0
dis3 = 0
dis4 = 0
dim1 =[]
dim1.append(a[0])
for x in range(0,4):#for a in iris:
res = ((a[1] - kmeans[x][1])**2)
res += ((a[2] - kmeans[x][2])**2)
res += ((a[3] - kmeans[x][3])**2)
res += ((a[4] - kmeans[x][4])**2)
res = math.sqrt(res)
if x == 0:
dis1=res
if x == 1:
dis2=res
if x == 2:
dis3=res
if x == 3:
dis4=res
if dis1 < dis2 and dis1 < dis3 and dis1 <
con1.append(a)
dim1.append(dis1)
distancia1.append(dim1)
elif dis2 < dis1 and dis2 < dis3 and dis2
con2.append(a)
dim1.append(dis1)
distancia2.append(dim1)
elif dis3 < dis1 and dis3 < dis2 and dis3
con3.append(a)
dim1.append(dis1)
distancia3.append(dim1)
elif dis4 < dis1 and dis4 < dis2 and dis4
con4.append(a)
dis4:
< dis4:
< dis4:
< dis3:
Proyecto de Investigación II Inteligencia Artificial
Pag 19
dim1.append(dis1)
distancia4.append(dim1)
else:
print 'distancia igual'
distancia1.append(kmeans[0])
distancia2.append(kmeans[1])
distancia3.append(kmeans[2])
distancia4.append(kmeans[3])
#ordenando
distancia1
distancia2
distancia3
distancia4
las listas
= sorted(distancia1,
= sorted(distancia2,
= sorted(distancia3,
= sorted(distancia4,
key=lambda
key=lambda
key=lambda
key=lambda
tup:
tup:
tup:
tup:
tup[1])
tup[1])
tup[1])
tup[1])
#Buscando la el centroide para cada conjunto
c12 = kmeans[0]
c11 = con1[0]
ite =0
while (c11[0] != c12[0] and ite < 100):
temp = random.randint(0,len(con1)) % len(con1)
c11 = con1[temp]
for i in range(0,(len(con1) -1 )):
res = ((c11[1] - con1[i][1])**2)
res += ((c11[2] - con1[i][2])**2)
res += ((c11[3] - con1[i][3])**2)
res += ((c11[4] - con1[i][4])**2)
res = math.sqrt(res)
if i ==0:
acu = res
if res < acu:
c12 = con1[i]
if c11[0] != c12[0]:
ite = 100;
c22 = kmeans[1]
c21 = con2[0]
ite=0
while (c21[0] != c22[0] and ite < 100):
ite+=1
temp = random.randint(0,len(con2)) % len(con2)
Proyecto de Investigación II Inteligencia Artificial
Pag 20
c21 = con2[temp]
for i in range(0,(len(con2) -1 )):
res = ((c21[1] - con2[i][1])**2)
res += ((c21[2] - con2[i][2])**2)
res += ((c21[3] - con2[i][3])**2)
res += ((c21[4] - con2[i][4])**2)
res = math.sqrt(res)
if i ==0:
acu = res
if res < acu:
c12 = con2[i]
if c11[0] != c12[0]:
ite = 100;
c32 = kmeans[2]
c31 = con2[0]
ite=0
while (c31[0] != c32[0] and ite < 100):
ite+=1
temp = random.randint(0,len(con2)) % len(con2)
c31 = con2[temp]
for i in range(0,(len(con2) -1 )):
res = ((c31[1] - con2[i][1])**2)
res += ((c31[2] - con2[i][2])**2)
res += ((c31[3] - con2[i][3])**2)
res += ((c31[4] - con2[i][4])**2)
res = math.sqrt(res)
if i ==0:
acu = res
if res < acu:
c12 = con2[i]
if c11[0] != c12[0]:
ite = 100;
c42 = kmeans[3]
c41 = con2[0]
ite=0
while (c41[0] != c42[0] and ite < 100):
ite+=1
temp = random.randint(0,len(con2)) % len(con2)
c41 = con2[temp]
for i in range(0,(len(con2) -1 )):
res = ((c41[1] - con2[i][1])**2)
Proyecto de Investigación II Inteligencia Artificial
Pag 21
res += ((c41[2] - con2[i][2])**2)
res += ((c41[3] - con2[i][3])**2)
res += ((c41[4] - con2[i][4])**2)
res = math.sqrt(res)
if i ==0:
acu = res
if res < acu:
c12 = con2[i]
if c11[0] != c12[0]:
ite = 100;
kmeans = []
kmeans.append(c11)
kmeans.append(c21)
kmeans.append(c31)
kmeans.append(c41)
##Clasificacion de elementos restantes
print 'elementos a clasificar ', len(iris)
for a in iris:
print 'elemento a clasificar',a
acu1 = 0
acu2 = 0
acu3 = 0
acu4 = 0
for i in range(0,4):
res = ((a[1] - kmeans[i][1])**2)
res += ((a[2] - kmeans[i][2])**2)
res += ((a[3] - kmeans[i][3])**2)
res += ((a[4] - kmeans[i][4])**2)
res = math.sqrt(res)
if i==0:
acu1 = res
elif i==1:
acu2 = res
elif i==2:
acu3 = res
else:
acu4 = res
if acu1 < acu2 and acu1 < acu3 and acu1 < acu4:
print 'El centroide es: ',
print kmeans[0]
elif acu2 < acu1 and acu2 < acu3 and acu2 < acu4:
Proyecto de Investigación II Inteligencia Artificial
Pag 22
print 'El centroide es: ',
print kmeans[1]
elif acu3 < acu1 and acu3 < acu2 and acu3 < acu4:
print 'El centroide es: ',
print kmeans[2]
elif acu4 < acu1 and acu4 < acu2 and acu4 < acu3:
print 'El centroide es: ',
print kmeans[3]
else:
print 'acutancia igual'
cursor.close()
con.close()
Proyecto de Investigación II Inteligencia Artificial
Pag 23
2.4.3 Redes neuronales (Perceptrón multicapa)
La estructura
Donde
del perceptrón está representada por:
son las entradas (por las dendritas) a la neurona, estas sufren un
efecto multiplicador
por la comunicación de las mismas al núcleo de la
neurona, donde se suma. Aquí se transforma y se modifica la salida de la
neurona mediante la función de transferencia f:
Se trata de un conjunto de elementos que colaboran para generar un valor de
salida, es este caso estudiaremos el comportamiento del modelo matemático
conocido como la generalización delta para la reducción del error cuadrático
de la red por medio de un gradiente.
La regla delta generalizada fue creada generalizar la regla delta sobre redes
neuronales de múltiples capas y funciones de transferencia no lineales y
diferenciables. Su utilización consiste en ajustar pesos y bias tratando de
minimizar el error cuadrático. Esto se realiza de forma continua, cambiando
dichas variables en la dirección contraria a la pendiente del error.
El
Se
Se
Se
Se
Se
Se
algoritmo es el siguiente:
introduce un vector de
entrada y se calcula su salida
determina el error asociado
determian las direcciones que se deben de cambiar para minimizar el error
determinan las cantidades en que es preciso cambiar cada peso
modifican los pesos
repiten los pasos 1 a 5 hasta reducir el error a un valor aceptable
La salida se compara con la salida deseada
Observaciones
-El algoritmo es más lento en comparación con los otros algoritmos en la fase
de entrenamiento.
-Puede perder el conocimiento adquirido si los datos tienen dispersión.
Proyecto de Investigación II Inteligencia Artificial
Pag 24
Proyecto de Investigación II Inteligencia Artificial
Pag 25
Proyecto de Investigación II Inteligencia Artificial
Pag 26
import cPickle #Permite guardar y abrir archivos
rapidamente
from numpy import *
class nn:
def sigmoid(self,x):
return tanh(x)
# derivada de la funcion sigmoid
def dsigmoid(self,y):
#d/dx(tanh(x))=1 - (tanh(x))^2
return 1.0-y*y
def __init__(self, ni, nh, no):
# numero de nodos entrada, oculta y salidas
self.ni = ni +1 # +1 para los bias
self.nh = nh
self.no = no
# activacion de los nodos
self.ai = ones((self.ni))
self.a1 = ones((self.nh))
self.ao = ones((self.no))
# crear pesos
self.w1 = random.uniform(-2.0,2.0,(self.ni,
self.nh))
self.w2 = random.uniform(-2.0,2.0,(self.nh,
self.no))
def guardar(self,filename):
W = [self.w1,self.w2]
cPickle.dump(W,open(filename,'w'))
def cargar(self,filename):
W = cPickle.load(open(filename,'r'))
self.w1=W[0]
self.w2=W[1]
Proyecto de Investigación II Inteligencia Artificial
Pag 27
def evaluar(self, inputs):
if len(inputs) != self.ni-1:
raise ValueError, 'numero erroneo de entradas'
# activaciones entradas
self.ai[0:self.ni-1]=inputs
# acticaciones capa oculta
# a1=f1(W1*p)
self.n1 = dot(transpose(self.w1),self.ai)
self.a1= self.sigmoid(self.n1)
# activaciones salidas
# a2=f2(W2* a1)
self.n2 = dot(transpose(self.w2),self.a1)
self.ao = self.sigmoid(self.n2)
return self.ao
def backPropagate(self, targets, N):
if len(targets) != self.no:
raise ValueError, 'numero de objetivos
incorrectos'
#Propagar errores hacia atras
# Calcular errores a la salida
d2=targets-self.ao
# Calcular errores en la capa oculta
d1 = dot(self.w2,d2)
# Acutalizar pesos de la salida
#Wnuevo += Wviejo+n*(delta2*f2')*a1
d2fp= self.dsigmoid(self.ao) * d2
change = d2fp *
reshape(self.a1,(self.a1.shape[0],1))
self.w2 = self.w2 + N * change
Proyecto de Investigación II Inteligencia Artificial
Pag 28
#Actualizar pesos de las entradas
#Wnuevo += Wviejo+n*(delta1*f1')*a0
d1fp =self.dsigmoid(self.a1) * d1
change = d1fp *
reshape(self.ai,(self.ai.shape[0],1))
self.w1 = self.w1 + N * change
# calcular error
error = sum(0.5* (targets-self.ao)**2)
return error
def test(self, entrada):
#Imprime la entrada y su salida de la red neuronal
for p in range(size(entrada,axis=0)):
print entrada[p,:], '->',
self.evaluar(entrada[p,:])
def singletrain(self,inputs,targets):
#Realiza una iteracion del entrenamiento
backpropagation
self.evaluar(inputs)
return self.backPropagate(targets,0.5)
def train(self, entrada, salida, iterations=1000,
N=0.5):
#Realiza entrenamiento backpropagation
# N: factor de aprendizaje
for i in xrange(iterations):
error = 0.0
for p in range(size(entrada,axis=0)):
inputs = entrada[p,:]
targets = salida[p,:]
self.evaluar(inputs)
error = error + self.backPropagate(targets,
N)
if i % 100 == 0 and i!=0:
Proyecto de Investigación II Inteligencia Artificial
Pag 29
print 'error ' + str(error)
2.5 Algoritmos de aprendizaje no supervisados
Es el proceso mediante el cual se genera conocimiento sin tener un marco
referencial (conjunto de entrenamiento) consiste en descubrir las semejanzas
en los datos de entrada y se generen reglas de corte como resultado del
proceso. Estas reglas deben de ser aplicables a nuevos datos. Se debe
procurar que el algoritmo cuente con un modelo que asegure su correctitud ya
que el material con el que cuenta es el de las entradas y ningún conjunto de
entrada que asegure tendencias.
Proyecto de Investigación II Inteligencia Artificial
Pag 30
2.5.1 Teoría de la Resonancia Adaptativa
Uno de los comportamientos extremos que tienen los algoritmos supervisados es
que los datos nuevos pueden hacer que el conocimiento adquirido se vea
desechado un caso claro es el del perceptrón multicapa que utiliza la función
de minimización, esta puede eliminar el conocimiento adquirido. Son dos
problemas de este tipo que requieren atención:
Plasticidad: Por una parte se debe permitir aprender nuevos patrones.
Estabilidad: Se debe de permitir retener los patrones aprendidos.
En las redes ART existen dos tipos de pesos, los llamados W, que son pesos
feedforward (alimentación hacia adelante) entre la capa de entrada y la capa
de salida, y los llamados T, que son pesos feedback (alimentación hacia atrás
) entre la capa de salida y la capa de entrada.
Los pesos feedforward (W) son iguales que los pesos feedback (T), solo que
estos están normalizados:
Donde es un parámetro que toma generalmente el valor 0,5.
El funcionamiento de un modelo ART se divide en cuatro fases:
Fase de Inicialización
Se inicializan los parámetros de la RNA y se
control.
Se inicializan los pesos de la siguiente manera:
establecen
las
señales
de
para conexiones hacia adelante, siendo
el número de entradas a la RNA.
para conexiones hacia atrás
Mediante las señales de control (ganancia y reinicio) se controla el flujo de
datos a través de la RNA y se pasa a las distintas fases.
Fase de Reconocimiento
En la fase de reconocimiento se efectúa una operación con los datos de
entrada y los pesos W asociados a cada neurona de la capa de salida, el
resultado de esta operación debe indicar qué clase tiene mayor prioridad para
ver si los datos de entrada entran en resonancia con ella. Por ejemplo, se
podría calcular la distancia euclídea entre los datos de entrada y los pesos
Proyecto de Investigación II Inteligencia Artificial
Pag 31
W, la clase ganadora sería aquella cuyo W estuviese más cerca de los datos de
entrada y por lo tanto sería la primera a la que se le intentaría asociar
dicho patrón.
La fórmula propuesta por sus creadores es:
para cada neurona de la capa de salida
donde
corresponde a cada una de las neuronas de la capa de entrada. Los
índices i serán para las neuronas de la capa de entrada y los subíndices j
para las neuronas de la capa de salida.
La selección de la neurona ganadora será como la neurona que obtenga el mayor
valor, esto expresado en fómula es:
Donde J corresponde al índice de la neurona ganadora en F2
el vector generado en dicha capa serán entonces un vector binario con un
único valor en 1 el cual indica la neurona ganadora y dada por :
Fase de Comparación
El objetivo es obtener una medida de similitud entre el vector de entrada y
el vector prototipo que surge de la capa de salida.
El vector de entrada y el vector producido por los feedback (T) de la neurona
ganadora en la capa de salida son comparados en la capa de entrada generando
el vector X.
El cálculo del vector X, se realiza mediante:
Sea I el vector de entrada.
O sea, se aplica un AND entre la entrada y el vector de pesos hacia atrás
correspondientes a la neurona ganadora de la capa F2
Si se cumple que la norma de "X" dividida entre la norma de la entrada es
mayor o igual que p, entonces se puede concluir que dicha entrada forma parte
de la categoría seleccionada y se debe proceder a ajustar los pesos tanto
hacia adelante como hacia atrás:
Proyecto de Investigación II Inteligencia Artificial
Pag 32
De lo contrario se envía una señal reinicio, para que inhiba la neurona
ganadora y proceda de nuevo la selección de una ganadora, excluyendo la
neurona inhibida.
Fase de Búsqueda
De no representar la neurona ganadora la categoría del vector de entrada,
esta neurona se desactiva y se empieza la búsqueda por otras categorías que
ya posea la red. Se repiten entonces los pasos anteriores hasta que se
encuentre una neurona ganadora que represente la categoría del vector de
entrada.
Si se repitiera el proceso hasta que no quedara ninguna neurona se llegaría a
una situación de saturación de la red que podría solucionarse ampliando el
número de neuronas de la RNA de forma dinámica.
Proyecto de Investigación II Inteligencia Artificial
Pag 33
2.5.2 Redes Bayesianas
Una red bayesiana, red de Bayes, red de creencia, modelo bayesiano (de Bayes)
o modelo probabilístico en un grafo acíclico dirigido es un modelo grafo
probabilístico (un tipo de modelo estático) que representa un conjunto de
variables aleatorias y sus dependencias condicionales a través de un grafo
acíclico dirigido (DAG por sus siglas en inglés). Por ejemplo, una red
bayesiana puede representar las relaciones probabilísticas entre enfermedades
y síntomas. Dados los síntomas, la red puede ser usada para computar las
probabilidad de la presencia de varias enfermedades.
Formalmente, las redes bayesianas son grafos dirigidos acíclicos cuyos nodos
representan variables aleatorias en el sentido de Bayes: las mismas pueden
ser cantidades observables, variables latentes, parámetros desconocidos o
hipótesis. Las aristas representan dependencias condicionales; los nodos que
no
se
encuentran
conectados
representan
variables
las
cuales
son
condicionalmente independientes de las otras. Cada nodo tiene asociado una
función de probabilidad que toma como entrada un conjunto particular de
valores de las variables padres del nodo y devuelve la probabilidad de la
variable representada por el nodo. Por ejemplo, si por padres son
variables
booleanas entonces la función de probabilidad puede ser representada por una
tabla de
entradas, una entrada para cada una de las
posibles
combinaciones de los padres siendo verdadero o falso. Ideas similares pueden
ser aplicadas a grafos no dirigidos, y posiblemente cíclicos; como son las
llamadas redes de Markov.
Existen algoritmos eficientes que llevan a cabo la inferencia y el
aprendizaje en redes bayesianas. Las redes bayesianas que modelan secuencias
de variables (ej señales del habla o secuencias de proteínas) son llamadas
redes bayesianas dinámicas. Las generalizaciones de las redes bayesianas que
pueden representar y resolver problemas de decisión bajo incertidumbre son
llamados diagramas de influencia.
Proyecto de Investigación II Inteligencia Artificial
Pag 34
Proyecto de Investigación II Inteligencia Artificial
Pag 35
=== Run information ===
Scheme:weka.classifiers.bayes.BayesNet -D -Q weka.classifiers.bayes.net.search.local.K2 -- -P
1 -S BAYES -E weka.classifiers.bayes.net.estimate.SimpleEstimator -- -A 0.5
Relation: iris
Instances: 150
Attributes: 5
sepallength
sepalwidth
petallength
petalwidth
class
Test mode:split 75.0% train, remainder test
=== Classifier model (full training set) ===
Bayes Network Classifier
not using ADTree
#attributes=5 #classindex=4
Network structure (nodes followed by parents)
sepallength(3): class
sepalwidth(3): class
petallength(3): class
petalwidth(3): class
class(3):
LogScore Bayes: -481.00632967833803
LogScore BDeu: -525.3834868062277
LogScore MDL: -536.5317339418378
LogScore ENTROPY: -471.39347511858665
LogScore AIC: -497.39347511858665
Time taken to build model: 0.02 seconds
=== Evaluation on test split ===
=== Summary ===
Correctly Classified Instances
33
Incorrectly Classified Instances
4
Kappa statistic
0.8374
Mean absolute error
0.0654
Root mean squared error
0.2173
Relative absolute error
14.7117 %
89.1892 %
10.8108 %
Proyecto de Investigación II Inteligencia Artificial
Pag 36
Root relative squared error
Total Number of Instances
46.0542 %
37
=== Detailed Accuracy By Class ===
TP Rate FP Rate Precision Recall F-Measure ROC Area Class
1
0
1
1
1
1
Iris-setosa
0.846 0.083
0.846 0.846 0.846
0.984 Iris-versicolor
0.846 0.083
0.846 0.846 0.846
0.984 Iris-virginica
Weighted Avg. 0.892 0.059
0.892 0.892 0.892
0.989
=== Confusion Matrix ===
a b c <-- classified as
11 0 0 | a = Iris-setosa
0 11 2 | b = Iris-versicolor
0 2 11 | c = Iris-virginica
Proyecto de Investigación II Inteligencia Artificial
Pag 37
2.5.3 Cadenas de Markov
Una cadena de Markov es una serie de eventos, en la cual la probabilidad de
que ocurra un evento depende del evento inmediato anterior. En efecto, las
cadenas de este tipo tienen memoria, "Recuerdan" el último evento y esto
condiciona las posibilidades de los eventos futuros. Esta dependencia del
evento anterior distingue a las cadenas de Markov de las series de eventos
independientes, como tirar una moneda al aire o un dado. En los negocios, las
cadenas de Markov se han utilizado para analizar los patrones de compra,los
deudores morosos, para planear las necesidades de personal y para analizar el
reemplazo de equipo. El análisis de Markov, llamado así en honor de un
matemático ruso que desarrollo el método en 1907, permite encontrar la
probabilidad de que un sistema se encuentre en un estado en particular en un
momento dado. Algo más importante aún, es que permite encontrar el promedio a
la larga o las probabilidades de estado estable para cada estado. Con esta
información se puede predecir el comportamiento del sistema a través del
tiempo. La tarea más difícil es reconocer cuándo puede aplicarse. La
caracteristica más importante que hay que buscar en la memoria de un evento a
otro.
Considere el problema siguiente: la compañía K, el fabricante de un cereal
para el desayuno, tiene un 25% del mercado actualmente. Datos del año
anterior indican que el 88% de los clientes de K permanecían fieles ese año,
pero un 12% cambiaron a la competencia. Además, el 85% de los clientes de la
competencia le permanecían fieles a ella, pero 15% de los clientes de la
competencia cambiaron a K. Asumiendo que estas tendencias continúen determine
¿Cuál es la parte que K aprovecha del mercado?:
En 2 años; y
En el largo plazo.
Esta situación es un ejemplo de un problema de cambio de marcas que sucede
muy a menudo que se presenta en la venta de bienes de consumo.
Para resolver este problema hacemos uso de cadenas de Markov o procesos de
Markov (qué es un tipo especial de proceso estocástico). El procedimiento se
da enseguida.
Procedimiento de solución
Observe que, cada año, un cliente puede estar comprando cereal de K o de la
competencia. Podemos construir un diagrama como el mostrado abajo donde los
dos círculos representan a los dos estados en que un cliente puede estar y
los arcos representan la probabilidad de que un cliente haga una cambio cada
año entre los estados. Note que los arcos curvos indican una "transición" de
un estado al mismo estado. Este diagrama es conocido como el diagrama de
Proyecto de Investigación II Inteligencia Artificial
Pag 38
estado de transición (notar que todos los arcos en ese diagrama son arcos
dirigidos).
Dado ese diagrama nosotros podemos construir la matriz de la transición
(normalmente denotada por el símbolo P) la qué nos dice la probabilidad de
hacer una transición de un estado a otro estado.
Sea:
Estado 1 = cliente que compra cereal de K y
Estado 2 = cliente que compra cereal de la competencia
Tenemos así la matriz de transición P para este problema, dada por
Para estado 1 2
Del estado 1 | 0.88 0.12 |
2 | 0.15 0.85 |
Note aquí que la suma de los elementos en cada fila de la matriz de la
transición es uno.
Por datos de este año sabemos que actualmente K tiene un 25% del mercado.
Tenemos que la fila de la matriz que representa el estado inicial del sistema
dado por:
Estado
1 2
[0.25, 0.75]
Normalmente denotamos esta fila de la matriz por s1 indicando el estado del
sistema en el primer periodo (años en este ejemplo en particular). Ahora la
teoría de Markov nos dice que, en periodo (año) t, el estado del sistema está
dado por el st de la fila de la matriz, donde:
st = st-1(P) =st-2(P)(P) = ... = s1(P)t-1
Tenemos que tener cuidado aquí al hacer la multiplicación de la matriz ya que
el orden de cálculo es importante (i.e. st-1(P) no es igual a (P)st-1 en
general). Para encontrar st nosotros podríamos intentar hallar P directamente
para la potencia t-1 pero, en la práctica, es mucho más fácil de calcular el
estado del sistema en cada sucesivo año 1,2,3 ,..., t.
Proyecto de Investigación II Inteligencia Artificial
Pag 39
Nosotros ya sabemos el estado del sistema en el año 1 (s1) tal que el estado
del sistema en el año dos (s2) está dado por:
s2 = s1P
= [0.25,0.75] |0.88 0.12 |
........|0.15 0.85 |
= [(0.25)(0.88) + (0.75)(0.15), (0.25)(0.12) + (0.75)(0.85)]
= [0.3325, 0.6675]
Note que este resultado tiene sentido intuitivo, e.g. del 25% comprando
actualmente al cereal de K, 88% continúan haciendolo, aunque del 75%
comprando el cereal del competidor 15% cambia a comprar cereal de K - dando
un (fracción) total de (0.25)(0.88) + (0.75)(0.15) = 0.3325 comprando cereal
de K.
De lo anterior, en el año dos 33.25% de las personas están en estado 1 - esto
es, está comprando cereal de K. Note aquí que, como un chequeo numérico, los
elementos de st deben sumar siempre uno.
En el año tres el estado del sistema se da por:
s3 = s2P
= [0.3325, 0.6675] |0.88 0.12 |
............... |0.15 0.85 |
= [0.392725, 0.607275]
Por lo tanto en el año tres 39.2725% de las personas están comprando al
cereal de K.
Recalcar que está pendiente la cuestión hecha sobre la porción que K comparte
del mercado en el largo plazo. Esto implica que necesitamos calcular st
cuando t se hace muy grande (se acerca al infinito).
La idea de la largo plazo es basada en la suposición de que, en el futuro, el
sistema alcance un "equilibrio" (a menudo llamado el "estado sustentable") en
el sentido de que el st = st-1. Ésto no quiere decir que las transiciones
entre estados no tengan lugar, suceden, pero ellos tienden "al equilibrio
global" tal que el número en cada estado permanece el mismo.
Hay dos enfoques básicos para calcular el estado sustentable:
Computational: - encontrar el estado sustentable calculando st para
t=1,2,3,... y se detiene cuando st-1 y st son aproximadamente el mismo. Esto
es obviamente muy fácil para una computadora y este es el enfoque usado por
un paquete computacional.
Algebraico: - para evitar cálculos aritméticos largos necesarios para
calcular st para t=1,2,3,... tenemos un atajo algebraico que puede usarse.
Recalcar que en el estado sustentable st = st-1 (= [x1,x2] para el ejemplo
considerado anteriormente). Entonces como st = st-1P tenemos eso
[x1,x2] = [x1,x2] | 0.88 0.12 |
.............| 0.15 0.85 |
(y también notar que x1 + x2 = 1). De esto tenemos tres ecuaciones que
podemos resolver.
Note aquí que hemos usado la palabra suposición anteriormente. Esto es porque
no todos los sistemas alcanzan un equilibrio, esto es, no cualquier sistema
tiene matriz de transición
| 0 1 |
Proyecto de Investigación II Inteligencia Artificial
Pag 40
|1 0 |
Nunca alcanza un estado sustentable.
Adoptando el enfoque algebraico anteriormente para el ejemplo del cereal K
tenemos las tres ecuaciones siguientes:
x1 = 0.88x1 + 0.15x2
x2 = 0.12x1 + 0.85x2
x1 + x2 = 1
o
0.12x1 - 0.15x2 = 0
0.12x1 - 0.15x2 = 0
x1 + x2 = 1
Note que la ecuación x1 + x2 = 1 es esencial. Sin élla no podríamos obtener
una única solución para x1 y x2. Resolviendo conseguimos x1 = 0.5556 y x2 =
0.4444
Por lo tanto, en la largo plazo, K comercializa una porción del mercado del
55.56%.
Un chequeo numérico útil (particularmente para problemas más grandes) es
sustituir el examen final calculando los valores en las ecuaciones originales
para verificar que ellos son consistentes con esas ecuaciones.
Proyecto de Investigación II Inteligencia Artificial
Pag 41
2.6 Algoritmos de ensamble
Había seis hombres de Indostán muy propensos a aprender, quienes fueron a ver
el elefante (A pesar de que todos ellos eran ciegos), para que cada uno de
ellos por observación pudieran saciar sus intelectos ellos concluyen que el
elefante es como una pared, una víbora, una lanza, un árbol, un abanico o una
soga dependiendo de la parte que tocaron. Los hombres debaten acaloradamente.
Para el uso del algoritmo de ensamble usaremos diversas opiniones de los
clasificadores anteriormente usados lo cual mejorará la clasificación pero
hará más lento el proceso de decisión, la implementación de Weka.
Aunque en muchas aplicaciones las redes neuronales son una herramienta
poderosa, en problemas de difícil resolución una única red resulta
insuficiente. Para solventar esta dificultad, los conjuntos de redes
neuronales proponen combinar diferentes redes de modo que se forme un
conjunto capaz de resolver mejor el problema en cuestión, proporcionando,
además, un diseño más sencillo y más fácilmente comprensible. Entre los
conjuntos de redes neuronales destacan los métodos de "Boosting" y,
especialmente, el algoritmo "AdaBoost".
Esquema de algoritmo Real AdaBoostEl algoritmo AdaBoost propone entrenar
iterativamente una serie de clasificadores base, de tal modo que cada nuevo
clasificador preste mayor atención a los datos clasificados erróneamente por
los clasificadores anteriores, y combinarlos de tal modo que se obtenga un
clasificador con elevadas prestaciones. Para ello, durante una serie de
iteraciones entrena un clasificador que implementa una función asignándole un
peso de salida, y lo añade al conjunto de modo que la salida global del
sistema se obtenga como combinación lineal ponderada de todos los
clasificadores base.
Para conseguir que cada nuevo clasificador preste mayor atención a los datos
más erróneos se emplea una función de énfasis que pondera la importancia de
cada dato durante el entrenamiento del clasificador. El análisis de esta
función
de énfasis nos ha permitido descomponerla en el producto de dos
términos, uno relacionado con el error cuadrático de las muestras y otro
asociado con la proximidad de estas a la frontera y, consecuentemente,
generalizar
la
estructura
de
la
función
de
énfasis
del
Adaboost,
introduciendo un parámetro de mezcla ajustable, λ, para controlar el
compromiso entre los dos términos de énfasis.
Proyecto de Investigación II Inteligencia Artificial
Pag 42
Proyecto de Investigación II Inteligencia Artificial
Pag 43
=== Run information ===
Scheme:weka.classifiers.meta.AdaBoostM1 -P 100 -S 1 -I 10 -W
weka.classifiers.trees.DecisionStump
Relation: iris
Instances: 150
Attributes: 5
sepallength
sepalwidth
petallength
petalwidth
class
Test mode:split 75.0% train, remainder test
=== Classifier model (full training set) ===
AdaBoostM1: Base classifiers and their weights:
Decision Stump
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-versicolor
petallength is missing : Iris-setosa
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor Iris-virginica
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor Iris-virginica
0.0
0.5
0.5
petallength is missing
Iris-setosa
Iris-versicolor Iris-virginica
0.3333333333333333 0.3333333333333333 0.3333333333333333
Weight: 0.69
Decision Stump
Proyecto de Investigación II Inteligencia Artificial
Pag 44
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-virginica
petallength is missing : Iris-virginica
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor Iris-virginica
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor Iris-virginica
0.0
0.3333333333333333 0.6666666666666667
petallength is missing
Iris-setosa
Iris-versicolor Iris-virginica
0.25 0.25 0.5000000000000001
Weight: 1.1
Decision Stump
Classifications
petalwidth <= 1.75 : Iris-versicolor
petalwidth > 1.75 : Iris-virginica
petalwidth is missing : Iris-versicolor
Class distributions
petalwidth <= 1.75
Iris-setosa
Iris-versicolor Iris-virginica
0.24154589371980675
0.7101449275362319 0.04830917874396136
petalwidth > 1.75
Iris-setosa
Iris-versicolor Iris-virginica
0.0
0.032258064516129024
0.967741935483871
petalwidth is missing
Iris-setosa
Iris-versicolor Iris-virginica
0.16666666666666666
0.5
0.33333333333333337
Weight: 1.32
Proyecto de Investigación II Inteligencia Artificial
Pag 45
Decision Stump
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-versicolor
petallength is missing : Iris-setosa
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor Iris-virginica
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor Iris-virginica
2.4541772123292936E-17 0.5536309127248501 0.44636908727514996
petallength is missing
Iris-setosa
Iris-versicolor Iris-virginica
0.3968253968253968 0.33393610608800484
0.2692384970865984
Weight: 1.0
Decision Stump
Classifications
petalwidth <= 0.8 : Iris-setosa
petalwidth > 0.8 : Iris-virginica
petalwidth is missing : Iris-virginica
Class distributions
petalwidth <= 0.8
Iris-setosa
Iris-versicolor Iris-virginica
1.0
0.0
0.0
petalwidth > 0.8
Iris-setosa
Iris-versicolor Iris-virginica
4.876852104094112E-17
0.3136440837893929 0.6863559162106071
petalwidth is missing
Iris-setosa
Iris-versicolor Iris-virginica
0.2715149848776456 0.22848501512235284
0.5000000000000014
Proyecto de Investigación II Inteligencia Artificial
Pag 46
Weight: 1.22
Decision Stump
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-versicolor
petallength is missing : Iris-versicolor
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor
-1.2574765214077044E-17
petallength is missing
Iris-setosa
Iris-versicolor
0.1759622238061291 0.5
Iris-virginica
Iris-virginica
0.6067682992755968 0.39323170072440317
Iris-virginica
0.324037776193871
Weight: 0.74
Decision Stump
Classifications
petallength <= 4.85 : Iris-versicolor
petallength > 4.85 : Iris-virginica
petallength is missing : Iris-virginica
Class distributions
petallength <= 4.85
Iris-setosa
Iris-versicolor Iris-virginica
0.2517002096709582 0.660989158028418 0.08731063230062384
petallength > 4.85
Iris-setosa
Iris-versicolor Iris-virginica
1.379474925594973E-17
0.058064332648205416
0.9419356673517946
petallength is missing
Iris-setosa
Iris-versicolor Iris-virginica
0.1301568472386974 0.3698431527613032 0.49999999999999944
Proyecto de Investigación II Inteligencia Artificial
Pag 47
Weight: 1.37
Decision Stump
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-virginica
petallength is missing : Iris-virginica
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor
-2.17703546955402E-18
petallength is missing
Iris-setosa
Iris-versicolor
0.32003984920368916
Iris-virginica
Iris-virginica
0.4168896637524031 0.5831103362475969
Iris-virginica
0.28346835863050734
0.39649179216580344
Weight: 0.93
Decision Stump
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-versicolor
petallength is missing : Iris-versicolor
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor Iris-virginica
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor Iris-virginica
3.621292691813957E-17
0.6437704901626133 0.35622950983738655
petallength is missing
Proyecto de Investigación II Inteligencia Artificial
Pag 48
Iris-setosa
Iris-versicolor Iris-virginica
0.2233256919345557 0.4999999999999997 0.27667430806544463
Weight: 0.96
Decision Stump
Classifications
petallength <= 2.45 : Iris-setosa
petallength > 2.45 : Iris-virginica
petallength is missing : Iris-virginica
Class distributions
petallength <= 2.45
Iris-setosa
Iris-versicolor
1.0
0.0
0.0
petallength > 2.45
Iris-setosa
Iris-versicolor
1.1378476401045689E-17
petallength is missing
Iris-setosa
Iris-versicolor
0.15437422894330288
Iris-virginica
Iris-virginica
0.4087218990793083 0.5912781009206917
Iris-virginica
0.3456257710566977 0.4999999999999995
Weight: 0.64
Number of performed Iterations: 10
Time taken to build model: 0.05 seconds
=== Evaluation on test split ===
=== Summary ===
Correctly Classified Instances
35
94.5946 %
Incorrectly Classified Instances
2
5.4054 %
Kappa statistic
0.9187
Mean absolute error
0.0868
Root mean squared error
0.1734
Relative absolute error
19.5118 %
Root relative squared error
36.7342 %
Proyecto de Investigación II Inteligencia Artificial
Pag 49
Total Number of Instances
37
=== Detailed Accuracy By Class ===
TP Rate FP Rate Precision Recall F-Measure ROC Area Class
1
0
1
1
1
1
Iris-setosa
1
0.083
0.867 1
0.929
0.984 Iris-versicolor
0.846 0
1
0.846 0.917
0.984 Iris-virginica
Weighted Avg. 0.946 0.029
0.953 0.946 0.946
0.989
=== Confusion Matrix ===
a b c <-- classified as
11 0 0 | a = Iris-setosa
0 13 0 | b = Iris-versicolor
0 2 11 | c = Iris-virginica
Proyecto de Investigación II Inteligencia Artificial
Pag 50
2.7 Python
Python es un lenguaje de programación que apuesta por la simplicidad,
versatilidad y rapidez de desarrollo. A continuación veremos unas notas
imprescindibles del lenguaje, extractadas básicamente de la página de inicio
del lenguaje que se puede ver en www.python.org. Python es un lenguaje de
scripting independiente de plataforma y orientado a objetos, preparado para
realizar cualquier tipo de programa, desde aplicaciones Windows a servidores
de red o incluso, páginas web. Es un lenguaje interpretado, lo que significa
que no se necesita compilar el código fuente para poder ejecutarlo, lo que
ofrece ventajas como la rapidez de desarrollo e inconvenientes como una menor
velocidad.
El creador del lenguaje es un europeo llamado Guido Van Rossum. Hace ya más
de una década que diseño Python, ayudado y motivado por su experiencia en la
creación de otro lenguaje llamado ABC. El objetivo de Guido era cubrir la
necesidad de un lenguaje orientado a objetos de sencillo uso que sirviese
para tratar diversas tareas dentro de la programación que habitualmente se
hacía en Unix usando C.
El desarrollo de Python duró varios años, durante los que trabajó en diversas
compañías de Estados Unidos. En el 2000 ya disponía de un producto bastante
completo y un equipo de desarrollo con el que se había asociado incluso en
proyectos empresariales. Actualmente trabaja en Zope, una plataforma de
gestión de contenidos y servidor de aplicaciones para el web, por supuesto,
programada por completo en Python.
Características del lenguaje
Propósito general
Se pueden crear todo tipo de programas. No es un lenguaje creado
específicamente para la web, aunque entre sus posibilidades sí se encuentra
el desarrollo de páginas.
Multiplataforma
Hay versiones disponibles de Python en muchos sistemas informáticos
distintos. Originalmente se desarrolló para Unix, aunque cualquier sistema es
compatible con el lenguaje siempre y cuando exista un intérprete programado
para él.
Interpretado
Quiere decir que no se debe compilar el código antes de su ejecución. En
realidad sí que se realiza una compilación, pero esta se realiza de manera
transparente para el programador. En ciertos casos, cuando se ejecuta por
primera vez un código, se producen unos bytecodes que se guardan en el
Proyecto de Investigación II Inteligencia Artificial
Pag 51
sistema y que sirven para acelerar la compilación implícita que realiza el
intérprete cada vez que se ejecuta el mismo código.
Interactivo
Python dispone de un intérprete por línea de comandos en el que se pueden
introducir sentencias. Cada sentencia se ejecuta y produce un resultado
visible, que puede ayudarnos a entender mejor el lenguaje y probar los
resultados de la ejecución de porciones de código rápidamente.
Orientado a Objetos
La programación orientada a objetos está soportada en Python y ofrece en
muchos casos una manera sencilla de crear programas con componentes
reutilizables.
Funciones y librerías
Dispone de muchas funciones incorporadas en el propio lenguaje, para el
tratamiento de cadenas, números, archivos, etc. Además, existen muchas
librerías que podemos importar en los programas para tratar temas específicos
como la programación de ventanas o sistemas en red o cosas tan interesantes
como crear archivos comprimidos.
Sintaxis clara
Por último, destacar que Python tiene una sintaxis muy visual, gracias a una
notación identada (con márgenes) de obligado cumplimiento. En muchos
lenguajes, para separar porciones de código, se utilizan elementos como las
llaves o las palabras clave begin y end. Para separar las porciones de código
en Python se debe tabular hacia dentro, colocando un margen al código que
iría dentro de una función o un bucle. Esto ayuda a que todos los
programadores adopten unas mismas notaciones y que los programas de cualquier
persona tengan un aspecto muy similar.
Todo lo anterior resumido en los siguientes 20 aforismos:
Hermoso es mejor que feo.
Explícito es mejor que implícito.
Simple es mejor que complejo.
Complejo es mejor que complicado.
Plano es mejor que anidado.
Disperso es mejor que denso.
La legibilidad cuenta.
Los casos especiales no son suficientemente especiales como para romper las
reglas.
Aunque lo pragmático gana a la pureza.
Los errores nunca deberían dejarse pasar silenciosamente.
A menos que se silencien explícitamente.
Cuando te enfrentes a la ambigüedad, rechaza la tentación de adivinar.
Debería haber una — y preferiblemente sólo una — manera obvia de hacerlo.
Proyecto de Investigación II Inteligencia Artificial
Pag 52
Aunque puede que no sea obvia a primera vista a menos que seas holandés.
(NT: Guido van Rossum es holandés)
Ahora es mejor que nunca.
Aunque muchas veces nunca es mejor que *ahora mismo*.
Si la implementación es difícil de explicar, es una mala idea.
Si la implementación es sencilla de explicar, puede que sea una buena idea.
Los espacios de nombres son una gran idea — ¡tengamos más de esas!
Proyecto de Investigación II Inteligencia Artificial
Pag 53
3. Sistemas dinámicos
La teoría de los sistemas dinámicos es el área de las matemáticas que
describe el comportamiento de sistemas complejos dinámicos, habitualmente se
usan ecuaciones diferenciales
o recurrencias. Cuando se ocupan ecuaciones
diferenciales es llamada teoría
de sistemas dinámicos continuos. Cuando se
usan las ecuaciones de recurrencia es llamada teoría de sistemas discretos.
Cuando se hace uso de una variable temporal sobre intervalos regulares se
hace referencia a ecuaciones dinámicas sobre escalas de tiempo. Existen casos
en los que se puede representar los modelos usando una teoría mixta.
En la teoría se trata con el comportamiento a largo plazo de sistemas
dinámicos y estudia las ecuaciones de movimiento de sistemas primariamente de
naturaleza mecánica. Por ejemplo la órbita de los planetas así como el
comportamiento de circuitos eléctricos y las soluciones de ecuaciones
diferenciales parciales que existen en el campo de la biología. hay un
esfuerzo importante en los sistemas caóticos.
Proyecto de Investigación II Inteligencia Artificial
Pag 54
3.1 Teoría del Caos
“Caos: Cuando el presente determina el futuro, pero el presente aproximado no
determina el futuro aproximado”
Edward Lorenz
La teoría del caos es un campo de estudio en las matemáticas, con
aplicaciones en varias disciplinas incluyendo la Meteorología, Sociología,
Física, Ingeniería, Economía, Biología, y Filosofía. La teoría del caos
estudia el comportamiento de sistemas dinámicos sensibles a las condiciones
iniciales el llamado efecto mariposa. Pequeñas diferencias en las condiciones
iniciales conducen a cambios en estos sistemas, predecir a largo plazo en
general no es posible, pasa incluso en los sistemas deterministas sin
elementos de carácter aleatorio lo cual hace a estos sistemas no predecibles.
Este comportamiento también es conocido como caos determinista o simplemente
caos.
El comportamiento caótico puede ser observado en muchos sistemas naturales
como la meteorología y el comportamiento climático, este comportamiento ha
sido estudiado como análisis del caos a través de modelos matemáticos y
técnicas como el ploteo recurrente y los mapas de Poincaré.
In descriptive statistics and chaos theory, a recurrence plot (RP) is a plot
showing, for a given moment in time, the times at which a phase space
trajectory visits roughly the same area in the phase space. In other words,
it is a graph of
showing on a horizontal axis and
space trajectory.
on a vertical axis, where
is a phase
Eckmann et al. (1987) introduced recurrence plots, which provide a way to
visualize the periodic nature of a trajectory through a phase space. Often,
the phase space does not have a low enough dimension (two or three) to be
pictured, since higher-dimensional phase spaces can only be visualized by
projection into the two or three-dimensional sub-spaces. However, making a
recurrence plot enables us to investigate certain aspects of the mdimensional phase space trajectory through a two-dimensional representation.
A recurrence is a time the trajectory returns to a location it has visited
before. The recurrence plot depicts the collection of pairs of times at which
the trajectory is at the same place, i.e. the set of
with
This can show many things, for instance, if the trajectory
periodic with period
multiple of
is
.
strictly
, then all such pairs of times will be separated by a
and visible as diagonal lines. To make the plot, continuous time
and continuous phase space are discretized, taking e.g.
as the location
Proyecto de Investigación II Inteligencia Artificial
Pag 55
of the trajectory at time
and counting as a recurrence any time the
trajectory gets sufficiently close (say, within ε) to a point it has been
previously. Concretely then, recurrence/non-recurrence can be recorded by the
binary function
and
the
recurrence
plot
puts
a
(black)
point
at
coordinates
if
.
Caused by characteristic behaviour of the phase space trajectory, a
recurrence plot contains typical small-scale structures, as single dots,
diagonal lines and vertical/horizontal lines (or a mixture of the latter,
which combines to extended clusters). The large-scale structure, also called
texture, can be visually characterised by homogenous, periodic, drift or
disrupted. The visual appearance of an RP gives hints about the dynamics of
the system.
Proyecto de Investigación II Inteligencia Artificial
Pag 56
3.2 Geometría Fractal
La geometría fractal es una rama de las matemáticas que estudia modelos
matemáticos adecuados para formas geométricas complejas e irregulares.
Dimensión fractal
Puede definirse en términos del mínimo número
necesarias para recubrir el conjunto, como el límite:
O en función del recuento del número de cajas
de
bolas
de
radio
de una cuadrícula de anchura
que intersecan al conjunto:
Se demuestra que ambas definiciones son equivalentes, y que son invariantes
bajo isometrías.
Dimensión de Hausdorff-Besicovitch
De una definición más compleja, la dimensión de Hausdorff-Besicovitch nos
proporciona un número
,
también invariante bajo isometrías, cuya relación con la dimensión fractal
es la siguiente:
Esto permite distinguir
dimensión fractal.
en
algunos
casos
entre
conjuntos
Proyecto de Investigación II Inteligencia Artificial
con
la
misma
Pag 57
Dimensión de fractales producidos por un IFS
Un sistema iterativo de funciones (IFS) es
contractivas definidas sobre un subconjunto de
un
conjunto
de
funciones
.
Cuando no hay solapamiento entre las imágenes de cada función, se demuestra
que
y que ambas pueden calcularse como solución de la ecuación:
donde ci designa el factor de contracción de cada aplicación contractiva del
IFS.
Proyecto de Investigación II Inteligencia Artificial
Pag 58
4. Construcción de la Heurística Modelo de flor
4.1 Proceso ETL Conjunto de Prueba
Cada atributo será considerado como una dimensión independiente.
4.1.1 Extracción del conjunto de prueba
Se descarga el archivo que contiene las tuplas del sitio. Se crea un esquema
y una nueva base de datos oracle, se crean las tablas del ods y dm en caso de
que aplique. Separamos el conjunto de instancias a utilizar de manera que el
25 % sean datos que sirvan para entrenar el algoritmo y el restante 75% sean
el conjunto de prueba.
4.1.2 Transformación del conjunto de prueba
El criterio para las las transformaciones es el siguiente:
-Los datos que tengan un campo con el signo “?” debe ser sustituido por un
null (Limpieza).
-Se deben de formatear los datos para ser interpretados como tipo “double”
(Estandarización)
-Para cada campo no numérico se debe de crear una regla de correspondencia de
manera que todos los campos sean numéricos (Discretización).
-Validación, se crea una regla de para evaluar el valor de cada tupla por la
cantidad de información que proporciona.
-Se crean las dimensiones para formar el espacio fase
4.1.3 Carga conjunto de prueba
Una vez que estén los datos listos, estos
dimensional que contendrá un atributo cada vez.
se
colocan
en
un
datamart
4.2 Construcción
El modelo de flor recrea el proceso de auto similitud de un fractal, si hay
relación entre los datos, esta relación debe de ser de una dimensión fractal.
El conocimiento adquirido al revisar e implementar los demás aprendices ha
permitido encontrar algunas peculiaridades propias para esta heurística.
Imagine entonces que es tarde y algo se aproxima hacia usted; puede
considerar que existen las condiciones para reconocer el objeto por el sonido
que hace, el olor que despide y finalmente por la forma que ve…
Proyecto de Investigación II Inteligencia Artificial
Pag 59
Cuando tenemos un conjunto de entrenamiento lo que se hace es tratar de
definir la forma o atributos para realizar una clasificación a través de un
umbral o función de activación. Para un ser humano es posible reconocer
diferentes formas de un mismo objeto primero identificando una silueta y
luego acercarse y tomar detalle las características menos visibles del
objeto.
Diferentes niveles de información hacen que un atributo sea más o menos útil
atendiendo a la premisa del peligro que supone, regresando a la metáfora
anterior, si el sonido es parecido al rugido de un tigre, entonces lo más
probable es que se trate de un tigre y se ocupan las otras características
para comprobarlo.
Finalmente hay otro aspecto que es conveniente recalcar existe un error
asociado en cada una de las observaciones hechas, pero en la naturaleza ese
supuesto error nos da un margen de operatividad.
4.2.1 Diseño
Usando el concepto anteriormente expuesto:
Encontrar la ecuación dado un fractal o el comportamiento.
Encontrar atractores.
Observaciones.
-Suponemos que los datos se comportan de forma fractal.
-Al encontrar la ecuación encontramos el modelo.
-Podemos no encontrar la ecuación.
-Consideramos el error como un coeficiente de ajuste.
Paso 1. Calcular las estadísticas de acercamientos, como se ha divido en cada
atributo en un posible indicador, se encontrara la relación más común entre
los n datos, es decir todas las distancias entre elementos de manera que:
Paso 2. Calcular los atractores de la dimensión.
Paso 3. Usar los datos obtenidos en el conjunto de prueba en el conjunto de
datos fuera del conjunto de prueba, si existen datos no vistos con antelación
en el conjunto de prueba, se crea un nuevo atractor para cada dimensión.
Paso 4. Si se puede generalizar el comportamiento con una ecuación, entonces
hemos acabado si no; utilizar los atractores para los datos
Proyecto de Investigación II Inteligencia Artificial
Pag 60
4.2.2 Codificación
import
import
import
import
import
import
import
java.io.BufferedReader;
java.io.File;
java.io.FileReader;
java.io.FileWriter;
java.io.PrintWriter;
java.io.IOException;
java.util.ArrayList;
Public class Archivo {
public ArrayList<Modelo> leerArchivo(String ruta)throws Exception{
ArrayList<Modelo> lista = new ArrayList<Modelo>();
//Se crea un objeto File usando el constructor que recibe la ruta(String)
File archivo = new File (ruta);
//Usamos estos 2 objetos porque BufferedReader contiene un m�todo sencilo
//Para leer el archivo por linea
FileReader fileReader = new FileReader (archivo);
BufferedReader buffReader = new BufferedReader(fileReader);
String linea=null;
int cont= 0;
while((linea=buffReader.readLine())!=null){
try{
cont++;
if(linea.length()>0){
String[] renglonTemporal = linea.split(",");
Modelo
m
=
new
Modelo(Double.valueOf(renglonTemporal[0]),
Double.valueOf(renglonTemporal[1]),Double.valueOf(renglonTemporal[2]),
Double.valueOf(renglonTemporal[3]) );
lista.add(m);
}
}catch(Exception e){
System.out.println("ERROR "+ e.getMessage());
}
//Modelo
m
=
new
Modelo(Double.valueOf(renglonTemporal[0]),Double.valueOf(renglonTemporal[1]),Double.valueOf(rengl
onTemporal[2]),Double.valueOf(renglonTemporal[3]));
//lista.add(m);
}
//Se valida que no sea nulo y se cierra
if( null != fileReader)
fileReader.close();
return lista;
}
}
public class Modelo{
private double dato1 = 0;
Proyecto de Investigación II Inteligencia Artificial
Pag 61
private
private
private
private
double
double
double
double
dato2
dato3
dato4
media
=
=
=
=
0;
0;
0;
0;
public Modelo(double dato1,double dato2,double dato3,double dato4){
this.dato1=dato1;
this.dato2=dato2;
this.dato3=dato3;
this.dato4=dato4;
this.media = ( dato1 + dato2 + dato3 + dato4 ) / 4;
}
@Override
public String toString() {
String
salida=
getDato1()+"
"+getMedia()+"\n";
return salida;
}
"+getDato2()+"
"+getDato3()+"
"+getDato4()+"
void setDato1(double dato1){
this.dato1 = dato1;
}
void setDato2(double dato2){
this.dato2 = dato2;
}
void setDato3(double dato3){
this.dato3 = dato3;
}
void setDato4(double dato4){
this.dato4 = dato4;
}
double getDato1(){
return this.dato1;
}
double getDato2(){
return this.dato2;
}
double getDato3(){
return this.dato3;
}
double getDato4(){
return this.dato4;
}
double getMedia(){
this.media = ((getDato1() + getDato2() + getDato3() + getDato4())/4);
return this.media;
}
public boolean compara( double b, double fractal) {
double baja = (getMedia() - (getMedia()*fractal)/2);
double alta = (getMedia() + (getMedia()*fractal)/2);
if( b < alta || b >baja)
return true;
return false;
}
}
import java.util.ArrayList;
Proyecto de Investigación II Inteligencia Artificial
Pag 62
public class Atractor {
ArrayList<Modelo> listaAtractores = new ArrayList<Modelo>();
public double promedio(){
double acumulador=0;
for(Modelo x:this.listaAtractores){
acumulador+= x.getMedia();
}
double prom = acumulador/this.listaAtractores.size();
return prom;
}
}
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class Principal {
public static void main(String args[]) throws IOException, Exception {
Archivo ar=new Archivo();
List<Modelo> listaPrueba = new ArrayList<Modelo>();
ArrayList<Atractor> listaAtractores = new ArrayList<Atractor>();
ArrayList<Modelo> lista = ar.leerArchivo("C:\\iris.data");
//en este ciclo se calculan los conjuntos de entrenamiento y prueba
for(Modelo x:lista ){
double ale = Math.random()*100;
//criterio de aceptacion
if(ale>68)
listaEntrenamiento.add(x);
else
listaPrueba.add(x);
}
//en este ciclo se llenan la lista de atractores
double fractal = 1;
//inicia la lista de atractores
Atractor nuevoAtractor = new Atractor();
nuevoAtractor.listaAtractores.add(listaEntrenamiento.get(0));
listaAtractores.add(nuevoAtractor);
listaEntrenamiento.remove(0);
while(listaEntrenamiento.size()>0){
int tamListaAtractores = listaAtractores.size();
for(int i =0; i<tamListaAtractores; i++) {
double
alta
=
listaAtractores.get(i).promedio()
+
(listaAtractores.get(i).promedio() * fractal ) / 2);
double
baja
=
listaAtractores.get(i).promedio()
(listaAtractores.get(i).promedio() * fractal ) / 2);
if(
listaEntrenamiento.get(0).getMedia()
<
alta
listaEntrenamiento.get(0).getMedia() > baja ){
listaAtractores.get(i).listaAtractores.add(listaEntrenamiento.get(0));
listaEntrenamiento.remove(0);
}else{
Atractor tempAtractor = new Atractor();
tempAtractor.listaAtractores.add(listaEntrenamiento.get(0));
listaAtractores.add(tempAtractor);
listaEntrenamiento.remove(0);
break;
Proyecto de Investigación II Inteligencia Artificial
(
(
&&
Pag 63
}
break;
}
}
System.out.println("Lista de entrenamiento tam= "+ listaEntrenamiento.size());
System.out.println("Lista de prueba tam= "+ listaPrueba.size());
System.out.println("Lista de atractores tam = "+listaAtractores.size());
while(listaPrueba.size()>0){
int tamListaAtractores = listaAtractores.size();
for(int i =0; i<tamListaAtractores; i++) {
double
alta
=
listaAtractores.get(i).promedio()
+
(
(listaAtractores.get(i).promedio() * fractal ) / 2);
double
baja
=
listaAtractores.get(i).promedio()
(
(listaAtractores.get(i).promedio() * fractal ) / 2);
if( listaPrueba.get(0).getMedia() < alta && listaPrueba.get(0).getMedia() > baja
){
listaAtractores.get(i).listaAtractores.add(listaPrueba.get(0));
listaPrueba.remove(0);
}else{
Atractor tempAtractor = new Atractor();
tempAtractor.listaAtractores.add(listaPrueba.get(0));
listaAtractores.add(tempAtractor);
listaPrueba.remove(0);
break;
}
break;
}
}
System.out.println("Lista de entrenamiento tam= "+ listaEntrenamiento.size());
System.out.println("Lista de prueba tam= "+ listaPrueba.size());
System.out.println("Lista de atractores tam = "+listaAtractores.size());
4.2.3 Implementación
Este código se usara en una PC con Windows 7 instalado, java 8 y se ejecutara
sobre netbens.
4.3 Pruebas
A continuación se muestran una serie de pruebas realizadas con el algoritmo
4.3.1 Cambio del tamaño fractal
Tamaño fractal = .01
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 130 clases esperadas 3
Diferencia -127
Tamaño fractal = .02
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 112 clases esperadas 3
Diferencia -109
Tamaño fractal = .03
Proyecto de Investigación II Inteligencia Artificial
Pag 64
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 103 clases esperadas 3
Diferencia -100
Tamaño fractal = .04
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 98 clases esperadas 3
Diferencia -95
Tamaño fractal = .05
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 148 clases esperadas 3
Diferencia -145
Tamaño fractal = .06
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 138 clases esperadas 3
Diferencia -135
Tamaño fractal = .07
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 137 clases esperadas 3
Diferencia -134
Tamaño fractal = .08
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 135 clases esperadas 3
Diferencia -132
Tamaño fractal = .09
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 135 clases esperadas 3
Diferencia -132
Tamaño fractal = .10
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 134 clases esperadas 3
Diferencia -131
Tamaño fractal = .20
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 114 clases esperadas 3
Diferencia -111
Tamaño fractal = .30
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 101 clases esperadas 3
Diferencia -98
Proyecto de Investigación II Inteligencia Artificial
Pag 65
Tamaño fractal = .40
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 98 clases esperadas 3
Diferencia -95
Tamaño fractal = .50
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 96 clases esperadas 3
Diferencia -93
Tamaño fractal = .60
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 90 clases esperadas 3
Diferencia -87
Tamaño fractal = .70
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 69 clases esperadas 3
Diferencia -66
Tamaño fractal = .80
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 50 clases esperadas 3
Diferencia -47
Tamaño fractal = .90
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 13 clases esperadas 3
Diferencia -10
Tamaño fractal = 1.00
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 7 clases esperadas 3
Diferencia -4
Tamaño fractal = 1.10
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 5 clases esperadas 3
Diferencia -2
Tamaño fractal =1 .20
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.30
Proyecto de Investigación II Inteligencia Artificial
Pag 66
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.40
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.50
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.60
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal =1.70
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.80
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.90
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 2.00
Valor ruleta 25% entrenamiento 75% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
4.3.2 Cambio de conjunto de entrenamiento
Tamaño fractal = .01
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 147 clases esperadas 3
Diferencia -144
Proyecto de Investigación II Inteligencia Artificial
Pag 67
Tamaño fractal = .02
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 145 clases esperadas 3
Diferencia -142
Tamaño fractal = .03
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 143 clases esperadas 3
Diferencia -140
Tamaño fractal = .04
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 141 clases esperadas 3
Diferencia -138
Tamaño fractal = .05
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 138 clases esperadas 3
Diferencia -135
Tamaño fractal = .06
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 139 clases esperadas 3
Diferencia -136
Tamaño fractal = .07
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 136 clases esperadas 3
Diferencia -133
Tamaño fractal = .08
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 137 clases esperadas 3
Diferencia -134
Tamaño fractal = .09
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 135 clases esperadas 3
Diferencia -132
Tamaño fractal = 0.10
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 134 clases esperadas 3
Diferencia -131
Tamaño fractal = 0.20
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 111 clases esperadas 3
Diferencia -108
Proyecto de Investigación II Inteligencia Artificial
Pag 68
Tamaño fractal = 0.30
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 101 clases esperadas 3
Diferencia -98
Tamaño fractal = 0.40
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 97 clases esperadas 3
Diferencia -94
Tamaño fractal = 0.50
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 94 clases esperadas 3
Diferencia -91
Tamaño fractal = 0.60
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 85 clases esperadas 3
Diferencia -82
Tamaño fractal = 0.70
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 62 clases esperadas 3
Diferencia -59
Tamaño fractal = 0.80
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 44 clases esperadas 3
Diferencia -41
Tamaño fractal = 0.90
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 14 clases esperadas 3
Diferencia -11
Tamaño fractal = 1.00
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 6 clases esperadas 3
Diferencia -3
Tamaño fractal = 1.10
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 6 clases esperadas 3
Diferencia -3
Tamaño fractal = 1.20
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 2 clases esperadas 3
Proyecto de Investigación II Inteligencia Artificial
Pag 69
Diferencia 1
Tamaño fractal = 1.30
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal =1.40
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.50
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.60
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal =1.70
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal =1.80
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Tamaño fractal = 1.90
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Valor ruleta 50% entrenamiento 50% conjunto de prueba
Tamaño fractal = 2.00
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Aumentando el conjunto de entrenamiento
Tamaño fractal = 0.01
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 147 clases esperadas 3
Diferencia -144
Proyecto de Investigación II Inteligencia Artificial
Pag 70
Tamaño fractal = 0.02
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 145 clases esperadas 3
Diferencia -142
Tamaño fractal = 0.03
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 144 clases esperadas 3
Diferencia -141
Tamaño fractal = 0.04
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 141 clases esperadas 3
Diferencia -138
Tamaño fractal = 0.05
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 140 clases esperadas 3
Diferencia -137
Tamaño fractal = 0.06
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 139 clases esperadas 3
Diferencia -136
Tamaño fractal = 0.07
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 138 clases esperadas 3
Diferencia -135
Tamaño fractal = 0.08
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 138 clases esperadas 3
Diferencia -135
Tamaño fractal = 0.09
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 134 clases esperadas 3
Diferencia -131
Tamaño fractal = 0.10
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 130 clases esperadas 3
Diferencia -127
Tamaño fractal = 0.20
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 115 clases esperadas 3
Diferencia -112
Proyecto de Investigación II Inteligencia Artificial
Pag 71
Tamaño fractal = 0.30
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 101 clases esperadas 3
Diferencia -98
Tamaño fractal = 0.40
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 98 clases esperadas 3
Diferencia -95
Tamaño fractal = 0.50
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 96 clases esperadas 3
Diferencia -93
Tamaño fractal = 0.60
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 82 clases esperadas 3
Diferencia -79
Tamaño fractal = 0.70
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 76 clases esperadas 3
Diferencia -73
Tamaño fractal = 0.80
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 50 clases esperadas 3
Diferencia -47
Tamaño fractal = 0.90
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 16 clases esperadas 3
Diferencia -13
Tamaño fractal = 1.00
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 8 clases esperadas 3
Diferencia -5
Tamaño fractal = 1.10
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 4 clases esperadas 3
Diferencia -1
Tamaño fractal = 1.20
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Proyecto de Investigación II Inteligencia Artificial
Pag 72
Numero de Atractores = 3 clases esperadas 3
Diferencia 0
Tamaño fractal = 1.30
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.40
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.50
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.60
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.70
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.80
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 1.90
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Tamaño fractal = 2.00
Valor ruleta 75% entrenamiento 25% conjunto de prueba
Numero de Atractores = 1 clases esperadas 3
Diferencia 2
Proyecto de Investigación II Inteligencia Artificial
Pag 73
4.4 Conclusiones de la heurística
Pasado el umbral de la mejor aproximación se sobreentrena el algoritmo y este
tiende a caer en un valor con una única clase. Las diferencias que existen
entre diferentes conjuntos de entrenamiento son mínimas lo cual es
extremadamente útil cuando queremos mejorar el desempeño a grandes rasgos del
sistema. En el rango de valores entre 1.00 y 1.30 se encuentran los
atractores más importantes del sistema que hacen que el sistema se clasifique
de manera cercana a la correcta. El orden del algoritmo es de cuadrático ya
que los ciclos no son completos y en el peor de los casos se vuelve lineal.
Con esta información se puede mejorar el algoritmo y es candidato para
incluirlo en un algoritmo de ensamble como ADABOOST y de esta manera
simplificar la clasificación y posterior predicción de un fenómeno. Debido a
las complicaciones que se encontraron para generalizar el comportamiento
caótico de los datos, se hizo que la misma estructura del algoritmo fuera
dinámica con lo cual se busca empatar la naturaleza de los datos. Con la
información conseguida sabemos que el sistema cuenta con una relación fractal
de aproximadamente 1.30 y contemplando un mínimo del 25% del total de datos
disponibles para realizar el entrenamiento
el sistema no se comporta como
caja oscura ya que los atractores siempre están disponibles y los atractores
no son estáticos puesto que cuando encuentra algún dato que no esté en los
atractores el sistema lo incluye.
Proyecto de Investigación II Inteligencia Artificial
Pag 74
5. Conclusiones
Los sistemas de clasificación tienen algunos puntos débiles que con el tiempo se han
reconocido y se han corregido, cada nueva técnica presenta ventajas respecto a sus
antecesores, pero al mismo tiempo trae consigo posibilidades de mejora, en este trabajo
se propone una forma de ver el mismo problema de clasificación como un problema de
predicción. Los avances que se han logrado en este trabajo requieren de un
conocimiento mayor de topologías y sistemas dinámicos mismos que no son tratados en
la licenciatura sin embargo usando los principios algorítmicos de los aprendices se ha
logrado subsanar esa deficiencia. En todo caso con la construcción de la primera
versión del modelo de flor se puede pensar en una nueva versión que resuelva a la par el
problema de los atractores y el problema del modelaje usando la función inversa a la
construcción de un fractal.
Proyecto de Investigación II Inteligencia Artificial
Pag 75
6. Bibliografía
[1] ESPEJO y. Reflejo del Caos al ORDEN. Guía ilustrada de la teoría
del caos y la ciencia de la totalidad. JOHN BRIGGS y F. DAVID PEAT.
[2] LA DOMESTICACION DEL AZAR: LA EROSION DEL DETERMINISMO Y EL NACIM
IENTO DE LAS CIENCIAS DEL CAOS - IAN HACKING.
[3]
Curso
de
aprendizaje
maquinal
http://see.stanford.edu/see/courseinfo.aspx?coll=348ca38a-3a6d-4052937d-cb017338d7b1
[4] Software para Data Minning
http://www.cs.waikato.ac.nz/ml/weka/
[5]Instalación y uso de Weka
http://users.dsic.upv.es/~jorallo/docent/doctorat/weka.pdf
[6]Instalación
de
Oracle
SQl
developer
en
Ubuntu
http://meandmyubuntulinux.blogspot.mx/2012/05/installing-oracle-11gr2-express.html
[7] Guía para realizar minería de datos
http://guidetodatamining.com/
[8]
Como
construir
un
clasificador
Bayes
ingenuo
https://www.bionicspirit.com/blog/2012/02/09/howto-build-naive-bayesclassifier.html
[9] Como construir un clasificador k-means en python
https://datasciencelab.wordpress.com/2013/12/12/clustering-with-kmeans-in-python/
[10]
Como
construir
un
perceptrón
multicapa
https://blog.dbrgn.ch/2013/3/26/perceptrons-in-python/
en
[11]
Redes
neuronales
usando
teoría
de
resonancia
http://mnemstudio.org/neural-networks-art1-example-1.htm
python
adaptiva
[12]
Redes
bayesianas
con
Python
http://derandomized.com/post/20009997725/bayes-net-example-withpython-and-khanacademy
Proyecto de Investigación II Inteligencia Artificial
Pag 76
[13] Generar Cadenas de Markov
http://agiliq.com/blog/2009/06/generating-pseudo-random-text-withmarkov-chains-u/
[14] Algoritmo de ensamble
http://scikit-learn.org/stable/modules/ensemble.html
[15] Teoría de fractales
http://classes.yale.edu/fractals/
Proyecto de Investigación II Inteligencia Artificial
Pag 77