Archivo de la categoría: Analítica

11 comandos para data scientists que quieran aprender a usar la consola

Algunas veces manipular datos puede resultar costoso. A menudo los data scientists tenemos que manipular grandes cantidades de datos por lo que es bueno conocer algunos tranquillos para optimizar el proceso. Aquí os dejo unos cuantos comandos con algunas opciones para trabajar más eficientemente.

head

head archivo.txt

Este comando imprime las 10 primeras lineas del archivo. Si queremos un numero distinto de lineas podemos usar la opción -n.

head -n 20 archivo.txt

Este último comando nos imprimirá las 20 primeras lineas del archivo. Al imprimir las primeras lineas de un fichero en pantalla nos ayuda a obtener la estructura global del archivo y algunos valores para hacernos una idea general del contenido del archivo.

tr

Este comando es perfecto para pre-procesar archivos. Por ejemplo podemos cambiar el archivo de tsv a csv.

cat tab_delimited.txt | tr "\\t" "," comma_delimited.csv

Algo muy interesante de “tr” son las clases. Las clases son funciones de elementos algo más “abstractos”. Aquí una lista de algunos:

[:alnum:] todas las letras y dígitos
[:alpha:] todas las letras
[:blank:] todos los espacios
[:digit:] todos los dígitos
[:lower:] todas las letras minúsculas
[:upper:] todas las letras mayúsculas
[:punct:] todos los caracteres de puntuación

y si los concatenas puedes hacer un script bastante interesante. También puedes usar las expresiones regulares. Aquí ejemplo para pasar de mayúsculas a minúsculas

cat filename.csv | tr '[A-Z]' '[a-z]'

wc

Este es un contador de palabras (word count). Basado en mi experiencia uso la opción -l a menudo. Esta opción cuenta el número de lineas en vez de palabras. Otras opciones

  • wc -m imprimer el recuento de caracteres
  • wc -L imprime la longitud de la linea más larga
  • wc -w cuenta el numero de palabras
  • wc – l cuenta lineas

split

Nos permite trocear archivos fácilmente para reducir su tamaño. El problema es que no añade la extensión del fichero a los nuevos documentos. Podemos trocear un fichero cada 500 lineas con el siguiente comando.

split -l 500 fichero.csv nuevo_fichero_

Si queremos poner una extensión a los nuevos ficheros tendremos que usar el siguiente comando en el directorio del output

find . -type f -exec mv '{}' '{}'.csv \;

Si queremos numerar los archivos partidos tendremos que usar el flag -d para indicar que el sufijo sea numérico.

uniq

Uniq solo opera con lineas contiguas idénticas. Motivo por el cual es interesante añadir el sort antes. El sort nos pone lineas idénticas contiguamente.

sort

# Ordenando la segunda columna alfabéticamente
sort -t, -k2 filename.csv
# Numericamente 
sort -t, -k2n filename.csv
# Orden inverso 
sort -t, -k2nr filename.csv
  • sort -f ignora el caso
  • sort -r ordena inversamente
  • sort -k especifica el identificador
  • sort -t usa la coma como separador
  • sort -R mezcla el orden
  • uniq -c cuenta el numero de apariciones
  • uniq -d solo imprime las lineas duplicadas

cut

Sirve para eliminar ciertas columnas en el archivo. Por ejemplo si nos queremos quedar con la primera y tercera columna

cut -d, -f 1,3 filename.csv

Pero si queremos todas las columnas menos la primera

cut -d, -f 2- filename.csv

puede servir perfectamente con otros comandos.

paste

este comando puede ser interesante ya que pone juntamente dos archivos. No pone uno al final del siguiente sino cada fila de lado.

Si tenemos dos ficheros

# names.txt 
adam 
john 
zach

y

# jobs.txt 
lawyer 
youtuber 
developer

Los podemos juntar usando el comando

# Join the two into a CSV 
paste -d ',' names.txt jobs.txt > person_data.txt

Consiguiendo el resultado

# Output 
adam,lawyer 
john,youtuber 
zach,developer

grep

Este es uno de los comandos mas famosillos en el mundillo y extremadamente poderoso. Grep busca expresiones regulares y las imprime. Es usado a menudo juntamente con otros comandos.

# Buscar recursivamente nombres de ficheros que contengan la palabra "word"
grep -lr 'word' .

Algunas opciones interesantes

  • alias grep=”grep –color=auto” hace grep más colorido
  • grep -E usa la versión extendida de las expresiones regulares
  • grep -w busca un mach completo de la palabra
  • grep -l imprme el nombre de los ficheros conteniendo la palabra
  • grep -v invierte el match

sed

Este comando también es uno de los más potentes. Trabaja linea a linea. La función más básica es s/old/new/g . Podemos eliminar las comas de los miles en un fichero csv

sed -i '' 's/\([0-9]\),\([0-9]\)/\1\2/g' data.txt 
# balance,name 
# 1000,john 
# 2000,jack

o eliminar una linea especifica

sed -i '' '/jack/d' data.txt 
# balance,name 
# 1000,john

awk

Este también es un comando de los más usados y el último de hoy. Tiene bastantes de las funcionalidades de grep en su ultima versión.

awk '/word/' filename.csv

En el siguiente ejemplo awk imprime la 3a y 4a columna de las filas que contengan la palabra word.

awk -F, '/word/ { print $3 "\t" $4 }' filename.csv

Es capaz de usar múltiples expresiones numéricas

# Print line number and columns where column three greater 
# than 2005 and column five less than one thousand
awk -F, ' $3 >= 2005 && $5 <= 1000 { print NR, $0 } ' filename.csv

puede hacer un sumatorio de las columnas para las filas que cumplan cierta condición

awk -F, '$1 == "something" { x+=$3 } END { print x }' filename.csv

Puede imprimir filas duplicadas

awk -F, '++seen[$0] == 2' filename.csv

O borrar duplicados

# lineas consecutivas
awk 'a !~ $0; {a=$0}']
# Lineas no consecutivas
awk '! a[$0]++' filename.csv
# Más eficiente
awk '!($0 in a) {a[$0];print}

Substituir valores usando gsub

awk '{gsub(/scarlet|ruby|puce/, "red"); print}'

Fuente: https://www.kdnuggets.com/2018/06/command-line-tricks-data-scientists.html

Resumen del paper: Análisis de datos topológicos

Recientemente me encontré un par de papers relevantes para la minería de datos (data mining). Incluso hay una empresa que basa su business model en este concepto (Ayasdi). El concepto como habéis podido leer en el titulo es análisis de datos topológicos. ¿Que significa esto? La ida principal, tal y como se expone en la Figura 1 (sacada del paper [1]), se basa en que los datos tienen forma y la forma es consistente. Por ejemplo, la letra “A” seguirá siendo la misma letra a pesar de que le apliquemos distintas transformaciones ya que la información obtenida es calculada en base a las distancias relativas. Podemos rotar los datos, hacia un lado u otro. Podemos cambiar la tipografía o la forma (aplastarla o extenderla) que seguirá siendo la misma letra. Al final la letra “A” esta formada por millones de puntos que no vemos. Quizás perdemos algo de detalle especifico pero se gana en visión global.

descripción gráfica de la letra A
Figura 1: Transformaciones aplicadas a la letra A siguen formando la misma letra. Extraído de [1]
El primer paso consiste en agrupar en sub-poblaciones en bins (contenedores). En el segundo paso estas divisiones son analizadas. Cada uno de los contenedores contiene puntos que son similares el uno al otro. Como los bins han sido divididos de tal forma que solapan entre ellos por lo que cada punto de nuestros datos pueden estar en más de un grupo. Finalmente para construir la red (network) dibujamos un link entre los distintos clusters de la network final.

Para empezar a construir la red tenemos que escoger la métrica y la lente. La métrica la usaremos para medir la similitud (o distancia) entre dos puntos mientras que la lente es una función matemática para observar los datos. Cualquier métrica que sirva para producir un numero de un punto puede ser una lente. Una lente puede ser la media, max, min, el centro, PCA-score, distancia SVM, entre otros. Se pueden agrupar los resultados de distintas lentes multiplicando el resultado de los outputs.

El vector unitario producido por a lente es dividido en subgrupos que se solapan. Todos los puntos que tienen valores de lentes en el mismo subgrupo se agrupan juntos en un contenedor. De esta forma distintas particiones son obtenidas para todos los puntos gracias al resultado de la lente. Como las lentes producen sets que solapan es posible que un punto este en múltiples contenedores. Todos los puntos en un contenedor son agrupados ya que todos los puntos son altamente similares entre si y este grupo representa un simple nodo de nuestra red. El color que le asignaremos es la media del color de la lente de este grupo. El nodo en su representación gráfica tiene un tamaño proporcional al numero de puntos que tenga el cluster.

Habiendo hecho lo pasos anteriores tendremos distintos nodos en nuestra red, con diferentes tamaños y colores. Los nodos se conectaran entre si cuando tengan puntos en común. Estos links generaran la red topológica final.

Tenemos que tener en cuenta que esta implementación tiene dos parámetros. Uno es la resolución que indica el numero de contenedores en los cuales vamos a partir los datos. Una baja resolución genera unos pocos nodos gruesos sintetizando la información generada por el algoritmo. Contrariamente si la incrementamos genera muchísimos nodos pero de un tamaño mas pequeño perdiendo similitud entre nodos incluso generando clusters aislados. El segundo parámetro se llama ganancia y controla las regiones que se solapan entre contenedores. Como mas grande sea la ganancia mas aristas (conexiones entre nodos) vas a obtener el tu red. Este parámetro resalta las relaciones entre los elementos de tus datos.

No hay unos valores óptimos para la resolución y la ganancia. Cada red es singular y sus parámetros tienen que ser escogidos acordemente. También depende de lo que se quiera observar en la red. Por lo que cada análisis requerire una afinación (tuning). Tened en cuenta que una resolución alta no siempre es lo mejor, ya que al final lo que puede producir un resultado muy similar al observar los datos directamente

Ya hemos explicado todas las ventajas ahora toca exponer algunas de sus desventajas. No es ninguna “magic bullet” puede funcionar para muchos casos pero hay otros en los que este algoritmo no sea el mejor para nuestros datos. No hay una sola solución que sea buena para todos los casos. Parte del problema es que es una ciencia con un alto componente matemático. Como los principios del deep learning, hasta que no haya implementaciones eficientes y fáciles de usar, la “gente normal” se va a abstener de usarlo. Finalmente, el coste computacional. Calcular todos los pasos es extremadamente costoso ya que se tienen que hacer distintos barridos sobre los datos e incluso calcular las distancias entre pares.

Para los que os vaya la marcha os dejo un vídeo de youtube. Se trata de un seminario en Standford donde se explica extremadamente bien el concepto (en ingles). Luego os dejo una presentación en slideshare donde se explica el concepto detalladamente. Y para terminar os dejo tres referencias que he usado para escribir este post y que si entendéis inglés las recomiendo encarecidamente que les echéis un vistazo.

 

 

Archivos multimedia para profundizar en el TDA

 

Referencias:

 

  1. Offroy, M., & Duponchel, L. (2016). Topological data analysis: A promising big data exploration tool in biology, analytical chemistry and physical chemistry. Analytica chimica acta910, 1-11.
  2. Nielson, J. L., Paquette, J., Liu, A. W., Guandique, C. F., Tovar, C. A., Inoue, T., … & Lum, P. Y. (2015). Topological data analysis for discovery in preclinical spinal cord injury and traumatic brain injury. Nature communications6, 8581.
  3. Chazal, F., & Michel, B. (2017). An introduction to Topological Data Analysis: fundamental and practical aspects for data scientists. arXiv preprint arXiv:1710.04019.

Como calcular distancias entre dos arrays con variables binarias

El computo de distancias es un procedimiento básico para poder procesar datos. Las distancias nos sirven en el mundo real para poder desplazarnos con efectividad pero también podemos usar las distancias en el mundo no-físico para medir la similitud entre dos entidades. Cuando hablamos de entidades no-físicas nos referirnos por ejemplo a palabras, objetos o conceptos abstractos. Por ejemplo, ¿Cual es la similitud entre dos palabras? Dependiendo del enfoque podemos obtener resultados muy distintos. En este caso estoy interesado en los distintos métodos para calcular distancias entre dos vectores binarios por ejemplo [0,1,0,0,0,1,1] y [0,0,1,0,0,1,0]. Si fueran vectores normales los podríamos tratar en el plano euclidiano calculando distancias como lo haríamos sobre un mapa pero usando 7 dimensiones, pero al ser binarios cada dimensión solo puede ser 0 ó 1 (y ningún otro valor intermedio). La solución no pasa por asignar otros números a las variables porque substituyendo el “uno” por un “tres” no cambia nada. Por ejemplo, las palabras binarias pueden servir para codificar si eres hombre (0) o mujer (1). ¿Cual es la distancia entre un hombre y una mujer? Lo mismo pasa con palabras, cual es la distancia entre “hola” y “guacamole” No hay un solo método universal que nos sirva para todos los problemas, por esta razón he hecho esta lista para que os pueda servir en un futuro. Los métodos de esta lista calculan la distancia entre vectores con elementos binarios. Cada método – o algoritmo – tiene sus ventajas e inconvenientes obligando al usuario a entender el problema y escoger la solución más adecuada para cada caso.

Todas las formulas siguen el mismo patrón. En la siguiente tabla hay todas las opciones que las variables pueden tomar:

. y = 1 y = 0 Total
x = 1 n11 n10 n1•
x = 0 n01 n00 n0•
Total n•1 n•0 N

Coeficiente de Jaccard

El coeficiente de Jaccard o el índice de Jaccard es una de las distancias mas intuitivas. Computa la cardinalidad de la intersección de los dos conjuntos (el numero de elementos que están en los dos grupos a la vez) dividido por su unión (todos los elementos que forman parte de un grupo o del otro). Dividiendo usando la unión de los conjuntos evita que conjuntos grandes con poca similitud dominen el espacio.

$$ Coeficente de Jaccard = \frac{n11}{n1•+n•1}$$

Coeficiente de Sørensen–Dice

Este método fue originalmente desarrollado para la botánica. Sørensen y Diece lo desarrollaron de forma independiente con 3 años de diferencia. Muy parecido al anterior, este se basa en dos veces la intersección dividido por la cardinalidad de los conjuntos. El numerador es multiplicado por dos porque en el denominador la unión de estos conjuntos contiene la intersección de los conjuntos duplicada, hay un conjunto de elementos que están en el grupo A y el grupo B.

$$ Sørensen-Diece = \frac{2*n11}{n•1+n1•}$$

Coeficiente de correlación de pearson

Quizás esta sea la métrica más avanzada de este post. A pesar de que algunos estadistas la han usado no tengo tan claro que sea una buena métrica para comparar arrays binarios. A pesar de esto lo voy a dejar al gusto del lector comprobar su validez con los datos.

$$ Coef pearson = \frac{ (n11-\frac{n01*n10}{N})}{sqrt(n10-N*n10/n^2)*sqrt(n01-N*n01/n^2)}$$

Coeficiente de Phi

El coeficiente Phi o coeficiente de correlación de Matthews es una medida para la asociación de dos variables binarias. En teoría si calculamos el coeficiente de correlación pearson para dos variables binarias nos dará el mismo resultado que con el coeficiente Phi.

$$Phi = \frac{n11*n00 – n10*n01}{sqrt(n0•*n1•*n•0*n•1)} $$

Distancia de Yule

Con la distancia distancia de yule no es extrapolable a otras métricas. Como estamos pudiendo ver todas las métricas se parecen mucho. Se busca lo común entre los conjuntos y se divide por el computo global o similar para corregir para el tamaño de los grupos.

$$ Yule distance = \frac{2*(n10+n01)}{n11+n01+n10+n01} $$

Russell-rao

En este caso la métrica es algo distinta. Las otras métricas miran lo que tienen en común los grupos, este algoritmo hace lo contrario. Rusell-rao buscan lo que no tienen en común. Aunque siguen normalizando el resultado para conseguir valores relativos.

$$Russel-Rao = \frac{N-n11}{N}$$

Sokal-Michener

Por esta distancia y la siguiente no encontré mucha información, por lo que usé los detalles de implementación de la libreria de python scipy.

$$ Skoal-Michener = \frac{2*(n1•+n•1)}{(2*(n1•+n•1)+n11+n00)}$$

Rogers-Tanmoto

Al igual que el anterior aquí os dejo el link a la implementación de scipy.

$$ Rogers-Tanmoto = \frac{n11+n00}{n11+n00+2*(n10+n01)} $$

Mutual information

O en español información mutua mide la interconexión entre dos variables. Puesto de otra forma, mide la incertidumbre de una variable habiendo observado otra (conocido como entropía). Esta métrica también es avanzada y aunque no se como funciona en comparación a pearson me da mejores vibraciones. Me ha resultado difícil/ineficiente implementarlo yo mismo completamente así que os dejo un snippet con el código en python.

[code language=”python”]

from sklearn.metrics import mutual_info_score

def calc_MI(x, y, bins):
c_xy = np.histogram2d(x, y, bins)[0]
mi = mutual_info_score(None, None, contingency=c_xy)
return mi

[/code]

Kulczynski-2

En teoría Kulczynski consiguió mejorar la facilidad de crear clusters. Lo mismo que hace Jaccard y que Russell-Rao mejoraron. Este es la segunda versión, más sofisticada.

$$ Kulczynski-2 = \frac{\frac{n11^2}{(n11+n01)*(n11+n10)}}{2} $$

Ochiai

En teoría ochiai – también conocido como cosine similarity– consigue mejorar Kulczynski-2 y consecuentemente Jaccard y Rusell-Rao.

$$ Ochiai = sqrt(\frac{a^2}{(n11+n10)*(n11+01)} $$

Yo lo dejo aquí pero podéis encontrar más métricas en los siguientes enlaces:

Search Results Binary Vector Dissimilarity Measures for Handwriting Identification consta de varias métricas, algunas ya señaladas en los anteriores apartados. Tengo que decir que las formulas que exponen me parecen algo raras, no se si las han adaptado al caso en concreto.

Para una descripción en profundidad de Kulczynski y Ochiai

Spearman’s rank correlation coefficient or Spearman’s rho para vuestro disfrute.

Optimizadores de tensor flow

Continuando el anterior post dónde introducí tensor flow hoy vengo con los optimizadores de funciones. Tensor flow ofrece optimizadores que cambian las variables para minimizar la funcion de perdida (loss function). El más simple es el de gradiente descendiente. Computan las derivadas simbólicas (symbolic derivatives) simplemente usando el modelo y la función tf.gradients. Por ejemplo:

[code language=”python”]
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
sess.run(init) # reset values to incorrect defaults.
for i in range(1000):
sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
print(sess.run([W, b]))
los resultados finales
[array([-0.9999969], dtype=float32), array([ 0.99999082],
dtype=float32)]
[/code]

El modelo completo para la regresión linal es:

[code language=”python”]
import numpy as np
import tensorflow as tf
# Model parameters
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Model input and output
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)
# loss
loss = tf.reduce_sum(tf.square(linear_model – y)) # suma de los cuadrados
# optimizer
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# training data
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# training loop
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x:x_train, y:y_train})
# evaluate training accuracy
curr_W, curr_b, curr_loss  = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
# When run, it produces
#W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11
[/code]
tf.contrib.learn te simplifica la vida con las funciones: ejecución, entrenamiento, iteraciones, evaluaciones entre otros

[code language=”python”]
import tensorflow as tf
import numpy as np
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
num_epochs=1000)
estimator.fit(input_fn=input_fn, steps=1000)
print(estimator.evaluate(input_fn=input_fn))
# Result: {‘global_step’: 1000, ‘loss’: 1.9650059e-11}
[/code]

Introducción a TensorFlow

La web oficial de TensorFlow tiene muy buenos recursos. En esencia lo que hay en este post proviene del “get started” de la web oficial.

En el primer ejemplo importaremos TensorFlow. Crearemos dos constantes y las imprimiremos en pantalla.

[code language=”python”]
import tensorflow as tf
node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # También tf.float32 de forma implícita
sess = tf.Session()
print(sess.run([node1, node2]))
node3 = tf.add(node1, node2)
print("node3: ", node3) #Esta linea muestra las propiedades del tensor
print("sess.run(node3): ",sess.run(node3)) # Aquí se imprime el resultado[/code]

También podemos aplicar operaciones a los tensors. Las operaciones producen más tensores. En el siguiente ejemplo sumamos dos variables (tensores) y luego las sumamos. Un tensor es capaz de procesar listas también como veremos.

[code language=”python”]
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b
print(sess.run(adder_node, {a: 3, b:4.5})) # 7.5
print(sess.run(adder_node, {a: [1,3], b: [2, 4]})) # Itera sobre la lista: 3 y 7
[/code]

Podemos multiplicar

[code language=”python”]
add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))
[/code]

E incluso podemos crear modelos lineales

[code language=”python”]
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b
[/code]

Las constantes son inicializadas con tf.constant, y su valor no puede ser cambiado. Contrariamente las variables son creadas usando tf.Variable y no son inicializadas en el inicio. Para inicializar las variables  tenemos que usar una función especial como en el siguiente ejemplo:

[code language=”python”]
init = tf.global_variables_initializer()
sess.run(init)
[/code]

Lo importante es usar init. Es un “handle” que inicia el grafo, inicializando las variables que hasta entonces habían permanecido sin inicializar.

Ya que la X es la variable podemos evaluar el modelo usando distintos valores simultáneamente de la siguiente manera:

[code language=”python”]
print(sess.run(linear_model, {x:[1,2,3,4]}))
# Output: [ 0, 0.30000001, 0.60000002, 0.90000004]
[/code]

La función de pérdida (loss function) puede medir la distancia entre el modelo actual y los datos proporcionados. Usaremos la función de pérdida estándar para hacer una regresión lineal que sume los cuadrados de las distancias entre el modelo actual y los datos. El modelo crea un vector en el que cada posición corresponde a una distancia de error. Cuando usamos tf.square estamos elevando al cuadrado el error. Luego sumamos los errores para crear un simple escalar que abstrae el error de todos los puntos usando tf.reduce_sum:

[code language=”python”]
y = tf.placeholder(tf.float32)
squared_deltas = tf.square(linear_model – y)
loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))
[/code]

El valor producido es:  23.66

Podríamos mejorar el modelo manualmente asignando nuevos valores a W para obtener resultados perfectos de -1 y 1. Una variables es inicializada por el valor proporcionado por tf.Variable pero puede ser cambiada si usamos operaciones como tf.assign. Por ejemplo, W=-1 y b=1 son los parámetros óptimos de nuestro modelo. Podemos cambiar W y b acordemente:

[code language=”python”]
fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]})
#resultado: 0
[/code]

Hemos adivinado el valor perfecto para W i b aunque este no es el objetivo de  machine learning. El objetivo es encontrar los parámetros correctos para el modelo automáticamente. Pero esto lo vais a encontrar en la próxima entrega 😉

Bonus: En matemáticas y en física, un tensor es cierta clase de entidad algebraica de varias componentes, que generaliza los conceptos de escalar, vector y matriz de una manera que sea independiente de cualquier sistema de coordenadas elegido. ( wikipedia )

Reducción de dimensiones: Principal Component Analysis (PCA)

Principal Component Analysis o PCA en corto es un método de reducción de dimensiones bastante conocido y comúnmente usado. Este método transforma ortogonalmente las observaciones (quizás relacionadas) en un conjunto de puntos linealmente no relacionados. De esta forma se consigue que el primer componente tenga la varianza mayor. El siguiente componente será el que tendrá la varianza mayor de los restantes y es ortogonal al anterior componente, y así sucesivamente. Este método es sensible a la escala de las variables. Para evitar que los valores sean un problema tendremos que escalar las variables estandardizándolos antes de usar PCA.

Reducción de dimensiones: Self-organizing feature map (SOFM)

Self-organizing map (SOM) o self-organizing feature map (SOFM) es un método que usa redes neuronales (neuronal networks) para reducir las dimensiones de un vector de datos. Para reducir las dimensiones lo que hace es usar los vecinos de un punto en concreto para moverlo al nuevo espacio dimensional manteniendo la misma topografía que en el espacio original.

Una de las ventajas de SOFM es que es un método unsupervised, esto quiere decir que no necesitamos un training dataset para entrenar nuestra red neuronal. Normalmente para la inteligencia artificial (y el machine learning) se requiere que el training dataset esté etiquetado. Un data set etiquetado son puntos del input que ya se sabe cual tiene que ser el resultado. De este modo la maquina es capaz de identificar que resultado tiene que producir.

Para explicar con más detalle este método voy a usar la foto de la wikipedia que lo hace más visual.

Somtraining
SOMF training

 

En la imagen vemos la malla que representa el input en un espacio multidimensional y la zona azul que representa un espacio 2D al que queremos extrapolar nuestros puntos. El primer paso es seleccionar nuestro punto en el espacio de origen que se acerque mas al espacio 2D. El segundo paso es mover ese punto en concreto al espacio 2D. El tercer paso, y ultimo, consiste en mantener las distancias entre puntos en el nuevo plano. Si se consigue mantener las distancias entre los puntos conseguiremos una reducción de dimensiones satisfactoria.

El paper original lo podéis encontrar aquí. Pero si no tenéis ninguna afiliación académica quizás os interese checkear este otro post.

Reducción de dimensiones: T-SNE

Como ya explicamos en el post anterior los ordenadores si que pueden procesar grandes cantidades de datos multidimensionales. Pero los humanos a veces necesitamos “ver” y entender los datos. Cuando estamos trabajando en un espacio multidimensional no podemos imaginarnos nuestro dataset. Para solventar este problema se ha desarrollado T-SNE. Éste es un algoritmo pensado especialmente en reducir dimensiones (a 2 o 3) para que podamos visualizar los datos. En el paper original se expresa de forma explícita que el algoritmo está pensado para la visualización de datos. Usar T-SNE para la reducción de dimensiones puede causar efectos desconocidos. Así que si lo usas para evitar “la maldición de la dimensionalidad”  allá tu 😉

El concepto principal consiste en que los puntos cercanos (en el espacio multidimensional) se atraen y los distantes se repelen. Para conseguir este objetivo el algoritmo tiene unos cuantos parámetros que se permiten alterar. La “perplexity” es la cantidad de vecinos que un simple punto puede afectar. Por lo que he visto hasta ahora un valor entre 30-50 suele ser el óptimo. Luego tenemos epsilon que nos sirve para determinar el tamaño de los pasos de aprendizaje. Valor pequeño el algoritmo le cuesta más a encontrar el óptimo. Con un valor grande te lo puedes pasar. Finalmente la cantidad de iteraciones o steps para conseguir la convergencia. A más iteraciones en teoría más cerca del valor óptimo, pero como es evidente como más iteraciones más tiempo de computación requieres.

Para los que queráis visualizar como funciona y un poco sus efectos cambiando los parámetros podéis verlo en vuestro navegador. Si por el contrario queréis implementarlo en Javascript aquí podéis encontrar una versión oficial del desarrollador principal (es la que estoy usando). Pero si sois tan malotes que queréis implementarlo vosotros mismos mejor que os leáis el paper original.

Bonus: En el paper para computar las distancias se usa la distancia euclidiana (la “normal”) quizás otro tipo de distancias puede ir mejor para vuestro problema.

Reducción de dimensiones: Introducción a los espacios multidimensionales

En inteligencia artificial y machine learning en la mayoría de ocasiones se usan espacios multidimensionales. Los espacios multidimensionales son espacios en los que los datos requieren más de un valor. Los espacios multidimensionales son espacios con puntos repartidos por el espacio. Un espacio 2D tiene dos dimensiones, las típicas X, Y. Un espacio 3D tiene tres dimensiones X, Y, Z. Las dimensiones las puedes llamar X, Y, Z pero también perro, gato, conejo. Como seres humanos estamos limitados a poder visualizar espacios a 3D máximo. Aunque no puedas visualizar dimensiones superiores a tres, puedes llegar a entenderlo. Imagínate que quieres ir a un restaurante a 10km máximo de tu casa. Esto en un mapa son dos dimensiones norte/sur y este/oeste. Ahora si decides que quieres ir a un restaurante italiano ya hemos añadido otra dimensión. Si no quieres pagar más de 10€ por la cena ya has añadido otra dimensión. Por lo que ya tenemos un espacio de 4D. Dos para las dimensiones del mapa norte/sur, este/oeste, otra para que tipo de restaurante y la cuarta para los precios. Se le podría sumar otra dimensión si añadiéramos en que planta esta el restaurante. Virtualmente podríamos añadir infinidad de dimensiones.

Un vector o un punto en nuestro espacio es un conjunto de valores para todas las dimensiones. Un valor (o dato) puede ser indefinido o ausente, no tiene porque tener un valor concreto. Un punto es asociado a la persona o el elemento de la acción. Tu puedes ser ese vector/punto. Con el ejemplo anterior nuestro punto sería (23, 31, italiano, 10) que hacen referencia a norte/sur, este/oeste, tipo de comida y precio máximo. Las variables pueden ser categóricas y cuantitativas. Las categóricas es “italiano” no tiene un valor númerico asociado. Otros ejemplos de variables categóricas pueden ser el sexo de una persona o su color preferido. Las variables cuantitativas son los números.

La pregunta del millón es: cómo podemos pensar en un espacio de más de tres dimensiones en el que una de ellas es “italiano”? Simplemente no podemos. Nuestro cerebro no puede visualizar más de tres dimensiones. Estos espacios sólo tienen sentido matemáticamente. Por lo que para trabajar en este tipo de espacios si queremos visualizarlos de algún modo tenemos que pensar en tres dimensiones máximo y extrapolarlo. Otra opción también puede ser usar distintas técnicas de reducción de dimensiones. En los próximos posts describiré distintos métodos para la reducción de dimensiones.

He intentado hacer como Moneyball para predecir el resultado de los partidos de fútbol y he fracasado

Hace ya algún tiempo leí un post interesante sobre como un data scientist usó el concepto presentado en el libro Moneyball para escoger mejor los jugadores del FIFA 2016 cuando jugaba con “Career Mode”. El concepto de Moneyball es básicamente hacer data mining para conseguir el mejor equipo de béisbol con el menor precio. El argumento principal del libro es que al fichar los jugadores de béisbol las personas usan sus propios inclinaciones que normalmente no coinciden con la realidad o que están ancladas al pasado. Como ejemplo en el libro pone que a menudo el resultado de una táctica ofensiva de un jugador se puede medir mejor usando la frecuencia con que el bateador llega a la base en vez de la velocidad con la que batea. La velocidad de bateo ha sido la métrica que se ha usado des del principio pero después de un análisis detallado los analistas descubrieron que otras métricas son más relevantes.

A partir de este concepto creé mi propio experimento. La idea era que normalmente los analistas usan datos reales de los partidos para definir la habilidad del jugador. El problema que tiene esto es que lo que se luce el jugador depende del nivel del contrincante. Por eso mi idea era usar una valoración más o menos neutra y absoluta para predecir la calidad de cada jugador. Estas métricas las usaría para predecir la calidad del once inicial y así poder determinar el resultado final del partido.

Lo primero que hice fue recopilar tanta información como pude de todos los jugadores que pude. Para determinar la calidad del jugador usé la que usan en el videojuego FIFA 2015. El valor de las apuestas que se habían hecho en distintos sitios web de apuestas lo saqué de football-data. La alineación inicial y el resultado final del partido lo saqué de 11v11.

Todo el scrapping que hice puede sonar muy divertido y rápido pero no fue así. Durante el proceso pasé por alto varias cosas importantes. Lo primero es que en la liga española tenemos muchos jugadores españoles y con nombres españoles. El problema de los nombres españoles es que usan caracteres especiales como acentos o la ñ causando problemas con el encoding. El segundo problema es que el scrapping es divertido si la página web es consistente y está bien ordenada. Resultó no ser el caso. Por algún motivo que desconozco algunas de las páginas de la web no tenían un formato consistente con el resto de la web y tuve que programar excepciones. El tercer y último punto es que las webs de dónde extraje la información tenían herramientas para evitar el scrapping. Por suerte no eran muy estrictos con el número de peticiones que un mismo ordenador podía hacer y conseguí toda la información que buscaba en relativamente poco tiempo.

El resultado final fue que no funcionó. Me pareció una idea innovadora pero quizás no muy realista. El fútbol se ha caracterizado por las sorpresas. Usando sólo la información de las apuestas puedo predecir en un 50% cual será el resultado final del partido. Curiosamente con regresión lineal y toda la información de los jugadores se puede predecir también con un 50% quién será el ganador del partido. Si quitamos el empate de la ecuación todos los algoritmos que probé siguen funcionando igual de “bien”. Básicamente podría tirar una moneda en el aire y decir que cara gana el equipo local y cruz el visitante y acertaría el mismo número de veces que todos los algoritmos probados. Una pena que no funcionara pero me alegra haberlo probado.