Proyecto Final Taller de Licenciatura I

FICHA DE IDENTIFICACIÓN DE PROYECTO FINAL
SISTEMA INTELIGENTE BASADO EN COMPUTACIÓN

Título EVOLUTIVA APLICANDO ALGORITMOS GENETICOS
Nombres y Apellidos Código de estudiantes
Oscar Rodrigo Villazón Canaviri 201311601
Autor/es
Fecha 16/12/2018
Carrera Ingeniería de Sistemas

Asignatura Taller de Licenciatura I
Grupo Regular A
Docente Ing. Roxana Ramos Larico
Periodo Académico 2 / 2018
Subsede Cochabamba
Copyright © (2018) por (Oscar Rodrigo Villazón Canaviri). Todos los derechos reservados.
Título: Sistema Inteligente Basado En Computación Evolutiva Aplicando Algoritmos Genéticos
Autor/es: Oscar Rodrigo Villazón Canaviri
RESUMEN:
En este proyecto se Investiga y analiza una estrategia de solución del juego

“Mastermind” que empleara un algoritmo evolutivo discreto con aplicación de operadores
genéticos discretos, operadores de orden y operadores personalizados. Se presenta los
conceptos correspondientes a los sistemas inteligentes, computación evolutiva y algoritmos
genéticos. También se muestra el modelo del juego y la estrategia para resolverlo.
Palabras clave: sistemas inteligentes, computación evolutiva, algoritmos genéticos, mastermind
ABSTRACT:
This project investigates and analyzes a solution strategy for the game "Mastermind" that
uses a discrete evolutionary algorithm with application of discrete genetic operators, order
operators and custom operators. The concepts corresponding to intelligent systems, evolutionary
computation and genetic algorithms are presented. It also shows the model of the game and the
strategy to solve it.
Key words: intelligent systems, evolutionary computation, genetic algorithms, mastermind
Asignatura: Taller de Licenciatura I

Página 2 de 70
Carrera: Ingeniería de Sistemas
Tabla De Contenidos
Lista De Ilustraciones ................................................................................................................. 5
Capítulo I. Descripción del Proyecto ......................................................................................... 6
1.1. Introducción .............................................................................................................. 6
1.2. Objetivos del Proyecto .............................................................................................. 7
1.2.1. Objetivo General ................................................................................................... 7
1.2.2. Objetivos Específicos ............................................................................................ 7
1.3. Justificación del Proyecto ......................................................................................... 7
1.4. Alcance del Proyecto ................................................................................................ 7
Capítulo II. Marco Teórico ........................................................................................................ 8
2.1 Inteligencia Artificial .................................................................................................... 8
2.1.1. Tipos De Inteligencia Artificial ............................................................................... 8
2.1.2. Aplicaciones Prácticas De La Inteligencia Artificial ............................................... 8
2.1.3. Ventajas y Desventajas de la Inteligencia Artificial .............................................. 10
2.2 Sistemas Inteligentes .................................................................................................. 10
2.2.1. Capacidades requeridas .......................................................................................... 10
2.3 Computación Evolutiva .............................................................................................. 12
2.3.1. ¿Cómo representamos a los individuos? ................................................................ 15
2.3.2. ¿Cómo se reproducen y mutan los individuos? ...................................................... 15
2.3.3. ¿Qué es eso de que un "individuo es suficientemente bueno"? ............................. 16
2.3.4. Aplicaciones ........................................................................................................... 17
2.4 Algoritmos Genéticos ................................................................................................. 17
2.4.1. Métodos de representación ..................................................................................... 19
2.4.2. Métodos de selección ............................................................................................. 20
2.4.3. Métodos de cambio ................................................................................................ 21
2.4.4. Ventajas y Desventajas de los algoritmos genéticos .............................................. 22
2.4.5. Algunos ejemplos específicos de AG .................................................................... 23
2.5 Mastemind .................................................................................................................. 31
2.5.1. Elementos Que Componen El Juego ...................................................................... 32
2.5.2. Como Se Juega ....................................................................................................... 32
2.6. Metodologías ................................................................................................................. 33
2.6.1. Metodología en Cascada ........................................................................................ 33
2.6.2. Método de Prototipos ............................................................................................. 34
2.6.3. Modelo Incremental o Iterativo y Creciente .......................................................... 36
Capítulo III. Marco Practico .................................................................................................... 38
3.1. Desarrollo del Proyecto ................................................................................................. 38
3.1.1. Administración del Proyecto .................................................................................. 38
3.2. Análisis del Sistema ................................................................................................ 38
3.2.1. Requisitos No Funcionales .................................................................................. 39
3.2.2. Requisitos Funcionales ........................................................................................ 39
3.3. Diseño del Sistema .................................................................................................. 41
3.3.1. Diagrama de flujo de la estructura base de un algoritmo genético. .................... 41
3.3.2. Diseño de la Solución del Juego Mastermind mediante Algoritmos Geneticos . 42
3.3.3. Como resolver el Juego mediante Computación Evolutiva ................................ 44
3.3.4. Periodo de Iteración – Primera Fase Prototipo.................................................... 46

Página 3 de 70
3.3.5. Periodo de Iteración – Fase Final ........................................................................ 48

Conclusiones ............................................................................................................................ 69
Bibliografía y Referencias ........................................................................................................ 70

Página 4 de 70
Lista De Ilustraciones
Ilustración 1 Principales aplicaciones prácticas de la IA ........................................................... 9

Ilustración 2 Metáfora Evolutiva ............................................................................................. 13
Ilustración 3 Esquema general de un algoritmo evolutivo ....................................................... 14
Ilustración 4 Pseudo-Codigo de algoritmo evolutivo............................................................... 14
Ilustración 5 Nuevo individuo a partir de dos .......................................................................... 15
Ilustración 6 Mutación ............................................................................................................. 16
Ilustración 7 Funcionamiento Algoritmos Genéticos .............................................................. 18
Ilustración 8 Estrategia de Mutación ........................................................................................ 21
Ilustración 9 Estrategia de Cruzamiento .................................................................................. 22
Ilustración 10 Mastermind ....................................................................................................... 31
Ilustración 11 Diagrama de flujo de la estructura base de un algoritmo genético ................... 41
Ilustración 12 Prototipo MM .................................................................................................... 46
Ilustración 13 Prototipo MM en ejecución............................................................................... 47
Ilustración 14 Muestra de la Codificación ............................................................................... 47
Ilustración 15 Interfaz principal Mastermind ........................................................................... 48
Ilustración 16 Mastermind Ejectudandose ............................................................................... 49
Ilustración 17 IA Mastermind .................................................................................................. 49
Ilustración 18UML IA .............................................................................................................. 50
Ilustración 19 common ............................................................................................................. 51
Ilustración 20 GUI.................................................................................................................... 51
Ilustración 21 Game ................................................................................................................. 52

Página 5 de 70
Capítulo I. Descripción del Proyecto
1.1. Introducción
La Computación Evolutiva engloba un amplio conjunto de técnicas de resolución de
problemas complejos, basadas en la emulación de procesos naturales de evolución. La principal
aportación de la Computación Evolutiva a la metodología de resolución de problemas, consiste
en el uso de mecanismos de selección de soluciones potenciales y de construcción de nuevos
candidatos por recombinación de características de otros ya presentes, de modo parecido a como
ocurre en la evolución de los organismos naturales. Entre esas técnicas destacan los Algoritmos
Genéticos y la Programación Evolutiva.
La Programación Evolutiva es una técnica de Computación Evolutiva útil para incorporar
conocimiento específico a los Algoritmos Genéticos y de esta forma mejorar la eficiencia de
éstos, ya que en los Algoritmos Genéticos se utilizan en gran medida datos pseudoaleatorios que
pueden llevar a una eficiencia muy pobre (e incluso no encontrar soluciones al problema en
cuestión). Pero estos datos pseudoaleatorios son los que dan genericidad a los Algoritmos
Genéticos, de forma que se pueden utilizar en muchos problemas de optimización; a veces, según
el problema en cuestión, puede que no se encuentre una solución óptima por los métodos
tradicionales (quizás por no estar bien condicionados) mientras que los algoritmos genéticos son
capaces de encontrarla. De esta forma, la Programación Evolutiva engloba la genericidad de los
Algoritmos Genéticos para encontrar soluciones e incorpora conocimiento específico para
generar eficiencia (encontrar más y mejores soluciones).
Por otro parte, la programación de juegos está convirtiéndose hoy en día en un creciente
campo donde se investigan y aplican tanto técnicas gráficas como complicados algoritmos que
provienen de campos tales como la Inteligencia Artificial y la Música Interactiva.
Con respecto a la algoritmia, en la programación de juegos se utilizan frecuentemente técnicas
de optimización para resolver numerosos problemas que se plantean, así como muchas otras
técnicas avanzadas y que no siempre se reconocen como tales: en realidad, todavía hay personas
que piensan que la programación de juegos es, como lo era antaño, una programación “sucia”
con muchos trucos para mejorar la velocidad, y sin uso apenas de algoritmos de organización.

Página 6 de 70
Hoy en día las cosas han cambiado (con la mejora y avance de las computadoras, más
potentes, y de los lenguajes de programación y API´s, interfaces de programación de
aplicaciones) y estamos ante uno de los campos más enormemente ampliados y comercializados:
el mercado de los videojuegos.
1.2. Objetivos del Proyecto

1.2.1. Objetivo General
El objetivo principal de este proyecto es Desarrollar un Sistema Inteligente basado en
computación evolutiva aplicando algoritmos genéticos para resolver el juego Mastermind.
1.2.2. Objetivos Específicos

En base al objetivo principal, se plantean los siguientes objetivos específicos:
 Investigar y analizar el marco teórico del proyecto.
 Investigar y analizar las distintas tecnologías que intervienen en el desarrollo del sistema.
 Analizar las herramientas que intervienen en el desarrollo del sistema.
 Seleccionar las herramientas adecuadas para el desarrollo del sistema
 Diseñar una interfaz intuitiva para facilitar el uso del sistema.
 Desarrollar todas las funcionalidades del sistema.
 Presentación del sistema desarrollado.
1.3. Justificación del Proyecto

Desde el curso de Sistemas Inteligentes, antes de que se desarrollara la idea en su estado
actual, nuestro objetivo fue realizar un proyecto que nos permitiera realizar experimentos
basados en la computación evolutiva aplicando algoritmos genéticos para su resolución.
Este consistía en realizar lo que es ahora nuestro proyecto, la resolución del juego Mastermind
mediante un sistema inteligente, la idea final fue tomando su forma actual una vez que fuimos
tomado contacto con la teoría y tecnologías necesarias.
1.4. Alcance del Proyecto
El proyecto a realizar abarcará solo la parte de Algoritmos genéticos de la Computación
Evolutiva para la resolución del mismo y el sistema desarrollado Mastermind solo actuará como
Generador de código (CodeMaker) y Rompedor de código (CodeBraker).

Página 7 de 70
Capítulo II. Marco Teórico
2.1 Inteligencia Artificial

La Inteligencia Artificial (IA) es la combinación de algoritmos planteados con el propósito de
crear máquinas que presenten las mismas capacidades que el ser humano. Una tecnología que
todavía nos resulta lejana y misteriosa, pero que desde hace unos años está presente en nuestro
día a día a todas horas.
2.1.1. Tipos De Inteligencia Artificial

Los expertos en ciencias de la computación Stuart Russell y Peter Norvig diferencian varios
tipos de inteligencia artificial:
 Sistemas que piensan como humanos: automatizan actividades como la toma de
decisiones, la resolución de problemas y el aprendizaje. Un ejemplo son las redes
neuronales artificiales.
 Sistemas que actúan como humanos: se trata de computadoras que realizan tareas de
forma similar a como lo hacen las personas. Es el caso de los robots.
 Sistemas que piensan racionalmente: intentan emular el pensamiento lógico racional
de los humanos, es decir, se investiga cómo lograr que las máquinas puedan percibir,
razonar y actuar en consecuencia. Los sistemas expertos se engloban en este grupo.
 Sistemas que actúan racionalmente: idealmente, son aquellos que tratan de imitar de
manera racional el comportamiento humano, como los agentes inteligentes.
2.1.2. Aplicaciones Prácticas De La Inteligencia Artificial

La IA está presente en la detección facial de los móviles, en los asistentes virtuales de voz
como Siri de Apple, Alexa de Amazon o Cortana de Microsoft y está integrada en nuestros
dispositivos cotidianos a través de bots (abreviatura de robots) o aplicaciones para móvil, tales
como: Lyli, un personal shopper en versión digital; Parla, concebida para ayudarnos con el
aprendizaje de idiomas; Ems, diseñada para hacernos un poco más llevadera la ardua tarea de
encontrar nuevo piso; o Gyant, un asistente virtual de Facebook que emite 'diagnósticos'
médicos. El objetivo de todas ellas: hacer más fácil la vida de las personas.

Página 8 de 70
Los avances en IA ya están impulsando el uso del big data debido a su habilidad para procesar
ingentes cantidades de datos y proporcionar ventajas comunicacionales, comerciales y
empresariales que la han llevado a posicionarse como la tecnología esencial de las próximas
décadas. Transporte, educación, sanidad, cultura... ningún sector se resistirá a sus encantos.
Ilustración 1 Principales aplicaciones prácticas de la IA

Página 9 de 70
2.1.3. Ventajas y Desventajas de la Inteligencia Artificial

Ventajas
 En el ámbito laboral reduce los costos y salarios adicionales.
 Por resultar un atractivo, conlleva a generar más ingresos.
 Se han desarrollado aplicaciones que realizan tareas que el hombre nunca hubiera
podido hacer debido a su complejidad.
 Puede predecir situaciones a largo plazo.
 Reduce el tiempo que consume realizar cierta actividad.
 Lograr grandes hallazgos y avances.
Desventajas
 Por ser software, requieren de constantes actualizaciones (mantenimiento).
 Realizar estos sistemas expertos requiere de mucho tiempo y dinero.
 Crear máquinas que sean autosuficientes y puedan ir desplazando a la raza humana.
 El uso irracional y exagerado de esta tecnología podría conllevar a la dominación de
las máquinas sobre el hombre, como también llegar a depender mucho de ellas.
 El hombre se siente menos importante cuando una máquina o un sistema “lo supera”.
2.2 Sistemas Inteligentes

Un sistema inteligente es un programa de computación que reúne características y
comportamientos asimilables al de la inteligencia humana o animal. La expresión "sistema
inteligente" se usa a veces para sistemas inteligentes incompletos, por ejemplo para una casa
inteligente o un sistema experto. Un sistema inteligente completo incluye "sentidos" que le
permiten recibir información de su entorno. Puede actuar, y tiene una memoria para archivar el
resultado de sus acciones. Tiene un objetivo e, inspeccionando su memoria, puede aprender de su
experiencia. Aprende cómo lograr mejorar su rendimiento y eficiencia.
2.2.1. Capacidades requeridas

Para que un sistema inteligente pueda ser considerado completo, debe incluir diversas
funcionalidades que incluyan

Página 10 de 70
• Inteligencia: Hay muchas definiciones de "inteligencia". Para usos prácticos usamos

esta: La inteligencia es el nivel del sistema en lograr sus objetivos de los sistemas
inteligente.
• Sistematización: Un sistema es parte del universo, con una extensión limitada en
espacio y tiempo. Las partes del sistema tienen más, o más fuertes, correlaciones con
otras partes del mismo sistema; que con partes fuera del sistema.
• Objetivo: Un objetivo es una cierta situación que el sistema inteligente quiere lograr.
Normalmente hay muchos niveles de objetivos, puede haber un objetivo principal y
muchos subobjetivos.
• Capacidad sensorial: Un sentido es la parte del sistema que puede recibir
comunicaciones del entorno. Se necesitan los sentidos para que el sistema inteligente
puede conocer su entorno y actuar interactivamente.
• Conceptualización: Un concepto es el elemento básico del pensamiento. Es el
almacenamiento físico, material de información (en neuronas o electrones). Todos los
conceptos de la memoria están interrelacionados en red. La capacidad de
conceptualizar implica el desarrollo de niveles de abstracción.
• Reglas de actuación: Una regla de actuación es el resultado de una experiencia o el
resultado de interpretar la propia memoria. Relaciona situación y consecuencias de la
acción.
• Memoria: La memoria es un almacenaje físico de conceptos y reglas de actuación.
Esto incluye la experiencia del sistema.
• Aprendizaje: El aprendizaje es probablemente la capacidad más importante de un
sistema inteligente. El sistema aprende conceptos a partir de la información recibida
de los sentidos. Aprende reglas de actuación a base de su experiencia. La actuación, a
veces hecha al azar, se almacena con su valor. Una regla de actuación aumenta en
valor si permitió el logro de un objetivo. El aprendizaje incluye la fijación de
conceptos abstractos, a base de ejemplos concretos y la creación de conceptos
compuestos que contienen los conceptos de partes de un objeto. El aprendizaje
también es la capacidad de detectar relaciones (patrones) entre la parte "situación" y la
parte "situación futura" de una regla de actuación.

Página 11 de 70
2.3 Computación Evolutiva

La computación evolutiva (en adelante CE) es una de las ramas de la Inteligencia Artificial
que se aplica para la resolución de problemas de optimización combinatoria. La CE está
inspirada en los mecanismos de evolución biológica propuestos por Darwin, Medel y Lamark.
Sin entrar mucho en detalle sobre los estudios que hicieron estos científicos, solo vamos a
mencionar brevemente lo que propusieron. Darwin propuso la "Selección natural de los más
adaptados", Medel propuso la "Teoría corpuscular de la herencia" y Lamark propuso la
"Herencia de caracteres adquiridos".
El principal problema de la inteligencia artificial es que no tiene una definición fácil o formal,
pero para entendernos podemos decir que la inteligencia artificial es una rama que trata de
"imitar" a la inteligencia natural y por tanto la computación evolutiva se basa en imitar la
evolución biológica tal y como la entendemos hoy en día. Como puedes suponer la CE trata de
resolver problemas de optimización combinatoria, con el fin de encontrar el mejor resultado al
problema, es decir tal y como pasa en la naturaleza, ya que el gran problema que hay, sobre todo
en el entorno animal; es la supervivencia y solo los más fuertes y mejor adaptados al entorno son
capaces de sobrevivir y reproducirse; en otras palabras, son los mejores individuos posibles o la
mejor solución al problema.
Aunque podemos "rizar mucho el rizo" la computación evolutiva se basa en la siguiente
metáfora, denominada como metáfora evolutiva:
 Una población de individuos coexiste en un determinado entorno con recursos
limitados.
 La competición por los recursos provoca la selección de aquellos individuos que están
mejor adaptados al entorno.
 Estos individuos se convierten en los progenitores de nuevos individuos a través de
procesos de mutación y recombinación.
 Los nuevos individuos pasan a competir por su supervivencia.
 Con el paso del tiempo, esta selección natural provoca el incremento en la “calidad”
de los individuos de la población.

Página 12 de 70
Ilustración 2 Metáfora Evolutiva
Dentro de lo que es la computación evolutiva, se engloban diferentes estrategias para la

resolución de problemas de optimización. Estas estrategias son las siguientes:
 Procesos de Búsqueda Evolutiva: Fue propuesta por Alan Turing en el año 1948.
 Estrategias Evolutivas (EE): Propuesto por Rechenberg en 1964. Representan a los
individuos con Vectores reales.
 Programación Evolutiva (PE): Propuesto por Fogel en 1965. Utilizan máquinas de
estado finito.
 Algoritmos Genéticos (AG): Propuesto por Holland en 1975. Representan a los
individuos como cadenas binarias.
 Programación Genética (PG): Propuesto por Koza en 1992. Utilizan Arboles LISP.
Podemos decir que la diferencia que hay entre estos algoritmos evolutivos, es la forma en la
que representan a los individuos. Hay que decir que la diferencia entre este tipo de algoritmos es
irrelevante ya que conceptualmente hacen los mismo con distintas formas de representar a los
individuos, por lo tanto, lo mejor a la hora de utilizar los algoritmos evolutivos es elegir la
representación más adecuada y los operadores de variación más adecuados para resolver el
problema que tengamos que resolver.

Página 13 de 70
El esquema general de un algoritmo evolutivo lo mostramos en la siguiente imagen:
Ilustración 3 Esquema general de un algoritmo evolutivo
A continuación, mostramos el Pseudo-Código de un algoritmo evolutivo:
Ilustración 4 Pseudo-Codigo de algoritmo evolutivo

Página 14 de 70
Hasta ahora hemos visto a grandes rasgos en que se basa la CE y el Pseudocódigo de los
algoritmos evolutivos, pero ¿Cómo representamos a los individuos?, ¿Cómo se reproducen y
mutan los individuos? y ¿Qué es eso de que un "individuo es suficientemente bueno”? Pues
vamos a responder a estas preguntas:
2.3.1. ¿Cómo representamos a los individuos?

Basándonos en el conocimiento humano y haciendo una simplificación, diremos que cada
persona tiene una información genética única que se puede ver en el ADN de cada uno.
Estos ADN los forman 4 tipos de "elementos" que son la "Adenina" (A), "Timina" (T),
"Citosina" (C) y "Guanina" (G), con lo que haciendo una gran simplificación podemos decir que
las personas estamos representados por un "ARRAY" compuesto por alguno de estos 4
"elementos" con lo cual ya tenemos aquí una forma (o estructura de datos) para representar a los
individuos. Esto, pasado a un problema de optimización combinatoria, significa que un posible
resultado al problema lo podemos pasar a un array (por ejemplo, un array binario de ceros y
unos), al que le daremos un cierto significado.
A este array que representa a un individuo del problema o una posible solución, se le
denomina Cromosoma.
2.3.2. ¿Cómo se reproducen y mutan los individuos?
Siguiendo con las simplificaciones, podemos decir que el proceso de reproducción no es más
que crear un nuevo individuo a partir de dos individuos dados, es decir combinando los dos
arrays que representan a dos individuos. A continuación, ponemos un ejemplo que como
obtenemos un nuevo individuo a partir de dos:
Ilustración 5 Nuevo individuo a partir de dos

Página 15 de 70
A grandes rasgos es así como funciona la reproducción humana, ya que uno al nacer hereda
unas características de la madre y otras del padre. Como se ve no se tiene porque heredar en
partes iguales las características de los dos progenitores.
Por último, en lo referente a la generación de nuevo individuos, existe la posibilidad de que
"Mute" algún gen; es decir, que sin ninguna "lógica" (aunque supongo que biológicamente la
tendrá) un determinado elemento del cromosoma cambie de valor, por ejemplo, al valor
complementario:
Ilustración 6 Mutación
2.3.3. ¿Qué es eso de que un "individuo es suficientemente bueno"?

Como se ha comentado los Algoritmos Evolutivos sirven para resolver problemas de
optimización combinatoria, pero tambien se ha de decir que no siempre alcanzan la mejor
solución, por lo tanto, hay que definir un umbral a partir del cual consideramos que la solución
que buscamos es lo suficientemente buena. Este umbral se ha de obtener a partir de una "función
de evaluación" que se ha de definir siempre que se utilicen algoritmos evolutivos. Esta función
de evaluación es conocida como "Función de Fitness" aunque también se le suele denominar
función de calidad, función de aptitud o función objetivo.
Como decía, esta función de fitness evaluará lo bueno o malo que es un individuo (o posible
solución del problema) por lo tanto con esta función podemos utilizar dos estrategias para
obtener la mejor solución al problema en función del conocimiento que tengamos del problema:
 Si no tenemos mucha idea de la solución que nos dará el problema, pondremos el
algoritmo evolutivo a ejecutarse hasta que complete 'N' generaciones y en la
generación 'N' evaluaremos todos los individuos con la función de fitness y cogeremos

Página 16 de 70
como solución el individuo que mejor resultado nos haya dado con la función de
fitness.
 La segunda estrategia se utiliza cuando sabemos el umbral de calidad que queremos
alcanzar para la solución del problema. En este caso se iran ejecutando generaciones
(una por una) y tras cada generación se evaluarán todos los individuos con la función
de fitness y si alguno cumple un determinado umbral de calidad, se parará de ejecutar
el algoritmo, al haber alcanzado una buena solución.
2.3.4. Aplicaciones
La Computación evolutiva constituye una de las áreas más activas de la llamada “inteligencia
computacional”, que agrupa además las redes neuronales y los sistemas difusos (del Inglés fuzzy
systems). Estas técnicas han logrado un gran número de aplicaciones exitosas en la industria y el
comercio. Los algoritmos evolutivos se han utilizado también como herramientas de modelaje y
resolución de problemas en las ciencias naturales.
2.4 Algoritmos Genéticos

Un algoritmo genético (AG) es una técnica de resolución de problemas que imita a la
evolución biológica como estrategia para resolver problemas, englobándose dentro de lo que
antes hemos denominado técnicas basadas en poblaciones.
Dado un problema específico a resolver, la entrada del AG es un conjunto de soluciones
potenciales a ese problema, codificadas de alguna manera, y una métrica llamada función de
aptitud, o fitness, que permite evaluar cuantitativamente a cada solución candidata. Estas
candidatas pueden ser soluciones que ya se sabe que funcionan, con el objetivo de que el AG las
mejore, pero se suelen generar aleatoriamente.
A partir de ahí, el AG evalúa cada candidata de acuerdo con la función de aptitud. Por
supuesto, se debe tener en cuenta que estas primeras candidatas generadas aleatoriamente,
tendrán una eficiencia mínima con respecto a la resolución del problema, y la mayoría no
funcionarán en absoluto. Sin embargo, por puro azar, unas pocas pueden ser prometedora,
pudiendo mostrar algunas características que muestren, aunque sólo sea de una forma débil e
imperfecta, cierta capacidad de solución del problema.

Página 17 de 70
Estas candidatas prometedoras se conservan y se les permite reproducirse. Se realizan

múltiples copias de ellas, pero estas copias no son perfectas, sino que se les introducen algunos
cambios aleatorios durante el proceso de copia, a modo de las mutaciones que pueden sufrir los
descendientes de una población.
Luego, esta descendencia digital prosigue con la siguiente generación, formando un nuevo
conjunto de soluciones candidatas, y son de nuevo sometidas a una ronda de evaluación de
aptitud.
Las candidatas que han empeorado o no han mejorado con los cambios en su código son
eliminadas de nuevo; pero, de nuevo, por puro azar, las variaciones aleatorias introducidas en la
población pueden haber mejorado a algunos individuos, convirtiéndolos en mejores soluciones
del problema, más completas o más eficientes.
El proceso se repite las iteraciones que haga falta, hasta que obtengamos soluciones
suficientemente buenas para nuestros propósitos.
Ilustración 7 Funcionamiento Algoritmos Genéticos
Aunque a algunos les puede parecer asombroso y anti intuitivo, los algoritmos genéticos han
demostrado ser una estrategia enormemente poderosa y exitosa para resolver problemas,
demostrando de manera espectacular el poder de los principios evolutivos. Se han utilizado
algoritmos genéticos en una amplia variedad de campos para desarrollar soluciones a problemas

Página 18 de 70
tan difíciles o más difíciles que los abordados por los diseñadores humanos. Además, las
soluciones que consiguen son a menudo más eficientes, más elegantes o más complejas que las
que un humano produciría.
2.4.1. Métodos de representación

Antes de que un algoritmo genético pueda ponerse a trabajar en un problema, se necesita un
método para codificar las soluciones potenciales del problema de forma que el propio algoritmo
pueda procesarlas aplicando las operaciones que le permiten evolucionar.
 Un enfoque común es codificar las soluciones como cadenas binarias: secuencias de
1's y 0's, donde el dígito de cada posición representa el valor de algún aspecto de la
solución.
 Otro método similar consiste en codificar las soluciones como cadenas de enteros o
números decimales, donde cada posición, de nuevo, representa algún aspecto
particular de la solución. Este método permite una mayor precisión y complejidad que
el método comparativamente restringido de utilizar sólo números binarios, y a menudo
está intuitivamente más cerca del espacio de problemas' (Fleming y Purshouse 2002
[3], p 1.228). Esta técnica se utilizó, por ejemplo, en el trabajo de Steffen Schulze-
Kremer, que escribió un algoritmo genético para predecir la estructura tridimensional
de una proteína, basándose en la secuencia de aminoácidos que la componen (Mitchell
1996 [47], p. 62).
 Un tercer método consiste en representar a los individuos de un AG como cadenas de
letras, donde cada letra, de nuevo, representa un aspecto específico de la solución. Un
ejemplo de esta técnica es el método basado en "codificación gramática" de Hiroaki
Kitano (Mitchell 1996 [47], p. 74).
La virtud de estos tres métodos es que facilitan la definición de operadores que causen los
cambios aleatorios en las candidatas seleccionadas: cambiar un 0 por un 1 o viceversa, sumar o
restar al valor de un número una cantidad elegida al azar, o cambiar una letra por otra.
 Otra estrategia, desarrollada principalmente por John Koza, de la Universidad de
Stanford, y denominada programación genética, representa a los programas como
estructuras de datos ramificadas llamadas árboles (Koza et al. 2003 [42], p. 35). En

Página 19 de 70
este método, los cambios aleatorios pueden generarse cambiado el operador, alterando
el valor de un cierto nodo del árbol, o sustituyendo un subárbol por otro.
2.4.2. Métodos de selección

Un algoritmo genético puede utilizar muchas técnicas diferentes para seleccionar a los
individuos que deben copiarse hacia la siguiente generación. A continuación, mostramos una
breve explicación de los más habituales (debe tenerse en cuenta de que algunos son mutuamente
excluyentes, mientras que otros se pueden combinar):
 Selección elitista: se garantiza la selección de los miembros más aptos de cada
generación. (La mayoría de los AGs no utilizan elitismo puro, sino que usan una
forma modificada por la que el individuo mejor, o algunos de los mejores, son
copiados hacia la siguiente generación en caso de que no surja nada mejor).
 Selección proporcional a la aptitud: los individuos más aptos tienen más
probabilidad de ser seleccionados, pero no la certeza.
 Selección por rueda de ruleta: una forma de selección proporcional a la aptitud en la
que la probabilidad de que un individuo sea seleccionado es proporcional a la
diferencia entre su aptitud y la de sus competidores.
 Selección escalada: al incrementarse la aptitud media de la población, la fuerza de la
presión selectiva también aumenta y la función de aptitud se hace más discriminadora.
Este método puede ser útil para seleccionar más tarde, cuando todos los individuos
tengan una aptitud relativamente alta y sólo les distingan pequeñas diferencias en la
aptitud.
 Selección por torneo: se eligen subgrupos de individuos de la población, y los
miembros de cada subgrupo compiten entre ellos. Sólo se elige a un individuo de cada
subgrupo para la reproducción.
 Selección por rango: a cada individuo de la población se le asigna un rango numérico
basado en su aptitud, y la selección se basa en este ranking, en lugar de las diferencias
absolutas en aptitud. La ventaja de este método es que puede evitar que individuos
muy aptos ganen dominancia al principio a expensas de los menos aptos, lo que

Página 20 de 70
reduciría la diversidad genética de la población y podría obstaculizar la búsqueda de

una solución aceptable.
 Selección generacional: la descendencia de los individuos seleccionados en cada
generación se convierte en toda la siguiente generación. No se conservan individuos
entre las generaciones.
 Selección jerárquica: los individuos atraviesan múltiples rondas de selección en cada
generación. Las evaluaciones de los primeros niveles son más rápidas y menos
discriminatorias, mientras que los que sobreviven hasta niveles más altos son
evaluados más rigurosamente. La ventaja de este método es que reduce el tiempo total
de cálculo al utilizar una evaluación más rápida y menos selectiva para eliminar a la
mayoría de los individuos que se muestran poco o nada prometedores, y sometiendo a
una evaluación de aptitud más rigurosa y computacionalmente más costosa sólo a los
que sobreviven a esta prueba inicial.
2.4.3. Métodos de cambio

Una vez que la selección ha elegido a los individuos aptos, éstos deben ser alterados
aleatoriamente con la esperanza de mejorar su aptitud para la siguiente generación. Existen dos
estrategias básicas para realizar esta tarea:
 La primera y más sencilla es la que se conoce como mutación. Al igual que una
mutación en los seres vivos cambia un gen por otro, una mutación en un algoritmo
genético también causa pequeñas alteraciones en puntos concretos de la codificación
del individuo.
Ilustración 8 Estrategia de Mutación

Página 21 de 70
 El segundo método se llama cruzamiento, y consiste en seleccionar a dos individuos

para que intercambien segmentos de su código genético, produciendo una
"descendencia" artificial cuyos individuos son combinaciones de sus padres. Este
proceso pretende simular el proceso análogo de la recombinación que se da en los
cromosomas durante la reproducción sexual. Las formas comunes de cruzamiento
incluyen al cruzamiento de un punto, en el que se establece un punto de intercambio
en un lugar aleatorio del genoma de los dos individuos, y uno de los individuos
contribuye todo su código anterior a ese punto y el otro individuo contribuye todo su
código a partir de ese punto para producir una descendencia, y al cruzamiento
uniforme, en el que el valor de una posición dada en el genoma de la descendencia
corresponde al valor en esa posición del genoma de uno de los padres o al valor en esa
posición del genoma del otro padre, elegido con un 50% de probabilidad.
Ilustración 9 Estrategia de Cruzamiento
2.4.4. Ventajas y Desventajas de los algoritmos genéticos

Ventajas de los algoritmos genéticos
Los algoritmos genéticos poseen varias características que los hacen altamente deseables para
problemas de optimización:
 No requieren conocimientos específicos del problema para llevar a cabo la búsqueda
 Usan operadores aleatorios en vez de operadores determinísticos, lo que hace que la
convergencia de la técnica varíe con respecto al tiempo.

Página 22 de 70
 Operan de forma simultánea con varias soluciones, tomando información de varios

puntos del espacio de búsqueda como guía.
 Resultan menos afectados por los máximos locales que las técnicas de búsqueda
tradicionales.
Desventajas de los algoritmos genéticos
 El lenguaje que se debe utilizar debe tener la capacidad de tolerar cambios aleatorios;
que no lleguen a producir resultados sin sentido o errores fatales.
 Pueden tardar mucho en converger, o no converger en absoluto, dependiendo en cierta
medida de los parámetros que se utilicen tamaño de la población, número de
generaciones, etc.
 Pueden converger prematuramente debido a una serie de problemas de diversa índole.
2.4.5. Algunos ejemplos específicos de AG
Mientras el poder de la evolución gana reconocimiento cada vez más generalizado, los
algoritmos genéticos se utilizan para abordar una amplia variedad de problemas en un conjunto
de campos sumamente diverso, demostrando claramente su capacidad y su potencial. Esta
sección analizará algunos de los usos más notables en los que han tomado parte.
Acústica
Sato et al. 2002 utilizaron algoritmos genéticos para diseñar una sala de conciertos con
propiedades acústicas óptimas, maximizando la calidad del sonido para la audiencia, para el
director y para los músicos del escenario. Esta tarea implica la optimización simultánea de
múltiples variables. Comenzando con una sala con forma de caja de zapatos, el AG de los
autores produjo dos soluciones no dominadas, ambas descritas como ``con forma de hoja''. Los
autores afirman que estas soluciones tienen proporciones similares al Grosser Musikvereinsaal
de Viena, el cual está considerado generalmente como una de las mejores -si no la mejor- salas
de conciertos del mundo, en términos de propiedades acústicas.
Porto, Fogel y Fogel 1995 utilizaron programación evolutiva para adiestrar a redes neuronales
para distinguir entre reflexiones sonoras desde distintos tipos de objetos: esferas metálicas
hechas por el hombre, montañas submarinas, peces y plantas, y ruido aleatorio de fondo. Tras
500 generaciones, la mejor red neuronal que evolucionó tenía una probabilidad de clasificación
correcta que iba desde el 94% al 98%, y una probabilidad de clasificación errónea entre un 7,4%

Página 23 de 70
y un 1,5%, que son ``probabilidades razonables de detección y falsa alarma'' (p. 21). Esta red
evolucionada igualó las prestaciones de otra red desarrollada mediante recocido simulado, y
superó consistentemente a redes entrenadas mediante propagación hacia atrás, las cuales ``se
atascaban repetidamente en conjuntos de pesos subóptimos que no producían resultados
satisfactorios''. En contraste, ambos métodos estocásticos demostraron su capacidad para superar
estos óptimos locales y producir redes más pequeñas, efectivas y robustas; pero los autores
sugieren que el algoritmo evolutivo, a diferencia del recocido simulado, opera sobre una
población, y por tanto se beneficia de la información global sobre el espacio de búsqueda,
conduciendo potencialmente hacia un rendimiento mayor a la larga.
Ingeniería aeroespacial
Obayashi et al. 2000 utilizaron un algoritmo genético de múltiples objetivos para diseñar la
forma del ala de un avión supersónico. Hay tres consideraciones principales que determinan la
configuración del ala -minimizar la resistencia aerodinámica a velocidades de vuelo
supersónicas, minimizar la resistencia a velocidades subsónicas y minimizar la carga
aerodinámica (la fuerza que tiende a doblar el ala). Estos objetivos son mutuamente exclusivos, y
optimizarlos todos simultáneamente requiere realizar contrapartidas.
Astronomía y astrofísica
Charbonneau 1995 sugiere la utilidad de los AGs para problemas de astrofísica, aplicándolos
a tres problemas de ejemplo: obtener la curva de rotación de una galaxia basándose en las
velocidades rotacionales observadas de sus componentes, determinar el periodo de pulsación de
una estrella variable basándose en series de datos temporales, y sacar los valores de los
parámetros críticos de un modelo magnetohidrodinámico del viento solar. Son tres difíciles
problemas no lineales y multidimensionales.
El algoritmo genético de Charbonneau, PIKAIA, utiliza selección generacional y proporcional
a la aptitud, junto con elitismo, para asegurar que el mejor individuo se copia una vez hacia la
siguiente generación sin ninguna modificación. PIKAIA tiene un ritmo de cruzamiento de 0,65 y
un ritmo de mutación variable que se pone a 0,003 inicialmente y luego aumenta gradualmente,
mientras la población se aproxima a la convergencia, para mantener la variabilidad en el acervo
genético.

Página 24 de 70
Química
Un pulso láser ultracorto de alta energía puede romper moléculas complejas en moléculas más
sencillas, un proceso con aplicaciones importantes en la química orgánica y la microelectrónica.
Los productos específicos de una reacción así pueden controlarse modulando la fase del pulso
láser. Sin embargo, para moléculas grandes, obtener la forma del pulso deseado de manera
analítica es demasiado difícil: los cálculos son demasiado complejos y las características
relevantes (las superficies de energía potencial de las moléculas) no se conocen con suficiente
precisión.
Assion et al. 1998 resolvieron este problema utilizando un algoritmo evolutivo para diseñar la
forma del pulso. En lugar de introducir información compleja, específica del problema, sobre las
características cuánticas de las moléculas iniciales, para diseñar el pulso conforme a las
especificaciones, el AE dispara un pulso, mide las proporciones de las moléculas producto
resultantes, muta aleatoriamente las características del rayo con la esperanza de conseguir que
estas proporciones se acerquen a la salida deseada, y el proceso se repite. (En lugar de afinar
directamente las características del rayo láser, el AG de los autores representa a los individuos
como un conjunto de 128 números, en el que cada número es un valor de voltaje que controla el
índice de refracción de uno de los pixeles del modulador láser. De nuevo, no se necesita un
conocimiento específico del problema sobre las propiedades del láser o de los productos de la
reacción). Los autores afirman que su algoritmo, cuando se aplica a dos sustancias de muestra,
`èncuentra automáticamente la mejor configuración... no importa lo complicada que sea la
respuesta molecular'', demostrando un ``control coherente automatizado de los productos que son
químicamente diferentes uno del otro y de la molécula padre''.
Ingeniería eléctrica
Una matriz de puertas programable en campo (Field Programmable Gate Array, o FPGA), es
un tipo especial de placa de circuito con una matriz de celdas lógicas, cada una de las cuales
puede actuar como cualquier tipo de puerta lógica, interconectado con conexiones flexibles que
pueden conectar celdas. Estas dos funciones se controlan por software, así que, simplemente
cargando un programa especial en la placa, puede alterarse al vuelo para realizar las funciones de
cualquier dispositivo de hardware de la amplia variedad existente.

Página 25 de 70
El Dr. Adrian Thompson ha explotado este dispositivo, en conjunción con los principios de la
evolución, para producir un prototipo de circuito reconocedor de voz que puede distinguir y
responder a órdenes habladas utilizando sólo 37 puertas lógicas -una tarea que se habría
considerado imposible para cualquier ingeniero humano. Generó cadenas aleatorias de bits de
ceros y unos y las utilizó como configuraciones de la FPGA, seleccionando los individuos más
aptos de cada generación, reproduciéndolos y mutándolos aleatoriamente, intercambiando
secciones de su código y pasándolo hacia la siguiente ronda de selección. Su objetivo era
evolucionar un dispositivo que pudiera en principio discriminar entre tonos de frecuencias
distintas (1 y 10 kilohercios), y luego distinguir entre las palabras habladas ``go'' (adelante) y
``stop'' (para).
Mercados financieros
Mahfoud y Mani 1996 utilizaron un algoritmo genético para predecir el rendimiento futuro de
1.600 acciones ofertadas públicamente. Concretamente, al AG se le asignó la tarea de predecir el
beneficio relativo de cada acción, definido como el beneficio de esa acción menos el beneficio
medio de las 1.600 acciones a lo largo del periodo de tiempo en cuestión, 12 semanas (un cuarto
del calendario) en el futuro. Como entrada, al AG se le proporcionaron datos históricos de cada
acción en forma de una lista de 15 atributos, como la relación precio-beneficio y el ritmo de
crecimiento, medidos en varios puntos del tiempo pasado; se le pidió al AG que evolucionara un
conjunto de reglas si/entonces para clasificar cada acción y proporcionar, como salida, una
recomendación sobre qué hacer con respecto a la acción (comprar, vender o ninguna predicción)
y un pronóstico numérico del beneficio relativo. Los resultados del AG fueron comparados con
los de un sistema establecido, basado en una red neuronal, que los autores habían estado
utilizando para pronosticar los precios de las acciones y administrar las carteras de valores
durante tres años. Por supuesto, el mercado de valores es un sistema extremadamente ruidoso y
no lineal, y ningún mecanismo predictivo puede ser correcto el 100% del tiempo; el reto consiste
en encontrar un predictor que sea preciso más de la mitad de las veces.
Juegos
Una de las demostraciones más novedosas y persuasivas de la potencia de los algoritmos
genéticos la presentaron Chellapilla y Fogel 2001, que utilizaron un AG para evolucionar redes
neuronales que pudieran jugar a las damas. Los autores afirman que una de las mayores

Página 26 de 70
dificultades en este tipo de problemas relacionados con estrategias es el problema de la

asignación de crédito -en otras palabras, ¿cómo escribir una función de aptitud? Se ha creído
ampliamente que los criterios simples de ganar, perder o empatar no proporcionan la suficiente
información para que un algoritmo genético averigüe qué constituye el buen juego.
Geofísica
Sambridge y Gallaguer 1993 utilizaron un algoritmo genético para los hipocentros de los
terremotos basándose en datos sismológicos. (El hipocentro es el punto bajo la superficie
terrestre en el que se origina un terremoto. El epicentro es el punto de la superficie directamente
encima del hipocentro). Esto es una tarea sumamente compleja, ya que las propiedades de las
ondas sísmicas dependen de las propiedades de las capas de roca a través de las que viajan. El
método tradicional para localizar el hipocentro se basa en lo que se conoce como algoritmo de
inversión sísmico, que empieza con la mejor estimación de la ubicación, calcula las derivadas del
tiempo de viaje de la onda con respecto al punto de origen, y realiza una operación de matriz
para proporcionar una ubicación actualizada. Este proceso se repite hasta que se alcanza una
solución aceptable. (Este Mensaje del Mes, de noviembre de 2003, proporciona más
información). Sin embargo, este método requiere información diferencial y es propenso a quedar
atrapado en óptimos locales.
Un algoritmo de localización que no dependa de información diferencial o modelos de
velocidad puede evitar esta deficiencia calculando sólo el problema directo -la diferencia entre
los tiempos de llegada de la onda observados y predichos para distintas localizaciones del
hipocentro. Sin embargo, un método de búsqueda exhaustivo basado en este método sería
demasiado costoso computacionalmente. Éste, por supuesto, es precisamente el tipo de problema
de optimización en el que destacan los algoritmos genéticos. Como todos los AGs, el propuesto
por el artículo citado es paralelo en naturaleza -en lugar de mover un solo hipocentro más y más
cerca hacia la solución, comienza con una nube de hipocentros potenciales que encoge con el
tiempo hasta converger en una sola solución. Los autores afirman que su método ``puede
localizar rápidamente soluciones casi óptimas sin una búsqueda exhaustiva del espacio de
parámetros'', muestra `ùn comportamiento muy organizado que produce una búsqueda eficiente''
y es `ùn compromiso entre la eficiencia de los métodos basados en derivadas y la robustez de
una búsqueda exhaustiva completamente no lineal''.

Página 27 de 70
Ingeniería de materiales
Giro, Cyrillo y Galvão 2002 utilizaron algoritmos genéticos para diseñar polímeros
conductores de electricidad basados en el carbono, conocicos como polianilinas. Estos
polímeros, un tipo de material sintético inventado recientemente, tienen ``grandes aplicaciones
tecnológicas potenciales'' y podrían abrir la puerta a ``nuevos fenómenos físicos fundamentales''
(p. 170). Sin embargo, debido a su alta reactividad, los átomos de carbono pueden formar un
número virtualmente infinito de estructuras, haciendo que la búsqueda de nuevas moléculas con
propiedades interesantes sea del todo imposible. En este artículo, los autores aplican un enfoque
basado en AGs a la tarea de diseñar moléculas nuevas con propiedades especificadas a priori,
comenzando con una población de candidatos iniciales generada aleatoriamente. Concluyen que
su metodología puede ser una ``herramienta muy efectiva'' (p. 174) para guiar a los
investigadores en la búsqueda de nuevos compuestos y es lo suficientemente general para que
pueda extenderse al diseño de nuevos materiales que pertenezcan virtualmente a cualquier tipo
de molécula.
Matemáticas y algoritmia
Aunque algunas de las aplicaciones más prometedoras y las demostraciones más convincentes
de la potencia de los AGs se encuentran en el campo de la ingeniería de diseño, también son
relevantes en problemas ``puramente'' matemáticos. Haupt y Haupt 1998 describen el uso de
AGs para resolver ecuaciones de derivadas parciales no lineales de alto orden, normalmente
encontrando los valores para los que las ecuaciones se hacen cero, y dan como ejemplo una
solución casi perfecta para los coeficientes de la ecuación de quinto orden conocida como Super
Korteweg-de Vries.
Ejército y cumplimiento de la ley
Kewley y Embrechts 2002 utilizaron algoritmos genéticos para evolucionar planes tácticos
para las batallas militares. Los autores señalan que ``planear una batalla militar táctica es una
tarea compleja multidimensoinal que a menudo atormenta a los profesionales experimentados'',
no sólo porque este tipo de decisiones a menudo se toman bajo condiciones de mucho estrés,
sino también porque hasta los planes más sencillos requieren tomar en cuenta un gran número de
variables y consecuencias: minimizar las bajas amigas, maximizar las bajas enemigas, controlar
el terreno deseado, conservar recursos, etcétera. Los planificadores humanos tienen dificultades

Página 28 de 70
al tratar con las complejidades de esta tarea y a menudo deben recurrir a métodos ``rápidos y
sucios'', como hacer lo que funcionase la última vez.
Para superar estas dificultades, los autores del artículo citado desarrollaron un algoritmo
genético para automatizar la creación de planes de batalla, en conjunción con un programa
gráfico de simulación de batallas. El comandante introduce el resultado deseado y el AG
evoluciona automáticamente un plan de batalla; en la simulación utilizada, se tomaron en cuenta
factores como la topografía del terreno, la cobertura vegetal, la velocidad del movimiento de
tropas, y la precisión en los disparos. En este experimento también se utilizó la coevolución para
mejorar la calidad de las soliciones: los planes de batalla de las fuerzas enemigas evolucionaron
simultáneamente con los planes amigos, forzando al AG a corregir cualquier debilidad de su plan
que pudiese explotar el enemigo. Para medir la calidad de las soluciones producidas por el AG,
se compararon con planes de batalla para el mismo escenario producidos por un grupo de
`èxpertos militares experimentados... considerados muy capaces de desarrollar planes de acción
para el tamaño de las fuerzas utilizadas en este experimento''. Estos avezados expertos
desarrollaron su propio plan y, cuando la solución del AG estuvo acabada, se les dio la
oportunidad de examinarla y modificarla como vieran conveniente. Finalmente, todos los planes
se ejecutaron varias veces en el simulador para determinar su calidad media.
Robótica
El torneo internacional RoboCup es un proyecto para promocionar el avance de la robótica, la
inteligencia artificial y los campos relacionados, proporcionando un problema estándar con el
que probar las nuevas tecnologías -concretamente, es un campeonato anual de fútbol entre
equipos de robots autónomos. (El objetivo fijado es desarrollar un equipo de robots humanoides
que puedan vencer al equipo humano de fútbol que sea campeón del mundo en 2050;
actualmente, la mayoría de los equipos de robots participantes funcionan con ruedas). Los
programas que controlan a los miembros del equipo robótico deben exhibir un comportamiento
complejo, decidiendo cuándo bloquear, cuándo tirar, cómo moverse, cuándo pasar la pelota a un
compañero, cómo coordinar la defensa y el ataque, etcétera. En la liga simulada de 1997, David
Andre y Astro Teller inscribieron a un equipo llamado Darwin United cuyos programas de
control habían sido desarrollados automáticamente desde cero mediante programación genética,

Página 29 de 70
un desafío a la creencia convencional de que `èste problema es simplemente demasiado difícil

para una técnica como ésa'' (Andre y Teller 1999[3], p. 346).
Para resolver este difícil problema, Andre y Teller le proporcionaron al programa genético un
conjunto de funciones de control primitivas como girar, moverse, tirar, etcétera. (Estas funciones
estaban también sujetas al cambio y refinamiento durante el curso de la evolución). Su función
de aptitud, escrita para que recompensara el buen juego en general en lugar de marcar goles
expresamente, proporcionaba una lista de objetivos cada vez más importantes: acercarse a la
pelota, golpear la pelota, conservar la pelota en el campo contrario, moverse en la dirección
correcta, marcar goles y ganar el partido.
Diseño de rutas y horarios
Burke y Newall 1999 utilizaron algoritmos genéticos para diseñar los horarios de los
exámenes universitarios. Se sabe que, en general, el problema del horario es NP-completo, lo que
significa que no se conoce un método para hallar con garantías una solución óptima en un tiempo
razonable. En un problema así, hay restricciones duras -no puede asignarse la misma aula a dos
exámenes a la vez- y restricciones suaves -si es posible, no deben asignarse varios exámenes en
sucesión a un mismo estudiante, para minimizar la fatiga.
Las restricciones duras deben satisfacerse, mientras que las restricciones suaves deben
satisfacerse lo máximo posible. Los autores llaman `àlgoritmo memético'' a su método híbrido
para resolver este problema: un algoritmo evolutivo con selección por rango proporcional a la
aptitud, combinado con un trepacolinas local para optimizar las soluciones halladas por el AE. El
AE se utilizó en cuatro conjuntos de datos de universidades reales (la menor de las cuales tenía
25.000 alumnos), y sus resultados se compararon con los resultados producidos por un método
heurístico de vuelta atrás, un algoritmo muy consolidado que se encuentra entre los mejores que
se conocen para este problema y que se utiliza en varias universidades. Comparado con este
método, el AE produjo un resultado con una reducción de la penalización bastante uniforme del
40%.
Ingeniería de sistemas
Benini y Toffolo 2002[10] aplicaron un algoritmo genético a la tarea multiobjetivo de diseñar
molinos eólicos para generar energía eléctrica. Este diseño `ès un procedimiento complejo
caracterizado por varias decisiones sobre contrapartidas... El proceso de toma de decisiones es

Página 30 de 70
muy difícil y no hay tendencias de diseño bien establecidas''; como resultado, hoy existen varios
tipos de turbina distintos y no hay acuerdo sobre cuál es la óptima, si alguna lo es.
Deben tomarse en cuenta objetivos mutuamente exclusivos como la producción máxima de
energía anual y el coste mínimo de la energía.
En este artículo se utilizó un algoritmo evolutivo multiobjetivo para encontrar el mejor
conjunto de contrapartidas entre estos objetivos, construyendo palas de molino con una
configuración óptima de características como la velocidad de la punta de la pala, la razón
buje/punta, y la distribución de cuerda y giro. Al final, al AG consiguió encontrar soluciones
competitivas con los diseños comerciales, además de dilucidar más claramente los márgenes
entre los que se puede aumentar la producción anual de energía sin producir diseños demasiado
caros.
2.5 Mastemind
Mastermind (Español "Mente maestra") es un juego de mesa, de ingenio y reflexión, para dos
jugadores. Mastermind es actualmente una marca comercial propiedad de Pressman Toys; el
origen puede derivar de un juego tradicional inglés denominado Toros y vacas, se jugaba sobre
papel: los "toros" equivalían a las fichas negras, y las "vacas" a las blancas.
Ilustración 10 Mastermind

Página 31 de 70
2.5.1. Elementos Que Componen El Juego

Tablero compuesto por:
• 12 filas de agujeros grandes para las clavijas de colores.
• 12 filas de agujeros pequeños para las espigas blancas y negras.
• 5 agujeros para ocultar con el escudo el código secreto.
• 2 filas para las clavijas rojas y azules, para anotar los tanteos.
• 1 Compartimento grande para las clavijas de colores.
• 1 Compartimento para las espigas blancas y negras.
Aparte del tablero:
• 1 Escudo para ocultar el código secreto.
• 192 clavijas grandes de diferentes colores (Rojas, azules, verdes,
 amarillas, rosas, blancas, negras y marrones).
• 60 espigas blancas y negras para la clave.
• 4 espigas de tanteo, 2 rojas y 2 azules.
2.5.2. Como Se Juega
En Mastermind compiten 2 jugadores, uno de ellos creará un código oculto con 5 clavijas de
colores, pudiendo hacer las combinaciones con los 8 colores disponibles e incluso repitiendo
color si lo desea.
El código de colores debe de ocultarse con el escudo para que no pueda verlo el oponente, que
deberá acertar en el menor número posible de jugadas la clave para obtener una buena
puntuación.
Para descifrar el código secreto de colores el jugador deberá ir probando combinaciones
aleatorias de colores, y en cada combinación, el jugador contrario debe darle pistas mediante las
espigas blancas y negras.
Por cada clavija acertada en color y posición, colocará una espiga negra, y por cada color
acertado, pero en un lugar equivocado colocará una espiga blanca.
Termina al averiguarse la combinación (es decir, se consigue una combinación con cuatro
negras), o bien se agota el tablero (depende del tamaño, aunque generalmente son 15
combinaciones).

Página 32 de 70
2.6. Metodologías
2.6.1. Metodología en Cascada
El modelo de desarrollo de Software en cascada, es una metodología de la programación
muy antigua. Si bien su creador nunca lo menciona como metodología en cascada, el
funcionamiento y lineamiento de los procesos de la planeación, son exactamente iguales.
Básicamente, el estilo del modelo en cascada, es que no podrás avanzar a la siguiente fase, si la
anterior no se encuentra totalmente terminada, pues no tiene por qué haber vuelta atrás. Vamos a
ver cuáles son las fases de desarrollo de software del modelo en cascada, para que te puedas dar
una idea.
1. Análisis de Requisitos. El primer nivel del modelo cascada, es el análisis de requisitos.
Básicamente lo que se documenta aquí, son los objetivos de lo que el software debe hacer
al terminar el desarrollo, sin entrar en detalles de la parte interna, los cuales se verán
durante el proceso. Sin embargo, es importante señalar que una vez avanzado el paso de
análisis, no puede haber vuelta atrás, pues la metodología para el diseño de software con
la cual se trabaja no lo permitirá.
2. Diseño del Sistema. Todo lo que conlleva el armado de un diseño para el sistema que
vayas a utilizar, es lo que continua después del análisis de requisitos. Aquí se elaborará lo
que es la estructura del sistema y se determinarán las especificaciones para cada una de las
partes del sistema que se planea desarrollar. Siendo del mismo modo, una fase a la cual ya
no se podrá volver después de haber bajado al nivel 3.
3. Diseño del Programa. En este punto, aún no ingresamos a lo que es la escritura de
código, sin embargo, ya se realizan los algoritmos que se van a utilizar en la
programación. Si bien recuerdas, un algoritmo no necesariamente es código, simplemente
tomas una hoja de papel y escribes el algoritmo que vas a utilizar. Esto es precisamente lo
que se realiza en el paso número 3.
4. Codificación. Seguramente como programador, esta es la parte que estabas esperando,
pues ahora es momento de empezar a escribir todo el código que será necesario para el
desarrollo del software. Para este punto, la velocidad y el tiempo que se requiera,
dependerá mucho del lenguaje de programación que vayas a utilizar. Pues algunos
lenguajes de programación permiten utilizar componente, bibliotecas e incluso algunas

Página 33 de 70
funciones para reutilizar código, las cuales podrán acelerar el proceso de codificación en
gran manera.
5. Ejecución de Pruebas. La codificación ha terminado y ahora es momento de verificar
que nuestro sistema es realmente funciona, antes de que el cliente empiece a utilizarlo.
Este es precisamente el objetivo de la fase 5 de pruebas. Aquí es recomendable que
intentes mover lo más que se pueda tu software, con el objetivo de dañarlo
intencionalmente, de este modo, si supera las pruebas de daño realizadas por tí, entonces
estará listo para el usuario final.
6. Verificación. Después de haber realizado una gran cantidad de pruebas en la Fase 5,
debemos migrar a la verificación. Esta fase consiste en la ejecución del Software por parte
del usuario final. Si la fase cinco se realizó correcta y profundamente, el software no
tendrá ningún tipo de problema y el usuario final quedará satisfecho con el resultado.
7. Mantenimiento. Seguramente te has dado cuenta, de que las aplicaciones o el software
actual, constantemente se está actualizando. Esto se debe principalmente a que se le da
mantenimiento al software, se solucionan errores, se quitan algunos bugs, se añaden
funcionalidades, todo después de que el usuario final ya lo ha probado y utilizado en su
fase final. Esta es posiblemente una de las fases más tediosas del modelo de desarrollo de
software, pues debes estar atento a los comentarios de los usuarios, para ver qué cosas son
las que no funcionan correctamente y a las cuales hay que darles mantenimiento.
2.6.2. Método de Prototipos

Esta metodología de la programación todavía sigue siendo la favorita de muchos. Consiste
básicamente en que en base a los requerimientos y necesidades que tiene el cliente, se realiza de
forma rápida un prototipo, este no vendrá completo ni mucho menos terminado, pero si permitirá
contar con las bases necesarias para que cualquier programador pueda seguir trabajando en el
hasta llegar al código final.
Por si no lo sabes aún, un prototipo es una versión no terminada del producto que se le
entregará al cliente o usuario final. Esto nos genera cierta ventaja en el desarrollo de productos
similares con funciones distintas, por ejemplo. Supongamos que vas a desarrollar un proyecto
para 3 clientes distintos, ambos con una estructura idéntica, pero con funcionalidades muy

Página 34 de 70
distintas, entonces lo que hacemos es crear un prototipo base y entorno al mostrarlo a nuestros
clientes para que de ahí se empiecen a desarrollar las demás funciones.
Mejor vamos a ver cuáles son las etapas de desarrollo de software por las cuales tendrás que
pasar, en caso de utilizar la metodología de prototipos.
1. Planeación. A diferencia de otras metodologías, la planeación debe ser muy rápida, en
esta fase no puedes demorarte mucho, pues recuerda que solamente será un prototipo por
el momento.
2. Modelado. Nuevamente, una fase que deberá ser suficientemente rápida como para que
no nos quite nada de tiempo. Hacer el modelado será simple y te sigo recordando que
solamente es un prototipo, al menos por ahora.
3. Elaboración del Prototipo. Ya que contamos con la planeación de lo que vamos a
realizar y el modelado rápido, entonces es momento de elaborar el prototipo. Para esta
instancia, ya no te diré que lo debes hacer rápido, puesto que te tomará el tiempo que
tenga sea necesario elaborarlo, recuerda que este ya se muestra al cliente, así que ya es una
fase importante.
4. Desarrollo. Posterior a contar con el prototipo elaborado y mostrado al cliente, es
momento de comenzar el desarrollo. Este te tomará una gran cantidad de tiempo,
dependiendo del tamaño del proyecto y el lenguaje de programación que se vaya a utilizar.
5. Entrega y Retroalimentación. Una de las cosas con las que cuenta el modelo de
prototipos, es que una vez entregado el proyecto, debemos darle al cliente cierta
retroalimentación sobre cómo utilizarlo y ciertamente es una fase que se encuentra dentro
de las etapas de desarrollo de software esta metodología.
6. Comunicación con el Cliente. Es importante que una vez entregado el proyecto,
tengamos cierta comunicación con el cliente, básicamente para que nos indique si el
proyecto es correcto o si desea agregarle ciertas funciones, nuestra metodología lo
permite. Si fuera en modo cascada, entonces sería algo realmente imposible de hacer.
7. Entrega del Producto Final. Por último, solamente quedará entregar el sistema elaborado
mediante esta metodología. Aquí tendrás la ventaja de que el código es reutilizable, para
que así con el prototipo ya puedas simplemente empezar de nuevo y con una buena base
de código que te acelerará el proceso.

Página 35 de 70
2.6.3. Modelo Incremental o Iterativo y Creciente

El modelo Incremental, es una metodología de la programación muy utilizada hoy en día,
pues su comodidad de desarrollo permite que te obtenga un producto final mucho más completo
y exitoso. Se trata especialmente de la combinación de los modelos lineal e iterativo o bien,
modelo de cascada y prototipos. Básicamente consiste en completar varias iteraciones de lo que
es el modelo de cascada, pero sin completar ninguna, haciendo iteraciones lo que se hace es crear
una evolución en el producto, permitiendo que se agreguen nuevas especificaciones,
funcionalidades, opciones, funciones y lo que el usuario requiera después de cada iteración.
En pocas palabras, el Modelo Incremental repite el modelo de cascada una y otra vez, pero
con pequeñas modificaciones o actualizaciones que se le puedan ir agregando al sistema. De este
modo el usuario final se ve sumamente sumergido en el desarrollo y puedes proporcionarle un
resultado óptimo.
Fases del Modelo Incremental
El modelo iterativo o incremental, cuenta con algunas fases de desarrollo de software que
realmente no tienen mucha complejidad, vamos a verlas:
1. Inicialización. como en todo modelo de desarrollo, debe haber una inicialización, aquí se
puede hablar de dar una idea, de tener algunos requisitos que se buscan en el proyecto y
ciertas especificaciones que se pueden manejar. No es necesario que se haga una lista total
de requerimientos pues recordemos que el proyecto se basa en iteraciones, así que el
proyecto puede ir evolucionando poco a poco.
2. Periodos de Iteración. Durante el desarrollo del proyecto, es cuando damos inicio a las
iteraciones. La primera iteración se realiza con las características iniciales, básicamente al
final de la primera iteración, queda un pequeño prototipo de lo que será el proyecto, pero
se puede volver a inicializar la iteración y realizar modificaciones en los procesos, como
el análisis y las especificaciones o funciones que el usuario final requiere para su sistema.
El número de iteraciones que se realicen son ilimitadas y dependerá tanto del
desarrollador como del usuario final. Si nuestro objetivo es que el cliente o la persona que
necesita el trabajo quede completamente satisfecha, entonces nos veremos en la necesidad
de hacer la cantidad de iteraciones que se requieran al final del día.

Página 36 de 70
3. Lista de Control. Es importante que conforme se vaya realizando cada iteración, se vaya
llevando un control del mismo en una lista. Como si fuera un programa que recibe
actualizaciones constantemente. Cada una de las actualizaciones o iteraciones deberá ser
documentada y de ser posible, guardada en sus respectivas versiones, para que sea sencillo
volver atrás, en caso de que una iteración no sea exitosa o el usuario ya no la requiera.

Página 37 de 70
Capítulo III. Marco Practico
3.1. Desarrollo del Proyecto

En esta sección se describe la metodología que se utilizara para el desarrollo del proyecto de
software.
Se utilizarán prácticas de desarrollo de proyectos de software, que facilitarán los recursos
necesarios para una buena administración y por lo tanto la entrega de un producto que satisfacerá
los requerimientos, asegurando la calidad del producto; desarrollo iterativo, administración de
requerimientos y prototipos incrementales.
3.1.1. Administración del Proyecto
Metodología en cascada: Framework lineal y Metodo de Prototipos ambos hacen el Modelo
Incremental o Iterativo y Creciente, esta fue la metodología que se utilizará para realizar el
proyecto. Inicialmente se plantea una metodología de cuatro fases (análisis, diseño, desarrollo e
implementación), pero en el transcurso del proyecto se detecta una similitud con la metodología
en cascada y el método de prototipos, debido a que es flexible en la adopción e implementación
de sus fases dependiendo las necesidades para cada proyecto.
También se tiene en cuenta la evolución de los prototipos, producto de las iteraciones que se
realizaron de acuerdo a nuevos requerimientos a través del proyecto.
Una vez seleccionada la metodología se resaltaron las prácticas que se consideraron esenciales
de acuerdo a la experiencia previa del desarrollador, se identificó una buena administración de
requerimientos, una arquitectura robusta basada en componentes, utilización de prototipos
incrementales, verificación constante de los requerimientos y un control de cambios para todos
los artefactos producidos.
3.2. Análisis del Sistema
En este apartado vamos a definir los requisitos funcionales y no funcionales del sistema.
De cada requisito se especifica:
• Identificador: identifica de forma unívoca cada uno de los requisitos.
• Nombre: resumen del requisito.
• Descripción: explicación con detalle del requisito.

Página 38 de 70
3.2.1. Requisitos No Funcionales

Identificador NF-01
Nombre Portabilidad
Descripción El sistema debe poder ejecutarse en el sistema
operativos posibles Windows.
Identificador NF-02
Nombre Rendimiento
Descripción Se deberá optimizar dentro de lo posible el coste de ejecución de cada
una de las evoluciones, así como la ejecución completa del programa,
que finaliza con la obtención de la mejor solución.
Identificador NF-03
Nombre Lenguaje de programación
Descripción Se utilizará como lenguaje de programación Java, utilizando como
mínimo la versión de kit de desarrollo JDK 1.5
3.2.2. Requisitos Funcionales
Identificador F-01
Nombre Configuración
Descripción Toda configuración del sistema se podrá realizar de forma rápida y a
través de un único fichero de configuración. Podrá ser mediante un
fichero de texto.
Identificador F-02
Nombre Ficheros externos
Descripción El sistema debe obtener los datos, tanto para los datos de pruebas o
entrenamiento y test, de ficheros externos en texto plano. Cada
individuo estará en líneas separadas por un retorno. Las
características de cada individuo deberán estar separadas mediante
comas, tabulaciones o espacios.

Página 39 de 70
Identificador F-03
Nombre Fichero único
Descripción El sistema debe ser capaz de usar el mismo fichero tanto para
entrenamiento como para test, pudiendo usar la validación cruzada
definiendo el número de particiones si se trata de un único fichero para
todo.
Identificador F-04
Nombre Número de vecinos
Descripción El número de vecinos a evaluar utilizado por el algoritmo de búsqueda
debe ser configurable.
Identificador F-05
Nombre Evolución de la matriz
Descripción El sistema deberá permitir evolucionar la matriz con la que se optimiza
la fórmula del cálculo de la distancia en el algoritmo de búsqueda
de tres formas distintas:
- Completa: todos los elementos de la matriz formarán parte del
cromosoma del individuo a evolucionar.
- Simétrica: Sólo la diagonal y la parte superior formará parte del
cromosoma del individuo a evolucionar.
- Diagonal: Sólo la diagonal de la matriz formará parte del
cromosoma del individuo a evolucionar, el resto de los
elementos de la matriz serán 0.
Identificador F-06
Nombre Número de evoluciones
Descripción El número total de evoluciones o generaciones del algoritmo genético
se debe poder configurar para cada ejecución.
Identificador F-07
Nombre Desviación de la mutación
Descripción La desviación del operador de mutación debe ser configurable en cada
ejecución.
Identificador F-08
Nombre Tamaño de la población
Descripción El tamaño de la población total para el algoritmo genético debe ser
configurable.

Página 40 de 70
3.3. Diseño del Sistema

El Diseño proporciona detalles acerca de la estructura de los datos, las arquitecturas, las
interfaces y los componentes, con suficientes detalles como para permitir su interpretación y
realización física. Las actividades que se realizan en esta etapa son:
3.3.1. Diagrama de flujo de la estructura base de un algoritmo genético.
Ilustración 11 Diagrama de flujo de la estructura base de un algoritmo genético

Página 41 de 70
3.3.2. Diseño de la Solución del Juego Mastermind mediante Algoritmos Geneticos
a) Representación de la Población
 La población está compuesta por:
• El componente fundamental de la población es un puntero al tipo población,
que es un vector de punteros al conjunto de individuos.
typedef vector<TIndividuo*> TPoblacion;
• Junto con el puntero al vector de punteros a individuos, el conjunto de
propuestas es la otra parte importante de la población. Todas las propuestas
que se hacen quedan almacenadas y ordenadas con respecto a los criterios
establecidos, en un vector de TPropuestas, que es una clase creada para
almacenar el código de la propuesta junto con el número de casillas bien
colocadas y de casillas, que sin estar bien colocadas, si están en la combinación
original.
• Además de las dos variables anteriores, se encuentran las típicas variables: la
posición en la que se encuentra el mejor individuo, el tamaño de la población,
el tamaño del elitismo, porcentaje de cruce, de mutación…,todos estos son
parámetros que se incluyen en una clase TParámetros dentro de población y
que se configuran fácilmente.
b) Generación de la Población.
• Generar la población llama a generar cada uno de los individuos y después de
crearlos se meten de manera adecuada en el vector población.
• Señalar que cada 10 iteraciones sin que se encuentra la solución hemos
tomado la determinación de renovar la población. Esto lo hemos hecho porque
puede que la población generada al inicio no nos aporte nada positivo, incluso
después de mutar, cruzar…..
c) Representación de los individuos.
• Vamos a detenernos en describir cada individuo generado. Un individuo tiene
como parte fundamental el código que lo distingue. Dicho código se almacena
en un puntero a una clase TCodigo, clase que a su vez define un tipo

Página 42 de 70
numerado con todos los posibles valores para los componentes de una posible
combinación (blanco, negro, verde, azul y rojo). Un individuo, por lo tanto, no
es ni más ni menos que una combinación de colores, la que lo determina y
también es importante llevar una variable que nos indique lo que se parece el
nuevo individuo a las propuestas utilizadas.
typedef enum {blanco,negro,rojo,verde,azul,ninguno1,ninguno2}TColores;
vector<TColores>* codigo; /*Un puntero a un vector de colores*/
• Los valores ninguno1 y ninguno2 nos sirven, únicamente y exclusivamente,
para poder hacer comparaciones entre distintas combinaciones (para más
detalle ir al código).
d) Generación de los Individuos.
• La generación de los individuos no tiene nada que reseñar. Lo único que se
hace es establecer de manera aleatoria la combinación de colores que va a
representar a dicho individuo.
e) Función de Adaptación
• Es bastante importante elegir de manera adecuada la función de adaptación
para que las soluciones, en modo de propuestas, converjan de manera
adecuada a la combinación secreta. Son muchas las funciones de adaptación
que hemos probado, eso sí, siempre teniendo en cuenta las pistas que el
usuario nos ha dado con anterioridad.
• Está claro que de algún modo, hay que tener en cuenta las propuestas que se
han realizado y lo buenas que han sido estas. Para ello, el vector de propuestas
con el que contamos se ordena atendiendo al número de casillas bien puestas y
en el lugar correcto. Esto quiere decir que al final no hemos optado por tener
en cuenta las casillas que coinciden con las casillas de la combinación secreta,
pero no están en el mismo lugar (vimos que no aportaban una mayor velocidad
de convergencia). También hemos ignorado, por razones obvias, posibles
combinaciones repetidas. La función de adaptación utilizada tiene la siguiente
forma:

Página 43 de 70
donde lc es la longitud del código a adivinar y parecido(propuesta-individuo) nos da la

diferencia entre las que estén bien colocadas que tiene la propuesta en cuestión y el individuo. El
sumatorio se extiende a cada propuesta.
f) Función de Selección.
• En este caso, hemos utilizado elitismo, por lo tanto, la selección deja intactos para la
siguiente iteración los mejores individuos (un tanto por ciento dentro del número de
individuos de la población que permita notar la mejora y que no ralentice en demasía
el cómputo). Los seleccionados son los que se van a reproducir y mutar.
g) Función de Reproducción
• La reproducción consiste en el cruce entre las combinaciones de dos individuos. Los
dos individuos tienen sus correspondientes combinaciones, se elige un punto al azar
(entre 1 y 4) y se generan dos individuos nuevos en los que los colores de cada uno de
ellos resultan de la combinación de los colores de ambos padres.
• El porcentaje de cruce para el que se obtienen buenos valores no deber pasar el 10%,
así conseguimos frutos en el cruce y no se producen cruces innecesarios y que no
llevan a ningún sitio, sólo a entorpecer el cálculo.
h) Función de Mutación
• Mutar un individuo significa cambiar uno de sus genes (colores). Es decir, se elige un
gen dentro de la cadena de genes del individuo y se cambia su valor, en resumidas
cuentas, se cambia un componente de la combinación por otro color. Esto, claro está,
supone un recalculo de la adaptación del individuo.
3.3.3. Como resolver el Juego mediante Computación Evolutiva
En la literatura se encuentran trabajos que tratan de resolver el problema del Mastermind
usando diferentes técnicas, que se pueden categorizar como:
Unos trabajos lanzan adivinanzas estratégicas, con la intención de extraer información y
reducir el tamaño del espacio de búsqueda. Knuth, alcanza una respuesta, para L = 4 y N = 6,

Página 44 de 70
construyendo un conjunto de patrones de prueba (adivinanzas) y se elige uno de ellos en cada

jugada, tal que se minimice el número máximo de posibilidades restantes.
Irving, basado en el trabajo de Knuth, minimiza el número esperado de posibilidades
restantes.
Kooi propone la “Estrategia de muchas partes", la cual dice que, mientras el código a adivinar
tenga mayor número de respuestas posibles (fichas negras y blancas) será mejor, ya que así se
puede llegar a la solución más pronto. Bestavros utiliza las estratégias “MaxMin y MaxEnt”, en
las que el decodificador elige la adivinanza que ofrece la máxima cantidad de información. La
ventaja de estos algoritmos es que tratan de minimizar el espacio de búsqueda, pero por otro lado
se requiere más tiempo computacional para realizar dichas estrategias.
Otros autores se basan en la búsqueda exhaustiva, como Koyoma con L = 4 y N = 6, donde,
para una adivinanza, se verifican todos los códigos posibles manteniendo el mejor encontrado
(en fichas negras y blancas). Chen generalizó la estrategia de Koyoma para L = n y N = m. Estos
algoritmos demandan un gran tiempo de ejecución, puesto que, es necesario enumerar todos los
posibles códigos.
Se encuentran trabajos que aplican búsqueda aleatoria. Shapiro propone un algoritmo simple,
donde el decodificador crea una lista de posibles adivinanzas en un orden aleatorio y las va
probando una por una. Swaszek, ordena la lista creada por el decodificador en función al color.
En el trabajo de Rosu se generan combinaciones aleatorias que son usadas sucesivamente en
adivinanzas hasta conseguir una combinación que coincida con el código secreto. Una gran
desventaja de estos modelos es tomar en cuenta la información dada por las adivinanzas previas.
Finalmente, otros autores proponen usar métodos de búsqueda dirigidos como los algoritmos
genéticos con un valor de aptitud para elegir una solución. La ventaja de estas técnicas es que se
adaptan al juego Mastermind el cual, al ser un problema de optimización combinatoria, se puede
solucionar mediante un algoritmo evolutivo discreto. Así, Bento utilizó L = 5 y N = 8, guardando
la mejor combinación de cada generación, cada combinación tenía asociada una aptitud dada por
la diferencia entre la cantidad de fichas blancas y negras.
El trabajo de Berghman tiene como idea central la creación de información que será
almacenada a lo largo de las diferentes generaciones del modelo genético y las siguientes jugadas
se determinan basadas en la información obtenida anteriormente. Singley, empieza con un

Página 45 de 70
número de adivinanzas arregladas para descubrir el número de ocurrencias de cada color en el

código secreto y luego continúa con un algoritmo de búsqueda tabú. El fitness de una
combinación es una función que responde a las adivinanzas previas. La búsqueda de una nueva
adivinanza se hace a través de la última adivinanza jugada, en la cual dos posiciones son
escogidas aleatoriamente, intercambiadas y se agrega a la lista tabú. El fitness de la nueva
combinación es comparado al mejor fitness obtenido hasta el momento y reemplaza al último
cuando el nuevo fitness es mejor. Merelo, sólo incluye una determinada combinación dentro de
una población, si cumple que la distancia a la combinación secreta es mínima. Cada adivinanza
se obtiene mediante el cálculo de proximidad a conseguir las cuatro fichas negras como respuesta
del codificador.
3.3.4. Periodo de Iteración – Primera Fase Prototipo
La primera iteración se realiza con las características iniciales, básicamente al final de la
primera iteración, queda un pequeño prototipo de lo que será el proyecto, pero se puede volver a
inicializar la iteración y realizar modificaciones en los procesos, como el análisis y las
especificaciones o funciones que el usuario final requiere para su sistema.
Ilustración 12 Prototipo MM

Página 46 de 70
Ilustración 13 Prototipo MM en ejecución
Ilustración 14 Muestra de la Codificación

Página 47 de 70
3.3.5. Periodo de Iteración – Fase Final

La segunda fase de iteración se realiza con las características iniciales, básicamente al final de
la primera iteración, queda lo que será el proyecto terminado en su totalidad, en esta fase ya no
se realizaran modificaciones.
Interfaz del Software Desarrollado Mastermind
Interfaz del Juego Mastermind
Ilustración 15 Interfaz principal Mastermind
El juego Mastermind ejecutándose, se muestra cómo se va resolviendo el juego en cada

iteración.

Página 48 de 70
Ilustración 16 Mastermind Ejectudandose
En la siguiente imagen se muestra la Resolucion del Juego Mastermind mediante la

Inteligencia Artificial, al final mostrando la resolución del juego.
Ilustración 17 IA Mastermind

Página 49 de 70
Diagrama de UML del Software

En esta sección vemos el diagrama UML del paquete IA que contiene las diferentes
clases para la resolución del Juego Mastermind.
Ilustración 18UML IA

Página 50 de 70
Ilustración 19 common
Ilustración 20 GUI

Página 51 de 70
Ilustración 21 Game

Página 52 de 70
Código en Java del Algoritmo Genético
package ai;
import common.*;
import game.ControlInterface;
import java.util.ArrayList;
/**
* Un algoritmo de resolución genética.
* Esta implementación es una versión ligeramente modificada de la del documento:
* <a href="https://lirias.kuleuven.be/bitstream/123456789/164803/1/KBI_0806.pdf">
* Soluciones eficientes para Mastermind usando algoritmos genéticos </a>
* Para más información sobre algoritmos genéticos ver:
* <a href="http://en.wikipedia.org/wiki/Genetic_algorithm">
* Algoritmo genético en Wikipedia </a>
*/
public class GeneticSolver implements SolvingAlgorithm {
/**
* Tamaño de la población dentro de una generación.
*/
private final int POPULATION_SIZE = 2000;
/**
* Número de generaciones. Si no se encontró ningún código factible después de todas las
* generaciones, una nueva conjetura con nuevas generaciones y poblaciones será
* hecha.
*/
private final int GENERATION_SIZE = 500;
/**
* Max. Cantidad de códigos factibles. Los códigos factibles son buenas conjeturas. Si el
* max. Se encuentran códigos viables, el solucionador se detiene y da un giro con
* Un código factible elegido al azar.
*
* @ver #addToFeasibleCodes ()
*/
private final int FEASIBLE_CODES_MAX = 1;
private ControlInterface ci;
private int width;
private int colorQuant;
private boolean doubleColors;
private Row[] population = new Row[POPULATION_SIZE];
private int[] fitness = new int[POPULATION_SIZE];
private int[] blacks;
private int[] whites;

Página 53 de 70
private ArrayList<Row> feasibleCodes = new ArrayList<Row>();

private int parentPos = 0;
/**
* Inicializa la IA con la configuración del motor Mastermind.
*
* @param ci Una interfaz de control que la IA utilizará para
* interactuar con un juego.
*/
public GeneticSolver(ControlInterface ci) {
this.ci = ci;
width = ci.getSettingWidth();
colorQuant = ci.getSettingColQuant();
doubleColors = ci.getSettingDoubleCol();
population = new Row[POPULATION_SIZE];
fitness = new int[POPULATION_SIZE];
blacks = new int[ci.getSettingMaxTries()];
whites = new int[ci.getSettingMaxTries()];
initResults();
}
/**
* Inicialice los arrays "negros" y "blancos" con valores del
* GameField. Las matrices "negros" y "blancos" son necesarios para acelerar
* el procesamiento.
*/
public void initResults() {
for (int i = 0; i < ci.getActiveRowNumber(); i++) {
blacks[i] = ci.getResultRow(i)
.containsColor(Color.Black);
whites[i] = ci.getResultRow(i)
.containsColor(Color.White);
}
}
/**
* Hacer una conjetura completa en el motor de Mastermind.
* Esto incluye para generar una conjetura, pasarla al motor.
* y hacer un turno de juego completo.
*
* @return -1 = El juego terminó y el código no se rompió. 
* 1 = El juego terminó un código se rompió. 
* 0 = Solo un turno normal o el juego ya terminó.
* @ver ControlInterface # turno ()
*/

Página 54 de 70
public int makeGuess() {

Row guess = generateGuess();
ci.writeToGameField(guess.getColors());
int[] result = compare(guess, ci.getSecretCode());
blacks[ci.getActiveRowNumber()] = result[0];
whites[ci.getActiveRowNumber()] = result[1];
return ci.turn();
}
/**
* Crea nuevas generaciones hasta que se encuentren suficientes códigos elegibles.
*
* @return Una conjetura elegible.
*
* @see #initPopulation ()
* @see #calcFitness ()
* @see #sortFeasibleByFitness (int [], common.Row [])
* @ver #evolvePopulation ()
* @ver #addToFeasibleCodes ()
*/
public Row generateGuess() {
Row guess = new Row(width);
boolean doCalc;
// ¿Primero adivinar?
if (ci.getActiveRowNumber() == 0) {
return generateRndGuess();
}
do {
int genNumber = 0;
doCalc = true;
initPopulation();
calcFitness();
sortFeasibleByFitness(fitness, population);
while (doCalc == true && genNumber <= GENERATION_SIZE

&& feasibleCodes.size() <= FEASIBLE_CODES_MAX) {
parentPos = 0;
evolvePopulation();
calcFitness();
sortFeasibleByFitness(fitness, population);
doCalc = addToFeasibleCodes();
genNumber++;
}
if (feasibleCodes.isEmpty() == true) {
Debug.dbgPrint("IA: No se encontró ningún código factible. "

Página 55 de 70
+ "Reintentar con nueva población");

}
} while (feasibleCodes.isEmpty() == true);
// Elegir adivinanza.
Debug.dbgPrint("IA: Existe " + feasibleCodes.size() +
" Codigo(s) factible(s)");
guess = feasibleCodes.get((int) (Math.random() * feasibleCodes.size()));
Debug.dbgPrint("IA: adivinanza es " + guess);
return guess;
}
/**
* Evolucionar la población usando cruzamiento, mutación, permutación e
* inversión.
* 0.5 probabilidad para xOver1 y xOver2
* después del cruce
* 0.03 probabilidad de mutación
* 0.03 posibilidad de permutación
* 0.02 posibilidad de inversión.
*
* <a href="http://en.wikipedia.org/wiki/Genetic_algorithm#Reproduction">
* Reproducción </a>
*
* @see # xOver1 (common.Row [], int, int)
* @see # xOver2 (common.Row [], int, int)
* @see #mutation (common.Row [], int)
* @see #permutation (common.Row [], int)
* @see #inversion (common.Row [], int)
*/
private void evolvePopulation() {
Row[] newPopulation = new Row[POPULATION_SIZE];
for (int i = 0; i < POPULATION_SIZE; i++) {
newPopulation[i] = new Row(width);
}
for (int i = 0; i < POPULATION_SIZE; i += 2) {
if ((int) (Math.random() * 2) == 0) {
xOver1(newPopulation, i, i + 1);
} else {
xOver2(newPopulation, i, i + 1);
}
}

if ((int) (Math.random() * 100) < 3) {
mutation(newPopulation, i);

Página 56 de 70
} else if ((int) (Math.random() * 100) < 3) {

permutation(newPopulation, i);
} else if ((int) (Math.random() * 100) < 2) {
inversion(newPopulation, i);
}
}
doubleToRnd(newPopulation);
population = newPopulation;
}
/**
* Un código c es elegible o factible si resulta en los mismos valores para
* Xk e Yk para todas las conjeturas k que se han jugado hasta esa etapa,
* Si c era el código secreto. 
* X es el número de coincidencias exactas. Y es el número de conjeturas que son
* El color correcto pero en la posición incorrecta.
*
* @return False si factibleCodes está lleno. De lo contrario es cierto.
*/
private boolean addToFeasibleCodes() {
outer:
for (int j = 0; j < ci.getActiveRowNumber(); j++) {
int[] result = compare(population[i],
ci.getGameFieldRow(j));
if (result[0] != blacks[j] || result[1] != whites[j]) {

continue outer;
}
}
if (feasibleCodes.size() < FEASIBLE_CODES_MAX) {

if (feasibleCodes.contains(population[i]) == false) {
feasibleCodes.add(population[i]);
if (feasibleCodes.size() < FEASIBLE_CODES_MAX) {
return false;
}
}
} else {
// E está lleno.
return false;
}
}

Página 57 de 70
return true;
}
/**
* Sustituye elementos dobles en newpopulation.
*
* @param newPopulation La matriz de población que se manipulará.
*/
private void doubleToRnd(Row[] newPopulation) {
if (lookForSame(newPopulation, i) == true) {
newPopulation[i] = generateRndGuess();
}
}
}
/**
* Busque las filas que son iguales a la fila en popPos en newPopulation.
*
* @param newPopulation La matriz de población que se buscará.
* @param popPos La posición de la fila dentro de la matriz de población que
* serán comparados.
* @return true si se encuentra una fila igual. falso si no se encuentra una fila igual.
*/
private boolean lookForSame(Row[] newPopulation, int popPos) {
if (population[popPos].equals(newPopulation[popPos]) == true) {
return true;
}
}
return false;
}
/**
* Mutación. Reemplaza el color de una posición elegida al azar por un azar
* otro color.
*
* sera cambiado.
*/
private void mutation(Row[] newPopulation, int popPos) {
newPopulation[popPos].setColorAtPos((int) (Math.random() * width),
Color.values()[(int) (Math.random() * colorQuant)]);
}

Página 58 de 70
/**
* Permutación. Los colores de dos posiciones aleatorias se cambian.
*
* sera cambiado.
*/
private void permutation(Row[] newPopulation, int popPos) {
int pos1 = (int) (Math.random() * width);
Color tmp = newPopulation[popPos].getColorAtPos(pos1);
newPopulation[popPos].setColorAtPos(pos1,
newPopulation[popPos].getColorAtPos(pos2));
newPopulation[popPos].setColorAtPos(pos2, tmp);
}
/**
* Inversión. Se seleccionan aleatoriamente dos posiciones, y la secuencia de colores.
* Entre estas posiciones se invierte.
*
* sera cambiado.
*/
private void inversion(Row[] newPopulation, int popPos) {
if (pos2 < pos1) {

int tmp = pos2;
pos2 = pos1;
pos1 = tmp;
}
for (int i = 0; i < (pos2 - pos1)/2; i++) {

Color tmp = newPopulation[popPos].getColorAtPos(pos1 + i);
newPopulation[popPos].setColorAtPos(pos1 + i,
newPopulation[popPos].getColorAtPos(pos2 - i));
newPopulation[popPos].setColorAtPos(pos2 - i, tmp);
}
}
/**
* Cruce de un punto. Un único punto de cruce en el organismo de ambos padres.

Página 59 de 70
* Se seleccionan cadenas. Todos los datos más allá de ese punto en cualquier cadena de
organismos.
* Se intercambia entre los dos organismos progenitores. Los organismos resultantes son
* los niños.
*
* <a href="http://en.wikipedia.org/wiki/Crossover_%28genetic_algorithm%29#One-
point_crossover">
* Un punto de cruce </a>
*
* @param child1Pos La posición de una fila dentro de la matriz de población que
* sera cambiado.
* sera cambiado.
*/
private void xOver1(Row[] newPopulation, int child1Pos, int child2Pos) {
int mother = getParentPos();
int father = getParentPos();
int sep = ((int) (Math.random() * width)) + 1;
for (int i = 0; i < width; i++) {

if (i <= sep) {
newPopulation[child1Pos].setColorAtPos(i,
population[mother].getColorAtPos(i));
population[father].getColorAtPos(i));
} else {
}
}
}
/**
* Cruce de dos puntos. Se seleccionan dos puntos en el organismo parental.
* cuerdas. Todo entre los dos puntos se intercambia entre los padres.
* Organismos, prestando dos organismos infantiles.
*
* <a href="http://en.wikipedia.org/wiki/Crossover_%28genetic_algorithm%29#Two-
point_crossover">
* Cruce de dos puntos </a>
*

Página 60 de 70

* sera cambiado.
* sera cambiado.
*/
private void xOver2(Row[] newPopulation, int child1Pos, int child2Pos) {
int mother = getParentPos();
int father = getParentPos();
int sep1;
int sep2;
sep1 = ((int) (Math.random() * width)) + 1;

sep2 = ((int) (Math.random() * width)) + 1;
if (sep1 > sep2) {

int temp = sep1;
sep1 = sep2;
sep2 = temp;
}

if (i <= sep1 || i > sep2) {
} else {
}
}
/**
* Getter para una buena posición de los padres en la población.
* En este caso se utiliza el de la quinta parte de la mejor población.
* Es importante que solo los padres con un buen valor físico estén acostumbrados a
* Generar la siguiente generación.
*
* @return Una posición en el primer quinto de la matriz de población
* sucesivamente aumentando.
*/

Página 61 de 70
private int getParentPos() {

parentPos += (int) (Math.random() * 7);
if (parentPos < POPULATION_SIZE / 5) {
return parentPos;
} else {
parentPos = 0;
}
return parentPos;
}
/**
* Calcula la condición física de cada fila en la población.
* Un valor de aptitud y el elemento correspondiente de la matriz de población
* Ambos tienen el mismo índice en sus matrices respectivas.
*
* Debe parecerse a la función como se describe en el documento:
* <a href="https://lirias.kuleuven.be/bitstream/123456789/164803/1/KBI_0806.pdf">
* Soluciones eficientes para Mastermind usando algoritmos genéticos </a>
* en la página 6.
*/
private void calcFitness() {
int xtmp;
int ytmp;
xtmp = 0;
ytmp = 0;
for (int j = 0; j < ci.getActiveRowNumber(); j++) {
int[] result = compare(
population[i], ci.getGameFieldRow(j));
xtmp += Math.abs(result[0] - blacks[j]);// + ancho * j;
ytmp += Math.abs(result[1] - whites[j]);// + ancho * j;
}
fitness[i] = (xtmp + ytmp);
}
}
/**
* Compara dos filas.
* el resultado [0] se incrementa si un valor igual (color) se encuentra en una posición
igual.
* el resultado [1] se incrementa si un valor igual es una posición diferente.
* resultado [0] son las clavijas negras.
* resultado [1] son las clavijas blancas.
* <a
href="http://en.wikipedia.org/wiki/Mastermind_%28board_game%29#Gameplay_and_rules">

Página 62 de 70
* Reglas de mente maestra </a>

*
* @param a Row Guesscode.
* @param b Fila Secretcode.
* @return [0] es el número de clavijas negras, [1] es el número de clavijas blancas.
*/
private int[] compare(Row a, Row b) {
int[] result = {0, 0};
Color[] code = new Color[width];
Color[] secret = new Color[width];
// Crear copia real.
System.arraycopy(a.getColors(), 0, code, 0, width);
System.arraycopy(b.getColors(), 0, secret, 0, width);

if (code[i] == secret[i]) {
result[0]++;
secret[i] = null;
code[i] = null;
}
}
outer:
if (code[i] != null) {
for (int j = 0; j < width; j++) {
if (code[i] == secret[j]) {
result[1]++;
secret[j] = null;
continue outer;
}
}
}
}
return result;
}
/**
* Inicializa la población con filas aleatorias.
* factibleCodes se purgan.
*/
private void initPopulation() {
// Inicia poblacion con conjeturas al azar.
int i = 0;
feasibleCodes.clear();

Página 63 de 70
while (i < POPULATION_SIZE) {

population[i] = generateRndGuess();
i++;
}
}
/**
* Genera una fila con colores aleatorios.
* Genera una fila con la configuración de ancho actual. Los colores disponibles son
* determinado por la configuración de colorQuant. Si la configuración de doble color
* es falso, solo se establecen diferentes colores. 
* Advertencia: el uso de esta función puede llevar hasta
* varios minutos, especialmente si ha configurado un ancho alto,
* Muchos colores o cuando ejecutas el juego en una computadora lenta.
* Esto no es un error, solo un efecto secundario del complejo
* algoritmo que la IA está utilizando.
*
* @return A Row con colores aleatorios.
*/
private Row generateRndGuess() {
Row guess = new Row(width);
// Preparar valores para ajustar colorQuant-rule
Color[] values = new Color[colorQuant];
Color[] all = Color.values();
System.arraycopy(all, 0, values, 0, colorQuant);
// Hacer la generación de código real ...
int i = 0;
while (i < width) {
Color now = values[(int) (Math.random() * colorQuant)];
if (guess.containsColor(now) > 0) {
if (doubleColors == true) {
guess.setColorAtPos(i++, now);
}
} else {
guess.setColorAtPos(i++, now);
}
}
return guess;
}
/**
* Este es un Quicksort que clasifica los Arreglos de fitness y pop según los criterios
* En el gimnasio.fitness-array.
*
* @param fitness Una matriz int.

Página 64 de 70
* @param pop Una matriz de Filas.

* @see #sort (int [], common.Row [], int, int)
* @see #divide (int [], common.Row [], int, int, int)
* @see #swap (common.Row [], int, int)
* @see #swap (int [], int, int)
*/
private void sortFeasibleByFitness(int[] fitness, Row[] pop) {
sort(fitness, pop, 0, fitness.length - 1);
}
/**
* Función auxiliar para la ordenación recursiva.
*
* @param low El límite inferior.
* @param up El límite superior.
*/
private void sort(int[] fitness, Row[] pop, int low, int up) {
int p = (low + up) / 2;
if (up > low) {
//Feld zerlegen
int pn = divide(fitness, pop, low, up, p);
//und sortieren
sort(fitness, pop, low, pn - 1);
sort(fitness, pop, pn + 1, up);
}
}
/**
* Función auxiliar para partición.
*
* @param low El límite inferior.
* @param up El límite superior.
* @param pivot La posición del elemento Pivot.
* @return La nueva posición del elemento Pivot.
*/
private int divide(int[] fitness, Row[] pop, int low, int up, int pivot) {
int pn = low;
int pv = fitness[pivot];
swap(fitness, pivot, up);
swap(pop, pivot, up);
for (int i = low; i < up; i++) {

Página 65 de 70
if (fitness[i] <= pv) {

swap(fitness, pn, i);
swap(pop, pn++, i);
}
swap(fitness, up, pn);
swap(pop, up, pn);
}
return pn;
}
/**
* Función auxiliar para intercambiar dos elementos de una matriz int.
*
* @param a Posición del primer elemento.
* @param b Posición del segundo elemento.
*/
private void swap(int[] fitness, int a, int b) {
int tmp = fitness[a];
fitness[a] = fitness[b];
fitness[b] = tmp;
}
/**
* Función auxiliar para intercambiar dos elementos de una matriz de Filas.
*
* @param a Posición del primer elemento.
* @param b Posición del segundo elemento.
*/
private void swap(Row[] pop, int a, int b) {
Row tmp = pop[a];
pop[a] = pop[b];
pop[b] = tmp;
}
/**
* Prueba de velocidad.
*
* Repeticiones @param Repeticiones de resolver un juego.
*/
public void geneticSolverTest(int repetitions){
long start = System.currentTimeMillis();
long durationLongest = 0;
long durationShortest = 4000000;

Página 66 de 70
int gamewon = 0;
int gamelost = 0;
double guess = 0;
for (int i = 0; i < repetitions; i++) {

long starti = System.currentTimeMillis();
int game;
ci.newGame();
do {
game = makeGuess();
guess++;
} while (game == 0);
if (game == 1) {
gamewon++;
} else {
gamelost++;
}
long endi = System.currentTimeMillis();

if (endi - starti > durationLongest) {
durationLongest = endi - starti;
}
if (endi - starti < durationShortest) {
durationShortest = endi - starti;
}
}
long end = System.currentTimeMillis();

long duration = end - start;
System.out.println("##################\nResultados de referencia:");
System.out.println("Repeticiones: " + repetitions);
System.out.println("Duracion en ms: " + duration);
System.out.println("Duracion en s: " + (duration/1000f));
System.out.println("Duracion en m: "+ (duration/1000f/60));
System.out.println("Tiempo promedio de resolución en ms: "
+ (duration/repetitions));
System.out.println("Tiempo medio de resolución en s: "
+ (duration/1000f/repetitions));
System.out.println("Más corto en ms: "+ durationShortest);
System.out.println("Más largo en ms: "+ durationLongest);
System.out.println("Más corto en s: "+ durationShortest/1000f);

Página 67 de 70
System.out.println("Más largo en s: "+ durationLongest/1000f);

System.out.println("Más largo en m: "+ durationLongest/1000f/60);
System.out.println("Gana: "+ gamewon);
System.out.println("Pierde: "+ gamelost);
System.out.println("Conjeturas promedio: "+ (guess/repetitions));
}
}

Página 68 de 70
Conclusiones
En este trabajo solo se presentó la parte de Marco Teórico del Proyecto y los Objetivos a
desarrollarse, en el marco teórico vimos lo que es la inteligencia artificial y las ventajas y
desventajas que nos brindan en la actualidad, y conocimos varios dispositivos que hoy en día
gozan de IA. Como hemos podido ver a lo largo del documento los algoritmos genéticos son
actualmente una fuerte fuente de resolución de problemas complejos al realizar su ejecución en
paralelo pudiendo así obtener diferentes soluciones a problemas.
Sin embargo, como se ha podido observar, no hay ninguna estrategia que sea siempre
invencible, sino que hay un conjunto de estrategias que suelen dar buenos resultados. Así pues,
habrá que ajustar los parámetros de acción en función de cada problema a modelar para obtener
una solución que se adapte mejor a unas determinadas condiciones. Sin embargo, en una
situación real puede suceder que no se conozcan los parámetros iniciales o que no se sepa la
duración del algoritmo. Por lo tanto, habrá que elegir con sumo cuidado los parámetros iniciales.

Página 69 de 70
Bibliografía y Referencias
Bibliografía
 [1] D. E. Knuth, “The computer as master mind,” Journal of Recreational
Mathematics, vol. 9, pp. 1–6, 1976-77.
 [2] L. Berghman, D. Goossens, and R. Leus, “Efficient solutions for mastermind
using genetic algorithms,” Computers & operations research, vol. 36, no. 6, pp. 1880–
1885, 2009.
 [3] A. Singley, “Heuristic solution methods for the 1-dimensional and 2- dimensional
mastermind problem,” Ph.D. dissertation, UNIVERSITY OF FLORIDA, 2005.
 [4] J. Merelo-Guervós, P. Castillo, and V. Rivas, “Finding a needle in a haystack using
hints and evolutionary computation: the case of evolutionary mastermind,” Applied
Soft Computing, vol. 6, no. 2, pp. 170–179, 2006.
 [5] J. H. Holland, Adaptation in Natural and Artificial Systems, 1st ed. Ann Arbor,
Michigan: University of Michigan Press, 1975.
 [6] D. E. Goldberg, Genetic Algorithms in Search, Optimization and Machine
Learning.
Referencias
 [1] http://es.wikipedia.org/wiki/Algoritmo_gen%C3%A9tico
 [2] http://www.redcientifica.com/doc/doc199904260011.html
 [3] http://geneura.ugr.es/~jmerelo/ie/ags.htm
 [4] http://www.lsi.upc.es/~iea/transpas/9_geneticos/index.htm
 [5] http://casa.ccp.servidores.net/genetico.html
 [6] http://homepage.sunrise.ch/homepage/pglaus/gentore.htm#A
 [7] http://the-geek.org/docs/algen/
 [8] http://www.rennard.org/alife/english/gavgb.html

Página 70 de 70

Lingua

Benvenuto in Scribd!

Proyecto Final Taller de Licenciatura I

Caricato da

Informazioni sul documento

Descrizione:

Data di caricamento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Descrizione:

Copyright:

Formati disponibili

Proyecto Final Taller de Licenciatura I

Caricato da

Descrizione:

Copyright:

Formati disponibili

Titoli correlati

FICHA DE IDENTIFICACIÓN DE PROYECTO FINAL

SISTEMA INTELIGENTE BASADO EN COMPUTACIÓN

Carrera Ingeniería de Sistemas

En este proyecto se Investiga y analiza una estrategia de solución del juego

Palabras clave: sistemas inteligentes, computación evolutiva, algoritmos genéticos, mastermind

Key words: intelligent systems, evolutionary computation, genetic algorithms, mastermind

Asignatura: Taller de Licenciatura I

Asignatura: Taller de Licenciatura I

3.3.5. Periodo de Iteración – Fase Final ........................................................................ 48

Asignatura: Taller de Licenciatura I

Ilustración 1 Principales aplicaciones prácticas de la IA ........................................................... 9

Asignatura: Taller de Licenciatura I

Capítulo I. Descripción del Proyecto

Asignatura: Taller de Licenciatura I

1.2. Objetivos del Proyecto

1.2.2. Objetivos Específicos

1.3. Justificación del Proyecto

Asignatura: Taller de Licenciatura I

Capítulo II. Marco Teórico

2.1 Inteligencia Artificial

2.1.1. Tipos De Inteligencia Artificial

2.1.2. Aplicaciones Prácticas De La Inteligencia Artificial

Asignatura: Taller de Licenciatura I

Ilustración 1 Principales aplicaciones prácticas de la IA

Asignatura: Taller de Licenciatura I

2.1.3. Ventajas y Desventajas de la Inteligencia Artificial

2.2 Sistemas Inteligentes

2.2.1. Capacidades requeridas

Asignatura: Taller de Licenciatura I

• Inteligencia: Hay muchas definiciones de "inteligencia". Para usos prácticos usamos

Asignatura: Taller de Licenciatura I

2.3 Computación Evolutiva

Asignatura: Taller de Licenciatura I

Ilustración 2 Metáfora Evolutiva

Dentro de lo que es la computación evolutiva, se engloban diferentes estrategias para la

Asignatura: Taller de Licenciatura I

El esquema general de un algoritmo evolutivo lo mostramos en la siguiente imagen:

Ilustración 3 Esquema general de un algoritmo evolutivo

A continuación, mostramos el Pseudo-Código de un algoritmo evolutivo:

Ilustración 4 Pseudo-Codigo de algoritmo evolutivo

Asignatura: Taller de Licenciatura I

2.3.1. ¿Cómo representamos a los individuos?

Ilustración 5 Nuevo individuo a partir de dos

Asignatura: Taller de Licenciatura I

2.3.3. ¿Qué es eso de que un "individuo es suficientemente bueno"?

Asignatura: Taller de Licenciatura I

2.4 Algoritmos Genéticos

Asignatura: Taller de Licenciatura I

Estas candidatas prometedoras se conservan y se les permite reproducirse. Se realizan

Ilustración 7 Funcionamiento Algoritmos Genéticos

Asignatura: Taller de Licenciatura I

2.4.1. Métodos de representación

Asignatura: Taller de Licenciatura I

2.4.2. Métodos de selección

Asignatura: Taller de Licenciatura I

reduciría la diversidad genética de la población y podría obstaculizar la búsqueda de

2.4.3. Métodos de cambio