Elecosistema de código abierto es muy amplio y ofrece la posibilidad de encontrar la solución para casi cualquier problema que pueda ser solucionado en código. Para tomar una buena decisión en cuanto a las herramientas a utilizar para cada caso, es importante tomar en cuenta el alcance de los diversos lenguajes de programación. El campo de la ciencia de datos no es la excepción y las herramientas de tratamiento, análisis, clasificación y visualización de datos abundan en el inmenso mar del código abierto.

En Hexagon Data, nos mantenemos actualizados sobre las herramientas más modernas en cuanto a ciencia de datos se refiere. A continuación, le mostramos algunas de las 6 herramientas de código abierto más útiles para el campo de la ciencia de datos.

1. Python

La filosofía de este lenguaje de programación interpretado hace énfasis en una sintaxis que favorezca un código legible. Python es multiplataforma y soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional.

Python fue creado por Guido Von Rossum en 1991 y es sumamente versátil. Este lenguaje tiene un papel protagónico en desarrollo web, sistemas embebidos, videojuegos, aplicaciones de escritorio y por supuesto en ciencia de datos.

Por su facilidad de uso y portabilidad se ha convertido en el favorito de muchos matemáticos e ingenieros ajenos al campo de las ciencias de la computación, convirtiéndose en favorito para realizar cómputo científico.

Empezamos por este lenguaje, ya que todas las herramientas siguientes son parte de su ecosistema.

A continuación, se muestra un ejemplo de un programa “hola mundo” escrito en Python:

print("hola mundo")

2. Anaconda

Anaconda es una plataforma de distribución libre y abierta de Python yR, que es ampliamente utilizada en ciencia de datos y aprendizaje automático (machine learning). Anaconda procesa grandes volúmenes de información, análisis predictivo, cómputos científicos y está orientada a simplificar el despliegue y administración de los paquetes de software.

Las diferentes versiones de los paquetes se administran mediante el sistema de administración del paquete conda, el cual lo hace bastante sencillo de instalar, correr, y actualizar software de ciencia de datos y aprendizaje automático como scikit-team, TensorFlow y SciPy.

La distribución Anaconda es utilizada por 6 millones de usuarios e incluye más de 250 paquetes de ciencia de datos válidos para Windows, Linux y MacOS.

El siguiente ejemplo ilustra cómo instalar un paquete de Python mediante el administrador Conda:

$ conda install keras

3. scikit-learn

Scikit-learn (anteriormente scikits.learn) es una biblioteca para aprendizaje de máquina (machine learning) de software libre para el lenguaje de programación Python. Fue creada por David Cournapeau para un proyecto del Google summer of code project en 2007. Esta biblioteca incluye varios algoritmos de clasificación, regresión y análisis de grupos como máquinas de vectores de soporte, bosques aleatorios, Gradient boosting, K-means y DBSCAN. Sickit-learn está diseñada para interoperar con las bibliotecas numéricas y científicas NumPy y SciPy.

El siguiente ejemplo muestra el código en Python que representa el método de regresión lineal usando scikit-learn:

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

diabetes = datasets.load_diabetes()

# Use only one feature
diabetes_X = diabetes.data[:, np.newaxis, 2]

# Split the data into training/testing sets
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]

# Split the targets into training/testing sets
diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]

# Create linear regression object
regr = linear_model.LinearRegression()

# Train the model using the training sets
regr.fit(diabetes_X_train, diabetes_y_train)

# Make predictions using the testing set
diabetes_y_pred = regr.predict(diabetes_X_test)

# The coefficients
print('Coefficients: \n', regr.coef_)
# The mean squared error
print("Mean squared error: %.2f"
      % mean_squared_error(diabetes_y_test, diabetes_y_pred))
# Explained variance score: 1 is perfect prediction
print('Variance score: %.2f' % r2_score(diabetes_y_test, diabetes_y_pred))

# Plot outputs
plt.scatter(diabetes_X_test, diabetes_y_test,  color='black')
plt.plot(diabetes_X_test, diabetes_y_pred, color='blue', linewidth=3)

plt.xticks(())
plt.yticks(())

plt.show()

4. TensorFlow

TensorFlow es una biblioteca de software libre que se utiliza para realizar cálculos numéricos mediante diagramas de flujo de datos y fue publicada bajo la licencia de código abierto Apache 2.0 el 9 de noviembre de 2015.

Los nodos de los diagramas representan operaciones matemáticas y las aristas reflejan las matrices de datos multidimensionales (tensores) comunicadas entre ellas. Gracias a la flexibilidad de la arquitectura, solo necesitas una API para desplegar el sistema informático de una o varias CPU o GPU en un escritorio, servidor o dispositivo móvil.

En su origen, TensorFlow fue fruto del trabajo de investigadores e ingenieros de Google Brain Team que formaban parte de la organización de investigación del aprendizaje automático de Google. Su objetivo era realizar investigaciones en el campo del aprendizaje automático y las redes neuronales profundas. A pesar de que este era su propósito inicial, se trata de un sistema lo bastante general como para poder aplicarse en muchos otros campos. TensorFlow democratizó el acceso al cálculo científico y a las redes neuronales.

Aquí no incluimos un ejemplo de TensorFlow ya que las aplicaciones son algo más complejas debido a su naturaleza de cómputo científico, pero incluimos un enlace a un ejemplo de regresión lineal.

5. Keras

Keras es una interfaz de alto nivel para redes neuronales, capaz de ejecutarse sobre TensorFlow, CNTK o Theano. Fue desarrollada con el objetivo de posibilitar la experimentación en poco tiempo de modelos de redes neuronales. Se distingue por ser amigable al usuario, modular y extensible.

En 2017 el API de Keras fue integrado al núcleo de TensorFlow como tf.keras. Aunque tf.keras y Keras tienen sus respectivos códigos base separados, están estrechamente acoplados. tf.keras es claramente es la interfaz de alto nivel a usar a la hora de construir redes neuronales con TensorFlow.

Su autor principal y contribuidor es el ingeniero de Google François Chollet.

Aquí podrás ver un ejemplo de tf.keras y podrás darte cuenta de lo sencillo que es entrenar una red neuronal.

import tensorflow as tf
mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)
model.evaluate(x_test, y_test)

6. Spark

Apache Spark es un framework de computación en clúster open-source. Fue desarrollada originalmente en la Universidad de California, en el AMPLab de Berkeley. El código base del proyecto Spark fue donado más tarde a la Apache Software Foundation que se encarga de su mantenimiento desde entonces. Básicamente, es un sistema de computación que se basa en Hadoop Map Reduce y que, principalmente, permite dividir o paralelizar el trabajo, ya que normalmente se instala en un clúster de máquina. La idea es que tengamos n máquinas y cada una de esas instancias va a tener instalada una versión de Apache Spark.

De esta manera, cuando sea necesario procesar una gran cantidad de datos podemos dividir el mismo entre n partes, y cada máquina se encargará de una décima parte del trabajo.

Apache Spark está escrito en el lenguaje de programación Scala. Para darle soporte a Python con Spark, la comunidad de Apache Spark ha libertado una herramienta, PySpark.

A continuación, te mostramos un ejemplo de regresión lineal, del mismo repositorio de Spark que puedes consultar en aquí:

from __future__ import print_function

import sys

import numpy as np
from pyspark.sql import SparkSession


D = 10  # Number of dimensions

# Read a batch of points from the input file into a NumPy matrix object. We operate on batches to
# make further computations faster.
# The data file contains lines of the form    ... . We load each block of these
# into a NumPy array of size numLines * (D + 1) and pull out column 0 vs the others in gradient().
def readPointBatch(iterator):
    strs = list(iterator)
    matrix = np.zeros((len(strs), D + 1))
    for i, s in enumerate(strs):
        matrix[i] = np.fromstring(s.replace(',', ' '), dtype=np.float32, sep=' ')
    return [matrix]

if __name__ == "__main__":

    if len(sys.argv) != 3:
        print("Usage: logistic_regression  ", file=sys.stderr)
        sys.exit(-1)

    print("""WARN: This is a naive implementation of Logistic Regression and is
      given as an example!
      Please refer to examples/src/main/python/ml/logistic_regression_with_elastic_net.py
      to see how ML's implementation is used.""", file=sys.stderr)

    spark = SparkSession\
        .builder\
        .appName("PythonLR")\
        .getOrCreate()

    points = spark.read.text(sys.argv[1]).rdd.map(lambda r: r[0])\
        .mapPartitions(readPointBatch).cache()
    iterations = int(sys.argv[2])

    # Initialize w to a random value
    w = 2 * np.random.ranf(size=D) - 1
    print("Initial w: " + str(w))

    # Compute logistic regression gradient for a matrix of data points
    def gradient(matrix, w):
        Y = matrix[:, 0]    # point labels (first column of input file)
        X = matrix[:, 1:]   # point coordinates
        # For each point (x, y), compute gradient function, then sum these up
        return ((1.0 / (1.0 + np.exp(-Y * X.dot(w))) - 1.0) * Y * X.T).sum(1)

    def add(x, y):
        x += y
        return x

    for i in range(iterations):
        print("On iteration %i" % (i + 1))
        w -= points.map(lambda m: gradient(m, w)).reduce(add)

    print("Final w: " + str(w))

    spark.stop()

Fuentes: https://medium.com/