Instalación

Lo primero es instalar Python. Para ello, la mejor forma es bajarse Anaconda, está disponible en Windows, Linux y MacOS.

Descargar Anaconda

Recordar coger la versión de 64 bits y accesible directamente en los botones que aparecen. Las versiones de abajo son para otro tipo de arquitectura o para 32 bits, lo cual puede dar problemas si el SO es de 64 bits.

Verificar que está instalado

conda --version



In [1]:

    
#from IPython.display import HTML
#HTML('''<script>
#code_show=true; 
#function code_toggle() {
# if (code_show){
# $('div.input').hide();
# } else {
# $('div.input').show();
# }#
# code_show = !code_show
#} 
#$( ocument ).ready(code_toggle);
#</script>
#The raw code for this IPython notebook is by default hidden for easier reading.
#To toggle on/off the raw code, click <a href="javascript:code_toggle()">here</a>.''')

Crear un entorno

Anaconda nos permite tener distintos entornos, cada uno con distintas librerías (y versiones de librerías). De esa manera evitamos conflictos si queremos tener aplicaciones que requieran librerías incompatibles entre sí.

Vamos a crear el entorno para Inteligencia de Negocio con la versión 3 de Python, y la librería scikit-learn se crea de la siguiente forma:

conda create -n IN

Y para activarlo se ejecuta

source activate IN

Si todo va bien, en Linux, deberá de de verse "(IN)" en la línea de comandos.

Para desactivar se puede hacer:

source deactivate

Por qué Python

Python es un lenguaje muy usado en Machine-Learning y Ciencias de Datos en General. Tiene muchas ventajas:

Es Software Libre, así que no hay problemas de licencias.
Es un lenguaje muy fácil de aprender.
Librerías científicas muy buenas.
Fácil de integrar con otras librerías.

Librerías que usaremos

Las librerías que vamos a usar ya vienen instaladas por defecto. Son:

numpy, librería matemática, muy potente, y consigue la eficiencia de trabajar en C.
pandas, librería que permite trabajar con tablas de datos (como Excel) y leerlos y escribirlos de ficheros .csv y Excel.
scikit-learn, librería de 'Marchine Learning'.

Entorno de Desarrollo

Existen muchos entornos de desarrollo, como PyCharm, Spyder o PyDev (entorno Eclipse).

Nosotros vamos a usar Jupyter, que nos ofrece un entorno web para escribir código Python y ver el resultado de forma bastante interactiva.

Con conda se instala sólo. Para ejecutarlo primer vamos al directorio que queremos ejecutar y hacemos:

jupyter notebook

y luego desde el navegador abrimos la dirección, y podemos empezar a trabajar.



In [8]:

    
from IPython.display import YouTubeVideo
YouTubeVideo("qb7FT68tcA8")









    Out[8]:

Notebooks

Los notebooks de Python son fichero terminados en ".pynb", que pueden ser abiertos desde el navegador usando jupyter. Estos notebooks se dividen en celdas que pueden contener texto y código Python que se puede ejecutar, mostrando la salida de su ejecución.

Github entiende el formato, y permite visualizar un notebook, pero no se puede ejecutar el código, para eso es necesario descargar el fichero y editarlo localmente.

Recursos

Existe una gran cantidad de Notebooks muy útiles, en la propia wiki de Jupyter se encuentra una extensa galería de interesantes notebooks

Ejemplo del lenguaje Python

Vamos a empezar con el Hello, World. Mientras que en C sería

include<stdio.h>
int main(void) { printf("Hello World\n"); return 0; }

El código en Python es mucho más sencillo.



In [5]:

    
print("Hola a todos")









    



Hola a todos

Como véis, no hay puntos y coma al final de cada sentencia, le basta con fin de línea. Y en vez de printf usa print, que es mucho más sencillo.

Un ejemplo un poco más completo



In [4]:

    
sumcars = 0
sumwords = 0

for word in ['hola', 'a', 'todos']:
    print("Frase: ", word)
    sumcars += len(word)
    sumwords += 1
    
print("Se han mostrado ", sumwords, " palabras y ", sumwords, " caracteres")









    



Frase:  hola
Frase:  a
Frase:  todos
Se han mostrado  3  palabras y  3  caracteres

Visualizando datos

Vamos a visualizar unos pocos datos



In [18]:

    
%pylab inline









    



Populating the interactive namespace from numpy and matplotlib



In [11]:

    
import matplotlib
import matplotlib.pyplot as plt
import numpy as np



In [15]:

    
x = np.arange(30)
plt.plot(x,  x**2)









    Out[15]:





[<matplotlib.lines.Line2D at 0x7f464ce6ff60>]

Un ejemplo más completo



In [19]:

    
# example with a legend and latex symbols
fig, ax = plt.subplots()

ax.plot(x, x**2, label=r"$y = \alpha^2$")
ax.plot(x, x**3, label=r"$y = \alpha^3$")
ax.legend(loc=2) # upper left corner
ax.set_xlabel(r'$\alpha$', fontsize=18)
ax.set_ylabel(r'$y$', fontsize=18)
ax.set_title('Ejemplo más completo');

Haciendo uso de Machine Learning

Python posee la estupenda librería scikit-learn para trabajar con Machine Learning, que implementa muchos interesantes métodos. Vamos a mostrarlo aplicando clustering usando el algoritmo K-means.

Primero cargamos las librerías



In [22]:

    
import sklearn.datasets
import sklearn.cluster
import matplotlib.pyplot as plot



In [27]:

    
# Creamos los puntos
n = 1000
k = 4

# Generate fake data
data, labels = sklearn.datasets.make_blobs(
    n_samples=n, n_features=2, centers=k)

Primero pintamos los puntos



In [28]:

    
plot.scatter(data[:, 0], data[:, 1])









    Out[28]:





<matplotlib.collections.PathCollection at 0x7f463e9be780>

Aplicamos k-means



In [30]:

    
# scikit-learn
kmeans = sklearn.cluster.KMeans(k, max_iter=300)
kmeans.fit(data)
means = kmeans.cluster_centers_

plot.scatter(data[:, 0], data[:, 1], c=labels)
plot.scatter(means[:, 0], means[:, 1], linewidths=2, color='r')
plot.show()

Detectando criterio para abordar orquídeas

El '''hello world''' de aprendizaje es aprender a detectar el tipo de flores de orquídeas a partir de cuatro atributos.



In [32]:

    
import seaborn as sns



In [36]:

    
iris = sns.load_dataset("iris")
g = sns.PairGrid(iris, hue="species")
g.map(plt.scatter);
g = g.add_legend()



In [39]:

    
from sklearn import datasets
 
# load the iris dataset
iris = datasets.load_iris()
 
# start with the first two features: sepal length (cm) and sepal width (cm)
X = iris.data[:100,:2]
 
# save the target values as y
y = iris.target[:100]



In [40]:

    
# Define bounds on the X and Y axes
X_min, X_max = X[:,0].min()-.5, X[:,0].max()+.5
y_min, y_max = X[:,1].min()-.5, X[:,1].max()+.5
 
for target in set(y):
 x = [X[i,0] for i in range(len(y)) if y[i]==target]
 z = [X[i,1] for i in range(len(y)) if y[i]==target]
 plt.scatter(x,z,color=['red','blue'][target], label=iris.target_names[:2][target])
 
plt.xlabel('Sepal Length')
plt.ylabel('Sepal Width')
plt.xlim(X_min,X_max)
plt.ylim(y_min,y_max)
plt.title('Scatter Plot of Sepal Length vs. Sepal Width')
plt.legend(iris.target_names[:2], loc='lower right')
plt.show()

Se puede ver que es fácil de separar a partir de estos criterios