Actividad – Piedra, Papel o Tijeras

Objetivo
En esta actividad construiremos un videojuego en el que el ordenador jugará contra nosotros al
popular juego “piedra, papel o tijeras”. Y lo hará viendo e interpretando los gestos de nuestras
manos. Esto es, tendrá que ser capaz de reconocer el gesto de la mano que simboliza cada una de
las jugadas permitidas en el juego.
La intención de la aplicación que vamos a desarrollar es que uno de los jugadores sea el ordenador,
y el otro una persona. Teniendo en cuenta las reglas del juego, un posible análisis del problema sería
el siguiente:
● Un objeto, al que llamaremos Árbitro dirá: “piedra, papel o tijeras”.
● Un objeto, al que llamaremos Computadora, jugará de manera aleatoria una de las tres
posibles jugadas, y se almacenará en una variable. Podemos llamarla jugada_computadora.
● Un objeto, al que llamaremos Persona, activará la cámara de el ordenador, y el jugador le
mostrará su gesto, es decir, la jugada que ha elegido.
● El ordenador, a través del objeto Persona, reconocerá la jugada que corresponde al gesto del
jugador, y cuando la confianza en el reconocimiento de la imagen sea suficientemente alta,
almacenará el resultado en una variable. Podemos llamarla jugada_persona.
● Entonces, el Árbitro, aplicando las reglas del juego, decidirá quién de los dos ha ganado y el
juego termina.
Aunque parece que el ordenador es juez y parte en el juego, no tiene porqué ser así. Recordemos
que el ordenador es una máquina absolutamente obediente, solo hace lo que nosotros le ordenemos
mediante nuestro programa, así que el objeto Computadora, cuando selecciona su juego, no tiene
que usar la información que el ordenador tiene sobre el gesto que ha usado la persona. Eso es algo
que el programador decide. Por tanto, el ordenador no juega con ventaja.
Pues bien, ¡vamos al lío! El análisis que hemos realizado parece fácil de convertir en un programa
informático. Sin embargo, hay una parte que podría parecer muy complicada de implementar: el
reconocimiento del gesto que la persona expone a el ordenador a través de la cámara. Pero nosotros
ya sabemos que este tipo de problemas se resuelve aplicando las técnicas de Machine Learning.
Para resolver esa parte del problema podemos crear un modelo de ML capaz de reconocer los tres
gestos del juego, y una vez que funcione correctamente, lo podemos usar, como cualquier otro
bloque, en nuestro videojuego.
Pasos a seguir
1. CONSTRUCCIÓN MODELO ML
Abrimos el editor de LearningML https://web.learningml.org/ y hacemos clic en
Versión 1.2 (estable) y entramos en reconocer imágenes. A continuación hacemos
clic en Sección 1 Entrenar, creamos cuatro clases, una para cada jugada que
llamaremos piedra, papel y tijeras, y la cuarta para reconocer la ausencia de gesto,
que llamaremos sin gesto. Esta última nos vendrá bien para que el ordenador no
asocie por error una de las jugadas cuando aún no la hemos mostrado a la cámara.

A cada clase añadimos unas 30 imágenes del gesto que le corresponda usando la
cámara. Es importante colocar la mano en distintas posiciones de la cámara, es
decir, más arriba, más abajo, hacia la derecha, hacia la izquierda, más cerca, más
lejos, etcétera. La intención es que el conjunto de imágenes sea representativo del
gesto, y que el modelo sea capaz de reconocer cada gesto con independencia de la
posición exacta que la mano ocupe en el cuadro de la cámara.
Cuando hayamos completado el conjunto de entrenamiento, pasamos a la fase de
aprendizaje para que el algoritmo de ML construya un modelo a partir de las
imágenes.
Esto lo hacemos haciendo clic en el botón “Aprender a reconocer imágenes” de la
sección 2. Aprender.
Y cuando haya finalizado, es el momento de probarlo y comprobar si funciona
correctamente. Esto lo hacemos usando los controles de la sección 3. Probar.
Hacemos clic en el botón con la cámara y comprobamos si los gestos que
presentamos a la cámara se reconocen correctamente y con suficiente confianza.
Si durante la evaluación vemos que el modelo no está funcionando correctamente, o
la confianza es menor al 70% hay que mejorar el conjunto de datos de
entrenamiento, añadiendo o quitando imágenes a las clases que presentan
problemas en la clasificación.
¡Y ya tenemos el modelo! Ahora hay que usarlo en el videojuego que vamos a
construir. Este modelo constituirá el componente de Inteligencia Artificial de la
aplicación.
Ahora hacemos clic en el botón del gatito de Scratch, para iniciar la plataforma de
programación.

2. CREACIÓN DE JUEGO CON SCRATCH

Una vez en scratch, crearemos 3 objetos: uno para implementar las acciones del
jugador, otro para las de la computadora y el último para el árbitro. recuerda iniciar
sesión con tu cuenta y guardar el proyecto para no perder el trabajo.
Primero eliminamos el objeto del gatito que viene por defecto y después creamos
las variables jugada_persona y jugada_computadora, que almacenarán las jugadas
realizadas por la persona y el ordenador respectivamente. Además crearemos una
lista, que llamaremos jugadas, con los elementos piedra, papel y tijera.

Ahora añadimos el objeto Persona usando la herramienta de creación manual de

objetos. Se accede a ella haciendo clic en el desplegable de creación de objetos y
eligiendo el botón del pincel.
Usaremos Persona como nombre del objeto.

Y en la sección disfraces del editor de código añadiremos tres disfraces que se

llamarán como las jugadas: piedra, papel y tijera. En cada uno de los disfraces
dibujaremos algo que recuerde a una piedra, a un papel y a una tijera
respectivamente. También puedes usar imágenes que descargues de internet o
fotografías que tú mismos hagas.
Creación de los disfraces para el objeto Persona
Ahora vamos a crear el objeto Computadora copiando el objeto Persona (botón
derecho> duplicar) y cambiándole el nombre a computadora.

Finalmente, tenemos dos objetos con los mismos disfraces.

Por último, creamos el objeto Árbitro a partir de un objeto predefinido de Scratch .
Y nos quedará algo así:

Seleccionamos el objeto Árbitro y añadimos el siguiente código que implementa la

cuenta atrás para sacar la jugada.
El último bloque envía el mensaje “jugar”, y será recogido tanto por el objeto
Computadora como por Persona.
Comencemos con el código del objeto Computadora, para ello haz clic en el objeto
computadora y copia el siguiente código:

Cuando hacemos clic en la bandera, es decir, cuando se inicia el programa, fijamos

el tamaño del objeto a la mitad, lo colocamos a la izquierda de la pantalla y lo
escondemos, pues aún no queremos mostrar la jugada del ordenador. Además,
cuando reciba el mensaje “mostrar”, el objeto se mostrará. Este mensaje lo enviará
el árbitro cuando las dos partes hayan realizado su jugada. Por último, cuando
reciba el mensaje “jugar”, el objeto genera un número aleatorio entre 1 y 3 (ambos
inclusive) que será utilizado para elegir uno de los elementos de la lista jugadas, y
almacenarlo en la variable jugada_computadora. Es decir, esta variable terminará
conteniendo uno de los textos “piedra”, “papel” o “tijeras”. Finalmente, como hemos
llamado a los disfraces con los nombres de las jugadas, podemos usar el contenido
de la variable jugada_computadora para seleccionar el disfraz que mostrará el
ordenador.

Llegados a este punto puedes probar el código. Si todo va bien el árbitro dará
comienzo al juego y la computadora seleccionará su jugada.
A continuación añadimos el siguiente código al objeto Persona, para ello haz clic en
el objeto persona y copia el siguiente código:
Igual que con el objeto Computadora, cuando se hace clic en la bandera, se fija el
tamaño a la mitad, se coloca en la parte derecha de la pantalla y se esconde, pues
no queremos que se vea la jugada de la persona hasta que no llegue el momento.
Además, se apagará la cámara, pues al no haber comenzado aún el juego, no es
necesaria. Al recibir el mensaje “mostrar”, el objeto aparecerá en pantalla. Como ya
hemos comentado, es el objeto Árbitro quien decide cuándo enviar ese mensaje.
Y la parte más compleja sucede cuando el objeto recibe el mensaje “a jugar”.
Primero definiremos la transparencia de la cámara al 50%. Para usar ese bloque hay
que añadir la extensión “sensor de video”. Se hace clic en el botón de abajo a la
izquierda. Aparecen las extensiones disponibles entre las que se encuentra “sensor
de video”. Una vez seleccionada ya tienes disponible dicho bloque.

El siguiente bloque activa la cámara. Este bloque se encuentra en la sección

“learningml-images”. A continuación esperamos un pequeño tiempo. Esto se hace
con la intención de estabilizar la cámara de video.
Creamos una variable llamada confianza, para almacenar la confianza del
reconocimiento realizado por el modelo de ML, y le asignamos el valor inicial cero. A
continuación, creamos un bucle que se repetirá hasta que se cumpla el valor de la
confianza sea superior a 0.8 y además la clasificación realizada sea distinta “sin
gesto”. Esta última nos garantiza que no se realizará lectura de la jugada hasta que
la mano sea presentada a la cámara. Durante la ejecución del bucle la variable
confianza se va actualizando con el valor calculado por el bloque “confianza para la
imagen <imagen>” y la variable jugada_persona se carga con el valor dado por el
bloque “clasificar imagen <imagen>”, es decir, con el resultado que ofrece nuestro
modelo de ML. Ambos bloques se encuentran en la sección “learningml-images”.
Por último ten en cuenta que estos bloques pueden leer la imagen de entrada desde
uno de los disfraces del objeto o desde la cámara. En nuestro caso queremos que se
haga desde la cámara. Por eso debes colocar el bloque “imagen de video” como
argumentos de ambos bloques.
Cuando la persona presenta el gesto a la cámara y la condición de salida del bucle
se ha cumplido, tenemos almacenado en la variable jugada_persona, el valor que el
modelo de ML ha interpretado sobre el gesto de la persona. Y como hemos tenido la
precaución de llamar a los nombre de las clases de jugadas igual que a los
disfraces, esto es, “piedra”, “papel”, o “tijeras”, podemos usar el valor de la variable
juagada_persona para fijar el disfraz que el objeto Persona debe mostrar.
Por último apagamos la cámara y enviamos el mensaje “listo jugador”, para indicar
al árbitro que la lectura del gesto del jugador ya se ha realizado correctamente.

Ahora volvemos al código del objeto Árbitro. Vamos a ocultar la representación de

las variables y de la lista y a resolver el juego. Para ello usamos el siguiente código:

Aprovechamos para esconder todas las variables y colocar al árbitro en el centro de

la pantalla. Además añadimos el programa que se ejecutará cuando el árbitro reciba
el mensaje “listo jugador”, es decir, cuando ha sido interpretado correctamente el
gesto mostrado por la persona a la cámara. Este programa, tal y como se ve en la
imagen es muy sencillo: primero dice “Listo”, para indicar que ya se ha terminado la
partida, después envía el mensaje “mostrar”, que es recibido por los objetos
Computadora y Persona para aparecer en pantalla y mostrar el disfraz que
corresponde a su jugada. Y por último se resuelve el juego en los bloques “si – si no”
anidados.
Primero se comprueba si ambos jugadores han sacado la misma jugada, en cuyo
caso se produce un empate. En caso contrario se comprueban todas las opciones
ganadoras de la persona. Esto se hace en el bloque con forma de diamante que es
tan largo que no cabe en la imagen. Construir la condición puede resultar algo lioso,
pero no es difícil. Hay que concatenar dos bloques de condición “O”:

Y en cada uno de esos bloque conjuntivos (Y), meter una de las condiciones
ganadoras:

Finalmente podemos añadir dos objetos sin código para indicar quién es la
computadora y quién la persona.

Y con esto ya tenemos una versión sencilla del juego “piedras, papel o tijeras”. Ya
solo nos queda probarlo y jugar.