Archivos de la categoría Big Data

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.

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

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.

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

Podemos multiplicar

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))

E incluso podemos crear modelos lineales

W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + b

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:

init = tf.global_variables_initializer()
sess.run(init)

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:

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

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:

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]}))

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:

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

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.

Que formato es el mejor para guardar números con decimales (float)?

Hace ya algunos días que le estoy dando vueltas al crear un script que me cogiera determinados datos y los fuera guardando en un archivo. Como quiero guardar muchos datos durante un largo periodo de tiempo he pensado que quizás debería empezar por lo básico. Que formato de archivo es mejor para almacenar este tipo de datos.

Para averiguar que formato es el ideal para tal propósito he ideado un script en python que lo que hace es generar cuatro números aleatorios entre -10 y 10 por cada una de las 100.000 hileras disponibles (en total 400.000 valores). Luego, usando el mismo data set, he almacenado esta información usando distintos formatos. Los formatos que he usado son texto plano, CSV, TSV, JSON, SQLite y HDF5. Estos formatos son los que me han parecido adecuados para este tipo de tarea. He dejado fuera XML porque me pareció que tiene gran similitud con JSON y realmente no necesito la jerarquía ni flexibilidad que este formato me ofrece.

Véase que el mismo script indica el tamaño de cada fichero. El tiempo de ejecución es de unos 65 segundos en mi laptop.

El script:


import numpy as np
import os
from os import listdir
from os.path import isfile, join

import json
import csv
import sqlite3
import h5py #pip install h5py

#generated 4 rows with number_of_floats data
def data_generation(number_of_floats):
	ret = np.ndarray((number_of_floats, 4))
	for i in range(number_of_floats):
		ret[i] = np.random.uniform( -10, 10, 4 )
	return ret

#standard text saving
def save_text_file(data):
	f = open('text.txt', 'w')
	for el in data:
		f.write(str(el).strip('[]'))
		f.write('\n')
	f.close()
	return True

#saving with json files
def save_json(data):
	f = open('json.json', 'w')
	j=json.dumps(data.tolist())
	json.dump(j, f)
	f.close()
	return True

#saving numbers on csv
def save_csv(data):
	with open('csv.csv', 'w') as csvfile:
		fieldnames = ['Col_A', 'Col_B', 'Col_C', 'Col_D']
		writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
		for el in data:
			writer.writerow({'Col_A': str(el[0]), 'Col_B': str(el[1]),'Col_C': str(el[2]),'Col_D': str(el[3])})
	return True

#Tab Separated Values (TSV)
def save_tsv(data):
	with open('tsv.tsv', 'w') as tsvfile:
		writer = csv.writer(tsvfile, delimiter='\t')
		for el in data:
				writer.writerow(el)
	return True

#save data in sqlite
def save_sqlite(data):
	conn = sqlite3.connect('data.sqlite3')
	cur = conn.cursor()
	cur.execute('DROP TABLE IF EXISTS Data ')
	cur.execute('CREATE TABLE Data (Col_A REAL, Col_B REAL, Col_C REAL, Col_D REAL)')
	for el in data:
		cur.execute('INSERT INTO Data VALUES ('+str(el[0])+', '+str(el[1])+', '+str(el[2])+', '+str(el[3])+')')
	conn.commit()
	conn.close()

#save the data in a hdf file
def save_hdf(data):
	h = h5py.File('data.hdf5', 'w')
	dset = h.create_dataset('data', data=data)

#check the file size
def show_file_size():
	mypath = '.'
	onlyfiles = [ f for f in listdir(mypath) if isfile(join(mypath,f)) ]
	for fil in onlyfiles:
		statinfo = os.stat(fil)
		print 'name: '+str(fil)
		print 'size: '+str(statinfo.st_size)
		print ' '
	print onlyfiles

##############################
#
# Main
#
##############################

data = data_generation(100000)
save_text_file(data)
save_csv(data)
save_json(data)
save_csv(data)
save_tsv(data)
save_sqlite(data)
save_hdf(data)
show_file_size()
print 'Done'

Finalmente los resultados:

data-format-comparsion-plot

Formato Tamaño (Bytes)
Texto plano 4806060
CSV 5900742
TSV 7901330
JSON 8109034
SQLite 4468736
HDF5 3202144

Como se puede observar HDF5 es el ganador claramente siendo casi un 30% menor en tamaño que Sqlite que está ocupando el segundo lugar. No es de extrañar puesto que HDF es un formato de fichero diseñado especialmente para organizar y almacenar grandes cantidades de datos (ideado para supercomputadores). Para nuestra suerte las librerías tienen licencia BSD permitiendo mejoras y creación aplicaciones por parte de terceros. Lo que no me esperaba es que TSV obtuviera un tamaño similar a JSON y no a CSV. Sinceramente pensaba que CSV y TSV eran básicamente lo mismo.

Bonus: Para los interesados el script está en github.

Instalar MongoDB en Ubuntu

Uno de los propósitos de año nuevo, como ya visteis, ya me he puesto manos a la obra en aprender MongoDB. Para esto necesito tenerlo instalado en el ordenador (con SO Ubuntu) para poder trastear. Así que al turrón!

Primero de todo MongoDB nos recomienda importar la “public key” usada por el gestor de paquetes.

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10

Luego crearemos una lista en un fichero para MongoDB

echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list

Seguidamente actualizaremos la base local de paquetes con:

sudo apt-get update

Finalmente instalaremos la última versión estable de MongoDB

sudo apt-get install -y mongodb-org

Y así se instala MongoDB en nuestro ordenador local con Ubuntu! :)

Para iniciar MongoDB tendremos que ejecutar en la consola “mongod”. Pero para acceder a la consola y poder ejecutar queries en la base de datos tendremos que usar el comando “mongo”.

Bonus: Para los curiosos, la versión de 32bits permite un límite teórico de 4,3GB de datos (2^32). Teniendo en cuenta padding, espacios vacíos y otras ineficiencias la empresa estima que el espacio disponible para datos es de entre 2GB y 4GB.

Las mejores 8 herramientas para visualizar datos

Siguiendo ya un poco con algunos posts de visualización de datos del big data, he escrito otro más. Esta vez quizás conozcáis algunas herramientas pero os puedo asegurar que os sorprenderán algunos de sus usos para mostrar datos.

1 Excel

Excel te permite cambiar el color de las casillas según los parámetros anteriormente indicados. De este modo podremos visualizar a primera vista los valores. No da mucho juego pero sirve para representarlo de una forma rápida.

2 Google Chart

Es un conjunto de herramientas que te permite mostrar los datos de distintas maneras. Es el único sitio que ofrece la posibilidad de mostrar imágenes dinámicas. El problema de esto es que se procesa en el lado del cliente, por lo que si el navegador no tiene JavaScript se quedará con las ganas.

3 Flot

Es una librería para generar gráficas lineales o de barras. También se ejecuta desde la banda del cliente y se puede visualizar desde cualquer navegador que soporte VML. Ofrece muchas funciones, por lo que es más fácil personalizar las gráficas.

Algo parecido puede ser Rapaël y D3 cuya librería está más orientada a cosas más complejas.

4 Visual.ly

Es una herramienta de desarrollo de infográficos, ahora que se han puesto tanto de moda puede se una buena opción. Aunque sinceramente es algo limitado, si no sabes y no tienes ningún diseñador cerca te puede servir.

Puedes encontrar más herramientas para otras cosas en [eng] seomoz.

5 Modest Maps

Esta librería es algo (muy) sencilla pero de solo 10KB por lo que para todos los obsesos del tiempo de carga es estupendo. Para los que os mováis más en móvil os recomiendo leafet y para los que os vaya lo duro aquí tenéis OpenLayers, más complejo y con poca documentación.

6 Processing

Es un lenguaje de programación de fuente abierta que nos permite imágenes, interacciones y animaciones. Puede devolverte el fichero java, pero puedes evitar el uso de applets ya que también existe una versión JavaScript. Ahora incluso puedes llevarlo a iOS.

7 R

Es un paquete bajo licencia GNU muy interesante y muy profesional, ampliamente usado por estadistas. Es una herramienta algo compleja pero merece la pena dominarla.
(Aclarar que el programa se llama R,  no es una errata)

Gephi

Es una herramienta que nos permite relacionar distintos nodos haciendo esas imágenes que todos hemos visto alguna vez de redes en 3 dimensiones. No solamente permite visualizar grandes cantidades de datos también permite quitar algunos datos de la muestra.

Esto ha sido todo por hoy! 😀 Sé que hubiera estado mejor con fotos de cada herramienta así que si queréis visitad la [eng] fuente, en la encontraréis la mayoría de herramientas mencionadas más alguna otra que no me ha parecido importante citar.

Posibles problemas del Big Data

No todo es maravilloso en el Big Data, también tiene algunos inconvenientes que es necesario saber para no caer en errores.

Correlación: Que algo suceda no quiere decir que tenga una correlación que nos afecte. Por ejemplo que la gente que viene a trabajar los lunes esté más cansada y que los lunes tengamos más trabajadores que vienen en bus no quiere decir que al venir en bus se cansen más. Puede ser que su fin de semana fuera agotador.

Ahora ya no se pueden trazar estadísticas desde el despacho de la oficina, se tiene que hacer experimentos en el mundo real y comprobar que las hipótesis con sus conclusiones son ciertas.

No todas las organizaciones (incluida la administración) son capaces o tienen ganas de adaptarse.

Comprender los resultados: Prácticamente cualquier ordenador ahora te puede calcular grandes cantidades de datos, pero detrás de los resultados tiene que haber una conclusión. Los números por si solos son estériles, tiene que haber una parte humana para interpretar los resultados correctamente y sacar las conclusiones acertadas.

Problemas de base: Todos los datos están en un mismo sitio? Los poseedores de estos son las mismas personas? Puede pasar que en una empresa los datos estén repartidos entre los diferentes departamentos y almacenados de distintas formas. Esto requeriría una colaboración distinta entre los distintos departamentos de la misma empresa.

Pero no sólo esto, sino que también puede pasar que la empresa no sea la propietaria de los datos y consecuentemente no los puedas usar en según que circunstancias o necesites permisos.

Problemas de identificación: Esta es la incapacidad de identificación de los datos. Pongo un ejemplo más aclarador. Si lo que transmite datos es una tarjeta SIM como sabemos si es hombre o mujer, su edad… Los datos son de más utilidad si están ligados con las personas.

Problemas de privacidad: cada vez más los clientes quieren tener más control sobre sus datos y en que forma se usan, por lo que normalmente tienen que autorizar un permiso expreso para que sus datos se usen. A parte de esto la ley de cada país dictamina como se tienen que tratar estos datos, y en ocasiones como España, esta ley es muy dura. Todo esto puede terminar como 1984 de George Orwell.

Información desactualizada: Algunas veces nos entestamos en guardar datos. Esto es bueno para hacer predicciones, pero no por eso tenemos que dejar de adquirir nueva información. Basar decisiones en datos desactualizados no es muy sabio. Siempre es mejor tener información actualizada, forzando un poco más la situación podemos encontrar el ejemplo de que un cliente se ha mudado y la residencia que tenemos ya no es válida.

Incapacidad de tratamiento de la información en tiempo real: Algunas veces no vamos a necesitar los datos de inmediato, pero otras veces si que necesitamos saber los resultados progresivos para actuar al respeto. Por ejemplo, de que sirve tener los niveles de existencias si sólo se calculan una vez por semana? Si los tienes actualizados posiblemente no tengas problemas de aprovisionamiento. Sé que es un ejemplo infrecuente raro pero sirve.

 No todos los datos son información: hay infinidad de motivos por los cuales el 100% de nuestros datos no aportan información. Como por ejemplo duplicidad de datos P.ej. Retweets manuales (o la misma info en diferentes redes sociales), backups, etc.

Problemas de relevancia: No toda la información tiene la misma importancia. Hay ruido en Internet, pero además para lo que algunos puede ser ruido para otros puede ser música. Seguro que los diarios Chinos son importantes para los Chinos, pero para mi no me aportarían demasiado a menos que viviera allí.

Como veis no todo son ventajas, aunque a mi parecer vale la pena intentarlo. El futuro está en la optimización de los recursos y en esto se basa el Big Data.

Técnicas de análisis de Big Data

Evidentemente cuanta más data tengamos más exhaustivo va a ser nuestro análisis, algunas de estas técnicas pueden ser aplicadas a grupos pequeños, pero todas pueden ser aplicadas al Big Data. Aquí van los grupos:

  • A/B Testing: Esto es una de las técnicas que se puede usar con grupos de data pequeños. Se trata de mostrar dos versiones distintas de la web (o de lo que sea) para determinar que variación se adapta mejor a nuestros objetivos.

  • Aprendizaje de asociaciones: Se trata de encontrar relaciones entre datos que nos puedan ser útiles. En el caso de Facebook sería que personas tenemos mas posibilidades de empezar a seguir, pero en caso de Amazon es que producto posiblemente compraremos si hemos realizado un seguido de acciones (por ejemplo que dos productos se suelen comprar a la vez). Sabiendo esto lo pueden poner más fácil a los clientes.

  • Clasificación: Se trata de que la computadora determine a que grupo de data pertenece un nuevo set de data basándose en clasificaciones pasadas y los ejemplos “entrados a mano”. Un ejemplo sería determinar el idioma de un texto basado en ejemplos dados por humanos que si sepan que lengua es. Evidentemente cuanto mayor sea el dato a comparar menos probabilidades de error tendrá.

  • Análisis del cluser: Se trata de reducir el cluster a grupos más pequeños y de ordenarlos de otra forma encontrando similaridades que antes se nos habían pasado por alto. Por ejemplo, que tienen en común una chica de 20 años de Madrid y un hombre sevillano de 40 años? Pues que a los dos les gusta hacer puzzles en su tiempo libre.

  • Crowdsourcing: Es una técnica de recolección de data enviada por un largo grupo de usuarios (de aquí “crowd”). Preguntas a la comunidad y esta te responde. Un ejemplo de esto sería Starbucks que pregunta a los usuarios en que podría mejorar y que nuevos productos debería sacar al mercado.

  • Fusión e integración de la data: A veces hay datos que por si solos no aportan mucho pero combinados con otros ya es otro tema. El GPS de tu móvil sólo dice dónde estás, pero combinado con Twitter puedes encontrar gente nueva, o combinado con un mapa de la zona te ayuda a ubicarte.

  • Data mining: Es un conjunto de técnicas para extraer información útil de grandes cantidades de data y presentarlo de forma que los humanos lo podamos comprender y poder sacar provecho de ello. La data si no se sabe usar por si sola no sirve de nada.

  • Aprendizaje predictivo: Con el uso de modelos predictivos (basados en estadística y machine learning) podemos determinar o intentar predecir el futuro de determinados modelos.

  • Algoritmos genéticos: También conocidos como algoritmos de la evolución sirven para mejorar problemas no lineales. Como dice la teoría de la evolución, “sobrevive el mejor adaptado”, pues este caso vendría a ser el cambio que desarrolla un mejor desempeño.

  • Machine learning: Una parte de este es la inteligencia artificial y se basa en evolucionar su comportamiento basado en datos empíricos.

  • Circuitos neuronales: Recibe este nombre porque se parecen bastante a las conexiones de nuestras neuronas. Esta técnica nos ayuda a buscar patrones no lineales y optimizarlos.

  • Análisis de redes: Es un conjunto de técnicas que permiten encontrar los nodos de más influencia, la dirección de los datos. Esto permite conocer a los influencers (para estrategias de marketing) o para identificar los cuellos de botella.

  • Optimización: Los algoritmos genéticos son una de estas técnicas, sirven para mejorar el proceso en función el coste, velocidad…

  • Reconocimiento de patrones: Es una de las partes de clasificación. Dada una entrada, da una salida siguiendo el mismo algoritmo.

  • Predecir modelos: Se trata de crear un modelo matemático con la mayor probabilidad de predecir la salida. Calculan la probabilidad de que pase una determinada cosa.

  • Regresión: Es una de las técnicas para predecir modelos, se trata de que dadas algunas constantes, calcular que pasa cuando se modifican las variables.

  • Simulación: Dadas las probabilidades de todas las variables calcula que pasa en cada escenario para unos datos concretos. Haciendo así ver como puede reaccionar nuestro (p.ej.) material, a determinadas condiciones.

Uf, este ha sido un post muy intenso. Me ha costado lo suyo pero creo que ha salido bastante completo. Espero que os haya gustado, para cualquier cosa ya sabéis, comentario! 😉