Generando Goles Esperados con Variables Aleatorias en Python

Compártelo:

La creación de números aleatorios es una parte central de la programación: ya sea para simulaciones, juegos o modelos, hay una ¿Eres un apasionado del fútbol y la programación? ¿Te has preguntado alguna vez cómo los equipos de fútbol pueden predecir la probabilidad de marcar un gol en un partido? ¡Este artículo es para ti! Aprenderás a utilizar Python para modelar los goles esperados y la distribución de Poisson, dos conceptos clave para entender el fútbol moderno. ¡Prepárate para descubrir los secretos detrás de los números del fútbol y cómo puedes utilizarlos para mejorar tus estrategias de juego, viendo como aplicar esto para encontrar la probabilidad de que el Olímpic de Xàtiva gane en función de los objetivos esperados de un partido determinado.

Así que importemos el módulo aleatorio y comencemos.

In [1]:

import random

La forma más sencilla de obtener un número aleatorio es a través de la operación ‘.random()’. Esto nos dará un número aleatorio entre 0 y 1.

Vamos a comprobarlo:

In [2]:

random.random()

Out[2]:

0.10769078951918487

Un número entre 0 y 1 es muy útil, ya que nos da un porcentaje que podemos usar para calcular la probabilidad o para asignar a una variable para el cálculo.

Además, podemos usarlo para crear un número entero aleatorio multiplicándolo por el valor máximo posible y luego redondeándolo con ‘int()’. El ejemplo aquí nos da un número aleatorio entre 0 y 100:

In [3]:

int(random.random()*100)

Out[3]:

Alternativamente a lo anterior, podríamos usar otra función del módulo Random para crear un número entero aleatorio para nosotros: ‘.randint()’. Simplemente pasamos los valores más altos y más bajos posibles (inclusive) que vamos a permitir que tenga el numero aleatorio. Por ejemplo, simulemos una tirada de dados:

In [4]:

random.randint(1,6)

Out[4]:

Aplicación aleatoria a los goles esperados

Bien, una vez ya visto cómo funciona la creación de números aleatorios, vamos con nuestro equipo en el resto del artículo donde lo aplica a los goles esperados y nos permitirá calcular la «suerte» del Olímpic en función de la calidad de sus tiros.

En primer lugar, los goles esperados, como explicamos en su artículo, son una medida de cuántos goles se esperaba que marcase un equipo en función de los tiros que realizó. Entonces podemos ver el porcentaje de probabilidad de que el tiro se convierta en gol.

Conociendo los goles esperados, podemos usar ‘.random()’ para probar la probabilidad de ese resultado. Primero configuremos nuestras listas de tiros con sus valores de gol esperados: todos estos son porcentajes representados como decimales.

In [5]:

HomexG = [0.21,0.66,0.1,0.14,0.01]

AwayxG = [0.04,0.06,0.01,0.04,0.06,0.12,0.01,0.06]

El primer tiro del equipo local tenía un 21% de posibilidades de ser anotado. Vamos a crear un porcentaje aleatorio para simular si entra o no. Si es igual o inferior al 21%, podemos decir que está puntuado en nuestra simulación:

In [6]:

if random.random()<=0.21:

print(«GOL!»)

else:

print(«Falló!»)

Falló!

Como sucede aproximadamente 4 de cada 5 veces (Un 20% de las ocasiones), esta vez se falló el tiro. Ahora ejecutemos ese mismo lanzamiento 10000 veces:

In [7]:

Goals = 0

for i in range(0,10000):

if random.random()<=0.21:

Goals += 1

print(Goals)

2071

Entonces, de acuerdo con el puntaje xG y nuestra prueba aleatoria, si hacemos ese tiro 10,000 veces, podemos esperar 2075 goles (prácticamente en línea con los goles esperados de 0.21). En pocas palabras, así es como simulamos con números aleatorios.

Simulando un partido con Goles Esperados

En lugar de simular con un número, apliquemos esta misma prueba a cada tiro de la lista del equipo local y el visitante. Echemos un vistazo a la función a continuación e intentaremos comprender cómo aplica la prueba anterior a cada disparo en las listas HomexG y AwayxG.

In [8]:

def calculateWinner(home, away):

#Nuestro partido comienza en 0-0

HomeGoals = 0

AwayGoals = 0

#Tenemos una función dentro de nuestra función

#Esta ejecuta la prueba ‘.random()’ anterior para obtener una lista

def testShots(shots):

#Comienza el conteo de goles en 0

Goals = 0

#Para cada tiro, si entra, agrega un gol

for shot in shots:

if random.random() <= shot:

Goals += 1

#Finalmente, devuelva el número de goles

return Goals

# Ejecute la fórmula anterior para las listas local y visitante

HomeGoals = testShots(home)

AwayGoals = testShots(away)

#Devuelve el resultado

if HomeGoals > AwayGoals:

print(«Gana el Local! {} – {}».format(HomeGoals, AwayGoals))

elif AwayGoals > HomeGoals:

print(«Gana el Visitante! {} – {}».format(HomeGoals, AwayGoals))

else:

print(«Se reparten los puntos! {} – {}».format(HomeGoals, AwayGoals))

In [9]:

calculateWinner(HomexG, AwayxG)

Gana el Local! 3 – 1

Ahora estamos simulando un partido completo basado en los goles esperados, podríamos pensar que es genial, pero si queremos hacerlo bien, para obtener una estimación adecuada de la probabilidad de que un equipo gane, debemos hacer esto muchas veces.

Cambiemos nuestra última función para que simplemente devuelva el resultado, no una impresión fácil de usar. Luego podemos usar esta función una y otra vez para calcular un porcentaje preciso de posibilidades de ganar para cada equipo.

In [10]:

def calculateWinner(home, away):

HomeGoals = 0

AwayGoals = 0

def testShots(shots):

Goals = 0

for shot in shots:

if random.random() <= shot:

Goals += 1

return Goals

HomeGoals = testShots(home)

AwayGoals = testShots(away)

# Esto es todo lo que cambia desde arriba

#Ahora pasamos una cadena simple, en lugar de pedir una impresión.

if HomeGoals > AwayGoals:

return(«home»)

elif AwayGoals > HomeGoals:

return(«away»)

else:

return(«draw»)

Ahora, ejecutemos esta función 10000 veces, y veamos el porcentaje de resultados:

In [11]:

#Ejecute la calculadora xG 10000 veces para probar el %

def calculateChance(team1, team2):

home = 0;

away = 0;

draw = 0;

for i in range(0,10000):

matchWinner = calculateWinner(team1,team2)

if matchWinner == «home»:

home +=1

elif matchWinner == «away»:

away +=1

else:

draw +=1

home = home/100

away = away/100

draw = draw/100

print(«Después de 10000 partidos, el local gana {} %, el visitante gana {} % y hay un empate en {}% de partidos.».format(home, away, draw))

In [12]:

calculateChance(HomexG, AwayxG)

Después de 10000 partidos, el local gana 61.2%, el visitante gana 9.29% y hay un empate en 29.51% de partidos.

Ahora ya comprendemos mejor qué resultado podemos esperar normalmente de estos lanzamientos a portería.

Probemos una nueva racha de goles esperados: una gran oportunidad (50 %) contra 10 malas oportunidades (5 %). ¿Quién gana más a menudo aquí?

In [13]:

HomexG=[0.5]

AwayxG=[0.05,0.05,0.05,0.05,0.05,0.05,0.05,0.05,0.05,0.05]

calculateChance(HomexG, AwayxG)

Después de 10000 partidos, el local gana 30.84%, visitante gana 23.14% y hay un empate en 46.02% de los partidos.

Curiosamente, el equipo con grandes oportunidades tiene una ventaja del 5 % sobre el equipo que dispara muchas veces con pocas posibilidades. ¡Te hace pensar, sobre cuándo y dónde chutar!

Resumen del uso de Aleatorios en Python

Crear números aleatorios es fácil, ya sea que queramos un porcentaje aleatorio, un número entre 0 y 1 (.random()) o queramos un número entero aleatorio (randint()), el módulo aleatorio es de gran ayuda para muchos cálculos.

En este artículo, vimos cómo podemos aplicar números aleatorios a una simulación. Si algo relacionado con la creación de funciones o los bucles for fue confuso aquí, es posible que desee leerlos. Alternativamente, ¿por qué no avanzar con conjuntos de datos más complejos?

Compártelo: