Algoritmos Programacion Python

117

19.4. Visualización de datos 

Figura 19.2: Parcelas histograma de cada atributo.

19.4.2 Parcelas multivariantes Ahora podemos ver las interacciones entre las variables. Veamos gráficos de dispersión de todos los pares de atributos. Esto puede ser útil para detectar relaciones estructuradas entre las variables de entrada. # matriz gráfico de dispersión scatter_matrix (conjunto de datos) plt.show () Listado 19.13: visualizar el conjunto de datos utilizando gráficos de dispersión.

Tenga en cuenta la agrupación diagonal de algunos pares de atributos. Esto sugiere una alta correlación y una relación predecible.

19.5. Evaluar algunos algoritmos 

118

Figura 19.3: Diagramas de dispersión de cada Pairwise Conjunto de Atributo.

19.5 Evaluar algunos algoritmos Ahora es el momento de crear algunos modelos de los datos y estimar su exactitud en los datos que no se ven. Esto es lo que vamos a cubrir en este paso: 1. Separar a cabo un conjunto de datos de validación. 2. Set-up el instrumento de prueba para usar de 10 veces la validación cruzada. 3. Construir modelos de 5 y ss Erent di para predecir las especies a partir de las mediciones de fl ores

4. Seleccionar el mejor modelo.

19.5.1 Crear un conjunto de datos de validación Necesitamos saber si es o no el modelo que hemos creado es bueno. Más tarde, vamos a utilizar métodos estadísticos para estimar la exactitud de los modelos que creamos en los datos que no se ven. También queremos una estimación más concreta de la exactitud de la mejor modelo de datos que no se ven en su valoración sobre los datos que no se ven reales. Es decir, vamos a retener algunos datos que los algoritmos no se llega a ver y vamos a utilizar estos datos para obtener una segunda e independiente idea de

19.5. Evaluar algunos algoritmos 

119

la forma exacta el mejor modelo podría ser en realidad. Vamos a dividir el conjunto de datos se carga en dos, el 80% de los cuales vamos a utilizar para entrenar a nuestros modelos y 20% que vamos a retener como un conjunto de datos de validación.

# Split-cabo la validación de datos matriz = dataset.values X = array [:, 0: 4] Y = array [:, 4] validation_size = 0,20 semilla = 7 X_train, X_validation, Y_train, Y_validation = cross_validation.train_test_split (X, Y, test_size = validation_size, random_state = semilla)

Añadir 19.14: Separa los datos en del tren y la validación de datos. Ahora tiene datos de entrenamiento en el X tren y Y el tren Para la preparación de modelos y una validación X y validación Y Establece que podemos utilizar más tarde.

19.5.2 Prueba de arnés Vamos a utilizar la validación cruzada de 10 veces para estimar la precisión. Esto dividirá nuestro conjunto de datos en 10 partes, el 9 de tren y la prueba de los días 1 y repetir para todas las combinaciones de las divisiones de la prueba tren.

# Opciones de prueba y evaluación métrica num_folds = 10 num_instances = len (X_train) semilla = 7 puntuación = 'exactitud'

Añadir 19.15: Configuración del algoritmo de evaluación instrumento de prueba.

Estamos utilizando la métrica de exactitud para evaluar los modelos. Esta es una relación del número de instancias predijo correctamente dividido por el número total de casos en el conjunto de datos se multiplica por 100 para dar un porcentaje (por ejemplo 95% exacto). Vamos a utilizar la variable de puntuación cuando nos encontramos construir y evaluar cada modelo siguiente.

19.5.3 Build Modelos No sabemos qué algoritmos serían buenos para este problema o lo que con fi guraciones de usar. Nos hacemos una idea de las parcelas que algunas de las clases son linealmente separables parcialmente en algunas dimensiones, por lo que estamos esperando generalmente buenos resultados. Evaluemos seis algoritmos di ff Erent:

?? Regresión logística (LR). ?? Análisis discriminante lineal (LDA). ?? K-vecinos más cercanos (KNN).

?? Clasi fi cación y regresión Trees (CART). ?? Gaussian Bayes ingenuo (NB). ?? Máquinas de vectores soporte (SVM).

19.5. Evaluar algunos algoritmos 

120

Esta lista es una buena mezcla de sencilla lineal (LR y LDA), no lineal (KNN, CART, NB y SVM) algoritmos. Reiniciamos la semilla de números aleatorios antes de cada ejecución para garantizar que la evaluación de cada algoritmo se realiza usando exactamente las mismas divisiones de datos. Se asegura de que los resultados son directamente comparables. Vamos a construir y evaluar nuestros cinco modelos: # Inspección al azar Algoritmos modelos = [] models.append (( 'LR' ,  Regresión logística ())) models.append (( '  LDA'  , LinearDiscriminantAnalysis ())) models.append (( 'KNN' ,  KNeighborsClassifier ())) models.append (( 'CARRO' ,  DecisionTreeClassifier ())) models.append (( '  NÓTESE BIEN' , GaussianNB ())) models.append (( '  SVM' ,  SVC ()))

# evaluar cada modelo a su vez Resultados = [] nombres = [] para nombre, modelo en modelos:

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

Añadir 19.16: Evaluar un conjunto de algoritmos en el conjunto de datos.

19.5.4 seleccionar el mejor modelo Ahora tenemos 6 modelos y estimaciones de exactitud para cada uno. Necesitamos comparar los modelos entre sí y seleccionar la más exacta. Ejecutar el ejemplo anterior, se obtienen los siguientes resultados primas:

LR: 0.966667 (0.040825) LDA: 0.975000 (0.038188) KNN: 0.983333 (0.033333) CART: 0.975000 (0.038188) NB: 0.975000 (0.053359) SVM: 0.981667 (0.025000)

Listado 19.17: Salida de la evaluación de un conjunto de algoritmos.

Podemos ver que parece que KNN tiene la mayor puntuación estimada precisión. También podemos crear una gráfica de los resultados de la evaluación y comparación de modelo de la propagación y la precisión media de cada modelo. Hay una población de medidas de precisión para cada algoritmo, ya que cada algoritmo se evaluó 10 veces (10 de validación cruzada veces).

# Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

19.6. Hacer predicciones 

121

Añadir 19.18: Trace la distribución de las puntuaciones para cada algoritmo.

Se puede ver que la caja y bigote parcelas se aplastan en la parte superior de la gama, con muchas muestras de lograr el 100% de precisión.

Figura 19.4: cajas y bigotes parcelas Comparando el rendimiento del algoritmo.

19.6 Hacer predicciones El algoritmo KNN era el modelo más preciso que hemos probado. Ahora queremos tener una idea de la precisión del modelo en nuestro conjunto de datos de validación. Esto nos dará una comprobación independiente final de la precisión de la mejor modelo. Es importante mantener la validación del conjunto en caso de que tuvo un desliz durante el entrenamiento, tales como el exceso fi tting para el conjunto de entrenamiento o una fuga de datos. Tanto dará lugar a un resultado demasiado optimistas. Podemos correr el modelo KNN directamente en el conjunto de validación y resumir los resultados como un nivel de acierto final, una matriz de confusión y un informe de clasi fi cación.

# Hacer predicciones sobre el conjunto de datos de validación knn = KNeighborsClassifier () knn.fit (X_train, Y_train) predicciones = knn.predict (X_validation)

122

19.7. Resumen 

impresión (Accuracy_score (Y_validation, predicciones)) impresión (Confusion_matrix (Y_validation, predicciones)) impresión (Classification_report (Y_validation, predicciones))

Añadir 19.19: Hacer predicciones para el conjunto de datos de validación.

Podemos ver que la precisión es de 0,9 o 90%. La matriz de confusión proporciona una indicación de los tres errores. Por último, el informe de clasi fi cación presenta un desglose de cada clase de precisión, recordar, f1-score y el apoyo que muestra excelentes resultados (concedida el conjunto de datos de validación era pequeña).

0.9 [[7 0 0] [0 11 1] [0 2 9]]

apoyo f1-score recuerdo de precisión Iris-setosa Iris versicolor-0.85 Iris-virginica 0.90

1.00

1.00 0.92 0.82

1.00 0.88 0.86

7 12 11

avg / Total

0.90

0.90

0.90

30

Listado 19.20: Salida de hacer predicciones sobre la validación del conjunto de datos.

19.7 Resumen En esta lección usted descubrió paso a paso cómo llevar a cabo su proyecto de aprendizaje automático primera en Python. Usted descubrió que completar un pequeño proyecto de extremo a extremo, desde la carga de los datos para hacer predicciones es la mejor forma de familiarizarse con la plataforma.

19.7.1 Paso siguiente Ha aplicado las lecciones de la Parte II en un problema sencillo y completó su proyecto de aprendizaje de máquina primero. A continuación, deberá tomar las cosas un paso más allá y trabajar a través de un problema de modelado predictivo de regresión. Será un proyecto un poco más compleja e implicar a las transformaciones de datos, tuning algoritmo y el uso de métodos de conjunto para mejorar los resultados.

iv 11 Spot-Check Clasi fi cación Algoritmos 11.1 Algoritmo de controles in situ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 11.2 Algoritmos general . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . . . 71 11.3 linear Máquina algoritmos de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . 71 11.4 no lineales de la máquina algoritmos de aprendizaje . . . . . . . . . . . . . . . . . . . . . . 72 11.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

70

12 Spot-Check regresión Algoritmos 12.1 Algoritmos general . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . . . 76 12.2 linear Máquina algoritmos de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . 77 12.3 no lineales de la máquina algoritmos de aprendizaje . . . . . . . . . . . . . . . . . . . . . . 80 12.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

76

13 Comparación de algoritmos de aprendizaje de máquinas

83

13.1 elegir el mejor modelo de máquina de aprendizaje . . . . . . . . . . . . . . . . . . . . . 83 13.2 Comparación de aprendizaje automático Algoritmos Consistentemente . . . . . . . . . . . . . . . 83 13.3 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 14 Automatizar la máquina para la empresa Aprendizaje fluye con tuberías

87

14.1 Automatización de máquina para la empresa Aprendizaje flu  jos . . . . . . . . . . . . . . . . . . . . . . 87

14.2 Preparación de datos y modelización Pipeline . . . . . . . . .  . . . . . . . . . . . . . 87 14.3 extracción de características y Modelado Pipeline . . . . . . . . . . . . . . . . . . . . . 89 14.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 15 Mejorar el rendimiento con Conjuntos 15.1 Combinar Modelos En predicciones por conjuntos . . . . . . . .  . . . . . . . . . . . . 91 15,2 embolsado Algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 15.3 Algoritmos Impulso . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . . . . 94 15.4 La votación Ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 15.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

91

16 Mejorar el rendimiento con el algoritmo de sintonización 16.1 Parámetros de la máquina Algoritmo de Aprendizaje . . . . . . . . . . . . . . . . . . . . . . 98

98

16.2 cuadrícula de búsqueda de parámetros de si ntonización . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

16.3 búsqueda aleatoria de parámetros de sintonizac ión . . . . . . . . . . . . . . . . . . . . . . . . . 99 16.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 17 Guardar y cargar la máquina modelos de aprendizaje

101

17.1 Finalizar su modelo con salmuera . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 17.2 Finalizar su modelo con JOBLIB . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 17.3 Consejos para la finalización de su Modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 17.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

III Proyectos Plantilla 18 proyecto de modelado predictivo 18.1 Práctica máquina de aprendizaje con proyectos . . . . . . . . . . . . . . . . . . . . . . 106

105 106

capítulo 20 Proyecto Estudio de un caso de regresión Machine Learning ¿Cómo se trabaja a través de un problema de modelado predictivo de aprendizaje automático de extremo a extremo? En esta lección se trabajará a través de un estudio de regresión problema de modelado predictivo caso en Python incluyendo cada paso del proceso de aprendizaje de la máquina aplicada. Después de completar este proyecto, usted sabrá:

?? ¿Cómo funciona a través de un problema de modelado predictivo de regresión de extremo a extremo.

?? Cómo utilizar los datos transforma para mejorar el rendimiento del modelo. ?? Cómo utilizar la sintonización algoritmo para mejorar el rendimiento del modelo.

?? Cómo utilizar métodos de conjunto y puesta a punto de métodos de conjunto para mejorar el modelo de perfor-

Mance. Empecemos.

20.1 Problema De fi nición Para este proyecto se investigará el conjunto de datos de precios de viviendas de Boston. Cada registro en la base de datos describe un suburbio de Boston o de la ciudad. Los datos se extrae de la Norma área estadística metropolitana de Boston (AEME) en 1970. Los atributos se definen de la siguiente manera (tomado de la UCI Machine Learning Repositorio 1  ):

1. CRIM: cápita tasa de criminalidad de la ciudad por  2. ZN: proporción de suelo residencial dividido en zonas para las porciones más de 25.000 pies cuadrados

3. INDUS: proporción de acres de negocios no minoristas por la ciudad 4. CHAS: Charles River variable ficticia (= 1 si los límites de las vías fluviales; 0 en caso contrario)

5. NOX: concentración óxidos nítricos (partes por 10 millones) 1 https://archive.ics.uci.edu/ml/datasets/Housing

123

124

20.2. Cargar el conjunto de datos 

6. RM: número promedio de habitaciones por vivienda 7. AÑOS: proporción de unidades ocupadas por sus propietarios construidas antes de 1940

8. DIS: distancias ponderadas a cinco centros de empleo de Boston

9. RAD: índice de accesibilidad a radial carreteras 10. IMPUESTO: tasa de impuestos a la propiedad-valor completo por $ 10.000

11. PTRATIO: alumno-maestro por la ciudad 12. SEGUNDO: 1000 (  bk - 0.63)  2 donde Bk es la proporción de negros por la ciudad

13. LSTAT:% estatus más bajo de la población 14. MEDV: La mediana del valor de las viviendas ocupadas por sus propietarios en $ 1000

Podemos ver que los atributos de entrada tienen una mezcla de unidades.

20.2 Cargar el conjunto de datos Vamos a empezar o FF por la carga de las bibliotecas necesarias para este proyecto.

# bibliotecas de carga importar pandas importar numpy

importar matplotlib.pyplot como PLT de pandas.tools.plotting importar scatter_matrix de sklearn.preprocessing importar StandardScaler  de sklearn importar validación cruzada de sklearn.linear_model importar LinearRegression de sklearn.linear_model importar Lazo de sklearn.linear_model importar ElasticNet de sklearn.tree importar DecisionTreeRegressor  de sklearn.neighbors importar KNeighborsRegressor  de sklearn.svm importar SVR de sklearn.pipeline importar Tubería de sklearn.grid_search importar GridSearchCV de sklearn.ensemble importar RandomForestRegressor  de sklearn.ensemble importar GradientBoostingRegressor  de sklearn.ensemble importar ExtraTreesRegressor  de sklearn.ensemble importar AdaBoostRegressor  de sklearn.metrics importar error medio cuadrado

Listing 20.1: bibliotecas de carga. Ahora podemos cargar el conjunto de datos directamente desde el sitio web del repositorio UCI Machine Learning. # Cargar conjunto de datos url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

conjunto de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Listing 20.2: Cargar el conjunto de datos.

125

20.3. Analizar datos 

Se puede ver que estamos especificando los nombres cortos para cada atributo de modo que podamos hacer referencia a ellos claramente más adelante. También se puede ver que los atributos están delimitados por espacios en blanco en lugar de comas en este expediente y nos indican que esto csv pandas.read () función a través de la espacios en blanco delim argumento. Ahora tenemos nuestros datos cargados.

20.3 Análisis de datos Ahora podemos echar un vistazo más de cerca a nuestros datos cargados.

20.3.1 Estadística Descriptiva Vamos a empezar o FF por confirmando las dimensiones del conjunto de datos, por ejemplo, el número de filas y columnas.

# forma impresión (Dataset.shape)

Listing 20.3: Imprimir la forma del conjunto de datos.

Tenemos 506 casos para trabajar y podemos con fi rmar los datos tiene 14 atributos, incluyendo el atributo de salida MEDV.

(506, 14)

Listado 20.4: La salida de forma del conjunto de datos.

También vamos a ver los tipos de datos de cada atributo. # tipos impresión (dataset.dtypes)

Listing 20.5: Imprimir los tipos de datos de cada atributo. Podemos ver que todos los atributos, valores son en su mayoría reales numéricos (flotar) y algunos han sido interpretados como enteros (int). float64 ZN float64 INDUS float64 Int64 CHAS NOX float64 float64 RM AÑOS float64 DIS float64 RAD Int64 IMPUESTO float64 PTRATIO float64 B float64 float64 LSTAT MEDV float64 CRIM

Listado 20.6: La salida de los tipos de datos para cada atributo. Ahora vamos a echar un vistazo a los primeros 20 filas de los datos.

126

20.3. Analizar datos 

# cabeza impresión (Dataset.head (20)) Listing 20.7: Imprimir las primeras pocas filas del conjunto de datos.

Podemos con fi rmar que las escalas de los atributos están por todo el lugar debido a las unidades de Ering di ff. Podemos beneficiarse de algunas transformaciones más adelante. CRIM

ZN INDUS CHAS

0 0,00632 18,0 2,31 1 0,02731 0,0 7,07 2 0,02729 0,0 7,07 3 0,03237 0,0 2,18 4 0,06905 0,0 2,18 5 0,02985 0,0 2,18 6 0,08829 12,5 7,87 7 0,14455 12,5 7,87 8 0,21124 12,5 7,87 9 0,17004 12,5 7,87 10 0,22489 12,5 7,87 11 0,11747 12,5 7,87 12 0,09378 12,5 7,87 13 0,62976 0,0 8,14 14 0,63796 0,0 8,14 15 0,62739 0,0 8,14 16 1,05393 0,0 8,14 17 0,78420 0,0 8,14 18 0,80271 0,0 8,14 19 0,72580 0,0 8,14

NOX

RM

AÑOS

B LSTAT MEDV 15,3 396,90 4,98 24,0 17,8 396,90 9,14 21,6 17,8 392,83 4,03 34,7 18,7 33,4 2,94 394,63 18,7 36,2 5,33 396,90 18,7 28,7 5,21 394,12 15,2 395,60 12,43 22,9 15,2 396,90 19,15 27,1 15,2 386,63 29,93 16,5 15,2 386,71 17,10 18,9 15,2 392,52 20,45 15,0 15,2 396,90 13,27 18,9 15,2 390,50 15,71 21,7 21,0 20,4 8,26 396,90 21,0 380,02 10,26 18,2 21,0 19,9 8,47 395,62 21,0 23,1 6,58 386,85 21,0 386,75 14,67 17,5 21,0 288,99 11,69 20,2 21,0 390,95 11,28 18,2

DIS RAD DE IMPUESTOS PTRATIO

0 0,538 6,575 65,2 4,0900 1 296 0 0,469 6,421 78,9 4,9671 2 242 0 0,469 7,185 61,1 4,9671 2 242 0 0,458 6,998 45,8 6,0622 3 222 0 0,458 7,147 54,2 6,0622 3 222 0 0,458 6,430 58,7 6,0622 3 222 0 0,524 6,012 66,6 5,5605 5 311 0 0,524 6,172 96,1 5,9505 5 311 0 0.524 5.631 100,0 6,0821 5 311 0 0,524 6,004 85,9 6,5921 5 311 0 0,524 6,377 94,3 6,3467 5 311 0 0,524 6,009 82,9 6,2267 5 311 0 0,524 5,889 39,0 5,4509 5 311 0 0,538 5,949 61,8 4,7075 4 307 0 0,538 6,096 84,5 4,4619 4 307 0 0,538 5,834 56,5 4,4986 4 307 0 0,538 5,935 29,3 4,4986 4 307 0 0,538 5,990 81,7 4,2579 4 307 0 0,538 5,456 36,6 3,7965 4 307 0 0,538 5,727 69,5 3,7965 4 307

Listing 20.8: La salida de la primera pocos filas del conjunto de datos.

Vamos a resumir la distribución de cada atributo. # descripciones pandas.set_option ( 'precisión'  , 1) impresión (Dataset.describe ())

Listado 20.9: Imprimir las descripciones estadísticas del conjunto de datos. Ahora tenemos una mejor percepción de cómo di ff Erent son los atributos. Los valores mínimo y máximo, así son los medios varían mucho. es probable que vamos a obtener mejores resultados ajustando la base de los datos de alguna manera.

NOX RM AÑOS ZN INDUS CHAS LSTAT MEDV contar 5.1e + 02 506,0 506,0 02 506,0 5.1e 506,0 + 506,0 506,0 506,0 506,0 506,0 506,0 significar 3.6E + 00 11,4 11,1 6.9e-02 0,6 6,3 68,6 12,7 22,5 std 8.6e + 00 23,3 6.9 2.5e-01 0,1 0,7 28,1 7.1 9.2 min 6.3e-03 0.0 0,5 0.0E + 00 0,4 3.6 2.9 1.7 5.0 25% 8.2e-02 0,0 5,2 0.0E + 00 0,4 5,9 45,0 6,9 17,0

CRIM

DIS

RAD

IMPUESTOS PTRATIO

segundo

506,0 506,0 3.8

9,5 408,2

18,5 356,7

2.1

8,7 168,5

2,2 91,3

1.1

1,0 187,0

12.6

2.1

4,0 279,0

17,4 375,4

0.3

Capítulo 1 Bienvenido Bienvenido a Máquina de aprendizaje de dominio con Python.E   ste libro es su guía para el aprendizaje automático aplicada con Python. Va a descubrir el proceso paso a paso que puede utilizar para empezar y ser bueno en aprendizaje automático para el modelado predictivo con el ecosistema Python.

1.1 Aprender Machine Learning Python El camino equivocado Esto es lo que NO debe hacer cuando se inicia el estudio de aprendizaje automático en Python. 1. Obtener realmente bueno en la programación Python y sintaxis de Python. 2. estudio en profundidad de la teoría subyacente y los parámetros para algoritmos de aprendizaje automático en scikit-learn.

3. Evitar o tocar ligeramente en todas las demás tareas necesarias para completar un proyecto real. Creo que este enfoque puede funcionar para algunas personas, pero es un muy lento y de una manera indirecta de llegar a su objetivo. Le enseña que tiene que pasar todo su tiempo a aprender cómo utilizar algoritmos de aprendizaje automático individuales. También no te enseña el proceso de construcción de modelos predictivos de aprendizaje automático en Python que en realidad se puede utilizar para hacer predicciones. Lamentablemente, este es el enfoque utilizado para enseñar a la máquina de aprendizaje que veo en casi todos los libros y cursos en línea sobre el tema.

1.2 Máquina de aprendizaje en Python Este libro se centra en un específico sub-campo de aprendizaje de máquina llamada modelado predictivo. Este es el campo de aprendizaje de máquina que es el más útil en la industria y el tipo de máquina de aprendizaje que la biblioteca scikit-learn en Python sobresale en la facilitación. A diferencia de las estadísticas, donde los modelos se utilizan para  entender de datos, modelado predictivo es láser enfocado en el desarrollo de modelos que hacen que el la mayoría de las predicciones exactas a expensas de explicar por qué se hacen predicciones. A diferencia del amplio campo de aprendizaje de máquina que sea factible podría ser utilizado con los datos en cualquier formato, modelado predictivo se centra principalmente en los datos tabulares (por ejemplo, tablas de números como en una hoja de cálculo).

Este libro fue escrito en torno a tres temas diseñados para ayudarle a empezar y el uso de Python para la máquina de aprendizaje de E ff aplicada caz y rápida. Estas tres partes son las siguientes:

2

127

20.3. Analizar datos 

50%

75%

máx

2.6e-01 0.0 9,7 0.0E + 00 0,5 11,4 21,2 3.7e + 00 12,5 18,1 0.0E + 00 0,6 17,0 25,0 8.9e + 01 100,0 27,7 1,0 E + 00 0,9 38,0 50,0

6,2 77,5

3.2

5,0 330,0

6,6 94,1

5,2 24,0 666,0

19,1 391,4 20,2 396,2

8,8 100,0 12,1 24,0 711,0

22,0 396,9

Listado 20.10: Salida de las descripciones estadísticas del conjunto de datos.

Ahora, vamos a echar un vistazo a la correlación entre todos los atributos numéricos. # correlación pandas.set_option ( 'precisión'  , 2) impresión (Dataset.corr (método = '  Pearson'  ))

Añadir 20.11: Imprimir las correlaciones entre los atributos. Esto es interesante. Podemos ver que muchos de los atributos tienen una fuerte correlación (por ejemplo,

  ,70). Por ejemplo: >  0,70 o <  - 0 ?? NOX y INDUS con 0,77.

?? DIS y INDUS con -0.71. ?? IMPUESTO y INDUS con 0.72.

?? AÑOS y NOX con 0,73.

?? DIS y NOX con -0.78. También se parece a LSTAT tiene una buena correlación negativa con la variable de salida MEDV con un valor de -0,74.

ZN INDUS

CRIM

NOX CHAS

RM EDAD DIS

RAD DE IMPUESTOS PTRATIO

B LSTAT

MEDV

CRIM

1,00 -0,20 0,41 -5.59e-02 0,42 -0,22 0,35 -0,38 6.26e-01 0,58

- 0.39 ZN - 0,20 1,00 -0,53 -4.27e-02 -0,52 0,31 -0,57 0,66 -3.12e-01 -0,31 -0,39 0,18 -0,41 0.36 INDUS 0,41 -0,53 1,00 6.29e-02 0,76 -0,39 0,64 -0,71 5.95e-01 0,72 - 0.48 - 0,06 -0,04 0,06 1.00e + 00 0,09 0,09 0,09 -0,10 -7.37e-03 -0,04 -0,12 0,05 -0,05 CHAS 0.18 NOX 0,42 -0,52 0,76 9.12e-02 1,00 -0,30 0,73 -0,77 6.11e-01 0,67 - 0.43 RM - 0,22 0,31 -0,39 9.13e-02 -0,30 1,00 -0,24 0,21 -2.10e-01 -0,29 -0,36 0,13 -0,61 0.70 0,35 -0,57 0,64 8.65e-02 0,73 -0,24 1,00 -0,75 4.56e-01 0,51 AÑOS - 0.38 DIS - 0,38 0,66 -0,71 -9.92e-02 -0,77 0,21 -0,75 1,00 -4.95e-01 -0,53 -0,23 0,29 -0,50 0.25 RAD 0,63 -0,31 0,60 -7.37e-03 0,61 -0,21 0,46 -0,49 1.00e + 00 0,91 - 0.38 IMPUESTO 0,58 -0,31 0,72 -3.56e-02 0,67 -0,29 0,51 -0,53 9.10e-01 1,00 - 0.47 PTRATIO 0,29 -0,39 0,38 -1.22e-01 0,19 -0,36 0,26 -0,23 4.65e-01 0,46 - 0.51

0,29 -0,39 0,46

0,38 -0,36 0,60

0,19 -0,38 0,59

0,26 -0,27 0,60

0,46 -0,44 0,49 0,46 -0,44 0,54 1,00 -0,18 0,37

128

20.4. Las visualizaciones de datos 

segundo

- 0,39 0,18 -0,36 4.88e-02 -0,38 0,13 -0,27 0,29 -4.44e-01 -0,44 -0,18 1,00 -0,37

0.33 LSTAT MEDV

0,46 -0,41 0,60 -5.39e-02 0,59 -0,61 0,60 -0,50 4.89e-01 0,54

0,37 -0,37 1,00

- 0.74 - 0,39 0,36 -0,48 1.75e-01 -0,43 0,70 -0,38 0,25 -3.82e-01 -0,47 -0,51 0,33 -0,74 1.00

Listado 20.12: Salida de las descripciones estadísticas del conjunto de datos.

20.4 Datos visualizaciones 20.4.1 unimodales visualizaciones de datos Veamos visualizaciones de atributos individuales. A menudo es útil mirar sus datos utilizando múltiples visualizaciones di ff Erent con el fin de generar ideas. Veamos histogramas de cada atributo para tener una idea de las distribuciones de datos.

# histogramas dataset.hist (sharex = False, Sharey = False, xlabelsize = 1, ylabelsize = 1) plt.show ()

Listado 20.13: visualizar el conjunto de datos utilizando histogramas. Podemos ver que algunos atributos pueden tener una distribución exponencial, como CRIM, ZN, EDAD y SEGUNDO. Podemos ver que otros pueden tener una distribución bimodal como RAD y IMPUESTO.

129

20.4. Las visualizaciones de datos 

Figura 20.1: Parcelas histograma de cada atributo. Veamos las mismas distribuciones usando gráficos de densidad que las atenúan un poco. # densidad dataset.plot (tipo = 'densidad' ,  Subtramas = True, layout = (4,4), sharex = False, leyenda = False, FontSize = 1) plt.show ()

Listado 20.14: visualizar el conjunto de datos utilizando gráficos de densidad.

Esto tal vez se suma más pruebas para nuestra sospecha sobre posibles distribuciones exponenciales y bimodales. También se parece a NOX, RM y LSTAT pueden estar sesgadas distribuciones gaussianas, que podrían ser útiles más adelante con transformaciones.

130

20.4. Las visualizaciones de datos 

Figura 20.2: gráficos de densidad de cada atributo.

Veamos los datos con caja y bigote parcelas de cada atributo. # caja y bigote parcelas dataset.plot (tipo = 'caja' ,  Subtramas = True, layout = (4,4), sharex = False, Sharey = False, FontSize = 8) plt.show ()

Añadir 20.15: Visualizar el conjunto de datos utilizando caja y bigote parcelas. Esto ayuda a señalar el sesgo en muchas distribuciones hasta el punto de que los datos se parece a los valores atípicos (por ejemplo, más allá del bigote de las parcelas).

20.4. Las visualizaciones de datos 

131

Figura 20.3: caja y bigotes Parcelas de cada atributo.

20.4.2 multimodales visualizaciones de datos Veamos algunas visualizaciones de las interacciones entre las variables. El mejor lugar para empezar es una matriz gráfica de dispersión.

# matriz gráfico de dispersión scatter_matrix (conjunto de datos) plt.show () Listado 20.16: visualizar el conjunto de datos utilizando gráficos de dispersión.

Podemos ver que algunos de los atributos más alta correlacionados sí muestran una buena estructura en su relación. No es lineal, pero agradable curvos relaciones predecibles.

20.4. Las visualizaciones de datos 

132

Figura 20.4: Diagrama de dispersión de la matriz de conjunto de datos de atributos.

También vamos a visualizar las correlaciones entre los atributos. # matriz de correlación fig = plt.figure () ax = fig.add_subplot (111) cax = ax.matshow (dataset.corr (), Vmin = -1, vmax = 1, la interpolación = 'ninguna' )  Fig.colorbar (cax) garrapatas = numpy.arange (0,14,1) ax.set_xticks ax.set_yticks (garrapatas) (garrapatas) ax.set_xticklabels (nombres) ax.set_yticklabels (nombres) plt.show ()

Añadir 20.17: Visualizar las correlaciones entre atributos. El color rojo oscuro muestra correlación positiva mientras que el color azul oscuro muestra correlación negativa. También podemos ver algunos de color azul oscuro y rojo oscuro que sugiere candidatos para la eliminación de mejorar una mejor precisión de los modelos más adelante.

20.5. validación del conjunto de datos 

Figura 20.5: Matriz de correlación de conjunto de datos de atributos.

20.4.3 Resumen de las Ideas Hay una gran cantidad de estructura en este conjunto de datos. Tenemos que pensar en las transformaciones que podríamos usar más adelante para exponer mejor la estructura que a su vez puede mejorar la precisión de modelado. Hasta el momento, sería vale la pena probar:

?? La selección de características y la eliminación de los atributos más correlacionados.

?? Normalizar el conjunto de datos para reducir el e ff ect de escalas Ering di ff. ?? La estandarización del conjunto de datos para reducir los e ECTS y siguientes distribuciones de Ering di ff.

Con una gran cantidad de tiempo adicional También me gustaría explorar la posibilidad de hurgar en la basura (discretización) de los datos. Esto a menudo puede mejorar la precisión de los algoritmos de árboles de decisión.

20.5 Validación del conjunto de datos Es una buena idea utilizar un conjunto de retención a cabo la validación. Este es un ejemplo de los datos que tenemos de volver de nuestro análisis y modelado. La usamos la derecha al final de nuestro proyecto para confirmar la exactitud de nuestro modelo final. Es una prueba de humo que podemos utilizar para ver si tenemos mal estado y para

133

10

2.2. SciPy 

desarrollo y prototipado rápido con el poder para apoyar el desarrollo de aplicaciones de gran tamaño. También es ampliamente utilizado para el aprendizaje de máquina y datos de la ciencia debido a la excelente compatibilidad con bibliotecas y porque es un lenguaje de programación de propósito general (a diferencia de R o Matlab). Por ejemplo, ver los resultados de los resultados de la encuesta en 2011 la plataforma Kaggle

 2

y los

Nuggets KDD 2015 herramientas resultados de la encuesta  3  .

Esta es una consideración simple y muy importante. Esto significa que usted puede realizar su investigación y desarrollo (fi gurar qué modelos a utilizar) en el mismo lenguaje de programación que utiliza para sus sistemas de producción. Simplificando en gran medida la transición desde el desarrollo hasta la producción.

2.2 SciPy SciPy es un ecosistema de bibliotecas de Python para las matemáticas, la c iencia y la ingeniería. Es un complemento a Python que se necesita para el aprendizaje de la máquina. El ecosistema SciPy se compone de los siguientes módulos de núcleo relevantes para el aprendizaje de máquina:

?? NumPy: Una base para SciPy que le permite e fi cientemente el trabajo con datos en matrices.

?? matplotlib: Le permite crear gráficos 2D y tramas de datos. ?? pandas: Herramientas y estructuras de datos para organizar y analizar sus datos.

Para ser ff e caz en el aprendizaje de las máquinas en Python debe instalar y se familiarice con SciPy. Específicamente:

?? Usted va a preparar sus datos como matrices NumPy para el modelado de algoritmos de aprendizaje automático.

?? Que va a utilizar Matplotlib (y envoltorios de Matplotlib en otros marcos) para crear parcelas y los gráficos de sus datos. ?? Que va a utilizar para cargar las pandas explorar y comprender mejor sus datos.

2.3 scikit-learn La biblioteca scikit-learn es cómo se puede desarrollar la práctica y la máquina de aprendizaje en pitón. Se basa en el ecosistema y requiere SciPy. El nombre scikit sugiere que es un plug-in SciPy o kit de herramientas. El enfoque de la biblioteca es algoritmos de aprendizaje automático para la clasi fi cación, regresión, clustering y más. También proporciona herramientas para las tareas relacionadas, tales como la evaluación de los modelos, parámetros de ajuste y los datos pre-procesamiento.

Como Python y SciPy, scikit-learn es de código abierto y se puede utilizar en el comercio bajo la licencia BSD. Esto significa que usted puede aprender sobre el aprendizaje de máquina, el desarrollo de modelos y ponerlos en todas las operaciones con el mismo ecosistema y el código. Una razón poderosa para usar scikit-learn. http://blog.kaggle.com/2011/11/27/kagglers-favorite-tools/ 3 http://www.kdnuggets.com/polls/2015/analytics-data-mining-data-science-software-used. html 2

20.6. Evaluar Algoritmos: Línea de Base 

134

nos dará la confianza en nuestras estimaciones de exactitud en los datos que no se ven. Vamos a utilizar el 80% del conjunto de datos para el modelado y contener un 20% para su validación.

# Split-cabo la validación de datos matriz = dataset.values X = array [:, doce y trece] Y = array [:, 13] validation_size = 0,20 semilla = 7 X_train, X_validation, Y_train, Y_validation = cross_validation.train_test_split (X, Y, test_size = validation_size, random_state = semilla)

Añadir 20.18: Los datos se separan en un entrenamiento y validación de datos.

20.6 Evaluar Algoritmos: Línea de Base No tenemos idea de lo que los algoritmos harán bien en este problema. el instinto sugiere algoritmos de regresión como la regresión lineal y ElasticNet pueden hacer bien. También es posible que los árboles de decisión e incluso SVM pueden hacer bien. No tengo idea. Vamos a diseñar nuestro instrumento de prueba. Vamos a utilizar 10 veces la validación cruzada. El conjunto de datos no es demasiado pequeño y este es un buen instrumento de prueba con fi guración estándar. Vamos a evaluar algoritmos utilizando el error cuadrático medio (MSE) métrica. MSE dará una idea de lo equivocado bruto todas las predicciones son (0 es perfecto).

# Opciones de prueba y evaluación métrica num_folds = 10 num_instances = len (X_train) semilla = 7 puntuación = 'error medio cuadrado'

Añadir 20.19: Con fi gura algoritmo de evaluación instrumento de prueba. Vamos a crear una línea de base de rendimiento en este problema y verificación al azar una serie de algoritmos Erent di ff. Vamos a seleccionar un conjunto de algoritmos Erent di ff capaces de trabajar en este problema de regresión. Los seis algoritmos seleccionados incluyen:

?? Los algoritmos lineales: Regresión Lineal (LR), Lasso de regresión (LASSO) y ElasticNet (ES).

?? Los algoritmos no lineales: Clasi fi cación y regresión Trees (CART), Vector Soporte Regresión (SVR) y K-vecinos más cercanos (KNN). # Inspección al azar Algoritmos modelos = [] models.append (( 'LR' ,  LinearRegression ())) models.append ((   'LAZO' , Lasso ())) models.append (( 'ES' ,  ElasticNet () )) models.append (( '  KNN'  , KNeighborsRegressor ())) models.append (( '  CARRO' ,  DecisionTreeRegressor ())) models.append (( 'SVR'  , SVR ()))

Añadir 20.20: Crear la lista de algoritmos de evaluar.

20.6. Evaluar Algoritmos: Línea de Base 

135

Los algoritmos de todos los parámetros de ajuste de uso por defecto. Vamos a comparar los algoritmos. Vamos a mostrar l a media y la desviación estándar de MSE para cada algoritmo como lo calculamos y recoger los resultados para su uso posterior.

# evaluar cada modelo a su vez Resultados = [] nombres = [] para nombre, modelo en modelos:

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

Añadir 20.21: Evaluar la lista de algoritmos. Parece que tiene el LR MSE más bajo, seguido de cerca por CART. LR: -21.379856 (9,414264) LASSO: -26.423561 (11.651110) ES: -27.502259 (12.305022) KNN: -41.896488 (13.901688) CART: -23.608957 (12.033061) SVR: -85.518342 (31.994798)

Añadir 20.22: Los resultados de los algoritmos de evaluación. Vamos a echar un vistazo a la distribución de las puntuaciones en todos los pliegues de validación cruzada por el algoritmo.

# Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Añadir 20.23: Visualzie el Di ff erences en algoritmo de rendimiento. Podemos ver distribuciones similares para los algoritmos de regresión y tal vez una distribución más estrecha de las puntuaciones de CART.

20.7. Evaluar Algoritmos: Normalización 

136

Figura 20.6: Algoritmo de comparación de rendimiento.

Las escalas di ff Ering de los datos probablemente está dañando la habilidad de todos los algoritmos y tal vez más para SVR y KNN. En la siguiente sección vamos a ver en la ejecución de los mismos algoritmos utilizando una copia de los datos estandarizados.

20.7 Evaluar Algoritmos: Normalización Tenemos la sospecha de que las escalas di ff Ering de los datos en bruto pueden estar afectando negativamente la habilidad de algunos de los algoritmos. Evaluemos los mismos algoritmos con una copia del conjunto de datos normalizado. Aquí es donde los datos se transforma de tal manera que cada atributo tiene un valor medio de cero y una desviación estándar de 1. También es necesario para evitar la pérdida de datos cuando transformamos los datos. Una buena manera de evitar fugas es utilizar tuberías que estandarizan los datos y construir el modelo para cada pliegue en el instrumento de prueba de validación cruzada. De esta manera podemos obtener una estimación razonable de cómo cada modelo con datos estandarizados podría llevar a cabo en los datos que no se ven.

# Estandarizar el conjunto de datos tuberías = [] pipelines.append (( 'ScaledLR' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), (  'LR' ,  LinearRegression ())]))) pipelines.append (( 'ScaledLASSO' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  LAZO'  , Lasso ())])))

20.7. Evaluar Algoritmos: Normalización 

137

pipelines.append (( 'ScaledEN' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  ES' ,  ElasticNet ())]) )) pipelines.append (( '  ScaledKNN' ,  Pipeline ([( '  Escalador' , StandardScaler ()), ( 'KNN' ,  KNeighborsRegressor ())]))) pipelines.append (( '  ScaledCART' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  CARRO' , DecisionTreeRegressor ())]))) pipelines.append (( 'ScaledSVR' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  SVR' ,  RVS ())]))) resultados = [] nombres = []

para nombre, modelo en tuberías: kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

Añadir 20.24: Evaluación de algoritmos sobre estandarizada conjunto de datos.

Ejecutar el ejemplo proporciona una lista de los errores cuadráticos medios. Podemos ver que lo hizo escalar tener un efecto sobre ff e KNN, conduciendo el error más bajo que los otros modelos. ScaledLR: -21.379856 (9,414264) ScaledLASSO: -26.607314 (8,978761) ScaledEN: -27.932372 (10.587490) ScaledKNN: -20.107620 (12.376949) ScaledCART: -23.360362 (9,671240) ScaledSVR: -29.633086 (17.009186)

Añadir 20.25: Los resultados de la evaluación de algoritmos sobre estandarizada conjunto de datos. Vamos a echar un vistazo a la distribución de las puntuaciones a través de los pliegues de validación cruzada.

# Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Scaled algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Añadir 20.26: Visualzie el Di ff erences en el algoritmo de rendimiento estandarizadas conjunto de datos. Podemos ver que KNN tiene tanto una distribución estrecha del error y tiene la puntuación más baja.

20.8. Mejorar los resultados con ajuste 

138

Figura 20.7: Algoritmo de comparación de rendimiento en el conjunto de datos estandarizado.

20.8 mejorar los resultados con ajuste Sabemos por los resultados en la sección anterior que KNN logra buenos resultados en una versión a escala del conjunto de datos. Pero, ¿puede hacerlo mejor. El valor predeterminado para el número de vecinos en KNN es 7. Se puede utilizar una rejilla de búsqueda para tratar un conjunto de números Erent di ff de los vecinos y ver si podemos mejorar la puntuación. El siguiente ejemplo intenta impar K valores de 1 a 21, un rango arbitrario que cubre un buen valor conocido de 7. Cada K valor ( n vecinos) se evaluó utilizando 10 veces la validación cruzada en una copia estandarizada de la formación de datos.

escalador = StandardScaler (). caber (X_train) rescaledX = scaler.transform (X_train) k_values = numpy.array ([1,3,5,7,9,11,13,15,17,19,21]) param_grid = dict (N_neighbors = k_values) Modelo = KNeighborsRegressor () kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) de rejilla = GridSearchCV (estimador = modelo, param_grid = param_grid, puntuación = puntuación, cv = kfold) grid_result = grid.fit (rescaledX, Y_train)

Añadir 20.27: ajustar los parámetros del algoritmo KNN en el conjunto de datos estandarizado. Podemos mostrar las puntuaciones de la desviación media y estándar, así como el mejor valor para el rendimiento K abajo.

3.1. Python curso acelerado 

dieciséis

Asignación múltiple # Asignación múltiple a, b, c = 1, 2, 3 impresión (a B C)

Listado 3.7: Ejemplo de trabajo con asignación múltiple. Esto también puede ser muy útil para descomprimir los datos en estructuras de datos simples. Ejecución de las impresiones de ejemplo:

(1, 2, 3)

Listado 3.8: Salida del ejemplo de trabajo con asignación múltiple.

Sin valor  # Sin valor  a = Ninguno impresión (un)

Listado 3.9: Ejemplo de trabajar sin ningún valor. Ejecución de las impresiones de ejemplo: Ninguna

Listado 3.10: Salida del ejemplo de trabajo sin valor.

3.1.2 Control de Flujo Hay tres tipos principales de control de flujo que usted necesita aprender: condiciones If-Then-Else, Para-bucles y bien-Loops. If-Then-Else condicional value = 99 Si valor == 99: impresión 'Eso es rápido' elif valor> 200: impresión 'Eso es demasiado rápido'

más : impresión 'Eso es seguro'

Listado 3.11: Ejemplo de trabajo con un If-Then-Else condicional. Observe los dos puntos (:) al final de la condición y la pestaña significativa la intención de que el bloque de código bajo la condición. Ejecución de las impresiones de ejemplo: If-Then-Else condicional

Listado 3.12: Salida del ejemplo de trabajo con un If-Then-Else condicional.

20.9. Métodos Ensemble 

139

impresión ( "  Best:% f utilizando% s" % (Grid_result.best_score_, grid_result.best_params_)) para params, mean_score, puntuaciones en grid_result.grid_scores_: impresión (  "% F (% f) con:% r" % (Scores.mean (), scores.std (), params))

Listado 20.28: Salida de impresión de la adaptación del algoritmo KNN.

Se puede ver que lo mejor para K (n vecinos) se 3 proporcionando un error cuadrático medio de

- 18.172137, el mejor hasta ahora. Mejores: -18.172137 utilizando { 'n_neighbors': 3} -

20.169640 (14.986904) con: { 'n_neighbors': 1} 18.109304 (12.880861) con: { 'n_neighbors': 3} 20.063115 (12.138331) con: { '' n_neighbors: 5} 20.514297 (12.278136) con: { '' n_neighbors: 7} 20.319536 (11.554509) con: { '' n_neighbors: 9} 20.963145 (11.540907) con: { '' n_neighbors: 11} 21.099040 (11.870962) con: { 'n_neighbors': 13} 21.506843 (11.468311) con: { '' n_neighbors: 15} 22.739137 (11.499596) con: { 'n_neighbors': 17} 23.829011 (11.277558) con: { 'n_neighbors': 19} 24.320892 (11.849667) con: { '' n_neighbors: 21}

Listado 20.29: Salida de la adaptación del algoritmo KNN.

20.9 Métodos Ensemble Otra forma en que podemos mejorar el rendimiento de los algoritmos de este problema es mediante el uso de métodos de conjunto. En esta sección vamos a evaluar cuatro di algoritmos de aprendizaje automático conjunto ff Erent, dos impulsar y dos métodos de ensacado:

?? Impulsar Métodos: AdaBoost (AB) y el gradiente Impulso (GBM). ?? Métodos ensacado: Random Forests (RF) y árboles adicionales (ET). Vamos a utilizar el mismo instrumento de prueba como antes, 10 veces l a validación cruzada y tuberías que estandarizan los datos de entrenamiento para cada pliegue. conjuntos = [] ensembles.append (( 'ScaledAB' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), (  'AB' ,  AdaBoostRegressor ())]))) ensembles.append (( 'ScaledGBM' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  GBM' ,  GradientBoostingRegressor ())]))) ensembles.append (( 'ScaledRF' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  RF' ,  RandomForestRegressor ())]))) ensembles.append (( 'ScaledET' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  ET' ,  ExtraTreesRegressor ())]))) resultados = [] nombres = []

para nombre, modelo en Formación:

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación)

20.9. Métodos Ensemble 

140

results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ()) impresión (Msg)

Añadir 20.30: Evaluar Ensemble algoritmos en el conjunto de datos estandarizado. Ejecutar el ejemplo se calcula el error cuadrático medio para cada método utilizando los parámetros por defecto. Podemos ver que en general estamos consiguiendo mejores puntajes que nuestros algoritmos lineales y no lineales en las secciones anteriores.

ScaledAB: -14.964638 (6,069505) ScaledGBM: -9.999626 (4,391458) ScaledRF: -13.676055 (6,968407) ScaledET: -11.497637 (7,164636)

Listado 20.31: Salida desde la evaluación de conjunto de algoritmos. También podemos representar gráficamente la distribución de las puntuaciones a través de los pliegues de validación cruzada.

# Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Scaled Ensemble algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Añadir 20.32: Visualzie el Di f f erences de interpretación de conjunto estandarizado Algoritmo de conjunto de datos.

Parece que tiene Gradiente Impulsar una mejor puntuación media, que también se ve como árboles extra tiene una distribución similar y tal vez una mejor puntuación mediana.

20.10. Métodos Ensemble Tune 

141

Figura 20.8: comparar el rendimiento de los algoritmos Ensemble. Probablemente podemos hacerlo mejor, dado que las técnicas por conjuntos utilizan los parámetros por defecto. En la siguiente sección vamos a ver el ajuste del gradiente de Impulso para levantar aún más el rendimiento.

20.10 Métodos Ensemble Tune El número predeterminado de impulsar etapas para llevar a cabo ( n estimadores) es de 100. Este es un buen parámetro candidato del gradiente Impulsar afinar. A menudo, cuanto mayor sea el número de etapas impulsar, mejor será el rendimiento, pero cuanto mayor sea el tiempo de entrenamiento. En esta sección vamos a ver el ajuste del número de etapas para impulsar gradiente. A continuación se definen una cuadrícula de parámetros

n estimadores valores de 50 a 400 en incrementos de 50. Cada ajuste se evalúa utilizando 10 veces la validación cruzada.

escalador = StandardScaler (). caber (X_train) rescaledX = sc aler.transform (X_train) param_grid = dict (N_estimators = numpy.array ([50.100.150.200.250.300.350.400])) Modelo = GradientBoostingRegressor (random_state = semilla)

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) de rejilla = GridSearchCV (estimador = modelo, param_grid = param_grid, puntuación = puntuación, cv = kfold) grid_result = grid.fit (rescaledX, Y_train)

Añadir 20.33: Tune GBM en conjunto de datos a escala.

142

20.11. finalizar Modelo 

Al igual que antes, podemos resumir la mejor con fi guración y tener una idea de cómo el rendimiento cambia con cada di ff Erent con fi guración. impresión ( "  Best:% f utilizando% s" % (Grid_result.best_score_, grid_result.best_params_)) para params, mean_score, puntuaciones en grid_result.grid_scores_: impresión (  "% F (% f) con:% r" % (Scores.mean (), scores.std (), params))

Añadir 20.34: rendimiento de impresión de Tuned GBM en conjunto de datos a escala.

Podemos ver que la mejor con fi guración era n = estimadores 400 que resulta en un error cuadrático medio de -9.356471, alrededor de 0,65 unidades mejor que el método no sintonizada. Mejores: -9.356471 utilizando { 'n_estimators: 400} -

10.794196 (4.711473) con: { 'n_estimators': 50} 10.023378 (4.430026) con: { '' n_estimators: 100} 9.677657 (4.264829) con: { 'n_estimators': 150} 9.523680 (4.259064) con: { '' n_estimators: 200} 9.432755 (4.250884) con: { '' n_estimators: 250} 9.414258 (4.262219) con: { '' n_estimators: 300} 9.353381 (4.242264) con: { 'n_estimators': 350} 9.339880 (4.255717) con: { 'n_estimators': 400}

Añadir 20.35: Rendimiento de salida de Tuned GBM en conjunto de datos a escala. A continuación podemos fi nalizar el modelo y prepararlo para su uso general.

20.11 Finalizar Modelo En esta sección vamos a fi nalizar el gradiente de impulsar el modelo y evaluarla en nuestra bodega a cabo validación de datos. Lo primero que necesitamos para preparar el modelo y entrenar en el conjunto de datos de entrenamiento. Esto incluye la estandarización de la formación de datos antes del entrenamiento. # preparar el modelo escalador = StandardScaler (). caber (X_train) rescaledX = scaler.transform (X_train) Modelo = GradientBoostingRegressor (random_state = semilla, n_estimators = 400) model.fit (rescaledX, Y_train)

Listado 20.36: construir el modelo finalizado. Entonces podemos escalar los insumos para la validación de datos y generar predicciones. # transformar el conjunto de datos de validación rescaledValidationX = scaler.transform (X_validation) predicciones = model.predict (rescaledValidationX) impresión (Mean_squared_error (Y_validation, predicciones))

Añadir 20.37: evaluar el modelo finalizado. Podemos ver que el error cuadrático medio estimado es de 11,8, cerca de nuestra estimación de -9,3. 11.8752520792

Listado 20.38: Salida de Evaluación del modelo finalizado.

3.3. Matplotlib curso acelerado 

3.3 Matplotlib curso acelerado Matplotlib se puede utilizar para la creación de parcelas y gráficos. La biblioteca se utiliza generalmente como sigue: ?? Llamar a un dibujo de las funciones con algunos datos (por ejemplo. trama()).

?? Llamar a muchas funciones para configurar las propiedades de la trama (por ejemplo, etiquetas y colores). ?? Hacer visible la trama (por ejemplo. espectáculo()).

3.3.1 Línea Solar  El ejemplo siguiente crea una trama simple línea de uno de datos dimensionales. # diagrama de puntos básicos importar matplotlib.pyplot como PLT importar numpy

myarray = numpy.array ([1, 2, 3]) plt.plot (myarray) plt.xlabel ( 'Algunos eje x' )  Plt.ylabel ( '  Algunos eje y'  ) Plt.show ()

Perfil de 3.31: Ejemplo de creación de una parcela línea con Matplotlib.

Ejecutar el ejemplo produce:

21

20.12. Resumen 

143

20.12 Resumen En este capítulo se ha trabajado a través de un problema de aprendizaje de máquina de modelado predictivo de regresión de un extremo a extremo utilizando Python. Específicamente, los pasos tratados fueron: ?? Problema De fi nición (Boston datos de precios de la vivienda). ?? Carga del conjunto de datos.

?? Analizar los datos (algunas distribuciones asimétricas y atributos correlacionados).

?? Evaluar Algoritmos (regresión lineal se veía bien). ?? Evaluar algoritmos con Normalización (KNN se veía bien). ?? Algoritmo de sintonía ( K = 3 para KNN era mejor).

?? Métodos Ensemble (ensacado y Impulsar, Gradiente impulsar parecía bueno). ?? Métodos de ajuste Ensemble (obteniendo el máximo de Gradiente Impulsar). ?? Finalizar Modelo (utilizar todos los datos de entrenamiento y confirman utilizando validación de datos).

Trabajando a través de este estudio de caso se mostró cómo las recetas para las tareas de aprendizaje automático fi cas se pueden  juntar en un proyecto completo. Trabajando a través de este estudio de caso es una buena práctica en el aprendizaje automático aplicado usando Python y scikit-learn.

20.12.1 Siguiente Paso Ahora ha completado dos proyectos de modelado de aprendizaje automático de predicción de extremo a extremo. El primero era un problema fi cación clasificación multiclase y este segundo proyecto fue un problema de regresión. Lo siguiente es la tercera y fi nal estudio de caso de un problema de clasi fi cación binaria.

capítulo 21 Binaria Clasi fi cación del Proyecto Estudio de caso de máquina de aprendizaje ¿Cómo se trabaja a través de un problema de modelado predictivo de aprendizaje automático de extremo a extremo? En esta lección que va a trabajar a través de una clasi fi cación problema de modelado predictivo estudio de caso en Python incluyendo cada paso del proceso de aprendizaje automático aplicado. Después de completar este proyecto, usted sabrá:

?? ¿Cómo trabajar a través de un extremo a extremo clasi fi cación problema de modelado predictivo. ?? Cómo utilizar los datos transforma para mejorar el rendimiento del modelo. ?? Cómo utilizar la sintonización algoritmo para mejorar el rendimiento del modelo.

?? Cómo utilizar métodos de conjunto y puesta a punto de métodos de conjunto para mejorar el modelo de perfor-

Mance. Empecemos.

21.1 Problema De fi nición El objetivo de este proyecto será la Minas Sonar vs Rocks conjunto de datos 1  . E   l problema es pred ecir metal o de roca objetos a partir de los datos devueltos por la sonda. Cada patrón es un conjunto de 60 números en el rango

0.0 a 1.0. Cada número representa la energía dentro de una banda de frecuencia particular, integrada a lo largo de un cierto período de tiempo. La etiqueta asociada a cada registro contiene la letra R si el objeto es una roca y METRO si se trata de una mina (cilindro de metal). Los números en las etiquetas están en orden de ángulo de aspecto creciente, pero que no codifican el ángulo directamente.

21.2 Cargar el conjunto de datos Vamos a empezar o FF por la carga de las bibliotecas necesarias para este proyecto. 1

https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks)

144

145

21.3. Analizar datos 

# bibliotecas de carga importar pandas importar numpy

importar matplotlib.pyplot como PLT de pandas.tools.plotting importar scatter_matrix de sklearn.preprocessing importar StandardScaler  de sklearn importar validación cruzada de sklearn.metrics importar classification_report de sklearn.metrics importar matriz de confusión de sklearn.metrics importar accuracy_score de sklearn.pipeline importar Tubería de sklearn.grid_search importar GridSearchCV de sklearn.linear_model importar Regresión logística de sklearn.tree importar DecisionTreeClassifier  de sklearn.neighbors importar KNeighborsClassifier  de sklearn.discriminant_analysis importar LinearDiscriminantAnalysis de sklearn.naive_bayes importar GaussianNB de sklearn.svm importar SVC de sklearn.ensemble importar AdaBoostClassifier  de sklearn.ensemble importar GradientBoostingClassifier  de sklearn.ensemble importar RandomForestClassifier  de sklearn.ensemble importar ExtraTreesClassifier 

Listing 21.1: bibliotecas de carga. Ahora podemos cargar el conjunto de datos directamente desde el sitio web del repositorio UCI Machine Learning. url = "Https://goo.gl/NXoJfR" conjunto de datos = pandas.read_csv (url, encabezado = None)

Listing 21.2: Cargar el conjunto de datos.

Se puede ver que no estamos especificando los nombres de los atributos de este tiempo. Esto se debe a que no sea el atributo de clase (la última columna), las variables no contamos con nombres significativos. También indicamos que no hay información de la cabecera, esto es para evitar fi l código de carga de tomar el primer registro fi como los nombres de las columnas. Ahora que hemos cargado el conjunto de datos que podemos tener una mirada en ella.

21.3 Análisis de datos Vamos a echar un vistazo más de cerca a nuestros datos cargados.

21.3.1 Estadística Descriptiva Vamos a empezar o FF por confirmando las dimensiones del conjunto de datos, por ejemplo, el número de filas y columnas.

# forma impresión (Dataset.shape)

Listing 21.3: Imprimir la forma del conjunto de datos.

Tenemos 208 casos para trabajar y podemos con fi rmar los datos tiene 61 atributos, incluyendo el atributo de clase.

146

21.3. Analizar datos 

(208, 61)

Listado 21.4: La salida de forma del conjunto de datos.

También vamos a ver los tipos de datos de cada atributo. # tipos pandas.set_option ( '' display.max_rows ,  500) impresión (dataset.dtypes)

Listing 21.5: Imprimir los tipos de datos de cada atributo. Podemos ver que todos los atributos son numéricas (flotar) y que el valor de la clase que se ha leído en como un objeto.

0

float64 1 float64 2 float64 3 float64 4 float64 5 float64 6 float64 7 float64 8 float64 9 float64 10 float64

. .. 49

float64 50 float64 51 float64 52 float64 53 float64 54 float64 55 float64 56 float64 57 float64 58 float64 59 float64 60 objeto

Listado 21.6: La salida de los tipos de datos para cada atributo. Ahora vamos a echar un vistazo a los primeros 20 filas de los datos. # cabeza pandas.set_option ( 'Display.width' ,  100) impresión (Dataset.head (20)) Listing 21.7: Imprimir las primeras pocas filas del conjunto de datos.

Esto no muestra todas las columnas, pero podemos ver todos los datos tienen la misma escala. También podemos ver que el atributo de clase (60) tiene valores de cadena. 0

1

2

3

4

5

6

0,0200 0,0371 0,0428 0 0,0207 0,0954 0,0986 0,1539 0,1601 0,3109 0,2111 0,0027 ... 0,0453 0,0523 0,0843 1 0,0689 0,1183 0,2583 0,2156 0,3481 0,3337 0,2872 0,0084 ... 0,0262 0,0582 0,1099 2 0,1083 0,0974 0,2280 0,2431 0,3771 0,5598 0,6194 0,0232 ... 0,0100 0,0171 0,0623 3 0,0205 0,0205 0,0368 0,1098 0,1276 0,0598 0,1264 0,0121 ...

7

8

9 ...

51 \

Capítulo 4 Cómo cargar datos de la máquina de aprendizaje Usted debe ser capaz de cargar sus datos antes de poder iniciar su proyecto de aprendizaje automático. El formato más común para los datos de aprendizaje automático es CSV archivos. Hay un número de maneras de cargar un archivo CSV fi le en Python. En esta lección usted aprenderá tres maneras que usted puede utilizar para cargar sus datos CSV en Python:

1. Cargar archivos CSV con la biblioteca estándar de Python. 2. Cargar archivos CSV con NumPy. 3. Carga de archivos CSV con las pandas.

Empecemos.

4.1 Consideraciones al cargar datos CSV Hay una serie de consideraciones a la hora de cargar sus datos de aprendizaje automático de archivos CSV. Como referencia, se puede aprender mucho sobre las expectativas de los archivos CSV mediante la revisión de la solicitud CSV para su comentario titulado  Formato común y tipo MIME de valores separados por comas (CSV) Archivos  1  .

4.1.1 Archivo de cabecera ¿Los datos tienen un expediente de cabecera? Si es así esto puede ayudar en la asignación automática de nombres a cada columna de datos. Si no es así, puede que tenga que nombrar sus atributos manualmente. De cualquier manera, usted debe especificar explícitamente si o no su fi CSV le tenía un expediente de cabecera al cargar los datos.

4.1.2 Comentarios ¿Los datos tienen comentarios? Los comentarios en un archivo CSV fi l se indican mediante una almohadilla (#) al comienzo de una línea. Si tiene algún comentario en su archivo, dependiendo del método utilizado para cargar sus datos, es posible que necesite para indicar si o no esperar los comentarios y el carácter a esperar para significar una línea de comentario.

1h   ttps://tools.ietf.org/html/rfc4180

26

147

21.3. Analizar datos 

0,0762 0,0666 0,0481 4 0,0394 0,0590 0,0649 0,1209 0,2467 0,3564 0,4459 0,0031 ... 0,0286 0,0453 0,0277 5 0,0174 0,0384 0,0990 0,1201 0,1833 0,2105 0,3039 0,0045 ... 0,0317 0,0956 0,1321 6 0,1408 0,1674 0,1710 0,0731 0,1401 0,2083 0,3513 0,0201 ... 0,0519 0,0548 0,0842 7 0,0319 0,1158 0,0922 0,1027 0,0613 0,1465 0,2838 0,0081 ... 0,0223 0,0375 0,0484 8 0,0475 0,0647 0,0591 0,0753 0,0098 0,0684 0,1487 0,0145 ... 0,0164 0,0173 0,0347 9 0,0070 0,0187 0,0671 0,1056 0,0697 0,0962 0,0251 0,0090 ... 0,0039 0,0063 0,0152 10 0,0336 0,0310 0,0284 0,0396 0,0272 0,0323 0,0452 0,0062 ... 0,0123 0,0309 0,0169 11 0,0313 0,0358 0,0102 0,0182 0,0579 0,1122 0,0835 0,0133 ... 0,0079 0,0086 0,0055 12 0,0250 0,0344 0,0546 0,0528 0,0958 0,1009 0,1240 0,0176 ... 0,0090 0,0062 0,0253 13 0,0489 0,1197 0,1589 0,1392 0,0987 0,0955 0,1895 0,0059 ... 0,0124 0,0433 0,0604 14 0,0449 0,0597 0,0355 0,0531 0,0343 0,1052 0,2120 0,0083 ... 0,0298 0,0615 0,0650 15 0,0921 0,1615 0,2294 0,2176 0,2033 0,1459 0,0852 0,0031 ... 0,0352 0,0116 0,0191 16 0,0469 0,0737 0,1185 0,1683 0,1541 0,1466 0,2912 0,0346 ... 0,0192 0,0607 0,0378 17 0,0774 0,1388 0,0809 0,0568 0,0219 0,1037 0,1186 0,0331 ... 0,0270 0,0092 0,0145 18 0,0278 0,0412 0,0757 0,1026 0,1138 0,0794 0,1520 0,0084 ... 0,0126 0,0149 0,0641 19 0,1732 0,2565 0,2559 0,2947 0,4110 0,4983 0,5920 0,0092 ... 52

53

54

55

56

57

59 60

58

0,0065 0,0159 0,0072 0 0,0167 0,0180 0,0084 0,0090 0,0032 R 0,0089 0,0048 0,0094 1 0,0191 0,0140 0,0049 0,0052 0,0044 R 0,0166 0,0095 0,0180 2 0,0244 0,0316 0,0164 0,0095 0,0078 R 0,0036 0,0150 0,0085 3 0,0073 0,0050 0,0044 0,0040 0,0117 R 0,0054 0,0105 0,0110 4 0,0015 0,0072 0,0048 0,0107 0,0094 R 0,0014 0,0038 0,0013 5 0,0089 0,0057 0,0027 0,0051 0,0062 R 0,0248 0,0131 0,0070 6 0,0138 0,0092 0,0143 0,0036 0,0103 R 0,0120 0,0045 0,0121 7 0,0097 0,0085 0,0047 0,0048 0,0053 R 0,0128 0,0145 0,0058 8 0,0049 0,0065 0,0093 0,0059 0,0022 R 0,0223 0,0179 0,0084 9 0,0068 0,0032 0,0035 0,0056 0,0040 R 0,0120 0,0052 0,0056 10 0,0093 0,0042 0,0003 0,0053 0,0036 R 0,0265 0,0224 0,0074 11 0,0118 0,0026 0,0092 0,0009 0,0044 R 0,0127 0,0088 0,0098 12 0,0019 0,0059 0,0058 0,0059 0,0032 R 0,0095 0,0194 0,0080 13 0,0152 0,0158 0,0053 0,0189 0,0102 R 0,0057 0,0174 0,0188 14 0,0054 0,0114 0,0196 0,0147 0,0062 R 0,0153 0,0071 0,0212 15 0,0076 0,0152 0,0049 0,0200 0,0073 R 0,0158 0,0154 0,0109 16 0,0048 0,0095 0,0015 0,0073 0,0067 R 0,0131 0,0120 0,0108 17 0,0024 0,0045 0,0037 0,0112 0,0075 R 0,0010 0,0018 0,0068 18 0,0039 0,0120 0,0132 0,0070 0,0088 R 0,0035 0,0098 0,0121 19 0,0006 0,0181 0,0094 0,0116 0,0063 R

Listing 21.8: La salida de la primera pocos filas del conjunto de datos.

Vamos a resumir la distribución de cada atributo. # descripciones, el cambio de precisión a 3 lugares pandas.set_option ( 'precisión'  , 3) impresión (Dataset.describe ())

Listado 21.9: Imprimir las descripciones estadísticas del conjunto de datos.

De nuevo, como se espera, los datos tienen el mismo rango, pero curiosamente di ff Ering valores medios. Puede haber algún beneficio de la estandarización de los datos. 0

1

2

3

4

5

6

7

8

contar con 208.000 2.080e 02 208.000 208.000 + 208.000 208.000 208.000 208.000 208.000 208.000 media 0,029 3.844e-02 0,044 0,054 0,075 0,105 0,122 0,135 std 0,023 3.296e-02 0,038 0,047 0,056 0,059 0,062 0,085 min 0.002 6.000e-04 0,002 0,006 0,007 0,010 0,003 0,005

0,178 0,118 0,007

9\ 0,208 0,134 0,011

148

21.3. Analizar datos 

0,013 1.645e-02 0,019 0,023 3.080e-02 0,034 0,036 4.795e-02 0,058 0,137 2.339e-01 0,306

25% 50% 75%

máx

. . . . . . . . .

contar media

std std min 25% 50% 75%

máx

. . . . . . . . .

. . . . . . . . .

0,024 0,044 0,065 0,426

50

51

0,038 0,062 0,100 0,401 52

0,067 0,092 0,134 0,382 53

0,081 0,107 0,154 0,373 54

0,080 0,112 0,170 0,459 55

0,097 0,152 0,233 0,683

0,111 0,182 0,269 0,711 56 \

208. 208.00 000 0 2.0 2.080 80e e + 02 2.08 2.080e 0e + 02 02 208 208.0 .000 00 2.08 2.080e 0e + 02 02 2.0 2.080 80e e + 02 2.08 2.080e 0e + 02 02 0,016 1. 1.342e-02 1. 1.071e-02 0, 0,011 9. 9.290e-03 8.2 8.22 22e-03 7. 7.820e-03 0,0 0,012 9.63 .634e-0 e-03 7.06 .060e-0 e-03 0,007 ,007 7.0 7.088e-0 8e-03 3 5.73 .736e-0 e-03 5.78 .785e-0 e-03 0.000 8. 8.000e-04 5. 5.000e-04 0, 0,001 6. 6.000e-04 4.0 4.00 00e-04 3. 3.000e-04 0.008 7. 7.275e-03 5. 5.075e-03 0, 0,005 4. 4.150e-03 4.4 4.40 00e-03 3. 3.700e-03 0,014 1. 1.140e-02 9. 9.550e-03 0, 0,009 7. 7.500e-03 6.8 6.85 50e-03 5. 5.950e-03 0.021 1. 1.673e-02 1. 1.490e-02 0, 0,015 1. 1.210e-02 1.0 1.05 58e-02 1. 1.043e-02 0.100 7. 7.090e-02 3. 3.900e-02 0, 0,035 4. 4.470e-02 3.9 3.94 40e-02 3. 3.550e-02

59 Cantidad 2.080e + 02 2.080e + 02 + 02 2.080e significa 7.949e-03 7.941e-03 6.507e-03 std 6.470e-03 6.181e-03 5.031e-03 min 3.000e-04 1,000E-04 6.000e-04 25% 3.600e-03 3.675e-03 3.100e-03 5.800e-03 6.400e-03 5.300e-03 50% 75% 1.035e-02 1.033e-02 8.525e-03 máx 4.400e-02 3.640e-02 4.390e-02 57

58

Listado 21.10: Salida de las descripciones estadísticas del conjunto de datos. Vamos a echar un vistazo rápido a la ruptura de los valores de clase. # dis distri tribuc bución ión de cla clases ses impresión (  Dataset.groupby (60) .size ()) impresión

Añadir 21.11: Imprimir la ruptura de clase del conjunto de datos.

Podemos ver que las clases están equilibradas entre razonablemente M ( minas) y R ( rocas). METRO 111 R

97

Listado 21.12: Salida de la descomposición de clase del conjunto de datos.

21.3.2 unimodales visualizaciones de datos Veamos visualizaciones de atributos individuales. A menudo es útil mirar sus datos utilizando múltiples visualizaciones di ff Erent con el fin de generar ideas. Veamos histogramas de cada atributo para tener una idea de las distribuciones de datos.

# hi hist stog ogra rama mass dataset.hist (sharex = False, Sharey = False, xlabelsize = 1, ylabelsize = 1) plt.show ()

Añadir 21.13: Visualizar el conjunto de datos con histogramas. Podemos ver que hay una gr an cantidad de distribuciones gaussianas similares y tal vez algunas distribuciones exponentiallike para otros atributos.

149

21.3. Analizar datos 

Figura 21.1: Parcelas histograma de atributos del conjunto de datos. Vamos a echar un vistazo a la misma perspectiva de los datos utilizando gráficos de densidad.

# densi sid dad dataset.plot (tipo =  ='  densidad' ,  Subtramas = True, diseño = (8,8), sharex = False, la leyenda = False, tamaño de fuente = 1) plt.show ()

Listado 21.14: Visualizar el conjunto de datos con gráficos de densidad.

Esto es útil, se puede ver que muchos de los atributos tienen una distribución asimétrica. Un poder transformar como un Box-Cox transformación que se puede corregir la asimetría en la distribución podría ser útil.

150

21.3. Analizar datos 

Figura 21.2: gráficos de densidad de atributos del conjunto de datos.

Siempre es bueno mirar caja y bigote parcelas de atributos numéricos para tener una i dea de la extensión de los valores.

# caj caja a y big bigote ote pa parce rcelas las dataset.plot (tipo =  = 'caja' ,  Subtramas = True, diseño = (8,8), sharex = False, Sharey = False, tamaño de fuente = 1) plt.show ()

Añadir 21.15: Visualizar el conjunto de datos con la caja y bigote parcelas. Podemos ver que los atributos tienen bastante di ff diferenciales Erent. Dado que las escalas son el mismo, puede sugerir algún beneficio en la estandarización de los datos para el modelado de obtener todos los medios alineados.

151

21.3. Analizar datos 

Figura 21.3: caja y bigotes Parcelas de atributos del conjunto de datos.

21.3.3 multimodales visualizaciones de datos Vamos a visualizar las correlaciones entre los atributos. # matriz de correlación fig = plt.figure () ax = fig.add_subplot (111) cax = ax.matshow (dataset.corr (), Vmin = -1, vmax = 1, la interpolación = 'ninguna' )  Fig.colorbar (cax) plt.show ()

Añadir 21.16: Visualizar las correlaciones entre atributos. Parece que también hay algún tipo de estructura en el orden de los atributos. El rojo alrededor de la diagonal sugiere que los atributos que están uno al lado del otro en general son más correlacionados entre sí. Las manchas azules también sugieren cierta correlación negativa moderada son los atributos más lejos el uno del otro en el orden. Esto tiene sentido si el orden de los atributos se refiere al ángulo de los sensores para el chirp sonar.

32

5.2. Las dimensiones de sus datos 

impresión   (ojeada) impresión

Listing 5.1: Ejemplo de revisar el primer par de filas de datos. Se puede ver que la primera columna indica el número de la fila, que es muy útil para hacer referencia a una observación específica.

preg clase plas pres piel prueba masa pedi edad 0 72 35 6 148 0 33,6 0,627 50 1 1 85 66 29 0 26,6 0,351 31 2 0 64 8 183 0 23,3 0,672 32 89 66 23 94 28,1 0,167 21 3 1 4 40 0 137 35 168 43,1 2,288 33 74 5 116 0 25,6 0,201 30 5 0 6 3 78 50 32 88 31,0 0,248 26 10 115 0 35,3 0,134 29 7 0 0 8 70 2 197 45 543 30,5 0,158 53 9 0 96 8 125 0 0,0 0.232 54 10 92 4 110 0 37,6 0,191 30 0 0 11 74 10 168 0 38,0 0,537 34 12 80 10 139 0 27,1 1,441 57 0 13 60 1 189 23 846 30,1 0,398 59 14 72 5 166 19 175 25,8 0,587 51 15 7 100 0 30,0 0,484 32 0 0 dieciséis 84 0 118 47 230 45,8 0,551 31 17 74 7 107 0 29,6 0,254 31 0 18 30 38 1 103 83 43,3 0,183 33 19 70 30 1 115 96 34,6 0,529 32

1 0 1 0 1 0 1 0 1 1 0 1 0 1 1 1 1 1 0 1

Listing 5.2: Salida de revisar el primer par de filas de datos.

5.2 Dimensiones de sus datos Debe tener un muy buen control sobre la cantidad de datos que tiene, tanto en términos de filas y columnas.

?? Demasiadas filas y al goritmos pueden tomar mucho tiempo para entrenar. Demasiado pocos y tal vez lo hace

no tiene datos suficientes para entrenar los algoritmos. ?? Demasiado muchas características y algunos algoritmos pueden ser distraídos o debido Do ff er pobre desempeño

a la maldición de la dimensionalidad.

Puede revisar la forma y el tamaño de su base de datos mediante la impresión de la forma propiedad en la trama de datos pandas.

# Las dime dimensi nsione oness de sus sus datos datos importar url = pandas "Https://goo.gl/vhm1eU" nombres = [ ['  Preg'  , '' plas  plas , '' pres  pres , 'piel' 'piel'  , 'prueba' 'prueba'  , 'masa' 'masa'  , 'Pedi' 'Pedi'  , 'años' 'años'  , 'clase' 'clase' ]  Datos = pandas.read_csv (url, nombres = nombres) forma = data.shape impresión  (forma) impresión

Listado 5.3: Ejemplo de revisar la forma de los datos.

21.4. validación del conjunto de datos 

152

Figura 21.4: Parcela de correlaciones entre los atributos del conjunto de datos.

21.4 Validación del conjunto de datos Es una buena idea utilizar un conjunto de retención a cabo la validación. Este es un ejemplo de los datos que tenemos de volver de nuestro análisis y modelado. La usamos la derecha al final de nuestro proyecto para confirmar la exactitud de nuestro modelo final. Es una prueba de humo que podemos utilizar para ver si tenemos mal estado y nos dará la confianza en nuestras estimaciones de exactitud en los datos que no se ven. Vamos a utilizar el 80% del conjunto de datos para el modelado y contener un 20% para su validación.

# Split-cabo la validación de datos [:, 0:60] .astype (array = dataset.values X = array flotador  ) Y = array [:, 60] validation_size = 0,20 semilla = 7 X_train, X_validation, Y_train, Y_validation = cross_validation.train_test_split (X, Y, test_size = validation_size, random_state = semilla)

Añadir 21.17: Crear Formación independiente y la validación de datos.

21.5. Evaluar Algoritmos: Línea de Base 

153

21.5 Evaluar Algoritmos: Línea de Base No sabemos lo que los algoritmos harán bien en este conjunto de datos. el instinto sugiere algoritmos basados distancia como K-vecinos más cercanos y máquinas de vectores soporte pueden hacer bien. Vamos a diseñar nuestro instrumento de prueba. Vamos a utilizar 10 veces la validación cruzada. El conjunto de datos no es demasiado pequeño y este es un buen instrumento de prueba con fi guración estándar. Vamos a evaluar algoritmos mediante el exactitud

métrico. Esta es una medida bruta que le dará una idea rápida de cómo corregir un determinado modelo es. Más útil en los problemas de clasi fi cación binarios como éste. # Opciones de prueba y evaluación métrica num_folds = 10 num_instances = len (X_train) semilla = 7 puntuación = 'exactitud'

Añadir 21.18: Preparar el instrumento de prueba para la evaluación de algoritmos. Vamos a crear una línea de base de rendimiento en este problema y verificación al azar una serie de algoritmos Erent di ff. Vamos a seleccionar un conjunto de algoritmos Erent di ff capaces de trabajar en este problema de clasi fi cación. Los seis algoritmos seleccionados incluyen:

?? Los algoritmos lineales: Regresión logística (LR) y el análisis discriminante lineal (LDA). ?? Los algoritmos no lineales: Clasi fi cación y regresión Trees (CART), Vector Soporte Máquinas (SVM), Gaussian Bayes ingenuo (NB) y K-vecinos más cercanos (KNN). # Inspección al azar Algoritmos modelos = [] models.append (( 'LR' ,  Regresión logística ())) models.append (( '  LDA'  , LinearDiscriminantAnalysis ())) models.append (( 'KNN' ,  KNeighborsClassifier ())) models.append (( 'CARRO' ,  DecisionTreeClassifier ())) models.append (( '  NÓTESE BIEN' , GaussianNB ())) models.append (( '  SVM' ,  SVC ()))

Añadir 21.19: Preparar Algoritmos de evaluar. Los algoritmos de todos los parámetros de ajuste de uso por defecto. Vamos a comparar los algoritmos. Vamos a mostrar la media y la desviación estándar de precisión para cada algoritmo como lo calculamos y recoger los resultados para su uso posterior.

Resultados = [] nombres = [] para nombre, modelo en modelos:

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

Añadir 21.20: Evaluación de Algoritmos Utilizando el instrumento de prueba.

21.5. Evaluar Algoritmos: Línea de Base 

154

Ejecutar el ejemplo proporciona la salida a continuación. Los resultados sugieren que tanto la regresión logística y K-vecinos más cercanos pueden ser más digno de estudio. LR: 0.782721 (0.093796) LDA: 0.746324 (0.117854) KNN: 0.808088 (0.067507) CART: 0.740809 (0.118120) NB: 0.648897 (0.141868) SVM: 0.608824 (0.118656)

Listado 21.21: Salida de Evaluación de Algoritmos. Estos son simplemente significan valores de exactitud. Siempre es conveniente examinar la distribución de los valores de precisión calculados a través de los pliegues de validación cruzada. Podemos hacerlo utilizando gráficamente caja y bigote parcelas.

# Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Listado 21.22: visualización de la distribución del algoritmo de rendimiento. Los resultados muestran una distribución justa para KNN que es alentador, que sugiere una baja varianza. Los malos resultados de SVM son sorprendentes.

21.6. Evaluar Algoritmos: estandarizar los datos 

155

Figura 21.5: cajas y bigotes parcelas de algoritmo de rendimiento. Es posible que la variada distribución de los atributos está teniendo un e ff ect en la precisión de los algoritmos tales como SVM. En la siguiente sección vamos a repetir esta verificación al azar con una copia estandarizada de la formación de datos.

21.6 Evaluar Algoritmos: estandarizar los datos Tenemos la sospecha de que las di stribuciones di ff Ering de los datos en bruto pueden estar afectando negativamente la habilidad de algunos de los algoritmos. Evaluemos los mismos algoritmos con una copia del conjunto de datos normalizado. Aquí es donde los datos se transformado de tal manera que cada atributo tiene un valor medio de cero y una desviación estándar de uno. También es necesario para evitar la pérdida de datos cuando transformamos los datos. Una buena manera de evitar fugas es utilizar tuberías que estandarizan los datos y construir el modelo para cada pliegue en el instrumento de prueba de validación cruzada. De esta manera podemos obtener una estimación razonable de cómo cada modelo con datos estandarizados podría llevar a cabo en los datos que no se ven.

# Estandarizar el conjunto de datos tuberías = [] pipelines.append (( 'ScaledLR' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), (  'LR' ,  Regresión logística ())]))) pipelines.append (( 'ScaledLDA' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  LDA' ,  LinearDiscriminantAnalysis ())])))

21.6. Evaluar Algoritmos: estandarizar los datos 

156

pipelines.append (( 'ScaledKNN' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  KNN' ,  KNeighborsClassifier ())]))) pipelines.append (( '  ScaledCART'  , Pipeline ([( 'Escalador' ,  StandardScaler ()), ( '  CARRO' ,  DecisionTreeClassifier ())]))) pipelines.append (( '  ScaledNB' ,  Pipeline ([( '  Escalador'  , StandardScaler ()), ( 'NÓTESE BIEN' ,  GaussianNB ())]))) pipelines.append (( '  ScaledSVM' ,  Pipeline ([( '  Escalador' ,  StandardScaler ()), ( '  SVM'  , SVC ())]))) resultados = [] nombres = []

para nombre, modelo en tuberías: kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

Añadir 21.23: Evaluación de Algoritmos en un conjunto de datos a escala.

Ejecutar el ejemplo proporciona los resultados se indican a continuación. Podemos ver que KNN todavía está haciendo bien, incluso mejor que antes. También podemos ver que la estandarización de los datos ha levantado la habilidad de SVM ser el algoritmo más preciso probado hasta ahora. ScaledLR: 0.734191 (0.095885) ScaledLDA: 0.746324 (0.117854) ScaledKNN: 0.825735 (0.054511) ScaledCART: 0.711765 (0.107567) ScaledNB: 0.648897 (0.141868) ScaledSVM: 0.836397 (0.088697)

Añadir 21.24: Salida de la evaluación de algoritmos en el conjunto de datos a escala. Una vez más, debemos trazar la distribución de las puntuaciones de exactitud utilizando caja y bigote parcelas. # Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Scaled algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Añadir 21.25: visualización de la distribución del algoritmo de rendimiento en el conjunto de datos a escala.

Los resultados sugieren investigar más profundamente en la SVM y algoritmos KNN. Es muy probable que con fi guración más allá del defecto puede producir modelos más precisos.

Capítulo 6 Entender sus datos con la visualización

Usted debe entender sus datos con el fin de obtener los mejores resultados de algoritmos de aprendizaje automático. La forma más rápida de aprender más sobre sus datos es utilizar la visualización de datos. En este capítulo usted descubrirá exactamente cómo se puede visualizar los datos de aprendizaje automático en Python usando pandas. Recetas de este capítulo utilizan la aparición de la diabetes indios Pima conjunto de datos presentado en el capítulo 4  . Empecemos.

6.1 Parcelas univariados En esta sección vamos a ver tres técnicas que se pueden utilizar para comprender cada atributo del conjunto de datos de forma independiente. ?? Histogramas. ?? Parcelas densidad.

?? Cajas y bigotes parcelas.

6.1.1 Los histogramas Una manera rápida de obtener una idea de la distribución de cada atributo es mirar histogramas. los datos del grupo histogramas en los contenedores y que proporcionan un recuento del número de observaciones en cada bandeja. De la forma de los contenedores se puede obtener rápidamente una idea de si un atributo es gaussiana, sesgada o incluso tiene una distribución exponencial. También puede ayudar a ver los posibles valores atípicos. # Los histogramas univariado importar matplotlib.pyplot como PLT importar url = pandas "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Datos = pandas.read_csv (URL, nombres = nombres) data.hist () plt.show ()

Listado 6.1: Ejemplo de creación de parcelas de histograma.

38

21.7. algoritmo de optimización 

157

Figura 21.6: cajas y bigotes parcelas de algoritmo de rendimiento en el conjunto de datos estandarizado.

21.7 Algoritmo de sintonización En esta sección, hemos investigado el ajuste de los parámetros para dos algoritmos que parecen ser prometedores desde el punto de comprobación en la sección anterior: KNN y SVM.

21.7.1 Ajuste KNN Podemos empezar o FF sintonizando el número de vecinos para KNN. El número predeterminado de vecinos es 7. A continuación tratamos todos los valores impares de K del 1 al 21, que cubre el valor predeterminado de 7. Cada K valor se evalúa usando 10 veces la validación cruzada en la formación de datos estandarizado. escalador = StandardScaler (). ajuste (X_train) rescaledX = scaler.transform (X_train) v ecinos = [1,3,5,7,9,11,13,15,17,19,21] param_grid = dict (N_neighbors = vecinos) Modelo = KNeighborsClassifier () kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) de rejilla = GridSearchCV (estimador = modelo, param_grid = param_grid, puntuación = puntuación, cv = kfold) grid_result = grid.fit (rescaledX, Y_train) impresión ( "  Best:% f utilizando% s" % (Grid_result.best_score_, grid_result.best_params_)) para params, mean_score, puntuaciones en grid_result.grid_scores_:

21.7. algoritmo de optimización 

158

impresión (  "% F (% f) con:% r" % (Scores.mean (), scores.std (), params))

Añadir 21.26: Sintonice el algoritmo KNN en el conjunto de datos a escala.

Podemos imprimir con fi guración que dio lugar a la más alta precisión, así como la exactitud de todos los valores probados. Ejecutar el ejemplo vemos los resultados de abajo. Mejor: 0.849398 usando { '' n_neighbors: 1} 0.850000 (0.059686) con: { 'n_neighbors': 1} 0.837132 (0.066014) con: { 'n_neighbors': 3} 0.837500 (0.037377) con: { ' ' n_neighbors: 5} 0.763971 (0.089374) con: { ' ' n_neighbors: 7} 0.751471 (0.087051) con: { ' ' n_neighbors: 9} 0.733456 (0.104831) con: { '' n_neighbors: 11} 0.733088 (0.105806) con: { 'n_neighbors': 13} 0.727941 (0.076148) con: { '' n_neighbors: 15} 0.709926 (0.079287) con: { 'n_neighbors': 17} 0.722059 (0.085088) con: { 'n_neighbors': 19} 0.710294 (0.109505) con: { '' n_neighbors: 21}

Añadir 21.27: Resultados de Tuning KNN en el conjunto de datos a escala.

Podemos ver que la configuración óptima es con fi K = 1. Esto es interesante como el algoritmo hará predicciones usando el ejemplo más similar en el conjunto de datos de entrenamiento solo.

21.7.2 Ajuste SVM Podemos ajustar dos parámetros clave del algoritmo SVM, el valor de C ( el grado de relajación del margen) y el tipo de núcleo. El valor predeterminado para SVM (la clase SVC) es utilizar el kernel Función de base radial (RBF) con una do valor ajustado a 1,0. Al igual que con KNN, vamos a realizar una búsqueda cuadrícula utilizando 10 veces la validación cruzada con una copia estandarizada de la formación de datos. Vamos a tratar una serie de simples núcleo tipos y do valores con menos prejuicios y más sesgo (menos de y más de 1,0 respectivamente).

# Tune escala SVM escalador = StandardScaler (). caber (X_train) rescaledX = scaler.transform (X_train) c_values = [0,1, 0,3, 0,5, 0,7, 0,9, 1,0, 1,3, 1,5, 1,7, 2,0] kernel_values = [ 'lineal'  , 'escuela politécnica' , 'RBF' , 'sigmoideo' ] Param_grid = dict (C = c_values, kernel = kernel_values) Modelo = SVC ()

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) de rejilla = GridSearchCV (estimador = modelo, param_grid = param_grid, puntuación = puntuación, cv = kfold) grid_result = grid.fit (rescaledX, Y_train) impresión ( "  Best:% f utilizando% s" % (Grid_result.best_score_, grid_result.best_params_)) para params, mean_score, puntuaciones en grid_result.grid_scores_: impresión (  "% F (% f) con:% r" % (Scores.mean (), scores.std (), params))

Añadir 21.28: Tune la SVM algoritmo en el conjunto de datos a escala.

Ejecutar el ejemplo imprime la mejor con fi guración, la precisión, así como la precisión para todas las combinaciones con fi guración. Mejor: 0.867470 usando { 'núcleo': 'RBF', 'C': 1,5}

21.8. Métodos Ensemble 

159

0.758456 (0.099483) con: { ' kernel': 'lineal', 'C': 0,1} 0.529412 (0.118825) con: { ' kernel': 'poli', 'C': 0,1} 0.573162 (0.130930) con: { ' kernel': 'rbf', 'C': 0,1} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 0,1} 0.746324 (0.109507) con: { ' kernel': 'lineal', 'C': 0,3} 0.642647 (0.132187) con: { ' kernel': 'poli', 'C': 0,3} 0.765809 (0.091692) con: { ' kernel': 'rbf', 'C': 0,3} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 0,3} 0.740074 (0.082636) con: { ' kernel': 'lineal', 'C': 0,5} 0.680147 (0.098595) con: { ' kernel': 'poli', 'C': 0,5} 0.788235 (0.064190) con: { ' kernel': 'rbf', 'C': 0,5} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 0,5} 0.746691 (0.084198) con: { ' kernel': 'lineal', 'C': 0,7} 0.740074 (0.127908) con: { ' kernel': 'poli', 'C': 0,7} 0.812500 (0.085513) con: { ' kernel': 'rbf', 'C': 0,7} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 0,7} 0.758824 (0.096520) con: { ' kernel': 'lineal', 'C': 0,9} 0.770221 (0.102510) con: { ' kernel': 'poli', 'C': 0,9} 0.836397 (0.088697) con: { ' kernel': 'rbf', 'C': 0,9} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 0,9} 0.752574 (0.098883) con: { ' kernel': 'lineal', 'C': 1,0} 0.788235 (0.108418) con: { ' kernel': 'poli', 'C': 1,0} 0.836397 (0.088697) con: { ' kernel': 'rbf', 'C': 1,0} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 1,0} 0.769853 (0.106086) con: { ' kernel': 'lineal', 'C': 1,3} 0.818382 (0.107151) con: { ' kernel': 'poli', 'C': 1,3} 0.848162 (0.080414) con: { ' kernel': 'rbf', 'C': 1,3} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 1,3} 0.758088 (0.092026) con: { ' kernel': 'lineal', 'C': 1,5} 0.830147 (0.110255) con: { ' kernel': 'poli', 'C': 1,5} 0.866176 (0.091458) con: { ' kernel': 'rbf', 'C': 1,5} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 1,5} 0.746324 (0.090414) con: { ' kernel': 'lineal', 'C': 1,7} 0.830515 (0.116706) con: { ' kernel': 'poli', 'C': 1,7} 0.860294 (0.088281) con: { ' kernel': 'rbf', 'C': 1,7} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 1,7} 0.758456 (0.094064) con: { ' kernel': 'lineal', 'C': 2,0} 0.830882 (0.108950) con: { ' kernel': 'poli', 'C': 2,0} 0.866176 (0.095166) con: { ' kernel': 'rbf', 'C': 2,0} 0.409559 (0.073625) con: { ' kernel': 'sigmoide', 'C': 2,0}

Añadir 21.29: Resultados de Tuning SVM en el conjunto de datos a escala.

Podemos ver la información más precisa con fi guración fue SVM con un RBF núcleo y una do valor de

1.5. La precisión 86,7470% es aparentemente mejor que lo que podría lograr KNN.

21.8 Métodos Ensemble Otra forma en que podemos mejorar el rendimiento de los algoritmos de este problema es mediante el uso de métodos de conjunto. En esta sección vamos a evaluar cuatro di algoritmos de aprendizaje automático conjunto ff Erent, dos impulsar y dos métodos de ensacado:

?? Impulsar Métodos: AdaBoost (AB) y el gradiente Impulso (GBM).

160

21.8. Métodos Ensemble 

?? Métodos ensacado: Random Forests (RF) y árboles adicionales (ET). Vamos a utilizar el mismo instrumento de prueba como la validación cruzada antes, 10 veces. Sin la normalización de datos se utiliza en este caso porque los cuatro algoritmos se basan en conjuntos de árboles de decisión que son menos sensibles a las distribuciones de datos.

# conjuntos conjuntos = [] ensembles.append (( 'AB' ,  AdaBoostClassifier ())) ensembles.append (( '  GBM' , GradientBoostingClassifier ())) ensembles.append (( 'RF' ,  RandomForestClassifier ())) ensembles.append (( 'ET' ,  ExtraTreesClassifier ())) Resultados = [] nombres = []

para nombre, modelo en Formación:

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X_train, Y_train, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

Añadir 21.30: Evaluar Ensemble algoritmos. Ejecutar el ejemplo proporciona las siguientes puntuaciones de exactitud. AB: 0.819853 (0.058293) GBM: 0.829044 (0.143517) RF: 0.765074 (0.107129) ET: 0.794485 (0.087874)

Listado 21.31: Salida de Evaluar Algoritmos Ensemble. Podemos ver que las dos técnicas proporcionan fuertes impulsar las puntuaciones de exactitud en los años 80 bajos (%) con fi guraciones por defecto. Podemos representar gráficamente la distribución de las puntuaciones de precisión a través de los pliegues de validación cruzada.

# Comparación de algoritmos fig = plt.figure () fig.suptitle ( 'Ensemble algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Añadir 21.32: visualizar la distribución del conjunto algoritmo de rendimiento. Los resultados sugieren GBM puede ser digno de más estudios, con una media fuerte y un diferencial que sesga hacia 90s alto (%) en la precisión.

43

6.2. Parcelas multivariantes 

Figura 6.4: Diagrama de matriz de correlación.

El ejemplo no es genérico en el que se especi fi ca los nombres de los atributos a lo largo de los ejes, así como el número de garrapatas. Esta receta cam hacerse más genérico mediante la eliminación de estos aspectos de la siguiente manera:

# Matriz de corrección de la parcela (genérico) importar matplotlib.pyplot como PLT importar pandas importar url = numpy "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Datos = pandas.read_csv (URL, nombres = nombres) correlaciones = data.corr () # matriz de correlación trama fig = plt.figure () ax = fig.add_subplot (111) cax = ax.matshow (correlaciones, Vmin = -1, vmax = 1) fig.colorbar (cax) plt.show ()

Listado 6.5: Ejemplo de creación de una parcela matriz de c orrelación genérica.

La generación de la trama, se puede ver que se da la misma información a pesar de lo que es un poco más difícil de ver qué atributos se correlacionan por su nombre. Utilice esta parcela genérica como un primer corte

161

21.9. finalizar Modelo 

Figura 21.7: cajas y bigotes parcelas de interpretación de conjunto.

21.9 Finalizar Modelo La SVM mostró la mayor promesa como una complejidad baja y el modelo estable para este problema. En esta sección vamos a fi nalizar el modelo mediante la formación en el conjunto de datos de entrenamiento y hacer predicciones para el conjunto de datos de validación de retención a cabo para confirmar nuestros hallazgos. Una parte de los hallazgos fue que SVM funciona mejor cuando el conjunto de datos está estandarizada para que todos los atributos tienen un valor medio de cero y una desviación estándar de uno. Podemos calcular esto desde todo el conjunto de datos de entrenamiento y aplicar la misma transformación a los atributos de la entrada de la validación de datos.

# preparar el modelo escalador = StandardScaler (). ajuste del modelo (X_train) rescaledX = scaler.transform (X_train) = SVC (C = 1,5) model.fit (rescaledX, Y_train) # estimar la precisión en la validación de datos rescaledValidationX = scaler.transform (X_validation) predicciones = model.predict (rescaledValidationX) impresión (Accuracy_score (Y_validation, predicciones)) impresión (Confusion_matrix (Y_validation, predicciones)) impresión (Classification_report (Y_validation, predicciones))

Listado 21.33: Evaluar SVM en el conjunto de datos de validación.

162

21.10. Resumen 

Podemos ver que logramos una precisión de casi el 86% en el conjunto de datos de validación que mantiene de salida. Una puntuación que se acerque a nuestras expectativas estimadas anteriormente durante la puesta a punto de SVM.

,857142857143 [[23 4] [2 13]]

apoyo f1-score recuerdo de precisión METRO R

avg / Total

0.92 0,76

0.85 0.87

0.88 0,81

27 15

0.86

0.86

0.86

42

Listado 21.34: Salida de Evaluación de SVM en el conjunto de datos de validación.

21.10 Resumen En este capítulo se ha trabajado a través de un fi cación problema de aprendizaje máquina de modelado predictivo clasificación de extremo a extremo utilizando Python. Específicamente, los pasos tratados fueron:

?? Problema De fi nición (Sonar de datos de retorno). ?? Carga del conjunto de datos.

?? Analizar los datos (misma escala, pero las distribuciones di ff Erent de datos).

?? Evaluar Algoritmos (KNN se veía bien). ?? Evaluar Algoritmos con Normalización (KNN y SVM se veía bien). ?? Algoritmo de sintonía ( K = 1 para KNN era bueno, SVM con un núcleo RBF y C = 1,5 estaba mejor).

?? Métodos Ensemble (embolsado e impulsar, no es tan bueno como SVM). ?? Finalizar Modelo (utilizar todos los datos de entrenamiento y confirman utilizando validación de datos).

Trabajando a través de este estudio de caso se mostró cómo las recetas para las tareas de aprendizaje automático fi cas se pueden juntar en un proyecto completo. Trabajando a través de este estudio de caso es una buena práctica en el aprendizaje automático aplicado usando Python.

21.10.1 Siguiente Paso Este fue el tercer y fi estudio de caso de proyectos de modelado predictivo final. ¡Bien hecho! Ahora tiene la experiencia y habilidades en el trabajo a través de proyectos de aprendizaje de máquina de modelado predictivo de extremo a extremo. En la siguiente sección usted descubrirá ideas para pequeños proyectos de estudios de casos adicionales que se podía trabajar durante más práctica.

capítulo 22 Más proyectos de modelado predictivo Ahora puede trabajar a través de proyectos de aprendizaje de máquina de modelado predictivo utilizando Python. ¿Ahora que? En este capítulo, nos fijamos en formas que se pueden practicar y refinar sus nuevas habilidades.

22.1 construir y mantener Recetas A lo largo de este libro que ha trabajado a través de muchas clases de aprendizaje automático utilizando Python. En su conjunto, este es el comienzo de su propia base de código privado que se puede utilizar para poner en marcha su proyecto de aprendizaje de máquina actual o siguiente. Estas recetas son un comienzo, no un fin. El más grande y más sofisticado que su catálogo de la máquina de aprendizaje se convierte en recetas, más rápido se puede empezar a trabajar en nuevos proyectos y más precisos serán los modelos que se pueden desarrollar.

A medida que aplica sus habilidades de aprendizaje automático utilizando la plataforma de Python, que se desarrollará la experiencia y habilidades con las nuevas técnicas y di ff Erent con Python. Se puede sacar o fragmentos abstractos y recetas a medida que avanza y añadirlos a su propia colección de recetas, basándose en el código que se puede utilizar en proyectos futuros de aprendizaje automático. Con el tiempo, va a amasar su propio catálogo maduro y altamente adaptada de código de aprendizaje automático para Python.

22.2 Pequeños Proyectos en conjuntos de datos pequeños Seguir practicando sus habilidades usando Python. Conjuntos de datos del repositorio UCI Machine Learning

 1

se utilizaron en este libro para demostrar cómo lograr tareas especí fi cas en un proyecto de aprendizaje automático. También fueron utilizados en los proyectos de estudio de caso más largos. Ellos están estandarizados, relativamente limpio, bien entendido y excelente para su uso como práctica conjuntos de datos. Se pueden utilizar los conjuntos de datos en el repositorio UCI Machine Learning como el foco de pequeños (5-a-10 horas de correo ff ORT) centrado proyectos de aprendizaje automático utilizando la plataforma de Python. Una vez completado, se puede escribir de seguridad de sus hallazgos y compartirlos en línea como parte de su cartera en expansión de los proyectos de aprendizaje automático.

Estos pueden ser usados por los que más tarde como un depósito de conocimiento sobre la que se puede construir y desarrollar aún más sus habilidades. También se pueden utilizar para demostrar a los gerentes o futuros empleadores que usted es capaz de entregar resultados en proyectos de aprendizaje de máquina de modelado predictivo utilizando la plataforma de Python. Aquí es un proceso que se puede utilizar para practicar el aprendizaje de máquina en Python:

  ttp://archive.ics.uci.edu/ml/ 1h

163

164

22.3. Máquina de aprendizaje competitivo 

1. Examine la lista de conjuntos de datos libres en el repositorio y descargar algunas que te parezcan interesantes.

2. Utilice la plantilla y recetas de proyectos en este libro para trabajar a tr avés del conjunto de datos y desarrollar un modelo preciso.

3. Escriba sus conclusiones de obra OW y fi fl de una manera que se puede hacer referencia a ellos más tarde o quizás compartirlo públicamente en un sitio web.

Mantener el proyecto a corto, limite sus proyectos a 5-a-10 horas, se decir una semana pena de noches y el tiempo libre.

22.3 Máquina de aprendizaje competitivo Utilizar la máquina de aprendizaje competitivo para impulsar sus habilidades. Trabajando en pequeños proyectos en la sección anterior es una buena manera de practicar los fundamentos. En algún momento los problemas llegarán a ser fácil para usted. También es necesario ser empujado fuera de su zona de confort para ayudarle a crecer aún más sus habilidades.

Una excelente manera de desarrollar sus habilidades de aprendizaje automático con Python es más para comenzar a participar en las competiciones. En una competición, el organizador le proporciona un conjunto de datos de entrenamiento, un conjunto de datos de prueba en el que está para hacer predicciones, una medida de rendimiento y un límite de tiempo. Usted y sus competidores continuación, trabajar para crear el modelo más preciso posible. Los ganadores consiguen a menudo dinero del premio.

Estas competiciones a menudo duran semanas o meses y puede ser muy divertido. También O ff er una gran oportunidad para poner a prueba sus habilidades con herramientas de aprendizaje automático en conjuntos de datos que a menudo requieren una gran cantidad de limpieza y preparación. El primer sitio Web para las competiciones de aprendizaje automático es Kaggle

 2  .

Los concursos son estratificación fi cado en clases Erent di ff tales como la investigación, el reclutamiento y 101 para los principiantes. Un buen punto de partida sería la competición para principiantes ya que a menudo son menos desafiante y tienen un montón de ayuda en forma de tutoriales para empezar.

22.4 Resumen En este capítulo se han descubierto tres áreas donde se puede practicar sus nuevas habilidades de aprendizaje automático se encuentran con Python. Ellos eran:

1. Continuar para construir y mantener su catálogo de recetas máquina de aprendizaje empezando por el catálogo de recetas proporcionadas como un bono con este libro. 2. Continuar trabajando en las bases de datos estándar de aprendizaje automático en la UCI Machine Learning Repositorio.

3. Para iniciar el trabajo a través de los grandes conjuntos de datos de la máquina de aprendizaje competitivo e incluso de comenzar a participar en las competiciones de aprendizaje automático.

  ttps://www.kaggle.com 2h

22.4. Resumen 

22.4.1 Paso siguiente Esto concluye la Parte III de este libro en proyectos de aprendizaje automático. Lo siguiente que fi nal o FF el libro con un resumen de lo lejos que han llegado y donde se puede mirar si necesita ayuda adicional con Python.

165

parte IV conclusiones

166

capítulo 23 ¿Cómo lejos que han llegado Lo hiciste. Bien hecho. Tome un momento y mirar hacia atrás en lo lejos que han llegado.

1. Usted comenzó O ff con un interés en el aprendizaje automático y un fuerte deseo de ser capaz de practicar y aplicar el aprendizaje automático usando Python.

2. Usted ha descargado, instalado y puesto en Python, tal vez por el tiempo primero, y comenzó a familiarizarse con la sintaxis de la lengua y el ecosistema SciPy. 3. Poco a poco y de manera constante a lo largo de una serie de lecciones ha aprendido las tareas estándar de una máquina de modelado predictivo mapa del proyecto de aprendizaje en la plataforma Python. 4. Sobre la base de las recetas para las tareas de aprendizaje automático comunes que trabajó a través de sus primeros problemas de aprendizaje automático de extremo a extremo utilizando Python.

5. El uso de una plantilla estándar, las recetas y experiencias que se han reunido, que ahora está en condiciones de trabajar a través de nuevas y di ff Erent predictivos problemas de aprendizaje de máquina de modelado por su cuenta.

No hacer la luz de esto. Usted ha recorrido un largo camino en un corto periodo de tiempo. Usted ha desarrollado la habilidad importante y valiosa de ser capaz de trabajar a través de problemas de aprendizaje automático de extremo a extremo utilizando Python. Se trata de una plataforma que se utiliza por la mayoría de los profesionales que trabajan científico de datos. El cielo es el límite para usted.

Quiero tomar un momento y sinceramente las gracias por permitirme ayudarle a iniciar su viaje de aprendizaje de máquina con Python. Espero que seguir aprendiendo y divertirse a medida que continúe a dominar la máquina de aprendizaje.

167

51

7.7. Resumen 

importar url = numpy "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] trama de datos = pandas.read_csv (URL, nombres = nombres) Array = dataframe.values # array separado en componentes de entrada y salida X = array [:, 0: 8] Y = array [:, 8] binarizer = Binarizer (umbral = 0,0) .fit (X) binaryX = binarizer.transform (X) # resumir datos transformados numpy.set_printoptions (precisión = 3) impresión (BinaryX [0: 5 ,:])

Listado 7.7: Ejemplo de datos de binarización. Se puede ver que todos los valores son iguales o inferiores a 0 están marcados 0 y todos los de arriba están marcados 0 1.

[[1. 1. 1. 1. 0. 1. 1. 1.] [1. 1. 1. 1. 0. 1. 1. 1.] [ 1. 1. 1. 0. 0. 1. 1. 1.] [1. 1. 1. 1. 1. 1. 1. 1.] [0. 1. 1. 1. 1. 1. 1. 1.]]

Listing 7.8: Salida de los datos de la normalización.

7.7 Resumen En este capítulo has descubierto cómo se pueden preparar los datos para el aprendizaje de máquina en Python usando scikit-learn. Ahora tiene recetas para: ?? Cambiar la escala de los datos.

?? Estandarizar los datos. ?? Normalizar los datos. ?? los datos de binarización.

7.7.1 Siguiente Ahora ya sabe cómo transformar sus datos para exponer mejor la estructura del problema a los algoritmos de modelado. En la siguiente lección usted descubrirá cómo seleccionar las características de los datos que son más relevantes para hacer predicciones.

capítulo 24 Obtener más ayuda Esto es sólo el comienzo de su viaje de aprendizaje de máquina con Python. A medida que comience a trabajar en sus propios proyectos de aprendizaje automático que puede necesitar ayuda. En este capítulo se señalan algunas de las mejores fuentes de Python y ayuda de aprendizaje automático que se puede hallar.

24.1 Recomendaciones generales En general, la documentación de Python y la pila SciPy es excelente. Hay una buena mezcla de guías de usuario y documentación de la API. Le aconsejo que lea la documentación de la API para las clases y funciones que está utilizando, ahora que ya sabe qué clases y funciones para su uso. La documentación de la API le dará una comprensión más completa de la más profunda con fi guración que se puede explorar para servir a sus intereses de mejores modelos de rendimiento.

Otros son recursos invaluables Preguntas y Respuestas sitios como StackOver flujo  1  . P   uede buscar mens ajes de error y los problemas que están teniendo y código de ejemplo fi nd e ideas que le ayudarán directamente. También hacer uso de la  Relacionado puestos en el lado derecho de la pantalla, ya que le puede guiar a los mensajes relacionados y tal vez igual de votos.

24.2 Ayuda con Python Python es un lenguaje de programación con todas las funciones. Por lo tanto, cuanto más se aprende sobre él, mejor que se puede utilizar. Si usted es relativamente nuevo en la plataforma Python aquí hay algunos recursos valiosos para ir un paso más profundo:

?? Clase Python Google.

https://developers.google.com/edu/python/ ?? HOWTOs pitón, de valor incalculable para los idiomas de aprendizaje y tal (Python 2).

https://docs.python.org/2/howto/index.html ?? Python Standard Reference Library (Python 2). https://docs.python.org/2/library/index.html 1h   ttp://StackOverflow.com

168

24.3. Ayuda para SciPy y NumPy 

169

24.3 Ayuda con SciPy y NumPy Es una gran idea para familiarizarse con el ecosistema más amplio SciPy y por eso lo recomiendo las notas de la conferencia SciPy se enumeran a continuación. Creo que la documentación NumPy es excelente (y profundo) pero es probable que no lo necesitan, a menos que usted está haciendo algo exótico.

?? Lecture Notes SciPy.

http://www.scipy-lectures.org/ ?? Guía del usuario NumPy.

http://docs.scipy.org/doc/numpy/user/

24.4 Ayuda con Matplotlib Ser bueno en el trazado. Con fi mella hasta el punto de que se puede copiar y pegar una receta para trazar los datos en la caída de un sombrero. Es una habilidad invaluable. Creo que se le sirve mejor mirando un montón de ejemplos de tipos de gráficos matplotlib di ff Erent y la preparación de recetas para que se utilice más adelante. Haciendo parcelas bonitas es un tema Erent di ff por completo y por eso lo recomiendo estudiar cuidadosamente la API. Veo parcelas como herramientas desechables para aprender más acerca de un problema.

?? Galería matplotlib de tipos de gráficos y código de ejemplo.

http://matplotlib.org/gallery.html ?? Guía de principiantes matplotlib.

http://matplotlib.org/users/beginner.html ?? Matplotlib Referencia de API.

http://matplotlib.org/api/index.html

24.5 Ayuda con las pandas Hay una gran cantidad de documentación para las pandas, creo que debido a que es una herramienta flexible, tales fl. En general, los ejemplos de libros de cocina serán más útiles para usted aquí, ya que le dará ideas sobre maneras di ff Erent a segmentar los datos.

?? pandas página de documentación (guía del usuario). Tenga en cuenta la tabla de contenidos de la izquierda,

es muy extensa. http://pandas.pydata.org/pandas-docs/stable/ ?? Pandas libro de cocina que proporciona muchos ejemplos corto y dulce.

http://pandas.pydata.org/pandas-docs/stable/cookbook.html ?? Pandas Referencia API.

http://pandas.pydata.org/pandas-docs/stable/api.html

8.4. Análisis de componentes principales 

54

(atributos y combinación de atributos) la que más contribuyen a predecir el atributo de destino. Usted puede aprender más acerca de la RFE clase  3 en el scikit-learn documentación. El ejemplo siguiente utiliza RFE con el algoritmo de regresión logística para seleccionar los 3 mejores características. La elección del algoritmo no importa demasiado, ya que siempre que sea hábil y consistente. # Extracción de características con RFE de pandas importar read_csv de sklearn.feature_selection importar RFE de sklearn.linear_model importar Regresión logística # Cargar datos url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

# extracción de características Modelo = regresión logística () rfe = RFE (modelo, 3) ajuste = rfe.fit (X, Y) impresión ( "  Num Características:% d" )  % Fit.n_features_  impresión ( "  Características seleccionados:% s" )  % Fit.support_  impresión ( "  Característica Ranking:% s" )  % Fit.ranking_ 

Listado 8.3: Ejemplo de selección de características RFE. Se puede ver que RFE eligió los 3 mejores características como preg, la masa y pedicura. Estos están marcados

Cierto en el apoyo matriz y marcado con una opción 1 en el clasificación formación. Una vez más, puede asignar manualmente los índices de función a los índices de nombres de atributos. Num Características: 3

Características seleccionados: [Verdadero Falso Falso Falso Falso Verdadero Verdadero Falso] Característica de clasificación: [1 2 3 5 6 1 1 4]

Listado 8.4: Salida de la selección de características RFE.

8.4 Análisis de Componentes Principales Análisis de Componentes Principales (PCA o) utiliza álgebra lineal para transformar el conjunto de datos en una forma comprimida. En general, esto se llama una técnica de reducción de datos. Una propiedad de la ACP es que se puede elegir el número de dimensiones o componentes principales en el resultado transformado. En el siguiente ejemplo, se utiliza PCA y seleccione 3 componentes principales. Más información sobre el PCA clase en scikit-learn mediante la revisión de la API  4  . # Extracción de características con ACP importar numpy

de pandas importar read_csv de sklearn.decomposition importar PCA # Cargar datos url = "Https://goo.gl/vhm1eU" 3 http://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.RFE.html# sklearn.feature_selection.RFE

4

http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html

55

8.5. Importancia de funciones 

nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

# extracción de características PCA = PCA (n_components = 3) ajuste = pca.fit (X) # sintetizar componentes impresión ( "  Varianza explicada:% s" )  % Fit.explained_variance_ratio_  impresión (Fit.components_)

Listing 8.5: Ejemplo de PCA extracción de caracterís ticas.

Se puede ver que el conjunto de datos transformado (3 componentes principales) dio a luz poco parecido con los datos de origen.

Varianza explicada: [0.88854663 0.06159078 0.02579012] [[-2.02176587e-03 9.78115765e-02 1.60930503e-02 6.07566861e-02 9.93110844e-01 1.40108085e-02 5.37167919e-04 -3.56474430e-03] [2.26488861e-02 9.72210040e-01 1.41909330e-01 -5.78614699e-02 - 9.46266913e-02 4.69729766e-02 8.16804621e-04 1.40168181e-01] [-2.24649003e-02 1.43428710e-01 -9.22467192e-01 -3.07013055e-01 2.09773019e-02 -1.32444542e-01 -6.39983017e-04 -1.25454310e-01]]

Listado 8.6: Salida del PCA extracción de características.

Importancia 8.5 Característica árboles de decisión en bolsas como Random Forest y árboles adicionales pueden ser utilizados para estimar la importancia de las características. En el siguiente ejemplo se construye una ExtraTreesClassifier clasi fi cador de la aparición de la diabetes indios Pima conjunto de datos. Usted puede aprender más acerca de la ExtraTreesClassifier clase  5

en el scikit-learn API. # Importancia característica adicional con árboles clasificador  de pandas importar read_csv de sklearn.ensemble importar ExtraTreesClassifier  # Cargar datos url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

# extracción de características Modelo = ExtraTreesClassifier () model.fit (X, Y) impresión(Model.feature_importances_)

Listado 8.7: Ejemplo de función de importancia. 5 http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier. html

56

8.6. Resumen 

Se puede ver que se nos da una puntuación de importancia para cada atributo en el que el mayor sea la puntuación, más importante atributo. Los resultados sugieren la importancia de plas, edad y masa. [0.11070069 0.2213717 0.08824115 0.08068703 0.07281761 0.14548537 0.12654214 0.15415431]

Listado 8.8: Salida de la función de importancia.

8.6 Resumen En este capítulo se descubrió la selección de características para la preparación de los datos de aprendizaje automático en Python con scikit-learn. Usted aprendió técnicas de selección de función automática de alrededor de 4 di ff Erent:

?? Selección univariado. ?? Función recursiva de eliminación. ?? Análisis de componentes principales.

?? Importancia función.

8.6.1 Siguiente Ahora es el momento de empezar a buscar en la forma de evaluar los algoritmos de aprendizaje automático en el conjunto de datos. En la si guiente lección usted descubrirá métodos de remuestreo que se pueden utilizar para estimar el rendimiento de un algoritmo de aprendizaje automático en los datos que no se ven.

Capítulo 9 Evaluar el desempeño de la máquina algoritmos de aprendizaje con remuestreo Usted necesita saber qué tan bien sus algoritmos realizan en los datos que no se ven. La mejor manera de evaluar el desempeño de un algoritmo sería hacer predicciones para los nuevos datos a los que ya conoce las respuestas. La segunda mejor manera es utilizar técnicas inteligentes de las estadísticas llamados métodos de remuestreo que le permiten realizar estimaciones precisas de lo bien que su algoritmo llevará a cabo en los nuevos datos. En este capítulo usted descubrirá cómo se puede estimar la precisión de los algoritmos de aprendizaje automático utilizando métodos de remuestreo en Python y scikit-learn en el conjunto de datos indios Pima. Empecemos.

9.1 Evaluar los algoritmos de aprendizaje de máquinas ¿Por qué no se puede entrenar a su algoritmo de aprendizaje automático en el conjunto de datos y el uso de las predicciones de este mismo conjunto de datos para evaluar algoritmos de aprendizaje automático? La respuesta simple es más fi tting.

Imagínese un algoritmo que recuerda cada observación se muestra durante el entrenamiento. Si usted evaluó el algoritmo de aprendizaje automático en el mismo conjunto de datos utilizados para entrenar el algoritmo, entonces un algoritmo como éste tendría una puntuación perfecta en la formación de datos. Pero las predicciones que hizo en los nuevos datos serían terribles. Debemos evaluar nuestros algoritmos de aprendizaje automático de datos que no se utilizan para entrenar el algoritmo.

La evaluación es una estimación que podemos utilizar para hablar de lo bien que pensamos que el algoritmo puede hacer realidad en la práctica. No es una garantía de rendimiento. Una vez que se estima el rendimiento de nuestro algoritmo, podemos volver a entrenar el algoritmo final de todo el conjunto de datos de entrenamiento y dejarlo listo para su uso operativo. Lo siguiente que vamos a mirar a las técnicas ff Erent cuatro di que podemos utilizar para dividir nuestro conjunto de datos de entrenamiento y crear estimaciones útiles de desempeño para nuestros algoritmos de aprendizaje automático:

?? Tren y de prueba. ?? K veces cruzar Validación. ?? Deja Un hacia fuera validación cruzada.

?? Splits repetidas Test-Tren azar.

57

9.2. Dividir en juegos de trenes y de prueba 

58

9.2 Dividir en juegos de trenes y de prueba El método más simple que podemos utilizar para evaluar el rendimiento de un algoritmo de aprendizaje automático es utilizar la formación Erent di ff y conjuntos de datos de prueba. Podemos llevar nuestro conjunto de datos original, que se dividió en dos partes. Entrenar el algoritmo en la primera parte, hacer predicciones sobre la segunda parte y evaluar las predicciones con los resultados esperados. El tamaño de la escisión puede depender del tamaño y la especificidad cs del conjunto de datos, aunque es común el uso de 67% de los datos para la formación y el 33% restante para la prueba. Esta técnica de evaluación del algoritmo es muy rápido. Es ideal para grandes conjuntos de datos (millones de registros), donde existe una fuerte evidencia de que las dos divisiones de los datos son representativos del problema subyacente. Debido a la velocidad, es útil utilizar este método cuando el algoritmo que se está investigando es lento para entrenar. Una desventaja de esta técnica es que puede tener una alta varianza. Esto si gnifica que erences di ff en el conjunto de datos de entrenamiento y de prueba pueden resultar en erences di ff significativas en la estimación de la precisión. En el siguiente ejemplo dividimos el conjunto de datos indios Pima en 67% / 33% se divide para la formación y probar y evaluar la precisión de un modelo de regresión logística.

# Evaluar el uso de un tren y un equipo de prueba importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] test_size = 0,33 semilla = 7

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split (X, Y, test_size = test_size, random_state = semilla) modelo de regresión logística = () model.fit (X_train, Y_train) resultado = model.score (X_test, Y_test) impresión ( "  Precisión: .3f% %%" )  % (Resultado * 100,0)

Listado 9.1: Ejemplo de evaluación de un algoritmo con un conjunto de tren y de prueba.

Podemos ver que la precisión estimada para el modelo fue de aproximadamente 75%. Tenga en cuenta que además de especificar el tamaño de la división, también especifica la semilla aleatoria. Debido a la división de los datos es al azar, queremos asegurarnos de que los resultados son reproducibles. Al especificar la semilla aleatoria nos aseguramos de que tenemos los mismos números aleatorios cada vez que corremos el código y, a su vez la misma división de los datos. Esto es importante si queremos comparar este resultado a la precisión estimada de otro algoritmo de aprendizaje automático o el mismo algoritmo con un di ff Erent con fi guración. Para asegurar la comparación era manzanas de-manzanas, hay que asegurarse de que están entrenados y evaluados sobre exactamente los mismos datos.

Precisión: 75,591%

Listado 9.2: Salida de la evaluación de un algoritmo con un conjunto de tren y de prueba.

9.3. K veces cruzar Validación 

59

9,3 K-pliegue de validación cruzada validación cruzada es un método que se puede utilizar para estimar el rendimiento de un algoritmo de aprendizaje automático con menor varianza de un solo conjunto partir-prueba tren. Funciona mediante la división del conjunto de datos en k-partes (por ejemplo,  k =  5 o k = 1  0). Cada división de los datos se denomina un pliegue. El algoritmo está entrenado en  k - 1 pliegues con una retenido y probado en el pliegue retuvo. Esto se repite de manera que cada pliegue del conjunto de datos se le da la oportunidad de ser el equipo de prueba frenado. Después de ejecutar la validación cruzada se termina con k di puntuaciones de rendimiento ff Erent que se puede resumir utilizando una media y una desviación estándar.

El resultado es una estimación más fiable del rendimiento del algoritmo en nuevos datos. Es más exacto porque el algoritmo es entrenado y evaluado varias veces en los datos Erent di ff. La elección de  k Debe permitir que el tamaño de cada partición prueba sea suficiente como para ser una muestra razonable del problema grande, permitiendo al mismo tiempo suficientes repeticiones de la evaluación de la prueba de tren del algoritmo para proporcionar una estimación correcta de los resultados de algoritmos en los datos que no se ven. Para los conjuntos de datos de tamaño modesto en los miles o decenas de miles de registros,  k valores de 3, 5 y 10 son comunes. En el siguiente ejemplo utilizamos 10 veces la validación cruzada.

# Evaluar el uso de validación cruzada importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = regresión logística () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión ( "  Precisión:% .3f %% (% .3f %%)" )  % (Results.mean () * 100.0, results.std () * 100,0)

Listado 9.3: Ejemplo de la evaluación de un algoritmo con K veces Validación Cruzada.

Se puede ver que nos informan de la media y la desviación estándar de la medida de rendimiento. Al resumir las medidas de rendimiento, es una buena práctica para resumir la distribución de las medidas, en este caso, suponiendo una distribución de Gauss de rendimiento (una suposición muy razonable) y el registro de la media y la desviación estándar.

Precisión: 76,951% (4,841%)

Añadir 9,4: Salida de la evaluación de un algoritmo con K veces Validación Cruzada.

Validación 9.4 Dejar Un hacia fuera de la Cruz Puede con fi gura la validación cruzada para que el tamaño del pliegue es 1 (  k se establece en el número de observaciones en el conjunto de datos). Esta variación de la validación cruzada se llama licencia-un-out validación cruzada. El resultado es un gran número de medidas de rendimiento que se pueden resumir en

9.5. Repetidas Test-Tren Splits azar 

60

una ORT e ff para dar una estimación más razonable de la exactitud de su modelo de datos que no se ven. Una desventaja es que puede ser un procedimiento computacionalmente más caro que k veces la validación cruzada. En el siguiente ejemplo se utiliza la licencia-un-out validación cruzada. # Evaluar el uso de dejar a uno fuera de validación cruzada importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X)

LOOCV = cross_validation.LeaveOneOut (n = num_instances) modelo de regresión logística = () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = LOOCV) impresión ( "  Precisión:% .3f %% (% .3f %%)" )  % (Results.mean () * 100.0, results.std () * 100,0)

Listing 9.5: Ejemplo de evaluación de un algoritmo con Dejar Un hacia fuera validación cruzada. Se puede ver en la desviación estándar que tiene la puntuación más varianza que los k-fold resultados de la validación cruzada descritos anteriormente. Precisión: 76,823% (42,196%)

Listado 9.6: Salida de la evaluación de un algoritmo con Dejar Un hacia fuera validación cruzada.

9.5 repetidas Test-Tren Splits azar  Otra variación en k veces la validación cruzada es crear una división aleatoria de los datos como la división de tren / de ensayo descrito anteriormente, pero repite el proceso de la división y la evaluación de los algoritmos de múltiples veces, como validación cruzada. Esto tiene la velocidad de la utilización de una fracción de tren / prueba y la reducción de la variación en el rendimiento estimado de k veces la validación cruzada. También puede repetir el proceso muchas más veces como sea necesario para mejorar l a precisión. Un inconveniente es que repeticiones pueden incluir gran parte de los mismos datos en el tren o l a prueba de división de una ejecución a, la introducción de redundancia en la evaluación. El siguiente ejemplo divide los datos en un tren de división 67% / 33% / prueba y repite el proceso 10 veces.

# Evaluar el uso de Split aleatoria Cruz Validación importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_samples = 10 test_size = 0,33 num_instances = len (X)

9.6. ¿Qué técnicas para utilizar cuando 

61

semilla = 7

kfold = cross_validation.ShuffleSplit (n = num_instances, n_iter = num_samples, test_size = test_size, random_state = semilla) modelo de regresión logística = () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión ( "  Precisión:% .3f %% (% .3f %%)" )  % (Results.mean () * 100.0, results.std () * 100,0)

Listing 9.7: Ejemplo de evaluación de un algoritmo con Shu ffl mi dividido Cruz de validación. Podemos ver que en este caso la distribución de la medida de rendimiento está a la par con la validación cruzada k veces por encima.

Precisión: 76,496% (1,698%)

Listing 9.8: Salida de la evaluación de un algoritmo con Shu ffl mi dividido Cruz de validación.

9.6 ¿Qué técnicas para utilizar cuando En esta sección se enumeran algunos consejos para tener en cuenta lo que la técnica de remuestreo para utilizar en circunstancias di ff Erent.

?? En general la validación cruzada k veces es la Estándar dorado para evaluar el rendimiento de una algoritmo de aprendizaje automático en los datos que no se ven con k ajustado a 3, 5, o 10.

?? El uso de una fracción de tren / prueba es buena para la velocidad cuando se utiliza un algoritmo lento y produce estimaciones de rendimiento con el menor sesgo cuando se utilizan grandes conjuntos de datos.

?? Técnicas como la validación cruzada de dejar uno fuera y divisiones aleatorias repetidas pueden ser útiles intermedios cuando tratan de equilibrar la varianza en el rendimiento estimado, la velocidad de formación de modelo y tamaño de conjunto de datos.

El mejor consejo es experimentar y encontrar una técnica para su problema que es rápido y produce estimaciones razonables de rendimiento que se puede utilizar para tomar decisiones. En caso de duda, el uso de validación cruzada 10 veces.

9.7 Resumen En este capítulo usted descubrió técnicas estadísticas que se pueden utilizar para estimar el rendimiento de los algoritmos de aprendizaje automático, llamado remuestreo. Específicamente, usted aprendió sobre:

?? Tren y de prueba. ?? Validación cruzada. ?? Deja Un hacia fuera validación cruzada.

?? Splits repetidas Test-Tren azar.

9.7.1 Siguiente En la siguiente sección aprenderá cómo se puede evaluar el desempeño de clasi fi cación de regresión y algoritmos que utilizan un conjunto de medidas de Erent di ff y construido en los informes de evaluación.

Capítulo 10 Métricas de rendimiento de la máquina Algoritmo de Aprendizaje Las métricas que usted elija para evaluar sus algoritmos de aprendizaje automático son muy importantes. La elección de las métricas de influencias cómo el rendimiento de los algoritmos de aprendizaje automático se mide y se compara. Que influyen en la forma en que el peso de las importancia de las características Erent di ff en los resultados y su última elección de qué algoritmo para elegir. En este capítulo usted descubrirá cómo seleccionar y máquina Erent uso di ff aprendizaje de las métricas de rendimiento en Python con scikit-learn. Empecemos.

10.1 Algoritmo de Evaluación Métrica En esta lección, varias métricas de evaluación algoritmo Erent di ff se demuestran para ambos problemas fi cación y el tipo de regresión de aprendizaje automático caciones. En cada receta, el conjunto de datos se descarga directamente desde el repositorio UCI Machine Learning. ?? Para las métricas de clasi fi cación, la aparición de la diabetes indios Pima conjunto de datos se utiliza como demostrado

tración. Este es un problema fi clasi binario en el que todas las variables de entrada son numérico.

?? Para las métricas de regresión, el conjunto de datos de precios de viviendas de Boston se utiliza como demostración. esto es un

problema de regresión, donde también son numérico todas las variables de entrada.

Todas las recetas evalúan los mismos algoritmos, de regresión logística para la clasi fi cación y regresión lineal para los problemas de regresión. Un instrumento de prueba transversal de validación de 10 veces se utiliza para demostrar cada métrica, porque este es el escenario más probable que va a utilizar cuando se emplea di ff Erent métricas de evaluación algoritmo. Una advertencia en estas recetas es la cruz validation.cross puntuación val función  1 utilizado para reportar el desempeñ o en cada receta. Sí permite el uso de di ff métricas de puntuación Erent que serán discutidas, pero se reportan todas las puntuaciones de modo que puedan ser ordenados en orden ascendente (mayor puntuación es el mejor). Algunas métricas de evaluación (como el error cuadrático medio) están descendiendo de forma natural puntuaciones (la puntuación más pequeño es el mejor) y se reportan como tal como negativos por el 1 http://scikit-learn.org/stable/modules/generated/sklearn.cross_validation.cross_val_

62

score.html

10.2. Classi Métrica fi cación 

63

cruzar validation.cross puntuación val () función. Esto es importante tener en cuenta, debido a que algunos resultados serán reportados como negativos que por definición no puede ser negativo. Yo te recordará sobre esta advertencia a medida que trabajamos a través de la lección. Usted puede aprender más sobre la máquina de aprendizaje métricas de rendimiento algoritmo apoyados por scikit-learn en la página Modelo   amos a seguir adelante con las métricas de evaluación. de evaluación: la cuantificación de la calidad de las predicciones  2  . V

10.2 Classi Métrica fi cación Clasi fi cación problemas son quizás el tipo más común de problema de aprendizaje máquina y, como tal, hay una gran variedad de métricas que se pueden utilizar para evaluar las predicciones para estos problemas. En esta sección vamos a revisar cómo utilizar las siguientes mediciones:

?? Clasi fi cación Precisión. ?? Pérdida logarítmica.

?? Área bajo la curva ROC. ?? Matriz de confusión. ?? Informe de clasi fi cación.

10.2.1 Clasi fi cación Precisión Clasi exactitud fi catión es el número de predicciones correctas hechas como una relación de todas las predicciones hechas. Esta es la métrica de evaluación más común para los problemas de clasi fi cación, también es el más mal usada. Es realmente sólo es adecuado cuando hay un número igual de observaciones en cada clase (que no suele ser el caso) y que todas las predicciones y los errores de predicción son igualmente importantes, que a menudo no es el caso. A continuación se muestra un ejemplo de cálculo de clasi fi cación exactitud. # Clasificación cruzada de validación Precisión importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = regresión logística () de puntuación = 'exactitud' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión ( "  Precisión:% .3f (% .3f)" )  % (Results.mean (), results.std ())

Listado 10.1: Ejemplo de la evaluación de un algoritmo por la precisión de clasi fi cación. 2 http://scikit-learn.org/stable/modules/model_evaluation.html

10.2. Classi Métrica fi cación 

64

Se puede ver que se informa de la relación. Esto se puede convertir en un porcentaje multiplicando el valor por 100, dando una puntuación de exactitud de aproximadamente el 77% de precisión. Precisión: 0.770 (0.048)

Listado 10.2: La salida de evaluar un algoritmo por la exactitud de clasi fi cación.

10.2.2 Pérdida logarítmica pérdida logarítmica (o logloss) es una medida de rendimiento para evaluar las predicciones de probabilidades de pertenencia a una determinada clase. La probabilidad escalar entre 0 y 1 puede verse como una medida de confianza para una predicción por un algoritmo. Las predicciones que son correctas o incorrectas son premiados o castigados de forma proporcional a la confianza de la predicción. A continuación se muestra un ejemplo de cálculo de logloss para las predicciones de regresión logística en el inicio de la diabetes indios Pima conjunto de datos.

# Validación cruzada Clasificación LogLoss importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = regresión logística () de puntuación = 'Log_loss' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión ( "  Logloss:% .3f (% .3f)" )  % (Results.mean (), results.std ())

Perfil de 10.3: Ejemplo de la evaluación de un algoritmo por logloss. logloss más pequeño es mejor con 0 representando una logloss perfecto. Como se mencionó anteriormente, la medida se invierte para ser ascendente cuando se utiliza el cruzar puntuación val () función. Logloss: -0,493 (0,047)

Listado 10.4: Salida de la evaluación de un algoritmo por logloss.

Curva 10.2.3 Área Bajo la República de China El área bajo la curva de ROC (AUC o, para abreviar) es una medida de rendimiento para clasi fi cación binaria problemas. Las AUC representa la capacidad del modelo para discriminar entre clases positivos y negativos. Un área de 1,0 representa un modelo que hizo que todas las predicciones perfectamente. Un área de 0,5 representa un modelo que es tan bueno como al azar. Más información sobre ROC aquí. ROC puede ser dividido en sensibilidad y especificidad. Un problema de clasi fi cación binario es realmente un comercio o FF entre sensibilidad y especificidad.

10.2. Classi Métrica fi cación 

sesenta y cinco

?? La sensibilidad es la verdadera tasa positiva también llamado el recuerdo. Es el número de instancias

de la clase positiva (primera) que en realidad predijo correctamente.

?? Especificidad también se llama la verdadera tasa negativa. Es el número de instancias de la negativo (segundo) de clase que realmente se predijo correctamente.

El siguiente ejemplo proporciona una demostración de calcular AUC. # Validación cruzada Clasificación AUC ROC importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = regresión logística () de puntuación = 'Roc_auc' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión ( "  AUC:% .3f (% .3f)" )  % (Results.mean (), results.std ())

Perfil de 10.5: Ejemplo de la evaluación de un algoritmo por AUC. Se puede ver la AUC está relativamente cerca de 1 y mayor que 0,5, lo que sugiere cierta habilidad en las predicciones

AUC: 0,824 (0,041)

Listado 10.6: Salida de la evaluación de un algoritmo por las AUC.

Matriz de Confusión 10.2.4 La matriz de confusión es una presentación práctica de la exactitud de un modelo con dos o más clases. La tabla presenta predicciones sobre los resultados eje X y precisión en el eje y. Las células de la tabla son el número de predicciones hechas por un algoritmo de aprendizaje automático. Por ejemplo, un algoritmo de aprendizaje automático puede predecir 0 o 1 y cada predicción en realidad puede haber sido un 0 o 1. predicciones para 0 que eran en realidad 0 aparecerá en la celda para predicción =  0 y   , mientras que las predicciones para 0 que eran en realidad 1 aparecerá en la celda para predicción =  0 y = reales 1  . Y así sucesivamente. A = reales 0 continuación se muestra un ejemplo de cálculo de una matriz de confusión para un conjunto de predicciones mediante una regresión logística en la aparición de la diabetes indios Pima conjunto de datos.

# Matriz de confusión Cruz Clasificación Validación importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística de sklearn.metrics importar confusion_matrix url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ]

10.2. Classi Métrica fi cación 

66

trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] test_size = 0,33 semilla =7

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split (X, Y, test_size = test_size, random_state = semilla) modelo de regresión logística = () model.fit (X_train, Y_train) predijo = model.predict (X_test) matriz = confusion_matrix (Y_test, predicho) impresión (matriz)

Perfil de 10.7: Ejemplo de la evaluación de un algoritmo por matriz de confusión.

A pesar de que la matriz se imprime sin títulos, se puede ver que la mayoría de las predicciones caen en la línea diagonal de la matriz (que son predicciones correctas). [[141 21] [41 51]]

Perfil de 10,8: salida de la evaluación de un algoritmo por matriz de confusión.

10.2.5 Informe de Clasi fi cación La biblioteca scikit-learn proporciona un informe comodidad al trabajar con problemas de clasi fi cación para darle una idea de la precisión de un modelo usando una serie de medidas. los informe de clasificación () función muestra la precisión, recordar, F1-score y el apoyo para cada clase. El siguiente ejemplo demuestra el informe sobre el problema de clasi fi cación binaria. # Cruz informe de clasificación de validación importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística de sklearn.metrics importar url = classification_report "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] test_size = 0,33 semilla = 7

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split (X, Y, test_size = test_size, random_state = semilla) modelo de regresión logística = () model.fit (X_train, Y_train) predijo = model.predict (X_test) Informe = classification_report (Y_test, valor de referencia) impresión (informe)

Listado 10.9: Ejemplo de la evaluación de un algoritmo de clasificación informe fi cación.

Se puede ver buena predicción y el recuerdo para el algoritmo.

67

10.3. Las métricas de regresión 

apoyo f1-score recuerdo de precisión 0.0 1.0 avg / Total

0,77 0,71

0.87 0.55

0.82 0.62

162 92

0.75

0,76

0.75

254

Listado 10.10: Salida de la evaluación de un algoritmo de clasificación informe fi cación.

10.3 Regresión Métrica En esta sección se examinarán 3 de las métricas más comunes para la evaluación de las predicciones sobre los problemas de aprendizaje automático de regresión:

?? La media de error absoluto.

?? Error medio cuadrado. ?? R  2.

Error 10.3.1 absoluta media El error medio absoluto (o MAE) es la suma de los erences di ff absolutos entre las predicciones y valores reales. Se da una idea de lo equivocado que estaban las predicciones. La medida da una idea de la magnitud del error, pero no idea de la dirección (por ejemplo, sobre o debajo de la predicción). El siguiente ejemplo muestra el cálculo de error absoluto medio en el conjunto de datos de precios de casa de Boston.

# Validación cruzada de regresión MAE importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar LinearRegression url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = LinearRegression () de puntuación = 'Mean_absolute_error' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión ( "  MAE: .3f% (% .3f)" )  % (Results.mean (), results.std ())

Perfil de 10,11: Ejemplo de la evaluación de un algoritmo de Mean Absolute Error. Un valor de 0 indica que no hay error o predicciones perfectas. Al igual que logloss, esta métrica es invertida por el cruzar puntuación val () función.

10.3. Las métricas de regresión 

68

MAE: -4,005 (2,084)

Listado 10.12: Salida de la evaluación de un algoritmo de Mean error absoluto.

10.3.2 Error Cuadrático Medio El error cuadrático medio (o MSE) es muy parecido al error absoluto medio en que proporciona una idea bruto de la magnitud de error. Tomando la raíz cuadrada del cuadrado medio del error convierte las unidades de vuelta a las unidades originales de la variable de salida y puede ser significativa para la designación y presentación. Esto se llama el error de media cuadrática (o RMSE). El siguiente ejemplo proporciona una demostración de cálculo de error cuadrático medio.

# Validación cruzada de regresión MSE importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar LinearRegression url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = LinearRegression () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión ( "  MSE:% .3f (% .3f)" )  % (Results.mean (), results.std ())

Perfil de 10,13: Ejemplo de la evaluación de un algoritmo de Mean Squared Error. Esta medida también se invierte de manera que los resultados van en aumento. Recuerde que debe tomar el valor absoluto antes de tomar la raíz cuadrada si está interesado en el cálculo del ECM. MSE: -34,705 (45,574)

Listado 10.14: Salida de la evaluación de un algoritmo de error cuadrático medio.

10.3.3 R  2 Métrico los R  2 (  o R Squared) métrica proporciona una indicación de la bondad de la fi t de un conjunto de predicciones a los valores reales. En la literatura estadística esta medida se llama el coe fi ciente de determinación. Este es un valor entre 0 y 1 para no- fi t y perfecto fi t respectivamente. El siguiente ejemplo proporciona una demostración de cálculo de la media  R  2 para un conjunto de predicciones. # Cross Validación de regresión R ^ 2 importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar LinearRegression url = "Https://goo.gl/sXleFv"

69

10.4. Resumen 

nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = LinearRegression () de puntuación = 'R2' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión ( "  R ^ 2:% .3f (% .3f)" )  % (Results.mean (), results.std ())

Perfil de 10,15: Ejemplo de la evaluación de un algoritmo por R Squared.

Se puede ver las predicciones tienen una razonable fi cio a los valores reales con un valor cercano a cero y menor que 0,5.

R ^ 2: 0.203 (0.595)

Listado 10.16: Salida de la evaluación de un algoritmo de R al cuadrado.

10.4 Resumen En este capítulo usted descubrió métricas que se pueden utilizar para evaluar sus algoritmos de aprendizaje automático. Aprendiste unas tres métricas de clasi fi cación: La precisión, la pérdida y la curva logarítmica Área Bajo la República de China. También aprendió acerca de dos métodos de conveniencia para la predicción de resultados clasi fi cación: la matriz de confusión y el Informe de clasi fi cación. Por último, también ha aprendido unos tres métricas para los problemas de regresión: error absoluto medio, y el cuadrado medio del error   R  2.

10.4.1 Siguiente Ahora ya sabe cómo evaluar el rendimiento de los algoritmos de aprendizaje automático utilizando una variedad de métricas Erent di ff y cómo utilizar esas métricas para estimar el rendimiento de los algoritmos de nuevos datos que no se ven utilizando remuestreo. En la siguiente lección de empezar a buscar en algoritmos de aprendizaje automático a sí mismos, a partir de técnicas de clasi fi cación.

Capítulo 11 Spot-Check Clasi fi cación Algoritmos Un control puntual es una forma de descubrir qué algoritmos funcionan bien en su problema de aprendizaje automático. No se puede saber qué algoritmos son los más adecuados para su problema de antemano. Debe ensayo una serie de métodos y centrar la atención en aquellos que sí demuestran los más prometedores. En este capítulo usted descubrirá algoritmos de aprendizaje de seis máquinas que se pueden utilizar cuando la mancha de comprobación de su problema de clasi fi cación en Python con scikit-learn. Después de completar esta lección sabrá:

1. ¿Cómo inspección al azar algoritmos de aprendizaje automático en un problema de clasi fi cación.

2. ¿Cómo inspección al azar dos algoritmos de clasi fi cación lineales. 3. ¿Cómo inspección al azar cuatro algoritmos de clasi fi cación no lineales.

Empecemos.

11.1 Algoritmo de controles in situ No se puede saber qué algoritmo que funciona mejor en su conjunto de datos de antemano. Debe usar ensayo y error para descubrir una lista corta de algoritmos que hacen bien en su problema que entonces se puede doblar y sintonizar más. Yo llamo a este proceso de medición esporádica. La pregunta no es: Lo algoritmo debo usar en mi conjunto de datos? En cambio, es: Lo que debería algoritmos de i nspección al azar en mi conjunto de datos? Se puede adivinar en qué algoritmos podrían hacer bien en su conjunto de datos, y esto puede ser un buen punto

de partida. Recomiendo probar una mezcla de algoritmos y ver lo que es bueno en escoger la estructura de los datos. A continuación se presentan algunas sugerencias al punto de comprobación de algoritmos en el conjunto de datos:

?? Pruebe una mezcla de representaciones de algoritmo (por ejemplo, casos y árboles). ?? Pruebe una mezcla de algoritmos de aprendizaje (por ejemplo, di ff algoritmos Erent para el aprendizaje del mismo tipo

de la representación).

?? Trate de una mezcla de tipos de modelado (por ejemplo, lineal y funciones no lineales o paramétrico y

no paramétrica). Vamos a conseguir específico. En la siguiente sección, vamos a ver en los algoritmos que se pueden utilizar para inspección al azar en su próximo proyecto de clasi fi c ación de aprendizaje automático en Python.

70

71

11.2. algoritmos general 

11.2 Algoritmos general Vamos a echar un vistazo a seis algoritmos de clasi fi cación que se puede detectar a comprobar en su conjunto de datos. A partir de dos algoritmos de aprendizaje automático lineales:

?? Regresión logística.

?? Análisis discriminante lineal. Luego, mirando a los cuatro algoritmos de aprendizaje automático no lineales:

?? K-vecinos más cercanos.

?? Naive Bayes.

?? Clasi fi cación y regresión árboles. ?? Support Vector Machines. Cada receta se demuestra en el inicio indios Pima de la diabetes de datos. Un arnés de prueba usando la validación cruzada 10 veces se utiliza para demostrar cómo detectar a comprobar cada algoritmo de aprendizaje automático y la media de las medidas de precisión se utilizan para indicar el rendimiento algoritmo. Las recetas asumen que usted sabe acerca de cada algoritmo de aprendizaje automático y la forma de utilizarlos. No vamos a entrar en el API o parametrización de cada algoritmo.

11.3 linear Máquina algoritmos de aprendizaje Esta sección demuestra recetas mínimos para el uso de dos algoritmos de aprendizaje automático lineales: regresión logística y análisis discriminante lineal.

11.3.1 regresión logística La regresión logística asume una distribución gaussiana para las variables de entrada numéricos y puede modelar problemas de clasi fi cación binarios. Se puede construir un modelo de regresión logística utilizando el

Regresión logística clase 1  . # Clasificación de regresión logística importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X)

1 http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.

html

72

11.4. No lineales de la máquina algoritmos de aprendizaje 

semilla = 7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = regresión logística () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Perfil de 11.1: Ejemplo del algoritmo de regresión logística. Ejecutar el ejemplo imprime la precisión estimada media. ,76951469583

Listado 11.2: La salida del algoritmo de regresión logística.

El análisis discriminante lineal 11.3.2 Análisis discriminante lineal o LDA es una técnica estadística para binario y multiclase clasificacion. También supone una distribución de Gauss para las variables de entrada numéricos. Se puede construir un modelo LDA mediante el LinearDiscriminantAnalysi clase 2  . # Clasificación LDA importar pandas de sklearn importar validación cruzada de sklearn.discriminant_analysis importar LinearDiscriminantAnalysis url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = LinearDiscriminantAnalysis () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 11.3: Ejemplo del algoritmo de LDA. Ejecutar el ejemplo imprime la precisión estimada media. ,773462064252

Listado 11.4: La salida del algoritmo LDA.

11.4 no lineales de la máquina algoritmos de aprendizaje En esta sección se demuestra recetas mínimos para el uso de 4 algoritmos de aprendizaje automático no lineales. 2 http://scikit-learn.org/stable/modules/generated/sklearn.discriminant_analysis.

LinearDiscriminantAnalysis.html

73

11.4. No lineales de la máquina algoritmos de aprendizaje 

Los vecinos más cercanos 11.4.1 KK-vecinos más cercanos (KNN o) utiliza una métrica de distancia para hallar la K la mayoría de los casos similares en los datos de entrenamiento para una nueva instancia y toma el resultado medio de los vecinos como la predicción. Se puede construir un modelo KNN utilizando el KNeighborsClassifier clase  3  . # La clasificación KNN importar pandas de sklearn importar validación cruzada de sklearn.neighbors importar KNeighborsClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) random_state = 7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = random_state) Modelo = KNeighborsClassifier () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Perfil de 11.5: Ejemplo del algoritmo KNN. Ejecutar el ejemplo imprime la precisión estimada media. ,726555023923

Listado 11.6: La salida del algoritmo KNN.

11.4.2 Naive Bayes Naive Bayes calcula la probabilidad de cada clase y la probabilidad condicional de cada clase dada cada valor de entrada. Estas probabilidades se estiman para nuevos datos y multiplican entre sí, en el supuesto de que son todos independientes (una suposición simple o ingenua). Cuando se trabaja con los datos de valor real, una distribución de Gauss se asume para estimar fácilmente las probabilidades de las variables de entrada utilizando el Gaussian Función de densidad de probabilidad. Se puede construir un modelo bayesiano usando el GaussianNB clase  4  .

# Clasificación bayesiano de Gauss importar pandas de sklearn importar validación cruzada de sklearn.naive_bayes importar GaussianNB url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8]

3 http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.

4

http://scikit-learn.org/stable/modules/generated/sklearn.naive_bayes.GaussianNB.html

html

74

11.4. No lineales de la máquina algoritmos de aprendizaje 

Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7 kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = GaussianNB () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Perfil de 11.7: Ejemplo del algoritmo de Bayes ingenuo. Ejecutar el ejemplo imprime la precisión estimada media. ,75517771702

Listado 11.8: La salida del algoritmo bayesiano.

11.4.3 Clasi fi cación y regresión Trees Clasi fi cación y regresión árboles (CART o árboles de decisión sólo) construir un árbol binario de los datos de entrenamiento. puntos de división se eligen con avidez mediante la evaluación de cada atributo y cada valor de cada atributo en la formación de datos con el fin de minimizar una función de coste (como el índice de Gini). Se puede construir un modelo Usando las DecisionTreeClassifier clase 5  . # Clasificación CART importar pandas de sklearn importar validación cruzada de sklearn.tree importar DecisionTreeClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = DecisionTreeClassifier () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Perfil de 11.9: Ejemplo del algoritmo CART. Ejecutar el ejemplo imprime la precisión estimada media. ,692600820232

Listado 11.10: Salida del algoritmo CART. 5 http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.

html

75

11.5. Resumen 

11.4.4 Support Vector Machines Máquinas de Vectores Soporte (SVM o) buscar una línea que mejor separa dos clases. Estas instancias de datos que están más cerca de la línea que mejor separa las clases se denominan vectores de soporte e influencia donde se coloca la línea. SVM se ha ampliado para dar soporte a múltiples clases. De particular importancia es el uso de las funciones del kernel Erent di ff mediante el parámetro de kernel. Una potente función de base radial se utiliza por defecto. Se puede construir un modelo SVM utilizando el SVC clase 6  . # Clasificación SVM importar pandas de sklearn importar validación cruzada de sklearn.svm importar SVC url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = SVC () resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 11,11: Ejemplo del algoritmo SVM. Ejecutar el ejemplo imprime la precisión estimada media. ,651025290499

Listado 11.12: Salida del algoritmo SVM.

11.5 Resumen En este capítulo usted descubrió algoritmos de aprendizaje de máquina 6 que se pueden utilizar para inspección al azar en su clasi fi cación problema en Python usando scikit-learn. Específicamente, ha aprendido a inspección al azar dos algoritmos de aprendizaje automático: lineales de regresión logística y análisis discriminante lineal. También ha aprendido a inspección al azar cuatro algoritmos no lineales: K-vecinos más cercanos, Naïve Bayes, Clasi fi cación y la regresión Árboles y máquinas de vectores soporte.

11.5.1 Siguiente En la siguiente lección usted descubrirá cómo se puede utilizar la medición esporádica en los problemas de aprendizaje automático de regresión y la práctica con siete di ff algoritmos de regresión Erent.

6

http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html

capítulo 12 Spot-Check regresión Algoritmos Un control puntual es una forma de descubrir qué algoritmos funcionan bien en su problema de aprendizaje automático. No se puede saber qué algoritmos son los más adecuados para su problema de antemano. Debe ensayo una serie de métodos y centrar la atención en aquellos que sí demuestran los más prometedores. En este capítulo usted descubrirá algoritmos de aprendizaje de seis máquinas que se pueden utilizar cuando la mancha de comprobación de su problema de regresión en Python con scikit-learn. Después de completar esta lección sabrá:

1. ¿Cómo inspección al azar algoritmos de aprendizaje automático en un problema de regresión.

2. ¿Cómo inspección al azar cuatro algoritmos de regresión lineal.

3. ¿Cómo inspección al azar tres algoritmos de regresión no lineal.

Empecemos.

12.1 Algoritmos general En esta lección vamos a echar un vistazo a siete algoritmos de regresión que se puede detectar a comprobar en su conjunto de datos. A partir de cuatro algoritmos de aprendizaje automático lineales:

?? Regresión lineal. ?? Regresión Ridge.

?? LASSO regresión lineal. ?? Regresión red elástica. A continuación, la observación de tres algoritmos de aprendizaje automático no lineales:

?? K-vecinos más cercanos.

?? Clasi fi cación y regresión árboles. ?? Support Vector Machines.

76

77

12.2. Máquinas lineales algoritmos de aprendizaje 

Cada receta se demuestra en el conjunto de datos de precios de viviendas de Boston. Se trata de un problema de regresión, donde todos los atributos son numéricos. Un instrumento de prueba con la validación cruzada de 10 veces se utiliza para demostrar cómo detectar a comprobar cada algoritmo de aprendizaje automático y la media de las medidas de error al cuadrado se utilizan para indicar rendimiento de los algoritmos. Tenga en cuenta que significan los valores de error al cuadrado se invierten (negativo). Esta es una peculiaridad de la cruzar puntuación val () función utilizada que requiere que todas las métricas de algoritmo que se ordena en orden ascendente (mayor valor es mejor). Las recetas asumen que usted sabe acerca de cada algoritmo de aprendizaje automático y la forma de utilizarlos. No vamos a entrar en el API o parametrización de cada algoritmo.

12.2 linear Máquina algoritmos de aprendizaje Esta sección proporciona ejemplos de cómo utilizar cuatro di ff Erent algoritmos de aprendizaje automático para la regresión lineal en Python con scikit-learn.

12.2.1 Regresión Lineal La regresión lineal asume que las variables de entrada tienen una distribución de Gauss. También se supone que las variables de entrada son relevantes para la variable de salida y que no están altamente correlacionadas entre sí (un problema llamado colinealidad). Es posible construir un modelo de regresión lineal usando el LinearRegression clase 1  .

# regresión lineal importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar LinearRegression url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold modelo (n = num_instances, n_folds = num_folds, random_state = semilla) = LinearRegression () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión (Results.mean ())

Perfil de 12.1: Ejemplo del algoritmo de regresión lineal. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 34.7052559445

Perfil de 12,2: salida del algoritmo de regresión lineal. 1 http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.

html

12.2. Máquinas lineales algoritmos de aprendizaje 

78

12.2.2 regresión contraída regresión Ridge es una extensión de la regresión lineal en el que la función de pérdida es modi fi para reducir al mínimo la complejidad del modelo de medida como la suma al cuadrado el valor de los valores coe fi ciente (también llamado el L2-norma). Se puede construir un modelo de regresión contraída mediante el uso de la Cresta

clase 2 . # regresión ridge importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Cresta url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = cresta () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión (Results.mean ())

Perfil de 12.3: Ejemplo del algoritmo de regresión cresta. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 34.0782462093

Listado 12.4: La salida del algoritmo de regresión contraída.

12.2.3 LASSO Regresión The Least Absolute Contracción y selección del operador (o LASSO para abreviar) es una modificación de la regresión lineal, como regresión Ridge, donde la función de pérdida es modi fi para reducir al mínimo la complejidad del modelo de medida como el valor absoluto suma de los valores coe fi ciente (también llamado la L1-norma). Se puede construir un modelo LASSO mediante el uso de la Lazo clase 3  . # La regresión Lasso importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar url = Lasso "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = Verdadero, nombres = nombres) Array = dataframe.values X = array [:, doce y trece]

2 3

http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html

79

12.2. Máquinas lineales algoritmos de aprendizaje 

Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla = 7 kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = Lasso () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión (Results.mean ())

Listado 12.5: Ejemplo del algoritmo de regresión LASSO. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 34.4640845883

Listado 12.6: La salida del algoritmo de regresión LASSO.

12.2.4 ElasticNet Regresión ElasticNet es una forma de regresión regularización que combina las propiedades tanto de Regresión Ridge y regresión LASSO. Se busca minimizar la complejidad del modelo de regresión (magnitud y el número de coeficientes de FFI coe regresión) penalizando el modelo utilizando tanto la L2-norma (suma al cuadrado los valores fi ciente COE) y la L1-norma (valores de suma absoluta Coe fi ciente). Se puede construir un modelo ElasticNet utilizando el ElasticNet clase

 4  .

# ElasticNet regresión importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar ElasticNet url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = ElasticNet () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión (Results.mean ())

Perfil de 12.7: Ejemplo del algoritmo de regresión ElasticNet. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 31.1645737142

Perfil de 12,8: salida del algoritmo de regresión ElasticNet. 4

http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html

80

12.3. No lineales de la máquina algoritmos de aprendizaje 

12.3 no lineales de la máquina algoritmos de aprendizaje Esta sección proporciona ejemplos de cómo utilizar tres di ff Erent algoritmos de aprendizaje automático para la regresión no lineal en Python con scikit-learn.

Los vecinos más cercanos 12.3.1 KK-vecinos más cercanos (KNN o) localiza el K la mayoría de los casos similares en la formación de datos para una nueva instancia de datos. Desde el K vecinos, una variable media o la mediana de salida se toma como la predicción. Es de destacar la distancia métrica utilizada (la métrico argumento). La distancia Minkowski se utiliza por defecto, que es una generalización de tanto la distancia euclidiana (utilizado cuando todas las entradas tienen la misma escala) y la distancia Manhattan (para cuando las escalas del ff er variables de entrada di). Se puede construir un modelo KNN para la regresión utili zando el KNeighborsRegressor clase  5  .

# regresión KNN importar pandas de sklearn importar validación cruzada de sklearn.neighbors importar KNeighborsRegressor url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = KNeighborsRegressor () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión (Results.mean ())

Perfil de 12.9: Ejemplo del algoritmo de regresión KNN. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 107.28683898

Listado 12.10: Salida del algoritmo de regresión KNN.

12.3.2 Clasi fi cación y regresión Trees Los árboles de decisión o la Clasi fi cación y la regresión árboles (CART como se les conoce) utilizan los datos de entrenamiento para seleccionar los mejores puntos para dividir los datos con el fin de minimizar una métrica de costo. La métrica de coste por defecto para los árboles de decisión de regresión es el error cuadrático medio, se especifica en el criterio

parámetro. Puede crear un modelo CART para la regresión utilizando el DecisionTreeRegressor  clase 6 . 5 http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsRegressor.

6

http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html

html

12.3. No lineales de la máquina algoritmos de aprendizaje 

81

# Decisión del árbol de regresión importar pandas de sklearn importar validación cruzada de sklearn.tree importar DecisionTreeRegressor url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = DecisionTreeRegressor () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) impresión (Results.mean ())

Perfil de 12,11: Ejemplo del algoritmo de regresión CART. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 35.4906027451

Listado 12.12: Salida del algoritmo de regresión CART.

12.3.3 Support Vector Machines Support Vector Machines (SVM) se desarrollaron para binario clasificacion. La técnica se ha extendido por los problemas de valor real de predicción de llamadas Soporte vector de regresión (RVS). Al igual que el ejemplo de clasi fi cación, RVS se basa en la biblioteca LIBSVM. Puede crear un modelo SVM para la regresión utilizando el SVR clase  7  .

# La regresión SVM importar pandas de sklearn importar validación cruzada de sklearn.svm importar SVR url = "Https://goo.gl/sXleFv" nombres = [ 'CRIM'  , 'ZN' , 'INDUS' , 'CHAS' , 'NOX' , 'RM' , 'AÑOS' , 'SID' , 'RAD' , 'IMPUESTO' , 'PTRATIO' , ' SEGUNDO' , 'LSTAT' , 'MEDV' ]

trama de datos = pandas.read_csv (url, delim_whitespace = True, nombres = nombres) Array = dataframe.values X = array [:, doce y trece] Y = array [:, 13] num_folds = 10 num_instances = len (X) de semilla =7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = SVR () de puntuación = 'error medio cuadrado' resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) 7

http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html

82

12.4. Resumen 

impresión (Results.mean ())

Listado 12,13: Ejemplo del algoritmo de regresión SVM. Ejecutar el ejemplo proporciona una estimación del error cuadrático medio. - 91.0478243332

Listado 12.14: Salida del algoritmo de regresión SVM.

12.4 Resumen En este capítulo se descubrió la forma de inspección al azar algoritmos de aprendizaje automático para los problemas de regresión en Python usando scikit-learn. Específicamente, ha aprendido unos cuatro algoritmos de aprendizaje automático: lineales de regresión lineal, regresión contraída, LASSO de regresión lineal y elástico neto de regresión. También ha aprendido unos tres algoritmos no lineales: K-vecinos más cercanos, Clasi fi cación y la regresión Árboles y máquinas de vectores soporte.

12.4.1 Siguiente Ahora que ya sabe cómo utilizar fi cación y de regresión algoritmos caciones que necesita saber cómo comparar los resultados de los algoritmos Erent di ff entre sí. En la siguiente lección usted descubrirá cómo diseñar experimentos sencillos para comparar directamente algoritmos de aprendizaje automático entre sí en su conjunto de datos.

capítulo 13 Comparación de algoritmos de aprendizaje de máquinas

Es importante comparar el desempeño de múltiples algoritmos de aprendizaje automático Erent di ff constantemente. En este capítulo usted descubrirá cómo se puede crear un instrumento de prueba para comparar múltiples algoritmos de aprendizaje automático Erent di ff en Python con scikit-learn. Puede utilizar este instrumento de prueba como una plantilla en sus propios pr oblemas de aprendizaje automático y añadir más y Erent di ff algoritmos para comparar. Después de completar esta lección sabrá:

1. ¿Cómo formular un experimento para comparar directamente los algoritmos de aprendizaje automático.

2. Una plantilla reutilizable para evaluar el desempeño de múltiples algoritmos en un conjunto de datos.

3. ¿Cómo informan y visualizar los resultados al comparar el rendimiento algoritmo. Empecemos.

13.1 elegir el mejor modelo de máquina de aprendizaje Cuando se trabaja en un proyecto de aprendizaje automático, que a menudo terminan con varios buenos modelos para elegir. Cada modelo tendrá características de rendimiento Erent di ff. El uso de métodos de remuestreo como la validación cruzada, se puede obtener una estimación precisa de cómo cada modelo puede ser invisibles en los datos. Tienes que ser capaz de utilizar estas estimaciones para elegir uno o dos mejores modelos de la serie de modelos que ha creado. Cuando se tiene un nuevo conjunto de datos, es una buena idea para visualizar los datos utilizando técnicas Erent di ff con el fin de observar los datos desde perspectivas Erent di ff. La misma idea se aplica a la selección del modelo. Se debe utilizar un número de maneras di ff Erent de mirar la precisión estimada de sus algoritmos de aprendizaje automático con el fin de elegir el algoritmo de uno o dos a fi nalizar. Una manera de hacer esto es usar métodos de visualización para mostrar la exactitud media, la varianza y otras propiedades de la distribución de precisiones de modelo. En la siguiente sección usted descubrirá exactamente cómo se puede hacer eso en Python con scikit-learn.

13.2 Comparación de aprendizaje automático Algoritmos Consistentemente La clave para una comparación justa de los algoritmos de aprendizaje automático es asegurar que cada algoritmo se evalúa de la misma manera en los mismos datos. Usted puede lograr esto forzando cada algoritmo

83

13.2. Comparar Machine Learning Algoritmos Consistentemente 

84

para ser evaluados en un instrumento de prueba consistente. En el siguiente ejemplo de seis di algoritmos ff Erent Clasi fi cación se comparan en un único conjunto de datos:

?? Regresión logística.

?? Análisis discriminante lineal. ?? K-vecinos más cercanos.

?? Clasi fi cación y regresión árboles. ?? Naive Bayes.

?? Support Vector Machines. El conjunto de datos es la aparición de los indios Pima problema de la diabetes. El problema tiene dos clases y ocho variables de entrada numéricos de diferentes escalas. El 10 veces cruzada procedimiento de validación se utiliza para evaluar cada algoritmo, importante fi con gurado con la misma semilla aleatoria para asegurar que las mismas se divide para los datos de entrenamiento se realizan y que cada algoritmo se evalúa precisamente de la misma manera. Cada algoritmo se le da un nombre corto, útil para resumir los resultados después. # Comparación de algoritmos importar pandas importar matplotlib.pyplot como PLT de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística de sklearn.tree importar DecisionTreeClassifier  de sklearn.neighbors importar KNeighborsClassifier  de sklearn.discriminant_analysis importar LinearDiscriminantAnalysis de sklearn.naive_bayes importar GaussianNB de sklearn.svm importar SVC # conjunto de datos de carga url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

# preparar configuración para mazos de prueba cruzada validación num_folds = 10 num_instances = len (X) de semilla = 7 # preparar modelos modelos = [] models.append (( 'LR' ,  Regresión logística ())) models.append (( '  LDA'  , LinearDiscriminantAnalysis ())) models.append (( 'KNN' ,  KNeighborsClassifier ())) models.append (( 'CARRO' ,  DecisionTreeClassifier ())) models.append (( '  NÓTESE BIEN' , GaussianNB ())) models.append (( '  SVM' ,  SVC ()))

# evaluar cada modelo a su vez Resultados = [] nombres = [] de puntuación = 'exactitud' para nombre, modelo en modelos:

13.2. Comparar Machine Learning Algoritmos Consistentemente 

85

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) cv_results = cross_validation.cross_val_score (modelo, X, Y, cv = kfold, puntuación = puntuación) results.append (cv_results) names.append (nombre) msg = "% S:% f (% f)" % (Nombre, cv_results.mean (), cv_results.std ())

impresión (Msg)

# comparación algoritmo gráfico de cajas fig = plt.figure () fig.suptitle ( 'Algoritmo de comparación'  ) Ax = fig.add_subplot (111) plt.boxplot (resultados) ax.set_xticklabels (nombres) plt.show ()

Perfil de 13.1: Ejemplo de comparación de múltiples algoritmos.

Ejecución del ejemplo proporciona una lista de cada nombre corto algoritmo, la precisión media y la desviación estándar de precisión. LR: 0.769515 (0.048411) LDA: 0.773462 (0.051592) KNN: 0.726555 (0.061821) CART: 0.695232 (0.062517) NB: 0.755178 (0.042766) SVM: 0.651025 (0.072141)

Listado 13.2: La salida de la comparación de múltiples algoritmos. El ejemplo también proporciona un gráfico de caja y bigotes que muestra la propagación de las puntuaciones de precisión a través de cada pliegue de validación cruzada para cada algoritmo.

13.3. Resumen 

86

Figura 13.1: Parcelas de caja y bigotes comparar el rendimiento del algoritmo

A partir de estos resultados, se sugiere que tanto la regresión logística y análisis discriminante lineal son, quizás, más digno de estudio sobre este problema.

13.3 Resumen En este capítulo has descubierto cómo evaluar múltiples algoritmos de aprendizaje automático Erent di ff en un conjunto de datos en Python con scikit-learn. Ha aprendido a ambos utilizan el mismo instrumento de prueba para evaluar los algoritmos y la forma de resumir los resultados tanto numérica como el uso de una caja y bigotes parcela. Se puede utilizar esta receta como un modelo para la evaluación de múltiples algoritmos de sus propios problemas.

13.3.1 Siguiente En esta lección ha aprendido a comparar el rendimiento de los algoritmos de aprendizaje automático entre sí. Pero lo que si es necesario preparar sus datos como parte del proceso de comparación. En la siguiente lección usted descubrirá Tuberías en scikit-learn y cómo superar los problemas comunes de la pérdida de datos cuando se comparan los algoritmos de aprendizaje automático.

capítulo 14 Automatizar la máquina para la empresa Aprendizaje fluye con tuberías Hay flujos de trabajo estándar en un proyecto de aprendizaje de máquina que puede ser automatizado. En Python scikit-learn, Tuberías ayudan a claramente definen y automatizar estos flujos de trabajo. En este capítulo usted descubrirá Tuberías en scikit-learn y cómo puede automatizar común de la máquina de aprendizaje de trabajo fluye. Después de completar esta lección sabrá:

1. ¿Cómo utilizar tuberías para minimizar la fuga de datos.

2. ¿Cómo construir un oleoducto preparación de datos y el modelado. 3. ¿Cómo construir un ducto de extracción de características y modelado.

Empecemos.

14.1 Automatización de máquina para la empresa Aprendizaje flujos Hay estándar de trabajo fluye en la máquina de aprendizaje aplicada. Estándar porque superan los problemas comunes como la fuga de datos en su instrumento de prueba. Python scikit-learn proporciona una utilidad de tuberías para ayudar a automatizar el trabajo de aprendizaje automático flujos. Tuberías de trabajo al permitir que para una secuencia lineal de datos transforma estar encadenado juntos culminando en un proceso de modelado que puede ser evaluada.

El objetivo es asegurar que todos los pasos en la tubería están limitados a los datos disponibles para la evaluación, tales como la formación de datos o cada pliegue del procedimiento de validación cruzada. Usted puede aprender más acerca de Tuberías en scikit-learn mediante la lectura de la sección de la tubería  1 de la guía del usuario. También puede revisar la docum entación de la API para las clases y la tubería y FeatureUnion tubería módulo  2  .

14.2 Preparación de datos y modelización Pipeline Una trampa fácil caer en el aprendizaje de la máquina aplicada tiene una fuga de datos de su formación de datos para el conjunto de datos de prueba. Para evitar esta trampa se necesita un instrumento de prueba robusta con una fuerte separación de 1 http://scikit-learn.org/stable/modules/pipeline.html 2

http://scikit-learn.org/stable/modules/classes.html#module-sklearn.pipeline

87

14.2. Preparación de datos y modelización Pipeline 

88

formación y las pruebas. Esto incluye la preparación de datos. preparación de datos es una manera fácil de fugas conocimiento de toda la formación de datos con el algoritmo. Por ejemplo, la preparación de sus datos mediante la normalización o estandarización en todo el conjunto de datos de entrenamiento antes de aprendizaje no sería una prueba válida debido a la formación de datos habría sido influenciada por la magnitud de los datos en el conjunto de prueba.

Tuberías ayudan a prevenir la fuga de datos en su instrumento de prueba, asegurando que la preparación de datos, como la estandarización está limitado a cada pliegue de su procedimiento de validación cruzada. El ejemplo siguiente muestra este importante preparación de datos y la evaluación del modelo de trabajo flujo en la aparición de la diabetes indios Pima conjunto de datos. La tubería se define con dos pasos:

1. Normalizar los datos. 2. Aprender un modelo de análisis discriminante lineal. La tubería se evalúa a continuación, utilizando la validación cruzada 10 veces. # Crear una tubería que estandariza los datos a continuación, crea un modelo de pandas importar read_csv de sklearn.cross_validation importar KFold de sklearn.cross_validation importar cross_val_score de sklearn.preprocessing importar StandardScaler  de sklearn.pipeline importar Tubería de sklearn.discriminant_analysis importar LinearDiscriminantAnalysis # Cargar datos url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

# crear tuberías estimadores = [] estimators.append (( 'estandarizar' ,  StandardScaler ())) estimators.append (( 'Lda' ,  LinearDiscriminantAnalysis ())) Modelo = Pipeline (estimadores)

# evaluar la tubería num_folds = 10 num_instances = len (X) de semilla = 7 kfold = KFold (n = num_instances, n_folds = num_folds, random_state = semilla) resultados = c ross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 14.1: Ejemplo de un gasoducto para estandarizar y los datos del modelo.

Nótese cómo creamos una lista de Python de pasos que se proporcionan a la tubería de proceso de los datos. Observe también cómo la propia Pipeline es tratado como un estimador y se evalúa en su totalidad por el k-veces cruzada procedimiento de validación. Ejecutar el ejemplo proporciona un resumen de la precisión de la instalación en el conjunto de datos.

,773462064252

Listado 14.2: La salida de una tubería de estandarizar y datos del modelo.

14.3. Extracción de características y Modelado Pipeline 

89

14.3 extracción de características y Modelado Pipeline extracción de características es otro procedimiento que es susceptible a la fuga de datos. Al igual que la preparación de datos, procedimientos de extracción de características deben limitarse a los datos del conjunto de datos de entrenamiento. La tubería proporciona una herramienta muy útil llamada FeatureUnion que permite que los resultados de múltiples procedimientos de selección de características y de extracción para ser combinados en un conjunto de datos más grande sobre la que puede ser entrenado un modelo. Es importante destacar que toda la extracción de características y la unión característica se produce dentro de cada pliegue del procedimiento de validación cruzada. El siguiente ejemplo demuestra la tubería de fi nido con cuatro pasos:

1. Extracción de Características con Análisis de Componentes Principales (3 funciones).

Extracción 2. Característica con la Selección de Estadística (6 funciones). 3. Característica Unión.

4. Aprender un modelo de regresión logística. La tubería se evalúa a continuación, utilizando la validación cruzada 10 veces. # Crear una tubería que extrae características de los datos a continuación, crea un modelo de pandas importar read_csv de sklearn.cross_validation importar KFold de sklearn.cross_validation importar cross_val_score de sklearn.pipeline importar Tubería de sklearn.pipeline importar FeatureUnion de sklearn.linear_model importar Regresión logística de sklearn.decomposition importar PCA de sklearn.feature_selection importar SelectKBest # Cargar datos url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

# crear la unión función características = [] features.append (( PCA ,  PCA (n_components = 3))) features.append (( 'Select_best' ,  SelectKBest (k = 6))) feature_union = FeatureUnion (características) # crear tuberías estimadores = [] estimators.append (( ' Feature_union' ,  Feature_union)) estimators.append (( 'logístico' ,  Regresión logística ())) Modelo = Pipeline (estimadores)

# evaluar la tubería num_folds = 10 num_instances = len (X) de semilla = 7 kfold = KFold (n = num_instances, n_folds = num_folds, random_state = semilla) resultados = c ross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 14.3: Ejemplo de un extracto de la tubería y de combinar características antes de modelado.

14.4. Resumen 

90

Observe cómo el FeatureUnion es su propio oleoducto que a su vez es un solo paso en la tubería final utilizado para alimentar de regresión logística. Esto podría hacerle pensar sobre cómo puede empezar a incrustar las tuberías dentro de las tuberías. Ejecutar el ejemplo proporciona un resumen de la precisión de la i nstalación en el conjunto de datos.

,776042378674

Listado 14.4: La salida de un extracto de la tubería y de combinar las características antes modelado.

14.4 Resumen En este capítulo se descubrieron las di fi cultades de la fuga de datos en la máquina de aprendizaje aplicada. Usted descubrió las utilidades de la tubería en Python scikit-learn y la forma en que se puede utilizar para automatizar el trabajo estándar de la máquina de aprendizaje aplicada fluye. Ha aprendido a utilizar tuberías en dos importantes casos de uso:

?? Preparación de datos y el modelado constreñidos a cada pliegue del procedimiento de validación cruzada.

?? extracción de características y la unión función constreñidos a cada pliegue de la validación cruzada procedimiento.

14.4.1 Siguiente Esto completa las lecciones sobre cómo evaluar algoritmos de aprendizaje automático. En la siguiente lección que se llevará a su primera mirada fi en cómo mejorar el rendimiento algoritmo en sus problemas mediante el uso de métodos de conjunto.

capítulo 15 Mejorar el rendimiento con Conjuntos Conjuntos le puede dar un impulso en la precisión en su conjunto de datos. En este capítulo usted descubrirá cómo se puede crear algunos de los más poderosos tipos de conjuntos en Python usando scikit-learn. Esta lección le guiará a través del impulso, embolsado y la votación por mayoría y le mostrará cómo se puede seguir trinquete hasta la exactitud de los modelos en sus propias bases de datos. Después de completar esta lección sabrá:

1. Cómo utilizar métodos embolsado conjuntos tales como los árboles de decisión, en bolsas al azar forestal y árboles adicionales.

2. Cómo usar impulsar métodos conjuntos tales como los AdaBoost y el gradiente estocástico impulsar.

3. Cómo usar métodos de votación de conjunto para combinar las predicciones de varios algoritmos.

Empecemos.

15.1 Combinar Modelos En predicciones por conjuntos Los tres métodos más populares para combinar las predicciones de los modelos di ff Erent son: ?? Harpillera. La construcción de múltiples modelos (normalmente del mismo tipo) de submuestras Erent di ff 

de la formación de datos. ?? Impulsar. La construcción de modelos múltiples (típicamente del mismo tipo), cada uno de los cuales aprende a

fi x los errores de predicción de un modelo anterior en la secuencia de modelos. ?? Votación. La construcción de múltiples modelos (por lo general de tipo di f f Ering) y estadísticas s imples (como

el cálculo de la media) se utiliza para combinar las predicciones.

Esto presupone que está generalmente familiarizado con algoritmos de aprendizaje automático y métodos de conjunto y no voy a entrar en los detalles de cómo funcionan los algoritmos o sus parámetros. El inicio indios Pima de diabetes de datos se utiliza para demostrar cada algoritmo. Cada conjunto algoritmo se demuestra usando la validación cruzada 10 veces y la clasi fi cación métrica de rendimiento de precisión.

91

15.2. Algoritmos de ensacado 

92

15,2 embolsado Algoritmos La agregación de arranque (o ensacado) consiste en tomar varias muestras de su formación de datos (con reemplazo) y la formación de un modelo para cada muestra. La predicción de salida final es un promedio a través de las predicciones de todos los sub-modelos. Los tres modelos de ensacado tratados en esta sección son los siguientes:

?? Embolsados árboles de decisión.

?? Bosque aleatoria. ?? Los árboles adicionales.

15.2.1 embolsados árboles de decisión Embolsado funciona mejor con algoritmos que tienen una alta varianza. Un ejemplo muy conocido son los árboles de decisión,

En el siguiente ejemplo es un ejemplo de la utilización de la BaggingClassifier con el fi cación Classi y algoritmo de regresión Trees ( DecisionTreeClassifier  crean un total de 100 árboles. a menudo construidas sin poda.

# Árboles de decisión en bolsas para la clasificación importar pandas de sklearn importar validación cruzada de sklearn.ensemble importar BaggingClassifier  de sklearn.tree importar DecisionTreeClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) carrito = DecisionTreeClassifier () num_trees = 100 Modelo = BaggingClassifier (base_estimator = carro, n_estimators = num_trees, random_state = semilla) r esultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 15.1: Ejemplo de la Decisión Bagged árboles Ensemble algoritmo. Ejecutar el ejemplo, se obtiene una estimación robusta de la exactitud del modelo. ,770745044429

Listado 15.2: La salida de la Decisión Bagged árboles Ensemble algoritmo. 1

http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingClassifier.html

 1  ).  se

93

15.2. Algoritmos de ensacado 

15.2.2 Random Forest Los bosques aleatorios es una extensión de árboles de decisión bolsas. Las muestras de la formación de datos se toman con el reemplazo, pero los árboles están construidos de una manera que reduce la correlación entre ERS fi caciones individuales. Específicamente, en lugar de elegir con avidez el mejor punto de división en la construcción de cada árbol, sólo un subconjunto aleatorio de características se consideran para cada división. Se puede construir un modelo de bosque aleatorio para clasi fi cación mediante el RandomForestCla

clase 2 . El siguiente ejemplo muestra el uso de Random Bosque para clasi fi con 100 árboles y puntos de división elegidos de una selección aleatoria de 3 características. # Clasificación Random Forest importar pandas de sklearn importar validación cruzada de sklearn.ensemble importar RandomForestClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

num_trees = 100 max_features = 3 kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = RandomForestClassifier (n_estimators = num_trees, max_features = max_features) resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 15.3: Ejemplo de Random Forest Ensemble algoritmo. Ejecución del ejemplo proporciona una estimación de la media de precisión clasi fi cación. ,770727956254

Listado 15.4: Salida del Bosque aleatoria Ensemble algoritmo.

15.2.3 Los árboles extra Los árboles adicionales son otra modi fi cación de ensacado, donde árboles al azar se construyen a partir de muestras de la formación de datos. Es posible construir un modelo de árboles adicional para clasi fi cación mediante el ExtraTreesClassifier clase  3  . E   l siguiente ejemplo proporciona una demostración de árboles adicion ales con el número de árboles establecidos a 100 y divisiones elegidas a partir de 7 funciones aleatorias. # Clasificación adicional árboles importar pandas de sklearn importar validación cruzada de sklearn.ensemble importar ExtraTreesClassifier url = "Https://goo.gl/vhm1eU"

2 http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.

html

3 http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier. html

94

15.3. impulsar Algoritmos 

nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

num_trees = 100 max_features = 7 kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = ExtraTreesClassifier (n_estimators = num_trees, max_features = max_features) resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Listado 15.5: Ejemplo de árboles adicional Ensemble algoritmo. Ejecución del ejemplo proporciona una estimación de la media de precisión clasi fi cación. ,760269993165

Listado 15.6: La producción de árboles adicional Ensemble algoritmo.

15.3 Algoritmos Impulso Impulsar algoritmos de conjunto crea una secuencia de modelos que tratan de corregir los errores de los modelos delante de ellos en la secuencia. Una vez creados, los modelos hacen predicciones que pueden ser ponderados por su exactitud demostrada, y los resultados se combinan para crear una predicción de salida final. Los dos algoritmos de aprendizaje automático impulsar conjunto más comunes son: ?? AdaBoost. ?? Impulsar estocástico degradado.

15.3.1 AdaBoost AdaBoost fue quizás la primera impulsar con éxito conjunto algoritmo. Por lo general, funciona por instancias de ponderación en el conjunto de datos por lo fácil o di fi culto son para clasificar, lo que permite que el algoritmo de pagar o menos atención a ellos en la construcción de modelos posteriores. Se puede construir un modelo AdaBoost para clasi fi cación mediante el AdaBoostClassifier clase 4  . E   l siguiente ejemplo demuestra la construcción de 30 árboles de decisión en la secuencia utilizando el algoritmo  d e AdaBoost.

# Clasificación AdaBoost importar pandas de sklearn importar validación cruzada de sklearn.ensemble importar AdaBoostClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) 4 http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.

html

95

15.3. impulsar Algoritmos 

matriz = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

num_trees = 30 kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = AdaBoostClassifier (n_estimators = num_trees, random_state = semilla) resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Perfil de 15.7: Ejemplo de AdaBoost Ensemble Algorithm. Ejecución del ejemplo proporciona una estimación de la media de precisión clasi fi cación. ,76045796309

Listado 15.8: La salida del algoritmo AdaBoost Ensemble.

15.3.2 Impulsar estocástico Gradiente Stochastic Gradiente Impulsar (también llamado gradiente Impulsar Máquinas) son una de las técnicas por conjuntos más sofisticados. También es una técnica que está demostrando ser quizás una de las mejores técnicas disponibles para mejorar el rendimiento a través de conjuntos. Se puede construir un modelo Impulsar Gradiente de clasi fi cación mediante el GradientBoostingClassifier clase  5  . E   l ejemplo siguiente demuestra estocástico Gradiente Impulsar para clasi fi co n 100 árboles. # Estocástico Gradiente Clasificación Impulsar  importar pandas de sklearn importar validación cruzada de sklearn.ensemble importar GradientBoostingClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

num_trees = 100 kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) Modelo = GradientBoostingClassifier (n_estimators = num_trees, random_state = semilla) resultados = cross_validation.cross_val_score (modelo, X, Y, cv = kfold) impresión (Results.mean ())

Perfil de 15.9: Ejemplo de Stochastic Gradiente Impulsar Ensemble Algorithm. Ejecución del ejemplo proporciona una estimación de la media de precisión clasi fi cación. ,764285714286

Añadir 15.10: Salida del estocástico Gradiente Impulsar Ensemble algoritmo. 5 http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.

GradientBoostingClassifier.html

15.4. La votación Ensemble 

96

15.4 La votación Ensemble El voto es una de las formas más sencillas de combinar las predicciones de varios algoritmos de aprendizaje automático. Funciona mediante la primera creación de dos o más modelos independientes de su conjunto de datos de entrenamiento. A fi cador de votación Clasi puede ser utilizado para envolver sus modelos y promediar las predicciones de los submodelos cuando se le preguntó a hacer predicciones para los nuevos datos. Las predicciones de los sub-modelos pueden ser ponderados, pero la especificación de los pesos para ERS fi caciones manualmente o incluso heurísticamente es di FFI culto. métodos más avanzados pueden aprender a mejor el peso de las predicciones de los sub-modelos, pero esto se denomina apilamiento (agregación apilados) y en la actualidad no se proporciona en scikit-learn.

Puede crear un modelo conjunto de votación para la clasi fi cación mediante el VotingClassifier  clase 6  . El código siguiente proporciona un ejemplo de la combinación de las predicciones de regresión logística, clasificacion y árboles de regresión y las máquinas de vectores de soporte juntos para un problema de clasi fi cación.

# La votación Ensemble para la Clasificación importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística de sklearn.tree importar DecisionTreeClassifier  de sklearn.svm importar SVC de sklearn.ensemble importar VotingClassifier url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] num_folds = 10 num_instances = len (X) de semilla = 7

kfold = cross_validation.KFold (n = num_instances, n_folds = num_folds, random_state = semilla) # crear los modelos sub estimadores = [] model1 = regresión logística () estimators.append (( 'logístico'  , Model1)) model2 = DecisionTreeClassifier () estimators.append (( 'carro' ,  Model2)) MODEL3 = SVC () estimators.append (( '  SVM'  , MODEL3))

# crear el modelo de conjunto ensemble = VotingClassifier (estimadores) resultados = cross_validation.cross_val_score (ensemble, X, Y, cv = kfold) impresión (Results.mean ())

Listado 15.11: Ejemplo de la votación Ensemble algoritmo. Ejecución del ejemplo proporciona una estimación de la media de precisión clasi fi cación. ,729049897471

Listado 15.12: Salida de la votación Ensemble algoritmo. 6

http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.VotingClassifier.html

15.5. Resumen 

97

15.5 Resumen En este capítulo usted descubrió algoritmos de aprendizaje automático de conjunto para mejorar el rendimiento de los modelos en sus problemas. Ha aprendido a: ?? Embolsado Conjuntos incluyendo embolsados árboles de decisión, Bosque aleatoria y árboles adicionales.

?? Impulsar Conjuntos incluyendo AdaBoost y estocástico Gradiente impulsar. ?? Conjuntos de votación para el promedio de las predicciones para los modelos arbitrarios.

15.5.1 Siguiente En la siguiente sección se descubrirá otra técnica que se puede utilizar para mejorar el rendimiento de los algoritmos en su conjunto de datos denominado algoritmo de sintonía.

capítulo 16 Mejorar el rendimiento con el algoritmo de sintonización

modelos de aprendizaje automático se parametrizan de manera que su comportamiento puede ser sintonizado para un problema dado. Los modelos pueden tener muchos parámetros y hallazgo la mejor combinación de parámetros pueden tratarse como un problema de búsqueda. En este capítulo usted descubrirá cómo ajustar los parámetros de algoritmos de aprendizaje automático en Python utilizando el scikit- learn. Después de completar esta lección sabrá:

1. La importancia del ajuste de parámetros algoritmo para mejorar el rendimiento del algoritmo. 2. Cómo usar una estrategia de sintonía algoritmo de búsqueda rejilla.

3. Cómo usar una estrategia aleatoria algoritmo de búsqueda de sintonía.

Empecemos.

16.1 Parámetros de la máquina Algoritmo de Aprendizaje tuning algoritmo es un paso fi nal en el proceso de aprendizaje de la máquina aplicada antes de fi nalizar su modelo. A veces se llama optimización hiperparámetro donde los parámetros del algoritmo se denominan hiperparámetros, mientras que los coe fi cientes que se encuentran por el propio algoritmo de aprendizaje automático se conocen como parámetros. Optimización sugiere la búsqueda en la naturaleza del problema. Expresado como un problema de búsqueda, puede utilizar estrategias de búsqueda di ff Erent de encontrar un parámetro buena y sólida o un conjunto de parámetros de un algoritmo en un problema dado. Python scikit-learn proporciona dos métodos sencillos para el algoritmo de ajuste de parámetros:

?? Rejilla de búsqueda de parámetros de sintonización. ?? Buscar aleatoria de parámetros de sintonización.

16.2 cuadrícula de búsqueda de parámetros de sintonización Rejilla de búsqueda es una aproximación al parámetro de ajuste que metódicamente va a construir y evaluar un modelo para cada combinación de parámetros del algoritmo se especifica en una cuadrícula. Puede realizar una cuadrícula

98

99

16.3. Buscar aleatoria de parámetros de sintonización 

realizar búsquedas con los GridSearchCV clase  1  .  E l e jemplo siguiente evalúa Erent di ff alfa valores para el algoritmo de regresión contraída en la diabetes de datos estándar. Se trata de una red de búsqueda unidimensional.

# Rejilla de búsqueda para el algoritmo de sintonización importar pandas importar numpy

de sklearn importar validación cruzada de sklearn.linear_model importar Cresta de sklearn.grid_search importar GridSearchCV url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8]

alfas = numpy.array ([1,0.1,0.01,0.001,0.0001,0]) param_grid = dict (Alfa = alfas) Modelo = cresta () rejilla = GridSearchCV (estimador = modelo, param_grid = param_grid) grid.fit (X, Y) impresión (Grid.best_score_) impresión (Grid.best_estimator_.alpha)

Listado 16.1: Ejemplo de una red de búsqueda de parámetros del algoritmo. Ejecución del ejemplo se enumeran a cabo la puntuación óptima logrado y el conjunto de parámetros en la cuadrícula que consigue que la puntuación. En este caso, el alfa valor de 1,0. ,279617559313 1.0

Listado 16.2: la salida de una red de búsqueda de parámetros del algoritmo.

16.3 búsqueda aleatoria de parámetros de sintonización búsqueda aleatoria es un enfoque de ajuste de parámetros que muestra parámetros del algoritmo de una distribución aleatoria (es decir, uniforme) para un fijada número de iteraciones. Un modelo se construye y evalúa para cada combinación de parámetros elegidos. Puede realizar una búsqueda aleatoria de parámetros del algoritmo utilizando el RandomizedSearchCV clase 2  . E   l ejemplo siguiente evalúa di ff Erent azar alfa los valores entre 0 y 1 para  e l algoritmo de regresión contraída en la diabetes de datos estándar. Un total de 100 iteraciones se realizan con uniformemente aleatorio alfa valores seleccionados en el rango entre 0 y 1 (el rango que alfa Los valores pueden tomar). # Aleatorizado para el algoritmo de sintonización importar pandas importar numpy

de scipy.stats importar uniforme de sklearn.linear_model importar Cresta de sklearn.grid_search importar RandomizedSearchCV 1

http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.GridSearchCV.html

2 http://scikit-learn.org/stable/modules/generated/sklearn.grid_search.RandomizedSearchCV.

html

100

16.4. Resumen 

url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] = {param_grid 'alfa' :  Uniforme ()} semilla = 7

Modelo = cresta () iteraciones = 100 Rsearch = RandomizedSearchCV (estimador = modelo, param_distributions = param_grid, n_iter = iteraciones, random_state = semilla) rsearch.fit (X, Y) impresión (Rsearch.best_score_) impresión(Rsearch.best_estimator_.alpha)

Listado 16.3: Ejemplo de una búsqueda aleatoria de parámetros del algoritmo. Ejecutar el ejemplo produce resultados muy similares a los del ejemplo de búsqueda cuadrícula anterior. una óptima alfa valor cerca de 1,0 se descubre. ,279617354112 ,989527376274

Listado 16.4: la salida de una búsqueda aleatoria de parámetros del algoritmo.

16.4 Resumen Algoritmo parámetro de ajuste es un paso importante para la mejora de rendimiento de los algoritmos derecha antes de presentar los resultados o la preparación de un sistema para la producción. En este capítulo usted descubrió ajuste de parámetros del algoritmo y dos métodos que se pueden utilizar en este momento en Python y scikit-learn para mejorar los resultados del algoritmo:

?? Rejilla de búsqueda de parámetros de sintonización ?? Buscar aleatoria de parámetros de sintonización

16.4.1 Siguiente Esta lección concluye la cobertura de las técnicas que se pueden utilizar para mejorar el rendimiento de los algoritmos en su conjunto de datos. En la lección siguiente y final usted descubrirá cómo puede fi nalizar su modelo para utilizarlo en los datos que no se ven.

capítulo 17 Guardar y modelos de aprendizaje carga de la máquina

La búsqueda de un modelo de aprendizaje de máquina precisa no es el final del proyecto. En este capítulo usted descubrirá cómo guardar y cargar su modelo de aprendizaje automático en Python usando scikit-learn. Esto le permite guardar su modelo para archivar y cargarlo más tarde con el fin de hacer predicciones. Después de completar esta lección sabrá:

1. La importancia de la serialización de modelos para su reutilización. 2. Cómo utilizar conservar en vinagre para serializar y deserializar modelos de aprendizaje automático.

3. Modo de empleo JOBLIB para serializar y deserializar modelos de aprendizaje automático.

Empecemos.

17.1 Finalizar su modelo con salmuera Pepinillo es la forma estándar de la serialización de objetos en Python. Se puede utilizar el conservar en vinagre 1 operación par a serializar sus algoritmos de aprendizaje automático y guardar el formato serializado a un archivo. Más tarde se puede cargar este fi l deserializar su modelo y lo utilizan para hacer nuevas predicciones. El siguiente ejemplo muestra cómo se puede entrenar un modelo de regresión logística en el inicio de la diabetes indios Pima conjunto de datos, guardar el modelo para archivar y cargarlo para hacer predicciones sobre el equipo de prueba no se ve.

# Guardar utilizando el modelo de l a salmuera importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística importar salmuera url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] test_size = 0,33

1 https://docs.python.org/2/library/pickle.html

101

17.2. Finalizar su modelo con JOBLIB 

102

semilla = 7

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split (X, Y, test_size = test_size, random_state = semilla) # Montar el modelo en 33% Modelo = regresión logística () model.fit (X_train, Y_train) # guardar el modelo en el disco archivo = 'Finalized_model.sav' pickle.dump (modelo, abierto (nombre del archivo, 'Wb' ))

# algún tiempo después... # cargar el modelo del disco loaded_model = pickle.load ( abierto (  nombre del archivo, 'Rb' )) Resultado = loaded_model.score (X_test, Y_test) impresión (resultado)

Listado 17.1: Ejemplo del uso de la salmuera para serializar y deserializar un modelo.

Ejecutar el ejemplo guarda el modelo de model.sav finalizado en su directorio de trabajo local. Cargar el modelo guardado y evaluación que proporciona una estimación de la precisión del modelo de datos que no se ven.

,755905511811

Listado 17.2: Salida de la utilización de salmuera para serializar y deserializar un modelo.

17.2 Finalizar su modelo con JOBLIB los JOBLIB 2 biblioteca es parte del ecosistema SciPy y proporciona utilidades para la canalización empleos de Python. Se proporciona utilidades para los objetos de ahorro y Python carga que hacen uso de estructuras de datos NumPy, e fi cientemente  3  . E   sto puede ser útil para algunos algoritmos de aprendizaje automático que requieren una gran cantidad de parámetros o almacenan todo el conjunto de datos (por ejemplo, K-vecinos más cercanos). El siguiente ejemplo muestra cómo se puede entrenar un modelo de regresión logística en el inicio de la diabetes indios Pima conjunto de datos, guardar el modelo a archivar usando JOBLIB y cargarlo para hacer predicciones sobre el equipo de prueba no se ve.

# Guardar modelo Usando JOBLIB importar pandas de sklearn importar validación cruzada de sklearn.linear_model importar Regresión logística de sklearn.externals importar JOBLIB url = "Https://goo.gl/vhm1eU" nombres = [ 'Preg'  , '' plas , '' pres , 'piel' , 'prueba' , 'masa' , 'Pedi' , 'años' , 'clase' ] Trama de datos = pandas.read_csv (url, nombres = nombres) Array = dataframe.values X = array [:, 0: 8] Y = array [:, 8] test_size = 0,33 semilla = 7

2 https://pypi.python.org/pypi/joblib 3

https://pythonhosted.org/joblib/generated/joblib.dump.html

17.3. Consejos para la finalización de su Modelo 

103

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split (X, Y, test_size = test_size, random_state = semilla) # Montar el modelo en 33% Modelo = regresión logística () model.fit (X_train, Y_train) # guardar el modelo en el disco archivo = 'Finalized_model.sav'  joblib.dump (modelo, nombre de archivo)

# algún tiempo después... # cargar el modelo del disco loaded_model = joblib.load (filename) resultado = loaded_model.score (X_test, Y_test) impresión (resultado)

Listado 17.3: Ejemplo del uso de JOBLIB para serializar y deserializar un modelo.

Ejecutar el ejemplo guarda el modelo para archivar como model.sav finalizado y también crea una fi l para cada matriz NumPy en el modelo (cuatro fi adicional les). Después se carga el modelo se informó de una estimación de la precisión del modelo de datos no se ve. ,755905511811

Listing 17.4: La salida de la utilización de JOBLIB para serializar y deserializar un modelo.

17.3 Consejos para la finalización de su Modelo Esta sección enumera algunas consideraciones importantes al fi nalizar sus modelos de aprendizaje automático.

?? La versión de Python. Tomar nota de la versión de Python. Es casi seguro que requiere la misma versión principal (y tal vez menor) de Python utiliza para serializar el modelo cuando posteriormente se lo carga y deserializar ella. ?? Versiones de la biblioteca. La versión de las principales bibliotecas utiliza en su aprendizaje automático

proyecto casi con toda seguridad tiene por qué ser el mismo al deserializar un modelo guardado. Esto no se limita a la versión de NumPy y la versión de scikit-learn. ?? La serialización manual. Es posible que como a la salida manualmente los parámetros de su modelo aprendido que se puede utilizar directamente en scikit-learn u otra plataforma en el futuro. A menudo, las técnicas utilizadas internamente por algoritmos de aprendizaje automático para hacer predicciones son mucho más simples que las que se utilizan para conocer los parámetros se puede ser fácil de implementar en el código personalizado que usted tiene control sobre.

Tomar nota de la versión para que pueda volver a crear el medio ambiente si por alguna razón no se puede volver a cargar el modelo en otra máquina u otra plataforma en un momento posterior.

17.4 Resumen En este capítulo has descubierto cómo conservar sus algoritmos de aprendizaje automático en Python con scikit-learn. Aprendiste dos técnicas que se pueden utilizar:

17.4. Resumen 

104

?? los conservar en vinagre API para la serialización de objetos estándar de Python.

?? los JOBLIB API para la e fi cientemente la serialización de objetos Python con matrices NumPy.

17.4.1 Siguiente Con esto concluye sus lecciones de aprendizaje automático en Python con ScyPy y scikit-learn. A continuación en la Parte III va a unir todo lo que ha aprendido y trabajar a través de extremo a extremo aplicado proyectos de aprendizaje automático.

Parte III proyectos

105

capítulo 18 Plantilla de proyecto de modelado predictivo aprendizaje automático aplicada es una habilidad empírica. No se puede conseguir mejor en él mediante la lectura de libros y artículos. Tienes que practicar. En esta lección usted descubrirá la plantilla de proyecto de aprendizaje automático de seis pasos simples que usted puede utilizar para poner en marcha su proyecto en Python. Después de completar esta lección sabrá:

1. Cómo estructurar un proyecto de modelado predictivo de extremo a extremo. 2. ¿Cómo asignar las tareas sobre los cuales aprendiste en la segunda parte en un proyecto.

3. ¿Cómo utilizar mejor la plantilla de proyecto estructurado para asegurar un resultado preciso para su conjunto de datos.

Empecemos.

18.1 Práctica máquina de aprendizaje con proyectos Trabajando a través de problemas de aprendizaje automático de extremo a extremo, es de importancia crítica. Usted puede leer sobre el aprendizaje automático. También puede probar pequeñas recetas ff One-O. Sin embargo, el aprendizaje automático aplicado no cobrará vida para usted hasta que se trabaja a través de un conjunto de datos de principio a fin.

Trabajando a través de unas fuerzas de proyectos que pensar en cómo se utilizará el modelo, para desafiar sus suposiciones y ser bueno en todas las partes de un proyecto, no sólo sus partes favoritas. La mejor manera de practicar proyectos de aprendizaje de máquina de modelado predictivo es el uso de conjuntos de datos estandarizados de la UCI Machine Learning Repositorio. Una vez que tenga un conjunto de datos práctica y un montón de recetas de Python, ¿cómo poner todo junto y el trabajo a través del problema de extremo a extremo?

18.1.1 Uso Un paso a paso proceso estructurado Cualquier proyecto de aprendizaje de máquina de modelado predictivo puede ser dividido en seis tareas comunes:

1. De fi ne problema.

2. Resumir datos. 3. Preparar los datos.

106

18.2. Plantilla del proyecto Machine Learning en Python 

107

4. Evaluar Algoritmos. 5. mejorar los resultados. 6. Los resultados presentes.

Las tareas pueden ser combinados o descomponen más, pero esto es la estructura general. Para trabajar a través de modelado predictivo problemas de aprendizaje automático en Python, será necesario asignar Python en este proceso. Las tareas pueden necesitar ser adaptados o cambiado de nombre ligeramente para adaptarse a la forma del pitón de hacer las cosas (por ejemplo, las pandas para la carga y los datos scikit-learn para el modelado). La siguiente sección proporciona exactamente esta asignación y elabora cada tarea y los tipos de sub-tareas y bibliotecas que se pueden utilizar.

18.2 plantilla de proyecto de aprendizaje automático en Python En esta sección se presenta una plantilla de proyecto que puede utilizar para resolver problemas de aprendizaje automático en Python extremo a extremo.

Plantilla 18.2.1 Resumen A continuación se muestra la plantilla de proyecto que puede utilizar en sus proyectos de aprendizaje automático en Python.

# Plantilla de proyecto Python # 1. Preparar Problema # a) las bibliotecas de carga # b) Carga conjunto de datos # 2. Datos Resumir  # a) Estadística descriptiva # b) Visualizaciones de datos # # # # # # # # #

3. Preparar los datos

a) Limpieza de datos b) Selección de características

c) Datos Transformadas

4. Evaluar Algoritmos a) validación de datos de salida de Split b) las opciones de prueba y evaluación métrica c) verificación al azar A lgoritmos d) Comparación de algoritmos

# 5. Mejorar la Precisión # a) Algoritmo de sintonización # b) Conjuntos # # # #

6. Finalizar Modelo a) Las predicciones para el conjunto de datos de validación

b) Crear modelo autónomo en toda formación de datos c) Guardar modelo para su uso posterior 

Listado 18.1: plantilla de proyecto de aprendizaje de máquina de modelado predictivo.

18.3. Machine Learning proyecto de plantilla Pasos 

108

18.2.2 Cómo utilizar la plantilla de proyecto 1. Crear un nuevo archivo para su proyecto (por ejemplo, name.py proyecto).

2. Copia de la plantilla de proyecto.

3. pegar en su proyecto vacío fi l. 4. Comenzar a llenar en, usando recetas de este libro y otros.

18.3 Machine Learning proyecto de plantilla Pasos Esta sección proporciona algunos detalles adicionales sobre cada uno de los pasos de la plantilla.

18.3.1 Preparar Problema Este paso es sobre la carga de todo lo necesario para empezar a trabajar en su problema. Esto incluye:

?? módulos de Python, clases y funciones que se vayan a utilizar. ?? Cargando el conjunto de datos desde CSV.

Este es también el hogar de cualquier fi guración con mundial puede que tenga que hacer. También es el lugar donde puede que tenga que tomar una muestra reducida de su conjunto de datos si es demasiado grande como para trabajar con ellos. Lo ideal es que el conjunto de datos debe ser lo suficientemente pequeño como para construir un modelo o crear una visualización en un minuto, lo ideal es 30 segundos. Siempre se puede ampliar modelos bien que realizan más tarde.

18.3.2 Datos Resumir  Este paso se acerca mejor comprensión de los datos que tiene disponible. Esto incluye la comprensión de sus datos mediante: ?? Las estadísticas descriptivas tales como resúmenes.

?? visualizaciones de datos, tales como las parcelas con Matplotlib, idealmente utilizando las funciones de confort de

Pandas. Tómese su tiempo y utilizar los resultados para llevar a un montón de preguntas, suposiciones e hipótesis que se puede investigar más tarde con modelos especializados.

18.3.3 Preparación de Datos Este paso se trata de la preparación de los datos de una manera tal que mejor expone la estructura del problema y las relaciones entre sus atributos de entrada con la variable de salida. Esto incluye tareas tales como:

?? Limpieza de datos mediante la eliminación de duplicados, marcando los valores perdidos e incluso la imputación de falta

valores.

18.3. Machine Learning proyecto de plantilla Pasos 

109

?? La selección de características donde las características redundantes se puede quitar y desarrolló nuevas características.

?? Los datos se transforma en atributos se escalan o redistribuidos a fin de exponer la mejor  estructura del problema después de algoritmos de aprendizaje.

Inicio simple. Vuelve a menudo este paso y el ciclo con el siguiente paso hasta que convergen en un subconjunto de algoritmos y una presentación de los datos que se traduce en modelos precisos o exactos suficiente para continuar.

18.3.4 Evaluar Algoritmos Este paso es de aproximadamente hallazgo de un subconjunto de los algoritmos de aprendizaje automático que son buenos en la explotación de la estructura de los datos (por ejemplo, tienen la habilidad mejor que la media). Esto implica etapas tales como:

?? La separación de un conjunto de datos de validación a utilizar para su posterior confirmación de la habilidad de su

modelo desarrollado. ?? De fi nir las opciones de prueba utilizando scikit-learn como la validación cruzada y la métrica de evaluación

usar. ?? De controles in situ un conjunto de algoritmos de aprendizaje automático lineales y no lineales.

?? Al comparar la precisión estimada de algoritmos. En un problema dado es probable que pasar la mayor parte de su tiempo en esto y el paso anterior hasta que convergen en un conjunto de 3 a 5 en el desempeño así algoritmos de aprendizaje automático.

18.3.5 mejorar la precisión Una vez que tenga una lista de algoritmos de aprendizaje automático, que necesita para obtener el máximo provecho de ellos. Hay dos maneras di ff Erent para mejorar la precisión de los modelos:

?? Buscar una combinación de parámetros para cada algoritmo utilizando scikit-learn que los rendimientos los mejores resultados.

?? Combinar la predicción de múltiples modelos en un conjunto de predicción utilizando ensemble

técnicas. La línea entre esto y el paso anterior puede distorsionar cuando un proyecto se concreta. Puede haber un poco de sintonía algoritmo en el paso anterior. Y en el caso de los conjuntos, puede llevar más de una lista de algoritmos transmita a combinar sus predicciones.

18.3.6 Finalizar Modelo Una vez que haya encontrado un modelo que usted cree que puede hacer predicciones precisas sobre los datos que no se ven, ya está listo para fi nalizar la misma. Finalización de un modelo puede implicar sub-tareas tales como: ?? Usando un modelo óptimo puesto a punto por scikit-learn para hacer predicciones sobre los datos que no se ven.

?? La creación de un modelo independiente utilizando los parámetros ajustados por scikit-learn.

18.4. Sugerencias para usar la plantilla Bueno 

110

?? Almacenamiento de un modelo óptimo para archivar para su uso posterior.

Una vez que llegan tan lejos que esté listo para presentar los resultados a las partes interesadas y / o implementar su modelo para empezar a hacer predicciones sobre los datos que no se ven.

18.4 Sugerencias para usar la plantilla Bueno En esta sección se enumeran sugerencias que se pueden utilizar para hacer la mayor parte de la plantilla de proyecto de aprendizaje automático en Python.

?? Fast primera pasada. Hacer un pase primero-Fi a través de los pasos del proyecto lo más rápido posible. Esta

le dará la confianza que tiene todas las piezas que usted necesita y una línea de base desde la que mejorar.

?? Ciclos. El proceso en no lineal, sino cí clico. Usted hará un bucle entre los pasos, y probablemente probablemente

pasar la mayor parte de su tiempo en los bucles entre los pasos 3-4 o 3-4-5 hasta que logre un nivel de precisión que es su ciente fi o se le acaba el tiempo. ?? Tratar a cada paso. Es fácil saltarse los pasos, especialmente si usted no está con fi abolladura o

familiarizados con las tareas de ese paso. Tratar de hacer algo en cada paso del proceso, incluso si no mejora la precisión. Siempre se puede construir sobre él más tarde. No se salte pasos, simplemente reducir su contribución.

?? Precisión trinquete. El objetivo del proyecto es la exactitud del modelo. Cada paso contribuye para lograr este objetivo. El tratamiento de los cambios que realice como experimentos que aumentan la precisión que el camino de oro en el proceso y reorganizar otros pasos que les rodean. La precisión es un trinquete que sólo puede moverse en una dirección (mejor, no peor). ?? Adaptar según sea necesario. Modificar los pasos que necesite en un proyecto, especialmente a medida que se

con más experiencia con la plantilla. Difuminar los bordes de tareas, tales como los pasos 4-5 para servir mejor a la exactitud del modelo.

18.5 Resumen En esta lección usted descubrió una plantilla de proyecto de aprendizaje automático en Python. Se expuso los pasos de un proyecto de aprendizaje de máquina de modelado predictivo, con el objetivo de maximizar la precisión del modelo. Puede copiar y pegar la plantilla y utilizarla para poner en marcha su proyecto de aprendizaje de máquina actual o siguiente en Python.

18.5.1 Paso siguiente Ahora que ya sabe cómo estructurar un proyecto de aprendizaje máquina de modelado predictivo en Python, es necesario poner este conocimiento para su uso. En la siguiente lección que va a trabajar a través de un sencillo problema de estudio de casos de extremo a extremo. Se trata de un estudio de casos y de la famosa  Hola Mundo de los proyectos de aprendizaje automático.

capítulo 19 Su primera máquina Proyecto de Aprendizaje en Python Paso a Paso Es necesario para ver cómo todas las piezas de un proyecto de aprendizaje de máquina de modelado predictivo realidad encajan juntos. En esta lección completar su proyecto de aprendizaje primera máquina de ficción usando Python. En este proyecto tutorial paso a paso, usted:

?? Descargar e instalar Python SciPy y obtener el paquete más útil para el aprendizaje automático

en Python. ?? Cargar un conjunto de datos y comprender su estructura usando resúmenes estadísticos estadísticos y datos visual-

ización. ?? Crear 6 modelos de aprendizaje automático, escoger el mejor y construir la c onfianza de que la precisión es de confianza.

Si usted es una máquina de aprendizaje para principiantes y mirando a fi nalmente a comenzar a utilizar Python, este tutorial fue diseñado para usted. ¡Empecemos! ¡Empecemos!

19.1 El Mundo Hola de la máquina de aprendizaje El mejor pequeño proyecto para comenzar con una nueva herramienta es la clasi fi c ación del iris fl ores. Este es un buen conjunto de datos para su proyecto primero porque está muy bien entendido.

?? Los atributos son numéricos lo que tiene que cifra la manera de cargar y manejar datos.

?? Es un problema de clasi fi cación, lo que le permite practicar con un tipo más fácil de supervisión algoritmo de aprendizaje.

?? Es un problema de clasi fi cación multiclase (multi-nominal) que puede requerir algunas especializadas

manejo. ?? Sólo tiene 4 atributos y 150 filas, lo que significa que es pequeño y fácilmente fi cios en la memoria (y

una pantalla o una sola hoja de papel). ?? Todos los atributos numéricos están en las mismas unidades y la misma escala que no requiere ningún escalamiento o transformadas especial para empezar.

111

112

19.2. Cargar los datos 

En este tutorial vamos a trabajar a través de un pequeño proyecto de aprendizaje automático de extremo a extremo. He aquí un resumen de lo que vamos a cubrir: 1. Carga del conjunto de datos.

2. Al resumir el conjunto de datos. 3. Visualizar el conjunto de datos. 4. La evaluación de algunos algoritmos.

5. Hacer algunas predicciones.

Tómese su tiempo y trabajo a través t ravés de cada paso. Trate de escribir los comandos sí mismo o copiar y pegar los comandos para acelerar las cosas. Comience su entorno interactivo de Python y vamos a empezar con su  Hola Mundo proyecto de aprendizaje de máquina en Python.

19.2 cargar los datos En este paso vamos a cargar las bibliotecas y los datos CSV iris fi l de la URL.

19.2.1 Importación de bibliotecas En primer lugar, vamos a importar todos los módulos, funciones y objetos que vamos a utilizar en este tutorial. # bibliotecas de carga importar pandas de pandas.tools.plotting importar scatter_matrix importar matplotlib.pyplot como PLT de sklearn importar validación cruzada de sklearn.metrics importar classification_report de sklearn.metrics importar matriz de confusión de sklearn.metrics importar accuracy_score de sklearn.linear_model importar Regresión logística de sklearn.tree importar DecisionTreeClassifier  de sklearn.neighbors importar KNeighborsClassifier  de sklearn.discriminant_analysis importar LinearDiscriminantAnalysis de sklearn.naive_bayes importar GaussianNB de sklearn.svm importar SVC

Listing 19.1: bibliotecas de carga.

Todo debe cargar sin error. Si usted tiene un error, deténgase. Es necesario un entorno de trabajo SciPy antes de continuar. Ver las indicaciones en el capítulo  2 sobre la configuración de su e ntorno. ntorno.

19.2.2 Cargar conjunto de datos Podemos cargar los datos directamente desde el repositorio UCI Machine Learning. Estamos utilizando las pandas para cargar los datos. También utilizaremos pandas junto a explorar los datos tanto con la estadística descriptiva y la visualización de datos. Tenga en cuenta que estamos especificando los nombres de cada columna al cargar los datos. Esto ayudará más tarde cuando se exploran los datos.

113

19.3. Resumir el conjunto de datos 

# Cargar conjunto de datos url = "Https://goo.gl/mLmoIz" nombres = [ 'Sépalo de longitud'  , 'Sépalo-width' , 'Pétalo de longitud' , 'Pétalo-width' , 'clase' ] Conjunto de datos = pandas.read_csv (url, nombres = nombres) Listado 19.2: Cargar el conjunto de datos del iris.

El conjunto de datos debe cargar sin incidentes. Si usted tiene problemas de red, se puede descargar el iris.data fi l 1 en su directorio de trabajo y cargarlo con el mismo método, el cambio de dirección URL a la fi local de nombre de archivo.

19.3 Resumir el conjunto de datos Ahora es el momento de echar un vistazo a los datos. En este paso vamos a echar un vistazo a los datos de algunas maneras Erent di ff:

?? Dimensiones del conjunto de datos.

?? Vistazo a los datos en sí. ?? Resumen estadístico de todos los atributos. ?? Desglose de los datos por parte de la variable de clase.

No se preocupe, cada una ojeada a los datos es un comando. Estos son comandos útiles que se pueden utilizar una y otra vez en proyectos futuros.

19.3.1 Las dimensiones de conjunto de datos Podemos tener una idea rápida de cómo muchos casos (filas) y el número de atributos (columnas) contiene los datos con la propiedad de forma. # forma impresión (Dataset.shape)

Listing 19.3: Imprimir la forma del conjunto de datos.

Debería ver 150 casos y 5 atributos: (150, 5)

Listado 19.4: La salida de forma del conjunto de datos.

19.3.2 vistazo a los datos También es siempre una buena idea para calcular visualmente realidad sus datos.

# cabeza impresión (Dataset.head (20)) Listing 19.5: Imprimir las primeras pocas filas del conjunto de datos.

  ttps://goo.gl/mLmoIz 1h

114

19.3. Resumir el conjunto de datos 

Debería ver los primeros 20 filas de los datos: clase

sépalo de longitud sépalo ancho de pétalo de longitud pétalo de ancho 0 1 2 3 4 5 6 7 8 9

10 11 12 13 14 15 dieciséis

17 18 19

5.1 4.9 4.7 4.6 5.0 5.4 4.6 5.0 4.4 4.9 5.4 4.8 4.8 4.3 5.8 5.7 5.4 5.1 5.7 5.1

3.5 3.0 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 3.7 3.4 3.0 3.0 4.0 4.4 3.9 3.5 3.8 3.8

1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 1.5 1.6 1.4 1.1 1.2 1.5 1.3 1.4 1.7 1.5

0,2 Iris-setosa 0,2 Iris-setosa 0,2 Iris-setosa 0,2 Iris-setosa 0,2 Iris-setosa 0,4 Iris-setosa 0,3 Iris-setosa 0,2 Iris-setosa 0,2 Iris-setosa 0,1 Iris-setosa 0,2 Iris-setosa 0,2 Iris-setosa 0,1 Iris-setosa 0,1 Iris-setosa 0,2 Iris-setosa 0,4 Iris-setosa 0,4 Iris-setosa 0,3 Iris-setosa 0,3 Iris-setosa 0,3 Iris-setosa

Listing 19.6: La salida de la primera pocos filas del conjunto de datos.

19.3.3 Resumen estadístico Ahora podemos echar un vistazo a un resumen de cada atributo. Esto incluye el recuento, media, la valores mínimo y máximo, así como algunos percentiles. # descripciones impresión (Dataset.describe ())

Listado 19.7: Imprimir las descripciones estadísticas del conjunto de datos.

Podemos ver que todos los valores numéricos tienen la misma escala (centímetros) y rangos similares entre 0 y 8 centímetros. sépalo de longitud sépalo ancho de pétalo de longitud pétalo de ancho de recuento

media

std min 25% 50% 75%

máx

150.000000 150.000000 150.000000 150.000000 5.843333 3.054000 3.758667 0.828066 0.433594 1.764420 4.300000 2.000000 1.000000 5.100000 2.800000 1.600000 5.800000 3.000000 4.350000 6.400000 3.300000 5.100000 7.900000 4.400000 6.900000

1.198667 0.763161 0.100000 0.300000 1.300000 1.800000 2.500000

Listado 19.8: La salida de las descripciones estadísticas del conjunto de datos.

19.3.4 Clase Distribución Ahora vamos a echar un vistazo a la cantidad de instancias (filas) que pertenecen a cada clase. Podemos ver esto como un recuento absoluto.

19.4. Visualización de datos 

115

# distribución de clases impresión (Dataset.groupby (  'clase' )  .tamaño())

Listing 19.9: Imprimir la distribución de clases en el conjunto de datos.

Podemos ver que cada clase tiene el mismo número de casos (50 o 33% del conjunto de datos). clase Iris-setosa 50 Iris-versicolor 50 Iris-virginica 50

Listado 19.10: Salida de la distribución de clases en el conjunto de datos.

La visualización de datos 19.4 Ahora tenemos una idea básica acerca de los datos. Debemos ampliar esto con algunas visualizaciones. Vamos a tener en cuenta dos tipos de parcelas: ?? parcelas univariados para comprender mejor cada atributo.

?? parcelas multivariantes para comprender mejor las relaciones entre los atributos.

19.4.1 Parcelas univariados Vamos a empezar con algunas parcelas univariados, es decir, las parcelas de cada variable individual. Dado que las variables de entrada son numéricos, podemos crear caja y bigote parcelas de cada uno. # caja y bigote parcelas dataset.plot (tipo = 'caja' ,  Subtramas = True, diseño = (2,2), sharex = False, Sharey = False) plt.show ()

Añadir 19.11: Visualizar el conjunto de datos utilizando caja y bigote parcelas.

������������������������ �����������

���������������������� ������������������������ ������������������������

��������������

Jason Brownlee

Máquina de aprendizaje de dominio con Python Entender sus datos, crear modelos precisos y los proyectos de trabajo de extremo a extremo

yo

Máquina de aprendizaje de dominio con Python © Derechos de autor 2016 Jason Brownlee. Todos los derechos reservados.

Edición: v1.2

Contenido

Prefacio

iii

I. Introducción

1

1 Bienvenido 1.1 Aprender Machine Learning Python El camino equivocado . . . . . . . . . . . . . . . . . 1.2 Máquina de aprendizaje en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Lo que este libro no es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2 2 2 6 7

Clases II

8

Ecosistema Pitón 2 de la máquina de aprendizaje 2.1 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 SciPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2.3 scikit-learn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Instalación 2.4 Ecosistema Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

9 9

3 Curso acelerado en Python y SciPy 3.1 Python curso acelerado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.2 NumPy curso acelerado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 3.3 Matplotlib curso acelerado . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . . 21 3.4 pandas curso acelerado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 3.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

14

4 Cómo cargar datos de la máquina de aprendizaje

26

4.1 Consideraciones al cargar datos CSV . . . . . . . . . . . . . . . .  . . . . . . 26 4,2 Pima indios conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.3 Carga de archivos CSV con la biblioteca estándar de Python . . . . . . . . .  . . . . . . . 27 4.4 Carga de archivos CSV con NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.5 Carga de archivos CSV con las pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.6 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

ii

iii 5 Entender sus datos con estadísticas descriptivas 5.1 vistazo a sus datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 5.2 Dimensiones de sus datos . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . 32 Tipo 5.3 Datos para cada atributo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 5.4 Estadística descriptiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 5.5 de clase de distribución (Sólo Clasi fi cación) . . . . . . . . . . . . . . . . . . . . . . . 34 5.6 Las correlaciones entre los atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 5.7 Sesgo de Distribuciones univariantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 5.8 Consejos para recordar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 5.9 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

31

6 comprender los datos con la visualización 6.1 Parcelas univariados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 6.2 Parcelas multivariantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 6.3 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

38

7 Preparar sus datos para la máquina de aprendizaje 7.1 necesidad de datos pre-procesamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 7.2 Transformaciones de Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 7.3 Datos Rescale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 7.4 Datos Estandarizar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 7.5 Datos Normalizar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 7.6 Datos de binarización (Agrega binario) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 7.7 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

47

8 Función de selección para la máquina de aprendizaje

52

Selección 8.1 Característica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 8.2 Selección univariante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 8.3 recursiva en función de eliminación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 8.4 Análisis de Componentes Principales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Importancia 8.5 Característica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 8.6 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 9 evaluar el rendimiento de la máquina algoritmos de aprendizaje con remuestreo 57 9.1 Evaluar los algoritmos de aprendizaje de máquinas . . . . . . . . . . . . . . . . . . . . . . . 57 9.2 Dividir en juegos de trenes y de prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 9,3 K-pliegue de validación cruzada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Validación 9.4 Dejar Un hacia fuera de la Cruz . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 9.5 repetidas Test-Tren Splits azar . . . . . . . . . . . . . . . .  . . . . . . . . . 60 9.6 ¿Qué técnicas para utilizar cuando . . . . . . . . .  . . . . . . . . . . . . . . . . . . 61 9.7 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 10 métricas de rendimiento de la máquina Algoritmo de Aprendizaje

10.1 Algoritmo de Evaluación Métrica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 10.2 Classi Métrica fi cación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 10.3 Regresión Métrica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 10.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

62

v 18.2 plantilla de proyecto de aprendizaje automático en Python . . . . . . . . . . . . . . . . . . . 107 18.3 Machine Learning proyecto de plantilla Pasos . . . . . . . . . . . . . . . . . . . . . 108 . . . . . . . . . . . . . . . . . . . . . . . . . 110 18.4 Sugerencias para usar la plantilla Bueno 18.5 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 19 Su primer proyecto Machine Learning en Python Paso a Paso 19.1 El Mundo Hola de la máquina de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . 111 19.2 cargar los datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 19.3 Resumir el conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 La visualización de datos 19.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 19.5 Evaluar algunos algoritmos . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . 118 19.6 Hacer predicciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 19.7 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

111

20 Regresión Machine Learning Case Study Project 123 20.1 Problema De fi nición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 20.2 Cargar el conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 20.3 Análisis de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 20.4 Datos visualizaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 20.5 Validación del conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 20.6 Evaluar Algoritmos: Línea de Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 20.7 Evaluar Algoritmos: Normalización . . . . . . . . . . . . . . .  . . . . . . . . . 136 20.8 mejorar los resultados con ajuste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 20.9 Métodos Ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Métodos Ensemble 20.10Tune . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 20.11Finalize Modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 20.12Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 21 Binary Clasi fi cación de la máquina de aprendizaje del Proyecto Estudio de caso

144

21.1 Problema De fi nición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 21.2 Cargar el conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 21.3 Análisis de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 21.4 Validación del conjunto de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 21.5 Evaluar Algoritmos: Línea de Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 21.6 Evaluar Algoritmos: estandarizar los datos . . . . . . . . . . . . . . . . . . . . . . . 155 21.7 Algoritmo de sintonización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 21.8 Métodos Ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 21.9 Finalizar Modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 21.10Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 Más de 22 proyectos de modelado predictivo 22.1 construir y mantener Recetas . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . 163 22.2 Pequeños Proyectos en conjuntos de datos peq ueños . . . . . . . . . . . . . . . . . . . . . . . . . . 163 22.3 Máquina de aprendizaje competitivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 22.4 Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

163

vi

IV Conclusiones

166

23 ¿Cómo lejos que han llegado

167

24 Obtener más ayuda 24.1 Recomendaciones generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 24.2 Ayuda con Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 24.3 Ayuda con SciPy y NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 24.4 Ayuda con Matplotlib . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . . . . 169 24.5 Ayuda con las pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 24.6 Ayuda con scikit-learn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

168

Prefacio Creo que Python es una plataforma increíble para el aprendizaje automático. Hay tantos algoritmos y tanto poder listos para usar. A menudo me preguntan la pregunta:  ¿Cómo se utiliza Python para el aprendizaje de máquina? Este libro es mi de fi nitivo respuesta a esa pregunta. Contiene lo mejor de mi conocimiento y las ideas sobre la forma de trabajar a través de proyectos de aprendizaje de máquina de modelado predictivo utilizando el ecosistema Python. Es el libro que yo también voy a usar como un repaso al inicio de un nuevo proyecto. Estoy muy orgulloso de este libro y espero que les resulta un compañero útil en su viaje de aprendizaje de máquina con Python.

Jason Brownlee Melbourne, Australia 2016

vii

parte I Introducción

1

1.2. Máquina de aprendizaje en Python 

3

lecciones: Conoce cómo las sub-tareas de un mapa del proyecto de aprendizaje automático en Python y el mejor manera práctica de trabajar a través de cada tarea.

proyectos: Unir todo el conocimiento de las lecciones trabajando a través de estudio de caso problemas de modelado predictivo.

Recetas : Aplicar el aprendizaje de máquina con un catálogo de recetas independientes en Python que se puede copiar y pegar como punto de partida para nuevos proyectos.

1.2.1 Lecciones Usted necesita saber cómo llevar a cabo las tareas parciales fi cos de un proyecto de aprendizaje máquina con el ecosistema Python. Una vez que sepa cómo llevar a cabo una tarea discreta usando la plataforma y obtener un resultado fiable, puede hacerlo una y otra vez en un proyecto tras otro. Vamos a empezar con una visión general de las tareas comunes en un proyecto de aprendizaje automático. Un proyecto de aprendizaje de máquina de modelado predictivo puede ser dividido en 6 tareas de nivel superior:

1. De fi ne Problema: Investigar y caracterizar el problema con el fin de comprender mejor  los objetivos del proyecto. 2. Analizar datos: Utilizar la estadística descriptiva y la visualización para entender mejor los datos que tiene disponible.

3. Preparar los datos: El uso de datos transforma el fin de exponer mejor la estructura de la problema de predicción de algoritmos de modelado.

4. Evaluar Algoritmos: Diseñar un instrumento de prueba para evaluar una serie de algoritmos estándar  en los datos y seleccionar la parte superior unos pocos a investigar más a fondo.

5. Mejorar Resultados: Utilice la sintonización de algoritmos y métodos de conjunto para obtener el máximo provecho de

con buen desempeño algoritmos en sus datos. 6. Resultados actuales: Finalizar el modelo, hacer predicciones y los resultados actuales.

Una bendición y una maldición con Python es que hay tantas técnicas y tantas maneras de hacer lo mismo con la plataforma. En la segunda parte de este libro usted descubrirá una manera práctica fácil o mejor para completar cada subtarea de un proyecto de aprendizaje de máquina general. A continuación se muestra un resumen de las lecciones de la Parte II y las sub-tareas que va a aprender. ?? Lección 1: Ecosistema de Python para aprendizaje automático.

?? Lección 2: Python y SciPy curso acelerado. ?? Lección 3: Los conjuntos de datos de carga de CSV.

?? Lección 4: Comprender datos con estadística descriptiva. ( Analizar datos) ?? Lección 5: Comprender datos con la visualización. ( Analizar datos) ?? Lección 6: Pre-Proceso de Datos. ( Preparar los datos)

1.2. Máquina de aprendizaje en Python 

4

?? Lección 7: Selección de características. ( Preparar los datos)

?? Lección 8: métodos de remuestreo. ( Evaluar Algoritmos) ?? Lección 9: Algoritmo métricas de evaluación. ( Evaluar Algoritmos) ?? Lección 10: inspección al azar Clasi fi cación Algoritmos. ( Evaluar Algoritmos) ?? Lección 11: inspección al azar de regresión Algoritmos. ( Evaluar Algoritmos)

?? Lección 12: Selección del modelo. ( Evaluar Algoritmos) ?? Lección 13: Tuberías. ( Evaluar Algoritmos) ?? Lección 14: Métodos Ensemble. ( Mejorar Resultados) ?? Lección 15: Algoritmo de parámetros de sintonización. ( Mejorar Resultados)

?? Lección 16: El modelo de finalización. ( Resultados presentes)

Estas clases están destinadas para ser leído de principio a fin con el fin, que muestra exactamente cómo completar cada tarea en un proyecto de aprendizaje de máquina de modelado predictivo. Por supuesto, se puede echar mano de lecciones especí fi cas de nuevo más tarde para refrescarse. Las clases se estructuran para demostrar las clases de API y las funciones clave, que muestra cómo utilizar las técnicas especí fi cas para una tarea de aprendizaje de máquina común. Cada lección fue diseñado para ser completado en menos de 30 minutos (dependiendo de su nivel de habilidad y el entusiasmo). Es posible trabajar a través de todo el libro en un fin de semana. También funciona si quieres echar mano de las secciones especí fi cos y utilizar el libro como referencia.

1.2.2 Proyectos Recetas para las tareas de modelado predictivo comunes son de importancia crítica, pero también son sólo el punto de partida. Aquí es donde la mayoría de los libros y cursos detienen. Es necesario para reconstruir las recetas juntos en proyectos de extremo a extremo. Esto le mostrará cómo entregar en realidad un modelo o hacer predicciones sobre nuevos datos utilizando Python. Este libro utiliza pequeños conjuntos de datos de aprendizaje automático bien entendidas desde el repositorio de aprendizaje UCI Machine 1 tanto en las clases y en los proyectos de ejemplo. Estos conjuntos de datos están disponibles de fo rma gratuita como CSV descargas. Estos conjuntos de datos son excelentes para la práctica de aprendizaje automático aplicado debido a que:

?? Ellos son pequeños, lo que significa que encajan en la memoria y algoritmos pueden modelar en

tiempo razonable. ?? Ellos se comportan bien, lo que significa que a menudo no es necesario hacer un montón de ingeniería característica para obtener un buen resultado.

?? Son puntos de referencia, lo que significa que muchas personas han utilizado antes y que pueda obtener ideas de buenos algoritmos para tratar de niveles de precisión que debe esperar. En la tercera parte se trabajará a tr avés de tres proyectos: 1h   ttp://archive.ics.uci.edu/ml

1.2. Máquina de aprendizaje en Python 

5

Proyecto Mundial hola (Iris fl ores conjunto de datos): Este es un pase rápido a través de los pasos del proyecto sin mucha sintonía o la optimización en un conjunto de datos que se utiliza ampliamente como el Hola Mundo de aprendizaje automático.

Regresión (conjunto de datos de precios de viviendas de Boston): Trabajar a través de cada paso del proceso del proyecto

con un problema de regresión.

Binaria clasificacion (Sonar conjunto de datos): Trabajar a través de cada paso del proceso del proyecto

utilizando todos los métodos en un problema fi clasi binario. Estos proyectos unifican todas las lecciones de la Parte II. También le dan información sobre el proceso de trabajo a través de los problemas de aprendizaje de máquina de modelado predictivo que es muy valiosa cuando usted está tratando de tener una idea de cómo hacer esto en la práctica. También se incluye en esta sección es una plantilla para trabajar a través de problemas de aprendizaje automático de modelado predictivo que puede utilizar como punto de partida para los proyectos actuales y futuros. Yo encontramos esto útil a mí mismo para establecer la dirección y configuración de tareas importantes (que son fáciles de olvidar) en nuevos proyectos.

1.2.3 Recetas Las recetas son ejemplos independientes pequeños en Python que muestran cómo hacer una cosa específico y obtener un resultado. Por ejemplo, usted podría tener una receta que se muestra cómo utilizar el algoritmo de bosque aleatorio para clasi fi cación. Usted podría tener otro para la normalización de los atributos de un conjunto de datos. Recetas hacen que el di ff rencia entre un principiante que está teniendo problemas y aprende rápido capaz de hacer predicciones precisas de forma rápida en cualquier nuevo proyecto. Un catálogo de recetas ofrece un repertorio de habilidades que se pueden extraer de al iniciar un nuevo proyecto. Más formalmente, las recetas se definen de la siguiente manera:

?? Las recetas son fragmentos de código no tutoriales. ?? Recetas proporcionan código sólo lo suficiente como para trabajar.

?? Recetas no son demostrativos exhaustiva. ?? Recetas corren como está y producen un resultado.

?? Recetas suponen que se instalan las bibliotecas necesarias. ?? Recetas utilizan conjuntos de datos o conjuntos de datos proporcionados en las bibliotecas mercantiles integradas.

Usted está comenzando su viaje en la máquina de aprendizaje con Python con mi catálogo personal de recetas máquina de aprendizaje previstos con este libro. Todo el código de las lecciones de la Parte II están disponibles en el catálogo de la receta Python. También hay recetas para las técnicas no están cubiertos en este libro, incluyendo el uso de un gran número de algoritmos y muchos estudios de casos adicionales. Recetas están divididas en directorios de acuerdo a las tareas comunes de un proyecto de aprendizaje de máquina que se enumeran más arriba. La siguiente lista proporciona un resumen de las recetas disponibles.

?? Analizar datos: Recetas para cargar, resumir y visualizar datos, incluyendo visualizaciones utilizando gráficos univariantes y multivariantes parcelas.

1.3. Lo que este libro no es 

6

?? Preparar los datos: Recetas para la preparación de datos, incluyendo la limpieza de datos, selección de características

y los datos se transforma.

?? algoritmos: Recetas para el uso de un gran número de algoritmos de aprendizaje automático, que incluye

lineales, no lineales, y árboles de decisión para la clasi fi cación y la regresión.

?? Evaluar Algoritmos: Recetas para los métodos de re-muestreo, métricas de evaluación algoritmo y selección del modelo. ?? Mejorar Resultados: Recetas para la sintonización de algoritmos y métodos Ensemble. ?? Finalizar el modelo: Recetas para guardar y modelos de carga en el disco.

?? Otro: Recetas para empezar con las estructuras sintácticas y de datos de Py thon utilizados en SciPy. ?? Estudios de caso: Los estudios de casos para binario clasi fi cación, multiclase clasi fi cación y regresión

sion problemas. Este es un recurso valioso que se puede utilizar para poner en marcha sus proyectos de aprendizaje de máquinas actuales y futuras. También puede ampliar este catálogo de recetas a medida que descubre nuevas técnicas.

1.2.4 Sus resultados de la lectura de este libro Este libro le llevará de ser un desarrollador que esté interesado en la máquina de aprendizaje con Python a un desarrollador que tiene los recursos y la capacidad para trabajar a través de un nuevo conjunto de datos de extremo a extremo utilizando Python y desarrollar modelos predictivos precisos. Específicamente, usted sabrá: ?? ¿Cómo trabajar a través de un pequeño extremo a extremo de datos de tamaño medio.

?? Cómo ofrecer un modelo que puede hacer predicciones exactas sobre los nuevos datos que no se ven.

?? Cómo completar todas las subtareas de un problema de modelado predictivo con Python.

?? ¿Cómo aprender nuevas técnicas y di ff Erent en Python y SciPy. ?? Cómo obtener ayuda con Python aprendizaje automático.

Desde aquí se puede empezar a bucear en la memoria descriptiva cs de las funciones, técnicas y algoritmos que se utilizan con el objetivo de aprender cómo usarlos mejor con el fin de ofrecer modelos predictivos más precisos, más fiable en menos tiempo.

1.3 Lo que este libro no es Este libro fue escrito para los desarrolladores profesionales que quieren saber cómo construir modelos de aprendizaje automático fiables y precisos en Python.

?? Este no es un libro de texto de aprendizaje automático. Nosotros no va a obtener en el básico teoría del aprendizaje de las máquinas (por ejemplo, i nducción, el sesgo de la varianza comercio-o ff, etc.). Se espera que usted t iene cierta familiaridad con conceptos básicos de aprendizaje automático, o ser capaz de recogerlos usted mismo.

1.4. Resumen 

7

?? Este no es un libro algoritmo. No vamos a estar trabajando a través de los detalles de cómo específico algoritmos de aprendizaje automático de trabajo (por ejemplo, Random Forests). Se espera que tenga un conocimiento básico de algoritmos de aprendizaje automático o cómo recoger este conocimiento mismo.

?? Este no es un libro de programación Python. No van a pasar mucho tiempo en sintaxis de Python y programación (por ejemplo, las tareas básicas de programación en Python). Se espera que sea un desarrollador que puede recoger un nuevo lenguaje similar a C con relativa rapidez.

Todavía se puede obtener una gran cantidad de este libro si usted es débil en una o dos de estas áreas, pero puede tener dificultades recogiendo el idioma o exigir alguna explicación más detallada de las técnicas. Si este es el caso, consulte la  Obtener más ayuda en el capítulo final del libro y buscar un buen texto de referencia acompañante.

1.4 Resumen Espero que estén tan emocionados como yo para empezar. En este capítulo de introducción que ha aprendido que este libro no es convencional. A diferencia de otros libros y cursos que se centran en gran medida de algoritmos de aprendizaje automático en Python y se centran en poco más, este libro le guiará a través de cada paso de un proyecto de aprendizaje de máquina de modelado predictivo.

?? Parte II de este libro ofrece lecciones i ndependientes que incluyen una mezcla de recetas y tutoriales para construir sus habilidades básicas de trabajo y con fi anza en Python. ?? Parte III de este libro introducirá una plantilla de proyecto de aprendizaje automático que se puede utilizar  como punto de partida en sus propios proyectos y le guía a través de tres proyectos de extremo a extremo.

?? El compañero de recetas de este libro proporciona un catálogo de aprendizaje de más de 90 máquinas

recetas en Python. Puede navegar por este valioso recurso, encuentre recetas útiles y de copiar y pegar en sus proyectos de aprendizaje de máquinas actuales y futuras. ?? Parte IV se fi nal el libro. Será mirar hacia atrás en lo lejos que han llegado en el desarrollo sus nuevas habilidades en la máquina aplicada aprender con Python. También podrá descubrir los recursos que se pueden utilizar para obtener ayuda, siempre y cuando usted tiene alguna pregunta sobre Python o el ecosistema.

1.4.1 Paso siguiente A continuación, comenzará la Parte II y su primera lección. Va a echar un vistazo más de cerca el ecosistema Python para el aprendizaje automático. Usted descubrirá lo que Python y SciPy son, por qué es tan poderoso como una plataforma para el aprendizaje de las máquinas y las formas di ff Erent que debe y no debe utilizar la plataforma.

Parte II lecciones

8

Capitulo 2 Ecosistema de Python para la máquina de aprendizaje El ecosistema Python está creciendo y puede convertirse en la plataforma dominante para el aprendizaje automático. La razón principal para la adopción de Python para el aprendizaje automático se debe a que es un lenguaje de programación de propósito general que se puede utilizar tanto para la I + D y en la producción. En este capítulo usted descubrirá el ecosistema Python para el aprendizaje automático. Después de completar esta lección sabrá:

1. Python y se está levantando el uso de la máquina de aprendizaje.

2. SciPy y la funcionalidad que proporciona NumPy, Matplotlib y pandas. 3. scikit-learn que proporciona todos los algoritmos de aprendizaje automático.

4. ¿Cómo configurar su ecosistema Python para el aprendizaje de máquina y qué versiones de usar 

Empecemos.

2.1 Python Python es un propósito interpretado lenguaje de programación de. Es fácil de aprender y utilizar principalmente porque el lenguaje se centra en la legibilidad. La filosofía de Python es capturado en el Zen de Python que incluye frases como:

Bello es mejor que feo. Explícito es mejor que implícito. Simple es mejor que complejo. Complejo es mejor que complicado. Piso es mejor que anidado. Escaso es mejor que denso. La legibilidad cuenta.

Listado 2.1: Muestra del Zen de Python. Es un lenguaje popular en general, que aparece constantemente en los 10 lenguajes de programación superiores en las encuestas sobre StackOver flujo  1  . E   s un lenguaje dinámico y mu y adecuado para interactivo 1 http://stackoverflow.com/research/developer-survey-2015

9

2.4. Instalación de Python Ecosistema 

11

Instalación 2.4 Ecosistema Python Hay varias formas de instalar el ecosistema Python para el aprendizaje automático. En esta sección cubrimos cómo instalar el ecosistema Python para el aprendizaje automático.

2.4.1 Cómo instalar Python El primer paso es instalar Python. Yo prefiero usar y recomendar Python 2.7. Las instrucciones para instalar Python será específico para su plataforma. Consulte las instrucciones descarga de Python  4 en el Guía de principiantes de Python.U   na vez instalado se puede confirmar la instalación se realizó correctamente. Abra una línea de comandos y escriba: --version pitón

Listing 2.2: Imprimir la versión de Python instalado. Usted debe ver una respuesta similar a la siguiente: 2.7.11 Python

Añadir 2,3: Versión Ejemplo Python. Los ejemplos de este libro asumen que está utilizando esta versión de Python 2 o más reciente. Los ejemplos de este libro no se han probado con Python 3.

2.4.2 Cómo instalar SciPy Hay muchas formas de instalar SciPy. Por ejemplo, dos formas populares son para usar de gestión de paquetes en su plataforma (por ejemplo, yum en RedHat o macports en OS X) o utilizar una herramienta de gestión de paquetes de Python como PIP. La documentación SciPy es excelente y se abordan las instrucciones howto para muchas plataformas di ff Erent en la página  Instalación de la pila SciPy  5  .  Al instalar SciPy, asegúrese de instalar los paquetes siguientes, como míni mo:

?? scipy

?? numpy

?? matplotlib ?? pandas

Una vez instalado, puede con fi rmar que la instalación se ha realizado correctamente. Abra el entorno interactivo de Python tecleando pitón en la línea de comandos, a continuación, escribir y ejecutar el siguiente código Python para imprimir las versiones de las librerías instaladas. # scipy importar scipy impresión (  'SciPy: {}'  . f  ormato  (Scipy .__ version__)) # numpy importar numpy

impresión ( '  Numpy: {}'  . f  ormato (  Numpy .__ version__)) 4

https://wiki.python.org/moin/BeginnersGuide/Download

  ttp://scipy.org/install.html 5h

2.4. Instalación de Python Ecosistema 

12

# matplotlib importar matplotlib impresión ( '  Matplotlib: {}'  . f  ormato (  Matplotlib .__ version__)) # pandas importar pandas impresión ( '  Pandas: {}'  . f  ormato (  Pandas .__ version__))

Listing 2.4: Imprimir las versiones de la pila SciPy. En mi estación de trabajo en el momento de la escritura veo la siguiente salida. scipy: matplotlib 1.10.4:: 0.17.0 numpy 1.5.1 pandas: 0.17.1

Añadir 2,5: versiones ejemplo de la pila SciPy. Los ejemplos de este libro se supone que tiene estas versiones de las bibliotecas SciPy o más nuevos. Si usted tiene un error, es posible que tenga que consultar la documentación de la plataforma.

2.4.3 Cómo instalar scikit-learn Yo sugeriría que se utiliza el mismo método para instalar scikit-learn que utilizó para instalar SciPy. Hay instrucciones para instalar scikit-learn 6  , p  ero están limitados a usar el pitón pepita y Conda gestores de paquetes. Al igual que SciPy, puede con fi rmar que scikit-learn se ha instalado correctamente. Comience su entorno interactivo de Python y el tipo y ejecute el código siguiente. # scikit-learn importar sklearn impresión ( '  Sklearn: {}'  . f  ormato (  Sklearn .__ version__))

Listing 2.6: Imprimir las versiones de scikit-learn. Se imprimirá la versión de la biblioteca scikit-learn instalado. En mi estación de trabajo en el momento de la escritura veo el siguiente resultado: sklearn: 0.17.1

Añadir 2,7: versiones de ejemplo de scikit-learn. Los ejemplos de este libro se supone que tiene esta versión de scikit-learn o más reciente.

2.4.4 Cómo instalar el ecosistema: Una manera más fácil Si no está con fi mella en la instalación de software en su máquina, hay una opción más fácil para usted. Hay una distribución llamada Anaconda que se puede descargar e instalar de forma gratuita 7  . E   s compatible con las tres principal es plataformas de Microsoft Windows, Mac OS X y Linux. Incluye Python, SciPy y scikit-learn. Todo lo que necesita para aprender, practicar y aprender el uso de la máquina con el Medio Ambiente Python.

6h   ttp://scikit-learn.org/stable/install.html 7 https://www.continuum.io/downloads

2.5. Resumen 

13

2.5 Resumen En este capítulo usted descubrió el ecosistema Python para el aprendizaje automático. Ha aprendido a: ?? Python y se está levantando el uso de la máquina de aprendizaje.

?? SciPy y la funcionalidad que proporciona NumPy, Matplotlib y pandas. ?? scikit-learn que proporciona todos los algoritmos de aprendizaje automático. También ha aprendido cómo instalar el ecosistema Python para el aprendizaje de máquina en su estación de trabajo.

2.5.1 Siguiente En la siguiente lección obtendrá un curso intensivo en el ecosistema Python y SciPy, concebida expresamente específico para obtener un desarrollador como si al día con ecosistemas muy rápido.

Capítulo 3 Curso acelerado en Python y SciPy No es necesario ser un desarrollador de Python para comenzar a utilizar el ecosistema Python para el aprendizaje automático. Como desarrollador que ya sabe cómo programar en uno o más lenguajes de programación, que son capaces de recoger un nuevo lenguaje como Python muy rápidamente. Sólo tiene que saber algunas propiedades del lenguaje para transferir lo que ya sabe que el nuevo idioma. Después de completar esta lección sabrá:

1. ¿Cómo navegar sintaxis del lenguaje Python.

2. Suficiente NumPy, Matplotlib y pandas a leer y escribir máquina de aprendizaje de scripts de Python.

3. Una base desde la que construir un entendimiento más profundo de las tareas de aprendizaje automático en Python.

Si ya sabe un poco de Python, este capítulo será un recordatorio para usted. Empecemos.

3.1 Python curso acelerado En nuestros primeros pasos en Python que necesita saber algunos detalles clave acerca de la sintaxis del lenguaje a ser capaz de leer y entender el código Python. Est o incluye:

?? Asignación. ?? Control de flujo. ?? Estructuras de datos.

?? Funciones. Vamos a cubrir cada uno de estos temas a su vez con pequeños ejemplos independientes que se pueden escribir y ejecutar. Recuerde, los espacios en blanco tiene significado en Python.

3.1.1 Asignación Como programador, misiones y tipos no deben ser sorprendente para usted. 14

15

3.1. Python curso acelerado 

Instrumentos de cuerda

# Instrumentos de cuerda data = 'Hola Mundo' impresión (Datos [0])

impresión (  len (  datos)) impresión (datos)

Listado 3.1: Ejemplo de la utilización de cadenas. Observe cómo se puede acceder a los caracteres en la cadena utilizando la sintaxis de matrices. Ejecución de las impresiones de ejemplo:

h 11

Hola Mundo

Listado 3.2: Salida del ejemplo de trabajo con cuerdas.

Números # Números value = 123,1 impresión (Valor) valor = 10 impresión (valor)

Listado 3.3: Ejemplo de trabajar con números. Ejecución de las impresiones de ejemplo:

123,1 10

Listado 3.4: Salida del ejemplo de trabajo con los números.

Boole # Boole a = Verdadero b = False

impresión (A, b)

Listado 3.5: Ejemplo de trabajo con booleanos. Ejecución de las impresiones de ejemplo:

(Verdadero Falso)

Listado 3.6: Salida del ejemplo de trabajo con booleanos.

17

3.1. Python curso acelerado 

En bucle # En bucle para yo en el rango (10): impresión yo

Perfil de 3.13: Ejemplo de trabajo con un Para-Loop. Ejecución de las impresiones de ejemplo: 0 1 2 3 4 5 6 7 8 9

Listado 3.14: Salida del ejemplo de trabajo con un ciclo for.

Mientras-Loop # Mientras-Loop i=0 mientras i