Juguemos piedra, papel y tijera con redes neuronales💙
Tags: deeplearning, python, machinelearning
Published: 2020-05-24 19:19:02

¿Alguna vez has escuchado el término de machine learning o aprendizaje automático? ¿Es algo que está de moda? ¿Realmente es útil? ¿se tiene que saber mucha matemáticas, estadística y programación? 🤔. El machine learning es una disciplina ligada a la inteligencia artificial y a la estadística que le permite a nuestros ordenadores aprender a resolver problemas sin ser explícitamente programados para ello. El resultado que obtenemos con machine learning son algoritmos capaces de hacer predicciones y tomar decisiones sin programación previa y con datos que no han visto nunca. 😮

Aunque el camino para aprender requiere conocer de SQL, bases de datos, matemáticas, estadística, programación entre otros. En este tutorial vamos a realizar un juego de piedra, papel o tijeras entrenando una red neuronal, la cual aprenderá a jugar y a ganar. Con este pequeño tutorial verás que con algunas herramientas ya estarás entrenado tu primer algoritmo de aprendizaje automático, el lenguaje de programación que utilizaremos será python, ya veras que muy pronto aprenderás a realizar tus increíbles proyectos de machine learning.
Siempre he pensado que es mejor disfrutar el camino, que pensar en la gran meta.😝 Divertirse mientras puedes aprender cosas nuevas es algo de lo más me gusta hacer, así que si me acompañas vamos a jugar un poco.🤗

comencemos🤓

## 1. Creamos una lista para las opciones de nuestro juego 🎲

Una lista es una estructura de datos usadas en python 🐍. Lo maravilloso de las listas es que puedes almacenar cualquier tipo de valor como un entero, una cadena de texto y hasta otras funciones. 
La notación para lista es una secuencia de valores encerrados entre corchetes y separados por comas. Para nuestro caso tenemos una lista de opciones del juego.

`options = ["👊", "✌", "🖐"]`

💜Nuestras opciones:
- "👊" : piedra
- "🖐" : papel
- "✌" : tijera

Luego, hacemos una pequeña función donde escribimos las reglas del juego, Tenemos dos jugadores llamados p1 y p2 y vamos a ver cuáles son las opciones para ganar.
~~~
def search_winner(p1, p2):
    if p1 == p2:
        result = 0
    elif p1 == "👊" and p2 == "✌":
        result = 1
    elif p1 == "👊" and p2 == "🖐":
        result = 2
    elif p1 == "✌" and p2 == "👊":
        result = 2
    elif p1 == "✌" and p2 == "🖐":
        result = 1
    elif p1 == "🖐" and p2 == "👊":
        result = 1
    elif p1 == "🖐" and p2 == "✌":
        result = 2
        
    return result  
~~~

Así podemos comprobar nuestra función:

`search_winner("🖐", "✌")`
`search_winner("✌","✌")`

Ahora vamos a crear un pequeño test, para seguir haciendo pruebas. Además hacemos una alternación y pintamos la validación del test. una iteración es repetir el proceso varias veces y algo muy útil en programación.
~~~
test = [
    ["👊", "👊", 0],
    ["👊", "✌", 1],
    ["👊", "🖐", 2]
]

for partida in test:
    print("player1: %s player2: %s Winner: %s Validation: %s" % (
        partida[0], partida[1], search_winner(partida[0], partida[1]), partida[2]
    ))
~~~

y estos son los resultados del test:



~~~
player1: 👊 player2: 👊 Winner: 0 Validation: 0
player1: 👊 player2: ✌ Winner: 1 Validation: 1
player1: 👊 player2: 🖐 Winner: 2 Validation: 2
~~~


💜Luego creamos una pequeña función que sea random, para el jugador 1 y el jugador 2. Importamos el modulo random con el cual podemos generar números aleatorios. 

~~~
from random import choice
def get_choice():
    return choice(options)
~~~

💜Ahora una pequeña prueba, para ver nuestros resultados con la función random:
~~~
for i in range(10):
    player1 = get_choice()
    player2 = get_choice()
    print("player1: %s player2: %s Winner: %s " % (
        player1, player2, search_winner(player1, player2)
    ))
~~~
💜Después de ejecutar la función tenemos:
~~~
player1: 👊 player2: 👊 Winner: 0 
player1: 👊 player2: ✌ Winner: 1 
player1: 🖐 player2: ✌ Winner: 2 
player1: ✌ player2: 🖐 Winner: 1 
player1: 👊 player2: ✌ Winner: 1 
player1: ✌ player2: 🖐 Winner: 1 
player1: 🖐 player2: 👊 Winner: 1 
player1: 👊 player2: 🖐 Winner: 2 
player1: 🖐 player2: ✌ Winner: 2 
player1: 👊 player2: 👊 Winner: 0 
~~~

💜Muy bien!!!! Hemos avanzado mucho en la estructura general nuestro juego, estableciendo las reglas del mismo, cuando realizas algún proyecto de programación siempre es importante partir el problema en pasos más pequeños e ir aumentando el nivel de dificultad, no te preocupes si al principio te cuesta un poco, todos pasamos por eso, solamente permanece en el camino lo puedes lograr.

Ahora vamos a hablar de Redes Neuronales 💁‍♀

## 2. Red Neuronal 🧠
Empecemos con nuestra red neuronal, vamos a hacer una función que convierta los emojis a una lista de ceros y unos para que nuestra red neuronal entienda mejor. Donde la piedra "👊"es [1,0,0], si es tijeras "✌" es [0,1,0] y si es papel "🖐" es [0,0,1]. Imagínate que las máquinas se hablan entre ellas y a esto se le denomina lenguaje de máquina o código de máquina, este lenguaje es una serie de instrucciones en forma de ceros y unos las cuales se ejecutan de manera secuencial. 👩‍💻
Una red neuronal artificial es un sistema que compone de entradas en su interior se realizan funciones de activación para producir salida. Lo que se busca con estos sistemas es que nuestros algoritmos ganen cierta inteligencia de las entradas para realizar una predicción. En nuestro caso queremos que la red aprenda las reglas del juego y que aprenda a ganar.😜

Ahora definamos una nueva función para que nuestro sistema entienda el lenguaje de máquina:
~~~
def str_to_list(option):
    if option=="👊":
        res = [1,0,0]
    elif option=="✌":
        res = [0,1,0]
    else:
        res = [0,0,1]
    return res

data_X = list(map(str_to_list, ["👊", "✌", "🖐"]))
data_y = list(map(str_to_list, ["🖐", "👊", "✌"]))

print(data_X)
print(data_y)
~~~

Este es nuestro resultado:
~~~
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
[[0, 0, 1], [1, 0, 0], [0, 1, 0]]
~~~

⚡Ahora vamos a empezar con la red neuronal. Importamos la librería scikit-learn.

Scikit-learn es una librería ideal para diseñar y entrenar redes neuronales, esta librería es usada por spotify, Evernote y utiliza algoritmos de clasificación, regresión ,agrupamiento entre otros. Es una libreria genial para comenzar a entrar tus modelos de machine learning

🧡Te dejo el link con la documentación oficial:(https://scikit-learn.org/stable/)

Ahora vamos a importar nuestra librería y utilizar uno de sus algoritmos de clasificación:

~~~
from sklearn.neural_network import MLPClassifier
clf = MLPClassifier(verbose=False, warm_start=True)
~~~

🧡Este es un clasificador perceptrón multicapa que tiene capacidad para resolver problemas que no son linealmente separables. 

<a href="http://google.com.au/" rel="some text">![Foo](https://upload.wikimedia.org/wikipedia/commons/6/64/RedNeuronalArtificial.png)</a>

Las capas pueden clasificarse en tres tipos 🤓:

- Capa de entrada: Constituida por aquellas neuronas que introducen los patrones de entrada en la red. En estas neuronas no se produce procesamiento.
- Capas ocultas: Formada por aquellas neuronas cuyas entradas provienen de capas anteriores y cuyas salidas pasan a neuronas de capas posteriores.
- Capa de salida: Neuronas cuyos valores de salida se corresponden con las salidas de toda la red.

💚Ahora vamos a crear nuestro modelo así:
~~~
model = clf.fit([data_X[0]], [data_y[0]])
print(model)
~~~

Luego, hacemos una función *jugar a aprender*. La idea es que nuestra red neuronal empiece a aprender a ganar por medio de la experiencia. En la función definimos la predicción que debe ser igual o superior al 95%.

~~~
def play_and_learn(iters=10, debug=False):
    score = {"win": 0, "loose": 0}
    
    data_X = []
    data_y = []
    
    for i in range(iters):
        player1 = get_choice()
        
        predict = model.predict_proba([str_to_list(player1)])[0]
        
        if predict[0] >= 0.95:
            player2 = options[0]
        elif predict[1] >= 0.95:
            player2 = options[1]
        elif predict[2] >= 0.95:
            player2 = options[2]
        else:
            player2 = get_choice()
            
        if debug==True:
            print("Player1: %s Player2 (modelo): %s --> %s" % (player1, predict, player2))
        
        winner = search_winner(player1, player2)
        if debug==True:
            print("Comprobamos: p1 VS p2: %s" % winner)
        
        if winner==2:
            data_X.append(str_to_list(player1))
            data_y.append(str_to_list(player2))
            
            score["win"]+=1
        else:
            score["loose"]+=1
        
    return score, data_X, data_y

~~~

Y lo ejecutamos así (Queremos ver si nuestro modelo ha aprendido algo):
~~~
score, data_X, data_y = play_and_learn(1, debug=True)
print(data_X)
print(data_y)
print("Score: %s %s %%" % (score, (score["win"]*100/(score["win"]+score["loose"]))))
if len(data_X):
    model = model.partial_fit(data_X, data_y)
~~~
Después de ejecutar:
~~~
Player1: ✌ Player2 (modelo): [0.17561242 0.16144559 0.83639906] --> 👊
Comprobamos: p1 VS p2: 2
[[0, 1, 0]]
[[1, 0, 0]]
Score: {'win': 1, 'loose': 0} 100.0 %
~~~

💚Y finalmente vamos a repetir este ejercicio un montón de veces, los algoritmos de inteligencia artificial funcionan gracias a la repetición que se hace y también debido al gran volumen de datos que tenemos hoy en día. por lo cual nuestro sistema debe entrenarse con un montón de iteraciones para que aprenda a ganar.

~~~
i = 0
historic_pct = []
while True:
    i+=1
    score, data_X, data_y = play_and_learn(1000, debug=False)
    pct = (score["win"]*100/(score["win"]+score["loose"]))
    historic_pct.append(pct)
    print("Iter: %s - score: %s %s %%" % (i, score, pct))
    
    if len(data_X):
        model = model.partial_fit(data_X, data_y)
    
    if sum(historic_pct[-9:])==900:
        break
~~~

Y después de ejecutar tenemos que:

~~~
Iter: 1 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 2 - score: {'win': 317, 'loose': 683} 31.7 %
Iter: 3 - score: {'win': 366, 'loose': 634} 36.6 %
Iter: 4 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 5 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 6 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 7 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 8 - score: {'win': 327, 'loose': 673} 32.7 %
Iter: 9 - score: {'win': 329, 'loose': 671} 32.9 %
Iter: 10 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 11 - score: {'win': 339, 'loose': 661} 33.9 %
Iter: 12 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 13 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 14 - score: {'win': 345, 'loose': 655} 34.5 %
Iter: 15 - score: {'win': 304, 'loose': 696} 30.4 %
Iter: 16 - score: {'win': 351, 'loose': 649} 35.1 %
Iter: 17 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 18 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 19 - score: {'win': 336, 'loose': 664} 33.6 %
Iter: 20 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 21 - score: {'win': 321, 'loose': 679} 32.1 %
Iter: 22 - score: {'win': 336, 'loose': 664} 33.6 %
Iter: 23 - score: {'win': 365, 'loose': 635} 36.5 %
Iter: 24 - score: {'win': 356, 'loose': 644} 35.6 %
Iter: 25 - score: {'win': 355, 'loose': 645} 35.5 %
Iter: 26 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 27 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 28 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 29 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 30 - score: {'win': 354, 'loose': 646} 35.4 %
Iter: 31 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 32 - score: {'win': 307, 'loose': 693} 30.7 %
Iter: 33 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 34 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 35 - score: {'win': 369, 'loose': 631} 36.9 %
Iter: 36 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 37 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 38 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 39 - score: {'win': 317, 'loose': 683} 31.7 %
Iter: 40 - score: {'win': 299, 'loose': 701} 29.9 %
Iter: 41 - score: {'win': 337, 'loose': 663} 33.7 %
Iter: 42 - score: {'win': 327, 'loose': 673} 32.7 %
Iter: 43 - score: {'win': 351, 'loose': 649} 35.1 %
Iter: 44 - score: {'win': 342, 'loose': 658} 34.2 %
Iter: 45 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 46 - score: {'win': 300, 'loose': 700} 30.0 %
Iter: 47 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 48 - score: {'win': 342, 'loose': 658} 34.2 %
Iter: 49 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 50 - score: {'win': 312, 'loose': 688} 31.2 %
Iter: 51 - score: {'win': 312, 'loose': 688} 31.2 %
Iter: 52 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 53 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 54 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 55 - score: {'win': 329, 'loose': 671} 32.9 %
Iter: 56 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 57 - score: {'win': 334, 'loose': 666} 33.4 %
Iter: 58 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 59 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 60 - score: {'win': 329, 'loose': 671} 32.9 %
Iter: 61 - score: {'win': 338, 'loose': 662} 33.8 %
Iter: 62 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 63 - score: {'win': 315, 'loose': 685} 31.5 %
Iter: 64 - score: {'win': 313, 'loose': 687} 31.3 %
Iter: 65 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 66 - score: {'win': 317, 'loose': 683} 31.7 %
Iter: 67 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 68 - score: {'win': 314, 'loose': 686} 31.4 %
Iter: 69 - score: {'win': 306, 'loose': 694} 30.6 %
Iter: 70 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 71 - score: {'win': 338, 'loose': 662} 33.8 %
Iter: 72 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 73 - score: {'win': 338, 'loose': 662} 33.8 %
Iter: 74 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 75 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 76 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 77 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 78 - score: {'win': 315, 'loose': 685} 31.5 %
Iter: 79 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 80 - score: {'win': 306, 'loose': 694} 30.6 %
Iter: 81 - score: {'win': 356, 'loose': 644} 35.6 %
Iter: 82 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 83 - score: {'win': 357, 'loose': 643} 35.7 %
Iter: 84 - score: {'win': 305, 'loose': 695} 30.5 %
Iter: 85 - score: {'win': 342, 'loose': 658} 34.2 %
Iter: 86 - score: {'win': 352, 'loose': 648} 35.2 %
Iter: 87 - score: {'win': 318, 'loose': 682} 31.8 %
Iter: 88 - score: {'win': 339, 'loose': 661} 33.9 %
Iter: 89 - score: {'win': 334, 'loose': 666} 33.4 %
Iter: 90 - score: {'win': 339, 'loose': 661} 33.9 %
Iter: 91 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 92 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 93 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 94 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 95 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 96 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 97 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 98 - score: {'win': 344, 'loose': 656} 34.4 %
Iter: 99 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 100 - score: {'win': 350, 'loose': 650} 35.0 %
Iter: 101 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 102 - score: {'win': 313, 'loose': 687} 31.3 %
Iter: 103 - score: {'win': 344, 'loose': 656} 34.4 %
Iter: 104 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 105 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 106 - score: {'win': 360, 'loose': 640} 36.0 %
Iter: 107 - score: {'win': 350, 'loose': 650} 35.0 %
Iter: 108 - score: {'win': 306, 'loose': 694} 30.6 %
Iter: 109 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 110 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 111 - score: {'win': 314, 'loose': 686} 31.4 %
Iter: 112 - score: {'win': 334, 'loose': 666} 33.4 %
Iter: 113 - score: {'win': 337, 'loose': 663} 33.7 %
Iter: 114 - score: {'win': 332, 'loose': 668} 33.2 %
Iter: 115 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 116 - score: {'win': 332, 'loose': 668} 33.2 %
Iter: 117 - score: {'win': 347, 'loose': 653} 34.7 %
Iter: 118 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 119 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 120 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 121 - score: {'win': 366, 'loose': 634} 36.6 %
Iter: 122 - score: {'win': 323, 'loose': 677} 32.3 %
Iter: 123 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 124 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 125 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 126 - score: {'win': 322, 'loose': 678} 32.2 %
Iter: 127 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 128 - score: {'win': 348, 'loose': 652} 34.8 %
Iter: 129 - score: {'win': 323, 'loose': 677} 32.3 %
Iter: 130 - score: {'win': 366, 'loose': 634} 36.6 %
Iter: 131 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 132 - score: {'win': 346, 'loose': 654} 34.6 %
Iter: 133 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 134 - score: {'win': 314, 'loose': 686} 31.4 %
Iter: 135 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 136 - score: {'win': 315, 'loose': 685} 31.5 %
Iter: 137 - score: {'win': 345, 'loose': 655} 34.5 %
Iter: 138 - score: {'win': 538, 'loose': 462} 53.8 %
Iter: 139 - score: {'win': 540, 'loose': 460} 54.0 %
Iter: 140 - score: {'win': 549, 'loose': 451} 54.9 %
Iter: 141 - score: {'win': 589, 'loose': 411} 58.9 %
Iter: 142 - score: {'win': 574, 'loose': 426} 57.4 %
Iter: 143 - score: {'win': 570, 'loose': 430} 57.0 %
Iter: 144 - score: {'win': 539, 'loose': 461} 53.9 %
Iter: 145 - score: {'win': 525, 'loose': 475} 52.5 %
Iter: 146 - score: {'win': 542, 'loose': 458} 54.2 %
Iter: 147 - score: {'win': 550, 'loose': 450} 55.0 %
Iter: 148 - score: {'win': 539, 'loose': 461} 53.9 %
Iter: 149 - score: {'win': 561, 'loose': 439} 56.1 %
Iter: 150 - score: {'win': 527, 'loose': 473} 52.7 %
Iter: 151 - score: {'win': 521, 'loose': 479} 52.1 %
Iter: 152 - score: {'win': 553, 'loose': 447} 55.3 %
Iter: 153 - score: {'win': 575, 'loose': 425} 57.5 %
Iter: 154 - score: {'win': 550, 'loose': 450} 55.0 %
Iter: 155 - score: {'win': 547, 'loose': 453} 54.7 %
Iter: 156 - score: {'win': 556, 'loose': 444} 55.6 %
Iter: 157 - score: {'win': 574, 'loose': 426} 57.4 %
Iter: 158 - score: {'win': 569, 'loose': 431} 56.9 %
Iter: 159 - score: {'win': 586, 'loose': 414} 58.6 %
Iter: 160 - score: {'win': 513, 'loose': 487} 51.3 %
Iter: 161 - score: {'win': 553, 'loose': 447} 55.3 %
Iter: 162 - score: {'win': 554, 'loose': 446} 55.4 %
Iter: 163 - score: {'win': 535, 'loose': 465} 53.5 %
Iter: 164 - score: {'win': 559, 'loose': 441} 55.9 %
Iter: 165 - score: {'win': 565, 'loose': 435} 56.5 %
Iter: 166 - score: {'win': 546, 'loose': 454} 54.6 %
Iter: 167 - score: {'win': 562, 'loose': 438} 56.2 %
Iter: 168 - score: {'win': 582, 'loose': 418} 58.2 %
Iter: 169 - score: {'win': 560, 'loose': 440} 56.0 %
Iter: 170 - score: {'win': 528, 'loose': 472} 52.8 %
Iter: 171 - score: {'win': 567, 'loose': 433} 56.7 %
Iter: 172 - score: {'win': 571, 'loose': 429} 57.1 %
Iter: 173 - score: {'win': 561, 'loose': 439} 56.1 %
Iter: 174 - score: {'win': 561, 'loose': 439} 56.1 %
Iter: 175 - score: {'win': 564, 'loose': 436} 56.4 %
Iter: 176 - score: {'win': 557, 'loose': 443} 55.7 %
Iter: 177 - score: {'win': 538, 'loose': 462} 53.8 %
Iter: 178 - score: {'win': 569, 'loose': 431} 56.9 %
Iter: 179 - score: {'win': 558, 'loose': 442} 55.8 %
Iter: 180 - score: {'win': 537, 'loose': 463} 53.7 %
Iter: 181 - score: {'win': 560, 'loose': 440} 56.0 %
Iter: 182 - score: {'win': 757, 'loose': 243} 75.7 %
Iter: 183 - score: {'win': 771, 'loose': 229} 77.1 %
Iter: 184 - score: {'win': 772, 'loose': 228} 77.2 %
Iter: 185 - score: {'win': 775, 'loose': 225} 77.5 %
Iter: 186 - score: {'win': 783, 'loose': 217} 78.3 %
Iter: 187 - score: {'win': 761, 'loose': 239} 76.1 %
Iter: 188 - score: {'win': 789, 'loose': 211} 78.9 %
Iter: 189 - score: {'win': 774, 'loose': 226} 77.4 %
Iter: 190 - score: {'win': 783, 'loose': 217} 78.3 %
Iter: 191 - score: {'win': 769, 'loose': 231} 76.9 %
Iter: 192 - score: {'win': 792, 'loose': 208} 79.2 %
Iter: 193 - score: {'win': 785, 'loose': 215} 78.5 %
Iter: 194 - score: {'win': 789, 'loose': 211} 78.9 %
Iter: 195 - score: {'win': 772, 'loose': 228} 77.2 %
Iter: 196 - score: {'win': 780, 'loose': 220} 78.0 %
Iter: 197 - score: {'win': 783, 'loose': 217} 78.3 %
Iter: 198 - score: {'win': 797, 'loose': 203} 79.7 %
Iter: 199 - score: {'win': 772, 'loose': 228} 77.2 %
Iter: 200 - score: {'win': 759, 'loose': 241} 75.9 %
Iter: 201 - score: {'win': 778, 'loose': 222} 77.8 %
Iter: 202 - score: {'win': 774, 'loose': 226} 77.4 %
Iter: 203 - score: {'win': 769, 'loose': 231} 76.9 %
Iter: 204 - score: {'win': 792, 'loose': 208} 79.2 %
Iter: 205 - score: {'win': 749, 'loose': 251} 74.9 %
Iter: 206 - score: {'win': 791, 'loose': 209} 79.1 %
Iter: 207 - score: {'win': 753, 'loose': 247} 75.3 %
Iter: 208 - score: {'win': 792, 'loose': 208} 79.2 %
Iter: 209 - score: {'win': 803, 'loose': 197} 80.3 %
Iter: 210 - score: {'win': 767, 'loose': 233} 76.7 %
Iter: 211 - score: {'win': 779, 'loose': 221} 77.9 %
Iter: 212 - score: {'win': 782, 'loose': 218} 78.2 %
Iter: 213 - score: {'win': 767, 'loose': 233} 76.7 %
Iter: 214 - score: {'win': 791, 'loose': 209} 79.1 %
Iter: 215 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 216 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 217 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 218 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 219 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 220 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 221 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 222 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 223 - score: {'win': 1000, 'loose': 0} 100.0 %
~~~

💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜

Se puede ver el sistema se comporta igual que un niño que está aprendiendo algo nuevo, gracias a la experiencia y repetición finalmente alcanza un score del 100%. 😀 
Esto ha sido todo, aprendimos que podemos usar la programación para aprender cosas de manera divertida⭐, que las máquinas tiene un lenguaje especial y mediante una serie de instrucciones podemos enseñarles casi cualquier cosa.😮 Finalmente estudiamos un poco sobre redes neuronales y creamos un sistema de clasificación Perceptrón multicapa.😎 

Déjame en los comentarios si te gusto o si tienes alguna duda, yo estaría feliz de ayudarte y espero ver pronto tus divertidas creaciones de machine learning.

Muchas gracias💜