Saltar al contenido

Archivos de categoría Python

K-vecinos más próximos en Python

Importación de los paquetes básicos

import itertools
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import NullFormatter
import pandas as pd
import numpy as np
import matplotlib.ticker as ticker
from sklearn import preprocessing
%matplotlib inline

Importación de los datos

Imagina un proveedor de telecomunicaciones que ha segmentado la base de sus clientes por servicio, categorizando a los clientes en cuatro grupos. Si los datos demográficos se pueden usar para predecir la pertenencia de grupo del envío, la compañía podría personalizar las ofertas para los prospectos. Es un problema de clasificación. Este ejemplo hace foco en datos demográficos, sean region, edad, estado civil, para predecir patrones de uso. El campo objetivo (target), llamado custcat, tiene cuatro valores posibles que corresponden a los cuatro grupos de clientes: 1- Servicio Básico 2- E-Servicio 3- Servicio Plus 4- Servicio Total

Nuestro objetivo es construir un clasificador para predecir la clase de casos desconocidos. Utilizaremos un tipo específico de clasificación llamado K vecino más cercano.

!wget -O teleCust1000t.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/teleCust1000t.csv
df = pd.read_csv('teleCust1000t.csv')
df.head()
region tenure age marital address income ed employ retire gender reside custcat
0 2 13 44 1 9 64.0 4 5 0.0 0 2 1
1 3 11 33 1 7 136.0 5 5 0.0 0 6 4
2 3 68 52 1 24 116.0 1 29 0.0 1 2 3
3 2 33 33 0 12 33.0 2 0 0.0 1 1 1
4 2 23 30 1 9 30.0 1 2 0.0 0 4 3

Veamos cuántos de cada clase están en nuestro set de datos

df['custcat'].value_counts()
3    281
1    266
4    236
2    217
Name: custcat, dtype: int64

Puedes explorar fácilmente tus datos utilizando técnicas de visualización:

df.hist(column='income', bins=50)

Definamos feature sets, X:

df.columns
Index(['region', 'tenure', 'age', 'marital', 'address', 'income', 'ed',
       'employ', 'retire', 'gender', 'reside', 'custcat'],
      dtype='object')

Para utilizar la librería scikit-learn, tenemos que convertir el data frame de Panda en un Numpy array:

X = df[['region', 'tenure','age', 'marital', 'address', 'income', 'ed', 'employ','retire', 'gender', 'reside']] .values  #.astype(float)
X[0:5]
array([[  2.,  13.,  44.,   1.,   9.,  64.,   4.,   5.,   0.,   0.,   2.],
       [  3.,  11.,  33.,   1.,   7., 136.,   5.,   5.,   0.,   0.,   6.],
       [  3.,  68.,  52.,   1.,  24., 116.,   1.,  29.,   0.,   1.,   2.],
       [  2.,  33.,  33.,   0.,  12.,  33.,   2.,   0.,   0.,   1.,   1.],
       [  2.,  23.,  30.,   1.,   9.,  30.,   1.,   2.,   0.,   0.,   4.]])

¿Cuáles son nuestras etiquetas?

y = df['custcat'].values
y[0:5]
array([1, 4, 3, 1, 3])

Normalizar los Datos

La estandarización de datos haciendo que la media sea 0 y la varianza uno es buena práctica, especialmente para algoritmos tales como KNN el cual se basa en distancia de casos:

X = preprocessing.StandardScaler().fit(X).transform(X.astype(float))
X[0:5]
array([[-0.02696767, -1.055125  ,  0.18450456,  1.0100505 , -0.25303431,
        -0.12650641,  1.0877526 , -0.5941226 , -0.22207644, -1.03459817,
        -0.23065004],
       [ 1.19883553, -1.14880563, -0.69181243,  1.0100505 , -0.4514148 ,
         0.54644972,  1.9062271 , -0.5941226 , -0.22207644, -1.03459817,
         2.55666158],
       [ 1.19883553,  1.52109247,  0.82182601,  1.0100505 ,  1.23481934,
         0.35951747, -1.36767088,  1.78752803, -0.22207644,  0.96655883,
        -0.23065004],
       [-0.02696767, -0.11831864, -0.69181243, -0.9900495 ,  0.04453642,
        -0.41625141, -0.54919639, -1.09029981, -0.22207644,  0.96655883,
        -0.92747794],
       [-0.02696767, -0.58672182, -0.93080797,  1.0100505 , -0.25303431,
        -0.44429125, -1.36767088, -0.89182893, -0.22207644, -1.03459817,
         1.16300577]])

Dividimos la muestra en los conjuntos de datos para el entrenamiento y para la prueba de exactitud

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=4)
print ('Set de Entrenamiento:', X_train.shape,  y_train.shape)
print ('Set de Prueba:', X_test.shape,  y_test.shape)
Set de Entrenamiento: (800, 11) (800,)
Set de Prueba: (200, 11) (200,)

Clasificación

importar librería del Clasificador que implementa k-vecinos más cercanos.

from sklearn.neighbors import KNeighborsClassifier

Para el entrenamiento vamos a comenzar con el algoritmo con k=4 por ahora:

k = 4
#Entrenar el Modelo y Predecir  
neigh = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)
neigh
KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=None, n_neighbors=4, p=2,
           weights='uniform')

Usamos el modelo para predecir el set de prueba:

yhat = neigh.predict(X_test)
yhat[0:5]
array([1, 1, 3, 2, 4])

Para evaluar la certeza usamos la función classification accuracy score que computa la certeza del subconjunto. Esta función es igual a la función jaccard_similarity_score. Básicamente, calcula cómo se relacionan las etiquetas actuales con las etiquetas predichas dentro del set de pruebas.

from sklearn import metrics
print("Entrenar el set de Certeza: ", metrics.accuracy_score(y_train, neigh.predict(X_train)))
print("Probar el set de Certeza: ", metrics.accuracy_score(y_test, yhat))
Entrenar el set de Certeza:  0.5475
Probar el set de Certeza:  0.32

Para un K=6 tenemos los siguientes resultados

k = 6
neigh6 = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)
yhat6 = neigh6.predict(X_test)
print("Certeza del Set de Entrenamiento: ", metrics.accuracy_score(y_train, neigh6.predict(X_train)))
print("Certeza del Set de Prueba: ", metrics.accuracy_score(y_test, yhat6))
Certeza del Set de Entrenamiento:  0.51625
Certeza del Set de Prueba:  0.31

Cálculo del mejor k

Elegimos k =1, lo utilizamos como parte del entrenamiento para modelar, y calculamos la certeza de la predicción utilizando todas las muestras del set de pruebas. Repetir este proceso, aumentando el k, y viendo luego, cual es el mejor k para el modelo.

Ks = 10
mean_acc = np.zeros((Ks-1))
std_acc = np.zeros((Ks-1))
ConfustionMx = [];
for n in range(1,Ks):
    #Entrenar el Modelo y Predecir  
    neigh = KNeighborsClassifier(n_neighbors = n).fit(X_train,y_train)
    yhat=neigh.predict(X_test)
    mean_acc[n-1] = metrics.accuracy_score(y_test, yhat)
    std_acc[n-1]=np.std(yhat==y_test)/np.sqrt(yhat.shape[0])
mean_acc
array([0.3  , 0.29 , 0.315, 0.32 , 0.315, 0.31 , 0.335, 0.325, 0.34 ])

Dibujo de la certeza del modelo para diferentes números de vecinos

plt.plot(range(1,Ks),mean_acc,'g')
plt.fill_between(range(1,Ks),mean_acc - 1 * std_acc,mean_acc + 1 * std_acc, alpha=0.10)
plt.legend(('Certeza ', '+/- 3xstd'))
plt.ylabel('Certeza ')
plt.xlabel('Número de Vecinos (K)')
plt.tight_layout()
plt.show()

print( "La mejor aproximación de certeza fue con ", mean_acc.max(), "con k=", mean_acc.argmax()+1) 
La mejor aproximación de certeza fue con  0.34 con k= 9
0 Seguir leyendo →

Regresión no lineal en Pyton

Importación de los paquetes básicos

import numpy as np              # paquete básico para calculos científicos
import matplotlib.pyplot as plt # para crear graficos
%matplotlib inline              # muestra los graficos en la linea de comandos de Python

Creación de diferentes conjuntos de datos

Función cúbica (y = a x^{3} + b x^{2} + c x + d)

x = np.arange(-5.0, 5.0, 0.1)
##Puede ajustar la pendiente y la intersección para verificar los cambios del gráfico
y = 1*(x**3) + 1*(x**2) + 1*x + 3
y_noise = 20 * np.random.normal(size=x.size)
ydata = y + y_noise
plt.plot(x, ydata,  'bo')
plt.plot(x,y, 'r') 
plt.ylabel('Variable dependiente')
plt.xlabel('Variable indepdendiente')
plt.show()

Función cuadrática (y = x^{2})

x = np.arange(-5.0, 5.0, 0.1)
##Se puede ajustar la pendiente y la intersección para verificar los cambios en el gráfico
y = np.power(x,2)
y_noise = 2 * np.random.normal(size=x.size)
ydata = y + y_noise
plt.plot(x, ydata,  'bo')
plt.plot(x,y, 'r') 
plt.ylabel('Variable dependiente')
plt.xlabel('Variable indepdiendente')
plt.show()

Exponencial (y = a + b c^{x})

X = np.arange(-5.0, 5.0, 0.1)
##Se puede ajustar la pendiente y la intersección para verificar los cambios en el gráfico
Y= np.exp(X)
plt.plot(X,Y) 
plt.ylabel('Variable Dependiente')
plt.xlabel('Variable Independiente')
plt.show()

Logarítmica (y = \log(x))

X = np.arange(-5.0, 5.0, 0.1)
Y = np.log(X)
plt.plot(X,Y) 
plt.ylabel('Variable Dependiente')
plt.xlabel('Variable Independiente')
plt.show()

Sigmoidal/Logística (y = a + \dfrac{b}{1 + c^{(x - d)}})

X = np.arange(-5.0, 5.0, 0.1)
Y = 1-4/(1+np.power(3, X-2))
plt.plot(X,Y) 
plt.ylabel('Variable Dependiente')
plt.xlabel('Variable Independiente')
plt.show()

Ejemplo completo

Descarga del fichero de datos

import numpy as np
import pandas as pd
#downloading dataset
!wget -nv -O china_gdp.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/china_gdp.csv
df = pd.read_csv("china_gdp.csv")
df.head(10)  # mostramos los primeros datos 
Year Value
0 1960 5.918412e+10
1 1961 4.955705e+10
2 1962 4.668518e+10
3 1963 5.009730e+10
4 1964 5.906225e+10
5 1965 6.970915e+10
6 1966 7.587943e+10
7 1967 7.205703e+10
8 1968 6.999350e+10
9 1969 7.871882e+10

Mostrado de los datos

plt.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plt.plot(x_data, y_data, 'ro')
plt.ylabel('GDP')
plt.xlabel('Year')
plt.show()

Eligiendo un modelo

A primera vista, determinamos que la función lógica podría ser una buena primera aproximación, ya que tiene la propiedad de comenzar con un crecimiento leve, aumentando en el medio y luego descendiendo nuevamente hacia el final; como vimos anteriormente y simplificando, la formula es y = \dfrac{1}{1 + e^{\beta_1(x - \beta_2)}} donde \beta_1 controla lo llano de la curva y \beta_2 lleva la curva sobre el eje x.

#define el modelo
def sigmoid(x, Beta_1, Beta_2):
     y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))
     return y

#ejecutamos un primer modelo
beta_1 = 0.10
beta_2 = 1990.0

#función logística
Y_pred = sigmoid(x_data, beta_1 , beta_2)

#predicción de puntos
plt.plot(x_data, Y_pred*15000000000000.)
plt.plot(x_data, y_data, 'ro')


Nuestra tarea aquí es encontrar los mejores parámetros para nuestro modelo. Normalicemos primero nuestro x e y:

xdata =x_data/max(x_data)
ydata =y_data/max(y_data)

Para buscar los mejores parámetros podemos utilizar curve_fit la cual utiliza cuadrados mínimos no lineales para cuadrar con la función sigmoide. popt son nuestros parámetros optimizados.

from scipy.optimize import curve_fit
popt, pcov = curve_fit(sigmoid, xdata, ydata)
#imprimir los parámetros finales
print(" beta_1 = %f, beta_2 = %f" % (popt[0], popt[1]))

beta_1 = 690.447530, beta_2 = 0.997207

Dibujamos el modelo

x = np.linspace(1960, 2015, 55)
x = x/max(x)
plt.figure(figsize=(8,5))
y = sigmoid(x, *popt)
plt.plot(xdata, ydata, 'ro', label='data')
plt.plot(x,y, linewidth=3.0, label='fit')
plt.legend(loc='best')
plt.ylabel('GDP')
plt.xlabel('Year')
plt.show()

Vemos la exactitud de nuestro modelo

# divide los datos en entrenamiento y prueba
msk = np.random.rand(len(df)) < 0.8
train_x = xdata[msk]
test_x = xdata[~msk]
train_y = ydata[msk]
test_y = ydata[~msk]

# construye el modelo utilizando el set de entrenamiento
popt, pcov = curve_fit(sigmoid, train_x, train_y)

# predecir utilizando el set de prueba
y_hat = sigmoid(test_x, *popt)

# evaluation
print("Promedio de error absoluto: %.2f" % np.mean(np.absolute(y_hat - test_y)))
print("Suma residual de cuadrados (MSE): %.2f" % np.mean((y_hat - test_y) ** 2))
from sklearn.metrics import r2_score
print("R2-score: %.2f" % r2_score(y_hat , test_y) )

Promedio de error absoluto: 0.04
Suma residual de cuadrados (MSE): 0.00
R2-score: 0.97

0 Seguir leyendo →

Regresión lineal en Pyton

Importación de los paquetes básicos

import matplotlib.pyplot as plt # para crear graficos
import pandas as pd             # herramientas para analisis de datos y estructuras de datos
import pylab as pl              # añade numpy+scipy+sympy+pandas+matplotlib+ipython = MatLab
import numpy as np              # paquete básico para calculos científicos
%matplotlib inline              # muestra los graficos en la linea de comandos de Python

Descarga del fichero de datos

!wget -O FuelConsumption.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/FuelConsumptionCo2.csv
df = pd.read_csv("FuelConsumption.csv")
df.head() # mostramos los primeros datos 
MODELYEAR MAKE MODEL VEHICLECLASS ENGINESIZE CYLINDERS TRANSMISSION FUELTYPE FUELCONSUMPTION_CITY FUELCONSUMPTION_HWY FUELCONSUMPTION_COMB FUELCONSUMPTION_COMB_MPG CO2EMISSIONS
0 2014 ACURA ILX COMPACT 2.0 4 AS5 Z 9.9 6.7 8.5 33 196
1 2014 ACURA ILX COMPACT 2.4 4 M6 Z 11.2 7.7 9.6 29 221
2 2014 ACURA ILX HYBRID COMPACT 1.5 4 AV7 Z 6.0 5.8 5.9 48 136
3 2014 ACURA MDX 4WD SUV – SMALL 3.5 6 AS6 Z 12.7 9.1 11.1 25 255
4 2014 ACURA RDX AWD SUV – SMALL 3.5 6 AS6 Z 12.1 8.7 10.6 27 244

Listamos los estadísticos principales para cada variable

df.describe()
MODELYEAR ENGINESIZE CYLINDERS FUELCONSUMPTION_CITY FUELCONSUMPTION_HWY FUELCONSUMPTION_COMB FUELCONSUMPTION_COMB_MPG CO2EMISSIONS
count 1067.0 1067.000000 1067.000000 1067.000000 1067.000000 1067.000000 1067.000000 1067.000000
mean 2014.0 3.346298 5.794752 13.296532 9.474602 11.580881 26.441425 256.228679
std 0.0 1.415895 1.797447 4.101253 2.794510 3.485595 7.468702 63.372304
min 2014.0 1.000000 3.000000 4.600000 4.900000 4.700000 11.000000 108.000000
25% 2014.0 2.000000 4.000000 10.250000 7.500000 9.000000 21.000000 207.000000
50% 2014.0 3.400000 6.000000 12.600000 8.800000 10.900000 26.000000 251.000000
75% 2014.0 4.300000 8.000000 15.550000 10.850000 13.350000 31.000000 294.000000
max 2014.0 8.400000 12.000000 30.200000 20.500000 25.800000 60.000000 488.000000

Selecciona algunas variables para verlas con más detalle.

cdf = df[['ENGINESIZE','CYLINDERS','FUELCONSUMPTION_COMB','CO2EMISSIONS']]
cdf.head(9)
ENGINESIZE CYLINDERS FUELCONSUMPTION_COMB CO2EMISSIONS
0 2.0 4 8.5 196
1 2.4 4 9.6 221
2 1.5 4 5.9 136
3 3.5 6 11.1 255
4 3.5 6 10.6 244
5 3.5 6 10.0 230
6 3.5 6 10.1 232
7 3.7 6 11.1 255
8 3.7 6 11.6 267

Para verlas mejor, podemos dibujar cada una de esas verialbes

viz = cdf[['CYLINDERS','ENGINESIZE','CO2EMISSIONS','FUELCONSUMPTION_COMB']]
viz.hist()
plt.show()

Comparamos cada variable con la emisión de carbono, para ver si se pueden relacionar linealmente

plt.scatter(cdf.FUELCONSUMPTION_COMB, cdf.CO2EMISSIONS,  color='blue')
plt.xlabel("FUELCONSUMPTION_COMB")
plt.ylabel("Emission")
plt.show()

plt.scatter(cdf.ENGINESIZE, cdf.CO2EMISSIONS,  color='blue')
plt.xlabel("Engine size")
plt.ylabel("Emission")
plt.show()

plt.scatter(cdf.CYLINDERS, cdf.CO2EMISSIONS,  color='blue')
plt.xlabel("Cylinders")
plt.ylabel("Emission")
plt.show()


Creamos un conjunto de datos de entrenamiento y otro de prueba

Se divide el conjunto de datos en uno de entrenamiento y otro de pruebas, siendo excluyentes. Esto permite una evaluación más exacta, ya que los datos de entrenamiento no son parte de los datos que se usaran para comprobar el modelo.

msk = np.random.rand(len(df)) < 0.8
train = cdf[msk]
test = cdf[~msk]

Modelado de datos usando el paquete sklearn

from sklearn import linear_model #  importación del paquete sklearn
train_x = np.asanyarray(train[['ENGINESIZE']]) # conjunto de datos independientes
train_y = np.asanyarray(train[['CO2EMISSIONS']]) # conjunto de datos dependientes 
regr = linear_model.LinearRegression() # uso del modelo de regresion lineal
regr.fit (train_x, train_y) # ejecución de los calculos
print ('Pendiente: ', regr.coef_) # muestra la pendiente
print ('Ordenada: ',regr.intercept_) # muestra la ordenada en el origen

Pendiente: [[39.071235]]
Ordenada: [126.65808636]

Pintamos el ajuste realizado

plt.scatter(train.ENGINESIZE, train.CO2EMISSIONS,  color='blue')
plt.plot(train_x, regr.coef_[0][0]*train_x + regr.intercept_[0], '-r')
plt.xlabel("Engine size")
plt.ylabel("Emission")

Se comparan los valores actuales con los predichos para calcular la exactitud del modelo de regresión

Existen distintas métricas de evaluación de modelos, utilicemos MSE para calcular la exactitud de nuestro modelo basado en el set de prueba:
– Error medio absoluto: Es una media del valor absoluto de los errores. Es la métrica más fácil de comprender ya que simplemente es el promedio de los errores pero en valor absoluto para que errores negativos no compensen los positivos.
– Error Cuadrado Medio (MSE): Es la media de los errores al cuadrado. Es más popular que el error medio absoluto porque hace que los grandes errores tengan más peso.
– R-cuadráticono es un error, es una medida popular que indica la precisión del modelo. Representa como de cerca están los datos de la linea de regresión. Mientras más alto es el R-cuadrático, mejor ajusta el modelo respecto de los datos. El máximo valor posible es 1 y puede tomar valores negativos.

from sklearn.metrics import r2_score # importación del paquete metrics de sklearn
test_x = np.asanyarray(test[['ENGINESIZE']]) # conjunto de datos independientes
test_y = np.asanyarray(test[['CO2EMISSIONS']]) # conjunto de datos dependientes
test_y_ = regr.predict(test_x) # ejecución de los calculos
print("Error medio absoluto: %.2f" % np.mean(np.absolute(test_y_ - test_y)))
print("Error cuadrado medio (MSE): %.2f" % np.mean((test_y_ - test_y) ** 2))
print("R2-cuadrático: %.2f" % r2_score(test_y_ , test_y) )

Error medio absoluto: 23.04
Error cuadrado medio (MSE): 894.25
R2-score: 0.70

0 Seguir leyendo →

Listas en python

Las listas en Python

La listas en Python son secuencias de elementos de cualquier tipo ordenados. El tipo de dato es list

Se crean usando: nombreVariable = [«cadena1», «cadena2», 1000.0, True, …]

Se puede usar la orden print para mostrar los elementos de la lista. Los elementos de una lista pueden ser también listas (matrices)

Si se quiere crear listas vacías se puede hacer como vacia1=[] o como vacia2=list()

0 Seguir leyendo →

Strings y Ficheros en Python

En esta entrada vamos a explicar el uso de Strings y de ficheros en Python.

0 Seguir leyendo →

Control de flujo y bucles en Python

Flujo de control

Antes de ver los bucles en Python, explicaremos como es el flujo de control. Para tomar decisiones se utiliza la orden if-else
Para ello se necesita una condición, que es una expresión que devuelva valores True o False y se utilizan compradores: <, <=, >, >=, !=, == y lógicos: not, and, or. La forma general es:

0 Seguir leyendo →

Variables y expresiones en Python

Tipos de datos en Python

Los conjuntos de valores o tipo de datos Primitivos en Python son los siguientes:

  • Numéricos enteros: int
  • Numéricos decimales: float
  • Texto: str (empiezan y terminan con comillas dobles o simples)
  • Lógicos (booleanos): booleanos (verdadero o falso) True/False

Se puede usar la función type() para identificar el tipo de datos.

0 Seguir leyendo →

Uso básico de Python

Primeros pasos con Python

Para iniciarse en el uso de Python podemos abrir su consola y poner instrucciones básicas.

0 Seguir leyendo →

Instalar PyCharm, ID de desarrollo para Python

Introducción

La versión de Python que voy a usar para este tutorial es la 2.7.10 (si ya tienes una nueva versión todo debe funcionar igual). Este tutorial es para instalar PyCharm en Windows. En Mac OS X el proceso es mucho mas sencillo, ya que solo se requiere descargar Python e instalar.

0 Seguir leyendo →

Como instalar Python

Vamos a empezar a instalar Python

Python es un lenguaje de programación muy popular que puede utilizarse para la creación de sitios web, juegos, software académico, gráficos y mucho, mucho más. Vamos a ver como instalar Python.

0 Seguir leyendo →