Post Top Ad

Your Ad Spot

viernes, 5 de julio de 2019

Clasificación en Python con Scikit-Learn y Pandas

Introducción

La clasificación es un gran dominio en el campo de las estadísticas y el aprendizaje automático. En general, la clasificación se puede dividir en dos áreas:
  1. Clasificación binaria , donde deseamos agrupar un resultado en uno de dos grupos.
  2. Clasificación multiclase , donde deseamos agrupar un resultado en uno de varios grupos (más de dos).
En este post, el enfoque principal estará en el uso de una variedad de algoritmos de clasificación en ambos dominios, se pondrá menos énfasis en la teoría que los respalda.
Podemos usar bibliotecas en Python como scikit-learn para modelos de aprendizaje automático y Pandas para importar datos como marcos de datos.
Estos se pueden instalar e importar fácilmente en Python con pip:
$ python3 -m pip install sklearn
$ python3 -m pip install pandas
import sklearn as sk  
import pandas as pd  

Clasificación binaria

Para la clasificación binaria, estamos interesados ​​en clasificar los datos en uno de dos grupos binarios, que generalmente se representan como 0 y 1 en nuestros datos.
Veremos los datos relacionados con la enfermedad coronaria (CHD) en Sudáfrica. El objetivo es utilizar diferentes variables como el consumo de tabaco , antecedentes familiares , niveles de colesterol LDL , consumo de alcohol , obesidad y más.
Una descripción completa de este conjunto de datos está disponible en la sección "Datos" del sitio web Elementos de aprendizaje estadístico .
El siguiente código lee los datos en un marco de datos de Pandas, y luego separa el marco de datos en un yvector de la respuesta y una Xmatriz de variables explicativas:
import pandas as pd  
import os

os.chdir('/Users/stevenhurwitt/Documents/Blog/Classification')  
heart = pd.read_csv('SAHeart.csv', sep=',', header=0)  
heart.head()

y = heart.iloc[:,9]  
X = heart.iloc[:,:9]  
Al ejecutar este código, solo asegúrese de cambiar la ruta del sistema de archivos en la línea 4 para que se adapte a su configuración.
sbptabacoldladiposidadfamistescribe unobesidadalcoholañoschd
016012.005.7323.1114925.3097.20521
11440.014.4128.6105528.872.06631
21180.083,4832.2815229.143.81460
31707.506.4138.0315131.9924.26581
413413.603,5027.7816025.9957.34491

Regresión logística

La regresión logística es un tipo de modelo lineal generalizado (GLM) que utiliza una función logística para modelar una variable binaria basada en cualquier tipo de variables independientes.
Para ajustar una regresión logística binaria con sklearn, usamos el módulo LogisticRegression con el multi_classconjunto a "ovr" y ajuste Xy.
Luego podemos usar el predictmétodo para predecir las probabilidades de nuevos datos, así como el scoremétodo para obtener la precisión de la predicción media:
import sklearn as sk  
from sklearn.linear_model import LogisticRegression  
import pandas as pd  
import os

os.chdir('/Users/stevenhurwitt/Documents/Blog/Classification')  
heart = pd.read_csv('SAHeart.csv', sep=',',header=0)  
heart.head()

y = heart.iloc[:,9]  
X = heart.iloc[:,:9]

LR = LogisticRegression(random_state=0, solver='lbfgs', multi_class='ovr').fit(X, y)  
LR.predict(X.iloc[460:,:])  
round(LR.score(X,y), 4)  
array([1, 1])  

Máquinas de vectores de soporte

Las máquinas de vectores de soporte (SVM) son un tipo de algoritmo de clasificación que es más flexible: pueden hacer una clasificación lineal, pero pueden usar otras funciones de base no lineales El siguiente ejemplo utiliza un clasificador lineal para ajustar un hiperplano que separa los datos en dos clases:
import sklearn as sk  
from sklearn import svm  
import pandas as pd  
import os

os.chdir('/Users/stevenhurwitt/Documents/Blog/Classification')  
heart = pd.read_csv('SAHeart.csv', sep=',',header=0)

y = heart.iloc[:,9]  
X = heart.iloc[:,:9]

SVM = svm.LinearSVC()  
SVM.fit(X, y)  
SVM.predict(X.iloc[460:,:])  
round(SVM.score(X,y), 4)  
array([0, 1])  

Bosques aleatorios

Los bosques aleatorios son un método de aprendizaje conjunto que se ajusta a múltiples árboles de decisión en subconjuntos de datos y promedia los resultados. Podemos ajustarlos nuevamente sklearny usarlos para predecir resultados, así como para obtener una precisión de predicción media:
import sklearn as sk  
from sklearn.ensemble import RandomForestClassifier

RF = RandomForestClassifier(n_estimators=100, max_depth=2, random_state=0)  
RF.fit(X, y)  
RF.predict(X.iloc[460:,:])  
round(RF.score(X,y), 4)  
0.7338  

Redes neuronales

Las redes neuronales son un algoritmo de aprendizaje automático que implica el ajuste de muchas capas ocultas que se utilizan para representar las neuronas que están conectadas con las funciones de activación sináptica Básicamente, utilizan un modelo del cerebro muy simplificado para modelar y predecir datos.
En sklearnesta publicación utilizamos para mantener la coherencia, sin embargo, las bibliotecas como Tensorflow y Keras son más adecuadas para ajustar y personalizar redes neuronales, de las cuales existen algunas variedades utilizadas para diferentes propósitos:
import sklearn as sk  
from sklearn.neural_network import MLPClassifier

NN = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(5, 2), random_state=1)  
NN.fit(X, y)  
NN.predict(X.iloc[460:,:])  
round(NN.score(X,y), 4)  
0.6537  

Clasificación Multi-Class

Si bien la clasificación binaria por sí sola es increíblemente útil, hay ocasiones en las que nos gustaría modelar y predecir datos que tienen más de dos clases. Muchos de los mismos algoritmos pueden usarse con ligeras modificaciones.
Además, es común dividir los datos en conjuntos de entrenamiento y pruebas . Esto significa que utilizamos una cierta parte de los datos para ajustar el modelo (el conjunto de entrenamiento) y guardamos la parte restante para evaluar la precisión predictiva del modelo ajustado (el conjunto de prueba).
No hay una regla oficial a seguir cuando se decida por una proporción dividida, aunque en la mayoría de los casos querrá dedicar alrededor del 70% para el conjunto de entrenamiento y alrededor del 30% para el conjunto de prueba.
Para explorar tanto las clasificaciones de clases múltiples como los datos de entrenamiento / pruebas, veremos otro conjunto de datos del sitio web Elementos de aprendizaje estadístico . Estos son datos que se utilizan para determinar cuál de los once sonidos vocálicos fueron hablados:
import pandas as pd

vowel_train = pd.read_csv('vowel.train.csv', sep=',', header=0)  
vowel_test = pd.read_csv('vowel.test.csv', sep=',', header=0)

vowel_train.head()

y_tr = vowel_train.iloc[:,0]  
X_tr = vowel_train.iloc[:,1:]

y_test = vowel_test.iloc[:,0]  
X_test = vowel_test.iloc[:,1:]  
yx.1x.2x.3x.4x.5x.6x.7x.8x.9x.10
01-3.6390.418-0.6701.779-0.1681.627-0.3880.529-0.874-0.814
12-3.3270.496-0.6941.365-0.2651.933-0.3630.510-0.621-0.488
23-2.1200.894-1.5760.147-0.7071.559-0.5790.676-0.809-0.049
34-2.2871.809-1.4981.012-1.0531.060-0.5670.235-0.091-0.795
45-2.5981.938-0.8461.062-1.6330.7640.394-0.1500.277-0.396
Ahora ajustaremos los modelos y los probaremos como se hace normalmente en estadística / aprendizaje automático: capacitándolos en el conjunto de entrenamiento y evaluándolos en el conjunto de prueba.
Además, dado que esta es una clasificación de múltiples clases, algunos argumentos deberán cambiarse dentro de cada algoritmo:
import pandas as pd  
import sklearn as sk  
from sklearn.linear_model import LogisticRegression  
from sklearn import svm  
from sklearn.ensemble import RandomForestClassifier  
from sklearn.neural_network import MLPClassifier

vowel_train = pd.read_csv('vowel.train.csv', sep=',',header=0)  
vowel_test = pd.read_csv('vowel.test.csv', sep=',',header=0)

y_tr = vowel_train.iloc[:,0]  
X_tr = vowel_train.iloc[:,1:]

y_test = vowel_test.iloc[:,0]  
X_test = vowel_test.iloc[:,1:]

LR = LogisticRegression(random_state=0, solver='lbfgs', multi_class='multinomial').fit(X_tr, y_tr)  
LR.predict(X_test)  
round(LR.score(X_test,y_test), 4)

SVM = svm.SVC(decision_function_shape="ovo").fit(X_tr, y_tr)  
SVM.predict(X_test)  
round(SVM.score(X_test, y_test), 4)

RF = RandomForestClassifier(n_estimators=1000, max_depth=10, random_state=0).fit(X_tr, y_tr)  
RF.predict(X_test)  
round(RF.score(X_test, y_test), 4)

NN = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(150, 10), random_state=1).fit(X_tr, y_tr)  
NN.predict(X_test)  
round(NN.score(X_test, y_test), 4)  
0.5455  
Si bien las implementaciones de estos modelos fueron bastante ingenuas (en la práctica hay una variedad de parámetros que pueden y deben variar para cada modelo), aún podemos comparar la precisión predictiva entre los modelos. Esto nos dirá cuál es el más preciso para este conjunto de datos de prueba y entrenamiento específico:
ModeloExactitud predictiva
Regresión logística46.1%
Máquinas de vectores soporte64.07%
Bosque aleatorio57.58%
Red neuronal54.55%
Esto nos muestra que para los datos de vocales, una SVM que utiliza la función de base radial predeterminada fue la más precisa.

Conclusión

Para resumir este post, comenzamos explorando la forma más simple de clasificación: binario. Esto nos ayudó a modelar datos donde nuestra respuesta podría tomar uno de dos estados.
Luego pasamos a la clasificación de múltiples clases, cuando la variable de respuesta puede tomar cualquier número de estados.
También vimos cómo ajustar y evaluar modelos con conjuntos de entrenamiento y pruebas. Además, podríamos explorar formas adicionales de refinar el ajuste del modelo entre varios algoritmos.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas