Predicción de remuneración de futbolistas ¶
Introducción ¶
Acontinuación se realizará una predicción de remuneraciones de futbolistas a partir de estadísticas sobre sus habilidades de juego. Para ellos se filtrarán los datos de habilidades y se realizará un análisis exploratorio para identificar patrones en los datos que permitan tener información fiable e implementar una predicción mediante una regresión lineal en tensorflow.
Análisis exploratorio. ¶
Contexto ¶
Los datos son estadísticas del juego Fifa 19 con los principales equipos y jugadores de fútbol del mundo. La base de datos se encuentran en https://www.kaggle.com/karangadiya/fifa19.
Estos datos fueron extraídos desde https://sofifa.com/.
Para este análisis se utilizarán sólo las variables relacionadas a habilidades específicas de los jugadores, esta son:
LS (Left Striker): Habilidad en la posición (0-99). |
ST (Striker): Habilidad en la posición (0-99). |
||
RS (Right Striker): Habilidad en la posición (0-99). |
LW (Left Wing): Habilidad en la posición (0-99). |
||
LF (Left Forward): Habilidad en la posición (0-99). |
CF (Center Forward): Habilidad en la posición (0-99). |
||
RF (Right Forward): Habilidad en la posición (0-99). |
RW (Right Wing): Habilidad en la posición (0-99). |
||
LAM (Left Attacking Midfielder): Habilidad en la posición (0-99). |
CAM (Center Attacking Midfielder): Habilidad en la posición (0-99). |
||
RAM (Right Attacking Midfielder): Habilidad en la posición (0-99). |
LM (Left Midfielder): Habilidad en la posición (0-99). |
||
LCM (Left Center Midfielder): Habilidad en la posición (0-99). |
CM (Center Midfielder): Habilidad en la posición (0-99). |
||
RCM (Right Center Midfielder): Habilidad en la posición (0-99). |
RM (Right Midfielder): Habilidad en la posición (0-99). |
||
LWB (Lef Wing Back): Habilidad en la posición (0-99). |
LDM (Left Defensive Midfielder): Habilidad en la posición (0-99). |
||
CDM (Center Defensive Midfielder): Habilidad en la posición (0-99). |
RDM (Right Defensive Midfielder): Habilidad en la posición (0-99). |
||
RWB (Right Wing Back): Habilidad en la posición (0-99). |
LB (Lef Back): Habilidad en la posición (0-99). |
||
LCB (Left Center Back): Habilidad en la posición (0-99). |
CB (Center Back): Habilidad en la posición (0-99). |
||
RCB (Right Center Back): Habilidad en la posición (0-99). |
RB (Right Back): Habilidad en la posición (0-99). |
||
Crossing: Ofensiva, habilidad en centros (0-99). |
Finishing: Ofensiva, habilidad en definición (0-99). |
||
HeadingAccuracy: Ofensiva, precisión con la cabeza (0-99). |
ShortPassing: Ofensiva, habilidad en pases cortos (0-99). |
||
Volleys: Ofensiva, habilidad en voleas (0-99). |
Dribbling: Técnica, habilidad en regates (0-99). |
||
Curve: Técnica, habilidad en balones con efecto (0-99). |
FKAccuracy: Técnica, habilidad en precisión faltas (0-99). |
||
LongPassing: Técnica, habilidad en pases largos (0-99). |
BallControl: Técnica, habilidad en control del balón (0-99). |
||
Acceleration: Movimiento, aceleración (0-99). |
SprintSpeed: Movimiento, velocidad (0-99). |
||
Agility: Movimiento, agilidad (0-99). |
Reactions: Movimiento, reflejos (0-99). |
||
Balance: Movimiento, equilibrio (0-99). |
ShotPower: Potencia, potencia (0-99). |
||
Jumping: Potencia, salto (0-99). |
Stamina: Potencia, resistencia (0-99). |
||
Strength: Potencia, fuerza (0-99). |
LongShots: Potencia, tiros lejanos (0-99). |
||
Aggression: Mentalidad, agresividad (0-99). |
Interceptions: Mentalidad, intercepción (0-99). |
||
Positioning: Mentalidad, colocación (0-99). |
Vision: Mentalidad, visión (0-99). |
||
Penalties: Mentalidad, penales (0-99). |
Composure: Mentalidad, compostura (0-99). |
||
Marking: Defensa, marcaje (0-99) |
StandingTackle: Defensa, robos (0-99) |
||
SlidingTackle: Defensa, entrada agresiva (0-99) |
GKDiving: Portero, estirada (0-99) |
||
GKHandling: Portero, paradas (0-99) |
GKKicking: Portero, saques (0-99) |
||
GKPositioning: Portero, colocación (0-99) |
GKReflexes: Portero, reflejos (0-99) |
La variable a predecir es Wage que es el salario del jugador.
Además, se dejará la variable Name (nombre del jugador) como marcador para contextualizar el resultado.
Análisis de los datos ¶
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.preprocessing import normalize
from sklearn import linear_model
import re
import seaborn as sns; sns.set(style="ticks", color_codes=True)
# Filtrar columnas a utilizar.
df=pd.read_csv('data.csv')
header = list(df)
Name = df[[list(df)[2]]]
x_vals = df[list(df)[28:(df.shape[1]-1)]]
header = list(x_vals)
y_vals = df[[list(df)[12]]]
Name.head(5)
La variable Name no requiere transformación.
La variable Wage a predecir está en formato de texto y con una nomenclatura que no sirve para realizar cálculos, se debe transformar.
y_vals.head(10)
pd.unique(y_vals['Wage'])
y_vals = np.array([float(re.sub(r'K$' ,"", re.sub(r'^€', "", x)))*1000 for x in y_vals['Wage']])
y_vals
Una vez transformada a float la variable a predecir (Wage), se revisará la distribución de los datos.
Observando el histograma claramente hay pocos jugadores que reciben una remuneración muy alta, esto puede causar malas predicciones. Para ello vamos a considerar en las predicciones el log(Wage).
Por otro lado el histograma del Wage muestra algunas observaciones con valor 0, estos son valores atípicos y no serán considerado e el análisis.
Wage_no0 = np.where(y_vals>0)[0]
y_vals = y_vals[Wage_no0]
x_vals = np.array(x_vals)[Wage_no0,:]
Name = np.array(Name)[Wage_no0]
flierprop = dict(markerfacecolor='None', marker='o', markeredgecolor='xkcd:violet')
medianprop = dict(color='xkcd:salmon')
fig, axs = plt.subplots(1,4, sharex=False, figsize=[14,3])
fig.suptitle('Histograma y Boxplot de remuneraciones de futbolistas',
y=0.99, size=15)
fig.subplots_adjust(hspace=0.5, wspace=0.25, top=0.8)
axs[0].hist(y_vals, color='xkcd:violet')
axs[0].set_title('Wage')
axs[1].hist(np.log(y_vals+1), color='xkcd:violet')
axs[1].set_title('Log(Wage)')
axs[2].boxplot(y_vals, vert=False, flierprops=flierprop, medianprops=medianprop)
axs[2].set_title('Wage')
axs[3].boxplot(np.log(y_vals+1), vert=False, flierprops=flierprop, medianprops=medianprop)
axs[3].set_title('Log(Wage)')
Hay mucho valores atípicos superiores, al examinar estos valores y evaluarlos se observa que el conjunto de valores atípicos tiene valores atípicos (o sea, algunos futbolistas ganan sumas muy muy altas comparados con los futbolistas que ya ganan sumas altas).
Por lo que para efectos prácticos se dividirá el conjunto en 3 grupos sueldos normales, sueldos altos y sueldos muy altos y se utilizará el logaritmo del sueldo como dato de remuneración.
corte = 1.5
Q1 = pd.DataFrame(y_vals).quantile(0.25)[0]
Q3 = pd.DataFrame(y_vals).quantile(0.75)[0]
IQR = Q3 - Q1
y_vals_sa = y_vals[y_vals>=(Q3 + corte * IQR)]
Qa1 = pd.DataFrame(y_vals_sa).quantile(0.25)[0]
Qa3 = pd.DataFrame(y_vals_sa).quantile(0.75)[0]
IQRa = Qa3 - Qa1
Sueldo_normal = y_vals<(Q3 + corte * IQR)
Sueldo_alto = (y_vals>=(Q3 + corte * IQR))&(y_vals<(Qa3 + corte * IQRa) )
Sueldo_muyalto = y_vals>=(Qa3 + corte * IQRa)
print('Hay '+str(sum(Sueldo_normal))+' futbolistas con sueldo normal.')
print('Hay '+str(sum(Sueldo_alto))+' futbolistas con sueldo alto.')
print('Hay '+str(sum(Sueldo_muyalto))+' futbolistas con sueldo muy alto.')
flierprop = dict(markerfacecolor='None', marker='o', markeredgecolor='xkcd:violet')
medianprop = dict(color='xkcd:salmon')
fig, axs = plt.subplots(1,4, sharex=False, figsize=[14,3])
fig.suptitle('Histograma y Boxplot de remuneraciones de futbolistas (Sueldos Normales)',
y=0.99, size=15)
fig.subplots_adjust(hspace=0.5, wspace=0.25, top=0.8)
axs[0].hist(y_vals[Sueldo_normal], color='xkcd:violet')
axs[0].set_title('Wage')
axs[1].hist(np.log(y_vals[Sueldo_normal]+1), color='xkcd:violet')
axs[1].set_title('Log(Wage)')
axs[2].boxplot(y_vals[Sueldo_normal], vert=False, flierprops=flierprop, medianprops=medianprop)
axs[2].set_title('Wage')
axs[3].boxplot(np.log(y_vals[Sueldo_normal]+1), vert=False, flierprops=flierprop, medianprops=medianprop)
axs[3].set_title('Log(Wage)')
fig, axs = plt.subplots(1,4, sharex=False, figsize=[14,3])
fig.suptitle('Histograma y Boxplot de remuneraciones de futbolistas (Sueldos Altos)',
y=0.99, size=15)
fig.subplots_adjust(hspace=0.5, wspace=0.25, top=0.8)
axs[0].hist(y_vals[Sueldo_alto], color='xkcd:violet')
axs[0].set_title('Wage')
axs[1].hist(np.log(y_vals[Sueldo_alto]+1), color='xkcd:violet')
axs[1].set_title('Log(Wage)')
axs[2].boxplot(y_vals[Sueldo_alto], vert=False, flierprops=flierprop, medianprops=medianprop)
axs[2].set_title('Wage')
axs[3].boxplot(np.log(y_vals[Sueldo_alto]+1), vert=False, flierprops=flierprop, medianprops=medianprop)
axs[3].set_title('Log(Wage)')
fig, axs = plt.subplots(1,4, sharex=False, figsize=[14,3])
fig.suptitle('Histograma y Boxplot de remuneraciones de futbolistas (Sueldos Muy Altos)',
y=0.99, size=15)
fig.subplots_adjust(hspace=0.5, wspace=0.25, top=0.8)
axs[0].hist(y_vals[Sueldo_muyalto], color='xkcd:violet')
axs[0].set_title('Wage')
axs[1].hist(np.log(y_vals[Sueldo_muyalto]+1), color='xkcd:violet')
axs[1].set_title('Log(Wage)')
axs[2].boxplot(y_vals[Sueldo_muyalto], vert=False, flierprops=flierprop, medianprops=medianprop)
axs[2].set_title('Wage')
axs[3].boxplot(np.log(y_vals[Sueldo_muyalto]+1), vert=False, flierprops=flierprop, medianprops=medianprop)
axs[3].set_title('Log(Wage)')
y_vals = np.log(y_vals + 1)[Sueldo_normal]
x_vals = np.array(x_vals)[Sueldo_normal,:]
Name = np.array(Name)[Sueldo_normal]
Para los análisis posteriores y las predicciones se considera sólo los jugadores con sueldos en un rango de
Ahora revisaremos los atributos de los futbolistas, hay varios NaN en el dataset, estos datos son información referida a los porteros.
Los porteros no tienen estadísticas asociadas a las posiciones definidas en el dataset, además su comportamiento a nivel de sueldos en el mercado del futbol es diferente al resto de los jugadores, por lo que para este análisis se eliminarán los datos NaN y las variables asociadas a los porteros GKDiving, GKDiving, GKKicking, GKPositioning y GKReflexes.
Name = [x[-1] for x in Name]
x_vals = pd.DataFrame(x_vals, columns=header)
index_null1 = np.where(x_vals[list(x_vals)[0]].isnull())
index_null2 = np.where(x_vals[list(x_vals)[26]].isnull())
index =[]
for i in range(len(index_null1[0])):
index.append(index_null1[0][i])
for i in range(len(index_null2[0])):
index.append(index_null2[0][i])
index_null = pd.unique(index)
print("Hay "+str(len(index_null))+" observaciones con valores NaN, relativos a los porteros.")
Name = pd.DataFrame(Name, columns=['Name'])
y_vals2 = pd.DataFrame(y_vals).drop(index_null, axis = 0) # Elimina target de las observaciones NaN.
y_vals = np.array([x for x in y_vals2[0]])
Name = np.array(pd.DataFrame(Name).drop(index_null, axis = 0)) # Elimina observaciones NaN
x_vals = x_vals.drop(index_null, axis = 0) # Elimina observaciones NaN
xvals2 = np.array(x_vals)
for i in range(x_vals.shape[0]):
for j in range(0,26):
xvals2[i,j] = float(re.sub(r'\+\w$', "", x_vals.iloc[i,j]))
x_vals = xvals2[:,:55] # elimina variables asociadas a los porteros
header = header[0:55] # elimina variables asociadas a los porteros
Ahora transformamos los datos de las variables predictoras en x_vals. Los datos de las columnas LS a la RB, que representan la puntuación de un jugador en esa posición tienen la forma 88+2, donde el primer número es el puntaje al inicio de la temporada y el segundo representa el incremento durante la temporada. En el análisis se omitirá esto último, quedandonos con el puntaje inicial.
Acontinuación se procede a dividor los conjuntos de datos en conjunto de entrenamiento(80%) y conjunto de prueba(20%).
Además se normalizarán las variables predictoras, como el rango de valoración va de 0-100, se normalizará todo por 100, quedando todas las variables predictoras entre 0-1.
f_train_test = 0.8
np.random.seed(123)
train_idx = np.random.choice(len(x_vals), round(len(x_vals)*f_train_test), replace=False)
test_idx = np.array(list(set(range(len(x_vals)))-set(train_idx)))
# Sueldo Normal
x_vals_train = x_vals[train_idx,]
x_vals_test = x_vals[test_idx]
y_vals_train = y_vals[train_idx]
y_vals_test = y_vals[test_idx]
Name_train = Name[train_idx]
Name_test = Name[test_idx]
# Como el rango de todas las columnas es de 0-100, dividiremos el conjunto entre 100.
x_vals_train = x_vals_train/100
x_vals_test = x_vals_test/100
Para los siguientes análisis se utilizará el conjunto de entrenamiento.
En la gráfica de correlación se observan muchas variables con alta correlación, esto puede traer inconvenientes al momento de la predicción, lo que se intentará manejar con los hiperparámetros de la norma L1 y L2.
f,ax = plt.subplots(figsize=(25, 15))
corr = abs(pd.DataFrame(np.array(x_vals_train, dtype='float'), columns=header).corr())
sns.heatmap(corr, annot=True, linewidths=0.5,linecolor="xkcd:gray", fmt= '.1f',ax=ax,
cmap='RdPu')
plt.show()
rows = 11
cols = 5
fig, axs = plt.subplots(rows,cols, sharex=False, figsize=[15,50])
fig.suptitle('Remuneración vs Habilidades', y=0.95, size=15)
fig.subplots_adjust(hspace=0.3, wspace=0.4, top=0.94)
nnn=0
for n1 in range(rows):
for n2 in range(cols):
sns.kdeplot(x_vals_train[:,nnn], y_vals_train, cmap='Reds', shade=True, shade_lowest=True, ax=axs[n1, n2])
axs[n1, n2].set_title(header[nnn])
axs[n1, n2].set_xlim(0.0, 1.0)
nnn = nnn + 1
Los datos visualizados muestran una concentración de datos en valores de bajas remuneraciones, esto podría producir una mala predicción para valores altos.
Por otro lado, algunas variables muestran una leve tendencia a mostrar un alza en remuneración cuando sube la puntuación, lo que es una buena señal de predicción para una regresión lineal.
Regresión Lineal ¶
# Declaración de Sesion y fijado de semillas aleatorias.
session = tf.Session()
tf.set_random_seed(321)
np.random.seed(321)
# Hiperparámetros
epochs = 1000
batch_size = int(np.round(x_vals_train.shape[0]*0.7)) # 70% del conjunto de entrenamiento
learning_rate = 0.001
elastic_param1 = tf.constant(0.05)
elastic_param2 = tf.constant(0.001)
# Declaración de placeholders
x_data = tf.placeholder(shape=[None, x_vals_train.shape[1]], dtype = tf.float32)
y_target = tf.placeholder(shape = [None, 1], dtype = tf.float32)
# Declaración de variables
A_ml = tf.Variable(tf.random_normal(shape = [x_vals_train.shape[1],1]))
b_ml = tf.Variable(tf.random_normal(shape = [1,1]))
# Declaración de predicción
y_pred = tf.add(tf.matmul(x_data, A_ml), b_ml)
# Función de pérdidas
l1_a_loss = tf.reduce_mean(tf.abs(A_ml))
l2_a_loss = tf.reduce_mean(tf.square(A_ml))
e1_term = tf.multiply(elastic_param1, l1_a_loss)
e2_term = tf.multiply(elastic_param2, l2_a_loss)
loss = tf.expand_dims(tf.add(tf.add(tf.reduce_mean(tf.square(y_target- y_pred)),e1_term), e2_term), 0)
# Inicialización de varibles
init = tf.global_variables_initializer()
session.run(init)
# Optimizador
my_opt = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
train_step = my_opt.minimize(loss)
loss_vec_train = []
loss_vec_test = []
loss_vec_val = []
RMSE_rl = []
for i in range(epochs):
# carga las observaciones aleatorias de entrenamiento y pruebas
rand_idx = np.random.choice(len(x_vals_train), size=batch_size)
rand_test_idx = np.array(list(set(range(len(x_vals_train)))-set(rand_idx)))
# separa conjunto de prueba aleatorio
rand_x = x_vals_train[rand_idx]
rand_y = np.transpose([y_vals_train[rand_idx]])
# separa conjunto de prueba aleatorio
rand_test_x = x_vals_train[rand_test_idx]
rand_test_y = np.transpose([y_vals_train[rand_test_idx]])
# entrenamiento iteracion i
session.run(train_step, feed_dict={x_data : rand_x, y_target: rand_y})
# perdidas del conjunto de entrenamiento
temp_loss_train = session.run(loss, feed_dict={x_data: rand_x, y_target: rand_y})[0]
loss_vec_train.append(temp_loss_train)
# perdidas del conjunto de prueba
temp_loss_test = session.run(loss, feed_dict={x_data: rand_test_x, y_target: rand_test_y})[0]
loss_vec_test.append(temp_loss_test)
# perdidas del conjunto de validación
temp_loss_val = session.run(loss, feed_dict={x_data: x_vals_test, y_target: np.transpose([y_vals_test])})[0]
loss_vec_val.append(temp_loss_val)
# RMSE
pred_test_rl = session.run(y_pred, feed_dict={x_data: x_vals_test})[0]
rmse_temp_rl = np.sqrt(np.mean(np.square(np.exp(y_vals_test) - np.exp(pred_test_rl))))
RMSE_rl.append(rmse_temp_rl)
if(i+1)%np.round(epochs/30)==0:
acc_and_loss = [i+1, temp_loss_train, temp_loss_test, temp_loss_val, rmse_temp_rl]
print("Paso #{}, Train Loss {:.3f}, Test Loss {:.3f}, Valid Loss {:.3f}, RMSE {:.3f}".format(*acc_and_loss))
Results = pd.DataFrame(Name_test, columns=['Name'])
Results['Wage'] = pd.Series(np.exp(y_vals_test)-1, index=Results.index)
pred_test_rl = session.run(y_pred, feed_dict={x_data: x_vals_test})
Results['Prediccion'] = pd.Series([np.round(np.exp(x[-1])-1,0) for x in pred_test_rl], index=Results.index)
plt.figure(figsize=(14,6))
plt.plot(loss_vec_train, color='xkcd:aquamarine', linestyle='-.', label="Pérdidas en Entrenamiento")
plt.plot(loss_vec_test, color='xkcd:salmon', linestyle='--', label="Pérdidas en Pruebas")
plt.plot(loss_vec_val, color='xkcd:violet', linestyle='-', label="Pérdidas en Validación")
plt.title("Pérdidas Regresión Lineal (ElasticNet)")
plt.xlabel("Iteración")
plt.ylabel("Pérdida")
plt.legend(loc="upper right")
plt.show()
plt.figure(figsize=(14,6))
plt.plot(RMSE_rl, color='xkcd:salmon', linestyle='-.',label="Error de Validación")
plt.axhline(y=RMSE_rl[len(RMSE_rl)-1], color='xkcd:violet', linestyle='-',
label = "RMSE "+str(np.round(RMSE_rl[len(RMSE_rl)-1],3)))
plt.title("Error Remuneración Futbolistas (Regresión Lineal)")
plt.xlabel("Jugadores")
plt.ylabel("RMSE")
plt.legend(loc="upper right")
plt.show()
RMSE = []
RMSE.append(RMSE_rl[len(RMSE_rl)-1])
session.close()
Resultados ¶
La regresión lineal entrega un RMSE de 4663, que representa un 25% aproximadamente del rango máximo de los datos. En general el error es debido a que el modelo no predice bien los valores altos.
Por otro lado este resultado es mejorable considerando otros atributos como el equipo del jugador, la liga, las ventas en publicidad, el prestigio, el país, etc.
Claramente el sueldo no es sólo definido por las habilidades de un jugador (como se puede ver en la tabla inferior), hay muchas otras carácterísticas que influyen. Introduciendo estos atributos al modelo debería mejorar, sobre todo para valores altos, donde ambos modelos muestran un bajo desempeño.
Results.loc[np.random.choice(len(x_vals_test), size=20)]