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

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

Í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



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>

<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>

<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>

Información de la mano que comienza

Hora de inicio de la mano

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">

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

<action no="2" player="Hummelx2" type="2" sum="$1"/>

</round>

<round no="1">

<cards type="Pocket" player="BowserJr">c10 s10</cards>

<cards type="Pocket" player="fakinit">dJ cJ</cards>

<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"/>

<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">

<cards type="Turn" player="">d10</cards>

</round>

<round no="4">

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

</round>

Numero de ronda

Cartas de las que

dispone un jugador

Apuestas

Cartas comunes que se

van poniendo sobre la

mesa

Apuesta de ciegas



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

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.

Estadísticas del HUD



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.



=== 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 Reca ll F-Measure ROC Area Class 0 0 0 0 0 0.807 0.0 0.67 0.418 0.48 0.6 7 0.559 0.647 1.0 0.644 0.393 0.505 0.6 44 0.566 0.644 2.0 0.002 0 1 0.0 02 0.004 0.736 3.0 Weighted Avg. 0.492 0.304 0.514 0.4 92 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

• 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 1863 51.1673 % Incorrectly Classified Instances 1778 48.8327 % Kappa statistic 0.2501 Mean absolute error 0.303 Root mean squared error 0.3886 Relative absolute error 88.441 % Root relative squared error 93.7416 % Total Number of Instances 3641 === Detailed Accuracy By Class === TP Rate FP Rate Precision Reca ll F-Measure ROC Area Class 0.282 0.028 0.542 0.2 82 0.371 0.845 0.0 0.58 0.332 0.502 0.5 8 0.538 0.674 1.0 0.631 0.373 0.513 0.6 31 0.566 0.679 2.0 0.19 0.027 0.546 0.1 9 0.282 0.801 3.0 Weighted Avg. 0.512 0.271 0.517 0.5 12 0.494 0.713 === Confusion Matrix === a b c d <-- classified as 109 240 36 2 | a = 0.0 81 773 465 13 | b = 1.0 11 437 881 68 | 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.


o o

o Simple Logistic

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




o Perceptron Simple

Para este clasificador usamos el Multilayer Perceptron con ninguna

capa oculta.





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í.





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.






• 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.


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:




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.





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:



=== Evaluation on training set === === Summary === Correctly Classified Instances 6618 61.8043 % Incorrectly Classified Instances 4090 38.1957 % Kappa statistic 0.4418 Mean absolute error 0.2413 Root mean squared error 0.3563 Relative absolute error 70.5073 % Root relative squared error 86.1383 % Total Number of Instances 10708 === Detailed Accuracy By Class === TP Rate FP Rate Precision Reca ll F-Measure ROC Area Class 0.761 0.021 0.797 0.7 61 0.779 0.944 0.0 0.785 0.375 0.542 0.7 85 0.641 0.789 1.0 0.462 0.112 0.726 0.4 62 0.564 0.792 2.0 0.53 0.065 0.59 0.5 3 0.559 0.873 3.0 Weighted Avg. 0.618 0.191 0.646 0.6 18 0.612 0.818 === Confusion Matrix === a b c d <-- classified as 799 226 9 16 | a = 0.0 100 3036 533 199 | b = 1.0 66 1818 1936 373 | 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.


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

suceder.



=== Evaluation on training set === === Summary === Correctly Classified Instances 6906 64.4938 % Incorrectly Classified Instances 3802 35.5062 % Kappa statistic 0.4722 Mean absolute error 0.2181 Root mean squared error 0.3483 Relative absolute error 63.7474 % Root relative squared error 84.2101 % Total Number of Instances 10708 === Detailed Accuracy By Class === TP Rate FP Rate Precision Reca ll F-Measure ROC Area Class 0.83 0.024 0.792 0.8 3 0.811 0.963 0.0 0.795 0.345 0.566 0.7 95 0.661 0.801 1.0 0.557 0.155 0.699 0.5 57 0.62 0.802 2.0 0.389 0.022 0.755 0.3 89 0.514 0.863 3.0 Weighted Avg. 0.645 0.191 0.668 0.6 45 0.638 0.827 === Confusion Matrix === a b c d <-- classified as 872 163 11 4 | a = 0.0 135 3076 582 75 | b = 1.0 60 1674 2336 123 | c = 2.0

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:





o RBFNetwork

Redes de funciones de base radial. Con train = 66% y conservando el

orden original. Tenemos los resultados:

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:



5.3 Resultados

En resumen, tenemos los siguientes resultados:

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.

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

(J48)

62.4828 % 62.8628 %

Multilayer Perceptron

(train=66%)

60.8624 % 71.6913 %


(MLP train=66%)

60.1208 % 67.9233 %

Multilayer Perceptron

(test=train)

61.8043 % 70.5073 %


(MLP test=train)

64.4938 % 63.7474 %

RBFNetwork 52.2384 % 86.9388 %

REPTree 58.8575 % 73.5421 %



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): 3 1 class): Chi-squared Ranking Filter Ranked attributes: 1354.5475 18 MiPosicion 960.8091 26 ValorSubida1 952.3952 27 ValorSubida2 883.6841 28 ValorSubida3 816.5711 22 ValorCarta2 787.1046 20 ValorCarta1 728.5459 29 ValorSubida4 525.3871 24 Pareja 197.4389 30 ValorSubida5 167.0821 23 Suited 52.7871 5 JugadoresTotales 52.7871 7 FichasJugador6 52.7871 6 PosicionJugador6 28.0305 25 Consecutivas 26.5342 9 FichasJugador5 26.5342 8 PosicionJugador5 22.037 11 FichasJugador4 22.037 10 PosicionJugador4 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:

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.

=== Attribute Selection on all input data === Search Method: Greedy Stepwise (forwards). Start set: no attributes Merit of best subset found: 0.09 Attribute Subset Evaluator (supervised, Class (nomi nal): 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



• 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:

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.

=== Attribute Selection on all input data === === Attribute Selection on all input data === Search Method: Greedy Stepwise (forwards). Start set: no attributes Merit of best subset found: 0.089 Attribute Subset Evaluator (supervised, Class (nomi nal): 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 Valo rSubida4



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

atributos (30 atributos)

62.4554 % 60.8624 %

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.

Hora Minuto JugadoresTotales MiPosicion PaloCarta1 ValorCarta1 PaloCarta2 ValorCarta2 Suited Pareja Consecutivas ValorSubida1 ValorSubida2 ValorSubida3 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.

Importantes para saber cuando los jugadores piensan más sus

acciones, siendo más racionales o las piensan menos siendo más

irracionales

Cuántos son nuestros adversarios es muy importante

Saber donde estoy situado en la mesa es primordial, ya que si

hablo más tarde tengo ventaja sobre los demás

Las cartas son con lo segundo con lo que se gana en el póker

Estas propiedades nos darán mayor expectativa, ayudándonos a

ligar jugadas fuertes, siendo un buen aliciente para jugar las

cartas

Con las apuestas es lo primero con lo que se gana en el póker,

así que tengo que saber las apuestas de los otros jugadores para

saber como de buenas son sus cartas



=== Confusion Matrix === a b c d <-- classified as 329 26 27 5 | a = 0.0 36 831 367 98 | b = 1.0 36 280 949 132 | c = 2.0 8 130 153 234 | d = 3.0

=== Detailed Accuracy By Class === TP Rate FP Rate Precision Reca ll F-Measure ROC Area Class 0.85 0.025 0.804 0.8 5 0.827 0.934 0.0 0.624 0.189 0.656 0.6 24 0.639 0.771 1.0 0.679 0.244 0.634 0.6 79 0.656 0.75 2.0 0.446 0.075 0.499 0.4 46 0.471 0.791 3.0 Weighted Avg. 0.644 0.176 0.641 0.6 44 0.641 0.783


=== Detailed Accuracy By Class === TP Rate FP Rate Precision Reca ll F-Measure ROC Area Class 0.863 0.047 0.687 0.8 63 0.765 0.965 0.0 0.509 0.15 0.661 0.5 09 0.575 0.776 1.0 0.767 0.328 0.593 0.7 67 0.669 0.787 2.0 0.39 0.038 0.635 0.3 9 0.483 0.853 3.0 Weighted Avg. 0.629 0.191 0.634 0.6 29 0.618 0.812

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

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

J48

MLP

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)





MLP (sin metacost) MLP (con metacost)

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:

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:

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)



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.

Técnica usada J48 MLP

%Aciertos Explorer

(Wrapper)

61.5216 % 61.4392 %

%Aciertos Experimenter

(Wrapper)

61.52 % 61.60%

%Aciertos Explorer

(Ranker)

64.3505 % 62.8673 %

%Aciertos Experimenter

(Ranker)

64.34 % 61.43 %



8. ANÁLISIS DE DIFICULTADES, RIESGOS Y APLICABILIDAD

8.1 Dificultades en la Obtención de la Solución

La principal dificultad a la hora de realizar el trabajo ha sido la obtención de los datos.

Debido a que estos datos suelen ser de carácter privado, o en su defecto de carácter

comercial, es muy complicado encontrarlos en la red o que la gente los preste sin desconfiar,

pero con un poco de suerte y la ayuda de un jugador profesional, hemos podido conseguir

datos con los que trabajar.

Otra de las dificultades encontradas, es la necesidad de tener un gran número de

datos, ya que en un problema tan complicado de aprender el número de manos

recomendables, estimamos, que deberían de ser de unos 20 o 30 treinta millones, para sacar

de ellas unas 200 o 300 mil instancias.

Además, sería más recomendable que los datos fueran de un mismo jugador, para que

sus decisiones sean aprendidas de manera coherente y sin contradicciones, llegando a

aprender cómo juega este jugador en concreto y no como se juega en general.

Incluso, para que el clasificador sea bueno desde el punto de vista del póquer, las

manos deberán ser de jugadores de un nivel medio-alto, y esta parte si la hemos conseguido.

Otra dificultad, aunque solucionable desde el punto de vista técnico, es eliminar los

errores que pueden tener los datos originales, teniendo mucho cuidado de no interpretar mal

estos, porque es la base del estudio.

8.2 Riesgos Previstos

Al principio del estudio, cuando no conseguíamos datos, o cuando los conseguimos y

vimos que podían no ser suficientes, nos hizo pensar en replantearnos el tema de la práctica.

Pero finalmente conseguimos los datos, aunque con poco margen de tiempo como para

preparar las primeras entregas.

La principal incertidumbre que se nos plantea es sí el clasificador obtenido es un buen

jugador de póquer. Es decir; no por obtener buenos resultados, implicando esto que el

clasificador se haya aprendido muy bien los patrones; significa que el clasificador pueda por

ejemplo ganar a un humano. Ya que lo que se intenta en la Inteligencia Artificial es imitar el

comportamiento inteligente del ser humano, nosotros querríamos saber si nuestro clasificador



ha adquirido parte de la inteligencia humana para jugar al póquer (Preflop). Esta inquietud se

ha conseguido calmar en la historia de la IA, enfrentando a humanos y máquinas, para ver

quién es mejor. Debido a las pocas instancias, deducimos que nuestro clasificador no sería

capaz de ganar a un humano, pero quizás con más instancias sí, ya que el factor humano no

adquirido por el clasificador, haría que las decisiones del humano fueran equivocadas, en

ciertas ocasiones donde el clasificador no va a alterar su comportamiento y tomará la decisión

acertada. Pero por otra parte, es el factor humano de lo que se le quiere poder dotar al

clasificador, ya que las decisiones tomadas por el humano depende en gran medida de este, y

a largo plazo, parece que el factor humano implica un progreso que las máquinas no

consiguen.

8.3 Análisis de Implantación

Para poder llevar a cabo este proyecto usamos un ordenador de nivel medio.

Las especificaciones usadas han sido:

• Ordenador Portátil Hacer Aspire 5315

• Procesador: Intel Celeron 1,86 Ghz

• Memoría RAM: 2 Gb

• Sistema Operativo: Linux

Se usó Linux debido a que hace una buena gestión de los recursos, pudiendo dar más

porcentaje de uso del procesador a Weka, y ya que íbamos a realizar tareas muy duras

computacionalmente, necesitábamos aprovechar al máximo el procesador, liberándolo de los

procesos del sistema operativo.

Además, a la hora de ejecutar Weka, el principal problema que se nos planteaba era

que por defecto tiene un espacio de memoria limitado, pero pudimos ampliarlo fácilmente

usando un comando.



9. ANÁLISIS DE LOS RESULTADOS Y CONCLUSIONES

De los resultados numéricos y simbólicos del estudio obtenemos un balance positivo, porque:

• Pasamos de un 46% a un 64% de aciertos:

• Añadiendo nuevos atributos

• Haciendo una buena exploración de los mejores algoritmos

• Haciendo una buena selección de atributos

• Son resultados buenos si tenemos en cuenta:

• El factor humano es muy importante, ya que es difícil aprenderlo

• Dificultad para encontrar datos

• Las instancias son insuficientes

• Usamos datos de varios jugadores, siendo mejor de un solo jugador

• Los datos son de jugadores profesionales lo que le da robustez a las decisiones

• Errores en los datos (stacks descomunales)

En la entrega intermedia dijimos que el porcentaje de aciertos es medio y, por tanto,

mejorable.

También dijimos que esperamos aumentar la tasa de aciertos hasta un 60 %, que

mediante la opción Experimenter de Weka trataríamos de encontrar el mejor algoritmo con la

mejor configuración para que el error cuadrático se redujera drásticamente.

Y todo esto lo hemos conseguido de forma muy notable, sin saber a priori si lo íbamos

a conseguir.

Lo hemos conseguido gracias a un estudio muy severo, mediante el cual hemos ido

mejorando la solución poco a poco, en cada paso que íbamos dando en el estudio. Hemos ido

filtrando los algoritmos y distintas técnicas, para ir encontrando la mejor solución del espacio

de soluciones.

Estamos orgullosos de nuestro clasificador preflop, que aunque no es muy bueno,

hemos conseguido llegar a hacerlo de la mejor manera posible, usando los mejores

procedimientos para desarrollarlo partiendo desde cero, hasta un proyecto final que es muy

manejable para aplicarle nuevas mejoras que lo hagan cada vez mejor.



10. TRABAJOS FUTUROS Y POSIBLES MEJORAS

Posibles mejoras podrían ser la utilización de sistemas híbridos, como por ejemplo

combinar un AG y las RN, para que el AG nos de los atributos que hacen máximos los aciertos

de la RN.

También, se podrían intentar obtener más instancias de los datos que ya tenemos. Por

ejemplo, una misma ronda de apuestas en el preflop podría dividirse en varias, si se da más de

una vuelta completa a la mesa, donde el jugador tomaría una nueva decisión, cada vez, en

función de una nueva situación. Si, por ejemplo, nuestro jugador decide ver con sus cartas y

después le llega una subida, tendrá que decidir ahora con la información de esta subida, con lo

que podríamos incluir esta información en una nueva instancia.

En las instancias se podría de alguna forma conseguir que el pasado tuviera

repercusión en las acciones a tomar. Esta sería un comportamiento muy humano, pero debido

a que muchas de las manos no son consecutivas y que ni los jugadores son los mismos, no

podríamos hacer esto.

Entre otras mejoras se incluye la posibilidad de añadir nuevos atributos, como las

estadísticas de los demás jugadores (ver 3.2), para tomar una decisión.

Un trabajo futuro sería completar el agente, para que funcionara en todas las rondas

del juego (Flop, Turn, River). Esto se podría hacer partiendo de lo que ya hay, y en nuevos

atributos dar la información de estas rondas, según vayan sucediéndose.

La posibilidad de utilizar mejores y más datos, sería otra mejora que podría dar buenos

resultados, en nuestro clasificador actual.



11. REFERENCIAS

[1] Wikipedia. Texas hold 'em Sin Límite. http://es.wikipedia.org/wiki/Texas_hold_%27em

[2] Poquerwiki. Preflop. http://poquerwiki.com/wiki/Preflop

[3] WikiPoquer. Tracker. http://www.wikipoquer.es/Tracker

[4] University of Alberta. The Second Man-Machine Poker Competition.

http://games.cs.ualberta.ca/poker/man-machine/

[5] University of Alberta. Resultados Campeonato 2009.

http://www.cs.ualberta.ca/~pokert/2009/index.php

[6] Youtube. Campeonato Universidad Alberta.

http://www.youtube.com/watch?v=m3fSc_gUNZk

[7] Nicholas Abou Risk. USING COUNTERFACTUAL REGRET MINIMIZATION TO CREATE A

COMPETITIVE MULTIPLAYER POKER AGENT. Edmonton, Alberta. 2009

[8] Jesús Nubiola. Análisis de Póker Online. http://jesusnubiola.com/poker/?p=92#more-92



12. ANEXO: REGLAS DE PÓKER TEXAS HOLD’EM NO LIMIT

12.1 ¿Qué es el póker Texas Hold'em sin límite?

El póker es un juego de habilidad con una componente de azar e información incompleta:

• Azar porque en una mano concreta las cartas se reparten de manera aleatoria

• De información incompleta porque no conocemos las cartas de nuestros oponentes

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

Sí y no, una mano concreta es principalmente azar, sin embargo un jugador que juega de

forma regular jugará miles de manos al año si juega en vivo y cientos de miles si juega online,

por lo que con el paso de las manos lo que prima es la habilidad, y el azar deja de tener

cualquier relevancia.

El Texas Hold'em sin límite es la modalidad de póker más popular. Esta modalidad prima la

habilidad por encima de lo que lo hacen muchas otras variantes de póker, y a la vez da la

sensación de azar y emoción a las personas que no saben jugarlo. La unión de estas dos

características hace que sea una modalidad extremadamente rentable.

12.3 La baraja de póker

Una baraja de póker (sin comodines) consta de 52 cartas, con cuatro palos, y por tanto con 13

naipes de cada palo. El orden de mayor a menor será A (As), K (Rey), Q (Dama/Reina), J (Jota),

T (Diez), 9, 8, 7, 6, 5, 4, 3, 2.

12.4 Manos de póker

Lo primero que se debe aprender es el diferente valor de las manos de póker. Una mano de

póker está compuesta de cinco cartas. En las siguientes secciones se explican las manos desde

la de más valor hasta la de menos valor.



Escalera real:

La escalera real está compuesta de AKQJT del mismo palo. Es la escalera de color más alta

posible.

Ejemplos:

Escalera de color:

La escalera de color está compuesta de cinco cartas consecutivas del mismo palo, el As nos va

a servir tanto por encima de la K como por debajo del dos, pero en el caso de que utilizásemos

el As por arriba en una escalera de color tendríamos, una escalera real.

Ejemplos:

En caso de que dos jugadores tengan escalera de color (situación muy improbable), ganará el

que tenga la escalera más alta:

Ejemplos:

gana a que a su vez gana a



Póker:

Consiste en cuatro cartas de igual valor.

Ejemplos:

: “Póker de seises”

: “Póker de ases”

Cuanto mayor sea el valor de las cartas que forman el póker mejor será la mano, es decir, un

póker de ases le gana a un póker de reyes, un póker de seises a uno de doses. En caso de que

dos jugadores tengan un póker del mismo valor lo que desempata será la quinta carta, cuanto

mayor sea su valor mejor mano será. A esta carta de desempate se le llama “kicker”.

Ejemplos:

gana a .

gana a .

Full House (o Full):

El full consta de tres cartas del mismo valor y las otras dos restantes del mismo valor entre sí,

es decir, trío más pareja.

Ejemplos:

:“Full de Ases y cuatros”

: “Full de doses y seises”

: “Full de seises y doses”

A la hora de nombrar la mano se nombra primero a la carta de la que hay tres iguales, y

después al valor de las dos restantes.

A la hora de que dos jugadores tengan full lo que primero desempata es el valor de las tres

cartas iguales.

le gana a

le gana a



En caso de que las tres cartas iguales tengan el mismo valor en las dos manos desempatarán

las dos restantes:

le gana a

le gana a

En los “Full” no existe kicker como en el poker, ya que para hacer nuestra mano ya

necesitamos cinco cartas, no queda margen para una carta más, este hecho es muy importante

para modalidades en la que tenemos que buscar nuestra mano entre más de cinco cartas,

como es el caso del Texas Hold’em.

Color:

Un color está compuesto por cinco cartas del mismo palo, y repetimos, del mismo palo, y no

sólo del mismo color. es un color pero no lo es.

Para desempatar dos colores iremos recorriendo las cartas que componen el color de mayor a

menor, y en caso de haber una diferencia gana la carta más alta. No vale más un color por

pertenecer a un palo concreto.

Ejemplos:

le gana a , porque A es mayor que K.

le gana a , porque K es mayor que Q.


Sin embargo no le gana a , la segunda mano no es un

color, es una escalera de color.

Escalera:

La escalera está compuesta de cinco cartas de valor consecutivo, pero no todas del mismo

palo.

Ejemplos:

es una escalera a la J

Se dice “a la J” porque la J es la carta más alta que compone la escalera, y en caso de que dos

jugadores tengan escalera, ganará la escalera más alta. La escalera más alta es A K Q J T y la

más pequeña 5 4 3 2 A.



Ejemplos:

es una escalera a la J.

es una escalera al 8.

Trío:

El trío está formado por tres cartas iguales y dos cartas diferentes entre sí. Aunque la jugada

principal se forme solo con algunas de ellas, tres en este caso, las otras dos sirven para

desempatar y por lo tanto cuentan.

Ejemplos:

es un trío de treses.

es un trío de ases.

no es un trío, es un full de ochos y sietes.

En caso de empate entre tríos desempatan las dos cartas restantes. En primer lugar se

compara la mayor de las restantes:

le gana a porque A es mayor que K.

le gana a porque 8 es mayor que 7.

En caso de que la carta más alta de las dos cartas no emparejadas se la misma, desempatará la

carta siguiente:


le gana a , porque J es mayor que 2.

Dobles parejas:

Las dobles parejas se componen de cuatro cartas emparejadas dos a dos y una carta sin

emparejar.

Ejemplos:

son dobles parejas de ases y ochos.

son dobles parejas de ochos y sietes.



En caso de que dos jugadores tengan dobles parejas desempatará primero el valor de la pareja

más alta:



En el caso de que la pareja más alta sea la misma desempatará la siguiente pareja:

le gana a porque J es mayor que T.


En el caso de que ambas parejas sean iguales desempatará la quinta carta, la carta que no está

emparejada:



A esta carta de desempate se le llama kicker.

Pareja:

Una pareja está compuesta por dos cartas iguales, y tres cartas sin emparejar:

es una pareja de ases.

es una pareja de seises.

En caso de que dos jugadores tengan pareja desempata el valor de la pareja:

le gana a porque A es mayor que K


En caso de que el valor de la pareja sea el mismo desempatan las tres siguientes cartas,

ordenadas de mayor a menor, primero se compara la de mayor valor, y si el valor fuese el

mismo se compara la siguiente, y así sucesivamente:



Carta más alta:



En caso de que un jugador no haya conseguido ligar una jugada, tendrá sólo cartas de

desempate para el hipotético caso de que el otro jugador tampoco haya conseguido ligar

jugada. Para el desempate se compara el valor de las cartas de mayor a menor:

le gana a porque K es mayor que Q


12.5 La mano de No Limit Texas Hold'em

En No Limit Texas Hold'em nos reparten sólo dos cartas, y tenemos que conseguir nuestra

jugada con cinco cartas que van a ser comunes a todos los jugadores. Elegiremos la mejor jugada posible. Podemos utilizar nuestras dos cartas, una o ninguna.

12.6 Empieza la mano (El Preflop)

En primer lugar, están las ciegas. Las ciegas son dos apuestas obligatorias, la ciega pequeña

(small blind) y la ciega grande (big blind), que en cada ronda del juego deben apostar los dos

jugadores que quedan a la izquierda del repartidor (dealer). El primer jugador a su izquierda

debe poner la ciega pequeña, y el jugador a la izquierda de éste, la ciega grande. El coste de la

ciega pequeña es la mitad de la ciega grande; ejemplo: 1 dólar en una mesa de $1/$2.

Tras apostar las ciegas, el repartidor da a cada jugador 2 cartas boca abajo. A lo largo de la

mano, se colocarán cinco cartas más boca arriba en el centro de la mesa, las llamadas "cartas

comunitarias", compartidas por todos los jugadores. Al término, cada jugador formará su

jugada usando la mejor combinación entre sus dos cartas y las cinco comunitarias; así, para

crear la mejor jugada, el jugador podrá usar una de sus dos cartas de mano, las dos, o ninguna.

Repartidas las dos cartas de mano, empieza la primera ronda de apuestas. Empieza "hablando"

el jugador que está sentado a la izquierda del que ha puesto la ciega grande. Las opciones que

tiene son retirarse (fold), ir (call) o apostar (bet). Si decide ir, tiene que igualar el importe de la

ciega grande. Si apuesta, debe subir al menos una apuesta pequeña ($1 en una mesa de

$1/$2). En el sin límite puede subir con todas las fichas del jugador, a esto se llama hacer “all-

in”. El turno de apuestas continúa en el sentido de las agujas del reloj hasta finalizar en el

jugador que ha puesto la ciega grande.

Si el primer jugador ha apostado, el siguiente jugador en hablar puede retirarse (fold), ir (call)

o subir (raise). El turno pasa a su izquierda y concluye cuando todos los jugadores han

contribuido al bote la misma cantidad de dinero, habiéndose retirado aquellos que así lo han

decidido. En caso de que un jugador suba y ningún otro iguale su apuesta, gana la mano

automáticamente y se lleva el dinero del bote.

12.7 Las Tres Primeras Cartas (El Flop)

Los jugadores que continúan en el juego, ven entonces el "Flop", que son las primeras tres

cartas comunitarias de las cinco de que va a constar la mano.

A continuación, hay otra ronda de apuestas. Esta vez empieza hablando el jugador que está

sentado inmediatamente a la izquierda del repartidor. Puede escoger entre pasar (check) o



apostar (bet). Si el jugador pasa, se reserva el derecho a igualar o superar cualquier apuesta

que se haga detrás de él cuando le vuelva a tocar el turno. Si apuesta, debe aportar al menos

una apuesta pequeña al bote. El turno de apuestas continúa de la misma forma que en la

ronda anterior, finalizando ahora en el jugador que hace de repartidor.

12.8 La Cuarta Carta (El Turn)

Los jugadores que siguen en la mano ven la cuarta carta, que en inglés se llama "The Turn" o

"Fourth Street". El turno de apuestas que se sigue funciona de la misma forma que el Flop.

12.9 La Quinta Carta (El River)

Los jugadores que siguen en la mano ven la quinta y última carta, que en inglés se llama "The

River" o "Fifth Street", y sigue un turno de apuestas idéntico al anterior. Al finalizar el turno,

los jugadores que permanecen en la mano deben comparar sus jugadas y se lleva el bote aquel

cuya combinación sea superior.

En la siguiente mano, la función de repartidor pasa al jugador que está sentado a la izquierda

del que lo acaba de ser.

memoria final

Documents