Memoria final

LA INTELIGENCIA ARTIFICIAL
EN LAS ORGANIZACIONES
CURSO 2009/2010

IA en el Póquer Online
Clasificador de manos Preflop

ANTONIO DÍAZ PONCE 100055301
RAÚL MARTÍNEZ FERNÁNDEZ 100054986
JAVIER GARCÍA-CUERVA VELASCO 100055253

LA INTELIGENCIA ARTIFICIAL EN LAS ORGANIZACIONES 2009/2010

ÍNDICE

1. INTRODUCCIÓN ................................................................................................. 4
1.1 Descripción del Problema......................................................................................4

1.2 Objetivos ..............................................................................................................5

1.3 Posibles aplicaciones.............................................................................................6

2. ESTADO DEL ARTE .............................................................................................. 7
2.1 Programas que aprendan a jugar como una persona ..............................................7

2.2 Clústering para agrupar tipos de jugadores .......................................................... 14

3. DESCRIPCIÓN COMPLETA DE LOS DATOS Y FUENTES EMPLEADOS .................... 16
3.1 Datos de entrada ................................................................................................ 16

3.2 Datos adicionales ................................................................................................ 19

3.3 Datos de Salida ................................................................................................... 20

4. PREPROCESADO DE LOS DATOS ....................................................................... 21
4.1 Estudio de los datos ............................................................................................ 21

4.2 Procesado de datos ............................................................................................. 21

5. EXPLORACIÓN DE LOS DATOS .......................................................................... 22
5.1 Clases ................................................................................................................. 22

5.2 Clasificadores...................................................................................................... 23

5.3 Resultados .......................................................................................................... 35

6. SELECCIÓN DE ATRIBUTOS ............................................................................... 37
6.1 Técnicas de selección de atributos. ...................................................................... 38

6.2 Ranker ................................................................................................................ 41

6.3 Filter................................................................................................................... 43

6.4 Wrapper ............................................................................................................. 43

6.5 Comparativa resultados selectores de atributos................................................... 43

6.6 Aprendizaje de las clases ..................................................................................... 45

7. EXPERIMENTACIÓN ......................................................................................... 48

IA en el Póquer Online: Clasificador de manos Preflop Página 2


8. ANÁLISIS DE DIFICULTADES, RIESGOS Y APLICABILIDAD ....................................... 50
8.1 Dificultades en la Obtención de la Solución.......................................................... 50

8.2 Riesgos Previstos ................................................................................................ 50

8.3 Análisis de Implantación ..................................................................................... 51

9. ANÁLISIS DE LOS RESULTADOS Y CONCLUSIONES ............................................. 52

10. TRABAJOS FUTUROS Y POSIBLES MEJORAS ...................................................... 53

11. REFERENCIAS................................................................................................... 54

12. ANEXO: REGLAS DE PÓKER TEXAS HOLD’EM NO LIMIT ..................................... 55
12.1 ¿Qué es el póker Texas Hold'em sin límite? ............................................................. 55

12.2 ¿Es entonces el póker un juego de azar?.................................................................. 55

12.3 La baraja de póker .................................................................................................. 55

12.4 Manos de póker ..................................................................................................... 55

12.5 La mano de No Limit Texas Hold'em ........................................................................ 61

12.6 Empieza la mano (El Preflop)................................................................................... 61

12.7 Las Tres Primeras Cartas (El Flop) ............................................................................ 61

12.8 La Cuarta Carta (El Turn) ......................................................................................... 62

12.9 La Quinta Carta (El River) ........................................................................................ 62



1. INTRODUCCIÓN
1.1 Descripción del Problema

El Texas hold 'em Sin Límite [1] es una versión del juego del póquer (ver ANEXO).
Actualmente es la más popular y también es la más jugada en la mayoría de casinos y
campeonatos mundiales. Esta es la modalidad sobre la que realizaremos el estudio. En ella
cada jugador sólo posee dos cartas (cartas personales) y su jugada es la mejor combinación de
5 cartas que puede formar con las cartas que se van poniendo en la mesa (denominadas cartas
comunitarias).

Hemos decidido realizar el estudio sobre el póquer, porque presenta diversas
características que lo hacen muy interesante para analizarlo desde el punto de vista de la
Inteligencia Artificial:

• Información incompleta
• No determinista
• Varios jugadores
• Toma de decisiones bajo incertidumbre
• Engaño
• Estudio del oponente

El problema principal es la toma de decisiones en el juego del Póker ya que se basa en
unos razonamientos abstractos muy variantes, en el que el factor humano influye de manera
superlativa en la decisión.

En una mano de póquer, las principales decisiones que se pueden realizar son:

• No ir: Lo que supone que el jugador deja de jugar
• Pasar: El jugador decide no subir ninguna apuesta
• Subir N: El jugador sube la apuesta del juego una cantidad “N”, podrá subir tanto
como la cantidad de dinero de la que disponga
Sin embargo, a pesar de que el conjunto de salida parece reducido, el conjunto de
variables a tomar en cuenta es mucho mayor, ya que, a la hora de tomar una decisión no sólo
depende de las cartas que se poseen, sino que también se tendrá en cuenta la posición que se
ocupa en la mesa y el modo de jugar de los contrincantes.

Además el tiempo de respuesta también suele influir en el modo de juego de los
jugadores, por ejemplo, un jugador que no tiene segura su jugada tardará más en decidirse
que un jugador que tiene una buena mano.



1.2 Objetivos

El objetivo principal es obtener un programa o agente, que mediante una técnica de
inteligencia artificial que sea capaz de tomar las mejores decisiones posibles, en la primera
ronda de apuestas del juego (Preflop*1 [2]). Es decir, el programa no jugará una mano entera,
sino que sólo intervendrá en la primera parte. Desarrollaremos un Clasificador de Manos
Preflop, el cuál recibiendo la información de la partida, obtenga como salida una decisión
(Fold, Call, Raise N), que se parezca lo máximo posible a la decisión que tomaría un jugador
profesional.

Hemos decidido centrarnos únicamente en la primera ronda de apuestas porque:

• Realizar un agente que juegue todas las rondas sería un proyecto de gran envergadura,
en el cúal habría que usar probablemente sistemas híbridos para llegar a obtener
buenos resultados.

• La selección de manos preflop es el paso más importante en el Texas Hold’em, porque
decide el resto de la mano.

• Podemos inferir técnicas usadas por profesionales (bluf, semi-bluf, robos, semi-robos,
squeeze,…) una vez obtenido el clasificador.

• En el estado del arte no hemos visto que se haga exactamente lo mismo, aunque sí van
más allá y desarrollan un jugador que juegue todas las ronas.

Es cierto, que es complejo de valorar finalmente si hemos creado un buen jugador, o
hemos conseguido aprender las mejores decisiones, ya que el conjunto de posibilidades es
muy grande.

En nuestro caso sería positivo que con estas decisiones consiguiésemos ganar el mayor
dinero posible cuando realicemos apuestas, y de perder la menor cantidad de dinero posible
cuando la jugada sea mala. Es decir, el objetivo a largo plazo no es ganar manos, sino jugar de
la mejor manera, para ganar el mayor dinero posible. Esto puede parecer contradictorio, pero
no lo es, ya que en el póquer prima la habilidad para ganar dinero, y muchas veces esto se
puede conseguir sin tener la mejor mano.
1
* Denomina la ronda de apuestas anterior a que se saque el flop, es decir, el momento del juego en que
cada cual cuenta únicamente con las dos cartas cubiertas para tomar una decisión; suele utilizarse
frecuentemente para denominar un tipo de juego, es decir, para explicar cuáles son las estrategias en
cuanto a rango de manos, apuestas etc. que deben seguirse en este punto de la mano. El
comportamiento de los jugadores en el juego preflop es una de las variables más importantes que se
manejan en los trackers*2 ya que proporciona valiosos datos estadísticos que permiten hacerse una
idea del rango de manos con que el contrincante suele permitirse jugar y de qué manera se mueve con
cada tipo de cartas.

*2 La palabra tracker [3] se puede traducir literalmente como “rastreador” y es utilizada, por ejemplo
para referirse a los perros rastreadores. En relación al póker denominamos tracker de manera genérica
a los software utilizados para recoger e interpretar estadísticas de nuestros rivales.



1.3 Posibles aplicaciones

Si obtuviéremos un buen clasificador, este podría usarse, como complemento en
herramientas que ayudan a los jugadores online a tomar decisiones. Estas herramientas dan
probabilidades, simulando muchas partidas, dándote una buena estimación de qué decisión
tomar. Nuestro agente, podría aconsejar al jugador en función de que haría un jugador
profesional, o por ejemplo que habría hecho él en otra misma ocasión, dependiendo de los
datos con los que se entrene al agente. Siendo de esta manera nuestro agente como una
herramienta de aprendizaje del póquer.

El agente, también podría usarse como parte de un jugador automático, esto sería
valioso para las casas de apuestas que albergan partidas de Póker Online, ya que, es necesario
un mínimo de jugadores para participar y para que los jugadores tengan un servicio de juego
24h podrían interactuar con estos jugadores creados mediante IA, aunque esto no sería lícito,
y sólo sería usado por salas de baja categoría, poco demandadas por la mayoría de los
usuarios.

Este jugador automático también sería muy demandado por usuarios cuyo fin no es
aprender a jugar al póker, sino ganar dinero, pudiéndose crear bots, o programas autónomos,
capaces de navegar por las aplicaciones e ir entrando en mesas para jugar. Podrían hasta
colaborar entre ellos, teniendo un sistema multiagentes que crea una rez de agentes, capaz de
comunicarse para intentar ganar el mayor dinero posible. Este tema es penado por las salas de
manera tajante, porque la gente dejaría de jugar en su sala. Aún así, hay bastante controversia
sobre si se puede diseñar un bot capaz de ganar a un humano en el póquer, ya que es un juego
bastante difícil como para aprenderlo con técnicas de inteligencia artificial.



2. ESTADO DEL ARTE

La Inteligencia Artificial ya se ha adentrado en el campo de la toma de decisiones en el
Póker. Actualmente se dice que es una de las principales amenazas del Póker Online, y esto se
debe a que los jugadores que han sido generados, a pesar de que no son capaces de vencer a
jugadores expertos, sí que son capaces de ganar a jugadores amateur y estándar.

Es por ello que actualmente se intentan introducir técnicas para poder expulsar a
jugadores automáticos. Técnicas como la resolución de los cada vez más inservibles captchas o
de problemas más específicos como preguntas, etc.

Además de empresas dedicadas a este propósito también las universidades se
encargan de organizar concursos, uno de los más conocidos es el First Man-Machine Poker
Championship [4], promocionado por la universidad de Alberta (Edmonton, Canadá), los
cuáles también son criticados ya que están realizando programas automáticos que juegan al
póker, pero se defienden diciendo que sus bots ganan a otros bots, pero no a los humanos.

Debido al secretismo que genera este terreno, por su directa productividad, es difícil
que las empresas comenten su relación con este tipo de investigaciones, y por tanto es difícil
obtener datos de manos y jugadas, así con información relacionada con la aplicación directa de
este tipo de solución.

A continuación, vamos a describir varios casos que hacen uso de IA en el póker.

2.1 Programas que aprendan a jugar como una persona
Nos vamos a centrar en los diseñados en el torneo anual de la universidad de Alberta.

En esta competición, cada jugador tiene que diseñar en Java un jugador, usando las
técnicas oportunas que considere, normalmente IA.

Respecto a la competición de este año la universidad de Alberta publica los resultados
[5].

En televisiones estadounidenses han hecho reportajes referentes a estas
competiciones [6].

A continuación ponemos una pequeña presentación, para conocer mejor la
competición, quién ha ganado este año y que técnicas han usado para hacer sus jugadores:



A continuación vamos a describir las técnicas de IA usadas por los ganadores:

• Limit Bankroll: MANZANA
Usaron un Perceptrón Multicapa con una capa oculta y tres neuronas de salida.

Las neuronas de entrada se encargan de codificar las características relevantes de la
situación actual del juego, tales como las cartas de mano, cartas de la mesa y las apuestas
anteriores, mientras que las neuronas de salida están entrenadas para dar P(fold), P(call),
P(raise), siendo P la probabilidad con la que los robots deben retirarse, igualar o subir, en
función del estado actual del juego.

El entrenamiento se realiza utilizando algoritmos estándares de aprendizaje, mientras
que los ejemplos de entrenamiento se construyeron a partir de las manos del ganador de la
competición del último año.

• Limit Runoff: GGValuta
El algoritmo general utilizado para calcular el equilibrio es un CFR (counterfactual
regret minimization) (reducción al mínimo).

El modelo de abstracción utilizado ha sido ligeramente modificado para cada calle: En
el pre-flop almacenan un nodo para cada posible situación (sin abstracción) y en el
flop/turn/river se utilizó un algoritmo de k-medias modificado para hacer clustering sobre las
manos.

Cada mano se asigna a un punto de N-dimensiones con una función diferente para
cada calle. Estas fueron elegidas en su mayoría intuitivamente y cada punto se coordina como
(E [HS] o el más bajo (E [HS]) o el más alto (E [HS])), donde el mayor y menor muestran el rango
potencial de que se complete otra carta.

Para el river se utilizó E [HS] con algunos cambios en las medias del rango potencial de
las rondas anteriores.

• No Limit Bankroll: Hyperborean-BR
La técnica Hyperborean-BR empleó una variedad de técnicas diseñadas para explotar
el método tradicional de la lectura de los otros jugadores.

Se trata de manipular el tamaño del bote, de manera que no se distinga de su
oponente. Con el fin de aprovechar que su oponente realice una exploración en el comienzo
del juego, para crear un modelo en bruto de su oponente.

Las técnicas en No Limit son más complejas que en Limit, ya que un jugador puede
apostar todas sus fichas y esto hace que se obtengan peores resultados, sobre todo contra
jugadores humanos.



• No Limit Runoff: Hyperborean-EQM
La técnica Hyperborean-EQM fue creado usando las mismas técnicas utilizadas por la
Universidad de Alberta en el pasado, con la excepción de que ahora utiliza una lectura más
suave. Además, los métodos utilizados para crear la estrategia han sido optimizados para jugar
sin límite.

A continuación comparamos los resultados [7], en el tercer campeonato de póker de la
Universidad de Alberta, del Hyperborean-BR y del Hyperborean-Eqm, contra todas las parejas
de oponentes, de los diferentes equipos. Las unidades se presentan como pequeñas apuestas
por mano (small bets per hand (sb/h)).

Vemos, que la tasa de ganancia es positiva en todos los casos.

Si por ejemplo comparamos otros dos modelos (akuma y dpp):

Vemos que la tasa de ganancia contra los Hyperborean suele ser negativa.

Esto nos indica que son unos buenos modelos, para la competición.

• 3 player Bankroll && Runoff: Hyperborean-EQM

Se usó la ejecución de un CFR (counterfactual regret minimization) (reducción al
mínimo), durante varias semanas, para crear tres jugadores. Los jugadores resultantes eran
tan grandes (respecto a estados del juego), que se usó un grano más grueso para construirlos.
Se usan 16 categorías o rangos según la fuerza de la mano, donde el jugador olvida sus rangos
de las rondas anteriores.



2.2 Clústering para agrupar tipos de jugadores

Estas técnicas intentan inferir posibles conjuntos de tipos de jugadores.

Nos centraremos en la usada por un español [8].

Sus resultados no son buenos. Y estadísticamente ya existen otras soluciones
bastantes buenas, pero describiremos solamente el funcionamiento de esta.

Su fuente de información es una inmensa base de datos de más de 22 millones de
manos de Texas Hold’em No Limit 50. A esta base de datos con las 22 millones de manos,
hicieron diferentes filtros para poder tratar mejor la información (preproceso), seleccionando
los atributos más relevantes para después pasar al proceso de clusterización. Mediante el
análisis de tres experimentos, muestran las diferentes posibilidades que ofrecen los distintos
algoritmos más conocidos hoy en día: X-means, K-Means y EM.

Cometieron muchos errores, el más grave de los cuales fue subestimar el
preprocesamiento de los datos. Antes de lanzarse hacia un ejercicio de
clusterización debieron estudiar concienzudamente los datos a tratar. Si bien es
verdad que su primer error fue tratar con una base de datos demasiado escasa (por
los atributos que querían analizar), no es menos cierto que quizás el nivel escogido
tampoco fue el adecuado. Según palabras del autor:
“Debíamos haber tratado de importar una base de datos de un nivel
más elevado de juego (e.g. NL200+) dónde los jugadores son mucho más
sistemáticos jugando y no existe tanto jugador ocasional.“
Estos aspectos, que deberían haber tenido muy en cuenta antes de lanzarse
a la clusterización de los datos (y más con tantos atributos) ya que sólo que un
atributo contenga valores dispares puede hacer que toda la clusterización se vea
afectada (no digamos si son más de dos atributos los que tienen valores no
fidedignos). Es por esto, por lo que no han obtenido todo lo que cabía esperar de
sus experimentos, aunque en el último experimento, los resultados han sido muy
esperanzadores porqué se veía dónde estaba el problema y, consecuentemente, se
pasó a filtrar con muchas más manos y menos atributos.
Aún con todas las dificultades encontradas, gracias a todos los experimentos
realizados, llegaron a la conclusión que para su problema era mejor hacer uso del
algoritmo EM en contra de usar el K-medias.
Otro aspecto a tener en cuenta es que se enfrentaron a un problema “real”,
con una ingente cantidad de datos por filtrar. Sólo la importación de los datos ya ha
llevado más de 50 horas. Esto sumado a que la base de datos que crea el Holdem
Manager* no es conocida (hay muy poca documentación sobre cómo son las tablas)
ha hecho que dedicáramos mucho tiempo en hacer ingeniería inversa para poder
sacar los datasets.



Otra área muy interesante que podrían haber tratado, pero no fue posible por la
incoherencia de los resultados obtenidos es la de reglas de asociación. Las reglas de asociación
permiten atacar por otro bando el problema y podrían llegar a dar información muy
interesante acerca de cómo se comportan los perfiles de jugadores (en caso de conseguir
clusterizar) o jugadores aislados (en caso de no poder clusterizar). Un enfoque que sería muy
práctico sería el de ir definiendo acciones claves (a criterio de experto) para ver cómo actúa
cada perfil. Por ejemplo el comportamiento de un jugador cuando es robado por un perfil
agresor y tiene cartas Premium (KK++) de mano. Ir definiendo numerosas reglas de este estilo
e ir llenando nuestro data set con las distintas acciones que nos va respondiendo la base de
datos (e.g % de call, raise y fold). Hay que destacar que esta manera de tratar el problema es
mucho más compleja que la usada hasta ahora, ya que implica unas sentencias SQL mucho
más elaboradas y un agrupamiento en forma de Datasets muy complejo de realizar, pero es
mucho más interesante las reglas que podrían sacar así que no las reglas que sacarían si
tratáran la información como en el Clústering (con tantos por ciento de cada atributo).



3. DESCRIPCIÓN COMPLETA DE LOS
DATOS Y FUENTES EMPLEADOS
3.1 Datos de entrada
En este apartado nos centraremos en explicar la fuente principal de los datos, así como
una visión panorámica de los datos utilizados.

Para la adquisición de los datos hemos tenido diversos problemas, ya que estos datos,
comúnmente, son de uso privado, y en caso de querer adquirirlos serian de pago. Debido a
esto, nos resulto muy complicado encontrar datos útiles para el estudio. Por ello pedimos
datos en diversos blogs sobre póker online, así como contactando con los responsables de 3
webs, sin recibir respuesta alguna

Después decidimos pedir los datos en foros sobre póker online, en los cuales nos
pusieron varios inconvenientes. Nos dijeron que queríamos los datos para hacer trampas, que
no conseguiríamos llegar a ningún sitio con nuestro estudio, que no darían sus manos ya que
son de pago, etc.

Finalmente, un usuario del foro de poker-red accedió a darnos datos de manos que
disponía. En total eran 100000 manos de póker, con las cuales empezamos nuestro estudio.

El formato de los datos es XML, y en él se recogen los datos más importantes que se
deben recoger en una mesa de póker.



A continuación explicaremos globalmente el formato de los datos:

<general>

<mode>real</mode>

<gametype>Holdem NL 0.50/1</gametype>

<tablename>Aosta__No_DP_</tablename>

<duration>N/A</duration>

<gamecount>N/A</gamecount>
Información de la mano que comienza
<startdate>2009-10-20 13:21:35</startdate>

<currency>USD</currency>

<nickname>PokerHandScout.com</nickname>

<bets>N/A</bets>

<wins>N/A</wins>

<chipsin>N/A</chipsin>

<chipsout>N/A</chipsout>
Hora de inicio de la mano
<ipoints>N/A</ipoints>

</general>

<startdate>2009-10-20 13:58:22</startdate>

<players>

<player seat="4" name="ChandlerMBing" chips="$10000000" dealer="0" win="$0" bet="$0"
/><player seat="3" name="Hummelx2" chips="$10000000" dealer="0" win="$0" bet="$1"
/><player seat="2" name="fakinit" chips="$10000000" dealer="0" win="$39" bet="$20"
/><player seat="1" name="BowserJr" chips="$10000000" dealer="1" win="$0" bet="$20" />

</players>

Resumen de la mano para cada jugador (lo
que ha ganado, las fichas que tenia, su
posición en la mesa, si era mano, si era
ciega pequeña o grande y su nombre)



<round no="0"> Apuesta de ciegas

<action no="1" player="fakinit" type="1" sum="$0.50"/>

<action no="2" player="Hummelx2" type="2" sum="$1"/>
Numero de ronda
</round>

<round no="1">

<cards type="Pocket" player="BowserJr">c10 s10</cards>
Cartas de las que
<cards type="Pocket" player="fakinit">dJ cJ</cards>
dispone un jugador
<action no="3" player="ChandlerMBing" type="0" sum="$ 0"/>

<action no="4" player="BowserJr" type="23" sum="$3"/>

<action no="5" player="fakinit" type="23" sum="$20"/>

<action no="6" player="Hummelx2" type="0" sum="$ 0"/>
Apuestas
<action no="7" player="BowserJr" type="3" sum="$17"/>

</round>

<round no="2">

<cards type="Flop" player="">hJ cA s9</cards>

</round>

<round no="3">
Cartas comunes que se
<cards type="Turn" player="">d10</cards> van poniendo sobre la
</round> mesa

<round no="4">

<cards type="River" player="">cK</cards>

</round>



3.2 Datos adicionales
Información adicional podría ser otra información que tuviese el jugador, que no fuese sólo la
mesa de juego, los oponentes, las fichas y las cartas, es decir, que no fuese sólo la información
que te da la sala de póker, que es la mínima para poder jugar.

Existen programas que usan los datos de las manos para generar estadísticas de tus
contrincantes. Y estas estadísticas se pueden mostrar sobreimpresas en la mesa de la sala de
póker online. A esto se llama HUD (head up display).

A continuación mostramos una mesa sin HUD y después una con HUD:

Figura 1: Mesa de Póker sin HUD

Figura 2: Mesa de Póker con HUD
Estadísticas del HUD

Esta información define a los jugadores, pudiéndose así saber si el jugador va a muchas
manos o a pocas, si es agresivo o pasivo, etc.

La ventaja del póker online son estas herramientas que te dan información extra de
mucha utilidad durante el juego.

Tener esta información podría servir como información adicional a nuestros datos.



3.3 Datos de Salida

Los datos de entrada necesitan un procesamiento que se explicará en el siguiente
apartado. De nuestro clasificador se espera que, dada una mano, sepa qué decisión tomar en
cuanto a Retirarse (Fold), Igualar (Call), Subir N(Raise), Resubir N(Re-Raise). Suponemos que
dado que los datos originales son de límites altos en los que juegan profesionales, las
decisiones tomadas serán bastante acertadas.

En cuanto a la mano se necesitará toda la información que hemos mencionado en el
apartado 3.1.



4. PREPROCESADO DE LOS DATOS
4.1 Estudio de los datos

El primer paso de nuestra práctica fue estudiar el formato de los datos que nos
proporcionaron, para así saber que parte de ellos nos iban a ser realmente útiles para la
práctica.

Gracias a este análisis, nos dimos cuenta que los datos correspondían a manos en las
cuales solo se veían las cartas de cada jugador en el caso de que llegasen al showdown
(momento final de la mano). Esto es debido a que los datos son recogidos por aplicaciones que
están 24 horas al día visitando todas las mesas de las salas de póquer online, y almacenando lo
que ocurre en las manos. Estas aplicaciones ven las mesas como un mero espectador, sin
poder ver las cartas de los jugadores, a menos que estos las enseñen. Debido a ello, de esas
100000 manos iniciales, las que realmente nos iban a interesar eran muchas menos. Esto
provocó el desánimo, ya que parecía que iba a ser imposible obtener los datos que
necesitábamos.

Pero, finalmente, nos percatamos de que, cuando se mostraban las cartas, como
mínimo lo hacían dos jugadores, así que realmente disponíamos del doble o más, manos útiles,
por lo que el número total de manos a utilizar era de 10708.

4.2 Procesado de datos

A continuación comenzamos con el procesado de los ficheros XML. Nuestro propósito
es seleccionar una serie de atributos y clases, y utilizando la herramienta WEKA, realizar un
estudio de minería de datos. Para ello debíamos transformar los datos dados en el XML al
formato arff de WEKA.

Para crear nuestro fichero arff programamos en Java un parser que recibiese los
ficheros XML de las manos, seleccionase y transformase los datos necesarios para la
construcción de los atributos, y finalmente construyese el fichero arff con los atributos,
patrones y clases.

En este procesado nos dimos cuenta de que había errores en las manos. Por ejemplo,
había manos en las que a un jugador se le caía la conexión a internet mientras se jugaba,
teniendo que controlar esto para poder sacar las instancias. Y otra causa de error fue, una
mano en la que jugaban jugadores no pertenecientes a la mano, no aparecían en el resumen
(ver 3.1), pero sí en las apuestas, con lo cual desechamos la mano por estar corrompida.

Al terminar el procesado vimos que, había muchos atributos que se repetían en todos
los patrones, incluso en varios atributos de un mismo patrón (ejemplo: apuestas), siendo esta
redundancia negativa para el clasificador y posteriormente subsanada con las técnicas de
selección de atributos.



5. EXPLORACIÓN DE LOS DATOS

5.1 Clases

Trabajamos con el fichero patrones.arff con 10708 patrones, sacados de unas 100.000
manos de póker, de 1795 jugadores.

Tenemos 4 clases {0,1,2,3} que son valores continuos (0.0,1.0,2.0,3.0) pero los usaremos
para clasificación.

Un patrón está en una clase u otra en función del nivel de la apuesta del jugador al que
pertenece el patrón.

• Clase 0: Apuesta de $0 1050 patrones 9,8%

• Clase 1: Apuesta entre $0 y $2.5 3868 patrones 36,1%

• Clase 2: Apuesta entre $2.5 y $5 4193 patrones 39,2%

• Clase 3: Apuesta superior a $5 1597 patrones 14,9%

De las 10708 instancias que hay en total, un 9,8% de los datos son de la clase 0, un 36,1%
son de la clase 1, un 39,2% de la clase 2,y un 14,9% de la clase 3. Al no encontrarse en la
misma proporción, están desequilibradas. Y sería bueno, para que se clasifiquen bien, que
estuvieran mejor equilibradas, pero no hemos conseguido ajustar a nivel de apuesta que haga
que estén mejor equilibradas las clases.



5.2 Clasificadores

El primer paso que haremos será probar nuestros datos con una serie de clasificadores
lineales y no lineales, para analizar estos resultados y poder centrarnos en los mejores
clasificadores, para en siguientes apartados filtrar los datos y ajustar mejor los parámetros de
los clasificadores.

Para realizar las pruebas, Java, muchas veces se quedaba sin memoria:

Por lo que ampliamos la memoria usada, a 512 Mb, con el comando:

java -jar -Xmx512m weka.jar

Para todas las pruebas se ha usado la opción de Percentage Split al 66% (train = 66% y test
= 33%) lo que dan 7067 instancias para entrenamiento de las 10708 del total. En algunas
pruebas, como complemento, se ha probado a usar el conjunto de entrenamiento para hacer
el test, y en estas pruebas explicaremos la razón de usarlo.

Además se ha marcado la opción, de conservar el orden de los patrones, marcada, ya que
si no Weka los desordena aleatoriamente, y esto es innecesario, ya que los datos ya son
aleatorios.



• CLASIFICADORES LINEALES: Separan los datos con fronteras de separación
lineales (plano o hiperplano).

o SMO

Soluciona problemas multiclase usando clasificación por parejas. En los
casos multi-clase las probabilidades predichas se juntaran usando los
métodos de emparejamiento Hastie y Tibshirani.

Obtenemos los siguientes resultados:

=== Evaluation on test split ===
=== Summary ===

Correctly Classified Instances 1793 49.2447 %
Incorrectly Classified Instances 1848 50.7553 %
Kappa statistic 0.1885
Mean absolute error 0.3093
Root mean squared error 0.3956
Relative absolute error 90.2991 %
Root relative squared error 95.4496 %
Total Number of Instances 3641

=== Detailed Accuracy By Class ===

TP Rate FP Rate Precision Recall F-Measure ROC Area Class
0 0 0 0 0 0.807 0.0
0.67 0.418 0.48 0.67 0.559 0.647 1.0
0.644 0.393 0.505 0.644 0.566 0.644 2.0
0.002 0 1 0.002 0.004 0.736 3.0
Weighted Avg. 0.492 0.304 0.514 0.492 0.422 0.675

=== Confusion Matrix ===

a b c d <-- classified as
0 354 33 0 | a = 0.0
0 892 440 0 | b = 1.0
0 497 900 0 | c = 2.0



o Logistic

Crea y utiliza un modelo de regresión logística multinomial con un
estimador. Hay algunas modificaciones del modelo propuesto por
leCessie y van Houwelingen.

=== Summary ===



0.282 0.028 0.542 0.282 0.371 0.845 0.0
0.58 0.332 0.502 0.58 0.538 0.674 1.0
0.631 0.373 0.513 0.631 0.566 0.679 2.0
0.19 0.027 0.546 0.19 0.282 0.801 3.0
Weighted Avg. 0.512 0.271 0.517 0.512 0.494 0.713


109 240 36 2 | a = 0.0
81 773 465 13 | b = 1.0
o
11 437 881 68 | c = 2.0
o

o Simple Logistic

Clasificador lineal para la construcción de modelos de regresión logística.

=== Summary ===



0.261 0.026 0.549 0.261 0.354 0.845 0.0
0.586 0.333 0.504 0.586 0.541 0.675 1.0
0.635 0.375 0.513 0.635 0.567 0.68 2.0
0.185 0.026 0.542 0.185 0.276 0.801 3.0
Weighted Avg. 0.512 0.272 0.518 0.512 0.493 0.713


101 248 36 2 | a = 0.0
72 780 467 13 | b = 1.0
11 432 887 67 | c = 2.0



o Perceptron Simple

Para este clasificador usamos el Multilayer Perceptron con ninguna
capa oculta.


=== Summary ===



0.189 0.018 0.557 0.189 0.282 0.826 0.0
0.045 0.035 0.426 0.045 0.081 0.598 1.0
0.947 0.863 0.406 0.947 0.568 0.58 2.0
0.11 0.016 0.532 0.11 0.183 0.734 3.0
Weighted Avg. 0.416 0.348 0.447 0.416 0.304 0.635


73 36 276 2 | a = 0.0
48 60 1210 14 | b = 1.0
7 32 1323 35 | c = 2.0



o Naive Bayes

Clasificador bayesiano cuyos atributos numéricos son modelados como
una distribución normal. Es un Clasificador discriminador bayes standard. Para
combinar las probabilidades de los distintos atributos asume que estas son
independientes entre sí.

=== Summary ===



0.817 0.208 0.319 0.817 0.458 0.87 0.0
0.491 0.292 0.492 0.491 0.492 0.625 1.0
0.448 0.245 0.533 0.448 0.487 0.663 2.0
0.147 0.022 0.527 0.147 0.23 0.792 3.0
Weighted Avg. 0.459 0.226 0.494 0.459 0.448 0.69


316 63 5 3 | a = 0.0
409 654 255 14 | b = 1.0
227 492 626 52 | c = 2.0



o Bayes Net

Red Bayesiana de aprendizaje que utiliza diferentes algoritmos de
búsqueda y medidas de calidad. Proporciona una serie de estructuras de datos
(estructura de la red, distribuciones de probabilidad condicional, etc), comunes
a la Red de aprendizaje de los algoritmos de Bayes como K2 y B.

=== Summary ===



0.687 0.061 0.573 0.687 0.625 0.932 0.0
0.524 0.226 0.572 0.524 0.547 0.721 1.0
0.67 0.344 0.548 0.67 0.603 0.728 2.0
0.227 0.042 0.478 0.227 0.307 0.811 3.0
Weighted Avg. 0.555 0.227 0.549 0.555 0.542 0.759


266 75 45 1 | a = 0.0
116 698 466 52 | b = 1.0
72 312 936 77 | c = 2.0



• CLASIFICADORES NO LINEALES: Separan los datos con fronteras de separación
no lineales.
o J48

Se trata de una implementación propia de WEKA para el algoritmo
C4.5, un algoritmo basado en clasificación por árbol de decisión.


=== Summary ===



0.827 0.027 0.782 0.827 0.804 0.923 0.0
0.592 0.197 0.634 0.592 0.612 0.727 1.0
0.663 0.259 0.614 0.663 0.638 0.712 2.0
0.455 0.077 0.499 0.455 0.476 0.738 3.0
Weighted Avg. 0.625 0.186 0.623 0.625 0.623 0.743


320 28 28 11 | a = 0.0
37 789 404 102 | b = 1.0
43 301 926 127 | c = 2.0

o Ordinal Class Classifier (J48)

Meta clasificador que permite que la clasificación estándar de
algoritmos sea aplicada a problemas ordinarios de clasificación.
Usamos, ahora, el j48. Y vemos que mejora de manera muy superflua:
=== Summary ===



0.829 0.012 0.889 0.829 0.858 0.947 0.0
0.612 0.196 0.643 0.612 0.627 0.735 1.0
0.658 0.299 0.578 0.658 0.615 0.688 2.0
0.419 0.065 0.52 0.419 0.464 0.738 3.0
Weighted Avg. 0.625 0.197 0.627 0.625 0.624 0.74


321 41 21 4 | a = 0.0
3 815 439 75 | b = 1.0
32 322 919 124 | c = 2.0



o Multilayer Perceptron (train = 66%)

Redes neuronales en formas de perceptrón muliticapa entrenadas con
el algoritmo backpropagation.
Para este modelo se probó con un 66% de los datos para
entrenamiento y un 33% para test. Después se probará también con "
Use training set", que hace test con los mismos datos con los que
entrena, para ver si hay mucha diferencia en los aciertos, como es
lógico esperar. Al tener un 33% para test, los resultados de este serán
lógicamente peores, pero comparando los dos tipos podremos saber
como de buenos son realmente estos resultados.
El número de capas ocultas usado fue el valor por defecto,
Y como ya dijimos al principio, conservando el orden original de los
datos.


=== Summary ===



0.804 0.037 0.718 0.804 0.759 0.953 0.0
0.523 0.194 0.609 0.523 0.563 0.726 1.0
0.689 0.285 0.601 0.689 0.642 0.761 2.0
0.467 0.069 0.531 0.467 0.497 0.858 3.0
Weighted Avg. 0.609 0.194 0.606 0.609 0.605 0.783


311 57 6 13 | a = 0.0
76 697 467 92 | b = 1.0
28 295 963 111 | c = 2.0



o Ordinal Class Classifier (MLP train = 66%)

Probamos el mismo meta clasificador que antes, pero usando como
algoritmo el perceptrón multicapa, con la misma configuración que en
el ejemplo anterior.
Observamos que no hay mejora, aunque la variación en el porcentaje
de aciertos es muy leve:

=== Summary ===



0.822 0.033 0.748 0.822 0.783 0.959 0.0
0.519 0.179 0.625 0.519 0.567 0.747 1.0
0.686 0.315 0.576 0.686 0.626 0.736 2.0
0.421 0.072 0.496 0.421 0.455 0.809 3.0
Weighted Avg. 0.601 0.2 0.601 0.601 0.597 0.774


318 48 15 6 | a = 0.0
58 691 497 86 | b = 1.0
32 273 959 133 | c = 2.0



o Multilayer Perceptron (test = train)

Para este modelo se probó también el MLP, pero con " Use training
set", que hace test con los mismos datos con los que entrena.
Hicimos esto, para ver si hay mucha diferencia en los aciertos, como es
lógico esperar. Ya que si el modelo construido es bueno, si se pone a
prueba con los patrones de entrenamiento, debería de obtener unos
muy buenos resultados.
El número de capas ocultas usado fue el valor por defecto,
Y conservando el orden original de los datos.


=== Evaluation on training set ===
=== Summary ===



0.761 0.021 0.797 0.761 0.779 0.944 0.0
0.785 0.375 0.542 0.785 0.641 0.789 1.0
0.462 0.112 0.726 0.462 0.564 0.792 2.0
0.53 0.065 0.59 0.53 0.559 0.873 3.0
Weighted Avg. 0.618 0.191 0.646 0.618 0.612 0.818


799 226 9 16 | a = 0.0
100 3036 533 199 | b = 1.0
66 1818 1936 373 | c = 2.0

Vemos que no hay una mejora sustancial como pensamos que debería
suceder.



o Ordinal Class Classifier (test = train)

Con el MLP anterior, también decidimos probar el meta clasificador,
usando "Use training set" y con la misma configuración que en el
ejemplo anterior.
Observamos que hay mejora, aunque la variación en el porcentaje de
aciertos es muy pequeña, vemos en la matriz de confusión que clasifica
mejor, y suele tener menos fallos:

=== Evaluation on training set ===
=== Summary ===



0.83 0.024 0.792 0.83 0.811 0.963 0.0
0.795 0.345 0.566 0.795 0.661 0.801 1.0
0.557 0.155 0.699 0.557 0.62 0.802 2.0
0.389 0.022 0.755 0.389 0.514 0.863 3.0
Weighted Avg. 0.645 0.191 0.668 0.645 0.638 0.827


872 163 11 4 | a = 0.0
135 3076 582 75 | b = 1.0
60 1674 2336 123 | c = 2.0



o RBFNetwork

Redes de funciones de base radial. Con train = 66% y conservando el
orden original. Tenemos los resultados:

=== Summary ===



0.677 0.081 0.497 0.677 0.573 0.915 0.0
0.52 0.261 0.535 0.52 0.528 0.687 1.0
0.626 0.363 0.518 0.626 0.567 0.682 2.0
0.137 0.018 0.558 0.137 0.22 0.767 3.0
Weighted Avg. 0.522 0.246 0.528 0.522 0.503 0.721


262 110 13 2 | a = 0.0
161 693 465 13 | b = 1.0
80 400 875 42 | c = 2.0

o REPTree

Es un método de aprendizaje rápido mediante árboles de decisión.
Construye un árbol de decisión usando la información de varianza y lo
poda usando como criterio la reducción del error. Solamente clasifica
valores para atributos numéricos una vez. Los valores que faltan se
obtienen partiendo las correspondientes instancias. Vemos que:

=== Summary ===



0.755 0.046 0.661 0.755 0.704 0.921 0.0
0.573 0.237 0.582 0.573 0.577 0.726 1.0
0.609 0.256 0.597 0.609 0.603 0.723 2.0
0.451 0.073 0.512 0.451 0.48 0.814 3.0
Weighted Avg. 0.589 0.2 0.586 0.589 0.587 0.758


292 75 17 3 | a = 0.0
101 763 402 66 | b = 1.0
41 348 851 157 | c = 2.0



5.3 Resultados
En resumen, tenemos los siguientes resultados:

Clasificadores Lineales Algoritmo % Aciertos % Error Absoluto
Media Aciertos =49,1028% SMO 49.2447 % 90.2991 %
Media Error = 87,5366% Logistic 51.1673 % 88.441 %
Simple Logistic 51.2222 % 88.6475 %
Perceptrón Simple 41.582 % 88.0926 %
Naive Bayes 45.9489 % 88.2112 %
Bayes Net 55.4518 % 81.5284 %
Clasificadores No Lineales Algoritmo % Aciertos % Error Absoluto
Media Aciertos = 60,4144% J48 62.4554 % 61.4247 %
Media Error =69,8297% OrdinalClassClassifier 62.4828 % 62.8628 %
(J48)
Multilayer Perceptron 60.8624 % 71.6913 %
(train=66%)
OrdinalClassClassifier 60.1208 % 67.9233 %
(MLP train=66%)
Multilayer Perceptron 61.8043 % 70.5073 %
(test=train)
OrdinalClassClassifier 64.4938 % 63.7474 %
(MLP test=train)
RBFNetwork 52.2384 % 86.9388 %
REPTree 58.8575 % 73.5421 %

Con los nuevos atributos (MiPosición, Pareja, Consecutivas) los resultados mejoran
notablemente a las pruebas iniciales que hicimos con los atributos antiguos, en la entrega
intermedia, del cuatrimestre. En estas teníamos entre un 43 y 46% con MLP, y con J48
teníamos 47.8369 %, usando 70% de train y 30% de test. La diferencia en los aciertos es
sustancial.

Como vemos en los resultados, para nuestro problema, los clasificadores no lineales
han tenido una media de aciertos mayor que la de los clasificadores lineales. Cualquier
clasificador no lineal, mejora al mejor de los clasificadores lineales.

Las pruebas de MLP y su meta clasificador, con test igual que entrenamiento, nos las
tendremos en cuenta para la comparativa final, ya que son los únicos que han sido testados
con el mismo conjunto de entrenamiento.

Si tuviéramos que elegir un algoritmo, de entre todos los probados, para resolver el
problema nos quedaríamos con el J48 por diversos motivos:
o Aunque el MLP (train = 66%) y su MetaClasificador del MLP (train = 66%) son
bastante buenos, no mejoran al J48, ni a su meta clasificador.
o Con el J48 podemos interpretar los resultados leyendo el árbol.
o El tiempo de ejecución del MLP es mayor y hace más incómodas las pruebas.
o No elegimos el metaclasificador del J48, ya que no entendemos muy bien el
funcionamiento de estos algoritmos, pero de lo que si estamos seguros es de
que no son una gran mejora.



Aunque, elegiremos el algoritmo J48 y el MLP para continuar la exploración de los
datos, ya que son los mejores en los resultados, y queremos seguir comparándolos y
puliéndolos para mejorar más sus resultados.

Con los resultados obtenidos no podemos considerar que los resultados obtenidos son
buenos, porque los errores son muy grandes. Pero teniendo en cuenta que las clases están
desequilibradas, los resultados son algo más aceptables.

Además el problema es bastante complicado para los pocos patrones de los que
disponemos.

Si tenemos en cuenta que los datos no son de un solo jugador, sino de 1795, lo que
significa que el comportamiento que se está intentando predecir es un comportamiento muy
general, donde el factor humano altera mucho el aprendizaje de los clasificadores.

Además, aún los datos no han sido filtrados, y como ya sabemos, tenemos muchos
datos superfluos e incorrectos, como el stack de los jugadores.

Una primera aproximación a decir que atributos son los más relevantes para la tarea
de clasificación, y así poder descartar otras sería ver que atributos están en la cima del árbol
que nos da el J48. Esto, en cambio, no se podría hacer con el MLP.

También podríamos decrementar el Confidence Factor para obtener un árbol más
pequeño y así poder estudiarlo mejor



6. SELECCIÓN DE ATRIBUTOS
Podemos dividir los métodos de selección de atributos en:

1. Evaluación individual de atributos (Ranker)

2. Evaluación de subconjuntos de atributos

a. Filter: se evalúan los atributos de manera individual, pero tiene en
cuenta la redundancia entre atributos.

b. Wrapper: se evalúan de manera conjunta.

Hay que definir:

• Una manera de moverse por el espacio de búsqueda (lo que llamaremos
método de búsqueda).

• Una manera (medida) de evaluar subconjuntos de atributos (lo que llamaremos
evaluador de atributos).



6.1 Técnicas de selección de atributos.
A continuación explicamos las técnicas usadas y sus resultados:

• Selección Ranker:

o Evaluador de atributos: ChiSquaredAttributeEval.

o Método de búsqueda: Ranker.

o Modo de selección de atributos: Use training set.

ChiSquaredAttributeEval: usa el estadístico Chi-squared para evaluar el valor
predictivo del atributo.

Obtenemos los atributos, seleccionados de manera individual por el valor de
correlación del atributo, ordenados de mejor a peor. No detecta correlación
conjunta. Y al contrario que Filter, no detecta redundancias en los atributos:

=== Attribute Selection on all input data ===

Search Method:
Attribute ranking.

Attribute Evaluator (supervised, Class (nominal): 31 class):
Chi-squared Ranking Filter

Ranked attributes:
1354.5475 18 MiPosicion
960.8091 26 ValorSubida1
816.5711 22 ValorCarta2
787.1046 20 ValorCarta1
525.3871 24 Pareja
167.0821 23 Suited
52.7871 5 JugadoresTotales
52.7871 7 FichasJugador6
52.7871 6 PosicionJugador6
28.0305 25 Consecutivas
0 2 CiegaGrande.
.
.
Selected attributes:
18,26,27,28,22,20,29,24,30,23,5,7,6,25,9,8,11,10,2,1,4,3,17,16,21,19,13,12,15,
14 : 30



• Selección Filter:

o Evaluador de atributos: CfsSubsetEval.

o Método de búsqueda: GreedyStepwise.

o Modo de selección de atributos: Use training set.

Filter es una técnica de evaluación de subcojuntos de atributos, pero no detecta
correlación conjunta.

Obtenemos un subconjunto, de atributos correlacionados entre sí, de los
mejores atributos:


Search Method:
Greedy Stepwise (forwards).
Start set: no attributes
Merit of best subset found: 0.09

Attribute Subset Evaluator (supervised, Class (nominal): 31 class):
CFS Subset Evaluator
Including locally predictive attributes

Selected attributes: 18,20,22,24,26,27,28,29,30 : 9
MiPosicion
ValorCarta1
ValorCarta2
Pareja
ValorSubida1
ValorSubida2
ValorSubida3
ValorSubida4
ValorSubida5

Filter penaliza los atributos redundantes. Tener atributos redundantes es como
tener el mismo atributo repetido. Así se le está dando más peso al atributo, y
esto no es correcto.



• Selección Wrapper:

o Evaluador de atributos: ClassifierSubsetEval.

Usando PART como clasificador.

Usando el conjunto de entrenamiento para calcular los
aciertos.

o Método de búsqueda: GreedyStepwise.

o Modo de selección de atributos: Use training set

Esta es una técnica de evaluación de subconjuntos de atributos, como Filter,
pero mucho más lenta, aunque más eficaz. Evalúa el subconjunto de atributos
ejecutando un algoritmo de minearía de datos concreto, sobre un conjunto de
entrenamiento. El algoritmo elegido ha sido PART.

Después de 12 horas ejecutando conseguimos que terminase, con el siguiente
subconjunto de atributos seleccionados:


Search Method:
Greedy Stepwise (forwards).
Start set: no attributes
Merit of best subset found: 0.089

Attribute Subset Evaluator (supervised, Class (nominal): 31 class):
Classifier Subset Evaluator
Learning scheme: weka.classifiers.rules.PART
Scheme options: -M 2 -C 0.25 -Q 1
Hold out/test set: Training data
Accuracy estimation: classification error

Selected attributes: 3,4,5,18,19,20,21,22,23,24,25,26,27,28,29,30 : 16
Hora
Minuto
JugadoresTotales
MiPosicion
PaloCarta1
ValorCarta1
PaloCarta2
ValorCarta2
Suited
Pareja
Consecutivas
ValorSubida1
ValorSubida2
ValorSubida3
ValorSubida4

Esta técnica es más lenta en ejecución que Filter y Ranker, pero da mejores
resultados. Para problemas sencillos, no haría falta y aparentemente no merece
la pena porque el tiempo que necesita es muy elevado, pero pensamos que en
nuestro problema, al haber tantos atributos que siempre tenían el mismo valor,
iba a ser importante hacer una selección buena de los atributos. Con las
pruebas siguientes corroboraremos si ha merecido la pena la espera.



6.2 Ranker

A continuación, utilizando Ranker, realizaremos una gráfica que muestre como varía el
porcentaje de aciertos en función del número de atributos considerados. La gráfica tiene un
punto cada 5 atributos. Esto quiere decir que la gráfica tendrá 30/5 = 6 puntos.

Para realizar las pruebas en Weka, en Reprocess aplicamos un filtro a los patrones,en
Attribute Selection y como evaluador elegimos ChiSquaredAttributeEval y como
método de búsqueda Ranker. También en Select Attributes podríamos habernos
guardado los datos después de haber hecho la selección de atributos, ya que Weka te
da esa opción.

Después vamos cogiendo grupos de atributos, múltiplos de 5 y ejecutando los
algoritmos de clasificación (J48 y MLP).

Número Atributos % Aciertos J48 % Aciertos MLP
5 53.337 % 44.9602 %
10 59.1046 % 52.3483 %
15 64.0483 % 60.7525 %
20 64.3505 % 62.8673 %
25 62.1533 % 61.8511 %
30 62.0983 % 60.3406 %

Si mostramos en una gráfica los datos, podemos ver como varia el porcentaje de
aciertos en función del número de atributos considerados.

Vemos que el J48 siempre va por delante del MLP. Al principio, las dos gráficas van
aumentando progresivamente, hasta alcanzar un máximo, para después estabilizarse e
ir decrementando poco a poco. Seleccionando los mejores 20 atributos del Ranker,
vemos que obtenemos los mejores resultados para ambos clasificadores.



Después de ver estos buenos resultados, decidimos intentar ver de manera gráfica la
separación entre las clases utilizando alguna pareja de los mejores atributos
seleccionados.

Ejecutamos el clasificador (J48) con los dos mejores atributos seleccionados con
Ranker (MiPosicion eje X y ValorSubida1 eje Y).

En Visualize podemos ver la separación de los patrones en clases (0, 1, 2 y 3):

No se ven conjuntos claramente repartidos, ya que se entremezclan bastantes los
patrones. La visualización no es la mejor, quizás una vista en tres dimensiones nos
ayudaría más a ver la separación. Lo que se puede apreciar es en cada montículo una
base de la clase 2, acompañada a veces por la clase 0, pero esto es sólo en algunos
valores de ValorSubida1. En la parte intermedia la clase 1. Y en la parte más superior
sobre todo la clase 3. El hecho de elegir los dos mejores atributos es el que favorece
que se separen mejor los datos, ya que hicimos pruebas con otras parejas de entre los
mejores atributos y los patrones se entremezclaban mucho más en la gráfica.



6.3 Filter

Ahora, probamos a utilizar Filter para comparar los dos clasificadores (J48 y MLP).

Filter nos arrojaba los 9 mejores atributos, que nos da unos aciertos:

% Aciertos J48 % Aciertos MLP
58.83 % 52.4032 %

Vemos que son unos resultados bastante pobres, aunque de nuevo el J48 mejora al
MLP, en aciertos y en todas las ventajas adicionales que este modelo conlleva.

6.4 Wrapper

Finalmente, probamos con el último selector de atributos, el cual nos da mayores
esperanzas de obtener unos muy buenos resultados.

Wrapper nos daba los mejores 16 atributos de entre los 31, tardando 12 horas en
darnos este subconjunto.

% Aciertos J48 % Aciertos MLP
61.5216 % 61.4392 %

Vemos que los resultados son bueno, y que el J48 está muy parejo a los resultados del
MLP.

6.5 Comparativa resultados selectores de atributos

Para ver que selector o selectores son mejores y poder elegir estos para trabajar con el
experimenter, realizamos una comparativa.

Selector de atributos % Aciertos J48 % Aciertos MLP
Ranker (20 atributos) 64.3505 % 62.8673 %
Filter (9 atributos) 58.83 % 52.4032 %
Wrapper (16 atributos) 61.5216 % 61.4392 %
Sin selección de 62.4554 % 60.8624 %
atributos (30 atributos)

Además de los selectores se incluyen los resultados en la exploración, con todos los
atributos, es decir, con los datos originales.



Para cada gráfica por separado, vemos que el Filter es el peor selector, incluso
comparándolo con los resultados de los datos originales. Con lo cuál no lo usaremos
para el experimenter de Weka.

El Ranker y Wrapper, son bastante parecidos en los resultados, aunque el Ranker ha
resultado mejor. Incluso el Wrapper no mejora los resultados originales. A priori,
pensábamos que el Wrapper iba a dar mejores resultados, ya que este es muy lento,
pero muy potente. Vemos que no ha merecido la pena esperar tanto tiempo por el
Wrapper, pero los atributos que nos arrojaba, a simple vista parecían bastante
interesantes, desde el punto de vista de un jugador profesional.

Importantes para saber cuando los jugadores piensan más sus
Hora acciones, siendo más racionales o las piensan menos siendo más
Minuto irracionales
JugadoresTotales Cuántos son nuestros adversarios es muy importante
MiPosicion Saber donde estoy situado en la mesa es primordial, ya que si
PaloCarta1 hablo más tarde tengo ventaja sobre los demás
ValorCarta1
PaloCarta2 Las cartas son con lo segundo con lo que se gana en el póker

ValorCarta2
Estas propiedades nos darán mayor expectativa, ayudándonos a
Suited ligar jugadas fuertes, siendo un buen aliciente para jugar las
Pareja cartas
Consecutivas
ValorSubida1 Con las apuestas es lo primero con lo que se gana en el póker,
ValorSubida2 así que tengo que saber las apuestas de los otros jugadores para
ValorSubida3 saber como de buenas son sus cartas
ValorSubida4

Cabe destacar que aunque la hora si puede influir en las cartas con las que jugar, no
entendemos muy bien porque el minuto le parece al Wrapper que es importante.
Suponemos que habrá obtenido una buena razón para llegar a esta conclusión.



6.6 Aprendizaje de las clases
En este apartado veremos si las distintas clases se aprenden de manera desequilibrada
y cuáles se aprenden mejor. Usaremos el Ranker con 20 atributos, ya que es el que
ofrece mejores resultados, tanto para el J48, como para el MLP.

Al estar las clases desequilibradas, la clase que tenga más representación en los datos
va a tener más aciertos en el test.

Como vimos en el primer punto de la experimentación, un 9,8% de los datos son de la
clase 0, un 36,1% son de la clase 1, un 39,2% de la clase 2, y un 14,9% de la clase 3.

En la matriz de confusión podemos ver cuanto se equivoca y acierta el clasificador, en
el test, que coge un 33% de los datos (3641 instancias). En la primera fila están los
patrones que son de la clase 0 y que fueron clasificados como de la clase 0, 1,2 y 3. La
segunda fila con la clase 1, la tercera con la clase 2 y la cuarta con la clase 3. En la
diagonal central, se pueden ver los aciertos. Y en los bordes los fallos.

J48 MLP
=== Confusion Matrix === === Confusion Matrix ===

a b c d <-- classified as a b c d <-- classified as
329 26 27 5 | a = 0.0 334 36 15 2 | a = 0.0
36 831 367 98 | b = 1.0 84 678 520 50 | b = 1.0
36 280 949 132 | c = 2.0 40 219 1072 66 | c = 2.0
8 130 153 234 | d = 3.0 28 92 200 205 | d = 3.0

También nos ayuda el porcentaje de aciertos (TP Rate) de cada clase:

J48

0.85 0.025 0.804 0.85 0.827 0.934 0.0
0.624 0.189 0.656 0.624 0.639 0.771 1.0
0.679 0.244 0.634 0.679 0.656 0.75 2.0
0.446 0.075 0.499 0.446 0.471 0.791 3.0
Weighted Avg. 0.644 0.176 0.641 0.644 0.641 0.783

MLP

0.863 0.047 0.687 0.863 0.765 0.965 0.0
0.509 0.15 0.661 0.509 0.575 0.776 1.0
0.767 0.328 0.593 0.767 0.669 0.787 2.0
0.39 0.038 0.635 0.39 0.483 0.853 3.0
Weighted Avg. 0.629 0.191 0.634 0.629 0.618 0.812

El TP Rate se calcula dividiendo el número de casos en que acertó, entre el número de
casos totales. Para la clase 0,en el J48, sería: 329/(329+26+27+5)=0.85. Nos dice que el
porcentaje de aciertos en los test, para los patrones de la clase 0 es del 85%



Las clases que tenían más representación en los datos eran la 1 y la 2. Pero aún así no
son las clases que mejor se aprenden, teniendo más aciertos, ya que es la clase 0, la
que mejor se aprenden (J48 y MLP).

Podríamos equilibrar el porcentaje de aciertos de las distintas clases usando un
metaclasificador. Nosotros usamos MetaCost. La mayoría de maneras existentes de
equilibrar o balacear los datos, usan costos haciendo una modificación al algoritmo de
clasificación, pero Metacost utiliza los costos fuera de este, con una técnica de
envoltura (wrapping). En MetaCost se crean réplicas del conjunto de entrenamiento
con bootstrap y hace un ensamble con bagging (con votación) para calcular la
probabilidad de clase de cada ejemplo (utiliza la fracción de los votos del ensamble
que corresponde a cada clase). Después se reetiqueta cada ejemplo con la clase
óptima estimada al incluir una matriz de costos (multiplica la probabilidad del ejemplo
de pertenecer a la clase óptima por el costo asociado) y reaplica el clasificador al
conjunto reetiquetado.

Como parámetros hay que pasarle el clasificador que estamos usando (J48 y MLP) para
la exploración de los datos y la matriz de costos, formada por probabilidades (números
decimales entre 0 y 1).

En la matriz de costos daremos menos probabilidad a las clases más desequilibrada
(con menos datos) y más probabilidad a las clases con más datos. En nuestro caso, un
9,8% de los datos son de la clase 0, un 36,1% son de la clase 1, un 39,2% de la clase 2, y
un 14,9% de la clase 3. Por lo tanto a la clase 0 y 3, le daremos menos probabilidad, ya
que tiene menos datos. La matriz de costos que usamos es la siguiente:

Damos un 25% a la clase 0, porque es la que tiene instancias, así el clasificador
intentará clasificar más patrones como de esta clase. A las clases 1 y 2 les damos un
75%, ya que son las dos clases que tiene más datos, casi igualmente repartidos. Y
finalmente a la clase 3 le daremos un 50% ya que tiene más datos que la clase 0, pero
pocos con respecto a la clase 1 y 2.

Si comparamos los resultados aplicando nuestros clasificadores, sin Metacost, con los
resultados obtenidos después de aplicarlo, tenemos:

J48 (sin metacost) J48 (con metacost)

329 26 27 5 | a = 0.0 341 25 14 7 | a = 0.0
36 831 367 98 | b = 1.0 37 773 369 153 | b = 1.0
36 280 949 132 | c = 2.0 45 289 913 150 | c = 2.0
8 130 153 234 | d = 3.0 7 98 121 299 | d = 3.0



MLP (sin metacost) MLP (con metacost)

334 36 15 2 | a = 0.0 325 37 7 18 | a = 0.0
84 678 520 50 | b = 1.0 108 650 412 162 | b = 1.0
40 219 1072 66 | c = 2.0 43 223 928 203 | c = 2.0
28 92 200 205 | d = 3.0 29 64 106 326 | d = 3.0

Vemos que el porcentaje de aciertos de las clases 0 y 3 aumenta, y en cambio para las
clases 1 y 2 disminuye. Vemos que a costa de empeorar la clase 1 y 2, se puede
conseguir que las clases 0 y 3 mejoren. Datos que antes se etiquetaban como de las
clases 1 y 2, ahora los etiqueta como de las clases 0 y 3.



7. EXPERIMENTACIÓN
A continuación, usando el Experimenter de Weka, haremos una experimentación con
los mejores algoritmos encontrados en la fase de exploración. El objetivo es comprobar si
alguno de los algoritmos es mejor de manera significativa que los demás. Probaremos los
mismos algoritmos cambiando el conjunto de datos, haciendo validación cruzada, y
especialmente, utilizándolos junto con algoritmos de selección de atributos, ya que estos
funcionaron bastante bien.

El Experimenter de Weka sirve para aplicar varios algoritmos de aprendizaje
automático sobre distintos conjuntos de datos. Y determinar de manera estadística cual se
comporta mejor.

En la fase de exploración conseguimos los mejores porcentajes de aciertos con un
grupo de los 20 mejores atributos obtenidos con Ranker y con los 16 atributos obtenidos con
Wrapper. Así que probaremos dos tipos de conjuntos de datos, que fueron filtrados de esta
manera, siendo el primero de ellos el del Wrapper y el segundo el del Ranker. Con esto
podremos realizar un contraste de hipótesis y ver que las diferencias son verdaderas, para así
poder descartar la casualidad.

Usamos Cross-Validation, con un tamaño de celda (Fold) de 10. Cada experimento se
repitió 10 veces. Y tomamos como algoritmo base el J48, ya que es el que nos ha dado mejores
resultados. Como algoritmo para comparar con el base tenemos el MLP, con hidden = a, que es
el segundo mejor algoritmo, para nuestro problema.

Después de más de 6 horas, obtenemos:

Dataset (1) trees.J48 '-C | (2) functions.M
--------------------------------------------------------------
'PatronesNL100-weka.filte(100) 61.52(1.50) | 61.60(1.78)
'PatronesNL100-weka.filte(100) 64.34(1.46) | 61.43(1.67) *
--------------------------------------------------------------
(v/ /*) | (0/1/1)

La nomenclatura (X,Y,Z), dice que X es el número de datasets en los que el algoritmo es
significativamente mejor que el algoritmo base. Y, que no es ni mejor ni peor. Y Z, que es
significativamente peor.

Como vemos, los resultados están bastante más igualados, que los resultados que
obtuvimos en la fase de exploración. El MLP llega a mejorar algo al J48 en los experimentos
con el conjunto de datos de Wrapper, pero empeora con los datos de los mejores 20 atributos
del Ranker.

Con estos resultados podemos descartar que la casualidad nos hiciera obtener los
resultados que obtuvimos en la fase de exploración de los datos, así que vamos a comparar
los resultados que obtuvimos en Explorer con los del Experimenter, tenemos:



Técnica usada J48 MLP
%Aciertos Explorer 61.5216 % 61.4392 %
(Wrapper)
%Aciertos Experimenter 61.52 % 61.60%
(Wrapper)
%Aciertos Explorer 64.3505 % 62.8673 %
(Ranker)
%Aciertos Experimenter 64.34 % 61.43 %
(Ranker)

Los resultados del Experimenter son bastante parecidos a los del Explorer. En el
Explorer obteníamos que el mejor resultado era el Ranker, y con el Experimenter también. En
el Explorer también obteníamos resultados bastante parecidos entre J48 y MLP, aunque
siempre era superior el J48, pero en el Experimenter, con el Wrapper, el MLP llega a mejorar al
J48. Aunque finalmente vemos que el mejor resultado sigue siendo el J48, con los 20 mejores
atributos del Ranker.


Memoria final

Recommended

Recommended

More Related Content

What's hot

What's hot (16)

Viewers also liked

Viewers also liked (19)

Similar to Memoria final

Similar to Memoria final (20)

Memoria final