Python Data Analytics - With Pandas, NumPy, and Matplotlib

30/8/2020 Con Pandas, NumPy y Matplotlib - Segunda edición - Fabio Nelli
Página 1
Datos de Python
Analítica
Con Pandas, NumPy y Matplotlib
-
Segunda edicion
-
Fabio Nelli
Página 2
Análisis de datos de Python

https://translate.googleusercontent.com/translate_f 1/396
Con Pandas, NumPy,

y Matplotlib
Segunda edicion
Fabio Nelli
Página 3
Análisis de datos de Python

Fabio Nelli
Roma, Italia
ISBN-13 (pbk): 978-1-4842-3912-4 ISBN-13 (electrónico): 978-1-4842-3913-1

https://doi.org/10.1007/978-1-4842-3913-1
Número de control de la Biblioteca del Congreso: 2018957991
Copyright © 2018 por Fabio Nelli

Esta obra está sujeta a derechos de autor. Todos los derechos están reservados por el editor, ya sea la totalidad o parte del
material se refiere, específicamente los derechos de traducción, reimpresión, reutilización de ilustraciones, recitación,
difusión, reproducción en microfilmes o de cualquier otra forma física, y transmisión o información
almacenamiento y recuperación, adaptación electrónica, software de computadora o mediante una metodología similar o diferente ahora
conocido o desarrollado en el futuro.
En este libro pueden aparecer nombres, logotipos e imágenes de marcas comerciales. En lugar de utilizar un símbolo de marca comercial con
cada aparición de un nombre, logotipo o imagen de marca registrada, usamos los nombres, logotipos e imágenes solo en un
editorial y en beneficio del propietario de la marca, sin intención de infringir la
marca comercial.
El uso en esta publicación de nombres comerciales, marcas comerciales, marcas de servicio y términos similares, incluso si no son
identificadas como tales, no debe tomarse como una expresión de opinión sobre si están o no sujetos a
derechos de propiedad.
Si bien se cree que los consejos y la información de este libro son verdaderos y precisos en la fecha de publicación,
ni los autores ni los editores ni el editor pueden aceptar ninguna responsabilidad legal por cualquier error o
omisiones que se puedan hacer. El editor no ofrece ninguna garantía, expresa o implícita, con respecto a la
material contenido aquí.
Director gerente, Apress Media LLC: Welmoed Spahr

Editor de adquisiciones: Todd Green
Editor de desarrollo: James Markham
Editora coordinadora : Jill Balzano
Imagen de portada diseñada por Freepik (www.freepik.com)
Distribuido al comercio de libros en todo el mundo por Springer Science + Business Media New York, 233 Spring Street,
6th Floor, Nueva York, NY 10013. Teléfono 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny @ springer-
sbm.com o visite www.springeronline.com. Apress Media, LLC es una LLC de California y el único miembro
(propietario) es Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc es una
Corporación de Delaware .
Para obtener información sobre traducciones, envíe un correo electrónico a rights@apress.com o visite http://www.apress.com/
derechos-permisos.
Los títulos de Apress se pueden comprar al por mayor para uso académico, corporativo o promocional. Versiones de libros electrónicos y
las licencias también están disponibles para la mayoría de los títulos. Para obtener más información, consulte nuestras ventas a granel de libros electrónicos e impresos
página web en http://www.apress.com/bulk-sales.
Cualquier código fuente u otro material complementario al que el autor haga referencia en este libro está disponible para
lectores en GitHub a través de la página del producto del libro, ubicada en www.apress.com/9781484239124. Para más
información detallada, visite http://www.apress.com/source-code.
Impreso en papel sin ácido
Página 4
“La ciencia nos hace avanzar en el conocimiento, pero solo el análisis

nos hace más conscientes "
Este libro está dedicado a todos aquellos que están constantemente
buscando conciencia
Página 5
Tabla de contenido
Sobre el Autor ............................................... .................................................. ..xvii
Acerca del revisor técnico .............................................. .................................. xix
Capítulo 1: Introducción al análisis de datos .......................................... ................. 1

Análisis de los datos ................................................ .................................................. .............................. 1
Dominios de conocimiento del analista de datos ............................................ .......................................... 3

Ciencias de la Computación ................................................ .................................................. ................. 3
Matemáticas y Estadística ............................................... .................................................. .... 4
Aprendizaje automático e inteligencia artificial ............................................. .............................. 5
Campos de aplicación profesionales .............................................. .............................................. 5
Comprensión de la naturaleza de los datos ............................................ .............................................. 5

Cuando los datos se convierten en información ............................................. ........................................... 6
Cuando la información se convierte en conocimiento ............................................. .............................. 6
Tipos de datos ............................................... .................................................. .......................... 6
El proceso de análisis de datos .............................................. .................................................. ............ 6

Definición del problema ................................................ .................................................. ................. 8
Extracción de datos ................................................ .................................................. ...................... 9
Preparación de datos ................................................ .................................................. .................. 10
Exploración / visualización de datos .............................................. ................................................. 10
Modelado predictivo ................................................ .................................................. ............. 12
Modelo de validación ................................................ .................................................. .................. 13
Despliegue ................................................. .................................................. ........................ 13
Análisis de datos cuantitativos y cualitativos ............................................. .................................... 14
Información abierta ................................................ .................................................. ................................ 15
Python y análisis de datos .............................................. .................................................. ............ 17
Conclusiones ................................................. .................................................. .............................. 17
Página 6
TABLA DE CONTENIDO
Capítulo 2: Introducción al mundo de Python .......................................... ............... 19

Python: el lenguaje de programación ............................................. ........................................... 19
Python: el intérprete .............................................. .................................................. ........ 21
Python 2 y Python 3 ............................................. .................................................. ................. 23
Instalando Python ................................................ .................................................. .................. 23
Distribuciones de Python ................................................ .................................................. ............ 24
Usando Python ................................................ .................................................. ........................ 26
Escribiendo código Python ............................................... .................................................. ............. 28
IPython ................................................. .................................................. ................................ 35
PyPI: el índice de paquetes de Python ............................................ .................................................. 39

Los IDE para Python .............................................. .................................................. ............... 40
Ciencia ................................................. .................................................. ........................................ 46
NumPy ................................................. .................................................. ................................ 47
Pandas ................................................. .................................................. ................................ 47
matplotlib ................................................. .................................................. ........................... 48
Conclusiones ................................................. .................................................. .............................. 48
Capítulo 3: La biblioteca NumPy ............................................ .................................... 49

NumPy: Un poco de historia ............................................. .................................................. ................. 49
La instalación de NumPy ............................................... .................................................. .............. 50

Ndarray: El corazón de la biblioteca ........................................... .................................................. ... 50
Crear una matriz ............................................... .................................................. ..................... 52
Tipos de datos ............................................... .................................................. ........................ 53
La opción dtype ............................................... .................................................. .................. 54
Creación intrínseca de una matriz ............................................. .................................................. .. 55
Operaciones básicas ................................................ .................................................. ....................... 57

Operadores aritméticos ................................................ .................................................. ........... 57
El producto Matrix ............................................... .................................................. ............... 59
Operadores de incremento y decremento .............................................. ...................................... 60
Funciones universales (ufunc) ............................................. .................................................. .... 61
Funciones agregadas ................................................ .................................................. ........... 62
vi
Página 7
TABLA DE CONTENIDO
Indexación, corte e iteración ............................................ .................................................. ...... 62

Indexación ................................................. .................................................. .............................. 63
Rebanar ................................................. .................................................. ................................. sesenta y cinco
Iterando una matriz ............................................... .................................................. .................. 67
Condiciones y matrices booleanas .............................................. .................................................. ... 69

Manipulación de formas ................................................ .................................................. .................. 70
Manipulación de matrices ................................................ .................................................. .................... 71

Unión de matrices ................................................ .................................................. ...................... 71
División de matrices ................................................ .................................................. .................... 72
Conceptos generales ................................................ .................................................. ...................... 74

Copias o vistas de objetos ............................................. .................................................. ..... 75
Vectorización ................................................. .................................................. ....................... 76
Radiodifusión ................................................. .................................................. ...................... 76
Matrices estructuradas ................................................ .................................................. ...................... 79

Lectura y escritura de datos de matriz en archivos ........................................... .......................................... 82
Cargar y guardar datos en archivos binarios ........................................... .................................... 82
Lectura de archivos con datos tabulares ............................................. ............................................... 83
Conclusiones ................................................. .................................................. .............................. 84
Capítulo 4: La biblioteca de pandas: una introducción ......................................... .......... 87

pandas: la biblioteca de análisis de datos de Python ........................................... ....................................... 87
Instalación de pandas ............................................... .................................................. ................. 88

Instalación desde Anaconda ............................................... .................................................. ... 88
Instalación desde PyPI ............................................... .................................................. ............ 89
Instalación en Linux ............................................... .................................................. ............. 90
Instalación desde la fuente ............................................... .................................................. ....... 90
Un repositorio de módulos para Windows ............................................. ............................................ 90
Prueba de la instalación de pandas .............................................. .................................................. 91
Empezando con pandas .............................................. .................................................. ....... 92

Introducción a las estructuras de datos de pandas ............................................. ......................................... 92
Las series ................................................ .................................................. ............................ 93
vii
Página 8
TABLA DE CONTENIDO
El DataFrame ................................................ .................................................. .................. 102
Los objetos de índice ............................................... .................................................. ............... 112
Otras funcionalidades en índices .............................................. ................................................. 114

Reindexando ................................................. .................................................. ........................ 114
Soltando ................................................. .................................................. .......................... 117
Alineación aritmética y de datos .............................................. .............................................. 118
Operaciones entre estructuras de datos .............................................. .......................................... 120
Métodos aritméticos flexibles ............................................... ................................................. 120
Operaciones entre DataFrame y Series ............................................. ........................... 121
Aplicación y asignación de funciones .............................................. .............................................. 122

Funciones por elemento ............................................... .................................................. ......... 123
Funciones por fila o columna ............................................. .................................................. 123
Funciones estadísticas ................................................ .................................................. ........... 125
Clasificación y clasificación ............................................... .................................................. ................ 126
Correlación y covarianza ............................................... .................................................. ...... 129

Datos “No es un número” ............................................ .................................................. .................. 131
Asignar un valor de NaN .............................................. .................................................. ......... 131
Filtrado de valores de NaN .............................................. .................................................. ...... 132
Relleno de ocurrencias de NaN .............................................. .................................................. .. 133
Indexación y nivelación jerárquica .............................................. ............................................. 134

Reordenación y clasificación de niveles .............................................. .............................................. 137
Estadística resumida por nivel .............................................. .................................................. .138
Conclusiones ................................................. .................................................. ............................ 139
Capítulo 5: pandas: lectura y escritura de datos ......................................... ............. 141

Herramientas API de E / S ............................................. .................................................. ............................... 141
Archivos CSV y textuales .............................................. .................................................. ................ 142
Lectura de datos en archivos CSV o de texto ........................................... .................................................. 143

Uso de RegExp para analizar archivos TXT ............................................ ............................................. 146
Leyendo archivos TXT en partes ............................................. .................................................. .148
Escribir datos en CSV .............................................. .................................................. ............. 150
viii
Página 9
TABLA DE CONTENIDO
Lectura y escritura de archivos HTML ............................................. .................................................. 152

Escribir datos en HTML .............................................. .................................................. ........... 153
Lectura de datos de un archivo HTML ............................................ ............................................. 155
Leyendo datos desde XML .............................................. .................................................. ............ 157
Lectura y escritura de datos en archivos de Microsoft Excel .......................................... ........................ 159
Datos JSON ................................................ .................................................. ............................... 162
El formato HDF5 ............................................... .................................................. ..................... 166
Pickle — Serialización de objetos Python ............................................. ............................................ 168

Serializar un objeto Python con cPickle ............................................ .................................... 168
Decapado con pandas ............................................... .................................................. .......... 169
Interactuar con bases de datos ............................................... .................................................. ...... 170

Carga y escritura de datos con SQLite3 ............................................ ................................... 171
Carga y escritura de datos con PostgreSQL ............................................ ............................. 174
Lectura y escritura de datos con una base de datos NoSQL: MongoDB ........................................ .......... 178
Conclusiones ................................................. .................................................. ............................ 180
Capítulo 6: pandas en profundidad: manipulación de datos ......................................... .......... 181

Preparación de datos ................................................ .................................................. ..................... 181
Fusión ................................................. .................................................. ............................ 182
Concatenando ................................................. .................................................. ........................ 188
Combinando ................................................. .................................................. ........................ 191
Pivotante ................................................. .................................................. ............................. 193
Eliminando ................................................. .................................................. .......................... 196
Transformación de datos ................................................ .................................................. ................ 197

Eliminación de duplicados ................................................ .................................................. ......... 198
Mapeo ................................................. .................................................. ............................ 199
Discretización y agrupamiento ............................................... .................................................. ....... 204

Detección y filtrado de valores atípicos .............................................. ............................................. 209
Permutación ................................................. .................................................. ........................... 210

Muestreo aleatorio ................................................ .................................................. ............. 211
ix
Página 10
TABLA DE CONTENIDO
Manipulación de cadenas ................................................ .................................................. ................. 212

Métodos integrados para la manipulación de cadenas ........................................... ................................. 212
Expresiones regulares ................................................ .................................................. .......... 214
Agregación de datos ................................................ .................................................. .................... 217

Agrupar por ................................................. .................................................. ............................ 218
Un ejemplo práctico ............................................... .................................................. ............ 219
Agrupación jerárquica ................................................ .................................................. ........ 220
Iteración de grupo ................................................ .................................................. ........................ 222
Cadena de Transformaciones ............................................... .................................................. .... 222
Funciones en grupos ............................................... .................................................. ........... 224
Agregación de datos avanzada ............................................... .................................................. ..... 225

Conclusiones ................................................. .................................................. ............................ 229
Capítulo 7: Visualización de datos con matplotlib ........................................... ........... 231

La biblioteca matplotlib ............................................... .................................................. .............. 231
Instalación ................................................. .................................................. ............................. 233
La QtConsole de IPython e IPython ............................................. ............................................. 233
La arquitectura matplotlib ............................................... .................................................. ...... 235

Capa de backend ................................................ .................................................. ................... 236
Capa de artista ................................................ .................................................. ........................ 236
Capa de secuencias de comandos (pyplot) ............................................. .................................................. ........ 238
pylab y pyplot ............................................... .................................................. ................. 238
pyplot ................................................. .................................................. ..................................... 239

Un gráfico interactivo simple .............................................. .................................................. ... 239
La ventana de trazado ............................................... .................................................. ................ 241
Establecer las propiedades de la parcela ............................................ .................................................. 243
matplotlib y NumPy ............................................... .................................................. ........ 246
Usando los kwargs ............................................... .................................................. ..................... 248

Trabajar con múltiples figuras y ejes ............................................ ................................. 249
Adición de elementos al gráfico ............................................. .................................................. .... 251

Añadiendo texto ................................................ .................................................. ........................ 251
Página 11
TABLA DE CONTENIDO
Agregar una cuadrícula ............................................... .................................................. ...................... 256

Agregar una leyenda ............................................... .................................................. ................. 257
Guardar sus gráficos ............................................... .................................................. ................... 260

Guardar el código ............................................... .................................................. .................. 260
Conversión de su sesión a un archivo HTML ........................................... ................................. 262
Guardar su gráfico directamente como una imagen ........................................... .................................... 264
Manejo de valores de fecha ............................................... .................................................. .............. 264
Tipología de cartas ................................................ .................................................. ......................... 267

Gráficos de líneas ................................................ .................................................. .............................. 267
Gráficos de líneas con pandas .............................................. .................................................. ...... 276
Histogramas ................................................. .................................................. ............................. 277

Gráfica de barras ................................................ .................................................. ............................... 278
Gráficos de barras horizontales ............................................... .................................................. .......... 281
Gráficos de barras multiseriales ............................................... .................................................. ......... 282
Gráficos de barras multiserie con pandas Dataframe ............................................ ....................... 285
Gráficos de barras apiladas multiserie .............................................. ............................................. 286
Gráficos de barras apiladas con un marco de datos de pandas ........................................... ......................... 290
Otras representaciones de gráficos de barras .............................................. ........................................... 291
Gráficos circulares ................................................ .................................................. ................................ 292

Gráficos circulares con un marco de datos de pandas ............................................ ....................................... 296
Gráficos avanzados ................................................ .................................................. ..................... 297
Gráficos de contorno ................................................ .................................................. ..................... 297
Cartas polares ................................................ .................................................. ....................... 299
El kit de herramientas de mplot3d ............................................... .................................................. .................. 302

Superficies 3D ................................................ .................................................. ....................... 302
Gráficos de dispersión en 3D .............................................. .................................................. ............... 304
Gráficos de barras en 3D .............................................. .................................................. .................. 306
Gráficos de paneles múltiples .............................................. .................................................. ....................... 307
Mostrar subparcelas dentro de otras subparcelas ............................................. ................................. 307
Cuadrículas de subparcelas ............................................... .................................................. ................ 309
Conclusiones ................................................. .................................................. ............................ 312
xi
Pagina 12
TABLA DE CONTENIDO
Capítulo 8: Aprendizaje automático con scikitelearn ........................................... ......... 313

La biblioteca scikit-learn ............................................. .................................................. .............. 313
Aprendizaje automático ................................................ .................................................. ................... 313
Aprendizaje supervisado y no supervisado .............................................. ................................ 314
Equipo de entrenamiento y equipo de prueba ............................................. .................................................. .315
Aprendizaje supervisado con scikit-learn ............................................ .......................................... 315
El conjunto de datos de flores de iris .............................................. .................................................. ............. 316

La descomposición de PCA ............................................... .................................................. ..... 320
Clasificador K-Vecinos más cercanos ............................................. .................................................. .. 322

Conjunto de datos de diabetes ................................................ .................................................. ..................... 327
Regresión lineal: la regresión de mínimos cuadrados ........................................... .......................... 328
Máquinas de vectores de soporte (SVM) ............................................ .................................................. 334

Clasificación de vectores de soporte (SVC) ............................................ ......................................... 334
SVC no lineal ................................................ .................................................. .................... 339
Trazado de diferentes clasificadores de SVM utilizando el conjunto de datos Iris .......................................... .......... 342
Regresión de vectores de soporte (SVR) ............................................ ............................................. 345
Conclusiones ................................................. .................................................. ............................ 347
Capítulo 9: Aprendizaje profundo con TensorFlow ........................................... ............... 349

Inteligencia artificial, aprendizaje automático y aprendizaje profundo ......................................... .......... 349
Inteligencia artificial ................................................ .................................................. .......... 350
El aprendizaje automático es una rama de la inteligencia artificial .......................................... ............. 351
El aprendizaje profundo es una rama del aprendizaje automático .......................................... ....................... 351
La relación entre inteligencia artificial, aprendizaje automático y aprendizaje profundo ... 351
Aprendizaje profundo ................................................ .................................................. ......................... 352

Redes neuronales y GPU .............................................. .................................................. .352
Disponibilidad de datos: fuente de datos abierta, Internet de las cosas y Big Data ................................ 353
Python ................................................. .................................................. .............................. 354
Frameworks de aprendizaje profundo en Python .............................................. ...................................... 354
Redes neuronales artificiales ............................................... .................................................. ........ 355

Cómo se estructuran las redes neuronales artificiales ............................................ ....................... 355
Perceptrón de capa única (SLP) ............................................ ................................................. 357
xii
Página 13
TABLA DE CONTENIDO
Perceptrón multicapa (MLP) ............................................ .................................................. 360

Correspondencia entre redes neuronales artificiales y biológicas .................................. 361
TensorFlow ................................................. .................................................. ............................. 362

TensorFlow: Marco de Google .............................................. .......................................... 362
TensorFlow: Gráfico de flujo de datos ............................................. ................................................. 362
Comenzar a programar con TensorFlow .............................................. ........................................... 363

Instalando TensorFlow ................................................ .................................................. ......... 363
Programación con IPython QtConsole ............................................. .............................. 364
El modelo y las sesiones en TensorFlow ............................................ ................................... 364
Tensores ................................................. .................................................. ............................. 366
Operación en tensores ............................................... .................................................. .......... 370
Perceptrón de capa única con TensorFlow ............................................. .................................... 371

Antes de empezar ................................................ .................................................. .................. 372
Datos a analizar .............................................. .................................................. ............ 372
Definición del modelo SLP .............................................. .................................................. .... 374
Fase de aprendizaje ................................................ .................................................. .................. 378
Fase de prueba y cálculo de precisión ............................................. ..................................... 383
Perceptrón multicapa (con una capa oculta) con TensorFlow ....................................... .... 386
La definición del modelo MLP .............................................. .................................................. .... 387
Fase de aprendizaje ................................................ .................................................. .................. 389
Perceptrón multicapa (con dos capas ocultas) con TensorFlow ....................................... ... 397
Evaluación de datos experimentales .............................................. ............................................ 404
Conclusiones ................................................. .................................................. ............................ 407
Capítulo 10: Un ejemplo: datos meteorológicos .......................................... ........ 409

Una hipótesis para probar: la influencia de la proximidad del mar .................................... .. 409
El sistema en el estudio: el mar Adriático y el valle del Po ..................................... ........ 410
Encontrar la fuente de datos .............................................. .................................................. ............ 414
Análisis de datos en el cuaderno Jupyter ............................................. ............................................. 415
Análisis de datos meteorológicos procesados ............................................. ................................. 421
xiii
Página 14
TABLA DE CONTENIDO
El viento de rosa ................................................ .................................................. ......................... 436

Cálculo de la distribución media de la velocidad del viento .......................................... ............... 441
Conclusiones ................................................. .................................................. ........................... 443
Capítulo 11: Incrustación de la biblioteca JavaScript D3 en IPython Notebook ... 445

La fuente de datos abierta para la demografía ............................................ ..................................... 445
La biblioteca JavaScript D3 .............................................. .................................................. ......... 449

Dibujar un gráfico de barras agrupadas ............................................. .................................................. .. 454
Los mapas de coropletas ............................................... .................................................. ............... 459
El mapa de coropletas de la población de EE. UU. En 2014 ......................................... ......................... 464
Conclusiones ................................................. .................................................. ............................ 471
Capítulo 12: Reconocimiento de dígitos escritos a mano ............................................ ............ 473

Reconocimiento de escritura a mano ................................................ .................................................. ......... 473
Reconocimiento de dígitos escritos a mano con scikit-learn ........................................... .......................... 474

El conjunto de datos de dígitos ............................................... .................................................. .................... 475
Aprender y predecir ............................................... .................................................. ........... 478
Reconocimiento de dígitos escritos a mano con TensorFlow ............................................. ........................ 480
Aprender y predecir ............................................... .................................................. ........... 482
Conclusiones ................................................. .................................................. ............................ 486
Capítulo 13: Análisis de datos textuales con NLTK .......................................... ............. 487
Técnicas de análisis de texto ............................................... .................................................. ......... 487
El kit de herramientas de lenguaje natural (NLTK) ........................................... ........................................ 488
Importar la biblioteca NLTK y la herramienta de descarga NLTK ......................................... ............ 489
Buscar una palabra con NLTK ............................................ .................................................. .493
Analizar la frecuencia de las palabras ............................................. ........................................... 494
Selección de palabras del texto ............................................. .................................................. 497
Bigrams y colocaciones ............................................... .................................................. ... 498
Usar texto en la red ............................................. .................................................. ............ 500

Extraer el texto de las páginas HTML ........................................... ..................................... 501
Análisis sentimental ................................................ .................................................. ......... 502
Conclusiones ................................................. .................................................. ............................ 506
xiv
Página 15
TABLA DE CONTENIDO
Capítulo 14: Análisis de imágenes y visión por computadora con OpenCV .......................... 507
Análisis de imágenes y visión artificial ............................................. ........................................... 507
OpenCV y Python ............................................... .................................................. .................. 508
OpenCV y Deep Learning .............................................. .................................................. ...... 509
Instalación de OpenCV ................................................ .................................................. .................... 509
Primeros enfoques para el procesamiento y análisis de imágenes ........................................... ...................... 509

Antes de empezar ................................................ .................................................. .................. 510
Cargar y mostrar una imagen ............................................. .................................................. .. 510
Trabajar con imágenes ............................................... .................................................. .......... 512
Guardar la nueva imagen .............................................. .................................................. ............ 514
Operaciones elementales en imágenes .............................................. ........................................ 514
Mezcla de imágenes ................................................ .................................................. .................. 520
Análisis de imagen ................................................ .................................................. ........................ 521
Detección de bordes y análisis de gradiente de imagen ............................................ ............................... 522

Detección de bordes ................................................ .................................................. .................. 522
La teoría del degradado de imagen .............................................. .................................................. .523
Un ejemplo práctico de detección de bordes con el análisis de gradiente de imagen ... 525
Un ejemplo de aprendizaje profundo: la detección de rostros .......................................... ............................... 532
Conclusiones ................................................. .................................................. ............................ 535
Apéndice A: Escritura de expresiones matemáticas con LaTeX ................................ 537

Con matplotlib ................................................ .................................................. ........................ 537
Con IPython Notebook en una celda de Markdown ........................................... ................................... 537

Con IPython Notebook en una celda de Python 2 .......................................... ....................................... 538
Subíndices y superíndices ............................................... .................................................. .... 538
Fracciones, binomios y números apilados ........................................... ................................. 538
Radicales ................................................. .................................................. ................................. 539
Fuentes ................................................. .................................................. ...................................... 539
Acentos ................................................. .................................................. .................................. 540
xv
Página 16
TABLA DE CONTENIDO
Apéndice B: Fuentes de datos abiertas ............................................ ............................... 549

Datos políticos y gubernamentales .............................................. .................................................. .. 549
Datos de salud ................................................ .................................................. ............................. 550
Datos sociales ................................................ .................................................. .............................. 550
Conjuntos de datos públicos y diversos ............................................. ............................................ 551
Datos financieros ................................................ .................................................. ......................... 552
Datos climáticos ................................................ .................................................. ........................... 552
Datos deportivos ................................................ .................................................. ............................. 553

Publicaciones, periódicos y libros ............................................ .......................................... 553
Datos musicales ................................................ .................................................. ........................... 553
Índice ................................................. .................................................. .................. 555
xvi
Página 17
Sobre el Autor
Fabio Nelli es científico de datos y consultor de Python, diseña y desarrolla Python
aplicaciones para análisis y visualización de datos. Tiene experiencia con la ciencia
mundo, habiendo desempeñado varios roles de análisis de datos en química farmacéutica para
empresas privadas de investigación y universidades. Ha sido consultor informático para
muchos años en IBM, EDS y Hewlett-Packard, junto con varios bancos y seguros
compañías. Tiene una maestría en química orgánica y una licenciatura en
tecnologías de la información y sistemas de automatización, con muchos años de experiencia en
ciencias de la vida (como Tech Specialist en Beckman Coulter, Tecan, Sciex).
Para obtener más información y otros ejemplos, visite su página en https: //www.meccanismocomplesso.
org y la página de GitHub https://github.com/meccanismocomplesso .
xvii
Página 18
Acerca del revisor técnico

Raul Samayoa es un desarrollador senior de software y máquina
especialista en aprendizaje con muchos años de experiencia en el
industria financiera. Un graduado de maestría de Georgia
Instituto de Tecnología, nunca ha conocido una red neuronal o
conjunto de datos que no le gustó. Le gusta evangelizar el uso de
Herramientas DevOps para ciencia de datos y desarrollo de software.
Raúl disfruta de la energía de su ciudad natal de Toronto,
Canadá, donde corre maratones, se ofrece como voluntario
instructor de tecnología de la Universidad de Toronto
codificadores, y le gusta trabajar con datos en Python y R.
xix
Página 19
CAPÍTULO 1
Introducción a
Análisis de los datos
En este capítulo, comenzará a dar los primeros pasos en el mundo del análisis de datos, aprendiendo en
detalle sobre todos los conceptos y procesos que componen esta disciplina. Los conceptos
discutidos en este capítulo son antecedentes útiles para los siguientes capítulos, donde estos
Los conceptos y procedimientos se aplicarán en forma de código Python, mediante el uso de
varias bibliotecas que se discutirán en tantos capítulos.
Análisis de los datos

En un mundo cada vez más centralizado en torno a la tecnología de la información, enormes cantidades de
los datos se producen y almacenan cada día. A menudo, estos datos provienen de la detección automática.
sistemas, sensores e instrumentación científica, o los produce diariamente y
inconscientemente cada vez que realiza un retiro del banco o realiza una compra,
cuando grabas varios blogs, o incluso cuando publicas en redes sociales.
Pero, cuales son los datos? Los datos en realidad no son información, al menos en términos de
su forma. En el flujo informe de bytes, a primera vista es difícil comprender su
esencia, si no estrictamente el número, palabra o tiempo que informan. La información es en realidad
el resultado del procesamiento, que, teniendo en cuenta un determinado conjunto de datos, extrae algunos
conclusiones que se pueden utilizar de diversas formas. Este proceso de extraer información
a partir de datos brutos se denomina análisis de datos .
El propósito del análisis de datos es extraer información que no es fácilmente deducible
pero que, entendido, conduce a la posibilidad de realizar estudios sobre la
mecanismos de los sistemas que los han producido, lo que le permite pronosticar
posibles respuestas de estos sistemas y su evolución en el tiempo.
1
© Fabio Nelli 2018
F. Nelli, Python Data Analytics , https://doi.org/10.1007/978-1-4842-3913-1_1
Página 20
CAPÍTULO 1 INTRODUCCIÓN AL ANÁLISIS DE DATOS
Partiendo de un enfoque metódico simple sobre la protección de datos, el análisis de datos ha

convertirse en una disciplina real, que lleve al desarrollo de metodologías reales que generen
modelos . El modelo es, de hecho, la traducción a una forma matemática de un sistema colocado
en estudio. Una vez que existe una forma matemática o lógica que puede describir el sistema
respuestas con diferentes niveles de precisión, puede hacer predicciones sobre
su desarrollo o respuesta a ciertos insumos. Por tanto, el objetivo del análisis de datos no es el
modelo, sino la calidad de su poder predictivo .
El poder predictivo de un modelo depende no solo de la calidad del modelado
técnicas sino también en la capacidad de elegir un buen conjunto de datos sobre el cual construir el
todo el proceso de análisis de datos. Por lo que la búsqueda de los datos , su extracción , y su posterior
preparación , aunque representa actividades preliminares de un análisis, también pertenecen a los datos
análisis en sí mismo, por su importancia en el éxito de los resultados.
Hasta ahora hemos hablado de los datos, su manejo y su procesamiento mediante
procedimientos de cálculo. Paralelamente a todas las etapas del procesamiento del análisis de datos, varios
Se han desarrollado métodos de visualización de datos . De hecho, para comprender los datos, tanto
individualmente y en términos de la función que desempeñan en todo el conjunto de datos, no hay mejor
sistema que desarrollar las técnicas de representación gráfica capaces de transformar
información, a veces implícitamente oculta, en cifras, que le ayudan más fácilmente
entender su significado. A lo largo de los años, se han desarrollado muchos modos de visualización para
diferentes modos de visualización de datos: los gráficos .
Al final del proceso de análisis de datos, tendrá un modelo y un conjunto de gráficos
muestra y luego podrá predecir las respuestas del sistema en estudio;
después de eso, pasará a la fase de prueba. El modelo se probará con otro conjunto
de datos para los que conoce la respuesta del sistema. Sin embargo, estos datos no se utilizan para
definir el modelo predictivo. Dependiendo de la capacidad del modelo para replicar real
respuestas observadas, tendrá un cálculo de error y conocimiento de la validez de
el modelo y sus límites operativos.
Estos resultados se pueden comparar con cualquier otro modelo para comprender si el nuevo
creado uno es más eficiente que los existentes. Una vez que haya evaluado eso,
puede pasar a la última fase del análisis de datos: implementación . Consiste en implementar
los resultados producidos por el análisis, es decir, la implementación de las decisiones a tomar
en base a las predicciones generadas por el modelo y los riesgos asociados.
El análisis de datos se adapta bien a muchas actividades profesionales. Entonces, conocimiento de eso
y cómo se puede poner en práctica es relevante. Le permite probar hipótesis y
comprender más profundamente los sistemas analizados.
Página 21
Dominios de conocimiento del analista de datos

El análisis de datos es básicamente una disciplina adecuada para el estudio de los problemas que puedan surgir.
en varios campos de aplicaciones. Además, el análisis de datos incluye muchas herramientas y
Metodologías que requieren buenos conocimientos de informática, matemáticas y estadística.
conceptos.
Un buen analista de datos debe poder moverse y actuar en muchas disciplinas diferentes.
áreas. Muchas de estas disciplinas son la base de los métodos de análisis de datos, y
el dominio de ellos es casi necesario. Es necesario el conocimiento de otras disciplinas
dependiendo del área de aplicación y estudio del proyecto de análisis de datos en particular
está a punto de emprender y, de manera más general, la experiencia suficiente en estas áreas puede
ayudarlo a comprender mejor los problemas y el tipo de datos necesarios.
A menudo, con respecto a los problemas importantes del análisis de datos, es necesario tener un
equipo interdisciplinario de expertos que pueden contribuir de la mejor manera posible en su
respectivos campos de competencia. En cuanto a problemas menores, un buen analista debe ser capaz de
reconocer los problemas que surgen durante el análisis de datos, indagar para determinar qué disciplinas
y habilidades son necesarias para resolver estos problemas, estudiar estas disciplinas y tal vez incluso
pregunte a las personas más conocedoras del sector. En resumen, el analista debe poder saber
cómo buscar no solo datos, sino también información sobre cómo tratarlos.
Ciencias de la Computación
El conocimiento de la informática es un requisito básico para cualquier analista de datos. De hecho,
sólo cuando tenga buenos conocimientos y experiencia en informática podrá
administrar de manera eficiente las herramientas necesarias para el análisis de datos. De hecho, cada paso relativo
El análisis de datos implica el uso de software de cálculo (como IDL, MATLAB, etc.) y
lenguajes de programación (como C ++, Java y Python).
La gran cantidad de datos disponibles en la actualidad, gracias a las tecnologías de la información, requiere
habilidades específicas para ser gestionadas de la manera más eficiente posible. De hecho, la investigación de datos
y la extracción requieren conocimiento de estos diversos formatos. Los datos están estructurados y
almacenados en archivos o tablas de bases de datos con formatos particulares. XML, JSON o simplemente XLS
o archivos CSV, son ahora los formatos comunes para almacenar y recopilar datos, y muchos
Las aplicaciones le permiten leer y administrar los datos almacenados en ellas. Cuando se trata de
extrayendo datos contenidos en una base de datos, las cosas no son tan inmediatas, pero es necesario
conocer el lenguaje de consulta SQL o utilizar software especialmente desarrollado para la extracción de
datos de una base de datos determinada.
Página 22
Además, para algunos tipos específicos de investigación de datos, los datos no están disponibles en un
formato explícito, pero están presentes en archivos de texto (documentos y archivos de registro) o páginas web, y
se muestran como gráficos, medidas, número de visitantes o tablas HTML. Esto requiere
experiencia técnica para el análisis y la eventual extracción de estos datos (llamado web
raspado ).
Por tanto, el conocimiento de las tecnologías de la información es necesario para saber utilizar
Varias herramientas puestas a disposición por la informática contemporánea, como aplicaciones
y lenguajes de programación. Estas herramientas, a su vez, son necesarias para realizar análisis de datos.
y visualización de datos.
El propósito de este libro es proporcionar todos los conocimientos necesarios, en la medida de lo posible,
en cuanto al desarrollo de metodologías para el análisis de datos. El libro usa Python
lenguaje de programación y bibliotecas especializadas que aportan una contribución decisiva a
la realización de todos los pasos que constituyen el análisis de datos, desde la investigación de datos hasta los datos
minería, a la publicación de los resultados del modelo predictivo.
Matemáticas y Estadística
Como verá a lo largo del libro, el análisis de datos requiere muchas matemáticas complejas
durante el tratamiento y tratamiento de datos. Necesitas ser competente en todo esto,
al menos para entender lo que estás haciendo. Alguna familiaridad con las principales estadísticas
conceptos también es necesario porque todos los métodos que se aplican en el análisis y
La interpretación de los datos se basa en estos conceptos. Como puedes decir que la computadora
la ciencia le brinda las herramientas para el análisis de datos, por lo que puede decir que las estadísticas brindan la
conceptos que forman la base del análisis de datos.
Esta disciplina proporciona muchas herramientas al analista y un buen conocimiento de cómo
Utilizarlos mejor requiere años de experiencia. Entre los estadísticos más utilizados
Las técnicas de análisis de datos son
• Métodos bayesianos
• Regresión
• Agrupación
Teniendo que lidiar con estos casos, descubrirás cómo las matemáticas y la estadística son
estrechamente relacionada. Gracias a las bibliotecas especiales de Python que se tratan en este libro, podrá
capaz de gestionarlos y manejarlos.
Página 23
Aprendizaje automático e inteligencia artificial

Una de las herramientas más avanzadas que se incluye en el campo del análisis de datos es el aprendizaje automático.
De hecho, a pesar de la visualización de datos y técnicas como la agrupación en clústeres y la regresión,
que debería ayudarlo a encontrar información sobre el conjunto de datos, durante esta fase de investigación,
a menudo puede preferir utilizar procedimientos especiales que están altamente especializados en la búsqueda
patrones dentro del conjunto de datos.
El aprendizaje automático es una disciplina que utiliza toda una serie de procedimientos y
algoritmos que analizan los datos para reconocer patrones, clústeres o tendencias y
luego extrae información útil para el análisis de datos de forma automatizada.
Esta disciplina se está convirtiendo cada vez más en una herramienta fundamental de análisis de datos, y
por tanto, su conocimiento, al menos en general, es de fundamental importancia para los datos
analista.
Campos de aplicación profesionales

Otro punto muy importante es el dominio de competencia de los datos.
(su fuente: biología, física, finanzas, pruebas de materiales, estadísticas de población, etc.).
De hecho, aunque los analistas han tenido una preparación especializada en el campo de la estadística,
también deben poder documentar la fuente de los datos, con el objetivo de percibir
y comprender mejor los mecanismos que generaron los datos. De hecho, los datos son
no simples cadenas o números; son la expresión, o más bien la medida, de cualquier
parámetro observado. Por lo tanto, comprender mejor de dónde provienen los datos puede mejorar
su interpretación. A menudo, sin embargo, esto es demasiado costoso para los analistas de datos, incluso aquellos con
las mejores intenciones, por lo que es una buena práctica encontrar consultores o figuras clave a quienes
puede plantear las preguntas adecuadas.
Comprensión de la naturaleza de los datos

El objeto de estudio del análisis de datos son básicamente los datos. Los datos entonces serán los
actor clave en todos los procesos de análisis de datos. Los datos constituyen la materia prima a ser
procesados, y gracias a su procesamiento y análisis, es posible extraer una variedad
de información con el fin de incrementar el nivel de conocimiento del sistema en estudio, que
es decir, uno del que proceden los datos.
Página 24
Cuando los datos se convierten en información

Los datos son los eventos registrados en el mundo. Todo lo que pueda medirse o categorizarse
se puede convertir en datos. Una vez recopilados, estos datos se pueden estudiar y analizar, tanto
para comprender la naturaleza de los eventos y, muy a menudo, también para hacer predicciones o al menos
para tomar decisiones informadas.
Cuando la información se convierte en conocimiento

Se puede hablar de conocimiento cuando la información se convierte en un conjunto de reglas que
le ayuda a comprender mejor ciertos mecanismos y, por lo tanto, a hacer predicciones sobre el
evolución de algunos eventos.
Tipos de datos
Los datos se pueden dividir en dos categorías distintas:
• Categórico (nominal y ordinal)
• Numérico (discreto y continuo)
Los datos categóricos son valores u observaciones que se pueden dividir en grupos o
categorías. Hay dos tipos de valores categóricos: nominal y ordinal . Un nominal
La variable no tiene un orden intrínseco que se identifique en su categoría. Una variable ordinal
en cambio, tiene un orden predeterminado.
Los datos numéricos son valores u observaciones que provienen de mediciones. Existen
dos tipos de valores numéricos: números discretos y continuos . Los valores discretos pueden ser
contados y son distintos y separados entre sí. Valores continuos, por otro
mano, son valores producidos por mediciones u observaciones que asumen cualquier valor
dentro de un rango definido.
El proceso de análisis de datos

El análisis de datos se puede describir como un proceso que consta de varios pasos en los que el
los datos se transforman y procesan para producir visualizaciones de datos y hacer
predicciones gracias a un modelo matemático basado en los datos recopilados. Entonces, datos
Página 25
El análisis no es más que una secuencia de pasos, cada uno de los cuales juega un papel clave en la
posteriores. Por tanto, el análisis de datos se esquematiza como una cadena de proceso que consta de
siguiente secuencia de etapas:
• Definición del problema
• Extracción de datos
• Preparación de datos: limpieza de datos
• Preparación de datos: transformación de datos
• Exploración y visualización de datos
• Modelado predictivo
• Prueba / validación del modelo
• Implementar: visualización e interpretación de resultados
• Implementar: implementación de la solución
Figura 1-1 muestra una representación esquemática de todos los procesos involucrados en el
análisis de los datos.
Página 26
Figura 1-1. El proceso de análisis de datos
Definición del problema

En realidad, el proceso de análisis de datos comienza mucho antes de la recopilación de datos sin procesar. En
De hecho, el análisis de datos siempre comienza con un problema a resolver, que necesita ser definido.
El problema se define solo después de haber enfocado el sistema que desea estudiar;
esto puede ser un mecanismo, una aplicación o un proceso en general. Generalmente este estudio
puede ser para comprender mejor su funcionamiento, pero en particular el estudio
estar diseñado para comprender los principios de su comportamiento con el fin de poder hacer
predicciones o elecciones (definidas como una elección informada).
El paso de definición y la documentación correspondiente ( entregables ) del
El problema científico o el negocio son muy importantes para enfocar todo el
análisis estrictamente en la obtención de resultados. De hecho, un estudio completo o exhaustivo de la
Página 27
El sistema a veces es complejo y no siempre tiene suficiente información para comenzar.

con. De modo que la definición del problema y especialmente su planificación puede determinar la
pautas a seguir para todo el proyecto.
Una vez que se ha definido y documentado el problema, puede pasar al proyecto
etapa de planificación del análisis de datos. Se necesita planificación para comprender qué profesionales
y recursos son necesarios para cumplir con los requisitos para llevar a cabo el proyecto como
eficientemente como sea posible. Así que vas a considerar las cuestiones en el área que involucran
resolución del problema. Buscará especialistas en diversas áreas de interés y
instale el software necesario para realizar análisis de datos.
También durante la fase de planificación, elige un equipo eficaz. Generalmente, estos
Los equipos deben ser interdisciplinarios para resolver el problema al observar los datos.
desde diferentes perspectivas. Entonces, construir un buen equipo es sin duda uno de los factores clave
conduciendo al éxito en el análisis de datos.
Extracción de datos
Una vez definido el problema, el primer paso es obtener los datos para poder
realizar el análisis. Los datos deben elegirse con la finalidad básica de construir el
modelo predictivo, por lo que la selección de datos también es crucial para el éxito del análisis.
Los datos de muestra recopilados deben reflejar tanto como sea posible el mundo real, es decir, cómo
el sistema responde a los estímulos del mundo real. Por ejemplo, si usa enormes
conjuntos de datos de datos brutos y no se recopilan de manera competente, estos pueden representar datos falsos o
situaciones de desequilibrio.
Por lo tanto, una mala elección de datos, o incluso la realización de análisis en un conjunto de datos que no
perfectamente representativo del sistema, dará lugar a modelos que se alejarán del
sistema en estudio.
La búsqueda y recuperación de datos a menudo requiere una forma de intuición que va más allá
mera investigación técnica y extracción de datos. Este proceso también requiere un cuidadoso
comprensión de la naturaleza y forma de los datos, que solo una buena experiencia y
el conocimiento en el campo de aplicación del problema puede proporcionar.
Independientemente de la calidad y cantidad de datos necesarios, otro problema es utilizar los mejores
fuentes de datos.
Si el entorno del estudio es un laboratorio (técnico o científico) y los datos
generados son experimentales, entonces, en este caso, la fuente de datos es fácilmente identificable. En esto
En este caso, los problemas serán solo relacionados con la configuración experimental.
Página 28
Pero no es posible que el análisis de datos reproduzca sistemas en los que los datos
recopilados de forma estrictamente experimental en todos los campos de aplicación. Muchos campos requieren
buscando datos del mundo circundante, a menudo confiando en experimentos externos
datos, o incluso más a menudo recogiéndolos a través de entrevistas o encuestas. Entonces en estos
casos, encontrar una buena fuente de datos que pueda proporcionar toda la información que necesita
para el análisis de datos puede resultar bastante complicado. A menudo es necesario recuperar datos de
múltiples fuentes de datos para complementar cualquier deficiencia, para identificar cualquier discrepancia,
y hacer que el conjunto de datos sea lo más general posible.
Cuando desee obtener los datos, un buen lugar para comenzar es la Web. Pero la mayor parte de
los datos en la Web pueden ser difíciles de capturar; de hecho, no todos los datos están disponibles en un archivo o
base de datos, pero puede ser contenido dentro de páginas HTML en muchos formatos diferentes. A
Para ello, una metodología denominada web scraping permite la recopilación de datos a través del
reconocimiento de la ocurrencia específica de etiquetas HTML dentro de las páginas web. Hay software
diseñado específicamente para este propósito, y una vez que se encuentra una ocurrencia, extrae la
datos deseados. Una vez finalizada la búsqueda, obtendrá una lista de datos listos para ser sometidos
al análisis de datos.
Preparación de datos
Entre todos los pasos involucrados en el análisis de datos, la preparación de datos, aunque aparentemente
menos problemático, de hecho requiere más recursos y más tiempo para completarse. Datos
a menudo se recopilan de diferentes fuentes de datos, cada una de las cuales tendrá datos con un
diferente representación y formato. Por tanto, todos estos datos deberán estar preparados para la
proceso de análisis de datos.
La preparación de los datos tiene que ver con la obtención, limpieza, normalización y
transformar datos en un conjunto de datos optimizado, es decir, en un formato preparado que normalmente
tabular y es adecuado para los métodos de análisis que se han programado durante el
fase de diseño.
Pueden surgir muchos problemas potenciales, incluidos valores no válidos, ambiguos o faltantes,
campos replicados y datos fuera de rango.
Exploración / visualización de datos

Explorar los datos implica esencialmente buscar los datos en un gráfico o estadístico.
presentación para encontrar patrones, conexiones y relaciones. Visualización de datos
es la mejor herramienta para resaltar posibles patrones.
10
Página 29
En los últimos años, la visualización de datos se ha desarrollado hasta tal punto que ha
convertirse en una verdadera disciplina en sí misma. De hecho, numerosas tecnologías se utilizan exclusivamente
para mostrar datos, y se aplican muchos tipos de visualización para extraer la mejor
información de un conjunto de datos.
La exploración de datos consiste en un examen preliminar de los datos, que es
importante para comprender el tipo de información que se ha recopilado y qué
significa. En combinación con la información adquirida durante el problema de definición,
esta categorización determinará qué método de análisis de datos será el más adecuado
para llegar a una definición de modelo.
Generalmente, esta fase, además de un estudio detallado de las cartas a través del
Los datos de visualización pueden consistir en una o más de las siguientes actividades:
• Resumen de datos
• Agrupar datos
• Explorar la relación entre los distintos atributos
• Identificar patrones y tendencias
• Construir modelos de regresión
• Construir modelos de clasificación
Generalmente, el análisis de datos requiere resumir declaraciones sobre los datos a ser
estudió. El resumen es un proceso mediante el cual los datos se reducen a interpretación sin
sacrificar información importante.
La agrupación en clústeres es un método de análisis de datos que se utiliza para encontrar grupos unidos por
atributos (también llamado agrupamiento ).
Otro paso importante del análisis se centra en la identificación de relaciones,
tendencias y anomalías en los datos. Para encontrar este tipo de información, a menudo
tener que recurrir a las herramientas, así como realizar otra ronda de análisis de datos, esta vez en
la visualización de datos en sí.
Otros métodos de minería de datos, como árboles de decisión y reglas de asociación,
Extrae automáticamente hechos o reglas importantes de los datos. Estos enfoques pueden ser
se utiliza en paralelo con la visualización de datos para descubrir las relaciones entre los datos.
11
Página 30
Modelado predictivo
El modelado predictivo es un proceso utilizado en el análisis de datos para crear o elegir un
modelo estadístico para predecir la probabilidad de un resultado.
Después de explorar los datos, tiene toda la información necesaria para desarrollar el
modelo matemático que codifica la relación entre los datos. Estos modelos son
útiles para comprender el sistema en estudio, y de una manera específica se utilizan para
dos propósitos principales. El primero es hacer predicciones sobre los valores de datos producidos por
el sistema; en este caso, tratará con modelos de regresión. El segundo propósito
es clasificar nuevos productos de datos y, en este caso, utilizará modelos de clasificación
o modelos de agrupamiento . De hecho, es posible dividir los modelos según el tipo de
resultado que producen:
• Modelos de clasificación : Si el resultado obtenido por el tipo de modelo es

categórico.
• Modelos de regresión : si el resultado obtenido por el tipo de modelo es

numérico.
• Modelos de agrupación : si el resultado obtenido por el tipo de modelo es

descriptivo.
Los métodos simples para generar estos modelos incluyen técnicas como el lineal
árboles de regresión, regresión logística, clasificación y regresión, y k-más cercano
vecinos. Pero los métodos de análisis son numerosos y cada uno tiene
características que lo hacen excelente para algunos tipos de datos y análisis. Cada uno de estos
Los métodos producirán un modelo específico, y luego su elección es relevante para la naturaleza de
el modelo de producto.
Algunos de estos modelos proporcionarán valores correspondientes al sistema real y
según su estructura. Explicarán algunas características del sistema en
estudiar de forma sencilla y clara. Otros modelos seguirán dando buenas predicciones,
pero su estructura no será más que una "caja negra" con capacidad limitada para explicar
características del sistema.
12
Página 31
Modelo de validación
La validación del modelo, es decir, la fase de prueba, es una fase importante que le permite
validar el modelo construido sobre la base de datos iniciales. Eso es importante porque permite
usted para evaluar la validez de los datos producidos por el modelo comparándolos directamente
con el sistema actual. Pero esta vez, sale del conjunto de datos iniciales en
que se ha establecido todo el análisis.
Generalmente, se referirá a los datos como el conjunto de entrenamiento cuando los utilice para
construyendo el modelo, y como el conjunto de validación cuando los está usando para validar el
modelo.
Así, al comparar los datos producidos por el modelo con los producidos por el
sistema, podrá evaluar el error y, utilizando diferentes conjuntos de datos de prueba, puede
Estimar los límites de validez del modelo generado. De hecho, lo predicho correctamente
los valores pueden ser válidos solo dentro de un cierto rango o tener diferentes niveles de coincidencia
dependiendo del rango de valores tomados en cuenta.
Este proceso le permite no solo evaluar numéricamente la efectividad de
el modelo sino también para compararlo con cualquier otro modelo existente. Hay varios
técnicas al respecto; el más famoso es la validación cruzada . Esta técnica es
basado en la división del conjunto de formación en diferentes partes. Cada una de estas partes, en
turn, se utilizará como conjunto de validación y cualquier otro como conjunto de entrenamiento. En este iterativo
manera, tendrá un modelo cada vez más perfeccionado.
Despliegue
Este es el paso final del proceso de análisis, que tiene como objetivo presentar los resultados, es decir, la
conclusiones del análisis. En el proceso de implementación del entorno empresarial, el
El análisis se traduce en un beneficio para el cliente que lo ha encargado. En técnica
o entornos científicos, se traduce en soluciones de diseño o publicaciones científicas.
Es decir, el despliegue consiste básicamente en poner en práctica los resultados obtenidos
del análisis de datos.
Hay varias formas de implementar los resultados del análisis de datos o la minería de datos.
Normalmente, la implementación de un analista de datos consiste en escribir un informe para la administración o
para el cliente que solicitó el análisis. Este documento describirá conceptualmente
los resultados obtenidos del análisis de datos. El informe debe dirigirse al
gerentes, que luego pueden tomar decisiones. Luego, pondrán en práctica el
conclusiones del análisis.
13
Página 32
En la documentación suministrada por el analista, cada uno de estos cuatro temas será
discutido en detalle:
• Resultados de analisis
• Implementación de decisiones
• Análisis de riesgo
• Medir el impacto empresarial
Cuando los resultados del proyecto incluyen la generación de modelos predictivos, estos
Los modelos se pueden implementar como aplicaciones independientes o se pueden integrar en otros
software.
Análisis de datos cuantitativos y cualitativos

El análisis de datos se centra completamente en los datos. Dependiendo de la naturaleza de los datos, es
posible hacer algunas distinciones.
Cuando los datos analizados tienen una estructura estrictamente numérica o categórica, entonces
se habla de análisis cuantitativo , pero cuando se trata de valores que
se expresan a través de descripciones en lenguaje natural, entonces estás hablando de
análisis cualitativo .
Precisamente por la diferente naturaleza de los datos tratados por los dos tipos de
análisis, puede observar algunas diferencias entre ellos.
El análisis cuantitativo tiene que ver con datos con un orden lógico o que pueden ser
categorizado de alguna manera. Esto conduce a la formación de estructuras dentro de los datos.
El orden, la categorización y las estructuras a su vez proporcionan más información y permiten
procesamiento adicional de los datos de una manera más matemática. Esto lleva a la generación
de modelos que proporcionan predicciones cuantitativas, lo que permite al analista de datos dibujar
conclusiones más objetivas.
En cambio, el análisis cualitativo tiene que ver con datos que generalmente no tienen una estructura,
al menos ninguno que sea evidente, y su naturaleza no es numérica ni categórica. por
Por ejemplo, los datos bajo estudio cualitativo podrían incluir textos escritos, visuales o de audio.
datos. Por tanto, este tipo de análisis debe basarse en metodologías, a menudo ad hoc, para
extraer la información que generalmente conducen a modelos capaces de proporcionar cualitativa
predicciones , con el resultado de que las conclusiones a las que puede llegar el analista de datos
también puede incluir interpretaciones subjetivas . Por otro lado, el análisis cualitativo
14
Página 33
Puede explorar sistemas más complejos y sacar conclusiones que no son posibles utilizando un
enfoque estrictamente matemático. A menudo, este tipo de análisis implica el estudio de sistemas
como fenómenos sociales o estructuras complejas que no son fácilmente mensurables.
Figura 1-2 muestra las diferencias entre los dos tipos de análisis.
Figura 1-2. Análisis cuantitativos y cualitativos
Información abierta
En apoyo de la creciente demanda de datos, ahora hay una gran cantidad de fuentes de datos.
disponible en Internet. Estas fuentes de datos brindan información libremente a cualquier persona en
necesitan, y se denominan datos abiertos .
Aquí hay una lista de algunos datos abiertos disponibles en línea. Puedes encontrar una lista más completa
y detalles de los datos abiertos disponibles en línea en el Apéndice B.
• DataHub ( http://datahub.io/dataset)
• Organización Mundial de la Salud ( http://www.who.int/research/en/)
• Data.gov ( http://data.gov )
• Portal de datos abiertos de la Unión Europea (http://open-data.europa.eu/

es / data / )
• Conjuntos de datos públicos de Amazon Web Service ( http://aws.amazon.com/

conjuntos de datos )
• Gráfico de Facebook (http://developers.facebook.com/docs/graph- api)
15
Página 34
• Healthdata.gov (http://www.healthdata.gov)
• Tendencias de Google ( http://www.google.com/trends/explore)
• Google Finance ( https://www.google.com/finance )
• Google Books Ngrams ( http://storage.googleapis.com/books/

ngrams / books / datasetsv2.html )
• Repositorio de aprendizaje automático ( http://archive.ics.uci.edu/ml/ )
Como una idea de las fuentes de datos abiertas disponibles en línea, puede mirar la nube LOD
diagrama (http://lod-cloud.net ), que muestra las conexiones del enlace de datos
entre varias fuentes de datos abiertas actualmente disponibles en la red (ver Figura 1-3).
Figura 1-3. Vinculando el diagrama de nube de datos abiertos 2014, por Max Schmachtenberg,
Christian Bizer, Anja Jentzsch y Richard Cyganiak. http://lod-cloud.net/
[Licencia CC-BY-SA]
dieciséis
Página 35
Python y análisis de datos

El principal argumento de este libro es desarrollar todos los conceptos de análisis de datos tratando
ellos en términos de Python. El lenguaje de programación Python se usa ampliamente en ciencia
círculos debido a su gran cantidad de bibliotecas que proporcionan un conjunto completo de herramientas para
análisis y manipulación de datos.
En comparación con otros lenguajes de programación utilizados generalmente para el análisis de datos, tales
como R y MATLAB, Python no solo proporciona una plataforma para procesar datos, sino que también
características que lo hacen único en comparación con otros lenguajes y aplicaciones especializadas.
El desarrollo de un número cada vez mayor de bibliotecas de apoyo, la implementación
de algoritmos de metodologías más innovadoras, y la capacidad de interactuar con otros
Los lenguajes de programación (C y Fortran) hacen que Python sea único entre su clase.
Además, Python no solo está especializado en el análisis de datos, sino que también tiene muchos
otras aplicaciones, como programación genérica, secuencias de comandos, interfaz con bases de datos,
y más recientemente desarrollo web, gracias a frameworks web como Django. Así es
posible desarrollar proyectos de análisis de datos que sean compatibles con el servidor web con
la posibilidad de integrarlo en la Web.
Entonces, para aquellos que quieran realizar análisis de datos, Python, con todos sus paquetes, es
considerada la mejor opción para el futuro previsible.
Conclusiones
En este capítulo, aprendió qué es el análisis de datos y, más específicamente, los diversos
procesos que lo componen. Además, ha comenzado a ver el papel que juegan los datos en la construcción
un modelo de predicción y cómo su selección cuidadosa está en la base de una cuidadosa y
análisis de datos preciso.
En el próximo capítulo, tomará esta visión de Python y las herramientas que proporciona para
realizar análisis de datos.
17
Página 36
CAPITULO 2
Introducción a
el mundo de Python
El lenguaje Python, y el mundo que lo rodea, está hecho por intérpretes, herramientas, editores,
bibliotecas, cuadernos, etc. Este mundo de Python se ha expandido enormemente en los últimos años, enriqueciendo
y adoptando formas que los desarrolladores que lo abordan por primera vez pueden encontrar
complicado y algo engañoso. Por lo tanto, si se está acercando a Python por primera vez
tiempo, es posible que se sienta perdido entre tantas opciones, especialmente sobre por dónde empezar.
Este capítulo le brinda una descripción general de todo el mundo de Python. Primero leerás un
descripción del lenguaje Python y sus características únicas. Verás a donde ir
start, qué es un intérprete y cómo empezar a escribir las primeras líneas de código en Python.
Luego se le presentan algunas formas nuevas y más avanzadas de escritura interactiva.
con respecto a los shells, como IPython e IPython Notebook.
Python: el lenguaje de programación

El lenguaje de programación Python fue creado por Guido Von Rossum en 1991 y
comenzó con un idioma anterior llamado ABC. Este lenguaje se puede caracterizar por una
serie de adjetivos:
• Interpretado
• Portátil
• Orientado a objetos
• Interactivo
• Interfaz
• Fuente abierta
• Fácil de entender y usar
19
© Fabio Nelli 2018
Página 37
CAPÍTULO 2 INTRODUCCIÓN AL MUNDO PYTHON
Python es un lenguaje de programación interpretado , es decir, está pseudocompilado. Una vez

escribe el código, necesita un intérprete para ejecutarlo. El intérprete es un programa que
instalado en cada máquina que tiene la tarea de interpretar el código fuente y ejecutar
eso. A diferencia de lenguajes como C, C ++ y Java, no hay tiempo de compilación con Python.
Python es un lenguaje de programación altamente portátil . La decisión de utilizar un
El intérprete como interfaz para leer y ejecutar código tiene una ventaja clave: la portabilidad.
De hecho, puede instalar un intérprete en cualquier plataforma (Linux, Windows y Mac)
y el código Python no cambiará. Debido a esto, Python se usa a menudo como el
lenguaje de programación para muchos dispositivos de formato pequeño, como Raspberry Pi y otros
microcontroladores.
Python es un lenguaje de programación orientado a objetos. De hecho, te permite especificar
clases de objetos e implementar su herencia. Pero a diferencia de C ++ y Java, no existen
constructores o destructores. Python también le permite implementar construcciones específicas en
su código para administrar excepciones. Sin embargo, la estructura del lenguaje es tan
flexible que le permite programar con enfoques alternativos con respecto a la
uno orientado a objetos. Por ejemplo, puede utilizar enfoques funcionales o vectoriales.
Python es un lenguaje de programación interactivo . Gracias al hecho de que Python usa
un intérprete a ejecutar, este lenguaje puede asumir aspectos muy diferentes según
en el contexto en el que se utiliza. De hecho, puede escribir código compuesto de muchas líneas,
similar a lo que podría hacer en lenguajes como C ++ o Java, y luego iniciar el programa,
o puede ingresar la línea de comando a la vez y ejecutarla, obteniendo inmediatamente el
resultados del comando. Luego, dependiendo de los resultados, puede decidir qué comando
para ejecutar a continuación. Esta forma altamente interactiva de ejecutar código hace que la computación Python
entorno similar a MATLAB. Esta característica de Python es una de las razones por las que es popular entre
la comunidad científica.
Python es un lenguaje de programación que puede interactuar . De hecho, esta programación
El lenguaje puede interactuar con el código escrito en otros lenguajes de programación como
como C / C ++ y FORTRAN. Incluso esta fue una elección ganadora. De hecho, gracias a este aspecto,
Python puede compensar lo que quizás sea su único punto débil, la velocidad de ejecución.
La naturaleza de Python, como lenguaje de programación altamente dinámico, a veces puede conducir
a la ejecución de programas hasta 100 veces más lenta que los correspondientes programas estáticos
compilado con otros lenguajes. Por tanto, la solución a este tipo de problema de rendimiento es
para conectar Python con el código compilado de otros lenguajes usándolo como si fuera
su propio.
20
Página 38
Python es un lenguaje de programación de código abierto . CPython, que es el

implementación de referencia del lenguaje Python, es completamente gratis y abierto
fuente. Además, cada módulo o biblioteca de la red es de código abierto y su
El código está disponible en línea. Cada mes, una extensa comunidad de desarrolladores incluye
mejoras para hacer que este lenguaje y todas sus bibliotecas sean aún más ricos y eficientes.
CPython es administrado por la organización sin fines de lucro Python Software Foundation, que fue creada
en 2001 y se ha dado a sí mismo la tarea de promover, proteger y promover Python
lenguaje de programación.
Finalmente, Python es un lenguaje simple de usar y aprender. Este aspecto es quizás el más
importante, porque es el aspecto más directo al que se enfrenta un desarrollador, incluso un novato.
La alta intuición y la facilidad de lectura del código Python a menudo conduce a la "simpatía"
para este lenguaje de programación y, en consecuencia, es la elección de la mayoría de los recién llegados
a la programación. Sin embargo, su simplicidad no significa estrechez, ya que Python es un
lenguaje que se está extendiendo en todos los campos de la informática. Además, Python está haciendo todo
de esto tan simplemente, en comparación con los lenguajes de programación existentes como C ++, Java,
y FORTRAN, que por su naturaleza son muy complejos.
Python: el intérprete
Como se describe en las secciones anteriores, cada vez que ejecuta el comando python, el
Se inicia el intérprete de Python, caracterizado por un >>> indicador.
El intérprete de Python es simplemente un programa que lee e interpreta los comandos
pasado al indicador. Ha visto que el intérprete puede aceptar una sola
comando a la vez o archivos completos de código Python. Sin embargo, el enfoque por el cual
realiza esto es siempre el mismo.
Cada vez que presiona la tecla Enter, el intérprete comienza a escanear el código (ya sea
una fila o un archivo completo de código) token por token (llamado tokenización ). Estos tokens son
fragmentos de texto que el intérprete organiza en una estructura de árbol. El árbol obtenido es el
estructura lógica del programa, que luego se convierte a bytecode (.pyc o .pyo). los
la cadena de proceso termina con el código de bytes que será ejecutado por una máquina virtual Python
(PVM). Ver figura 2-1.
21
Página 39
Figura 2-1. Los pasos realizados por el intérprete de Python
Puede encontrar muy buena documentación sobre este proceso en https: //www.ics.uci.
edu / ~ pattis / ICS-31 / lectures / tokens.pdf.
El intérprete estándar de Python se informa como Cython, ya que fue escrito en C.
Hay otras áreas que se han desarrollado utilizando otros lenguajes de programación,
como Jython, desarrollado en Java; IronPython, desarrollado en C # (solo para Windows); y
PyPy, desarrollado íntegramente en Python.
Cython
El proyecto Cython se basa en la creación de un compilador que traduce el código Python en
C. Este código luego se ejecuta dentro de un entorno Cython en tiempo de ejecución. Este tipo de
El sistema de compilación ha hecho posible introducir la semántica de C en Python
código para hacerlo aún más eficiente. Este sistema ha llevado a la fusión de dos mundos
del lenguaje de programación con el nacimiento de Cython, que puede considerarse un nuevo
lenguaje de programación. Puede encontrar mucha documentación al respecto en línea; te aconsejo
para visitar http://docs.cython.org .
Jython
En paralelo a Cython, existe una versión totalmente construida y compilada en Java, llamada Jython . Eso
fue creado por Jim Hugunin en 1997 (http://www.jython.org). Jython es una implementación
del lenguaje de programación Python en Java; se caracteriza además por el uso de clases Java
en lugar de módulos de Python para implementar extensiones y paquetes de Python.
PyPy
El intérprete de PyPy es un compilador JIT (justo a tiempo) y convierte el código Python
directamente en el código de máquina en tiempo de ejecución. Esta elección se tomó para acelerar la ejecución de
Pitón. Sin embargo, esta elección ha llevado al uso de un subconjunto más pequeño de comandos de Python,
definido como RPython . Para obtener más información al respecto, consulte el sitio web oficial en
http://pypy.org.
22
Página 40
Python 2 y Python 3
La comunidad de Python todavía está en transición de intérpretes de la Serie 2 a la Serie 3.

De hecho, actualmente encontrará dos versiones de Python que se utilizan en paralelo (versión 2.7
y versión 3.6). Este tipo de ambigüedad puede crear confusión, especialmente en términos de
elegir qué versión usar y las diferencias entre estas dos versiones. Uno
La pregunta que seguramente debe estar haciendo es por qué la versión 2.x todavía se está lanzando si es
distribuido alrededor de una versión mucho más mejorada como 3.x.
Cuando Guido Van Rossum (el creador de Python) decidió aportar importantes
cambios en el lenguaje Python, pronto descubrió que estos cambios harían que el nuevo
versión incompatible con una gran cantidad de código existente. Por lo tanto, decidió comenzar con un nuevo
versión de Python llamada Python 3.0. Para superar el problema de incompatibilidad y
evitar crear grandes cantidades de código inutilizable, se decidió mantener una compatibilidad
versión, 2.7 para ser precisos.
Python 3.0 hizo su primera aparición en 2008, mientras que la versión 2.7 se lanzó en 2010
con la promesa de que no sería seguido por grandes lanzamientos, y en este momento el
la versión actual es 3.6.5 (2018).
En el libro nos referimos a la versión de Python 3.x; sin embargo, con algunas excepciones, hay
No debería haber ningún problema con la versión Python 2.7.x (la última versión es 2.7.14 y fue
lanzado en septiembre de 2017).
Instalación de Python
Para desarrollar programas en Python tienes que instalarlo en tu sistema operativo.
Las distribuciones de Linux y las máquinas MacOS X ya deberían tener una versión preinstalada
de Python. Si no es así, o si desea reemplazar esa versión por otra, puede
instalarlo. La instalación de Python difiere de un sistema operativo a otro;
sin embargo, es una operación bastante simple.
En los sistemas Linux Debian-Ubuntu, ejecute este comando
apt-get install python
En los sistemas Red Hat Fedora Linux que trabajan con paquetes rpm, ejecute este comando
yum instalar python
23
Página 41
Si está ejecutando Windows o MacOS X, puede ir al sitio oficial de Python

( http://www.python.org ) y descargue la versión que prefiera. Los paquetes en este
caso se instalan automáticamente.
Sin embargo, hoy en día existen distribuciones que proporcionan una serie de herramientas que hacen que el
administración e instalación de Python, todas las bibliotecas y aplicaciones asociadas más fáciles.
Le recomiendo encarecidamente que elija una de las distribuciones disponibles en línea.
Distribuciones de Python
Debido al éxito del lenguaje de programación Python, muchas herramientas de Python se han
desarrollado para cumplir con diversas funcionalidades a lo largo de los años. Hay tantos que es
prácticamente imposible gestionarlos todos manualmente.
En este sentido, muchas distribuciones de Python administran de manera eficiente cientos de Python
paquetes. De hecho, en lugar de descargar individualmente el intérprete, que incluye
solo las bibliotecas estándar, y luego necesita instalar individualmente todas las
bibliotecas, es mucho más fácil instalar una distribución de Python.
En el corazón de estas distribuciones están los administradores de paquetes, que no son más
que las aplicaciones que administran, instalan, actualizan, configuran y eliminan automáticamente
Paquetes de Python que forman parte de la distribución.
Su funcionalidad es muy útil, ya que el usuario simplemente realiza una solicitud en un
paquete particular (que podría ser una instalación, por ejemplo), y el paquete
gerente, generalmente a través de Internet, realiza la operación analizando los
versión, junto con todas las dependencias con cualquier otro paquete, y descargándolos si
no están presentes.
Anaconda
Anaconda es una distribución gratuita de paquetes de Python distribuidos por Continuum Analytics
( https://www.anaconda.com). Esta distribución es compatible con Linux, Windows y MacOS
X sistemas operativos. Anaconda, además de proporcionar los últimos paquetes lanzados
en el mundo de Python, viene con la mayoría de las herramientas que necesita para configurar un Python
entorno de desarrollo.
De hecho, cuando instala la distribución Anaconda en su sistema, puede usar
muchas herramientas y aplicaciones descritas en este capítulo, sin preocuparse por tener que
instalar y administrar cada uno por separado. La distribución básica incluye Spyder como IDE,
IPython QtConsole y Notebook.
24
Página 42
La gestión de toda la distribución de Anaconda se realiza mediante una aplicación

llamado conda . Este es el administrador de paquetes y el administrador de entorno del
Distribución de Anaconda y maneja todos los paquetes y sus versiones.
conda install <nombre del paquete>
Uno de los aspectos más interesantes de esta distribución es la capacidad de gestionar

múltiples entornos de desarrollo, cada uno con su propia versión de Python. En efecto,
cuando instala Anaconda, la versión 2.7 de Python se instala de forma predeterminada. Todo instalado
los paquetes se referirán a esa versión. Esto no es un problema, porque Anaconda ofrece
la posibilidad de trabajar de forma simultánea e independiente con otras versiones de Python
creando un nuevo entorno. Puede crear, por ejemplo, un entorno basado en
Python 3.6.
conda crear -n py36 python = 3.6 anaconda
Esto generará un nuevo entorno Anaconda con todos los paquetes relacionados con el
Versión de Python 3.6. Esta instalación no afectará de ninguna manera el entorno construido con
Python 2.7. Una vez instalado, puede activar el nuevo entorno ingresando al
siguiente comando.
fuente activar py36
En Windows, use esto en su lugar:
activar py36
C: \ Users \ Fabio> activar py36

(py36) C: \ Usuarios \ Fabio>
Puede crear tantas versiones de Python como desee; solo necesitas cambiar el
parámetro pasado con la opción python en el comando conda create. Cuando quieres
para volver a trabajar con la versión original de Python, debes usar el siguiente comando:
fuente desactivar
En Windows, use esto:
(py36) C: \ Users \ Fabio> desactivar

Desactivando el entorno "py36" ...
C: \ Usuarios \ Fabio>
25
Página 43
Canopy entusiasta
Existe otra distribución muy similar a Anaconda y es la distribución Canopy
proporcionado por Enthought, una empresa fundada en 2001 y conocida por el proyecto SciPy
( https://www.enthought.com/products/canopy/ ). Esta distribución es compatible con Linux,
Sistemas Windows y MacOS X y consta de una gran cantidad de paquetes, herramientas,
y aplicaciones administradas por un administrador de paquetes. El administrador de paquetes de Canopy, como
opuesto a conda, es gráfico.
Desafortunadamente, solo la versión básica de esta distribución, llamada Canopy Express, es
gratis; además del paquete normalmente distribuido, también incluye IPython y un IDE
de Canopy que tiene una característica especial que no está presente en otros IDE. Tiene incrustado el
IPython para utilizar este entorno como una ventana para probar y depurar código.
Python (x, y)
Python (x, y) es una distribución gratuita que solo funciona en Windows y se puede descargar desde
http://code.google.com/p/pythonxy/. Esta distribución utiliza Spyder como IDE.
Usando Python
Python es rico pero simple y muy flexible. Permite la expansión de tu desarrollo
actividades en muchas áreas de trabajo (análisis de datos, científico, interfaces gráficas, etc.).
Precisamente por esta razón, Python se puede utilizar en muchos contextos diferentes, a menudo de acuerdo con
al gusto y habilidad del desarrollador. Esta sección presenta los diversos enfoques
a usar Python en el curso del libro. Según los diversos temas tratados en
diferentes capítulos, estos diferentes enfoques se utilizarán específicamente, ya que serán
más adecuado para la tarea en cuestión.
Shell de Python
La forma más fácil de acercarse al mundo de Python es abrir una sesión en el shell de Python,
que es una terminal que ejecuta una línea de comando. De hecho, puede ingresar un comando en
una vez y pruebe su funcionamiento inmediatamente. Este modo aclara la naturaleza de la
intérprete que subyace a Python. De hecho, el intérprete puede leer un comando en un
tiempo, manteniendo el estado de las variables especificadas en las líneas anteriores, un comportamiento similar
a la de MATLAB y otros programas de cálculo.
26
Página 44
Este enfoque es útil cuando se acerca a Python por primera vez. Puedes probar
comandos uno a la vez sin tener que escribir, editar y ejecutar un programa completo, que
podría estar compuesto por muchas líneas de código.
Este modo también es bueno para probar y depurar el código Python una línea a la vez, o
simplemente para hacer cálculos. Para iniciar una sesión en el terminal, simplemente escriba esto en el
línea de comando:
>>> pitón
Python 3.6.3 (predeterminado, 15 de octubre de 2017, 03:27:45) [MSC v.1900 64 bit (AMD64)]
en win32
Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.
>>>
Ahora el shell de Python está activo y el intérprete está listo para recibir comandos en
Pitón. Comience ingresando los comandos más simples, pero un clásico para comenzar
programación.
>>> print ("¡Hola mundo!")
Hola Mundo!
Ejecutar un programa completo

La mejor manera de familiarizarse con Python es escribir un programa completo y luego ejecutar
desde la terminal. Primero escriba un programa usando un editor de texto simple. Por ejemplo tu
puede usar el código que se muestra en el listado 2-1 y guárdelo como MyFirstProgram.py.
Listado 2-1. MyFirstProgram.py
myname = input ("¿Cómo te llamas?")

print ("Hola" + myname + ", me alegra decir: ¡Hola mundo!")
Ahora ha escrito su primer programa en Python y puede ejecutarlo directamente desde el

línea de comando llamando al comando python y luego el nombre del archivo que contiene
el código del programa.
python MyFirstProgram.py
¿Cuál es tu nombre? Fabio Nelli
Hola Fabio Nelli, me alegra decirte: ¡Hola mundo!
27
Página 45
Implementar el código usando un IDE

Un enfoque más completo que los anteriores es el uso de un IDE (un
Entorno de desarrollo integrado ). Estos editores proporcionan un entorno de trabajo en
que desarrollar su código Python. Son ricas en herramientas que hacen la vida de los desarrolladores
más fácil, especialmente al depurar. En las siguientes secciones, verá en detalle lo que
Los IDE están disponibles actualmente.
Interactuar con Python

El último enfoque, y en mi opinión, quizás el más innovador, es el interactivo
uno. De hecho, además de los tres enfoques anteriores, este enfoque le proporciona la
oportunidad de interactuar directamente con el código Python.
En este sentido, el mundo de Python se ha enriquecido enormemente con la introducción
de IPython . IPython es una herramienta muy poderosa, diseñada específicamente para satisfacer las necesidades
de interactuar entre el intérprete de Python y el desarrollador, que bajo este
El enfoque asume el papel de analista, ingeniero o investigador. IPython y sus características son
explicado con más detalle en una sección posterior.
Escribir código Python

En la sección anterior viste cómo escribir un programa simple en el que la cadena
Se imprimió "Hola mundo". Ahora en esta sección obtendrá una breve descripción de
conceptos básicos del lenguaje Python.
Esta sección no está destinada a enseñarle a programar en Python ni a ilustrar la sintaxis
reglas del lenguaje de programación, pero solo para darle una descripción general rápida de algunos
principios de Python necesarios para continuar con los temas tratados en este libro.
Si ya conoce el lenguaje Python, puede omitir con seguridad esta introducción
sección. En cambio, si no está familiarizado con la programación y le resulta difícil
para comprender los temas, le recomiendo que visite la documentación en línea,
tutoriales y cursos de diversa índole.
28
Página 46
Hacer cálculos
Ya ha visto que la función print () es útil para imprimir casi cualquier cosa.
Python, además de ser una herramienta de impresión, también es una gran calculadora. Iniciar una sesión en
el shell de Python y comenzar a realizar estas operaciones matemáticas:
>>> 1 + 2
3
>>> (1.045 * 3) / 4
0,78375
>>> 4 ** 2
dieciséis
>>> ((4 + 5j) * (2 + 3j))
(-7 + 22j)
>>> 4 <(2 * 3)
Cierto
Python puede calcular muchos tipos de datos, incluidos números complejos y condiciones
con valores booleanos. Como puede ver en estos cálculos, el intérprete de Python
devuelve directamente el resultado de los cálculos sin la necesidad de utilizar print ()
función. Lo mismo se aplica a los valores contenidos en variables. Es suficiente llamar al
variable para ver su contenido.
>>> a = 12 * 3.4
>>> un
40,8
Importar nuevas bibliotecas y funciones

Viste que Python se caracteriza por la capacidad de ampliar su funcionalidad importando
numerosos paquetes y módulos. Para importar un módulo en su totalidad, debe utilizar el
comando de importación.
>>> importar matemáticas
29
Página 47
De esta forma, todas las funciones contenidas en el paquete matemático están disponibles en su
Sesión de Python para que pueda llamarlos directamente. Por lo tanto, ha ampliado el conjunto estándar de
funciones disponibles cuando inicia una sesión de Python. Estas funciones se llaman con la
siguiente expresión.
nombre_biblioteca.nombre_función ()
Por ejemplo, ahora puede calcular el seno del valor contenido en la variable a.
>>> matemáticas.pecado (a)
Como puede ver, la función se llama junto con el nombre de la biblioteca. Algunas veces
puede encontrar la siguiente expresión para declarar una importación.
>>> de importación matemática *
Incluso si esto funciona correctamente, se debe evitar por buenas prácticas. De hecho, escribir un
importar de esta manera implica la importación de todas las funciones sin necesariamente definir
la biblioteca a la que pertenecen.
>>> pecado (a)

0.040693257349864856
Esta forma de importación puede dar lugar a errores muy grandes, especialmente si las bibliotecas importadas
son numerosos. De hecho, no es improbable que diferentes bibliotecas tengan funciones con la
mismo nombre, e importar todos estos daría como resultado una anulación de todas las funciones con
el mismo nombre importado previamente. Por tanto, el comportamiento del programa podría
generar numerosos errores o peor, comportamiento anormal.
En realidad, esta forma de importar se usa generalmente solo para un número limitado de funciones,
es decir, funciones que son estrictamente necesarias para el funcionamiento del programa, por lo que
evitando la importación de una biblioteca completa cuando es completamente innecesaria.
>>> de la importación matemática pecado
Estructura de datos
En los ejemplos anteriores viste cómo usar variables simples que contienen un solo valor.
Python proporciona una serie de estructuras de datos extremadamente útiles. Estas estructuras de datos son
capaz de contener muchos datos simultáneamente y, a veces, incluso datos de diferentes tipos.
30
Página 48
Las diversas estructuras de datos proporcionadas se definen de manera diferente dependiendo de cómo se
los datos están estructurados internamente.
• Lista
• Establecer
• Cuerdas
• Tuplas
• Diccionario
• Deque
• Montón
Esta es solo una pequeña parte de todas las estructuras de datos que se pueden crear con Python.
Entre todas estas estructuras de datos, las más utilizadas son los diccionarios y las listas .
El diccionario de tipos , también definido como dictados , es una estructura de datos en la que cada
El valor está asociado con una etiqueta particular, llamada clave . Los datos recopilados en un diccionario.
no tienen orden interno, pero son solo definiciones de pares clave / valor.
>>> dict = {'nombre': 'William', 'edad': 25, 'ciudad': 'Londres'}
Si desea acceder a un valor específico dentro del diccionario, debe indicar el

nombre de la clave asociada.
>>> dict ["nombre"]

'Guillermo'
Si desea iterar los pares de valores en un diccionario, debe usar el for-in

construir. Esto es posible mediante el uso de la función items ().
>>> para clave, valor en dict.items ():

... imprimir (clave, valor)
...
nombre William
25 años
ciudad londres
31
Página 49
La lista de tipos es una estructura de datos que contiene varios objetos en un orden preciso
para formar una secuencia a la que se pueden agregar y eliminar elementos. Cada artículo está marcado
con un número correspondiente al orden de la secuencia, llamado índice .
>>> lista = [1,2,3,4]

>>> lista
[1, 2, 3, 4]
Si desea acceder a los elementos individuales, es suficiente especificar el índice en

corchetes (el primer elemento de la lista tiene 0 como índice), mientras que si saca una parte
de la lista (o una secuencia), es suficiente especificar el rango con los índices i y j
correspondiente a los extremos de la porción.
>>> lista [2]

3
>>> lista [1: 3]
[2, 3]
Si está utilizando índices negativos en su lugar, esto significa que está considerando el último elemento
en la lista y pasando gradualmente al primero.
>>> lista [-1]

4
Para hacer un escaneo de los elementos de una lista, puede usar la construcción for-in.
>>> elementos = [1,2,3,4,5]

>>> para artículo en artículos:
... imprimir (elemento + 1)
...
2
3
4
5
6
32
Página 50
Programación funcional
El bucle for-in que se muestra en el ejemplo anterior es muy similar a los bucles que se encuentran en otros
lenguajes de programación. Pero en realidad, si quieres ser un desarrollador de "Python",
debe evitar el uso de bucles explícitos. Python ofrece enfoques alternativos, especificando
técnicas de programación como la programación funcional (orientada a expresiones
programación).
Las herramientas que proporciona Python para desarrollar la programación funcional comprenden una serie
de funciones:
• mapa (función, lista)

• filtro (función, lista)
• reducir (función, lista)
• lambda
• comprensión de listas
El bucle for que acaba de ver tiene un propósito específico, que es aplicar un
operación en cada elemento y luego de alguna manera recopilar el resultado. Esto lo puede hacer el
función map ().
>>> elementos = [1,2,3,4,5]

>>> def inc (x): devuelve x + 1
...
>>> lista (mapa (inc, elementos))
[2, 3, 4, 5, 6]
En el ejemplo anterior, primero define la función que realiza la operación en

cada elemento y luego lo pasa como el primer argumento a map (). Python permite
debe definir la función directamente dentro del primer argumento usando lambda como función.
Esto reduce en gran medida el código y compacta la construcción anterior en una sola línea de
código.
>>> lista (mapa ((lambda x: x + 1), elementos))

[2, 3, 4, 5, 6]
33
Página 51
Otras dos funciones que funcionan de manera similar son filter () y reduce (). los
La función filter () extrae los elementos de la lista para los que la función devuelve True.
La función reduce () en cambio considera todos los elementos de la lista para producir un solo
resultado. Para usar reduce (), debe importar el módulo functools.
>>> lista (filtro ((lambda x: x <4), elementos))

[1, 2, 3]
>>> de functools importar reducir
>>> reducir ((lambda x, y: x / y), elementos)
0.008333333333333333
Ambas funciones implementan otros tipos utilizando el bucle for. Ellos reemplazan
estos ciclos y su funcionalidad, que pueden expresarse alternativamente con simples
funciones. Eso es lo que constituye la programación funcional.
El concepto final de la programación funcional es la comprensión de listas. Este concepto es
utilizado para construir listas de una manera muy natural y simple, refiriéndose a ellas de una manera similar
a cómo los matemáticos describen los conjuntos de datos. Los valores en la secuencia están definidos
a través de una función u operación particular.
>>> S = [x ** 2 para x en el rango (5)]

>>> S
[0, 1, 4, 9, 16]
Sangría
Una peculiaridad para quienes proceden de otros lenguajes de programación es el papel que
la sangría juega. Mientras que solía administrar la muesca por motivos puramente estéticos
razones, haciendo el código algo más legible, en Python la sangría asume una
papel integral en la implementación del código, dividiéndolo en bloques lógicos. De hecho,
mientras que en Java, C y C ++, cada línea de código está separada de la siguiente por un punto y coma (;),
en Python no debe especificar ningún símbolo que los separe, incluidas las llaves para
indicar un bloque lógico.
Estos roles en Python se manejan mediante sangría; es decir, dependiendo de la
punto de partida de la línea de código, el intérprete determina si pertenece a una lógica
bloquear o no.
34
Página 52
>>> a = 4
>>> si a> 3:
... si a <5:
... print ("tengo cuatro")
... más:
... print ("Soy un pequeño número")
...
yo tengo cuatro
>>> si a> 3:
... si a <5:
... print ("Tengo cuatro")
... más:
... print ("Soy un gran número")
...
yo tengo cuatro
En este ejemplo, puede ver que, dependiendo de cómo esté el comando else
sangrado, las condiciones asumen dos significados diferentes (especificados por mí en las cadenas
sí mismos).
IPython
IPython es un desarrollo adicional de Python que incluye una serie de herramientas:
• El shell IPython, que es un potente shell interactivo que da como resultado un

Terminal Python muy mejorado.
• Una QtConsole, que es un híbrido entre un shell y una GUI, lo que permite
que muestre gráficos dentro de la consola en lugar de por separado
ventanas.
• IPython Notebook, que es una interfaz web que le permite

para mezclar texto, código ejecutable, gráficos y fórmulas en un solo
representación.
35
Página 53
Shell de IPython
Este shell aparentemente se parece a una sesión de Python que se ejecuta desde una línea de comandos, pero en realidad,
Proporciona muchas otras características que hacen que esta carcasa sea mucho más potente y versátil.
que el clásico. Para iniciar este shell, simplemente escriba ipython en la línea de comando.
> ipython
Python 3.6.3 (predeterminado, 15 de octubre de 2017, 3:27:45) [MSC v.1900 64bit (AMD64)]
Escriba "derechos de autor", "créditos" o "licencia" para obtener más información.
IPython 6.1.0: un Python interactivo mejorado. Tipo '?' por ayuda
En 1]:
Como puede ver, aparece un mensaje en particular con el valor In [1]. Esto significa que
es la primera línea de entrada. De hecho, IPython ofrece un sistema de indicaciones numeradas (indexadas)
con almacenamiento en caché de entrada y salida.
En [1]: print ("¡Hola mundo!")

Hola Mundo!
En [2]: 3/2
Fuera [2]: 1,5
En [3]: 5.0 / 2
Fuera [3]: 2.5
En [4]:
Lo mismo se aplica a los valores de salida que se indican con los valores Out [1],
Fuera [2], y así sucesivamente. IPython guarda todas las entradas que ingresa almacenándolas como variables.
De hecho, todas las entradas ingresadas se incluyeron como campos en una lista llamada In.
En [4]: En
Fuera [4]: [", 'imprimir" ¡Hola mundo! "', '3/2', '5.0 / 2', 'In']
Los índices de los elementos de la lista son los valores que aparecen en cada solicitud. Así, para
acceder a una sola línea de entrada, simplemente puede especificar ese valor.
En [5]: en [3]
Fuera [5]: '5.0 / 2'
36
Página 54
Para la salida, puede aplicar el mismo concepto.
En [6]: Fuera
Fuera [6]:
{2: 1,
3: 2,5,
4: ['',
u'print "¡Hola mundo!" ',
u'3 / 2 ',
u'5.0 / 2 ',
u'_i2 ',
u'In ',
u'En [3] ',
u'Out '],
5: u'5.0 / 2 '}
El proyecto Jupyter
IPython es un proyecto que ha crecido enormemente en los últimos tiempos, y con la
lanzamiento de IPython 3.0, todo se está moviendo hacia un nuevo proyecto llamado Jupyter
( https://jupyter.org) —Ver Figura 2-2.
Figura 2-2. El logotipo del proyecto Jupyter
37
Página 55
IPython seguirá existiendo como un shell de Python y como un núcleo de Jupyter, pero el
Notebook y los otros componentes independientes del lenguaje que pertenecen a IPython
El proyecto se moverá para formar el nuevo proyecto Jupyter.
Jupyter QtConsole
Para ejecutar esta aplicación desde la línea de comando, debe ingresar lo siguiente
mando:
ipython qtconsole
jupyter qtconsole
La aplicación consta de una GUI que tiene toda la funcionalidad presente en el IPython
cáscara. Ver figura 2-3.
Figura 2-3. El IPython QtConsole
38
Página 56
Cuaderno Jupyter
Jupyter Notebook es la última evolución de este entorno interactivo (consulte la Figura 2-4 ).
De hecho, con Jupyter Notebook, puede combinar código ejecutable, texto, fórmulas, imágenes,
y animaciones en un solo documento web. Esto es útil para muchos propósitos, como
presentaciones, tutoriales, depuración, etc.
Figura 2-4. La página web que muestra Jupyter Notebook
PyPI: el índice de paquetes de Python

El índice de paquetes de Python (PyPI) es un repositorio de software que contiene todo el software
necesario para programar en Python, por ejemplo, todos los paquetes de Python que pertenecen a
otras bibliotecas de Python. El repositorio de contenido es gestionado directamente por los desarrolladores de
paquetes individuales que se ocupan de actualizar el repositorio con las últimas versiones de
sus bibliotecas publicadas. Para obtener una lista de los paquetes contenidos en el repositorio, vaya a la
página oficial de PyPI en https://pypi.python.org/pypi.
En cuanto a la administración de estos paquetes, puede utilizar la aplicación pip,
que es el administrador de paquetes de PyPI.
Al iniciarlo desde la línea de comandos, puede administrar todos los paquetes y
decidir individualmente si un paquete debe instalarse, actualizarse o eliminarse. Pepita
comprobará si el paquete ya está instalado, o si necesita actualizarse, para controlar
dependencias y evaluar si son necesarios otros paquetes. Además,
gestiona los procesos de descarga e instalación.
39
Página 57
$ pip install <<nombre_paquete>>

$ pip búsqueda <<nombre_paquete>>
$ pip show <<nombre_paquete>>
$ pip unistall <<nombre_paquete>>
Con respecto a la instalación, si tiene Python 3.4+ (lanzado en marzo de 2014) y

Python 2.7.9+ (lanzado en diciembre de 2014) ya está instalado en su sistema, el pip
El software ya está incluido en estas versiones de Python. Sin embargo, si todavía está usando un
versión anterior de Python, necesita instalar pip en su sistema. La instalación de pip on
su sistema depende del sistema operativo en el que está trabajando.
En Linux Debian-Ubuntu, use este comando:
$ sudo apt-get install python-pip
En Linux Fedora, use este comando:
$ sudo yum instalar python-pip
En Windows, visite https://pip.pypa.io/en/latest/installing/ y descargar

get-pip.py en su PC. Una vez descargado el archivo, ejecute este comando:
python get-pip.py
De esta forma, instalará el administrador de paquetes. Recuerde agregar C: \ Python3.X \

Scripts para la variable de entorno PATH.
Los IDE para Python

Aunque la mayoría de los desarrolladores de Python están acostumbrados a implementar su código directamente
desde el shell (Python o IPython), algunos IDE (entornos de desarrollo interactivos)
también están disponibles. De hecho, además de un editor de texto, estos editores gráficos también proporcionan
una serie de herramientas que resultan muy útiles durante la redacción del código. Por ejemplo, el
Autocompletar el código, ver la documentación asociada con los comandos,
depuración y puntos de interrupción son solo algunas de las herramientas que este tipo de aplicación puede
proporcionar.
40
Página 58
Spyder
Spyder (Scientific Python Development Environment) es un IDE que tiene características similares a
el IDE de MATLAB (ver Figura 2-5 ). El editor de texto está enriquecido con resaltado de sintaxis y
herramientas de análisis de código. Además, puede integrar widgets listos para usar en sus aplicaciones gráficas.
Figura 2-5. El IDE de Spyder
Eclipse (pyDev)
Aquellos de ustedes que se han desarrollado en otros lenguajes de programación ciertamente saben
Eclipse, un IDE universal desarrollado completamente en Java (por lo tanto, requiere la instalación de Java
en su PC) que proporciona un entorno de desarrollo para muchos programas
idiomas (consulte la Figura 2-6 ). También hay una versión de Eclipse para desarrollar en Python,
gracias a la instalación de un complemento adicional llamado pyDev .
41
Página 59
Figura 2-6. El IDE de Eclipse
Sublime
Este editor de texto es uno de los entornos preferidos por los programadores de Python (consulte
Figura 2-7). De hecho, hay varios complementos disponibles para esta aplicación que hacen
Implementación de Python fácil y agradable.
42
Página 60
Figura 2-7. El IDE sublime
Liclipse
Liclipse, al igual que Spyder, es un entorno de desarrollo diseñado específicamente para
el lenguaje Python (ver Figura 2-8). Es muy similar al IDE de Eclipse pero es completamente
adaptado para un uso específico en Python, sin necesidad de instalar complementos como PyDev. Entonces es
la instalación y la configuración son mucho más simples que Eclipse.
43
Página 61
Figura 2-8. El IDE Liclipse
NinjaIDE
NinjaIDE (NinjaIDE es "No es simplemente otro IDE"), que se caracteriza por un nombre que es
un acrónimo recursivo, es un IDE especializado para el lenguaje Python (ver Figura 2-9). Sus
una aplicación muy reciente en la que se centran los esfuerzos de muchos desarrolladores. Ya
muy prometedor, es probable que en los próximos años, este IDE sea una fuente de muchos
sorpresas.
44
Página 62
Figura 2-9. El IDE Ninja
IDE de Komodo
Komodo es un IDE muy poderoso lleno de herramientas que lo convierten en un completo y profesional
entorno de desarrollo (consulte la Figura 2-10 ). Software pagado y escrito en C ++, el
El entorno de desarrollo de Komodo se puede adaptar a muchos lenguajes de programación,
incluido Python.
45
Página 63
Figura 2-10. El IDE de Komodo
Ciencia
SciPy (pronunciado "sigh pie") es un conjunto de bibliotecas de Python de código abierto especializadas para
computación científica. Muchas de estas bibliotecas son protagonistas de muchos capítulos de la
libro, dado que su conocimiento es fundamental para el análisis de datos. Juntos constituyen un
conjunto de herramientas para calcular y visualizar datos. Tiene poco que envidiar a otros especializados
entornos de cálculo y análisis de datos (como R o MATLAB). Entre la
bibliotecas que forman parte del grupo SciPy, hay tres en particular que se discuten
en los siguientes capítulos:
• NumPy
• matplotlib
• Pandas
46
Página 64
NumPy
Esta biblioteca, cuyo nombre significa Python numérico, constituye el núcleo de muchas otras
Bibliotecas de Python que se han originado a partir de él. De hecho, NumPy es la biblioteca básica
para la computación científica en Python, ya que proporciona estructuras de datos y alto rendimiento
funciones que el paquete básico de Python no puede proporcionar. De hecho, como verás
más adelante en el libro, NumPy define una estructura de datos específica que es una matriz N- dimensional
definido como ndarray .
El conocimiento de esta biblioteca es esencial en términos de cálculos numéricos ya que su
el uso correcto puede influir en gran medida en el rendimiento de sus cálculos. En todo
el libro, esta biblioteca es casi omnipresente debido a sus características únicas, por lo que un
todo el capítulo está dedicado a ella (Capítulo 3).
Este paquete proporciona algunas características que se agregarán al Python estándar:
• Ndarray : una matriz multidimensional mucho más rápida y eficiente

que los proporcionados por el paquete básico de Python.
• Cálculo por elementos : un conjunto de funciones para realizar este tipo

de cálculo con matrices y operaciones matemáticas entre
matrices.
• conjuntos de datos de lectura-escritura : Un conjunto de herramientas para la lectura y escritura de datos

almacenados en el disco duro.
• Integración con otros lenguajes como C, C ++ y FORTRAN : A

conjunto de herramientas para integrar código desarrollado con estos programas
Idiomas
Pandas
Este paquete proporciona estructuras de datos complejas y funciones diseñadas específicamente para
hacer que el trabajo en ellos sea fácil, rápido y eficaz. Este paquete es el núcleo del análisis de datos
en Python. Por tanto, el estudio y aplicación de este paquete es el principal objetivo en el que
trabajará a lo largo del libro (especialmente en los capítulos 4 , 5 y6 ). Conocimiento de su
cada detalle, especialmente cuando se aplica al análisis de datos, es un objetivo fundamental de
este libro.
El concepto fundamental de este paquete es el DataFrame , un bidimensional
estructura de datos tabular con etiquetas de fila y columna.
47
Página 65
Pandas aplica las propiedades de alto rendimiento de la biblioteca NumPy al

manipulación de datos en hojas de cálculo o en bases de datos relacionales (bases de datos SQL). De hecho,
mediante el uso de una indexación sofisticada, será fácil realizar muchas operaciones en este tipo
de estructura de datos, como remodelación, segmentación, agregaciones y selección de subconjuntos.
matplotlib
Este paquete es la biblioteca de Python que es actualmente más popular para producir gráficos y
otras visualizaciones de datos en 2D. Dado que el análisis de datos requiere herramientas de visualización, esta es la
biblioteca que mejor se adapte a este propósito. En el capítulo7, aprenderá sobre esta rica biblioteca en detalle
así sabrás representar los resultados de tu análisis de la mejor manera.
Conclusiones
Durante el transcurso de este capítulo, todos los aspectos fundamentales que caracterizan a Python
El mundo ha sido ilustrado. Los conceptos básicos del lenguaje de programación Python
se presentaron, con breves ejemplos que explican sus aspectos innovadores y cómo se
en comparación con otros lenguajes de programación. Además, diferentes formas de utilizar
Se presentaron Python en varios niveles. Primero vio cómo usar un comando simple:
intérprete de línea, luego se mostró un conjunto de interfaces gráficas de usuario simples hasta que obtuviste
a entornos de desarrollo complejos, conocidos como IDE, como Spyder, Liclipse y
NinjaIDE.
Incluso se presentó el proyecto altamente innovador Jupyter (IPython), mostrándole
cómo puede desarrollar código Python de forma interactiva, en particular con Jupyter Notebook.
Además, se destacó la naturaleza modular de Python con la capacidad de expandirse
el conjunto básico de funciones estándar proporcionadas por las bibliotecas externas de Python. A este respecto,
el repositorio en línea de PyPI se mostró junto con otras distribuciones de Python, como
Anaconda y Canopy Enthought.
En el capítulo siguiente, se ocupará de la primera biblioteca que es la base de todas las
cálculos en Python: NumPy. Aprende sobre ndarray, una estructura de datos que
es la base de las estructuras de datos más complejas utilizadas en el análisis de datos en los siguientes
capítulos.
48
Página 66
CAPÍTULO 3
La biblioteca de NumPy
NumPy es un paquete básico para computación científica con Python y especialmente para datos
análisis. De hecho, esta biblioteca es la base de una gran cantidad de conocimientos matemáticos y científicos.
Paquetes de Python, y entre ellos, como verá más adelante en el libro, los pandas
biblioteca. Esta biblioteca, especializada para el análisis de datos, está completamente desarrollada utilizando los conceptos
introducido por NumPy. De hecho, las herramientas integradas proporcionadas por la biblioteca estándar de Python
podría ser demasiado simple o inadecuado para la mayoría de los cálculos del análisis de datos.
Tener conocimiento de la biblioteca NumPy es importante para poder usar todos
paquetes científicos de Python y, en particular, para usar y comprender la biblioteca de pandas.
La biblioteca de pandas es el tema principal de los siguientes capítulos.
Si ya está familiarizado con esta biblioteca, puede pasar directamente a la siguiente
capítulo; de lo contrario, puede ver este capítulo como una forma de revisar los conceptos básicos o de
Vuelva a familiarizarse con él ejecutando los ejemplos de este capítulo.
NumPy: Un poco de historia

En los albores del lenguaje Python, los desarrolladores necesitaban realizar operaciones numéricas
cálculos, especialmente cuando este lenguaje estaba siendo utilizado por la comunidad científica.
El primer intento fue Numeric, desarrollado por Jim Hugunin en 1995, que fue
seguido de un paquete alternativo llamado Numarray. Ambos paquetes estaban especializados para
el cálculo de matrices, y cada uno tenía fortalezas dependiendo de en qué caso se
usado. Por lo tanto, se usaron de manera diferente según las circunstancias. Esta ambigüedad
condujo entonces a la idea de unificar los dos paquetes. Travis Oliphant comenzó a desarrollar el
Biblioteca NumPy para este propósito. Su primer lanzamiento (v 1.0) ocurrió en 2006.
A partir de ese momento, NumPy demostró ser la biblioteca de extensión de Python para
computación científica, y actualmente es el paquete más utilizado para el cálculo
de matrices multidimensionales y matrices grandes. Además, el paquete viene con una gama
de funciones que le permiten realizar operaciones en matrices de una manera altamente eficiente y
realizar cálculos matemáticos de alto nivel.
49
© Fabio Nelli 2018
Página 67
CAPÍTULO 3 LA BIBLIOTECA NUMPY
Actualmente, NumPy es de código abierto y tiene licencia BSD. Hay muchos

contribuyentes que han ampliado el potencial de esta biblioteca.
La instalación de NumPy
Generalmente, este módulo está presente como un paquete básico en la mayoría de las distribuciones de Python;
sin embargo, si no es así, puede instalarlo más tarde.
En Linux (Ubuntu y Debian), use:
sudo apt-get install python-numpy
En Linux (Fedora)
sudo yum instalar numpy scipy
En Windows con Anaconda, use:
conda instalar numpy
Una vez que NumPy está instalado en su distribución, para importar el módulo NumPy dentro
su sesión de Python, escriba lo siguiente:
>>> importar numpy como np
Ndarray: el corazón de la biblioteca

La biblioteca NumPy se basa en un objeto principal: ndarray (que significa
Matriz N-dimensional). Este objeto es una matriz homogénea multidimensional con un
número predeterminado de elementos: homogéneo porque prácticamente todos los elementos que contiene son
del mismo tipo y del mismo tamaño. De hecho, el tipo de datos lo especifica otro NumPy
objeto llamado dtype (tipo de datos); cada ndarray está asociado con un solo tipo de dtype.
El número de dimensiones y elementos de una matriz se define por su forma , una tupla
de N- enteros positivos que especifica el tamaño de cada dimensión. Las dimensiones son
definido como ejes y el número de ejes como rango .
Además, otra peculiaridad de las matrices NumPy es que su tamaño es fijo, es decir, una vez
define su tamaño en el momento de la creación, permanece sin cambios. Este comportamiento es
diferente de las listas de Python, que pueden aumentar o reducir su tamaño.
50
Página 68
Capítulo 3 la biblioteca Numpy
La forma más fácil de definir un nuevo ndarray es usar la función array (), pasando un
Lista de Python que contiene los elementos que se incluirán en ella como argumento.
>>> a = np.array ([1, 2, 3])

>>> un
matriz ([1, 2, 3])
Puede comprobar fácilmente que un objeto recién creado es un ndarray pasando el nuevo
variable a la función type ().
>>> tipo (a)

<escriba 'numpy.ndarray'>
Para conocer el dtype asociado al ndarray recién creado, debe usar

el atributo dtype.
Tenga en cuenta que el resultado de dtype, shape y otros atributos pueden variar entre diferentes
sistemas operativos y distribuciones de Python.
>>> a.dtype
dtype ('int64')
La matriz recién creada tiene un eje, y luego su rango es 1, mientras que su forma debe ser
(3,1). Para obtener estos valores de la matriz correspondiente, es suficiente usar el ndim
atributo para obtener los ejes, el atributo de tamaño para conocer la longitud de la matriz y la forma
atributo para obtener su forma.
>>> a.ndim
1
>>> a.tamaño
3
>>> una. forma
(3,)
51
Página 69
Lo que acaba de ver es el caso más simple de una matriz unidimensional. Pero el uso
de matrices se puede ampliar fácilmente a varias dimensiones. Por ejemplo, si define dos
matriz dimensional 2x2:
>>> b = np.array ([[1.3, 2.4], [0.3, 4.1]])

>>> b.dtype
dtype ('float64')
>>> b.ndim
2
>>> b.tamaño
4
>>> b. forma
(2, 2)
Esta matriz tiene rango 2, ya que tiene dos ejes, cada uno de longitud 2.
Otro atributo importante es el tamaño de los elementos , que se puede utilizar con objetos ndarray. Eso
define el tamaño en bytes de cada elemento de la matriz, y los datos son el búfer que contiene el
elementos reales de la matriz. Este segundo atributo todavía no se usa generalmente, ya que para
acceder a los datos dentro de la matriz, utilizará el mecanismo de indexación que verá en
las siguientes secciones.
>>> b.itemsize
8
>>> b.data
<búfer de lectura y escritura para 0x0000000002D34DF0, tamaño 32, desplazamiento 0 en
0x0000000002D5FEA0>
Crear una matriz

Para crear una nueva matriz, puede seguir diferentes caminos. El camino más común es el
que vio en la sección anterior a través de una lista o secuencia de listas como argumentos para
función array ().
>>> c = np.array ([[1, 2, 3], [4, 5, 6]])

>>> c
matriz ([[1, 2, 3],
[4, 5, 6]])
52
Página 70
La función array (), además de listas, puede aceptar tuplas y secuencias de tuplas.
>>> d = np.array (((1, 2, 3), (4, 5, 6)))

>>> d
matriz ([[1, 2, 3],
[4, 5, 6]])
También puede aceptar secuencias de tuplas y listas interconectadas.
>>> e = np.array ([(1, 2, 3), [4, 5, 6], (7, 8, 9)])

>>> e
matriz ([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Tipos de datos
Hasta ahora, solo ha visto valores numéricos enteros y flotantes simples, pero las matrices NumPy son
diseñado para contener una amplia variedad de tipos de datos (consulte la Tabla 3-1 ). Por ejemplo, puede utilizar
la cadena de tipo de datos:
>>> g = np.array ([['a', 'b'], ['c', 'd']])

>>> g
matriz ([['a', 'b'],
['discos compactos']],
dtype = '| <U1')
>>> g.dtype
dtype ('<U1')
>>> g.dtype.name
'str32'
53
Página 71
Tabla 3-1. Tipos de datos admitidos por NumPy
Tipo de datos Descripción
bool_ booleano (verdadero o falso) almacenado como un byte
En t_ Tipo de entero predeterminado (igual que C long; normalmente int64 o int32)
intc idéntico a C int (normalmente int32 o int64)
intp entero utilizado para la indexación (igual que C size_t; normalmente int32 o int64)
int8 byte (–128 a 127)
int16 entero (–32768 a 32767)
int32 entero (–2147483648 a 2147483647)
int64 entero (–9223372036854775808 a 9223372036854775807)
uint8 entero sin signo (0 a 255)
flotador_ Taquigrafía de float64
float16 flotador de precisión media: bit de signo, exponente de 5 bits, mantisa de 10 bits
float32 Flotante de precisión simple: bit de signo, exponente de 8 bits, mantisa de 23 bits
float64 Flotante de doble precisión: bit de signo, exponente de 11 bits, mantisa de 52 bits
complejo_ Taquigrafía para complex128
complex64 Número complejo, representado por dos flotantes de 32 bits (componentes reales e imaginarios)
complex128 Número complejo, representado por dos flotantes de 64 bits (componentes reales e imaginarios)
La opción dtype
La función array () no acepta un solo argumento. Has visto que cada
El objeto ndarray está asociado con un objeto dtype que define de forma única el tipo de datos
que ocupará cada elemento de la matriz. Por defecto, la función array () puede asociar
el tipo más adecuado según los valores contenidos en la secuencia de listas o
tuplas. En realidad, puede definir explícitamente el dtype usando la opción dtype como argumento
de la función.
54
Página 72
Por ejemplo, si desea definir una matriz con valores complejos, puede usar la
dtype opción de la siguiente manera:
>>> f = np.array ([[1, 2, 3], [4, 5, 6]], dtype = complex)
>>> f
matriz ([[1. + 0.j, 2. + 0.j, 3. + 0.j],
[4. + 0.j, 5. + 0.j, 6. + 0.j]])
Creación intrínseca de una matriz

La biblioteca NumPy proporciona un conjunto de funciones que generan ndarrays con contenido inicial,
creado con diferentes valores dependiendo de la función. A lo largo del capítulo, y
a lo largo del libro, descubrirá que estas funciones le resultarán muy útiles. De hecho, ellos
permiten que una sola línea de código genere grandes cantidades de datos.
La función zeros (), por ejemplo, crea una matriz completa de ceros con dimensiones
definido por el argumento de forma. Por ejemplo, para crear una matriz bidimensional de 3x3,
puedes usar:
>>> np.zeros ((3, 3))

matriz ([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
Mientras que la función ones () crea una matriz llena de unos de una manera muy similar.
>>> np.ones ((3, 3))

matriz ([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
De forma predeterminada, las dos funciones crearon matrices con el tipo de datos float64. Una característica
que será particularmente útil es arange (). Esta función genera matrices NumPy
con secuencias numéricas que responden a reglas particulares dependiendo de la pasada
argumentos. Por ejemplo, si desea generar una secuencia de valores entre 0 y 10,
se le pasará solo un argumento a la función, ese es el valor con el que
quiere terminar la secuencia.
>>> np. rango (0, 10)

matriz ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
55
Página 73
Si en lugar de comenzar desde cero desea comenzar desde otro valor, simplemente
especifique dos argumentos: el primero es el valor inicial y el segundo es el valor final.
>>> np. rango (4, 10)

matriz ([4, 5, 6, 7, 8, 9])
También es posible generar una secuencia de valores con intervalos precisos entre
ellos. Si se especifica el tercer argumento de la función arange (), esto representará la
brecha entre un valor y el siguiente en la secuencia de valores.
>>> np. rango (0, 12, 3)

matriz ([0, 3, 6, 9])
Además, este tercer argumento también puede ser flotante.
>>> np. rango (0, 6, 0.6)

matriz ([0., 0.6, 1.2, 1.8, 2.4, 3., 3.6, 4.2, 4.8, 5.4])
Hasta ahora solo ha creado matrices unidimensionales. Para generar bidimensional

matrices aún puede continuar usando la función arange () pero combinada con la
función reshape (). Esta función divide una matriz lineal en diferentes partes de la manera
especificado por el argumento de forma.
>>> np.arange (0, 12) .reshape (3, 4)

matriz ([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]])
Otra función muy similar a arange () es linspace (). Esta función todavía toma como
sus dos primeros argumentos son los valores inicial y final de la secuencia, pero el tercer argumento,
en lugar de especificar la distancia entre un elemento y el siguiente, define la
número de elementos en los que queremos que se divida el intervalo.
>>> np.linspace (0,10,5)

matriz ([0., 2.5, 5., 7.5, 10.])
Finalmente, otro método para obtener matrices que ya contienen valores es llenarlos
con valores aleatorios. Esto es posible usando la función random () de numpy.random
módulo. Esta función generará una matriz con muchos elementos como se especifica en el
argumento.
56
Página 74
>>> np.random.random (3)

matriz ([0.78610272, 0.90630642, 0.80007102])
Los números obtenidos variarán con cada ejecución. Para crear una matriz multidimensional,
simplemente pasa el tamaño de la matriz como argumento.
>>> np.random.random ((3,3))

matriz ([[0.07878569, 0.7176506, 0.05662501],
[0.82919021, 0.80349121, 0.30254079],
[0.93347404, 0.65868278, 0.37379618]])
Operaciones básicas
Hasta ahora, ha visto cómo crear una nueva matriz NumPy y cómo se definen los elementos en ella.
Ahora es el momento de ver cómo aplicarles varias operaciones.
Operadores aritméticos
Las primeras operaciones que realizará en matrices son los operadores aritméticos. los
los más obvios son sumar y multiplicar una matriz por un escalar.
>>> a = np. rango (4)

>>> un
matriz ([0, 1, 2, 3])
>>> a + 4
matriz ([4, 5, 6, 7])
>>> a * 2
matriz ([0, 2, 4, 6])
Estos operadores también se pueden utilizar entre dos matrices. En NumPy, estas operaciones
son elemento-sabio, es decir, los operadores se aplican sólo entre los correspondientes
elementos. Estos son objetos que ocupan la misma posición, por lo que el resultado final será
una nueva matriz que contiene los resultados en la misma ubicación de los operandos (consulte la Figura 3-1).
57
Página 75
>>> b = np. rango (4,8)

>>> b
matriz ([4, 5, 6, 7])
>>> a + b
matriz ([4, 6, 8, 10])
>>> a - b
matriz ([- 4, –4, –4, –4])
>>> a * b
matriz ([0, 5, 12, 21])
Figura 3-1. Suma de elementos
Además, estos operadores también están disponibles para funciones, siempre que el valor
devuelto es una matriz NumPy. Por ejemplo, puede multiplicar la matriz por el seno o el
raíz cuadrada de los elementos de la matriz b .
>>> a * np.sin (b)

matriz ([- 0. , –0,95892427, –0,558831, 1,9709598])
>>> a * np.sqrt (b)
matriz ([0. , 2.23606798, 4.89897949, 7.93725393])
Pasando al caso multidimensional, incluso aquí los operadores aritméticos

continúe operando por elementos.
58
Página 76
>>> A = np.arange (0, 9) .reshape (3, 3)

>>> A
matriz ([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> B = np.ones ((3, 3))
>>> B
matriz ([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
>>> A * B
matriz ([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
El producto Matrix
La elección de los elementos operativos es un aspecto peculiar de la biblioteca NumPy. En
De hecho, en muchas otras herramientas para el análisis de datos, el operador * se entiende como una matriz
producto cuando se aplica a dos matrices. Usando NumPy, este tipo de producto es en cambio
indicado por la función punto (). Esta operación no es por elementos.
>>> np.dot (A, B)

matriz ([[3., 3., 3.],
[12., 12., 12.],
[21., 21., 21.]])
El resultado en cada posición es la suma de los productos de cada elemento de

la fila correspondiente de la primera matriz con el elemento correspondiente de la
columna correspondiente de la segunda matriz. Figura 3-2 ilustra el proceso realizado
durante el producto de la matriz (ejecutar para dos elementos).
59
Página 77
Figura 3-2. Cálculo de elementos matriciales como resultado de un producto matricial
Una forma alternativa de escribir el producto de la matriz es ver la función punto () como una
función del objeto de una de las dos matrices.
>>> A. punto (B)

matriz ([[3., 3., 3.],
[12., 12., 12.],
[21., 21., 21.]])
Tenga en cuenta que dado que el producto de la matriz no es una operación conmutativa, el orden de la
operandos es importante. De hecho, A * B no es igual a B * A.
>>> np.dot (B, A)

matriz ([[9., 12., 15.],
[9., 12., 15.],
[9., 12., 15.]])
Operadores de incremento y decremento

En realidad, no existen tales operadores en Python, ya que no hay operadores llamados ++ o
––. Para aumentar o disminuir valores, debe utilizar operadores como + = y - =. Estas
Los operadores no son diferentes de los que vio anteriormente, excepto que en lugar de crear un
nueva matriz con los resultados, reasignarán los resultados a la misma matriz.
60
Página 78
>>> a = np. rango (4)

>>> un
matriz ([0, 1, 2, 3])
>>> a + = 1
>>> un
matriz ([1, 2, 3, 4])
>>> a - = 1
>>> un
matriz ([0, 1, 2, 3])
Por lo tanto, el uso de estos operadores es mucho más extenso que el simple
operadores incrementales que aumentan los valores en una unidad, y se pueden aplicar en
muchos casos. Por ejemplo, los necesita cada vez que desea cambiar los valores en un
matriz sin generar una nueva.
matriz ([0, 1, 2, 3])

>>> a + = 4
>>> un
matriz ([4, 5, 6, 7])
>>> a * = 2
>>> un
matriz ([8, 10, 12, 14])
Funciones universales (ufunc)

Una función universal, generalmente llamada ufunc, es una función que opera en una matriz en un
moda elemento por elemento. Esto significa que actúa individualmente sobre cada elemento.
de la matriz de entrada para generar un resultado correspondiente en una nueva matriz de salida. En el final,
obtiene una matriz del mismo tamaño que la entrada.
Hay muchas operaciones matemáticas y trigonométricas que cumplen con este
definición; por ejemplo, calculando la raíz cuadrada con sqrt (), el logaritmo con
log (), o el pecado con sin ().
>>> a = np. rango (1, 5)

>>> un
matriz ([1, 2, 3, 4])
61
Página 79
>>> np.sqrt (a)

matriz ([1. , 1.41421356, 1.73205081, 2. ])
>>> np.log (a)
matriz ([0. , 0.69314718, 1.09861229, 1.38629436])
>>> np.sin (a)
matriz ([0.84147098, 0.90929743, 0.14112001, –0.7568025])
Muchas funciones ya están implementadas en la biblioteca NumPy.
Funciones agregadas
Las funciones agregadas realizan una operación en un conjunto de valores, una matriz, por ejemplo, y
producir un único resultado. Por lo tanto, la suma de todos los elementos de una matriz es un agregado
función. Muchas funciones de este tipo se implementan dentro de la clase ndarray.
>>> a = np.array ([3.3, 4.5, 1.2, 5.7, 0.3])
>>> a.sum ()
15.0
>>> a.min ()
0,29999999999999999
>>> a.max ()
5.7000000000000002
>>> a.mean ()
3,0
>>> a.std ()
2.0079840636817816
Indexación, corte e iteración

En las secciones anteriores, vio cómo crear una matriz y cómo realizar operaciones
en eso. En esta sección, verá cómo manipular estos objetos. Aprenderás como
seleccionar elementos a través de índices y cortes, con el fin de obtener los valores contenidos en
ellos o hacer asignaciones con el fin de cambiar sus valores. Finalmente, también verá
cómo puedes hacer iteraciones dentro de ellos.
62
Página 80
Indexación
La indexación de matrices siempre usa corchetes ([]) para indexar los elementos de la matriz, por lo que
que los elementos pueden ser referidos individualmente para varios usos, como extraer un
valor, seleccionando elementos, o incluso asignando un nuevo valor.
Cuando crea una nueva matriz, un índice de escala apropiado también se
creado (ver figura 3-3).
Figura 3-3. Indexación de un ndarray monodimensional
Para acceder a un solo elemento de una matriz, puede consultar su índice.
>>> a = np. rango (10, 16)

>>> un
matriz ([10, 11, 12, 13, 14, 15])
>>> a [4]
14
Las matrices NumPy también aceptan índices negativos. Estos índices tienen el mismo
secuencia incremental de 0 a –1, –2, y así sucesivamente, pero en la práctica causan la
elemento para moverse gradualmente hacia el elemento inicial, que será el que tiene la
valor de índice más negativo.
>>> a [–1]
15
>>> a [–6]
10
Para seleccionar varios elementos a la vez, puede pasar una matriz de índices entre corchetes.
>>> a [[1, 3, 4]]

matriz ([11, 13, 14])
63
Página 81
Pasando al caso bidimensional, es decir, las matrices, están representadas

como matrices rectangulares que constan de filas y columnas, definidas por dos ejes, donde el eje 0
está representado por las filas y el eje 1 está representado por las columnas. Por lo tanto, indexar en
este caso está representado por un par de valores: el primer valor es el índice de la fila y el
el segundo es el índice de la columna. Por lo tanto, si desea acceder a los valores o seleccionar
elementos en la matriz, seguirá utilizando corchetes, pero esta vez hay dos
valores [índice de fila, índice de columna] (ver Figura 3-4).
Figura 3-4. Indexación de una matriz bidimensional
>>> A = np. Rango (10, 19). Remodelar ((3, 3))

>>> A
matriz ([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
Si desea eliminar el elemento de la tercera columna en la segunda fila, debe

inserte el par [1, 2].
>>> A [1, 2]
15
64
Página 82
Rebanar
El corte le permite extraer partes de una matriz para generar nuevas matrices. Cuando cuando
usa las listas de Python para dividir matrices, las matrices resultantes son copias, pero en NumPy, el
las matrices son vistas del mismo búfer subyacente.
Dependiendo de la parte de la matriz que desee extraer (o ver), debe
use la sintaxis de sector; es decir, utilizará una secuencia de números separados por dos puntos (:)
entre corchetes.
Si desea extraer una parte de la matriz, por ejemplo, una que vaya del
segundo al sexto elemento, debe insertar el índice del elemento inicial, es decir, 1,
y el índice del elemento final, es decir 5, separado por:.
>>> a = np. rango (10, 16)

>>> un
matriz ([10, 11, 12, 13, 14, 15])
>>> a [1: 5]
matriz ([11, 12, 13, 14])
Ahora, si desea extraer un elemento de la parte anterior y omitir un elemento específico

número de elementos siguientes, luego extraiga el siguiente y salte nuevamente, puede usar un tercer
número que define el espacio en la secuencia de los elementos. Por ejemplo, con un valor
de 2, la matriz tomará los elementos de forma alterna.
>>> a [1: 5: 2]
matriz ([11, 13])
Para comprender mejor la sintaxis de los segmentos, también debe examinar los casos en los que
no utilice valores numéricos explícitos. Si omite el primer número, NumPy implícitamente
interpreta este número como 0 (es decir, el elemento inicial de la matriz). Si omite el segundo
número, esto se interpretará como el índice máximo de la matriz; y si omites el
último número esto se interpretará como 1. Todos los elementos se considerarán sin
intervalos.
sesenta y cinco
Página 83
>>> a [:: 2]
matriz ([10, 12, 14])
>>> a [: 5: 2]
matriz ([10, 12, 14])
>>> a [: 5:]
matriz ([10, 11, 12, 13, 14])
En el caso de una matriz bidimensional, la sintaxis de corte aún se aplica, pero es

definido por separado para las filas y columnas. Por ejemplo, si desea extraer solo el
primera fila:
>>> A = np. Rango (10, 19). Remodelar ((3, 3))

>>> A
matriz ([[10, 11, 12],
[13, 14, 15],
[16, 17, 18]])
>>> A [0 ,:]
matriz ([10, 11, 12])
Como puede ver en el segundo índice, si deja solo los dos puntos sin definir un
número, seleccionará todas las columnas. En cambio, si desea extraer todos los valores de
la primera columna, tienes que escribir la inversa.
>>> A [:, 0]
matriz ([10, 13, 16])
En cambio, si desea extraer una matriz más pequeña, debe definir explícitamente todos
intervalos con índices que los definen.
>>> A [0: 2, 0: 2]
matriz ([[10, 11],
[13, 14]])
Si los índices de las filas o columnas a extraer no son contiguos, puede

especificar una matriz de índices.
>>> A [[0,2], 0: 2]
matriz ([[10, 11],
[16, 17]])
66
Página 84
Iterando una matriz

En Python, la iteración de los elementos en una matriz es realmente muy simple; solo necesitas usar
el para construir.
>>> para i en a:
... imprimir (i)
...
10
11
12
13
14
15
Por supuesto, incluso aquí, pasando al caso bidimensional, podría pensar en

aplicando la solución de dos bucles anidados con la construcción for. El primer bucle escaneará
las filas de la matriz y el segundo ciclo escaneará las columnas. En realidad, si aplica
el bucle for a una matriz, siempre realizará un escaneo de acuerdo con el primer eje.
>>> para la fila en A:

... imprimir (fila)
...
[10 11 12]
[13 14 15]
[16 17 18]
Si desea hacer una iteración elemento por elemento, puede usar lo siguiente
construir, usando el bucle for en A.flat.
>>> para el artículo en A.flat:

... imprimir (elemento)
...
10
11
12
13
14
15
67
Página 85
dieciséis
17
18
Sin embargo, a pesar de todo esto, NumPy ofrece una solución alternativa y más elegante
que el bucle for. Generalmente, necesita aplicar una iteración para aplicar una función en el
filas o en las columnas o en un artículo individual. Si desea lanzar un agregado
función que devuelve un valor calculado para cada columna o en cada fila,
hay una forma óptima que deja que NumPy gestione la iteración: el apply_
función along_axis ().
Esta función toma tres argumentos: la función agregada, el eje sobre el que
aplique la iteración y la matriz. Si el eje de la opción es igual a 0, la iteración evalúa
los elementos columna por columna, mientras que si el eje es igual a 1, la iteración evalúa
los elementos fila por fila. Por ejemplo, puede calcular los valores promedio primero por
columna y luego por fila.
>>> np.apply_along_axis (np.mean, axis = 0, arr = A)

matriz ([13., 14., 15.])
>>> np.apply_along_axis (np.mean, axis = 1, arr = A)
matriz ([11., 14., 17.])
En el caso anterior, usó una función ya definida en la biblioteca NumPy, pero

nada le impide definir sus propias funciones. También usaste un agregado
función. Sin embargo, nada le prohíbe utilizar ufunc. En este caso, iterando
por columna y por fila produce el mismo resultado. De hecho, el uso de ufunc realiza una
iteración elemento por elemento.
>>> def foo (x):

... devuelve x / 2
...
>>> np.apply_along_axis (foo, eje = 1, arr = A)
matriz ([[5., 5.5, 6.],
[6.5, 7., 7.5],
[8., 8.5, 9.]])
>>> np.apply_along_axis (foo, eje = 0, arr = A)
matriz ([[5., 5.5, 6.],
[6.5, 7., 7.5],
[8., 8.5, 9.]])
68
Página 86
Como puede ver, la función ufunc divide a la mitad el valor de cada elemento de la entrada
matriz independientemente de si la iteración se realiza por fila o por columna.
Condiciones y matrices booleanas

Hasta ahora, ha utilizado la indexación y el corte para seleccionar o extraer un subconjunto de una matriz. Estas
Los métodos utilizan índices numéricos. Una forma alternativa de extraer selectivamente los elementos en
una matriz es utilizar las condiciones y los operadores booleanos.
Suponga que desea seleccionar todos los valores que son menores de 0.5 en una matriz 4x4
que contiene números aleatorios entre 0 y 1.
>>> A = np.random.random ((4, 4))

>>> A
matriz ([[0.03536295, 0.0035115, 0.54742404, 0.68960999],
[0.21264709, 0.17121982, 0.81090212, 0.43408927],
[0,77116263, 0,04523647, 0,84632378, 0,54450749],
[0.86964585, 0.6470581, 0.42582897, 0.22286282]])
Una vez que se define una matriz de números aleatorios, si aplica una condición de operador,
recibirá como valor de retorno una matriz booleana que contiene valores verdaderos en las posiciones
en el que se cumple la condición. En este ejemplo, son todas las posiciones en las que
los valores son inferiores a 0,5.
>>> A <0,5
array ([[Verdadero, Verdadero, Falso, Falso],
[Verdadero, Verdadero, Falso, Verdadero],
[Falso, Verdadero, Falso, Falso],
[Falso, Falso, Verdadero, Verdadero]], dtype = bool)
En realidad, las matrices booleanas se utilizan implícitamente para realizar selecciones de partes de
matrices. De hecho, al insertar la condición anterior directamente dentro de los corchetes,
extraerá todos los elementos menores a 0.5, para obtener una nueva matriz.
>>> A [A <0,5]
matriz ([0.03536295, 0.0035115, 0.21264709, 0.17121982, 0.43408927,
0.04523647, 0.42582897, 0.22286282])
69
Página 87
Manipulación de formas
Ya viste, durante la creación de una matriz bidimensional, cómo es posible
convierte una matriz unidimensional en una matriz, gracias a la función reshape ().
>>> a = np.random.random (12)

>>> un
matriz ([0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705,
0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692,
0,41894881, 0,73581471])
>>> A = a. Reforma (3, 4)
>>> A
matriz ([[0.77841574, 0.39654203, 0.38188665, 0.26704305],
[0.27519705, 0.78115866, 0.96019214, 0.59328414],
[0.52008642, 0.10862692, 0.41894881, 0.73581471]])
La función reshape () devuelve una nueva matriz y, por lo tanto, puede crear nuevos objetos.
Sin embargo, si desea modificar el objeto modificando la forma, debe asignar un
tupla que contiene las nuevas dimensiones directamente a su atributo de forma.
>>> una.forma = (3, 4)

>>> un
matriz ([[0.77841574, 0.39654203, 0.38188665, 0.26704305],
[0.27519705, 0.78115866, 0.96019214, 0.59328414],
[0.52008642, 0.10862692, 0.41894881, 0.73581471]])
Como puede ver, esta vez es la matriz inicial para cambiar de forma y no hay
objeto devuelto. La operación inversa también es posible, es decir, puedes convertir un
matriz bidimensional en una matriz unidimensional, utilizando la función ravel ().
>>> a = a.ravel ()
matriz ([0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705,
0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692,
0,41894881, 0,73581471])
70
Página 88
O incluso aquí actuando directamente sobre el atributo de forma de la propia matriz.
>>> a.shape = (12)
>>> un
matriz ([0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705,
0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692,
0,41894881, 0,73581471])
Otra operación importante es la transposición de una matriz, que invierte las columnas.
con las filas. NumPy proporciona esta característica con la función transpose ().
>>> A.transpose ()
matriz ([[0.77841574, 0.27519705, 0.52008642],
[0.39654203, 0.78115866, 0.10862692],
[0.38188665, 0.96019214, 0.41894881],
[0.26704305, 0.59328414, 0.73581471]])
Manipulación de matrices
A menudo es necesario crear una matriz utilizando matrices ya creadas. En esta sección,
vea cómo crear nuevas matrices uniendo o dividiendo matrices que ya están definidas.
Unir matrices
Puede fusionar varias matrices para formar una nueva que contenga todas las matrices. NumPy
utiliza el concepto de apilamiento , proporcionando una serie de funciones en este sentido. por
ejemplo, puede realizar apilamiento vertical con la función vstack (), que combina
la segunda matriz como nuevas filas de la primera matriz. En este caso, la matriz crece en vertical
dirección. Por el contrario, la función hstack () realiza un apilado horizontal; eso es el
la segunda matriz se agrega a las columnas de la primera matriz.
>>> A = np. Personas ((3, 3))

>>> B = np.zeros ((3, 3))
>>> np.vstack ((A, B))
matriz ([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
71
Página 89
[0., 0., 0.],

[0., 0., 0.],
[0., 0., 0.]])
>>> np.hstack ((A, B))
matriz ([[1., 1., 1., 0., 0., 0.],
[1., 1., 1., 0., 0., 0.],
[1., 1., 1., 0., 0., 0.]])
Otras dos funciones que realizan el apilamiento entre varias matrices son column_
stack () y row_stack (). Estas funciones operan de manera diferente a las dos
funciones. Generalmente estas funciones se utilizan con matrices unidimensionales, que son
apilados como columnas o filas para formar una nueva matriz bidimensional.
>>> a = np.array ([0, 1, 2])

>>> b = np.array ([3, 4, 5])
>>> c = np.array ([6, 7, 8])
>>> np.column_stack ((a, b, c))
matriz ([[0, 3, 6],
[1, 4, 7],
[2, 5, 8]])
>>> np.row_stack ((a, b, c))
matriz ([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
División de matrices
En la sección anterior, vio cómo ensamblar múltiples arreglos mediante apilamiento. Ahora
verá cómo dividir una matriz en varias partes. En NumPy, usa la división para hacer
esta. Aquí también, tiene un conjunto de funciones que funcionan tanto horizontalmente con hsplit ()
función y verticalmente con la función vsplit ().
>>> A = np.arange (16) .reforma ((4, 4))

>>> A
matriz ([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15]])
72
Página 90
Por lo tanto, si desea dividir la matriz horizontalmente, lo que significa que el ancho de la matriz es
dividida en dos partes, la matriz A de 4x4 se dividirá en dos matrices de 2x4.
>>> [B, C] = np.hsplit (A, 2)

>>> B
matriz ([[0, 1],
[4, 5],
[8, 9],
[12, 13]])
>>> C
matriz ([[2, 3],
[6, 7],
[10, 11],
[14, 15]])
En cambio, si desea dividir la matriz verticalmente, lo que significa que la altura de la matriz es
dividida en dos partes, la matriz A de 4x4 se dividirá en dos matrices de 4x2.
>>> [B, C] = np.vsplit (A, 2)

>>> B
matriz ([[0, 1, 2, 3],
[4, 5, 6, 7]])
>>> C
matriz ([[8, 9, 10, 11],
[12, 13, 14, 15]])
Un comando más complejo es la función split (), que le permite dividir el

matriz en partes asimétricas. Pasando la matriz como argumento, también debe
especificar los índices de las partes a dividir. Si usa la opción axis = 1, entonces la
los índices serán columnas; si en cambio la opción es axis = 0, entonces serán índices de fila.
Por ejemplo, si desea dividir la matriz en tres partes, la primera de las cuales
incluir la primera columna, la segunda incluirá la segunda y la tercera columna, y
el tercero incluirá la última columna, debes especificar tres índices de la siguiente manera.
>>> [A1, A2, A3] = np.split (A, [1,3], eje = 1)

>>> A1
matriz ([[0],
[4],
73
Página 91
[8],
[12]])
>>> A2
matriz ([[1, 2],
[5, 6],
[9, 10],
[13, 14]])
>>> A3
matriz ([[3],
[7],
[11],
[15]])
Puedes hacer lo mismo por fila.
>>> [A1, A2, A3] = np.split (A, [1,3], eje = 0)

>>> A1
matriz ([[0, 1, 2, 3]])
>>> A2
matriz ([[4, 5, 6, 7],
[8, 9, 10, 11]])
>>> A3
matriz ([[12, 13, 14, 15]])
Esta característica también incluye las funcionalidades de vsplit () y hsplit ()

funciones.
Conceptos generales
Esta sección describe los conceptos generales subyacentes a la biblioteca NumPy. los
La diferencia entre copias y vistas es cuando devuelven valores. El mecanismo de
broadcasting, que ocurre implícitamente en muchas funciones de NumPy, también se trata en
esta sección.
74
Página 92
Copias o vistas de objetos

Como habrás notado con NumPy, especialmente cuando estás manipulando una matriz,
puede devolver una copia o una vista de la matriz. Ninguna de las asignaciones de NumPy produce
copias de matrices, ni ningún elemento contenido en ellas.
>>> a = np.array ([1, 2, 3, 4])

>>> b = a
>>> b
matriz ([1, 2, 3, 4])
>>> a [2] = 0
>>> b
matriz ([1, 2, 0, 4])
Si asigna una matriz a a otra matriz b, no la está copiando; la matriz b es solo

otra forma de llamar a la matriz a. De hecho, al cambiar el valor del tercer elemento,
cambie también el tercer valor de b. Cuando corta una matriz, el objeto devuelto es una vista de
la matriz original.
>>> c = a [0: 2]
>>> c
matriz ([1, 2])
>>> a [0] = 0
>>> c
matriz ([0, 2])
Como puede ver, incluso al cortar, en realidad está apuntando al mismo objeto. Si tu
desea generar una matriz completa y distinta, use la función copy ().
>>> a = np.array ([1, 2, 3, 4])

>>> c = a.copia ()
>>> c
matriz ([1, 2, 3, 4])
>>> a [0] = 0
>>> c
matriz ([1, 2, 3, 4])
En este caso, incluso cuando cambia los elementos de la matriz a, la matriz c permanece sin cambios.
75
Página 93
Vectorización
La vectorización , junto con la radiodifusión , es la base de la implementación interna
de NumPy. La vectorización es la ausencia de un bucle explícito durante el desarrollo de la
código. Estos bucles en realidad no se pueden omitir, pero se implementan internamente y luego
son reemplazados por otras construcciones en el código. La aplicación de la vectorización conduce a
un código más conciso y legible, y puede decir que aparecerá más "Pythonic"
en su apariencia. De hecho, gracias a la vectorización, muchas operaciones adquieren un carácter más
expresión matemática. Por ejemplo, NumPy te permite expresar la multiplicación
de dos matrices como se muestra:
a*b
O incluso dos matrices:
A*B
En otros lenguajes, tales operaciones se expresarían con muchos bucles anidados y

el para construir. Por ejemplo, la primera operación se expresaría de la siguiente manera:
para (i = 0; i <filas; i ++) {

c [i] = a [i] * b [i];
}
Mientras que el producto de matrices se expresaría de la siguiente manera:
para (i = 0; i <filas; i ++) {

para (j = 0; j <columnas; j ++) {
c [i] [j] = a [i] [j] * b [i] [j];
}
}
Puede ver que el uso de NumPy hace que el código sea más legible y más
matemático.
Radiodifusión
La transmisión permite que un operador o una función actúen en dos o más arreglos para operar
incluso si estas matrices no tienen la misma forma. Dicho esto, no todas las dimensiones pueden ser
sometido a radiodifusión; deben cumplir ciertas reglas.
76
Página 94
Viste que usando NumPy, puedes clasificar matrices multidimensionales a través de un

forma que es una tupla que representa la longitud de los elementos de cada dimensión.
Dos matrices pueden someterse a difusión cuando todas sus dimensiones son
compatible, es decir, la longitud de cada dimensión debe ser igual o una de ellas debe ser
igual a 1. Si no se cumple ninguna de estas condiciones, obtendrá una excepción que establece que
dos matrices no son compatibles.
>>> A = np.arange (16) .reforma (4, 4)

>>> b = np. rango (4)
>>> A
matriz ([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15]])
>>> b
matriz ([0, 1, 2, 3])
En este caso, obtiene dos matrices:
4x4
4
Hay dos reglas de transmisión. Primero debes agregar un 1 a cada falta

dimensión. Si ahora se cumplen las reglas de compatibilidad, puede aplicar la transmisión y
pase a la segunda regla. Por ejemplo:
4x4
4x1
Se cumple la regla de compatibilidad. Entonces puedes pasar a la segunda regla de

radiodifusión. Esta regla explica cómo extender el tamaño de la matriz más pequeña para que sea
el tamaño de la matriz más grande, de modo que la función u operador de elementos sea aplicable.
La segunda regla asume que los elementos faltantes (tamaño, longitud 1) se rellenan con
réplicas de los valores contenidos en tamaños extendidos (ver Figura 3-5 ).
77
Página 95
Figura 3-5. Aplicar la segunda regla de transmisión
Ahora que las dos matrices tienen las mismas dimensiones, se pueden agregar los valores internos
juntos.
>>> A + b
matriz ([[0, 2, 4, 6],
[4, 6, 8, 10],
[8, 10, 12, 14],
[12, 14, 16, 18]])
Este es un caso simple en el que una de las dos matrices es más pequeña que la otra. Ahí
Pueden ser casos más complejos en los que las dos matrices tienen formas diferentes y cada una es
más pequeño que el otro solo en ciertas dimensiones.
>>> m = np.arange (6) .reforma (3, 1, 2)

>>> n = np.arange (6) .reforma (3, 2, 1)
>>> m
matriz ([[[0, 1]],
[[2, 3]],
[[4, 5]]])
>>> n
matriz ([[[0],
[1]],
[[2],
[3]],
[[4],
[5]]])
78
Página 96
Incluso en este caso, al analizar las formas de las dos matrices, puede ver que son
compatible y por lo tanto se pueden aplicar las reglas de radiodifusión.
3x1x2
3x2x1
En este caso, ambos arreglos sufren la extensión de dimensiones (difusión).
m * = [[[0,1], n * = [[[0,0],
[0,1]], [1,1]],
[[2,3], [[2,2],
[2,3]], [3,3]],
[[4,5], [[4,4],
[4,5]]] [5,5]]]
Entonces puede aplicar, por ejemplo, el operador de suma entre las dos matrices,
elemento operativo.
>>> m + n
matriz ([[[0, 1],
[1, 2]],
[[4, 5],
[5, 6]],
[[8, 9],
[9, 10]]])
Matrices estructuradas
Hasta ahora, en los diversos ejemplos de las secciones anteriores, vio monodimensionales y
matrices bidimensionales. NumPy te permite crear matrices que son mucho más complejas
no solo en tamaño, sino en la estructura, llamados arreglos estructurados. Este tipo de matriz contiene
estructuras o registros en lugar de elementos individuales.
Por ejemplo, puede crear una matriz simple de estructuras como elementos. Gracias al dtype
opción, puede especificar una lista de especificadores separados por comas para indicar los elementos que
constituirá la estructura, junto con el tipo de datos y el orden.
79
Página 97
bytes b1
En t i1, i2, i4, i8
entradas sin firmar u1, u2, u4, u8
flotadores f2, f4, f8
complejo c8, c16
cadenas de longitud fija a <n>
Por ejemplo, si desea especificar una estructura que consta de un entero, un carácter
cadena de longitud 6 y un valor booleano, especificará los tres tipos de datos en el
dtype con el orden correcto utilizando los especificadores correspondientes.
Tenga en cuenta que el resultado de dtype y otros atributos de formato pueden variar entre diferentes
sistemas operativos y distribuciones de Python.
>>> estructurado = np.array ([(1, 'Primero', 0.5, 1 + 2j), (2, 'Segundo', 1.3,
2-2j), (3, 'Tercero', 0.8, 1 + 3j)], dtype = ('i2, a6, f4, c8'))
>>> estructurado
matriz ([(1, b'Primero ', 0.5, 1 + 2.j),
(2, b'Segundo ', 1.3, 2.-2.j),
(3, b'Tercero ', 0.8, 1. + 3.j)],
dtype = [('f0', '<i2'), ('f1', 'S6'), ('f2', '<f4'), ('f3', '<c8')])
También puede utilizar el tipo de datos especificando explícitamente int8, uint8, float16, complex64,
Etcétera.
>>> estructurado = np.array ([(1, 'Primero', 0.5, 1 + 2j), (2, 'Segundo', 1.3,2-2j),
(3, 'Tercero', 0.8, 1 + 3j)], dtype = ('
int16, a6, float32, complex64 '))
>>> estructurado
matriz ([(1, b'Primero ', 0.5, 1. + 2.j),
(2, b'Segundo ', 1.3, 2.-2.j),
(3, b'Tercero ', 0.8, 1. + 3.j)],
dtype = [('f0', '<i2'), ('f1', 'S6'), ('f2', '<f4'), ('f3', '<c8')])
Ambos casos tienen el mismo resultado. Dentro de la matriz, ves una secuencia dtype
que contiene el nombre de cada elemento de la estructura con el tipo de datos correspondiente.
80
Página 98
Escribiendo el índice de referencia apropiado, obtienes la fila correspondiente, que

contiene la estructura.
>>> estructurado [1]

(2, 'segundo segundo', 1.3, 2.-2.j)
Los nombres que se asignan automáticamente a cada elemento de estructura se pueden considerar
como los nombres de las columnas de la matriz. Utilizándolos como índice estructurado, puede consultar
a todos los elementos del mismo tipo, o de la misma columna.
>>> estructurado ['f1']

array ([b'Primero ', b'Segundo', b'Tercero '],
dtype = '| S6')
Como acaba de ver, los nombres se asignan automáticamente con una f (que significa
para campo) y un entero progresivo que indica la posición en la secuencia. De hecho,
Sería más útil especificar los nombres con algo más significativo. Esto es
posible y puede hacerlo en el momento de la declaración de la matriz:
>>> estructurado = np.array ([(1, 'Primero', 0.5,1 + 2j), (2, 'Segundo', 1.3,2-2j),
(3, 'Tercero', 0.8,1 + 3j)], dtype = [(
'id', 'i2'), ('posición', 'a6'), ('valor', 'f4'), ('complejo', 'c8')])
>>> estructurado
matriz ([(1, b'Primero ', 0.5, 1. + 2.j),
(2, b'Segundo ', 1.3, 2.-2.j),
(3, b'Tercero ', 0.8, 1. + 3.j)],
dtype = [('id', '<i2'), ('posición', 'S6'), ('valor', '<f4'),
('complejo', '<c8')])
O puede hacerlo más tarde, redefiniendo las tuplas de nombres asignados al dtype
atributo de la matriz estructurada.
>>> estructurado.dtype.names = ('id', 'orden', 'valor', 'complejo')
Ahora puede utilizar nombres significativos para los distintos tipos de campos:
>>> estructurado ['orden']

array ([b'Primero ', b'Segundo', b'Tercero '],
dtype = '| S6')
81
Página 99
Lectura y escritura de datos de matriz en archivos

Un aspecto muy importante de NumPy que aún no se ha discutido es el proceso de
leer datos contenidos en un archivo. Este procedimiento es muy útil, especialmente cuando
tienen que lidiar con grandes cantidades de datos recopilados en matrices. Este es un dato muy común
operación de análisis, ya que el tamaño del conjunto de datos a analizar es casi siempre enorme, y
por tanto, no es aconsejable ni posible gestionarlo manualmente.
NumPy proporciona un conjunto de funciones que permiten a los analistas de datos guardar los resultados de sus
cálculos en un archivo de texto o binario. Del mismo modo, NumPy le permite leer y convertir
datos escritos en un archivo en una matriz.
Cargar y guardar datos en archivos binarios

NumPy proporciona un par de funciones llamadas save () y load () que le permiten guardar
y luego recuperar los datos almacenados en formato binario.
Una vez que tenga una matriz para guardar, por ejemplo, una que contenga los resultados de su
procesamiento de análisis de datos, simplemente llame a la función save () y especifique como argumentos
el nombre del archivo y la matriz. Al archivo se le asignará automáticamente la extensión .npy.
>>> datos = ([[0.86466285, 0.76943895, 0.22678279],

[0.12452825, 0.54751384, 0.06499123],
[0.06216566, 0.85045125, 0.92093862],
[0.58401239, 0.93455057, 0.28972379]])
>>> np.save ('datos_ guardados', datos)
Cuando necesite recuperar los datos almacenados en un archivo .npy, use la función load ()
especificando el nombre del archivo como argumento, esta vez agregando la extensión .npy.
>>> datos_cargados = np.load ('datos_ guardados.npy')

>>> datos_cargados
matriz ([[0.86466285, 0.76943895, 0.22678279],
[0.12452825, 0.54751384, 0.06499123],
[0.06216566, 0.85045125, 0.92093862],
[0.58401239, 0.93455057, 0.28972379]])
82
Página 100
Leer archivos con datos tabulares

Muchas veces, los datos que desea leer o guardar están en formato de textura (TXT o CSV,
por ejemplo). Puede guardar los datos en este formato, en lugar de binario, porque los archivos
luego se puede acceder al exterior de forma independiente si está trabajando con NumPy o con
cualquier otra aplicación. Tomemos, por ejemplo, el caso de un conjunto de datos en el CSV (Coma-
Valores separados), en el que los datos se recopilan en un formato tabular donde
los valores están separados por comas (ver Listado 3-1 ).
Listado 3-1. ch3_data.csv
id, valor1, valor2, valor3

1,123,1.4,23
2,110,0.5,18
3,164,2.1,19
Para poder leer sus datos en un archivo de texto e insertar valores en una matriz, NumPy
proporciona una función llamada genfromtxt (). Normalmente, esta función toma tres
argumentos: el nombre del archivo que contiene los datos, el carácter que separa
valores entre sí (en este caso es una coma), y si los datos contienen columnas
encabezados.
>>> data = np.genfromtxt ('ch3_data.csv', delimiter = ',', names = True)

>>> datos
matriz ([(1.0, 123.0, 1.4, 23.0), (2.0, 110.0, 0.5, 18.0),
(3,0, 164,0, 2,1, 19,0)],
dtype = [('id', '<f8'), ('valor1', '<f8'), ('valor2', '<f8'),
('valor3', '<f8')])
Como puede ver en el resultado, obtiene una matriz estructurada en la que la columna
los encabezados se han convertido en los nombres de los campos.
Esta función realiza implícitamente dos bucles: el primer bucle lee una línea a la vez,
y el segundo bucle separa y convierte los valores contenidos en él, insertando el
elementos consecutivos creados específicamente. Un aspecto positivo de esta característica es que si
faltan algunos datos, la función puede manejarlos.
Tomemos, por ejemplo, el archivo anterior (ver Listado 3-2 ) con algunos elementos eliminados. Guárdalo
como data2.csv.
83
Página 101
Listado 3-2. ch3_data2.csv
id, valor1, valor2, valor3

1,123,1.4,23
2,110, 18
3, 2,1,19
Al iniciar estos comandos, puede ver cómo la función genfromtxt () reemplaza
los espacios en blanco en el archivo con valores nan.
>>> data2 = np.genfromtxt ('ch3_data2.csv', delimiter = ',', names = True)
>>> datos2
matriz ([(1.0, 123.0, 1.4, 23.0), (2.0, 110.0, nan, 18.0),
(3,0, nan, 2,1, 19,0)],
dtype = [('id', '<f8'), ('valor1', '<f8'), ('valor2', '<f8'),
('valor3', '<f8')])
En la parte inferior de la matriz, puede encontrar los encabezados de columna contenidos en el archivo.
Estos encabezados pueden considerarse etiquetas que actúan como índices para extraer los valores mediante
columna:
>>> data2 ['id']

matriz ([1., 2., 3.])
En cambio, al utilizar los índices numéricos de la forma clásica, extraerá datos

correspondiente a las filas.
>>> datos2 [0]

(1.0, 123.0, 1.4, 23.0)
Conclusiones
En este capítulo, aprendió sobre todos los aspectos principales de la biblioteca NumPy y se convirtió en
familiarizado con una variedad de características que forman la base de muchos otros aspectos que enfrentará en
el curso del libro. De hecho, muchos de estos conceptos se tomarán de otras fuentes científicas.
y bibliotecas informáticas que son más especializadas, pero que han sido estructuradas y
desarrollado sobre la base de esta biblioteca.
84
Página 102
Viste cómo, gracias al ndarray, puedes extender las funcionalidades de Python,

convirtiéndolo en un lenguaje adecuado para la computación científica y el análisis de datos.
Por lo tanto, el conocimiento de NumPy es crucial para cualquiera que quiera conquistar el mundo.
de análisis de datos.
En el siguiente capítulo, comenzamos a presentar una nueva biblioteca, llamada pandas, es decir
estructurado en NumPy y por lo tanto abarca todos los conceptos básicos ilustrados en este
capítulo. Sin embargo, los pandas amplían estos conceptos para que sean más adecuados para
análisis de los datos.
85
Página 103
CAPÍTULO 4
La biblioteca de los pandas: una

Introducción
Este capítulo entra en el corazón de este libro: la biblioteca de pandas. Esta fantástica pitón
biblioteca es una herramienta perfecta para cualquiera que desee realizar análisis de datos utilizando Python como
lenguaje de programación.
Primero, aprenderá sobre los aspectos fundamentales de esta biblioteca y cómo instalarla.
en su sistema, y luego se familiarizará con las dos estructuras de datos llamadas
series y marcos de datos . Durante el transcurso del capítulo, trabajará con un conjunto básico
de funciones proporcionadas por la biblioteca pandas, con el fin de realizar los datos más comunes
tareas de procesamiento. Familiarizarse con estas operaciones es un objetivo clave del resto de
libro. Por eso es muy importante repetir este capítulo hasta que se sienta cómodo
con su contenido.
Además, con una serie de ejemplos aprenderás algunos conceptos particularmente nuevos.
introducido en la biblioteca de pandas: indexación de estructuras de datos. Aprenderá cómo obtener el
la mayor parte de esta función para la manipulación de datos en este capítulo y en los siguientes.
Finalmente, verá cómo extender el concepto de indexación a múltiples niveles en el
Al mismo tiempo, a través del proceso denominado indexación jerárquica.
pandas: la biblioteca de análisis de datos de Python

pandas es una biblioteca Python de código abierto para análisis de datos altamente especializados. Es
actualmente el punto de referencia que todos los profesionales que utilizan el lenguaje Python necesitan
estudio con fines estadísticos de análisis y toma de decisiones.
Esta biblioteca fue diseñada y desarrollada principalmente por Wes McKinney comenzando
en 2008. En 2012, Sien Chang, uno de sus colegas, se agregó al desarrollo.
Juntos configuraron una de las bibliotecas más utilizadas en la comunidad de Python.
87
© Fabio Nelli 2018
Página 104
CAPÍTULO 4 LA BIBLIOTECA DE PANDAS: INTRODUCCIÓN
pandas surge de la necesidad de contar con una biblioteca específica para analizar datos que brinde,
de la forma más sencilla posible, todos los instrumentos para el procesamiento, extracción de datos y
manipulación de datos.
Este paquete de Python está diseñado sobre la base de la biblioteca NumPy. Esta elección, nosotros
puedo decir, fue fundamental para el éxito y la rápida propagación de los pandas. De hecho, esta elección no
solo hace que esta biblioteca sea compatible con la mayoría de los otros módulos, pero también aprovecha
la alta calidad del módulo NumPy.
Otra opción fundamental fue diseñar estructuras de datos ad hoc para el análisis de datos.
De hecho, en lugar de utilizar estructuras de datos existentes integradas en Python o proporcionadas por otros
bibliotecas, se desarrollaron dos nuevas estructuras de datos.
Estas estructuras de datos están diseñadas para trabajar con datos relacionales o datos etiquetados, por lo que
lo que le permite administrar datos con características similares a las diseñadas para SQL relacional
bases de datos y hojas de cálculo de Excel.
A lo largo del libro, de hecho, verá una serie de operaciones básicas para datos
análisis, que normalmente se utilizan en tablas de bases de datos y hojas de cálculo. pandas de hecho
proporciona un conjunto extendido de funciones y métodos que le permiten realizar estos
operaciones de manera eficiente.
Entonces, el propósito principal de los pandas es proporcionar todos los componentes básicos para cualquier persona.
acercarse al mundo del análisis de datos.
Instalación de pandas
La forma más sencilla y general de instalar la biblioteca de pandas es utilizar un paquete
solución, es decir, instalarlo a través de una distribución Anaconda o Enthought.
Instalación de Anaconda
Para aquellos que eligen usar la distribución de Anaconda, administrar la instalación es
muy simple. Primero tienes que ver si el módulo pandas está instalado y, de ser así, cuál
versión. Para hacer esto, escriba el siguiente comando desde la terminal:
lista de conda pandas
Como tengo el módulo instalado en mi PC (Windows), obtengo el siguiente resultado:
# paquetes en el entorno en C: \ Users \ Fabio \ Anaconda:

#
pandas 0,20,3 py36hce827b7_2
88
Página 105
Si no tiene pandas instalados, deberá instalarlo. Introduzca la siguiente

mando:
conda instalar pandas
Anaconda verificará inmediatamente todas las dependencias, gestionando la instalación de

otros módulos, sin que tengas que preocuparte demasiado.
Entorno de resolución: hecho

## Plan de paquete ##
Ubicación del entorno: C: \ Users \ Fabio \ Anaconda3

especificaciones agregadas / actualizadas:
- pandas
Se instalarán los siguientes paquetes nuevos:
Pandas: 0.22.0-py36h6538335_0
Continuar ([y] / n)?
Presione la tecla y en su teclado para continuar con la instalación.
Preparando transacción: hecho
Verificando transacción: hecho
Ejecutando transacción: hecho
Si desea actualizar su paquete a una versión más reciente, el comando para hacerlo es
muy simple e intuitivo:
pandas de actualización conda
El sistema verificará la versión de pandas y la versión de todos los módulos en
que depende y luego sugiera actualizaciones. A continuación, le preguntará si desea continuar con
la actualización.
Instalación desde PyPI

PyPI también puede instalar pandas usando este comando:
pip instalar pandas
89
Página 106
Instalación en Linux
Si está trabajando en una distribución de Linux y elige no usar ninguno de estos
distribuciones preempaquetadas, puede instalar el módulo pandas como cualquier otro paquete.
En las distribuciones de Debian y Ubuntu, use este comando:
sudo apt-get install python-pandas
Mientras esté en OpenSuse y Fedora, ingrese el siguiente comando:
zypper en python-pandas
Instalación desde la fuente

Si desea compilar su módulo pandas a partir del código fuente, puede encontrar lo que
necesita en GitHub en https://github.com/pandas-dev/pandas:
git clon git: //github.com/pydata/pandas.git

cd pandas
instalación de python setup.py
Asegúrese de haber instalado Cython en el momento de la compilación. Para obtener más información, lea
la documentación disponible en la Web, incluida la página oficial (http: // pandas.
pydata.org/pandas-docs/stable/install.html).
Un repositorio de módulos para Windows

Si está trabajando en Windows y prefiere administrar sus paquetes para siempre
tiene los módulos más actualizados, también hay un recurso en Internet donde puede
descargar muchos módulos de terceros: paquetes de extensión de Python de Christoph Gohlke
para el repositorio de Windows (www.lfd.uci.edu/~gohlke/pythonlibs/ ). Cada módulo es
suministrado con el formato de archivo WHL (rueda) tanto en 32 bits como en 64 bits. Para instalar cada
módulo, debe utilizar la aplicación pip (consulte PyPI en el capítulo 2).
pip instalar SomePackege-1.0.whl
Por ejemplo, para los pandas, puede encontrar y descargar el siguiente paquete:
pip instalar pandas-0.22.0-cp36-cp36m-win_amd64.whl
90
Página 107
Capítulo 4 la biblioteca pandas: una introducción
Al elegir el módulo, tenga cuidado de elegir la versión correcta para su versión

de Python y la arquitectura en la que está trabajando. Además, aunque NumPy
no requiere la instalación de otros paquetes, al contrario, pandas tiene muchos
dependencias. Así que asegúrese de obtenerlos todos. El orden de instalación no es importante.
La desventaja de este enfoque es que necesita instalar los paquetes
individualmente sin un administrador de paquetes que pueda ayudar a administrar el control de versiones y
interdependencias entre los distintos paquetes. La ventaja es un mayor dominio de
los módulos y sus versiones, para que tenga los módulos más actuales posibles sin
dependiendo de las elecciones de las distribuciones.
Prueba de la instalación de pandas

La biblioteca de pandas puede ejecutar una comprobación después de su instalación para verificar los controles internos (el
La documentación oficial indica que la prueba proporciona una cobertura del 97% de todo el código que contiene).
Primero, asegúrese de haber instalado el módulo nose en su distribución de Python (consulte
la barra lateral "Módulo de nariz"). Si lo hizo, puede comenzar la prueba ingresando lo siguiente
mando:
pandas de nosetests
La prueba tomará varios minutos y al final mostrará una lista de los problemas.
encontrado.
MÓDULO NARIZ
este módulo está diseñado para probar código Python durante las fases de desarrollo de un proyecto
o un módulo de Python en particular. este módulo amplía las capacidades de unittest
módulo. el módulo de Python involucrado en probar el código, sin embargo, hace que su codificación sea mucho
más simple y fácil.
le sugiero que lea este artículo en http://pythontesting.net/framework/nose/nose-

introducción / para obtener más información.
91
Página 108
Empezando con pandas

La mejor manera de comenzar con pandas es abrir un shell de Python y escribir comandos
uno a uno. De esta manera, tiene la oportunidad de familiarizarse con el individuo
funciones y estructuras de datos que se explican en este capítulo.
Además, los datos y funciones definidos en los distintos ejemplos siguen siendo válidos
a lo largo del capítulo, lo que significa que no es necesario definirlos cada vez. Tú
están invitados, al final de cada ejemplo, a repetir los distintos comandos, modificarlos
si es apropiado, y controlar cómo varían los valores en las estructuras de datos durante la operación.
Este enfoque es ideal para familiarizarse con los diferentes temas cubiertos en este
capítulo, dejándole la oportunidad de interactuar libremente con lo que está leyendo.
Tenga en cuenta que este capítulo asume que está familiarizado con Python y
numpy en general. si tiene alguna dificultad, lea los capítulos2 y 3 de este libro.
Primero, abra una sesión en el shell de Python y luego importe la biblioteca de pandas. los
La práctica general para importar el módulo pandas es la siguiente:
>>> importar pandas como pd

Por tanto, en este capítulo y en todo el libro, cada vez que vea pd y np,
hacer referencia a un objeto o método que hace referencia a estas dos bibliotecas, aunque
a menudo tendrá la tentación de importar el módulo pandas de esta manera:
>>> de la importación de pandas *
Por lo tanto, ya no tiene que hacer referencia a una función, objeto o método con pd; esta
El enfoque no se considera una buena práctica por la comunidad de Python en general.
Introducción a las estructuras de datos de pandas

El corazón de los pandas son las dos estructuras de datos primarias en las que todas las transacciones, que
se realizan generalmente durante el análisis de datos, están centralizados:
• Serie
• Marcos de datos
92
Página 109
La serie , como verá, constituye la estructura de datos diseñada para acomodar un

secuencia de datos unidimensionales, mientras que el marco de datos , una estructura de datos más compleja,
está diseñado para contener estuches de varias dimensiones.
Aunque estas estructuras de datos no son la solución universal a todos los problemas, sí
proporcionan una herramienta válida y robusta para la mayoría de aplicaciones. De hecho, siguen siendo muy sencillos de
entender y utilizar. Además, muchos casos de estructuras de datos más complejas aún pueden
se remonta a estos dos simples casos.
Sin embargo, sus peculiaridades se basan en una característica particular: la integración en su
estructura de los objetos de índice y las etiquetas. Verá que esta característica hace que estos datos
estructuras para ser fácilmente manipuladas.
Las series
La serie es el objeto de la biblioteca de pandas diseñada para representar datos unidimensionales.
estructuras, similares a una matriz pero con algunas características adicionales. Su estructura interna es
simple (ver figura 4-1) y se compone de dos matrices asociadas entre sí. los
la matriz principal contiene los datos (datos de cualquier tipo NumPy) a los que está asociado cada elemento
con una etiqueta, contenida dentro de la otra matriz, llamada índice .
Figura 4-1. La estructura del objeto de la serie.
93
Página 110
Declarar una serie

Para crear la serie especificada en la Figura 4-1 , simplemente llame al constructor Series () y
pasar como argumento una matriz que contiene los valores que se incluirán en ella.
>>> s = pd.Series ([12, -4,7,9])

>>> s
0 12
1-4
27
39
dtype: int64
Como puede ver en la salida de la serie, a la izquierda están los valores en el

index, que es una serie de etiquetas, y a la derecha están los valores correspondientes.
Si no especifica ningún índice durante la definición de la serie, por defecto,
los pandas asignarán valores numéricos que aumentan desde 0 como etiquetas. En este caso, las etiquetas
corresponden a los índices (posición en la matriz) de los elementos del objeto serie.
A menudo, sin embargo, es preferible crear una serie con etiquetas significativas para
distinguir e identificar cada elemento independientemente del orden en el que fueron insertados
en la serie.
En este caso será necesario, durante la llamada al constructor, incluir el índice
opción y asigne una matriz de cadenas que contengan las etiquetas.
>>> s = pd.Series ([12, -4,7,9], índice = ['a', 'b', 'c', 'd'])

>>> s
a 12
b -4
c7
d9
dtype: int64
Si desea ver individualmente las dos matrices que componen esta estructura de datos, debe
Puede llamar a los dos atributos de la serie de la siguiente manera: índice y valores.
>>> s.valores
matriz ([12, -4, 7, 9], dtype = int64)
>>> en el índice
Índice ([u'a ', u'b', u'c ', u'd'], dtype = 'objeto')
94
Página 111
Seleccionar los elementos internos

Puede seleccionar elementos individuales como matrices numpy ordinarias, especificando la clave.
>>> s [2]
7
O puede especificar la etiqueta correspondiente a la posición del índice.
>>> s ['b']
-4
De la misma manera que selecciona varios elementos en una matriz numpy, puede especificar el
siguiendo:
>>> s [0: 2]
a 12
b -4
dtype: int64
En este caso, puede utilizar las etiquetas correspondientes, pero especifique la lista de etiquetas en un
formación.
>>> s [['b', 'c']]

b -4
c7
dtype: int64
Asignar valores a los elementos

Ahora que comprende cómo seleccionar elementos individuales, también sabe cómo
asignarles nuevos valores. De hecho, puede seleccionar el valor por índice o por etiqueta.
>>> s [1] = 0
>>> s
a 12
b0
c7
d9
dtype: int64
95
Página 112
>>> s ['b'] = 1
>>> s
a 12
b1
c7
d9
dtype: int64
Definición de una serie a partir de matrices NumPy y otras series

Puede definir una nueva serie comenzando con matrices NumPy o con una serie existente.
>>> arr = np.array ([1,2,3,4])

>>> s3 = pd.Series (arr)
>>> s3
01
12
23
34
dtype: int64
>>> s4 = pd.Serie (s)

>>> s4
a 12
b4
c7
d9
dtype: int64
Tenga siempre en cuenta que los valores contenidos en la matriz NumPy o en la

las series originales no se copian, sino que se pasan por referencia. Es decir, el objeto se inserta
dinámicamente dentro del nuevo objeto de serie. Si cambia, por ejemplo su elemento interno
varía en valor, entonces esos cambios también estarán presentes en el nuevo objeto de serie.
>>> s3
01
12
23
34
96
Página 113
dtype: int64
>>> arr [2] = -2
>>> s3
01
12
2-2
34
dtype: int64
Como puede ver en este ejemplo, al cambiar el tercer elemento de la matriz arr,
también modificó el elemento correspondiente en la serie s3.
Filtrar valores
Gracias a la elección de la biblioteca NumPy como base de la biblioteca pandas y, como
Como resultado, para sus estructuras de datos, muchas operaciones que son aplicables a matrices NumPy son
extendido a la serie. Uno de ellos es el filtrado de valores contenidos en la estructura de datos.
a través de las condiciones.
Por ejemplo, si necesita saber qué elementos de la serie son mayores que 8,
escribe lo siguiente:
>>> s [s> 8]
a 12
d9
dtype: int64
Operaciones y funciones matemáticas

Otras operaciones como operadores (+, -, * y /) y funciones matemáticas que son
aplicable a la matriz NumPy se puede extender a la serie.
Simplemente puede escribir la expresión aritmética para los operadores.
>>> s / 2
un 6.0
b -2,0
c 3,5
d 4.5
dtype: float64
97
Página 114
Sin embargo, con las funciones matemáticas NumPy, debe especificar la función
referenciado con np y la instancia de la serie pasada como argumento.
>>> np.log (s)

a 2.484907
b 0,000000
c 1.945910
d 2.197225
dtype: float64
Evaluación de valles
A menudo hay valores duplicados en una serie. Entonces puede que necesite tener más
información sobre las muestras, incluida la existencia de duplicados y si
cierto valor está presente en la serie.
En este sentido, puede declarar una serie en la que hay muchos valores duplicados.
>>> serd = pd.Series ([1,0,2,1,2,3], index = ['blanco', 'blanco', 'azul', 'verde', '
verde amarillo'])
>>> serd
blanco 1
blanco 0
azul 2
verde 1
verde 2
amarillo 3
dtype: int64
Para conocer todos los valores contenidos en la serie, excluidos los duplicados, puede utilizar
la función única (). El valor de retorno es una matriz que contiene los valores únicos en el
serie, aunque no necesariamente en orden.
>>> serd.unique ()
matriz ([1, 0, 2, 3], dtype = int64)
Una función que es similar a unique () es value_counts (), que no solo devuelve
valores únicos, pero también calcula las ocurrencias dentro de una serie.
98
Página 115
>>> serd.value_counts ()
22
12
31
01
dtype: int64
Finalmente, isin () evalúa la pertenencia, es decir, la lista de valores dada. Esta

La función le dice si los valores están contenidos en la estructura de datos. Valores booleanos que son
devuelto puede ser muy útil al filtrar datos en una serie o en una columna de un marco de datos.
>>> serd.isin ([0,3])

blanco falso
blanco verdadero
azul falso
verde falso
verde falso
amarillo verdadero
dtype: bool
>>> serd [serd.isin ([0,3])]
blanco 0
amarillo 3
dtype: int64
Valores NaN
Como puede ver en el caso anterior, intentamos ejecutar el logaritmo de un número negativo
y recibió NaN como resultado. Este valor específico NaN (no es un número) se usa en pandas
estructuras de datos para indicar la presencia de un campo vacío o algo que no
definible numéricamente.
Generalmente, estos valores de NaN son un problema y deben gestionarse de alguna manera,
especialmente durante el análisis de datos. Estos datos a menudo se generan al extraer datos.
de una fuente cuestionable o cuando faltan datos en la fuente. Además, como tú
acabamos de ver, los valores de NaN también se pueden generar en casos especiales, como cálculos
de logaritmos de valores negativos, o excepciones durante la ejecución de algún cálculo
o función. En capítulos posteriores, verá cómo aplicar diferentes estrategias para abordar la
problema de los valores de NaN.
99
Página 116
Sin embargo, a pesar de su naturaleza problemática, los pandas le permiten definir explícitamente
NaN y agréguelos a una estructura de datos, como una serie. Dentro de la matriz que contiene el
valores, ingrese np.NaN donde quiera definir un valor faltante.
>>> s2 = pd.Series ([5, -3, np.NaN, 14])

>>> s2
0 5,0
1 -3,0
2 NaN
3 14.0
dtype: float64
Las funciones isnull () y notnull () son muy útiles para identificar los índices
sin valor.
>>> s2.isnull ()
0 falso
1 falso
2 verdadero
3 falso
dtype: bool
>>> s2.notnull ()
0 verdadero
1 verdadero
2 falso
3 verdadero
dtype: bool
De hecho, estas funciones devuelven dos series con valores booleanos que contienen True
y Valores falsos, dependiendo de si el artículo tiene un valor NaN o menos. El isnull ()
la función devuelve True en los valores NaN de la serie; inversamente, la función notnull ()
devuelve True si no son NaN. Estas funciones a menudo se colocan dentro de filtros para hacer una
condición.
>>> s2 [s2.notnull ()]

0 5,0
1 -3,0
3 14.0
100
Página 117
dtype: float64
>>> s2 [s2.isnull ()]
2 NaN
dtype: float64
Series como diccionarios

Una forma alternativa de pensar en una serie es pensar en ella como un diccionario de objeto. Esta
La similitud también se explota durante la definición de una serie de objetos. De hecho, puede crear
una serie de un dict previamente definido.
>>> mydict = {'rojo': 2000, 'azul': 1000, 'amarillo': 500,

'naranja': 1000}
>>> myseries = pd.Series (mydict)
>>> misterios
rojo 2000
azul 1000
amarillo 500
naranja 1000
dtype: int64
Como puede ver en este ejemplo, la matriz del índice se llena con las claves mientras
los datos se llenan con los valores correspondientes. También puede definir los índices de la matriz
por separado. En este caso, controlar la correspondencia entre las claves del dict y
Se ejecutará una matriz de índices de etiquetas. Si hay una discrepancia, los pandas agregarán el valor de NaN.
>>> colores = ['rojo', 'amarillo', 'naranja', 'azul', 'verde']

>>> myseries = pd.Series (mydict, index = colores)
>>> misterios
rojo 2000.0
amarillo 500.0
naranja 1000.0
azul 1000.0
verde NaN
dtype: float64
101
Página 118
Operaciones entre series

Hemos visto cómo realizar operaciones aritméticas entre series y valores escalares.
Lo mismo es posible realizando operaciones entre dos series, pero en este caso
incluso las etiquetas entran en juego.
De hecho, uno de los grandes potenciales de este tipo de estructuras de datos es que las series pueden
alinear los datos tratados de manera diferente entre ellos identificando sus etiquetas correspondientes.
En el siguiente ejemplo, agrega dos series que tienen solo algunos elementos en común
con la etiqueta.
>>> mydict2 = {'rojo': 400, 'amarillo': 1000, 'negro': 700}

>>> myseries2 = pd.Series (mydict2)
>>> myseries + myseries2
negro NaN
azul NaN
verde NaN
naranja NaN
rojo 2400.0
amarillo 1500.0
dtype: float64
Obtiene una nueva serie de objetos en la que solo se agregan los elementos con la misma etiqueta.
Todas las demás etiquetas presentes en una de las dos series aún se agregan al resultado pero tienen un NaN
valor.
El DataFrame
El marco de datos es una estructura de datos tabular muy similar a una hoja de cálculo. Estos datos
La estructura está diseñada para extender la serie a múltiples dimensiones. De hecho, el marco de datos
consiste en una colección ordenada de columnas (ver Figura 4-2), cada uno de los cuales puede contener
un valor de un tipo diferente (numérico, de cadena, booleano, etc.).
102
Página 119
Figura 4-2. La estructura del marco de datos
A diferencia de las series, que tienen una matriz de índice que contiene etiquetas asociadas con cada
elemento, el marco de datos tiene dos matrices de índice. La primera matriz de índice, asociada con
las líneas, tiene funciones muy similares a la matriz de índice en serie. De hecho, cada etiqueta es
asociado con todos los valores de la fila. La segunda matriz contiene una serie de etiquetas,
cada uno asociado con una columna en particular.
Un marco de datos también puede entenderse como un dictado de serie, donde las claves son las
los nombres de las columnas y los valores son las series que formarán las columnas del marco de datos.
Además, todos los elementos de cada serie se asignan de acuerdo con una matriz de etiquetas,
llamado el índice .
Definición de un marco de datos

La forma más común de crear un nuevo marco de datos es precisamente pasar un objeto dict al
Constructor de DataFrame (). Este objeto dict contiene una clave para cada columna que desee
a definir, con una matriz de valores para cada uno de ellos.
>>> datos = {'color': ['azul', 'verde', 'amarillo', 'rojo', 'blanco'],

'objeto': ['bola', 'bolígrafo', 'lápiz', 'papel', 'taza'],
'precio': [1.2,1.0,0.6,0.9,1.7]}
>>> marco = pd.DataFrame (datos)
>>> marco
precio del objeto de color
0 bola azul 1.2
1 bolígrafo verde 1.0
103
Página 120
2 lápices amarillos 0.6

3 papel rojo 0.9
4 taza blanca 1.7
Si el objeto dict desde el que desea crear un marco de datos contiene más datos
de lo que le interesa, puede hacer una selección. En el constructor del marco de datos,
puede especificar una secuencia de columnas usando la opción de columnas. Las columnas serán
creados en el orden de la secuencia independientemente de cómo estén contenidos en el dict
objeto.
>>> frame2 = pd.DataFrame (datos, columnas = ['objeto', 'precio'])

>>> marco2
precio del objeto
0 bola 1.2
1 bolígrafo 1.0
2 lápices 0.6
3 papel 0.9
4 tazas 1.7
Incluso para objetos de marco de datos, si las etiquetas no se especifican explícitamente en la matriz de índice,
pandas asigna automáticamente una secuencia numérica a partir de 0. En su lugar, si desea
asignar etiquetas a los índices de un marco de datos, tienes que usar la opción de índice y asignarlo
una matriz que contiene las etiquetas.
>>> frame2 = pd.DataFrame (datos, índice = ['uno', 'dos', 'tres', 'cuatro', 'cinco'])
>>> marco2
una bola azul 1.2
dos bolígrafos verdes 1.0
tres lápiz amarillo 0.6
cuatro papel rojo 0.9
cinco taza blanca 1.7
Ahora que hemos introducido las dos nuevas opciones llamadas índice y columnas, es
Es fácil imaginar una forma alternativa de definir un marco de datos. En lugar de usar un objeto dict,
puede definir tres argumentos en el constructor, en el siguiente orden: una matriz de datos,
una matriz que contiene las etiquetas asignadas a la opción de índice, y una matriz que contiene la
nombres de las columnas asignadas a la opción de columnas.
104
Página 121
En muchos ejemplos, como verá a partir de ahora en este libro, para crear una matriz de
valores de forma rápida y sencilla, puede usar np.arange (16) .reshape ((4,4)), que genera
una matriz 4x4 de números que aumentan de 0 a 15.
>>> frame3 = pd.DataFrame (np.arange (16) .reshape ((4,4)),

... índice = ['rojo', 'azul', 'amarillo', 'blanco'],
... columnas = ['bola', 'bolígrafo', 'lápiz', 'papel'])
>>> marco3
bolígrafo lápiz papel
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
Seleccionar elementos
Si desea saber el nombre de todas las columnas de un marco de datos, puede especificar el
atributo de columnas en la instancia del objeto de marco de datos.
>>> frame.columns
Índice (['colores', 'objeto', 'precio'], dtype = 'objeto')
De manera similar, para obtener la lista de índices, debe especificar el atributo de índice.
>>> frame.index
RangeIndex (inicio = 0, parada = 5, paso = 1)
También puede obtener el conjunto completo de datos contenidos dentro de la estructura de datos utilizando el
atributo de valores.
>>> frame.values
array ([['azul', 'bola', 1.2],
['verde', 'lápiz', 1.0],
['amarillo', 'lápiz', 0,6],
['rojo', 'papel', 0.9],
['blanco', 'taza', 1.7]], dtype = objeto)
105
Página 122
O, si está interesado en seleccionar solo el contenido de una columna, puede escribir el

nombre de la columna.
>>> marco ['precio']

0 1,2
1 1.0
2 0,6
3 0,9
4 1,7
Nombre: precio, dtipo: float64
Como puede ver, el valor de retorno es un objeto de serie. Otra forma de hacer esto es usar el
nombre de columna como atributo de la instancia del marco de datos.
>>> frame.price
0 1,2
1 1.0
2 0,6
3 0,9
4 1,7
Nombre: precio, dtipo: float64
Para filas dentro de un marco de datos, es posible usar el atributo loc con el índice
valor de la fila que desea extraer.
>>> frame.loc [2]

color amarillo
lápiz objeto
precio 0,6
Nombre: 2, dtype: object
El objeto devuelto es nuevamente una serie en la que los nombres de las columnas tienen
se convierten en la etiqueta del índice de la matriz y los valores se han convertido en los datos de la serie.
Para seleccionar varias filas, especifique una matriz con la secuencia de filas para insertar:
>>> frame.loc [[2,4]]

4 taza blanca 1.7
106
Página 123
Si necesita extraer una parte de un DataFrame, seleccione las líneas que desea
extracto, puede utilizar los números de referencia de los índices. De hecho, puede considerar un
fila como una parte de un marco de datos que tiene el índice de la fila como fuente (en el siguiente 0)
value y la línea encima del que queremos como segundo valor (en el siguiente).
>>> fotograma [0: 1]

0 bola azul 1.2
Como puede ver, el valor de retorno es un marco de datos de objeto que contiene una sola fila. Si tu
desea más de una línea, debe ampliar el rango de selección.
>>> fotograma [1: 3]

Finalmente, si lo que desea lograr es un valor único dentro de un marco de datos, primero use
el nombre de la columna y luego el índice o la etiqueta de la fila.
>>> marco ['objeto'] [3]

'papel'
Asignar valores
Una vez que comprenda cómo acceder a los diversos elementos que componen un marco de datos,
siga la misma lógica para agregar o cambiar los valores en él.
Por ejemplo, ya ha visto que dentro de la estructura del marco de datos, una matriz
de índices se especifica mediante el atributo de índice, y la fila que contiene el nombre del
columnas se especifica con el atributo de columnas. Bueno, también puedes asignar una etiqueta, usando
el atributo de nombre, a estas dos subestructuras para identificarlas.
>>> frame.index.name = 'id'

>>> frame.columns.name = 'elemento'
>>> marco
107
Página 124
artículo color precio del objeto

carné de identidad
0 bola azul 1.2
3 papel rojo 0.9
4 taza blanca 1.7
Una de las mejores características de las estructuras de datos de los pandas es su alta flexibilidad. En
De hecho, siempre puede intervenir en cualquier nivel para cambiar la estructura de datos internos. por
Por ejemplo, una operación muy común es agregar una nueva columna.
Puede hacer esto simplemente asignando un valor a la instancia del marco de datos y
especificando un nuevo nombre de columna.
>>> marco ['nuevo'] = 12

>>> marco
colores objeto precio nuevo
0 bola azul 1,2 12
1 bolígrafo verde 1,0 12
2 lápices amarillos 0,6 12
3 papel rojo 0,9 12
4 taza blanca 1,7 12
Como puede ver en este resultado, hay una nueva columna llamada nueva con el valor
dentro de 12 replicados para cada uno de sus elementos.
Sin embargo, si desea actualizar el contenido de una columna, debe usar una matriz.
>>> marco ['nuevo'] = [3.0,1.3,2.2,0.8,1.1]

>>> marco
precio del objeto de color nuevo
0 bola azul 1,2 3,0
1 bolígrafo verde 1,0 1,3
2 lápices amarillos 0,6 2,2
3 papel rojo 0,9 0,8
4 taza blanca 1,7 1,1
Puede seguir un enfoque similar si desea actualizar una columna completa, por
ejemplo, usando la función np.arange () para actualizar los valores de una columna con un
secuencia predeterminada.
108
Página 125
Las columnas de un marco de datos también se pueden crear asignando una serie a una de ellas,
por ejemplo, especificando una serie que contiene una serie creciente de valores a través del
uso de np.arange ().
>>> ser = pd.Series (np. rango (5))

>>> ser
00
11
22
33
44
dtype: int64
>>> marco ['nuevo'] = ser
>>> marco
0 bola azul 1,2 0
1 bolígrafo verde 1,0 1
2 lápiz amarillo 0,6 2
3 papel rojo 0,9 3
4 taza blanca 1,7 4
Finalmente, para cambiar un solo valor, simplemente seleccione el elemento y le dé el nuevo valor.
>>> fotograma ['precio'] [2] = 3.3
Membresía de valor
Ya ha visto la función isin () aplicada a la serie para determinar la
pertenencia a un conjunto de valores. Bueno, esta característica también es aplicable a objetos de marco de datos.
>>> frame.isin ([1.0, 'lápiz'])

0 Falso Falso Falso Falso
1 Falso Verdadero Verdadero Verdadero
109
Página 126
Obtiene un marco de datos que contiene valores booleanos, donde True indica valores que
conocer la membresía. Si pasa el valor devuelto como condición, obtendrá una
nuevo marco de datos que contiene solo los valores que satisfacen la condición.
>>> marco [marco.isin ([1.0, 'lápiz'])]

0 NaN NaN NaN NaN
1 pluma de NaN 1,0 1,0
2 NaN NaN NaN NaN
3 NaN NaN NaN NaN
4 NaN NaN NaN NaN
Eliminar una columna

Si desea eliminar una columna completa y todo su contenido, use el comando del.
>>> del frame ['nuevo']

>>> marco
precio del objeto de colores
0 bola azul 1.2
2 lápiz amarillo 3.3
3 papel rojo 0.9
4 taza blanca 1.7
Filtración
Incluso cuando se trata de un marco de datos, puede aplicar el filtrado mediante la aplicación de ciertos
condiciones. Por ejemplo, digamos que desea obtener todos los valores menores que un cierto número, por
ejemplo 1.2.
>>> cuadro [cuadro <1.2]

>>> marco
precio del objeto de colores
0 bola azul NaN
2 lápices amarillos NaN
3 papel rojo 0.9
4 taza blanca NaN
110
Página 127
Obtendrá un marco de datos que contiene valores inferiores a 1.2, manteniendo su original
posición. Todos los demás serán reemplazados por NaN.
DataFrame de dictado anidado

Una estructura de datos muy común utilizada en Python es un dictado anidado, como sigue:
nestdict = {'red': {2012: 22, 2013: 33},

'blanco': {2011: 13, 2012: 22, 2013: 16},
'azul': {2011: 17, 2012: 27, 2013: 18}}
Esta estructura de datos, cuando se pasa directamente como un argumento al DataFrame ()

constructor, será interpretado por pandas para tratar las claves externas como nombres de columna y
claves internas como etiquetas para los índices.
Durante la interpretación de la estructura anidada, es posible que no todos los campos
encontrar una pareja exitosa. pandas compensa esta inconsistencia agregando el NaN
valor a valores perdidos.
>>> nestdict = {'red': {2012: 22, 2013: 33},
... 'blanco': {2011: 13, 2012: 22, 2013: 16},
... 'azul': {2011: 17, 2012: 27, 2013: 18}}
>>> marco2 = pd.DataFrame (nestdict)
>>> marco2
azul rojo blanco
2011 17 NaN 13
2012 27 22,0 22
2013 18 33,0 16
Transposición de un marco de datos

Una operación que puede necesitar cuando se trata de estructuras de datos tabulares es
transposición (es decir, las columnas se convierten en filas y las filas en columnas). pandas permite
que lo haga de una manera muy sencilla. Puede obtener la transposición del marco de datos mediante
agregando el atributo T a su aplicación.
>>> marco2.T
2011 2012 2013
azul 17,0 27,0 18,0
rojo NaN 22,0 33,0
blanco 13,0 22,0 16,0
111
Página 128
Los objetos de índice

Ahora que sabe qué son la serie y el marco de datos y cómo están estructurados,
Es probable que pueda percibir las peculiaridades de estas estructuras de datos. De hecho, la mayoría de
sus excelentes características se deben a la presencia de un objeto Index que está integrado
en estas estructuras de datos.
Los objetos de índice son responsables de las etiquetas en los ejes y otros metadatos como
el nombre de los ejes. Ya has visto cómo se convierte una matriz que contiene etiquetas
en un objeto de índice y que necesita especificar la opción de índice en el constructor.
>>> ser = pd.Series ([5,0,3,8,4], index = ['rojo', 'azul', 'amarillo', 'blanco', 'verde'])
>>> índice de ser.
Índice (['rojo', 'azul', 'amarillo', 'blanco', 'verde'], dtype = 'objeto')
A diferencia de todos los demás elementos de las estructuras de datos de pandas (series y marcos de datos),
los objetos Index son inmutables. Una vez declaradas, no se pueden modificar. Esto garantiza
su intercambio seguro entre las diversas estructuras de datos.
Cada objeto de índice tiene varios métodos y propiedades que son útiles cuando
Necesito conocer los valores que contienen.
Métodos en índice
Hay algunos métodos específicos para índices disponibles para obtener información sobre
índices de una estructura de datos. Por ejemplo, idmin () e idmax () son dos funciones que
devuelve, respectivamente, el índice con el valor más bajo y el índice con el valor más alto.
>>> ser.idxmin ()
'azul'
>>> ser.idxmax ()
'blanco'
Índice con etiquetas duplicadas

Hasta ahora, ha cumplido todos los casos en los que los índices dentro de una única estructura de datos tienen un
etiqueta única. Aunque muchas funciones requieren esta condición para ejecutarse, esta condición es
no es obligatorio en las estructuras de datos de los pandas.
112
Página 129
Defina a modo de ejemplo, una serie con algunas etiquetas duplicadas.
>>> serd = pd.Series (rango (6), índice = ['blanco', 'blanco', 'azul', 'verde',
'verde amarillo'])
>>> serd
blanco 0
blanco 1
azul 2
verde 3
verde 4
amarillo 5
dtype: int64
En cuanto a la selección de elementos en una estructura de datos, si hay más valores en

correspondencia de la misma etiqueta, obtendrá una serie en lugar de un solo elemento.
>>> serd ['blanco']

blanco 0
blanco 1
dtype: int64
La misma lógica se aplica al marco de datos, con índices duplicados que devolverán el
marco de datos.
Con estructuras de datos pequeñas, es fácil identificar cualquier índice duplicado, pero si el
la estructura se hace gradualmente más grande, esto comienza a ser difícil. En este sentido, los pandas
le proporciona el atributo is_unique que pertenece a los objetos Index. Este atributo
le dirá si hay índices con etiquetas duplicadas dentro de los datos de la estructura (ambos
series y marco de datos).
>>> serd.index.is_unique
Falso
>>> frame.index.is_unique
Cierto
113
Página 130
Otras funcionalidades en índices

En comparación con las estructuras de datos comúnmente utilizadas con Python, vio que los pandas, como
además de aprovechar la calidad de alto rendimiento que ofrecen los arreglos NumPy,
elegido para integrar índices en ellos.
Esta elección ha resultado ser algo exitosa. De hecho, a pesar de la enorme flexibilidad
dada por las estructuras dinámicas que ya existen, utilizando la referencia interna a la
estructura, como la que ofrecen las etiquetas, permite a los desarrolladores que deben realizar
operaciones para realizarlas de forma más sencilla y directa.
Esta sección analiza en detalle una serie de características básicas que aprovechan esta
mecanismo.
• Reindexación
• Dejar caer
• Alineación
Reindexar
Anteriormente se dijo que una vez que se declara en una estructura de datos, el objeto Index
no puede ser cambiado. Esto es cierto, pero al ejecutar una reindexación, también puede superar
este problema.
De hecho, es posible obtener una nueva estructura de datos a partir de una existente donde
Las reglas de indexación se pueden definir de nuevo.
>>> ser = pd.Series ([2,5,7,4], index = ['uno', 'dos', 'tres', 'cuatro'])

>>> ser
uno 2
dos 5
tres 7
cuatro 4
dtype: int64
Para reindexar esta serie, pandas le proporciona la función reindex ().

Esta función crea un nuevo objeto de serie con los valores de la serie anterior
reorganizado de acuerdo con la nueva secuencia de etiquetas.
114
Página 131
Durante la reindexación, es posible cambiar el orden de la secuencia de índices,

elimine algunos de ellos o agregue otros nuevos. En el caso de una nueva etiqueta, pandas agrega NaN como el
valor correspondiente.
>>> ser.reindex (['tres', 'cuatro', 'cinco', 'uno'])

tres 7.0
cuatro 4.0
cinco NaN
uno 2.0
dtype: float64
Como puede ver en el valor devuelto, el orden de las etiquetas ha sido completamente
reorganizado. Se ha eliminado el valor correspondiente a la etiqueta dos y se ha eliminado una nueva etiqueta.
llamado cinco está presente en la serie.
Sin embargo, para medir el proceso de reindexación, se puede definir la lista de etiquetas.
incómodo, especialmente con un marco de datos grande. Entonces podrías usar algún método que permita
para completar o interpolar valores automáticamente.
Para comprender mejor el funcionamiento de este modo de reindexación automática, defina
la siguiente serie.
>>> ser3 = pd.Series ([1,5,6,3], índice = [0,3,5,6])

>>> ser3
01
35
56
63
dtype: int64
Como puede ver en este ejemplo, la columna de índice no es una secuencia perfecta de
números; de hecho, faltan algunos valores (1, 2 y 4). Una necesidad común sería
sea realizar la interpolación para obtener la secuencia completa de números. A
Para lograr esto, utilizará la reindexación con la opción de método establecida en ffill. Además, tú
necesita establecer un rango de valores para los índices. En este caso, para especificar un conjunto de valores entre 0
y 5, puede usar range (6) como argumento.
>>> ser3.reindex (rango (6), método = 'ffill')
01
11
115
Página 132
21
35
45
56
dtype: int64
Como puede ver en el resultado, los índices que no estaban presentes en la serie original
fueron agregados. Por interpolación, aquellos con el índice más bajo de la serie original tienen
asignado como valores. De hecho, los índices 1 y 2 tienen el valor 1, que pertenece a
índice 0.
Si desea que este valor de índice se asigne durante la interpolación, debe usar
el método bfill.
>>> ser3.reindex (rango (6), método = 'bfill')

01
15
25
35
46
56
dtype: int64
En este caso, el valor asignado a los índices 1 y 2 es el valor 5, que pertenece

al índice 3.
Al extender los conceptos de reindexar con series al marco de datos, puede tener un
reordenamiento no solo para los índices (filas), sino también con respecto a las columnas, o incluso
ambos. Como se mencionó anteriormente, es posible agregar una nueva columna o índice, pero como
hay valores perdidos en la estructura de datos original, los pandas les agregan valores NaN.
>>> frame.reindex (rango (5), método = 'relleno', columnas = ['colores', 'precio', 'nuevo',
'objeto'])
colores precio nuevo objeto
0 azul 1.2 bola azul
1 bolígrafo verde 1.0 verde
2 lápices amarillos 3.3 amarillos
3 papel rojo 0,9 rojo
4 taza blanca 1.7 blanca
116
Página 133
Goteante
Otra operación que está conectada a los objetos de índice está cayendo. Eliminar una fila o un
columna se vuelve simple, debido a las etiquetas utilizadas para indicar los índices y nombres de columna.
También en este caso, pandas proporciona una función específica para esta operación, llamada
soltar(). Este método devolverá un nuevo objeto sin los elementos que desea eliminar.
Por ejemplo, tomemos el caso en el que queremos eliminar un solo elemento de una serie. A
Para ello, defina una serie genérica de cuatro elementos con cuatro etiquetas distintas.
>>> ser = pd.Series (np. rango (4.), índice = ['rojo', 'azul', 'amarillo', 'blanco'])
>>> ser
rojo 0.0
azul 1.0
amarillo 2.0
blanco 3.0
dtype: float64
Ahora diga, por ejemplo, que desea eliminar el elemento correspondiente a la etiqueta
amarillo. Simplemente especifique la etiqueta como un argumento de la función drop () para eliminarla.
>>> ser.drop ('amarillo')

rojo 0.0
azul 1.0
blanco 3.0
dtype: float64
Para eliminar más elementos, simplemente pase una matriz con las etiquetas correspondientes.
>>> ser.drop (['azul', 'blanco'])

rojo 0.0
amarillo 2.0
dtype: float64
En cambio, con respecto al marco de datos, los valores se pueden eliminar haciendo referencia a las etiquetas
de ambos ejes. Declare el siguiente marco a modo de ejemplo.
>>> marco = pd.DataFrame (np.arange (16) .reshape ((4,4)),

117
Página 134
>>> marco
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
Para eliminar filas, simplemente pase los índices de las filas.
>>> frame.drop (['azul', 'amarillo'])

rojo 0 1 2 3
blanco 12 13 14 15
Para eliminar columnas, siempre debe especificar los índices de las columnas, pero
debe especificar el eje desde el cual eliminar los elementos, y esto se puede hacer usando el
opción de eje. Entonces, para hacer referencia a los nombres de las columnas, debe especificar eje = 1.
>>> frame.drop (['bolígrafo', 'lápiz'], eje = 1)

bola de papel
rojo 03
azul 4 7
amarillo 8 11
blanco 12 15
Alineación aritmética y de datos

Quizás la característica más poderosa que involucra los índices en una estructura de datos es que
los pandas pueden alinear índices que provienen de dos estructuras de datos diferentes. Esto es especialmente
verdadero cuando está realizando una operación aritmética en ellos. De hecho, durante estos
operaciones, no solo los índices entre las dos estructuras pueden estar en un orden diferente,
pero también pueden estar presentes solo en una de las dos estructuras.
Como puede ver en los ejemplos que siguen, los pandas demuestran ser muy poderosos en
alineando índices durante estas operaciones. Por ejemplo, puede comenzar a considerar dos
serie en la que se definen, respectivamente, dos matrices de etiquetas que no coinciden perfectamente
El uno al otro.
>>> s1 = pd.Series ([3,2,5,1], ['blanco', 'amarillo', 'verde', 'azul'])

>>> s2 = pd.Series ([1,4,7,2,1], ['blanco', 'amarillo', 'negro', 'azul', 'marrón'])
118
Página 135
Ahora, entre las diversas operaciones aritméticas, considere la suma simple. Como puedas
ver de las dos series que acabamos de declarar, algunas etiquetas están presentes en ambas, mientras que otras etiquetas
están presentes solo en uno de los dos. Cuando las etiquetas están presentes en ambos operadores, su
Se agregarán valores, mientras que en el caso contrario, también se mostrarán en el resultado
(nueva serie), pero con el valor NaN.
>>> s1 + s2
negro NaN
azul 3.0
marrón NaN
verde NaN
blanco 4.0
amarillo 6.0
dtype: float64
En el caso del marco de datos, aunque puede parecer más complejo, la alineación
sigue el mismo principio, pero se lleva a cabo tanto para las filas como para las columnas.
>>> marco1 = pd.DataFrame (np.arange (16) .reshape ((4,4)),

>>> marco2 = pd.DataFrame (np.arange (12) .reshape ((4,3)),
... índice = ['azul', 'verde', 'blanco', 'amarillo'],
... columnas = ['taza', 'bolígrafo', 'bola'])
>>> marco1
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
>>> marco2
taza bolígrafo bola
azul 0 1 2
verde 3 4 5
blanco 6 7 8
amarillo 9 10 11
119
Página 136
>>> marco1 + marco2

bola taza papel bolígrafo lápiz
azul 6,0 NaN NaN 6,0 NaN
verde NaN NaN NaN NaN NaN
rojo NaN NaN NaN NaN NaN
blanco 20,0 NaN NaN 20,0 NaN
amarillo 19,0 NaN NaN 19,0 NaN
Operaciones entre estructuras de datos

Ahora que está familiarizado con las estructuras de datos, como series y marcos de datos,
he visto cómo se pueden realizar varias operaciones elementales en ellos, es hora de ir
a operaciones que involucren dos o más de estas estructuras.
Por ejemplo, en la sección anterior, vio cómo se aplican los operadores aritméticos
entre dos de estos objetos. Ahora en esta sección profundizarás más el tema de
operaciones que se pueden realizar entre dos estructuras de datos.
Métodos aritméticos flexibles

Acaba de ver cómo usar operadores matemáticos directamente en los datos de pandas.
estructuras. Las mismas operaciones también se pueden realizar utilizando métodos apropiados,
llamados métodos aritméticos flexibles.
• agregar ()
• sub ()
• div ()
• mul ()
Para llamar a estas funciones, debe utilizar una especificación diferente a la

está acostumbrado a tratar con operadores matemáticos. Por ejemplo, en lugar de escribir una suma
entre dos marcos de datos, como frame1 + frame2, debe utilizar el siguiente formato:
>>> frame1.add (frame2)

120
Página 137

Como puede ver, los resultados son los mismos que obtendría con el operador de suma +.
También puede observar que si los índices y los nombres de las columnas difieren mucho de una serie a otra
otro, se encontrará con un nuevo marco de datos lleno de valores NaN. Verás más tarde en
este capítulo cómo manejar este tipo de datos.
Operaciones entre DataFrame y Series

Volviendo a los operadores aritméticos, pandas le permite realizar transacciones
entre diferentes estructuras. Por ejemplo, entre un marco de datos y una serie. por
Por ejemplo, puede definir estas dos estructuras de la siguiente manera.

>>> marco
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
>>> ser = pd.Series (np.arange (4), index = ['bola', 'bolígrafo', 'lápiz', 'papel'])
>>> ser
bola 0
bolígrafo 1
lápiz 2
papel 3
dtype: int64
Las dos estructuras de datos recién definidas se han creado específicamente para que
los índices de serie coinciden con los nombres de las columnas del marco de datos. De esta manera puedes
Aplicar una operación directa.
121
Página 138
>>> marco - ser

rojo 0000
azul 4 4 4 4
amarillo 8 8 8 8
blanco 12 12 12 12
Como puede ver, los elementos de la serie se restan de los valores de la

marco de datos correspondiente al mismo índice en la columna. El valor se resta por
todos los valores de la columna, independientemente de su índice.
Si un índice no está presente en una de las dos estructuras de datos, el resultado será un nuevo
columna con ese índice solo que todos sus elementos serán NaN.
>>> ser ['taza'] = 9

>>> ser
bola 0
bolígrafo 1
lápiz 2
papel 3
taza 9
dtype: int64
>>> marco - ser
rojo 0 NaN 0 0 0
azul 4 NaN 4 4 4
amarillo 8 NaN 8 8 8
blanco 12 NaN 12 12 12
Aplicación y asignación de funciones

Esta sección cubre las funciones de la biblioteca de pandas.
122
Página 139
Funciones por elemento

La biblioteca de pandas se basa en los cimientos de NumPy y luego extiende muchos de sus
características adaptándolas a nuevas estructuras de datos como series y dataframe. Entre estos
son las funciones universales , llamadas ufunc. Esta clase de funciones opera por elemento en
la estructura de datos.

>>> marco
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
Por ejemplo, puede calcular la raíz cuadrada de cada valor en el marco de datos
utilizando NumPy np.sqrt ().
>>> np.sqrt (marco)

rojo 0.000000 1.000000 1.414214 1.732051
azul 2.000000 2.236068 2.449490 2.645751
amarillo 2.828427 3.000000 3.162278 3.316625
blanco 3.464102 3.605551 3.741657 3.872983
Funciones por fila o columna

La aplicación de las funciones no se limita a las funciones de ufunc, sino que también incluye
los definidos por el usuario. El punto importante es que operan en una dimensión unidimensional.
matriz, dando como resultado un solo número. Por ejemplo, puede definir una función lambda
que calcula el rango cubierto por los elementos de una matriz.
>>> f = lambda x: x.max () - x.min ()
123
Página 140
También es posible definir la función de esta manera:
>>> def f (x):

... devuelve x.max () - x.min ()
...
Con la función apply (), puede aplicar la función que acaba de definir en el marco de datos.
>>> frame.apply (f)

bola 12
bolígrafo 12
lápiz 12
papel 12
dtype: int64
El resultado esta vez es un valor para la columna, pero si prefiere aplicar el

función por fila en lugar de por columna, debe establecer la opción de eje en 1.
>>> frame.apply (f, eje = 1)

rojo 3
azul 3
amarillo 3
blanco 3
dtype: int64
No es obligatorio que el método apply () devuelva un valor escalar. También puede
devolver una serie. Un caso útil sería extender la aplicación a muchas funciones.
simultaneamente. En este caso, tendremos dos o más valores para cada característica aplicada.
Esto se puede hacer definiendo una función de la siguiente manera:
>>> def f (x):

... return pd.Series ([x.min (), x.max ()], index = ['min', 'max'])
...
Luego, aplica la función como antes. Pero en este caso como un objeto te devolvió
obtener un marco de datos en lugar de una serie, en el que habrá tantas filas como valores
devuelto por la función.
124
Página 141
>>> frame.apply (f)

min 0 1 2 3
máx 12 13 14 15
Funciones estadísticas
La mayoría de las funciones estadísticas para matrices siguen siendo válidas para el marco de datos, por lo que
La función apply () ya no es necesaria. Por ejemplo, funciones como sum () y
mean () puede calcular la suma y el promedio, respectivamente, de los elementos contenidos
dentro de un marco de datos.
>>> frame.sum ()
bola 24
bolígrafo 28
lápiz 32
documento 36
dtype: int64
>>> frame.mean ()
pelota 6.0
bolígrafo 7.0
lápiz 8.0
papel 9.0
dtype: float64
También hay una función llamada describe () que le permite obtener un resumen
estadísticas a la vez.
>>> frame.describe ()
pelota bolígrafo lápiz papel
recuento 4,000000 4,000000 4,000000 4,000000
media 6,000000 7,000000 8,000000 9,000000
estándar 5.163978 5.163978 5.163978 5.163978
min 0.000000 1.000000 2.000000 3.000000
25% 3.000000 4.000000 5.000000 6.000000
50% 6,000000 7,000000 8,000000 9,000000
75% 9,000000 10,000000 11,000000 12,000000
máx. 12.000000 13.000000 14.000000 15.000000
125
Página 142
Clasificación y clasificación
Otra operación fundamental que utiliza la indexación es la clasificación. Ordenar los datos es a menudo
una necesidad y es muy importante poder hacerlo fácilmente. pandas proporciona el sort_
función index (), que devuelve un nuevo objeto que es idéntico al inicio, pero en el que
los elementos están ordenados.
Comencemos viendo cómo se pueden ordenar los elementos de una serie. La operación es bastante trivial
ya que la lista de índices a ordenar es solo uno.
>>> ser = pd.Series ([5,0,3,8,4],

... índice = ['rojo', 'azul', 'amarillo', 'blanco', 'verde'])
>>> ser
rojo 5
azul 0
amarillo 3
blanco 8
verde 4
dtype: int64
>>> ser.sort_index ()
azul 0
verde 4
rojo 5
blanco 8
amarillo 3
dtype: int64
Como puede ver, los elementos se ordenaron en orden alfabético ascendente según su
etiquetas (de la A a la Z). Este es el comportamiento predeterminado, pero puede establecer el orden opuesto al
estableciendo la opción ascendente en Falso.
>>> ser.sort_index (ascendente = Falso)

amarillo 3
blanco 8
rojo 5
verde 4
azul 0
dtype: int64
126
Página 143
Con el marco de datos, la clasificación se puede realizar de forma independiente en cada uno de sus dos
ejes. Entonces, si desea ordenar por fila siguiendo los índices, simplemente continúe usando el
función sort_index () sin argumentos como has visto antes, o si prefieres ordenar
por columnas, debe establecer las opciones del eje en 1.

>>> marco
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
>>> frame.sort_index ()
azul 4 5 6 7
rojo 0123
blanco 12 13 14 15
amarillo 8 9 10 11
>>> frame.sort_index (eje = 1)
bolígrafo lápiz
rojo 0312
azul 4 7 5 6
amarillo 8 11 9 10
blanco 12 15 13 14
Hasta ahora, ha aprendido a ordenar los valores según los índices. Pero muy
a menudo, es posible que deba ordenar los valores contenidos en la estructura de datos. En este caso, usted
tienes que diferenciar dependiendo de si tienes que ordenar los valores de una serie o un
marco de datos.
Si desea ordenar la serie, debe usar la función sort_values ().
>>> ser.sort_values ()
azul 0
amarillo 3
verde 4
127
Página 144
rojo 5
blanco 8
dtype: int64
Si necesita ordenar los valores en un marco de datos, use la función sort_values () vista
anteriormente pero con la opción by. Luego tienes que especificar el nombre de la columna en
que ordenar.
>>> frame.sort_values (por = 'lápiz')

rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
Si los criterios de clasificación se basarán en dos o más columnas, puede asignar una matriz
que contiene los nombres de las columnas a la opción by.
>>> frame.sort_values (por = ['bolígrafo', 'lápiz'])

rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
La clasificación es una operación estrechamente relacionada con la clasificación. Consiste principalmente en asignar
un rango (es decir, un valor que comienza en 0 y luego aumenta gradualmente) a cada elemento del
serie. El rango se asignará comenzando desde el valor más bajo hasta el más alto.
>>> ser.rank ()
rojo 4.0
azul 1.0
amarillo 2.0
blanco 5.0
verde 3.0
dtype: float64
128
Página 145
El rango también se puede asignar en el orden en que los datos ya están en los datos.
estructura (sin una operación de clasificación). En este caso, simplemente agregue la opción de método con
el primer valor asignado.
>>> ser.rank (método = 'primero')

rojo 4.0
azul 1.0
amarillo 2.0
blanco 5.0
verde 3.0
dtype: float64
De forma predeterminada, incluso la clasificación sigue un orden ascendente. Para invertir este criterio, establezca el
opción ascendente a Falso.
>>> ser.rank (ascendente = Falso)

rojo 2.0
azul 5.0
amarillo 4.0
blanco 1.0
verde 3.0
dtype: float64
Correlación y covarianza
Dos cálculos estadísticos importantes son la correlación y la covarianza, expresadas en
pandas por las funciones corr () y cov (). Este tipo de cálculos normalmente implican
dos series.
>>> seq2 = pd.Series ([3,4,3,4,5,4,3,2], ['2006', '2007', '2008',

'2009', '2010', '2011', '2012', '2013'])
>>> seq = pd.Series ([1,2,3,4,4,3,2,1], ['2006', '2007', '2008',
'2009', '2010', '2011', '2012', '2013'])
>>> seq.corr (seq2)
0,7745966692414835
>>> seq.cov (seq2)
0.8571428571428571
129
Página 146
La covarianza y la correlación también se pueden aplicar a un solo marco de datos. En este caso,
devuelven sus matrices correspondientes en forma de dos nuevos objetos de marco de datos.
>>> frame2 = pd.DataFrame ([[1,4,3,6], [4,5,6,1], [3,3,1,5], [4,1,6,4]] ,

>>> marco2
rojo 1436
azul 4 5 6 1
amarillo 3 3 1 5
blanco 4 1 6 4
>>> frame2.corr ()
bola 1.000000 -0.276026 0.577350 -0.763763
bolígrafo -0.276026 1.000000 -0.079682 -0.361403
lápiz 0.577350 -0.079682 1.000000 -0.692935
papel -0,763763 -0,361403 -0,692935 1,000000
>>> frame2.cov ()
bola 2.000000 -0.666667 2.000000 -2.333333
bolígrafo -0.666667 2.916667 -0.333333 -1.333333
lápiz 2.000000 -0.333333 6.000000 -3.666667
papel -2.333333 -1.333333 -3.666667 4.666667
Usando el método corrwith (), puede calcular las correlaciones por pares entre
las columnas o filas de un marco de datos con una serie u otro marco de datos ().
>>> ser = pd.Series ([0,1,2,3,9],

>>> ser
rojo 0
azul 1
amarillo 2
blanco 3
verde 9
dtype: int64
130
Página 147
>>> frame2.corrwith (ser)

bola 0.730297
bolígrafo -0.831522
lápiz 0.210819
papel -0.119523
dtype: float64
>>> frame2.corrwith (frame)
bola 0.730297
bolígrafo -0.831522
lápiz 0.210819
papel -0.119523
dtype: float64
Datos "No es un número"

En las secciones anteriores, vio con qué facilidad se pueden formar los datos faltantes. Son
reconocible en las estructuras de datos por el valor NaN (Not a Number). Entonces, tener valores
que no están definidos en una estructura de datos es bastante común en el análisis de datos.
Sin embargo, pandas está diseñado para gestionar mejor esta eventualidad. De hecho, en este
sección, aprenderá cómo tratar estos valores para que se puedan obviar muchos problemas.
Por ejemplo, en la biblioteca de pandas, el cálculo de estadísticas descriptivas excluye los valores de NaN
implícitamente.
Asignar un valor de NaN

Si necesita asignar específicamente un valor NaN a un elemento en una estructura de datos, puede
utilice el valor np.NaN (o np.nan) de la biblioteca NumPy.
>>> ser = pd.Series ([0,1,2, np.NaN, 9],

>>> ser
rojo 0.0
azul 1.0
amarillo 2.0
blanco NaN
verde 9.0
131
Página 148
dtype: float64
>>> ser ['blanco'] = Ninguno
>>> ser
rojo 0.0
azul 1.0
amarillo 2.0
blanco NaN
verde 9.0
dtype: float64
Filtrar valores de NaN

Hay varias formas de eliminar los valores de NaN durante el análisis de datos. Eliminándolos
a mano, elemento por elemento, puede ser muy tedioso y arriesgado, y nunca estás seguro de que
eliminó todos los valores de NaN. Aquí es donde la función dropna () viene en su ayuda.
>>> ser.dropna ()
rojo 0.0
azul 1.0
amarillo 2.0
verde 9.0
dtype: float64
También puede realizar directamente la función de filtrado colocando notnull () en el

condición de selección.
>>> ser [ser.notnull ()]

rojo 0.0
azul 1.0
amarillo 2.0
verde 9.0
dtype: float64
Si se trata de un marco de datos, se vuelve un poco más complejo. Si usa el

dropna () en este tipo de objeto, y solo hay un valor NaN en una columna o
fila, lo eliminará.
132
Página 149
>>> frame3 = pd.DataFrame ([[6, np.nan, 6], [np.nan, np.nan, np.nan], [2, np.nan, 5]],
... índice = ['azul', 'verde', 'rojo'],
... columnas = ['bola', 'taza', 'bolígrafo'])
>>> marco3
bolígrafo
azul 6.0 NaN 6.0
verde NaN NaN NaN
rojo 2,0 NaN 5,0
>>> frame3.dropna ()
DataFrame vacío
Columnas: [bola, taza, bolígrafo]
Índice: []
Por lo tanto, para evitar que las filas y columnas enteras desaparezcan por completo,
debe especificar la opción cómo, asignándole un valor de todo. Esto le dice a la dropna ()
función para eliminar solo las filas o columnas en las que todos los elementos son NaN.
>>> frame3.dropna (cómo = 'todo')

bolígrafo
azul 6.0 NaN 6.0
rojo 2,0 NaN 5,0
Completar ocurrencias de NaN

En lugar de filtrar los valores de NaN dentro de las estructuras de datos, con el riesgo de descartarlos
junto con los valores que podrían ser relevantes en el contexto del análisis de datos, puede reemplazar
ellos con otros números. Para la mayoría de los propósitos, la función fillna () es una excelente opción.
Este método toma un argumento, el valor con el que reemplazar cualquier NaN. Puede ser el
lo mismo para todos los casos.
>>> frame3.fillna (0)

bolígrafo
azul 6.0 0.0 6.0
verde 0,0 0,0 0,0
rojo 2,0 0,0 5,0
133
Página 150
O puede reemplazar NaN con diferentes valores según la columna, especificando

uno a uno los índices y los valores asociados.
>>> frame3.fillna ({'bola': 1, 'taza': 0, 'bolígrafo': 99})

bolígrafo
azul 6.0 0.0 6.0
verde 1,0 0,0 99,0
rojo 2,0 0,0 5,0
Indexación y nivelación jerárquica

La indexación jerárquica es una característica muy importante de los pandas, ya que le permite tener
múltiples niveles de índices en un solo eje. Le brinda una forma de trabajar con datos en múltiples
dimensiones sin dejar de trabajar en una estructura bidimensional.
Comencemos con un ejemplo simple, creando una serie que contiene dos arreglos de índices,
es decir, creando una estructura con dos niveles.
>>> mser = pd.Series (np.random.rand (8),

... índice = [['blanco', 'blanco', 'blanco', 'azul', 'azul', 'rojo', 'rojo',
'rojo'],
... ['arriba', 'abajo', 'derecha', 'arriba', 'abajo', 'arriba', 'abajo', 'izquierda']])
>>> mser
blanco hasta 0.461689
abajo 0.643121
derecha 0.956163
azul hasta 0,728021
abajo 0.813079
rojo hasta 0.536433
abajo 0.606161
izquierda 0.996686
dtype: float64
>>> mser.index
Pd.MultiIndex (niveles = [['azul', 'rojo', 'blanco'], ['abajo',
'izquierda derecha arriba']],
... etiquetas = [[2, 2, 2, 0, 0, 1, 1, 1],
[3, 0, 2, 3, 0, 3, 0, 1]])
134
Página 151
Mediante la especificación de la indexación jerárquica, la selección de subconjuntos de valores es

de cierta manera simplificada.
De hecho, puede seleccionar los valores para un valor dado del primer índice, y lo hace en
la forma clásica:
>>> mser ['blanco']

hasta 0.461689
abajo 0.643121
derecha 0.956163
dtype: float64
O puede seleccionar valores para un valor dado del segundo índice, en el siguiente
conducta:
>>> mser [:, 'arriba']

blanco 0.461689
azul 0.728021
rojo 0.536433
dtype: float64
Intuitivamente, si desea seleccionar un valor específico, especifique ambos índices.
>>> mser ['blanco', 'arriba']

0.46168915430531676
La indexación jerárquica juega un papel fundamental en la remodelación de datos y basados en grupos

operaciones como una tabla dinámica. Por ejemplo, los datos se pueden reorganizar y utilizar
en un marco de datos con una función especial llamada unstack (). Esta función convierte la
serie con un índice jerárquico a un marco de datos simple, donde el segundo conjunto de índices es
convertido en un nuevo conjunto de columnas.
>>> mser.unstack ()
abajo izquierda derecha arriba
azul 0.813079 NaN NaN 0.728021
rojo 0.606161 0.996686 NaN 0.536433
blanco 0.643121 NaN 0.956163 0.461689
135
Página 152
Si lo que quieres es realizar la operación inversa, que es convertir un dataframe

a una serie, usa la función stack () .
>>> marco
rojo 0123
azul 4 5 6 7
amarillo 8 9 10 11
blanco 12 13 14 15
>>> frame.stack ()
bola roja 0
bolígrafo 1
lápiz 2
papel 3
bola azul 4
bolígrafo 5
lápiz 6
papel 7
bola amarilla 8
bolígrafo 9
lápiz 10
papel 11
bola blanca 12
bolígrafo 13
lápiz 14
papel 15
dtype: int64
Con el marco de datos, es posible definir un índice jerárquico tanto para las filas como para
las columnas. En el momento en que se declara el marco de datos, debe definir una matriz de matrices
para las opciones de índice y columnas.
>>> mframe = pd.DataFrame (np.random.randn (16) .reshape (4,4),

... índice = [['blanco', 'blanco', 'rojo', 'rojo'], ['arriba', 'abajo', 'arriba', 'abajo']],
... columnas = [['bolígrafo', 'bolígrafo', 'papel', 'papel'], [1,2,1,2]])
136
Página 153
>>> mframe
bolígrafo papel
1 2 1 2
blanco hasta -1,964055 1,312100 -0,914750 -0,941930
abajo -1.886825 1.700858 -1.060846 -0.197669
rojo hacia arriba -1.561761 1.225509 -0.244772 0.345843
abajo 2.668155 0.528971 -1.633708 0.921735
Reordenación y clasificación de niveles

Ocasionalmente, es posible que deba reorganizar el orden de los niveles en un eje u ordenar por
valores en un nivel específico.
La función swaplevel () acepta como argumentos los nombres asignados a los dos
niveles que desea intercambiar y devuelve un nuevo objeto con los dos niveles
intercambiado entre ellos, dejando los datos sin modificar.
>>> mframe.columns.names = ['objetos', 'id']

>>> mframe.index.names = ['colores', 'estado']
>>> mframe
objetos bolígrafo papel
carné de identidad 1 2 1 2
estado de los colores
blanco hasta -1,964055 1,312100 -0,914750 -0,941930
abajo -1.886825 1.700858 -1.060846 -0.197669
rojo hacia arriba -1.561761 1.225509 -0.244772 0.345843
abajo 2.668155 0.528971 -1.633708 0.921735
>>> mframe.swaplevel ('colores', 'estado')

colores de estado
up white -1.964055 1.312100 -0.914750 -0.941930
abajo blanco -1.886825 1.700858 -1.060846 -0.197669
hacia arriba rojo -1.561761 1.225509 -0.244772 0.345843
abajo rojo 2.668155 0.528971 -1.633708 0.921735
137
Página 154
En cambio, la función sort_index () ordena los datos considerando solo aquellos

de un cierto nivel especificándolo como parámetro
>>> mframe.sort_index (nivel = 'colores')

rojo abajo 2.668155 0.528971 -1.633708 0.921735
hasta -1,561761 1,225509 -0,244772 0,345843
plumón blanco -1.886825 1.700858 -1.060846 -0.197669
hasta -1,964055 1,312100 -0,914750 -0,941930
Estadística de resumen por nivel

Muchas estadísticas descriptivas y estadísticas resumidas realizadas en un marco de datos o en un
Las series tienen una opción de nivel, con la que se puede determinar a qué nivel el descriptivo
y se deben determinar estadísticas resumidas.
Por ejemplo, si crea una estadística a nivel de fila, simplemente debe especificar el nivel
opción con el nombre del nivel.
>>> mframe.sum (nivel = 'colores')

bolígrafo de objetos papel
colores
rojo 1.106394 1.754480 -1.878480 1.267578
blanco -3.850881 3.012959 -1.975596 -1.139599
Si desea crear una estadística para un nivel dado de la columna, por ejemplo, el id,
debe especificar el segundo eje como argumento a través de la opción de eje establecida en 1.
>>> mframe.sum (nivel = 'id', eje = 1)

carné de identidad 1 2
blanco hasta -2.878806 0.370170
abajo -2.947672 1.503189
rojo hasta -1.806532 1.571352
abajo 1.034447 1.450706
138
Página 155
Conclusiones
Este capítulo presentó la biblioteca de pandas. Aprendió a instalarlo y vio un
panorama general de sus características.
Aprendió sobre las dos estructuras básicas de datos, llamadas serie y marco de datos,
junto con su funcionamiento y sus principales características. Especialmente, descubriste
la importancia de la indexación dentro de estas estructuras y la mejor manera de realizar las operaciones
en ellos. Finalmente, consideró la posibilidad de ampliar la complejidad de estos
estructuras creando jerarquías de índices, distribuyendo así los datos contenidos en
en diferentes subniveles.
En el siguiente capítulo, aprenderá a capturar datos de fuentes externas como archivos,
e inversamente, cómo escribir los resultados del análisis en ellos.
139
Página 156
CAPÍTULO 5
pandas: lectura
y escritura de datos
En el capítulo anterior, se familiarizó con la biblioteca de pandas y con la
funcionalidades básicas que proporciona para el análisis de datos. Viste ese marco de datos y
series son el corazón de esta biblioteca. Estos son el material sobre el que realizar todos los datos
manipulaciones, cálculos y análisis.
En este capítulo, verá todas las herramientas proporcionadas por pandas para leer los datos almacenados
en muchos tipos de medios (como archivos y bases de datos). Paralelamente, también verá cómo
escribir estructuras de datos directamente en estos formatos, sin preocuparse demasiado por la
tecnologías utilizadas.
Este capítulo se centra en una serie de funciones de API de E / S que pandas proporciona para leer
y escribir datos directamente como objetos de marco de datos. Empezamos mirando archivos de texto, luego nos movemos
gradualmente a formatos binarios más complejos.
Al final del capítulo, también aprenderá cómo interactuar con todos los
bases de datos, tanto SQL como NoSQL, incluidos ejemplos que muestran cómo almacenar datos en un
marco de datos. Al mismo tiempo, aprenderá a leer los datos contenidos en una base de datos y
recuperarlos como un marco de datos.
Herramientas API de E / S
pandas es una biblioteca especializada para el análisis de datos, por lo que esperas que esté enfocada principalmente
sobre cálculo y procesamiento de datos. Los procesos de escritura y lectura de datos desde / hacia
Los archivos externos pueden considerarse parte del procesamiento de datos. De hecho, verá cómo, incluso en
En esta etapa, puede realizar algunas operaciones para preparar los datos entrantes para
manipulación.
141
© Fabio Nelli 2018
Página 157
Capítulo 5 pandas: lectura y escritura de datos
Por tanto, este paso es muy importante para el análisis de datos y, por tanto, una herramienta específica para este
El propósito debe estar presente en los pandas de la biblioteca, un conjunto de funciones llamadas API de E / S. Estas
Las funciones se dividen en dos categorías principales: lectores y escritores .
Lectores Escritores
read_csv to_csv
read_excel para sobresalir
read_hdf to_hdf
read_sql to_sql
read_json to_json
read_html to_html
read_stata to_stata
read_clipboard to_clipboard
read_pickle to_pickle
read_msgpack to_msgpack (experimental)
read_gbq to_gbq (experimental)
Archivos CSV y textuales

Todo el mundo se ha acostumbrado a lo largo de los años a escribir y leer archivos en texto.
formar. En particular, los datos se informan generalmente en forma de tabla. Si los valores en una fila son
separados por comas, tienes el formato CSV (valores separados por comas), que es
quizás el formato más conocido y popular.
Otras formas de datos tabulares se pueden separar por espacios o tabulaciones y normalmente
contenidos en archivos de texto de varios tipos (generalmente con la extensión .txt).
Este tipo de archivo es la fuente de datos más común y es más fácil de transcribir y
interpretar. En este sentido, pandas proporciona un conjunto de funciones específicas para este tipo de archivo.
• read_csv
• read_table
• to_csv
142
Página 158
Lectura de datos en archivos CSV o de texto

Por experiencia, la operación más común de una persona que se acerca al análisis de datos es
para leer los datos contenidos en un archivo CSV, o al menos en un archivo de texto.
Pero antes de empezar a trabajar con archivos, debe importar las siguientes bibliotecas.

Para ver cómo manejan los pandas este tipo de datos, comenzaremos creando un pequeño
Archivo CSV en el directorio de trabajo, como se muestra en Listado 5-1y guárdelo como ch05_01.csv.
Listado 5-1. ch05_01.csv
blanco, rojo, azul, verde, animal

1,5,2,3, gato
2,7,8,5, perro
3,3,6,7, caballo
2,2,8,3, pato
4,4,2,1, ratón
Dado que este archivo está delimitado por comas, puede usar la función read_csv () para leer su
contenido y convertirlo en un objeto de marco de datos.
>>> csvframe = pd.read_csv ('ch05_01.csv')

>>> csvframe
animal blanco rojo azul verde
0 1 5 2 3 gato
1 2 7 8 5 perro
2 3 3 6 7 caballo
3 2 2 8 3 pato
4 4 4 2 1 ratón
Como puede ver, leer los datos en un archivo CSV es bastante trivial. Los archivos CSV están tabulados
datos en los que los valores de la misma columna están separados por comas. Desde archivos CSV
se consideran archivos de texto, también puede utilizar la función read_table (), pero especifique el
delimitador.
143
Página 159
>>> pd.read_table ('ch05_01.csv', sep = ',')

0 1 5 2 3 gato
1 2 7 8 5 perro
2 3 3 6 7 caballo
3 2 2 8 3 pato
4 4 4 2 1 ratón
En este ejemplo, puede ver que en el archivo CSV, los encabezados que identifican todas las columnas
están en la primera fila. Pero este no es un caso general; A menudo sucede que los datos tabulados
comenzar directamente en la primera línea (ver Listado 5-2).
1,5,2,3, gato
2,7,8,5, perro
3,3,6,7, caballo
2,2,8,3, pato
4,4,2,1, ratón
>>> pd.read_csv ('ch05_02.csv')
1 5 2 3 gato
0 2 7 8 5 perro
1 3 3 6 7 caballo
2 2 2 8 3 pato
3 4 4 2 1 ratón
En este caso, puede asegurarse de que sean los pandas los que asignen los nombres predeterminados a
las columnas estableciendo la opción de encabezado en Ninguno.
>>> pd.read_csv ('ch05_02.csv', encabezado = Ninguno)

01234
0 1 5 2 3 gato
1 2 7 8 5 perro
2 3 3 6 7 caballo
3 2 2 8 3 pato
4 4 4 2 1 ratón
144
Página 160
Además, puede especificar los nombres directamente asignando una lista de etiquetas al
opción de nombres.
>>> pd.read_csv ('ch05_02.csv', nombres = ['blanco', 'rojo', 'azul', 'verde', 'animal'])

0 1 5 2 3 gato
1 2 7 8 5 perro
2 3 3 6 7 caballo
3 2 2 8 3 pato
4 4 4 2 1 ratón
En casos más complejos, en los que desea crear un marco de datos con una jerarquía
estructura leyendo un archivo CSV, puede ampliar la funcionalidad de la función read_csv ()
agregando la opción index_col, asignando todas las columnas a convertir en índices.
Para comprender mejor esta posibilidad, cree un nuevo archivo CSV con dos columnas para
utilizados como índices de la jerarquía. Luego, guárdelo en el directorio de trabajo como ch05_03.csv
(ver listado 5-3 ).
color, estado, artículo1, artículo2, artículo3

negro, arriba, 3,4,6
negro, abajo, 2,6,7
blanco, arriba, 5,5,5
blanco, abajo, 3,3,2
blanco, izquierda, 1,2,1
rojo, arriba, 2,2,2
rojo, abajo, 1,1,4
>>> pd.read_csv ('ch05_03.csv', index_col = ['color', 'estado'])

artículo1 artículo2 artículo3
estado del color
negro arriba 346
abajo 267
blanquear 555
abajo 332
izquierda 121
rojo hasta 222
abajo 114
145
Página 161
Uso de RegExp para analizar archivos TXT

En otros casos, es posible que los archivos en los que analizar los datos no se muestren
separadores bien definidos como una coma o un punto y coma. En estos casos, el regular
las expresiones vienen en nuestra ayuda. De hecho, puede especificar una expresión regular dentro de read_table ()
función usando la opción sep.
Para comprender mejor la expresión regular y comprender cómo se puede aplicar como criterio para
separación de valores, comencemos con un caso simple. Por ejemplo, suponga que su TXT
El archivo tiene valores separados por espacios o tabulaciones en un orden impredecible. En esto
caso, tienes que usar la expresión regular, porque esa es la única forma de tener en cuenta tanto
tipos de separadores. Puede hacerlo usando el comodín / s * . / s representa el espacio o la pestaña
carácter (si desea indicar una pestaña, use / t), mientras que el asterisco indica que
puede haber varios caracteres (consulte la Tabla 5-1 para ver otros comodines comunes). Es decir,
los valores pueden estar separados por más espacios o más tabulaciones.
Tabla 5-1. Metacaracteres
. carácter único, excepto nueva línea
\re dígito
\RE carácter sin dígitos
\s Carácter de espacio en blanco
\S carácter que no es un espacio en blanco
\norte carácter de nueva línea
\t carácter de tabulación
\ uxxxx Carácter Unicode especificado por el

número hexadecimal xxxx
Tomemos, por ejemplo, un caso extremo en el que tenemos los valores separados por tabulaciones o
espacios en un orden aleatorio (ver Listado 5-4 ).
146
Página 162
Listado 5-4. ch05_04.txt
blanco rojo azul verde

1523
2785
3367
>>> pd.read_table ('ch05_04.txt', sep = '\ s +', motor = 'python')

blanco rojo azul verde
01523
12785
23367
Como puede ver, el resultado es un marco de datos perfecto en el que los valores son perfectamente
ordenado.
Ahora verá un ejemplo que puede parecer extraño o inusual, pero no es tan raro
como pueda parecer. Este ejemplo puede ser muy útil para comprender el alto potencial de un
regexp. De hecho, normalmente podría pensar en los separadores como caracteres especiales como comas,
espacios, tabulaciones, etc., pero en realidad puede considerar caracteres separadores como alfanuméricos
caracteres o, por ejemplo, números enteros como 0.
En este ejemplo, debe extraer la parte numérica de un archivo TXT, en el que
hay una secuencia de caracteres con valores numéricos y los caracteres literales son
completamente fusionado.
Recuerde establecer la opción de encabezado en Ninguno siempre que los encabezados de columna no sean
presente en el archivo TXT (ver Listado 5-5).
000END123AAA122
001END124BBB321
002END125CCC333
>>> pd.read_table ('ch05_05.txt', sep = '\ D +', encabezado = Ninguno, motor = 'python')
012
0 0 123 122
1 1 124 321
2 2 125 333
147
Página 163
Otro evento bastante común es excluir líneas del análisis. De hecho no siempre
desea incluir encabezados o comentarios innecesarios contenidos en un archivo (consulte el Listado 5-6).
Con la opción skiprows, puede excluir todas las líneas que desee, simplemente asignando una matriz
que contiene los números de línea que no se deben considerar en el análisis.
Preste atención cuando utilice esta opción. Si desea excluir los primeros cinco
líneas, debe escribir skiprows = 5, pero si desea descartar la quinta línea, tiene
para escribir skiprows = [5].
########### ARCHIVO DE REGISTRO ############

Este archivo ha sido generado por sistema automático
blanco, rojo, azul, verde, animal
12-feb-2015: Conteo de animales dentro de la casa
1,5,2,3, gato
2,7,8,5, perro
13-feb-2015: Conteo de animales fuera de casa
3,3,6,7, caballo
2,2,8,3, pato
4,4,2,1, ratón
>>> pd.read_table ('ch05_06.txt', sep = ',', skiprows = [0,1,3,6])

0 1 5 2 3 gato
1 2 7 8 5 perro
2 3 3 6 7 caballo
3 2 2 8 3 pato
4 4 4 2 1 ratón
Lectura de archivos TXT en partes

Cuando se procesan archivos grandes, o cuando solo está interesado en partes de estos archivos,
a menudo es necesario leer el archivo en partes (fragmentos). Esto es tanto para aplicar cualquier iteración
y porque no estamos interesados en analizar todo el archivo.
148
Página 164
Si, por ejemplo, desea leer solo una parte del archivo, puede especificar explícitamente
el número de líneas en las que analizar. Gracias a las opciones de nrows y skiprows,
puede seleccionar la línea inicial n (n = SkipRows) y las líneas que se leerán después (nrows = i).
>>> pd.read_csv ('ch05_02.csv', skiprows = [2], nrows = 3, header = Ninguno)

01234
0 1 5 2 3 gato
1 2 7 8 5 perro
2 2 2 8 3 pato
Otra operación interesante y bastante común es dividir en porciones esa parte de

el texto sobre el que desea analizar. Entonces, para cada porción se puede realizar una operación específica.
llevado a cabo, con el fin de obtener una iteración, porción por porción.
Por ejemplo, desea agregar los valores en una columna cada tres filas y luego
inserte estas sumas en una serie. Este ejemplo es trivial y poco práctico, pero es muy simple.
comprender, por lo que una vez que haya aprendido el mecanismo subyacente, podrá
aplicarlo en casos más complejos.
>>> fuera = pd.Series ()

>>> i = 0
>>> piezas = pd.read_csv ('ch05_01.csv', chunksize = 3)
>>> por pieza en piezas:
... out.set_value (i, pieza ['blanco']. sum ())
... yo = yo + 1
...
06
dtype: int64
06
dieciséis
dtype: int64
>>> fuera
06
dieciséis
dtype: int64
149
Página 165
Escribir datos en CSV

Además de leer los datos contenidos en un archivo, también es común escribir un archivo de datos
producido por un cálculo, o en general los datos contenidos en una estructura de datos.
Por ejemplo, es posible que desee escribir los datos contenidos en un marco de datos en un archivo CSV.
expediente. Para realizar este proceso de escritura, utilizará la función to_csv (), que acepta como
argumento el nombre del archivo que genera (vea el Listado 5-7 ).

índice = ['rojo', 'azul', 'amarillo', 'blanco'],
columnas = ['bola', 'bolígrafo', 'lápiz', 'papel'])
>>> frame.to_csv ('ch05_07.csv')
Si abre el nuevo archivo llamado ch05_07.csv generado por la biblioteca de pandas,

vea los datos como en el Listado 5-7 .
bola, bolígrafo, lápiz, papel

0,1,2,3
4,5,6,7
8,9,10,11
12,13,14,15
Como puede ver en el ejemplo anterior, cuando escribe un marco de datos en un archivo,
los índices y columnas están marcados en el archivo de forma predeterminada. Este comportamiento predeterminado puede ser
cambiado estableciendo el índice y el encabezado de dos opciones en False (ver Listado 5-8 ).
>>> frame.to_csv ('ch05_07b.csv', index = False, header = False)
Listado 5-8. ch05_07b.csv
1,2,3
5,6,7
9,10,11
13,14,15
150
Página 166
Un punto para recordar al escribir archivos es que los valores NaN presentes en un dato
La estructura se muestra como campos vacíos en el archivo (ver Listado 5-9 ).
>>> frame3 = pd.DataFrame ([[6, np.nan, np.nan, 6, np.nan],

... [np.nan, np.nan, np.nan, np.nan, np.nan],
... [np.nan, np.nan, np.nan, np.nan, np.nan],
... [20, np.nan, np.nan, 20.0, np.nan],
... [19, np.nan, np.nan, 19.0, np.nan]
... ],
... índice = ['azul', 'verde', 'rojo', 'blanco', 'amarillo'],
columnas = ['bola', 'taza', 'papel', 'bolígrafo', 'lápiz'])
>>> marco3
>>> frame3.to_csv ('ch05_08.csv')
bola, taza, papel, bolígrafo, lápiz

azul, 6.0 ,,, 6.0,
verde,,,,,
rojo,,,,,
blanco, 20.0 ,,, 20.0,
amarillo, 19.0 ,,, 19.0,
Sin embargo, puede reemplazar este campo vacío con un valor a su gusto usando el
Opción na_rep en la función to_csv (). Los valores comunes pueden ser NULL, 0 o iguales
NaN (consulte el listado 5-10 ).
>>> frame3.to_csv ('ch05_09.csv', na_rep = 'NaN')
151
Página 167
bola, taza, papel, bolígrafo, lápiz

azul, 6.0, NaN, NaN, 6.0, NaN
verde, NaN, NaN, NaN, NaN, NaN
rojo, NaN, NaN, NaN, NaN, NaN
blanco, 20.0, NaN, NaN, 20.0, NaN
amarillo, 19.0, NaN, NaN, 19.0, NaN
Tenga en cuenta que en los casos especificados, el marco de datos siempre ha sido objeto de
discusión ya que estas son las estructuras de datos que se escriben en el archivo. Pero todo
estas funciones y opciones también son válidas con respecto a la serie.
Leer y escribir archivos HTML

pandas proporciona el par correspondiente de funciones API de E / S para el formato HTML.
• read_html ()
• to_html ()
Estas dos funciones pueden resultar muy útiles. Apreciarás la posibilidad de convertir
estructuras de datos complejas como marcos de datos directamente en tablas HTML sin tener que
hackear una lista larga en HTML, especialmente si se trata de la Web.
La operación inversa puede ser muy útil, porque ahora la principal fuente de datos es
solo el mundo web. De hecho, muchos datos en Internet no siempre tienen la forma
"Listo para usar", que está empaquetado en algún archivo TXT o CSV. Muy a menudo, sin embargo, los datos son
informado como parte del texto de las páginas web. Así que también tener disponible una función para leer
podría resultar realmente útil.
Esta actividad está tan extendida que actualmente se la identifica como web scraping . Esta
proceso se está convirtiendo en parte fundamental del conjunto de procesos que se integrarán en
la primera parte del análisis de datos: extracción de datos y preparación de datos.
152
Página 168
Nota Muchos sitios web han adoptado ahora el formato htML5, para evitar problemas de
módulos faltantes y mensajes de error. te recomiendo encarecidamente que instales el módulo
html5lib. anaconda especificado:
conda instalar html5lib

Escribir datos en HTML

Ahora aprenderá a convertir un marco de datos en una tabla HTML. La estructura interna
del marco de datos se convierte automáticamente en etiquetas anidadas <TH>, <TR> y <TD>
conservando las jerarquías internas. No necesita saber HTML para usar este tipo de
función.
Debido a que las estructuras de datos como el marco de datos pueden ser bastante complejas y grandes, es
genial tener una función como esta cuando necesitas desarrollar páginas web.
Para comprender mejor este potencial, aquí hay un ejemplo. Puede empezar definiendo un
marco de datos simple.
Gracias a la función to_html (), puede convertir directamente el marco de datos en un
Tabla HTML.
>>> marco = pd.DataFrame (np.arange (4) .reshape (2,2))
Dado que las funciones de la API de E / S están definidas en las estructuras de datos de pandas, puede llamar
la función to_html () directamente en la instancia del marco de datos.
>>> imprimir (frame.to_html ())

<table border = "1" class = "dataframe">
<thead>
<tr style = "text-align: right;">
<th> </th>
<th> 0 </th>
<th> 1 </th>
</tr>
</thead>
<tbody>
153
Página 169
<tr>
<th> 0 </th>
<td> 0 </td>
<td> 1 </td>
</tr>
<tr>
<th> 1 </th>
<td> 2 </td>
<td> 3 </td>
</tr>
</tbody>
</table>
Como puede ver, toda la estructura formada por las etiquetas HTML necesarias para crear un
La tabla HTML se generó correctamente para respetar la estructura interna del
marco de datos.
En el siguiente ejemplo, verá cómo la tabla aparece generada automáticamente dentro de
un archivo HTML. En este sentido, creamos un marco de datos un poco más complejo que el anterior.
uno, donde están las etiquetas de los índices y los nombres de las columnas.
>>> marco = pd.DataFrame (np.random.random ((4,4)),

... índice = ['blanco', 'negro', 'rojo', 'azul'],
... columnas = ['arriba', 'abajo', 'derecha', 'izquierda'])
>>> marco
arriba abajo derecha izquierda
blanco 0.292434 0.457176 0.905139 0.737622
negro 0,794233 0,949371 0,540191 0,367835
rojo 0.204529 0.981573 0.118329 0.761552
azul 0,628790 0,585922 0,039153 0,461598
Ahora te concentras en escribir una página HTML mediante la generación de una cadena. Esta
es un ejemplo simple y trivial, pero es muy útil para comprender y probar el
funcionalidad de pandas directamente en el navegador web.
154
Página 170
Primero que nada creamos una cadena que contiene el código de la página HTML.
>>> s = ['<HTML>']
>>> s.append ('<HEAD> <TITLE> Mi DataFrame </TITLE> </HEAD>')
>>> s.append ('<CUERPO>')
>>> s.append (frame.to_html ())
>>> s.append ('</BODY> </HTML>')
>>> html = ".unir (s)
Ahora que toda la lista de la página HTML está contenida dentro de la variable html,
puede escribir directamente en el archivo que se llamará myFrame.html:
>>> html_file = open ('myFrame.html', 'w')

>>> html_file.write (html)
>>> html_file.close ()
Ahora en su directorio de trabajo habrá un nuevo archivo HTML, myFrame.html. Haga doble clic
para abrirlo directamente desde el navegador. Aparecerá una tabla HTML en la parte superior izquierda, como
como se muestra en la Figura 5-1 .
Figura 5-1. El marco de datos se muestra como una tabla HTML en la página web.
Leer datos de un archivo HTML

Como acaba de ver, los pandas pueden generar fácilmente tablas HTML a partir del marco de datos.
También es posible el proceso opuesto; la función read_html () realizará un análisis
una página HTML en busca de una tabla HTML. Si lo encuentra, convertirá esa tabla en un
marco de datos de objeto listo para ser utilizado en nuestro análisis de datos.
155
Página 171
Más precisamente, la función read_html () devuelve una lista de marcos de datos incluso si hay
solo una mesa. La fuente que se analizará puede ser de diferentes tipos. Por ejemplo tu
puede que tenga que leer un archivo HTML en cualquier directorio. Por ejemplo, puede analizar el HTML
archivo que creó en el ejemplo anterior:
>>> web_frames = pd.read_html ('myFrame.html')

>>> web_frames [0]
Sin nombre: 0 arriba abajo derecha izquierda
0 blanco 0.292434 0.457176 0.905139 0.737622
1 negro 0,794233 0,949371 0,540191 0,367835
2 rojo 0.204529 0.981573 0.118329 0.761552
3 azul 0,628790 0,585922 0,039153 0,461598
Como puede ver, todas las etiquetas que no tienen nada que ver con la tabla HTML no son
considerado absolutamente. Además, web_frames es una lista de marcos de datos, aunque en su
caso, el marco de datos que está extrayendo es solo uno. Sin embargo, puede seleccionar el elemento
en la lista que desea usar, llamándolo de la manera clásica. En este caso, el artículo es único.
y por lo tanto el índice será 0.
Sin embargo, el modo más utilizado con respecto a la función read_html () es que
de un análisis directo de una URL en la Web. De esta forma las páginas web en la red son
analizado directamente con la extracción de las tablas en ellos.
Por ejemplo, ahora llamará a una página web donde hay una tabla HTML que muestra un
lista de clasificación con algunos nombres y puntuaciones.
>>> ranking = pd.read_html ('https://www.meccanismocomplesso.org/en/

meccanismo-complesso-sito-2 / classifica-punteggio / ')
>>> ranking [0]
Miembro niveles de puntos Sin nombre: 3
0 1 BrunoOrsini 1075 Yaya
1 2 Berserker 700 Yaya
2 3 albertosallu 275 Yaya
3 4 Señor Y 180 Yaya
4 5 Jon 170 Yaya
5 6 michele sisi 120 Yaya
6 7 STEFANO GUST 120 Yaya
7 8 Davide Alois 105 Yaya
8 9 Cecilia Lala 105 Yaya
...
156
Página 172
La misma operación se puede ejecutar en cualquier página web que tenga una o más tablas.
Leer datos de XML

En la lista de funciones de la API de E / S, no hay una herramienta específica con respecto a XML (Extensible
Markup Language) formato. De hecho, aunque no figura en la lista, este formato es muy importante,
porque muchos datos estructurados están disponibles en formato XML. Esto no presenta ningún problema,
ya que Python tiene muchas otras bibliotecas (además de pandas) que administran la lectura y
escritura de datos en formato XML.
Una de estas bibliotecas es la biblioteca lxml, que destaca por su excelente
rendimiento durante el análisis de archivos muy grandes. En esta sección aprenderá a utilizar
este módulo para analizar archivos XML y cómo integrarlo con pandas para finalmente obtener el
marco de datos que contiene los datos solicitados. Para obtener más información sobre esta biblioteca,
Recomiendo encarecidamente visitar el sitio web oficial de lxml en http://lxml.de/index.html.
Tomemos, por ejemplo, el archivo XML que se muestra en el listado. 5-11 . Anótelo y guárdelo con el
nombre books.xml directamente en su directorio de trabajo.
Listado 5-11. books.xml
<? xml version = "1.0"?>

<Catálogo>
<ID del libro = "ISBN9872122367564">
<Autor> Ross, Mark </Author>
<Title> Libro de recetas XML </Title>
<Genre> Computadora </Genre>
<Precio> 23,56 </Precio>
<PublishDate> 2014-22-01 </PublishDate>
</Book>
<ID del libro = "ISBN9872122367564">
<Author> Bracket, Barbara </Author>
<Title> XML para principiantes </Title>
<Genre> Computadora </Genre>
<Precio> 35,95 </Precio>
<PublishDate> 16/12/2014 </PublishDate>
</Book>
</Catalog>
157
Página 173
En este ejemplo, tomará la estructura de datos descrita en el archivo XML para convertir
directamente en un marco de datos. Lo primero que debe hacer es utilizar el submódulo objetivar del
lxml, importándola de la siguiente manera.
>>> desde lxml importar objetivar
Ahora puede hacer el analizador del archivo XML con solo la función parse ().
>>> xml = objectify.parse ('libros.xml')

>>> xml
<objeto lxml.etree._ElementTree en 0x0000000009734E08>
Tienes un árbol de objetos, que es una estructura de datos interna del módulo lxml.
Mire con más detalle este tipo de objeto. Para navegar en esta estructura de árbol, para
para seleccionar elemento por elemento, primero debe definir la raíz. Puedes hacer esto con el
función getroot ().
>>> raíz = xml.getroot ()
Ahora que se ha definido la raíz de la estructura, puede acceder a los distintos nodos
del árbol, cada uno correspondiente a la etiqueta contenida en el archivo XML original. Los artículos serán
tienen el mismo nombre que las etiquetas correspondientes. Entonces, para seleccionarlos, simplemente escriba los distintos
etiquetas separadas con puntos, reflejando de cierta manera la jerarquía de nodos en el árbol.
>>> root.Book.Author
'Ross, Mark'
>>> root.Book.PublishDate
'2014-22-01'
De esta forma accede a los nodos individualmente, pero puede acceder a varios elementos en el
mismo tiempo usando getchildren (). Con esta función, obtendrá todos los nodos secundarios de la
elemento de referencia.
>>> root.getchildren ()
[<Libro de elementos en 0x9c66688>, <Libro de elementos en 0x9c66e08>]
Con el atributo de etiqueta, obtienes el nombre de la etiqueta correspondiente al nodo hijo.
>>> [child.tag para niño en root.Book.getchildren ()]

['Autor', 'Título', 'Género', 'Precio', 'Fecha de publicación']
158
Página 174
Mientras que con el atributo de texto obtienes el valor contenido entre los
etiquetas correspondientes.
>>> [child.text para niño en root.Book.getchildren ()]

['Ross, Mark', 'XML Cookbook', 'Computadora', '23 .56 ',' 2014-22-01 ']
Sin embargo, independientemente de la capacidad de moverse a través de la estructura de árbol lxml.etree,

lo que necesita es convertirlo en un marco de datos. Defina la siguiente función, que tiene
la tarea de analizar el contenido de un eTree para llenar un marco de datos línea por línea.
>>> def etree2df (raíz):

... column_names = []
... para i en el rango (0, len (root.getchildren () [0] .getchildren ())):
... column_names.append (root.getchildren () [0] .getchildren () [i] .tag)
... xml: frame = pd.DataFrame (columnas = nombres_columna)
... para j en el rango (0, len (root.getchildren ())):
... obj = root.getchildren () [j] .getchildren ()
... textos = []
... para k en el rango (0, len (column_names)):
... textos.append (obj [k] .text)
... fila = dict (zip (nombres_columna, textos))
... row_s = pd.Series (fila)
... row_s.name = j
... xml: frame = xml: frame.append (filas_s)
... return xml: marco
...
>>> etree2df (raíz)
Autor Título Género Precio Fecha de publicación
0 Ross, Mark XML Cookbook Computer 23.56 2014-22-01
1 Soporte, Barbara XML para Dummies Computer 35.95 2014-12-16
Leer y escribir datos en archivos de Microsoft Excel

En la sección anterior, vio cómo los datos se pueden leer fácilmente desde archivos CSV. Es
No es raro, sin embargo, que haya datos recopilados en forma tabular en un Excel
hoja de cálculo.
159
Página 175
pandas proporciona funciones específicas para este tipo de formato. Has visto que la E / S
API proporciona dos funciones para este propósito:
• para sobresalir()
• read_excel ()
La función read_excel () puede leer archivos de Excel 2003 (.xls) y archivos de Excel 2007 (.xlsx).
Esto es posible gracias a la integración del módulo interno xlrd.
Primero, abra un archivo de Excel e ingrese los datos como se muestra en la Figura 5-2 . Copie los datos en
sheet1 y sheet2. Luego guárdelo como ch05_data.xlsx.
Figura 5-2. Los dos conjuntos de datos en sheet1 y sheet2 de un archivo de Excel
160
Página 176
Para leer los datos contenidos en el archivo XLS y convertirlos en un marco de datos, solo
tienes que usar la función read_excel ().
>>> pd.read_excel ('ch05_data.xlsx')

blanco rojo verde negro
a 12 23 17 18
b 22 16 19 18
c 14 23 22 21
Como puede ver, de forma predeterminada, el marco de datos devuelto se compone de los datos
tabulado en las primeras hojas de cálculo. Sin embargo, si necesita cargar los datos en el segundo
hoja de cálculo, debe especificar el nombre de la hoja o el número de la hoja
(índice) como el segundo argumento.
>>> pd.read_excel ('ch05_data.xlsx', 'Hoja2')

amarillo violeta azul naranja
A 11 16 44 22
B 20 22 23 44
C 30 31 37 32
>>> pd.read_excel ('ch05_data.xlsx', 1)
amarillo violeta azul naranja
A 11 16 44 22
B 20 22 23 44
C 30 31 37 32
Lo mismo se aplica a la escritura. Para convertir un marco de datos en una hoja de cálculo en Excel,
tienes que escribir lo siguiente.

... índice = ['exp1', 'exp2', 'exp3', 'exp4'],
... columnas = ['Jan2015', 'Fab2015', 'Mar2015', 'Apr2005'])
>>> marco
Ene2015 Fab2015 Mar2015 Abr2005
exp1 0.030083 0.065339 0.960494 0.510847
exp2 0.531885 0.706945 0.964943 0.085642
exp3 0.981325 0.868894 0.947871 0.387600
exp4 0.832527 0.357885 0.538138 0.357990
>>> frame.to_excel ('datos2.xlsx')
161
Página 177
En el directorio de trabajo, encontrará un nuevo archivo de Excel que contiene los datos, como se muestra
en la Figura 5-3 .
Figura 5-3. El marco de datos en el archivo de Excel
Datos JSON
JSON (JavaScript Object Notation) se ha convertido en uno de los estándares más comunes
formatos, especialmente para la transmisión de datos en la Web. Por eso es normal trabajar con
este formato de datos si desea utilizar datos en la Web.
La particularidad de este formato es su gran flexibilidad, aunque su estructura está lejos
de ser aquella a la que estáis bien acostumbrados, es decir, tabular.
En esta sección, verá cómo utilizar las funciones read_json () y to_json () para
permanezca dentro de las funciones de la API de E / S discutidas en este capítulo. Pero en la segunda parte tu
verá otro ejemplo en el que tendrá que lidiar con datos estructurados en JSON
formato mucho más relacionado con casos reales.
En mi opinión, una aplicación en línea útil para verificar el formato JSON es
JSONViewer, disponible en http://jsonviewer.stack.hu/. Esta aplicación web, una vez
ingresa o copia datos en formato JSON, le permite ver si el formato que ingresó
es válido. Además, muestra la estructura del árbol para que pueda comprender mejor su
estructura (ver figura 5-4 ).
162
Página 178
Figura 5-4. JSONViewer
Comencemos con el caso más útil, es decir, cuando tiene un marco de datos y
Necesita convertirlo en un archivo JSON. Entonces, defina un marco de datos y luego llame a to_json ()
función en él, pasando como argumento el nombre del archivo que desea crear.
>>> marco = pd.DataFrame (np.arange (16) .reshape (4,4),

>>> frame.to_json ('frame.json')
En el directorio de trabajo, encontrará un nuevo archivo JSON (ver Listado 5-12 ) que contiene
los datos del marco de datos traducidos al formato JSON.
163
Página 179
Listado 5-12. frame.json
{"arriba": {"blanco": 0, "negro": 4, "rojo": 8, "azul": 12}, "abajo": {"blanco": 1, "negro": 5,

"rojo": 9, "azul": 13}, "derecho": {"blanco": 2, "negro": 6, "rojo": 10, "azul": 14},
"izquierda": {"blanco": 3, "negro": 7, "rojo": 11, "azul": 15}}
Lo contrario es posible, usando read_json () con el nombre del archivo pasado como
un argumento.
>>> pd.read_json ('frame.json')

abajo izquierda derecha arriba
negro 5 7 6 4
azul 13 15 14 12
rojo 9 11 10 8
blanco 1 3 2 0
El ejemplo que ha visto es un caso bastante simple en el que los datos JSON estaban en
forma tabular (ya que el archivo frame.json proviene de un marco de datos). Sin embargo, generalmente
los archivos JSON no tienen una estructura tabular. Por lo tanto, necesitará convertir de alguna manera
el archivo dict de estructura en forma tabular. Este proceso se llama normalización .
La biblioteca pandas proporciona una función, llamada json_normalize (), que puede
convertir un dict o una lista en una tabla. Primero tienes que importar la función:
>>> de pandas.io.json importar json_normalize
Luego escribe un archivo JSON como se describe en Listado 5-13 con cualquier editor de texto. Guárdalo en
el directorio de trabajo como books.json.
Listado 5-13. books.json
[{"writer": "Mark Ross",

"nacionalidad": "EE.UU.",
"libros": [
{"title": "XML Cookbook", "price": 23.56},
{"title": "Python Fundamentals", "price": 50.70},
{"title": "La biblioteca de NumPy", "price": 12.30}
]
},
164
Página 180
{"writer": "Barbara Bracket",

"nacionalidad": "Reino Unido",
"libros": [
{"title": "Java Enterprise", "price": 28.60},
{"title": "HTML5", "price": 31.35},
{"title": "Python for Dummies", "price": 28.00}
]
}]
Como puede ver, la estructura de archivos ya no es tabular, sino más compleja. Luego
el enfoque con la función read_json () ya no es válido. Mientras aprende de esto
Por ejemplo, aún puede obtener los datos en forma tabular de esta estructura. Primero tienes que
cargue el contenido del archivo JSON y conviértalo en una cadena.
>>> importar json

>>> archivo = abrir ('libros.json', 'r')
>>> texto = archivo.read ()
>>> texto = json.loads (texto)
Ahora está listo para aplicar la función json_normalize (). De un vistazo rápido al
contenido de los datos dentro del archivo JSON, por ejemplo, es posible que desee extraer una tabla
que contiene todos los libros. Luego, escriba la clave de los libros como segundo argumento.
>>> json_normalize (texto, 'libros')

precio título
0 23,56 Libro de recetas XML
1 50.70 Fundamentos de Python
2 12.30 La biblioteca NumPy
3 28.60 Java Enterprise
4 31,35 HTML5
5 28.00 Python para tontos
La función leerá el contenido de todos los elementos que tengan libros como clave. Todas
las propiedades se convertirán en nombres de columnas anidadas mientras que los valores correspondientes
llenará el marco de datos. Para los índices, la función asigna una secuencia de incrementos
números.
165
Página 181
Sin embargo, obtiene un marco de datos que contiene solo cierta información interna. Sería
Sería útil sumar los valores de otras claves del mismo nivel. En este caso puede agregar otros
columnas insertando una lista de claves como tercer argumento de la función.
>>> json_normalize (texto, 'libros', ['nacionalidad', 'escritor'])

precio nacionalidad del título escritor
0 23,56 Libro de recetas XML Estados Unidos Mark Ross
1 50.70 Fundamentos de Python Estados Unidos Mark Ross
2 12.30 La biblioteca NumPy Estados Unidos Mark Ross
3 28.60 Java Enterprise Reino Unido Barbara Bracket
4 31,35 HTML5 Reino Unido Barbara Bracket
5 28.00 Python para tontos Reino Unido Barbara Bracket
Ahora, como resultado, obtiene un marco de datos a partir de una estructura de árbol inicial.
El formato HDF5
Hasta ahora has visto cómo escribir y leer datos en formato de texto. Cuando su análisis de datos
implica grandes cantidades de datos, es preferible utilizarlos en formato binario. Existen
Varias herramientas en Python para manejar datos binarios. Una biblioteca que está teniendo cierto éxito en
esta área es la biblioteca HDF5.
El término HDF significa formato de datos jerárquico y, de hecho, esta biblioteca es
relacionado con la lectura y escritura de archivos HDF5 que contienen una estructura con nodos y
la posibilidad de almacenar múltiples conjuntos de datos.
Esta biblioteca, completamente desarrollada en C, sin embargo, también tiene interfaces con otros tipos de
lenguajes como Python, MATLAB y Java. Es muy eficiente, especialmente cuando se usa
este formato para guardar grandes cantidades de datos. Comparado con otros formatos que funcionan más
simplemente en binario, HDF5 admite la compresión en tiempo real, aprovechando así
patrones repetitivos en la estructura de datos para comprimir el tamaño del archivo.
En la actualidad, las posibles opciones en Python son PyTables y h5py. Estas dos formas
difieren en varios aspectos y, por tanto, su elección depende mucho de las necesidades de
aquellos que lo usan.
h5py proporciona una interfaz directa con las API de alto nivel HDF5, mientras que PyTables
abstrae muchos de los detalles de HDF5 para proporcionar contenedores de datos más flexibles,
tablas indexadas, capacidades de consulta y otros medios sobre los cálculos.
166
Página 182
pandas tiene un dictado similar a una clase llamado HDFStore, que usa PyTables para almacenar objetos pandas.
Entonces, antes de trabajar con el formato HDF5, debe importar la clase HDFStore:
>>> de pandas.io.pytables importar HDFStore
Ahora está listo para almacenar los datos de un marco de datos dentro de un archivo .h5. Primero, crea un
marco de datos.

Ahora cree un archivo HDF5 llamándolo mydata.h5, luego ingrese los datos dentro del
marco de datos.
>>> tienda = HDFStore ('mydata.h5')

>>> almacenar ['obj1'] = marco
Desde aquí, puede adivinar cómo puede almacenar múltiples estructuras de datos dentro
el mismo archivo HDF5, especificando para cada uno de ellos una etiqueta.
>>> marco
blanco 0 0.5 1 1.5
negro 2 2,5 3 3,5
rojo 4 4.5 5 5.5
azul 6 6,5 7 7,5
>>> almacenar ['obj2'] = marco
Entonces, con este tipo de formato, puede almacenar múltiples estructuras de datos en un solo archivo,
representado por la variable de tienda.
>>> tienda
<clase 'pandas.io.pytables.HDFStore'>
Ruta del archivo: mydata.h5
/ obj1 cuadro (forma -> [4,4])
167
Página 183
Incluso el proceso inverso es muy sencillo. Teniendo en cuenta tener un archivo HDF5
que contienen varias estructuras de datos, los objetos dentro se pueden llamar de la siguiente manera:
>>> almacenar ['obj2']

blanco 0 0.5 1 1.5
negro 2 2,5 3 3,5
rojo 4 4.5 5 5.5
azul 6 6,5 7 7,5
Pickle: serialización de objetos de Python

El módulo pickle implementa un poderoso algoritmo para serialización y
deserialización de una estructura de datos implementada en Python. El decapado es el proceso en
que la jerarquía de un objeto se convierte en un flujo de bytes.
Esto permite que un objeto sea transmitido y almacenado, y luego sea reconstruido por el
propio receptor conservando todas las características originales.
En Python, la operación de selección la realiza el módulo pickle, pero actualmente
hay un módulo llamado cPickle que es el resultado de una enorme cantidad de trabajo
optimizando el módulo pickle (escrito en C). Este módulo puede ser de hecho en muchos casos
incluso 1000 veces más rápido que el módulo pickle. Sin embargo, independientemente del módulo
que utiliza, las interfaces de los dos módulos son casi iguales.
Antes de pasar a mencionar explícitamente las funciones de E / S de los pandas que operan en este
formato, veamos con más detalle el módulo cPickle y veamos cómo usarlo.
Serializar un objeto Python con cPickle

El formato de datos utilizado por el módulo pickle (o cPickle) es específico de Python. Por
Por defecto, se utiliza una representación ASCII para representarlo, para que sea legible desde
el punto de vista humano. Luego, al abrir un archivo con un editor de texto, es posible que pueda
comprender su contenido. Para utilizar este módulo, primero debe importarlo:
>>> importar pepinillos
Luego cree un objeto lo suficientemente complejo como para tener una estructura de datos interna, para
ejemplo un objeto dict.
>>> datos = {'color': ['blanco', 'rojo'], 'valor': [5, 7]}
168
Página 184
Ahora realizará una serialización del objeto de datos a través de la función dumps ()
del módulo cPickle.
>>> pickled_data = pickle.dumps (datos)
Ahora, para ver cómo serializó el objeto dict, debe mirar el contenido del
variable pickled_data.
>>> imprimir (pickled_data)

(dp1
S'color '
p2
(lp3
Es blanco
p4
aS'red '
p5
asS'value '
p6
(lp7
I5
aI7
como.
Una vez que haya serializado los datos, pueden escribirse fácilmente en un archivo o enviarse a través de un
enchufe, tubería, etc.
Después de ser transmitido, es posible reconstruir el objeto serializado
(deserialización) con la función load () del módulo cPickle.
>>> nframe = pickle.loads (pickled_data)

>>> nframe
{'color': ['blanco', 'rojo'], 'valor': [5, 7]}
Decapado con pandas

Cuando se trata de encurtir (y despegar) con la biblioteca de pandas, todo es mucho
más fácil. No es necesario importar el módulo cPickle en la sesión de Python y el
toda la operación se realiza implícitamente.
169
Página 185
Además, el formato de serialización utilizado por pandas no está completamente en ASCII.
>>> marco = pd.DataFrame (np.arange (16) .reshape (4,4), índice =

['arriba abajo izquierda derecha'])
>>> marco.to_pickle ('marco.pkl')
Hay un nuevo archivo llamado frame.pkl en su directorio de trabajo que contiene todos los
información sobre el marco de datos del marco.
Para abrir un archivo PKL y leer el contenido, simplemente use este comando:
>>> pd.read_pickle ('marco.pkl')

0123
arriba 0 1 2 3
abajo 4 5 6 7
izquierda 8 9 10 11
derecha 12 13 14 15
Como puede ver, todas las implicaciones en la operación de decapado y desencadenado son
completamente oculto para el usuario de pandas, haciendo el trabajo tan fácil y comprensible como
posible, para aquellos que deben ocuparse específicamente del análisis de datos.
Nota Cuando utilice este formato, asegúrese de que el archivo que abre sea seguro. en efecto,
El formato de pepinillo no fue diseñado para protegerse contra errores y
datos construidos maliciosamente.
Interactuar con bases de datos

En muchas aplicaciones, los datos rara vez provienen de archivos de texto, dado que ciertamente no es
la forma más eficiente de almacenar datos.
Los datos a menudo se almacenan en una base de datos relacional basada en SQL, y también en muchos
bases de datos alternativas NoSQL que se han vuelto muy populares en los últimos tiempos.
Cargar datos desde SQL en un marco de datos es suficientemente simple y pandas tiene algunos
funciones para simplificar el proceso.
170
Página 186
El módulo pandas.io.sql proporciona una interfaz unificada independiente de la base de datos,

llamado sqlalchemy. Esta interfaz simplifica el modo de conexión, ya que independientemente de la
DB, los comandos siempre serán los mismos. Para hacer una conexión, usa el create_
función motor (). Con esta función puede configurar todas las propiedades necesarias para
utilice el controlador, como usuario, contraseña, puerto e instancia de base de datos.
A continuación, se muestra una lista de ejemplos para los distintos tipos de bases de datos:
>>> de sqlalchemy import create_engine
Para PostgreSQL:
>>> motor = create_engine ('postgresql: // scott: tiger @ localhost: 5432 / mydatabase')

Para MySQL
>>> motor = create_engine ('mysql + mysqldb: // scott: tiger @ localhost / foo')
Para Oracle
>>> motor = create_engine ('oracle: // scott: tiger@127.0.0.1: 1521 / sidname')
Para MSSQL
>>> motor = create_engine ('mssql + pyodbc: // mydsn')
Para SQLite
>>> motor = create_engine ('sqlite: ///foo.db')
Carga y escritura de datos con SQLite3

Como primer ejemplo, utilizará una base de datos SQLite utilizando el controlador Python integrado
sqlite3. SQLite3 es una herramienta que implementa un DBMS SQL de una manera muy simple y liviana.
manera, por lo que se puede incorporar en cualquier aplicación implementada con Python
idioma. De hecho, este práctico software le permite crear una base de datos integrada en un
fila india.
Esto la convierte en la herramienta perfecta para cualquiera que quiera tener las funciones de un
base de datos sin tener que instalar una base de datos real. SQLite3 podría ser la elección correcta
para cualquiera que quiera practicar antes de pasar a una base de datos real, o para cualquiera que
necesita utilizar las funciones de una base de datos para recopilar datos, pero permaneciendo dentro de un único
programa, sin tener que interactuar con una base de datos.
171
Página 187
Cree un marco de datos que utilizará para crear una nueva tabla en la base de datos SQLite3.
... columnas = ['blanco', 'rojo', 'azul', 'negro', 'verde'])
>>> marco
blanco rojo azul negro verde
001234
156789
2 10 11 12 13 14
3 15 16 17 18 19
Ahora es el momento de implementar la conexión a la base de datos SQLite3.
>>> motor = create_engine ('sqlite: ///foo.db')
Convierta el marco de datos en una tabla dentro de la base de datos.
>>> frame.to_sql ('colores', motor)
En cambio, para leer la base de datos, debe usar la función read_sql () con la
nombre de la tabla y el motor.
>>> pd.read_sql ('colores', motor)

índice blanco rojo azul negro verde
0001234
1156789
2 2 10 11 12 13 14
3 3 15 16 17 18 19
Como puede ver, incluso en este caso, la operación de escritura en la base de datos se ha convertido
muy simple gracias a las API de E / S disponibles en la biblioteca de pandas.
Ahora verá las mismas operaciones, pero sin usar la API de E / S. Esto puede ser
útil para tener una idea de cómo los pandas resultan ser una herramienta eficaz para leer y escribir
datos a una base de datos.
Primero, debe establecer una conexión con la base de datos y crear una tabla definiendo el
tipos de datos corregidos, para acomodar los datos que se van a cargar.
>>> importar sqlite3

>>> consulta = "" "
... prueba CREAR TABLA
172
Página 188
... (a VARCHAR (20), b VARCHAR (20),

... c REAL, d INTEGER
...); "" "
>>> con = sqlite3.connect (': memoria:')
>>> con.execute (consulta)
<objeto sqlite3.Cursor en 0x0000000009E7D730>
>>> con.commit ()
Ahora puede ingresar datos usando la instrucción SQL INSERT.
>>> datos = [('blanco', 'arriba', 1,3),

... ('negro', 'abajo', 2,8),
... ('verde', 'arriba', 4,4),
... ('rojo', 'abajo', 5,5)]
>>> stmt = "INSERT INTO test VALUES (?,?,?,?)"
>>> con.executemany (stmt, datos)
<objeto sqlite3.Cursor en 0x0000000009E7D8F0>
>>> con.commit ()
Ahora que ha visto cómo cargar los datos en una tabla, es hora de ver cómo consultar
la base de datos para obtener los datos que acaba de registrar. Esto es posible usando un SELECT de SQL
declaración.
>>> cursor = con.execute ('seleccionar * de la prueba')
>>> cursor
<objeto sqlite3.Cursor en 0x0000000009E7D730>
>>> filas = cursor.fetchall ()
>>> filas
[(u'white ', u'up', 1.0, 3), (u'black ', u'down', 2.0, 8), (u'green ', u'up',
4.0, 4), (u'red ', 5.0, 5)]
Puede pasar la lista de tuplas al constructor del marco de datos, y si necesita el

nombre de las columnas, puede encontrarlas dentro del atributo de descripción del cursor.
>>> cursor.description
(('a', Ninguno, Ninguno, Ninguno, Ninguno, Ninguno, Ninguno), ('b', Ninguno, Ninguno, Ninguno, Ninguno,
Ninguno, Ninguno), ('c
173
Página 189
uno, Ninguno, Ninguno, Ninguno, Ninguno), ('d', Ninguno, Ninguno, Ninguno, Ninguno, Ninguno, Ninguno))
>>> pd.DataFrame (filas, columnas = zip (* cursor.description) [0])
aBCD
0 blanco hasta 1 3
1 negro abajo 2 8
2 verde hasta 4 4
3 rojo abajo 5 5
Como puede ver, este enfoque es bastante laborioso.
Carga y escritura de datos con PostgreSQL

Desde pandas 0.14, la base de datos PostgreSQL también es compatible. Así que verifique si el
La versión de su PC corresponde a esta versión o superior.
>>> pd .__ versión__

>>> '0.22.0'
Para ejecutar este ejemplo, debe tener instalada en su sistema una base de datos PostgreSQL.
En mi caso creé una base de datos llamada postgres, con postgres como usuario y contraseña
como contraseña. Reemplace estos valores con los valores correspondientes a su sistema.
Lo primero que debe hacer es instalar la biblioteca psycopg2, que está diseñada para administrar y
manejar la conexión con las bases de datos.
Con Anaconda:
conda instalar psycopg2
O si está utilizando PyPi:
pip instalar psycopg2
Ahora puede establecer una conexión con la base de datos:
>>> importar psycopg2

>>> motor = create_engine ('postgresql: // postgres: contraseña @ localhost: 5432 /
postgres ')
174
Página 190
Tenga en cuenta que en este ejemplo, dependiendo de cómo instaló el paquete en Windows,
a menudo aparece el siguiente mensaje de error:
from psycopg2._psycopg import BINARY, NUMBER, STRING,

DATETIME, ROWID
ImportError: Error de carga de DLL: el módulo especificado no pudo
ser encontrado.
Esto probablemente significa que no tiene las DLL de PostgreSQL (libpq.dll en particular)
en tu RUTA. Agregue uno de los directorios postgres \ xx \ bin a su RUTA y debería
poder conectarse desde Python a sus instalaciones de PostgreSQL.
Crea un objeto de marco de datos:

índice = ['exp1', 'exp2', 'exp3', 'exp4'],
columnas = ['feb', 'mar', 'apr', 'may']);
Ahora vemos con qué facilidad puede transferir estos datos a una tabla. Con to_sql () podrás
registre los datos en una tabla llamada marco de datos.
>>> frame.to_sql ('marco de datos', motor)
pgAdmin III es una aplicación gráfica para administrar bases de datos PostgreSQL. Es una muy
herramienta útil y está presente en Linux y Windows. Con esta aplicación, es fácil de ver
el marco de datos de la tabla que acaba de crear (consulte la Figura 5-5 ).
175
Página 191
Figura 5-5. La aplicación pgAdmin III es un administrador de bases de datos gráfico perfecto para
PostgreSQL
Si conoce bien el lenguaje SQL, una forma más clásica de ver la nueva tabla creada
y su contenido usa una sesión psql.
>>> psql -U postgres
En mi caso, estoy conectado al usuario de postgres; puede ser diferente en su caso. Una vez
está conectado a la base de datos, realice una consulta SQL en la tabla recién creada.
176
Página 192
postgres = # SELECT * FROM DATAFRAME;

índice | feb | mar | abr | mayo
----- + ----------------- + ----------------- + -------- --------- + -----------------
exp1 | 0,757871296789076 | 0,422582915331819 | 0,979085739226726 | 0,332288515791064
exp2 | 0,124353978978927 | 0,273461421503087 | 0,049433776453223 | 0,0271413946693556
exp3 | 0.538089036334938 | 0.097041417119426 | 0.905979807772598 | 0.123448718583967
exp4 | 0,736585422687497 | 0,982331931474687 | 0,958014824504186 | 0,448063967996436
(4 righe)
Incluso la conversión de una tabla en un marco de datos es una operación trivial. Incluso aqui ahi
es una función read_sql_table () que lee directamente en la base de datos y devuelve un
marco de datos.
>>> pd.read_sql_table ('marco de datos', motor)

índice feb mar abr may
0 exp1 0,757871 0,422583 0,979086 0,332289
1 exp2 0.124354 0.273461 0.049434 0.027141
2 exp3 0.538089 0.097041 0.905980 0.123449
3 exp4 0,736585 0,982332 0,958015 0,448064
Pero cuando desea leer datos en una base de datos, la conversión de un todo y un solo
tabla en un marco de datos no es la operación más útil. De hecho, quienes trabajan con
Las bases de datos relacionales prefieren usar el lenguaje SQL para elegir qué datos y en qué
formulario para exportar los datos insertando una consulta SQL.
El texto de una consulta SQL se puede integrar en la función read_sql_query ().
>>> pd.read_sql_query ('SELECT index, apr, may FROM DATAFRAME WHERE apr>
0,5 ', motor)
índice abril mayo
0 exp1 0.979086 0.332289
1 exp3 0.905980 0.123449
2 exp4 0,958015 0,448064
177
Página 193
Lectura y escritura de datos con una base de datos NoSQL:

MongoDB
Entre todas las bases de datos NoSQL (BerkeleyDB, Tokyo Cabinet y MongoDB),
MongoDB se está convirtiendo en el más extendido. Dada su difusión en muchos sistemas,
Parece apropiado considerar la posibilidad de leer y escribir datos producidos con
la biblioteca de pandas durante el análisis de datos.
Primero, si tiene MongoDB instalado en su PC, puede iniciar el servicio para apuntar a
un directorio determinado.
mongod --dbpath C: \ MongoDB_data
Ahora que el servicio está escuchando en el puerto 27017, puede conectarse a esta base de datos
usando el controlador oficial de MongoDB: pymongo.
>>> importar pymongo

>>> cliente = MongoClient ('localhost', 27017)
Una sola instancia de MongoDB puede admitir varias bases de datos al mismo
hora. Entonces ahora necesita apuntar a una base de datos específica.
>>> db = client.mydatabase
>>> db
Base de datos (MongoClient ('localhost', 27017), u'mycollection ')
Para hacer referencia a este objeto, también puede utilizar
>>> cliente ['mydatabase']
Base de datos (MongoClient ('localhost', 27017), u'mydatabase ')
Ahora que ha definido la base de datos, debe definir la colección. los

colección es un grupo de documentos almacenados en MongoDB y se puede considerar el
equivalente a las tablas en una base de datos SQL.
>>> colección = db.mycollection

>>> db ['mycollection']
Colección (Base de datos (MongoClient ('localhost', 27017), u'mydatabase '),
u'mycollection ')
>>> colección
Colección (Base de datos (MongoClient ('localhost', 27017), u'mydatabase '),
u'mycollection ')
178
Página 194
Ahora es el momento de cargar los datos en la colección. Cree un DataFrame.

... columnas = ['blanco', 'rojo', 'azul', 'negro', 'verde'])
>>> marco
blanco rojo azul negro verde
001234
156789
2 10 11 12 13 14
3 15 16 17 18 19
Antes de agregarse a una colección, debe convertirse a formato JSON. los

el proceso de conversión no es tan directo como podría imaginarse; esto es porque necesitas
configurar los datos que se registrarán en la base de datos para volver a extraerlos como DataFrame de la manera más justa y
simplemente como sea posible.
>>> importar json
>>> registro = json.loads (frame.T.to_json ()). valores ()
>>> grabar
[{u'blue ': 7, u'green': 9, u'white ': 5, u'black': 8, u'red ': 6},
{u'blue ': 2, u'green': 4, u'blanco ':
0, u'black ': 3, u'red': 1}, {u'blue ': 17, u'green': 19, u'white ': 15,
u'black ': 18, u'red': 16}, {u
'azul': 12, u'green ': 14, u'white': 10, u'black ': 13, u'red': 11}]
Ahora finalmente está listo para insertar un documento en la colección,
y puede hacer esto con la función insert ().
>>> colección.mydocumento.insertar (registro)
[ObjectId ('54fc3afb9bfbee47f4260357'), ObjectId ('54fc3afb9bfbee47f4260358'),
ObjectId ('54fc3afb9bfbee47f4260359'), ObjectId ('54fc3afb9bfbee47f426035a')]
Como puede ver, tiene un objeto por cada línea grabada. Ahora que los datos han
cargado en el documento dentro de la base de datos MongoDB, puede ejecutar
el proceso inverso, es decir, leer datos en un documento y luego convertirlos en un
marco de datos.
179
Página 195
>>> cursor = colección ['mydocument']. find ()

>>> marco de datos = (lista (cursor))
>>> del dataframe ['_ id']
>>> marco de datos
negro azul verde rojo blanco
087965
132410
2 18 17 19 16 15
3 13 12 14 11 10
Ha eliminado la columna que contiene los números de identificación para la referencia interna
de MongoDB.
Conclusiones
En este capítulo, vio cómo utilizar las funciones de la API de E / S de la biblioteca pandas en
para leer y escribir datos en archivos y bases de datos conservando la estructura del
marcos de datos. En particular, varios modos de escritura y lectura de datos de acuerdo con
se ilustró el tipo de formato.
En la última parte del capítulo, vio cómo interactuar con los modelos más populares de
bases de datos para registrar y / o leer datos directamente como un marco de datos listo para ser procesado
con las herramientas de los pandas.
En el siguiente capítulo, verá las funciones más avanzadas de los pandas de la biblioteca.
Se discuten instrumentos complejos como el GroupBy y otras formas de procesamiento de datos.
en detalle.
180
Página 196
CAPÍTULO 6
pandas en profundidad: datos

Manipulación
En el capítulo anterior, vio cómo adquirir datos de fuentes de datos como
bases de datos y archivos. Una vez que tenga los datos en el formato de marco de datos, estarán listos para ser
manipulado. Es importante preparar los datos para que puedan someterse más fácilmente
al análisis y manipulación. Especialmente en preparación para la siguiente fase, los datos deben
prepárate para la visualización.
En este capítulo, profundizará en la funcionalidad que la biblioteca de pandas
ofertas para esta etapa de análisis de datos. Las tres fases de la manipulación de datos serán
tratados individualmente, ilustrando las distintas operaciones con una serie de ejemplos y sobre
cuál es la mejor forma de utilizar las funciones de esta biblioteca para realizar dichas operaciones. El tres
Las fases de la manipulación de datos son:
• Preparación de datos
• Transformación de datos
• Agregación de datos
Preparación de datos
Antes de comenzar a manipular datos, es necesario prepararlos y ensamblar
ellos en forma de estructuras de datos de modo que puedan ser manipulados más tarde con el
herramientas puestas a disposición por la biblioteca de pandas. Los diferentes procedimientos para la preparación de datos
se enumeran aquí.
• Cargando
• Montaje
181
© Fabio Nelli 2018
Página 197
CAPÍTULO 6 PANDAS EN PROFUNDIDAD: MANIPULACIÓN DE DATOS
• Fusión
• Concatenando
• Combinando
• Remodelación (pivotante)
• Eliminando
El capítulo anterior cubrió la carga. En la fase de carga, también existe esa parte
de la preparación que se refiere a la conversión de muchos formatos diferentes en un
estructura como un marco de datos. Pero incluso después de tener los datos, probablemente de diferentes
fuentes y formatos, y lo unificó en un marco de datos, deberá realizar más
operaciones de preparación. En este capítulo, y en particular en esta sección, verá cómo
para realizar todas las operaciones necesarias para obtener los datos en una estructura de datos unificada.
Los datos contenidos en los objetos pandas se pueden ensamblar de diferentes formas:
• La fusión -La función pandas.merge () conecta las filas de una

marco de datos basado en una o más claves. Este modo es muy familiar
para aquellos que confían en el lenguaje SQL, ya que también
implementa operaciones de unión.
• Concatenación : la función pandas.concat () concatena el

objetos a lo largo de un eje.
• Combinando : la función pandas.DataFrame.combine_first ()

es un método que le permite conectar datos superpuestos para
Complete los valores faltantes en una estructura de datos tomando datos de otro
estructura.
Además, parte del proceso de preparación también es pivotante, que consiste en

intercambio entre filas y columnas.
Fusión
La operación de fusión, que corresponde a la operación JOIN para aquellos que son
familiarizado con SQL, consiste en una combinación de datos a través de la conexión de filas
utilizando una o más claves.
182
Página 198
De hecho, cualquiera que trabaje con bases de datos relacionales suele utilizar la consulta JOIN con
SQL para obtener datos de diferentes tablas utilizando algunos valores de referencia (claves) compartidos entre
ellos. Sobre la base de estas claves, es posible obtener nuevos datos en forma tabular como el
resultado de la combinación de otras tablas. Esta operación con la biblioteca pandas se llama
merging y merge () es la función para realizar este tipo de operación.
Primero, debe importar la biblioteca de pandas y definir dos marcos de datos que servirán
como ejemplos para esta sección.

>>> frame1 = pd.DataFrame ({'id': ['bola', 'lápiz', 'bolígrafo', 'taza', 'cenicero'],
... 'precio': [12.33,11.44,33.21,13.23,33.62]})
>>> marco1
precio id
0 bola 12,33
1 lápiz 11,44
2 bolígrafos 33,21
3 tazas 13.23
4 cenicero 33.62
>>> frame2 = pd.DataFrame ({'id': ['lápiz', 'lápiz', 'bola', 'bolígrafo'],
... 'color': ['blanco', 'rojo', 'rojo', 'negro']})
>>> marco2
identificación de color
0 lápiz blanco
1 lápiz rojo
2 bola roja
3 bolígrafos negros
Realice la fusión aplicando la función merge () a los dos objetos del marco de datos.
>>> pd.merge (marco1, marco2)

id precio color
0 bola 12,33 roja
1 lápiz 11,44 blanco
2 lápices 11,44 rojo
3 bolígrafos 33.21 negro
183
Página 199
Como puede ver en el resultado, el marco de datos devuelto consta de todas las filas que tienen
una identificación en común. Además de la columna común, las columnas de la primera y
se agregan los segundos marcos de datos.
En este caso, usó la función merge () sin especificar ninguna columna explícitamente.
De hecho, en la mayoría de los casos es necesario decidir cuál es la columna en la que basar la
fusionando.
Para hacer esto, agregue la opción on con el nombre de la columna como clave para la fusión.
>>> frame1 = pd.DataFrame ({'id': ['bola', 'lápiz', 'bolígrafo', 'taza', 'cenicero'],

... 'color': ['blanco', 'rojo', 'rojo', 'negro', 'verde'],
... 'brand': ['OMG', 'ABC', 'ABC', 'POD', 'POD']})
>>> marco1
identificación del color de la marca
0 OMG bola blanca
1 lápiz rojo ABC
2 bolígrafos rojos ABC
Taza 3 POD negra
Cenicero 4 POD verde
>>> frame2 = pd.DataFrame ({'id': ['lápiz', 'lápiz', 'bola', 'bolígrafo'],
... 'brand': ['OMG', 'POD', 'ABC', 'POD']})
>>> marco2
identificación de marca
0 OMG lápiz
1 lápiz POD
2 bolas ABC
3 bolígrafos POD
Ahora, en este caso, tiene dos marcos de datos que tienen columnas con el mismo nombre. Así que si
lanzas una combinación, no obtienes ningún resultado.
>>> pd.merge (marco1, marco2)

DataFrame vacío
Columnas: [marca, color, identificación]
Índice: []
184
Página 200
Es necesario definir explícitamente los criterios de fusión que deben seguir los pandas,
especificando el nombre de la columna de clave en la opción on.
>>> pd.merge (frame1, frame2, on = 'id')

brand_x color id brand_y
0 OMG bola blanca ABC
1 lápiz rojo ABC OMG
2 lápiz rojo ABC POD
3 bolígrafo rojo ABC POD
>>> pd.merge (frame1, frame2, on = 'marca')
color de la marca id_x id_y
0 OMG lápiz bola blanca
1 bola de lápiz roja ABC
2 bolígrafo rojo ABC
Lápiz taza 3 POD negro
Bolígrafo taza 4 POD negro
5 lápiz cenicero verde POD
6 bolígrafo cenicero POD verde
Como era de esperar, los resultados varían considerablemente en función de los criterios de fusión.
Sin embargo, a menudo surge el problema opuesto, es decir, tener dos marcos de datos en los que
las columnas clave no tienen el mismo nombre. Para remediar esta situación, debe utilizar
las opciones left_on y right_on, que especifican la columna de clave para el primero y para el
segundo marco de datos. Ahora puedes ver un ejemplo.
>>> frame2.columns = ['marca', 'sid']

>>> marco2
marca sid
0 OMG lápiz
1 lápiz POD
2 bolas ABC
3 bolígrafos POD
>>> pd.merge (frame1, frame2, left_on = 'id', right_on = 'sid')
brand_x color id brand_y sid
0 OMG bola blanca bola ABC
1 lápiz rojo ABC lápiz OMG
2 lápiz rojo ABC lápiz POD
3 bolígrafo rojo ABC
185
Página 201
Por defecto, la función merge () realiza una unión interna; las claves en el resultado son las
resultado de una intersección.
Otras opciones posibles son la combinación izquierda , la combinación derecha y la combinación externa . El exterior
join produce la unión de todas las claves, combinando el efecto de una unión izquierda con una unión derecha. A
seleccione el tipo de unión que tiene para usar la opción cómo.
>>> frame2.columns = ['marca', 'id']

>>> pd.merge (frame1, frame2, on = 'id')
>>> pd.merge (frame1, frame2, on = 'id', how = 'externo')
Taza 4 POD negra NaN
Cenicero 5 POD verde NaN
>>> pd.merge (frame1, frame2, on = 'id', how = 'left')
Taza 4 POD negra NaN
Cenicero 5 POD verde NaN
>>> pd.merge (frame1, frame2, on = 'id', how = 'right')
186
Página 202
Para fusionar varias claves, simplemente agregue una lista a la opción de encendido.
>>> pd.merge (frame1, frame2, on = ['id', 'brand'], how = 'outside')

identificación del color de la marca
0 OMG bola blanca
1 lápiz rojo ABC
2 bolígrafos rojos ABC
Taza 3 POD negra
Cenicero 4 POD verde
5 lápiz OMG NaN
6 lápices POD NaN
7 bola ABC NaN
8 bolígrafos POD NaN
Fusionar en un índice
En algunos casos, en lugar de considerar las columnas de un marco de datos como claves, los índices podrían
utilizarse como claves para la fusión. Luego, para decidir qué índices considerar, debe
establezca las opciones left_index o right_index en True para activarlas, con la capacidad de
activarlos a ambos.
>>> pd.merge (frame1, frame2, right_index = True, left_index = True)

brand_x color id_x brand_y id_y
0 OMG bola blanca OMG lápiz
2 bolígrafo rojo ABC bola ABC
Bolígrafo 3 POD taza negra POD
Pero los objetos del marco de datos tienen una función join (), que es mucho más conveniente
cuando desee hacer la fusión por índices. También se puede utilizar para combinar muchos
Objetos de marco de datos que tienen los mismos índices o los mismos pero sin columnas superpuestas.
De hecho, si lanza
>>> frame1.join (frame2)
187
Página 203
Obtendrá un código de error porque algunas columnas en frame1 tienen el mismo nombre que
marco 2. Luego cambie el nombre de las columnas en frame2 antes de iniciar la función join () .
>>> frame2.columns = ['brand2', 'id2']
>>> frame1.join (frame2)
marca color id brand2 id2
0 OMG bola blanca OMG lápiz
2 bolígrafo rojo ABC bola ABC
Bolígrafo 3 POD taza negra POD
Cenicero 4 POD verde NaN NaN
Aquí ha realizado una fusión, pero basada en los valores de los índices en lugar de
las columnas. Esta vez también está el índice 4 que estaba presente solo en el cuadro 1, pero el
los valores correspondientes a las columnas de frame2 reportan NaN como un valor.
Concatenando
Otro tipo de combinación de datos se denomina concatenación . NumPy proporciona una
función concatenar () para hacer este tipo de operación con matrices.
>>> matriz1 = np.arange (9) .reshape ((3,3))

>>> matriz1
matriz ([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> matriz2 = np.arange (9) .reshape ((3,3)) + 6
>>> matriz2
matriz ([[6, 7, 8],
[9, 10, 11],
[12, 13, 14]])
>>> np.concatenar ([matriz1, matriz2], eje = 1)
matriz ([[0, 1, 2, 6, 7, 8],
[3, 4, 5, 9, 10, 11],
[6, 7, 8, 12, 13, 14]])
188
Página 204
>>> np.concatenar ([matriz1, matriz2], eje = 0)

matriz ([[0, 1, 2],
[3, 4, 5],
[6, 7, 8],
[6, 7, 8],
[9, 10, 11],
[12, 13, 14]])
Con la biblioteca de pandas y sus estructuras de datos como series y dataframe, teniendo
Los ejes etiquetados le permiten generalizar aún más la concatenación de matrices. El concat ()
La función es proporcionada por pandas para este tipo de operación.
>>> ser1 = pd.Series (np.random.rand (4), index = [1,2,3,4])

>>> ser1
1 0,636584
2 0,345030
3 0.157537
4 0.070351
dtype: float64
>>> ser2
5 0,411319
6 0.359946
7 0,987651
8 0.329173
dtype: float64
>>> pd.concat ([ser1, ser2])
1 0,636584
2 0,345030
3 0.157537
4 0.070351
5 0,411319
6 0.359946
7 0,987651
8 0.329173
dtype: float64
189
Página 205
Por defecto, la función concat ( ) trabaja en axis = 0, teniendo como objeto devuelto un
serie. Si establece el eje = 1, el resultado será un marco de datos.
>>> pd.concat ([ser1, ser2], eje = 1)

0 1
1 0,636584 NaN
2 0,345030 NaN
3 0,157537 NaN
4 0,070351 NaN
5 NaN 0,411319
6 NaN 0,359946
7 NaN 0,987651
8 NaN 0,329173
El problema con este tipo de operación es que las partes concatenadas no son
identificable en el resultado. Por ejemplo, desea crear un índice jerárquico en el eje
de concatenación. Para hacer esto, debes usar la opción de claves.
>>> pd.concat ([ser1, ser2], claves = [1,2])

1 1 0,636584
2 0,345030
3 0.157537
4 0.070351
2 5 0,411319
6 0.359946
7 0,987651
8 0.329173
dtype: float64
En el caso de combinaciones entre series a lo largo del eje = 1 las teclas se convierten en
encabezados de columna del marco de datos.
>>> pd.concat ([ser1, ser2], eje = 1, claves = [1,2])

1 2
1 0,636584 NaN
2 0,345030 NaN
3 0,157537 NaN
190
Página 206
4 0,070351 NaN
5 NaN 0,411319
6 NaN 0,359946
7 NaN 0,987651
8 NaN 0,329173
Hasta ahora ha visto la concatenación aplicada a la serie, pero la misma lógica puede
ser aplicado al marco de datos.
>>> frame1 = pd.DataFrame (np.random.rand (9) .reshape (3,3), index = [1,2,3],

columnas = ['A', 'B', 'C'])
>>> frame2 = pd.DataFrame (np.random.rand (9) .reshape (3,3), index = [4,5,6],
columnas = ['A', 'B', 'C'])
>>> pd.concat ([frame1, frame2])
UNA si C
1 0,400663 0,937932 0,938035
2 0,202442 0,001500 0,231215
3 0,940898 0,045196 0,723390
4 0,568636 0,477043 0,913326
5 0,598378 0,315435 0,311443
6 0,619859 0,198060 0,647902
>>> pd.concat ([marco1, marco2], eje = 1)

UNA si C UNA si C
1 0,400663 0,937932 0,938035 NaN NaN NaN
2 0,202442 0,001500 0,231215 NaN NaN NaN
3 0,940898 0,045196 0,723390 NaN NaN NaN
4 NaN NaN NaN 0,568636 0,477043 0,913326
5 NaN NaN NaN 0,598378 0,315435 0,311443
6 NaN NaN NaN 0,619859 0,198060 0,647902
Combinatorio
Existe otra situación en la que hay una combinación de datos que no se pueden obtener
ya sea con fusión o concatenación. Toma el caso en el que quieres los dos
Los conjuntos de datos deben tener índices que se superpongan en su totalidad o al menos parcialmente.
191
Página 207
Una función aplicable a la serie es combine_first (), que realiza este tipo de
operación junto con la alineación de datos.
>>> ser1 = pd.Series (np.random.rand (5), index = [1,2,3,4,5])

>>> ser1
1 0,942631
2 0.033523
3 0,886323
4 0.809757
5 0,800295
dtype: float64
>>> ser2
2 0,739982
4 0,225647
5 0,709576
6 0.214882
dtype: float64
>>> ser1.combine_first (ser2)
1 0,942631
2 0.033523
3 0,886323
4 0.809757
5 0,800295
6 0.214882
dtype: float64
>>> ser2.combine_first (ser1)
1 0,942631
2 0,739982
3 0,886323
4 0,225647
5 0,709576
6 0.214882
dtype: float64
192
Página 208
En cambio, si desea una superposición parcial, puede especificar solo la parte de la serie
desea superponer.
>>> ser1 [: 3] .combine_first (ser2 [: 3])

1 0,942631
2 0.033523
3 0,886323
4 0,225647
5 0,709576
dtype: float64
Pivotante
Además de ensamblar los datos para unificar los valores recolectados de diferentes
fuentes, otra operación bastante común es pivotar . De hecho, la disposición de los valores
por fila o por columna no siempre se adapta a sus objetivos. A veces te gustaría
reorganizar los datos por valores de columna en filas o viceversa.
Pivotar con indexación jerárquica

Ya ha visto que un marco de datos puede admitir la indexación jerárquica. Esta característica
se puede aprovechar para reorganizar los datos en un marco de datos. En el contexto de pivotar,
tienen dos operaciones básicas:
• Apilamiento : gira o pivota la estructura de datos convirtiendo columnas

a filas
• Desapilamiento: convierte filas en columnas
>>> marco1 = pd.DataFrame (np.arange (9) .reshape (3,3),

... índice = ['blanco', 'negro', 'rojo'],
... columnas = ['bola', 'bolígrafo', 'lápiz'])
>>> marco1
bolígrafo lápiz
blanco 0 1 2
negro 3 4 5
rojo 6 7 8
193
Página 209
Usando la función stack () en el marco de datos, obtendrá el pivote del

columnas en filas, produciendo así una serie:
>>> ser5 = frame1.stack ()

bola blanca 0
bolígrafo 1
lápiz 2
bola negra 3
bolígrafo 4
lápiz 5
bola roja 6
bolígrafo 7
lápiz 8
dtype: int32
A partir de esta serie indexada jerárquicamente, puede reensamblar el marco de datos en un

tabla dinámica mediante el uso de la función unstack ().
>>> ser5.unstack ()
bolígrafo lápiz
blanco 0 1 2
negro 3 4 5
rojo 6 7 8
También puede desapilar en un nivel diferente, especificando el número de niveles o su

name como argumento de la función.
>>> ser5.unstack (0)

blanco negro rojo
pelota 036
bolígrafo 147
lápiz 2 5 8
194
Página 210
Pasar de formato "largo" a "ancho"

La forma más común de almacenar conjuntos de datos se produce mediante el registro puntual de datos.
que llenará una línea del archivo de texto, por ejemplo, CSV o una tabla de una base de datos. Esto pasa
especialmente cuando tiene lecturas instrumentales, resultados de cálculos iterados a lo largo del tiempo o
la simple entrada manual de una serie de valores. Un caso similar de estos archivos es, por ejemplo
el archivo de registros, que se llena línea por línea acumulando datos en él.
La característica peculiar de este tipo de conjunto de datos es tener entradas en varios
columnas, a menudo duplicadas en líneas posteriores. Siempre permaneciendo en formato tabular de
datos, cuando se encuentre en tales casos, puede hacer referencia a ellos como formato largo o apilado .
Para tener una idea más clara al respecto, considere el siguiente marco de datos.
>>> longframe = pd.DataFrame ({'color': ['blanco', 'blanco', 'blanco',

... 'rojo', 'rojo', 'rojo',
... 'negro', 'negro', 'negro'],
... 'item': ['bola', 'bolígrafo', 'taza',
... 'bola', 'bolígrafo', 'taza',

... 'bola', 'bolígrafo', 'taza'],
... 'valor': np.random.rand (9)})
>>> fotograma largo
valor del elemento de color
0 bola blanca 0.091438
1 bolígrafo blanco 0.495049
2 taza blanca 0.956225
3 bola roja 0.394441
4 bolígrafos rojos 0.501164
5 taza roja 0.561832
6 bola negra 0.879022
7 bolígrafo negro 0.610975
8 taza negra 0.093324
Este modo de registro de datos tiene algunas desventajas. Uno, por ejemplo, es el
multiplicidad y repetición de algunos campos. Considerando las columnas como claves, los datos en
Este formato será difícil de leer, especialmente para comprender completamente las relaciones
entre los valores clave y el resto de columnas.
195
Página 211
En lugar del formato largo, hay otra forma de organizar los datos en una tabla que es
llamado ancho . Este modo es más fácil de leer, lo que permite una fácil conexión con otras tablas y
ocupa mucho menos espacio. Entonces, en general, es una forma más eficiente de almacenar los datos,
aunque menos práctico, especialmente si durante el llenado de los datos.
Como criterio, seleccione una columna, o un conjunto de ellas, como clave primaria; entonces, los valores
contenido en él debe ser único.
En este sentido, pandas te brinda una función que te permite hacer una transformación
de un marco de datos del tipo largo al tipo ancho. Esta función es pivot () y
acepta como argumentos la columna, o columnas, que asumirán el rol de clave.
A partir del ejemplo anterior, elige crear un marco de datos en formato ancho
eligiendo la columna de color como clave y el elemento como segunda clave, cuyos valores
formará las nuevas columnas del marco de datos.
>>> fotograma ancho = fotograma largo.pivot ('color', 'elemento')

>>> marco ancho
valor
bolígrafo de taza de bola de artículo
color
negro 0.879022 0.093324 0.610975
rojo 0.394441 0.561832 0.501164
blanco 0.091438 0.956225 0.495049
Como puede ver ahora, en este formato, el marco de datos es mucho más compacto y el
los datos contenidos en él son mucho más legibles.
Eliminando
La última etapa de la preparación de datos es la eliminación de columnas y filas. Ya lo tienes
visto esta parte en el Capítulo 4. Sin embargo, para completar, la descripción se reitera aquí.
Defina un marco de datos a modo de ejemplo.
>>> marco1 = pd.DataFrame (np.arange (9) .reshape (3,3),

... índice = ['blanco', 'negro', 'rojo'],
... columnas = ['bola', 'bolígrafo', 'lápiz'])
196
Página 212
>>> marco1
bolígrafo lápiz
blanco 0 1 2
negro 3 4 5
rojo 6 7 8
Para eliminar una columna, simplemente use el comando del aplicado al

marco de datos con el nombre de columna especificado.
>>> del frame1 ['bola']

>>> marco1
pluma lapiz
blanco 1 2
negro 4 5
rojo 7 8
En cambio, para eliminar una fila no deseada, debe usar la función drop () con la
etiqueta del índice correspondiente como argumento.
>>> frame1.drop ('blanco')

pluma lapiz
negro 4 5
rojo 7 8
Transformación de datos
Hasta ahora, ha visto cómo preparar datos para su análisis. Este proceso en efecto representa
un reensamblaje de los datos contenidos en un marco de datos, con posibles adiciones por otros
marco de datos y eliminación de partes no deseadas.
Ahora comenzamos la segunda etapa de la manipulación de datos: la transformación de datos. Después
organiza la forma de los datos y su eliminación dentro de la estructura de datos, es importante
para transformar sus valores. De hecho, en esta sección, verá algunos problemas comunes y
los pasos necesarios para superarlos utilizando funciones de la biblioteca de pandas.
Algunas de estas operaciones implican la presencia de valores duplicados o no válidos, con
posible remoción o reemplazo. Otras operaciones se relacionan en cambio modificando el
índices. Otros pasos incluyen el manejo y procesamiento de los valores numéricos de los datos.
y cuerdas.
197
Página 213
Eliminación de duplicados
Las filas duplicadas pueden estar presentes en un marco de datos por varias razones. En marcos de datos de
enorme tamaño, la detección de estas filas puede ser muy problemática. En este caso, pandas
proporciona una serie de herramientas para analizar los datos duplicados presentes en grandes estructuras de datos.
Primero, cree un marco de datos simple con algunas filas duplicadas.
>>> dframe = pd.DataFrame ({'color': ['blanco', 'blanco', 'rojo', 'rojo', 'blanco'],

... 'valor': [2,1,3,3,2]})
>>> dframe
valor del color
0 blanco 2
1 blanco 1
2 rojo 3
3 rojo 3
4 blanco 2
La función duplicada () aplicada a un marco de datos puede detectar las filas que parecen
ser duplicado. Devuelve una serie de valores booleanos donde cada elemento corresponde a una fila,
con Verdadero si la fila está duplicada (es decir, solo las otras apariciones, no la primera), y con
Falso si no hay duplicados en los elementos anteriores.
>>> dframe.duplicated ()
0 falso
1 falso
2 falso
3 verdadero
4 verdadero
dtype: bool
Tener una serie booleana como valor de retorno puede ser útil en muchos casos, especialmente
para el filtrado. De hecho, si desea saber cuáles son las filas duplicadas, simplemente escriba el
siguiendo:
>>> dframe [dframe.duplicated ()]

valor del color
3 rojo 3
4 blanco 2
198
Página 214
Generalmente, todas las filas duplicadas deben eliminarse del marco de datos; Para hacer eso,
pandas proporciona la función drop_duplicates (), que devuelve los marcos de datos sin
filas duplicadas.
>>> dframe [dframe.duplicated ()]

valor del color
3 rojo 3
4 blanco 2
Cartografía
La biblioteca de pandas proporciona un conjunto de funciones que, como verá en esta sección,
explotar el mapeo para realizar algunas operaciones. El mapeo no es más que el
creación de una lista de coincidencias entre dos valores diferentes, con la capacidad de vincular un valor
a una etiqueta o cadena en particular.
Para definir el mapeo no hay mejor objeto que dict objects.
mapa = {
'etiqueta1': 'valor1,
'etiqueta2': 'valor2,
...
}
Las funciones que verá en esta sección realizan operaciones específicas, pero
todos aceptan un objeto dictado.
• replace (): reemplaza valores
• map (): crea una nueva columna
• rename (): reemplaza los valores del índice
Reemplazo de valores mediante mapeo

A menudo, en la estructura de datos que ha reunido hay valores que no cumplen
tus necesidades. Por ejemplo, el texto puede estar en un idioma extranjero o puede ser un sinónimo
de otro valor, o puede que no se exprese en la forma deseada. En tales casos, un reemplazo
La operación de varios valores es a menudo un proceso necesario.
199
Página 215
Defina, como ejemplo, un marco de datos que contenga varios objetos y colores, incluidos
dos colores que no están en inglés. A menudo durante las operaciones de montaje es probable que se mantenga
mantener datos con valores en una forma indeseable.
>>> frame = pd.DataFrame ({'item': ['bola', 'taza', 'bolígrafo', 'lápiz', 'cenicero'],

... 'color': ['blanco', 'rosso', 'verde', 'negro', 'amarillo'],
'precio': [5.56,4.20,1.30,0.56,2.75]})
>>> marco
precio del artículo de color
0 bola blanca 5.56
1 taza rosso 4.20
2 bolígrafos verdes 1,30
3 lápiz negro 0.56
4 cenicero amarillo 2,75
Para poder reemplazar los valores incorrectos con nuevos valores, es necesario definir un
mapeo de correspondencias, conteniendo como clave los nuevos valores.
>>> nuevos colores = {

... 'rosso': 'rojo',
... 'verde': 'verde'
...}
Ahora lo único que puede hacer es usar la función replace () con el mapeo como
argumento.
>>> frame.replace (nuevos colores)

0 bola blanca 5.56
1 taza roja 4.20
3 lápiz negro 0.56
Como puede ver en el resultado, los dos colores se han reemplazado con el correcto
valores dentro del marco de datos. Un caso común, por ejemplo, es el reemplazo de NaN
valores con otro valor, por ejemplo 0. Puede usar replace (), que realiza su trabajo
muy bien.
200
Página 216
>>> ser = pd.Series ([1,3, np.nan, 4,6, np.nan, 3])

>>> ser
0 1,0
1 3,0
2 NaN
3 4.0
4 6.0
5 NaN
6 3.0
dtype: float64
>>> ser.replace (np.nan, 0)
0 1,0
1 3,0
2 0,0
3 4.0
4 6.0
5 0.0
6 3.0
dtype: float64
Agregar valores mediante mapeo

En el ejemplo anterior, vio cómo sustituir valores mapeando correspondencias.
En este caso, continúa explotando el mapeo de valores con otro ejemplo. En esto
caso de que esté explotando el mapeo para agregar valores en una columna dependiendo de los valores
contenido en otro. El mapeo siempre se definirá por separado.
>>> frame = pd.DataFrame ({'item': ['bola', 'taza', 'bolígrafo', 'lápiz', 'cenicero'],

... 'color': ['blanco', 'rojo', 'verde', 'negro', 'amarillo']})
>>> marco
artículo de color
0 bola blanca
1 taza roja
2 bolígrafos verdes
3 lápiz negro
4 cenicero amarillo
201
Página 217
Supongamos que desea agregar una columna para indicar el precio del artículo mostrado
en el marco de datos. Antes de hacer esto, se asume que tiene una lista de precios disponible
en algún lugar, en el que se describe el precio de cada tipo de artículo. Definir entonces un dict
objeto que contiene una lista de precios para cada tipo de artículo.
>>> precios = {
... 'bola': 5.56,
... 'taza': 4.20,
... 'botella': 1,30,
... 'tijeras': 3.41,
... 'pluma': 1,30,
... 'lápiz': 0,56,
... 'cenicero': 2,75
...}
La función map () aplicada a una serie o columna de un marco de datos acepta un

función o un objeto que contiene un dict con mapeo. Entonces en tu caso puedes aplicar
el mapeo de los precios en el artículo de la columna, asegurándose de agregar una columna al precio
marco de datos.
>>> marco ['precio'] = marco ['artículo']. mapa (precios)

>>> marco
0 bola blanca 5.56
1 taza roja 4.20
3 lápiz negro 0.56
Cambiar el nombre de los índices de los ejes

De una manera muy similar a lo que vio para los valores contenidos dentro de la serie y
el marco de datos, incluso la etiqueta del eje se puede transformar de una manera muy similar utilizando el
cartografía. Entonces, para reemplazar los índices de etiquetas, pandas proporciona la función rename (), que
toma el mapeo como un argumento, es decir, un objeto dict.
202
Página 218
>>> marco
0 bola blanca 5.56
1 taza roja 4.20
3 lápiz negro 0.56
>>> reindex = {
... 0: 'primero',
... 1 segundo',
... 2: 'tercero',
... 3: 'cuarto',
... 4: 'quinto'}
>>> frame.rename (reindexar)
primera bola blanca 5.56
segunda taza roja 4.20
tercer bolígrafo verde 1,30
cuarto lápiz negro 0.56
quinto cenicero amarillo 2.75
Como puede ver, de forma predeterminada, los índices se renombran. Si desea cambiar el nombre de las columnas
debe utilizar la opción de columnas. Esta vez asigna varias asignaciones explícitamente a la
dos opciones de índice y columna.
>>> recolumn = {
... 'item': 'objeto',
... 'valor del precio'}
>>> frame.rename (índice = reindexar, columnas = volver a columna)
valor del objeto de color
203
Página 219
También aquí, para los casos más simples en los que tiene un único valor para ser reemplazado,
puede evitar tener que escribir y asignar muchas variables.
>>> frame.rename (index = {1: 'first'}, columnas = {'item': 'object'})
0 bola blanca 5.56
primera taza roja 4.20
3 lápiz negro 0.56
Hasta ahora, ha visto que la función rename () devuelve un marco de datos con la
cambios, dejando sin cambios el marco de datos original. Si quieres que los cambios tomen
efecto sobre el objeto en el que llama a la función, establecerá la opción en el lugar para
Cierto.
>>> frame.rename (column = {'item': 'object'}, inplace = True)

>>> marco
0 bola blanca 5.56
1 taza roja 4.20
3 lápiz negro 0.56
Discretización y Binning
Un proceso de transformación más complejo que verá en esta sección es
discretización . A veces se puede utilizar, especialmente en algunos casos experimentales, para
manejar grandes cantidades de datos generados en secuencia. Realizar un análisis de la
datos, sin embargo, es necesario transformar estos datos en categorías discretas, por ejemplo,
dividiendo el rango de valores de tales lecturas en intervalos más pequeños y contando el
ocurrencia o estadísticas en ellos. Otro caso podría ser cuando tienes una gran cantidad
de muestras debido a lecturas precisas en una población. Incluso aquí, para facilitar el análisis de
los datos, es necesario dividir el rango de valores en categorías y luego analizar el
ocurrencias y estadísticas relacionadas con cada uno.
204
Página 220
En su caso, por ejemplo, puede tener una lectura de un valor experimental entre
0 y 100. Estos datos se recopilan en una lista.
>>> resultados = [12,34,67,55,28,90,99,12,3,56,74,44,87,23,49,89,87]
Sabes que los valores experimentales tienen un rango de 0 a 100; por lo tanto tu
puede dividir uniformemente este intervalo, por ejemplo, en cuatro partes iguales, es decir, bins. El primero
contiene los valores entre 0 y 25, el segundo entre 26 y 50, el tercero entre
51 y 75, y el último entre 76 y 100.
Para hacer esta agrupación con pandas, primero debe definir una matriz que contenga el
valores de separación de bin:
>>> bins = [0,25,50,75,100]
Luego usa una función especial llamada cut () y la aplica a la matriz de resultados también
pasando los contenedores.
>>> cat = pd.cut (resultados, contenedores)

>>> gato
(0, 25]
(25, 50]
(50, 75)
(50, 75)
(25, 50]
(75, 100]
(75, 100]
(0, 25]
(0, 25]
(50, 75)
(50, 75)
(25, 50]
(75, 100]
(0, 25]
(25, 50]
(75, 100]
(75, 100]
Niveles (4): Índice (['(0, 25]', '(25, 50]', '(50, 75)', '(75, 100]'],
dtype = objeto)
205
Página 221
El objeto devuelto por la función cut () es un objeto especial de tipo categórico . Tú

puede considerarlo como una matriz de cadenas que indican el nombre del contenedor. Internamente contiene
una matriz de categorías que indica los nombres de las diferentes categorías internas y un código
matriz que contiene una lista de números iguales a los elementos de los resultados (es decir, la matriz
sujeto a binning). El número corresponde al contenedor al que corresponde el
se asigna el elemento de resultados.
>>> cat.categories
IntervalIndex ([0, 25], (25, 50], (50, 75], (75, 100])
cerrado = 'derecho'
dtype = 'intervalo [int64]')
>>> códigos de gato
matriz ([0, 1, 2, 2, 1, 3, 3, 0, 0, 2, 2, 1, 3, 0, 1, 3, 3], dtype = int8)
Finalmente para conocer las ocurrencias de cada bin, es decir, cuántos resultados caen en cada
categoría, tienes que usar la función value_counts ().
>>> pd.value_counts (gato)

(75, 100] 5
(0, 25] 4
(25, 50] 4
(50, 75] 4
dtype: int64
Como puede ver, cada clase tiene el límite inferior con un paréntesis y el límite superior
con un paréntesis. Esta notación es consistente con la notación matemática que se usa
para indicar los intervalos. Si el corchete es cuadrado, el número pertenece al rango (límite
cerrado), y si es redondo, el número no pertenece al intervalo (límite abierto).
Puede dar nombres a varios bins llamándolos primero en una matriz de cadenas y
luego asignando a las opciones de etiquetas dentro de la función cut () que ha usado para
crea el objeto categórico.
>>> bin_names = ['improbable', 'menos probable', 'probable', 'muy probable']

>>> pd.cut (resultados, bins, etiquetas = bin_names)
improbable
menos probable
probable
probable
206
Página 222
menos probable
muy probable
muy probable
improbable
improbable
probable
probable
menos probable
muy probable
improbable
menos probable
muy probable
muy probable
Niveles (4): Índice (['improbable', 'menos probable', 'probable', 'muy probable'],
dtype = objeto)
Si la función cut ( ) se pasa como argumento a un entero en lugar de explicar el

bordes del contenedor, esto dividirá el rango de valores de la matriz en muchos intervalos según lo especificado
por el número.
Los límites del intervalo se tomarán por el mínimo y máximo de la muestra.
datos, es decir, la matriz sometida a agrupamiento.
>>> pd.cut (resultados, 5)

(2,904, 22,2]
(22,2, 41,4]
(60,6, 79,8]
(41,4; 60,6)
(22,2, 41,4]
(79,8, 99]
(79,8, 99]
(2,904, 22,2]
(2,904, 22,2]
(41,4; 60,6)
(60,6, 79,8]
(41,4; 60,6)
(79,8, 99]
207
Página 223
(22,2, 41,4]
(41,4; 60,6)
(79,8, 99]
(79,8, 99]
Niveles (5): Índice (['(2.904, 22.2]', '(22.2, 41.4]', '(41.4, 60.6])',
'(60.6, 79.8]', '(79.8, 99]'], dtype = objeto)
Además de cut (), pandas proporciona otro método para agrupar: qcut (). Esta
La función divide la muestra directamente en quintiles. De hecho, dependiendo de la distribución
de la muestra de datos, al usar cut (), tendrá un número diferente de ocurrencias
para cada contenedor. En su lugar, qcut () asegurará que el número de ocurrencias para cada bin sea
iguales, pero los bordes de cada contenedor varían.
>>> quintiles = pd.qcut (resultados, 5)

>>> quintiles
[3, 24]
(24, 46)
(62,6, 87]
(46, 62,6]
(24, 46)
(87, 99]
(87, 99]
[3, 24]
[3, 24]
(46, 62,6]
(62,6, 87]
(24, 46)
(62,6, 87]
[3, 24]
(46, 62,6]
(87, 99]
(62,6, 87]
Niveles (5): Índice (['[3, 24]', '(24, 46]', '(46, 62,6]', '(62,6, 87]',
'(87, 99]'], dtype = objeto)
208
Página 224
>>> pd.value_counts (quintiles)

[3, 24] 4
(62,6, 87] 4
(87, 99] 3
(46, 62,6] 3
(24, 46] 3
dtype: int64
Como puede ver, en el caso de los quintiles, los intervalos que delimitan el contenedor difieren de
los generados por la función cut (). Además, si observa las ocurrencias de cada
bin encontrará que qcut () intentó estandarizar las ocurrencias para cada bin, pero en el caso
de quintiles, los dos primeros bins tienen una ocurrencia en más porque el número de resultados
no es divisible por cinco.
Detectar y filtrar valores atípicos

Durante el análisis de datos, la necesidad de detectar la presencia de valores anormales en un
la estructura surge a menudo. A modo de ejemplo, cree un marco de datos con tres columnas de
1.000 valores completamente aleatorios:
>>> randframe = pd.DataFrame (np.random.randn (1000,3))
Con la función describe () puede ver las estadísticas de cada columna.
>>> randframe.describe ()
0 1 2
contar 1000.000000 1000.000000 1000.000000
media 0.021609 -0.022926 -0.019577
estándar 1.045777 0.998493 1.056961
min -2,981600 -2,828229 -3,735046
25% -0,675005 -0,729834 -0,737677
50% 0,003857 -0,016940 -0,031886
75% 0,738968 0,619175 0,718702
máx. 3.104202 2.942778 3.458472
209
Página 225
Por ejemplo, puede considerar valores atípicos aquellos que tienen un valor mayor que tres
veces la desviación estándar. Tener solo la desviación estándar de cada columna de la
marco de datos, use la función std ().
>>> randframe.std ()
0 1.045777
1 0.998493
2 1.056961
dtype: float64
Ahora aplica el filtrado de todos los valores del marco de datos, aplicando el
correspondiente desviación estándar para cada columna. Gracias a la función any (),
puede aplicar el filtro en cada columna.
>>> randframe [(np.abs (randframe)> (3 * randframe.std ())). any (1)]

0 1 2
69 -0.442411 -1.099404 3.206832
576 -0.154413 -1.108671 3.458472
907 2.296649 1.129156 -3.735046
Permutación
Las operaciones de permutación (reordenamiento aleatorio) de una serie o las filas de una
Los marcos de datos son fáciles de hacer usando la función numpy.random.permutation ().
Para este ejemplo, cree un marco de datos que contenga números enteros en orden ascendente.
>>> nframe = pd.DataFrame (np.arange (25) .reshape (5,5))

>>> nframe
01234
001234
156789
2 10 11 12 13 14
3 15 16 17 18 19
4 20 21 22 23 24
210
Página 226
Ahora cree una matriz de cinco enteros de 0 a 4 dispuestos en orden aleatorio con el
función permutation (). Este será el nuevo orden en el que establecer los valores de una fila de
el marco de datos.
>>> nuevo_orden = np.permutación aleatoria (5)

>>> nuevo_orden
matriz ([2, 3, 0, 1, 4])
Ahora aplíquelo al marco de datos en todas las líneas, usando la función take ().
>>> nframe.take (nuevo_orden)

01234
2 10 11 12 13 14
3 15 16 17 18 19
001234
156789
4 20 21 22 23 24
Como puede ver, el orden de las filas ha cambiado; ahora los índices siguen lo mismo
orden como se indica en la matriz new_order.
Puede enviar incluso una parte de todo el marco de datos a una permutación. Genera
una matriz que tiene una secuencia limitada a un cierto rango, por ejemplo, en nuestro caso de 2 a
4.
>>> nuevo_orden = [3,4,2]

>>> nframe.take (nuevo_orden)
01234
3 15 16 17 18 19
4 20 21 22 23 24
2 10 11 12 13 14
Muestreo aleatorio
Acaba de ver cómo extraer una parte del marco de datos determinado sometiéndolo
a la permutación. A veces, cuando tienes un marco de datos enorme, es posible que debas muestrear
de forma aleatoria, y la forma más rápida de hacerlo es utilizando np.random.randint ()
función.
211
Página 227
>>> muestra = np.random.randint (0, len (nframe), tamaño = 3)

>>> muestra
matriz ([1, 4, 4])
>>> nframe.take (muestra)
01234
156789
4 20 21 22 23 24
4 20 21 22 23 24
Como puede ver en este muestreo aleatorio, puede obtener la misma muestra aún más
a menudo.
Manipulación de cuerdas
Python es un lenguaje popular gracias a su facilidad de uso en el procesamiento de cadenas y
texto. La mayoría de las operaciones se pueden realizar fácilmente mediante el uso de funciones integradas proporcionadas por Python.
Para casos más complejos de coincidencia y manipulación, es necesario utilizar
Expresiones
Métodos integrados para la manipulación de cadenas

En muchos casos, tiene cadenas compuestas en las que le gustaría separar las
varias partes y luego asignarlas a las variables correctas. La función split () permite
separar partes del texto, tomando como punto de referencia un separador, por ejemplo, un
coma.
>>> texto = '16 Bolton Avenue, Boston '

>>> texto.split (',')
['16 Bolton Avenue ',' Boston ']
Como puede ver en el primer elemento, tiene una cadena con un carácter de espacio en el
final. Para superar este problema común, debe usar la función split () junto
con la función strip () , que recorta el espacio en blanco (incluidas las nuevas líneas).
>>> tokens = [s.strip () para s en text.split (',')]

>>> tokens
['16 Bolton Avenue ',' Boston ']
212
Página 228
El resultado es una matriz de cadenas. Si el número de elementos es pequeño y siempre el

Igualmente, una forma muy interesante de realizar asignaciones puede ser esta:
>>> dirección, ciudad = [s.strip () para s en text.split (',')]

>>> dirección
'16 Bolton Avenue '
>>> ciudad
'Bostón'
Hasta ahora, ha visto cómo dividir el texto en partes, pero a menudo también necesita lo contrario,
es decir, concatenar varias cadenas entre ellas para formar un texto más extenso.
La forma más intuitiva y sencilla es concatenar las distintas partes del texto con
el operador +.
>>> dirección + ',' + ciudad

'16 Bolton Avenue, Boston '
Esto puede ser útil cuando solo tiene dos o tres cadenas para concatenar. Si
tiene muchas partes para concatenar, un enfoque más práctico en este caso es usar
la función join () asignada al carácter separador, con la que desea unir el
Varias cuerdas.
>>> cadenas = ['A +', 'A', 'A -', 'B', 'BB', 'BBB', 'C +']
>>> ';'. join (cadenas)
'A +; A; A-; B; BB; BBB; C +'
Otra categoría de operaciones que se pueden realizar en la cadena es buscar

fragmentos de texto en ellos, es decir, subcadenas. Python proporciona la palabra clave que representa el
la mejor forma de detectar subcadenas.
>>> 'Boston' en texto

Cierto
Sin embargo, existen dos funciones que podrían servir para este propósito: index () y
encontrar().
>>> text.index ('Boston')

19
>>> text.find ('Boston')
19
213
Página 229
En ambos casos, devuelve el número de caracteres correspondientes en el texto.

donde tienes la subcadena. La diferencia en el comportamiento de estas dos funciones puede
ser visto, sin embargo, cuando no se encuentra la subcadena:
>>> text.index ('Nueva York')

Rastreo (llamadas recientes más última):
Archivo "<stdin>", línea 1, en <módulo>
ValueError: subcadena no encontrada
>>> text.find ('Nueva York')
-1
De hecho, la función index () devuelve un mensaje de error y find () devuelve -1 si el
no se encuentra la subcadena. En la misma zona, puedes saber cuántas veces un personaje
o una combinación de caracteres (subcadena) ocurre dentro del texto. La función count ()
le proporciona este número.
>>> text.count ('e')

2
>>> text.count ('Avenida')
1
Otra operación que se puede realizar en cuerdas es reemplazar o eliminar un

subcadena (o un solo carácter). En ambos casos usará la función replace (),
donde si se le pide que reemplace una subcadena con un carácter en blanco, la operación
será equivalente a la eliminación de la subcadena del texto.
>>> text.replace ('Avenida', 'Calle')

'16 Bolton Street, Boston '
>>> text.replace ('1', ")
'16 Bolton Avenue, Boston '
Expresiones regulares
Las expresiones regulares proporcionan una forma muy flexible de buscar y hacer coincidir patrones de cadenas
dentro del texto. Una sola expresión, genéricamente llamada regex , es una cadena formada según
el lenguaje de expresiones regulares. Hay un módulo de Python incorporado llamado re, que es
responsable del funcionamiento de la expresión regular.
214
Página 230
En primer lugar, cuando desee utilizar expresiones regulares, deberá importar el

módulo:
>>> importar re
El módulo re proporciona un conjunto de funciones que se pueden dividir en tres categorías:
• La coincidencia de patrones
• Sustitución
• División
Ahora empieza con algunos ejemplos. Por ejemplo, la expresión regular para expresar una secuencia
de uno o más espacios en blanco es \ s +. Como vio en la sección anterior, para dividir
texto en partes a través de un carácter separador, usó split (). Hay una división ()
función incluso para el módulo re que realiza las mismas operaciones, solo que puede aceptar un
patrón de expresiones regulares como criterio de separación, lo que lo hace considerablemente más flexible.
>>> texto = "¡Este es un \ t texto \ n extraño!"

>>> re.split ('\ s +', texto)
['Esto', 'es', 'an', 'extraño', '¡texto!']
Analicemos más profundamente el mecanismo de re módulo. Cuando llamas al re.split ()

función, la expresión regular se compila primero, luego llama a split ()
función en el argumento de texto. Puede compilar la función regex con re.compile ()
función, obteniendo así una expresión regular de objeto reutilizable y ganando en términos de ciclos de CPU.
Esto es especialmente cierto en las operaciones de búsqueda iterativa de una subcadena en un conjunto o un
Matriz de cadenas.
>>> regex = re.compile ('\ s +')
Entonces, si crea un objeto regex con la función compile (), puede aplicar split ()
directamente a él de la siguiente manera.
>>> regex.split (texto)

['Esto', 'es', 'an', 'extraño', '¡texto!']
Para hacer coincidir un patrón de expresiones regulares con cualquier otra subcadena empresarial en el texto, puede utilizar
la función findall (). Devuelve una lista de todas las subcadenas del texto que cumplen con
requisitos de la expresión regular.
215
Página 231
Por ejemplo, si desea buscar en una cadena todas las palabras que comienzan con "A" en mayúscula,
o, por ejemplo, con "a" independientemente de si está en mayúscula o minúscula, debe ingresar thr
siguiendo:
>>> text = 'Esta es mi dirección: 16 Bolton Avenue, Boston'

>>> re.findall ('A \ w +', texto)
['Avenida']
>>> re.findall ('[A, a] \ w +', texto)
['dirección', 'Avenida']
Hay otras dos funciones relacionadas con la función findall (): match () y
buscar(). Mientras que findall () devuelve todas las coincidencias dentro de una lista, la función de búsqueda ()
devuelve solo la primera coincidencia. Además, el objeto devuelto por esta función es un
objeto particular:
>>> re.search ('[A, a] \ w +', texto)

<_sre.SRE_Match objeto; intervalo = (11, 18), coincidencia = 'dirección'>
Este objeto no contiene el valor de la subcadena que responde a la expresión regular

patrón, pero devuelve sus posiciones inicial y final dentro de la cadena.
>>> buscar = re.search ('[A, a] \ w +', texto)

>>> search.start ()
11
>>> search.end ()
18
>>> texto [search.start (): search.end ()]
'habla a'
La función match () realiza coincidencias solo al principio de la cadena; sí hay

no coincide con el primer carácter, no avanza en la investigación dentro de la cadena. Si lo haces
Si no encuentra ninguna coincidencia, no devolverá ningún objeto.
>>> re.match ('[A, a] \ w +', texto)

>>>
216
Página 232
Si match () tiene una respuesta, devuelve un objeto idéntico al que viste para el
buscando función.
>>> re.match ('T \ w +', texto)

<_sre.SRE_Match objeto; intervalo = (0, 4), coincidencia = 'Esto'>
>>> coincidencia = re.match ('T \ w +', texto)
>>> texto [match.start (): match.end ()]
'Esta'
Agregación de datos
La última etapa de la manipulación de datos es la agregación de datos. La agregación de datos implica una
transformación que produce un único entero a partir de una matriz. De hecho, ya has
realizó muchas operaciones de agregación de datos, por ejemplo, cuando calculó la suma (),
mean () y count (). De hecho, estas funciones operan sobre un conjunto de datos y realizan una
cálculo con un resultado coherente que consta de un solo valor. Sin embargo, una ms formal
manera y el que tiene más control en la agregación de datos es el que incluye el
categorización de un conjunto.
La categorización de un conjunto de datos llevada a cabo para agrupar es a menudo una etapa crítica
en el proceso de análisis de datos. Es un proceso de transformación ya que, tras la división
en diferentes grupos, aplica una función que convierte o transforma los datos en algunos
manera dependiendo del grupo al que pertenezcan. Muy a menudo, las dos fases de agrupación y
La aplicación de una función se realiza en un solo paso.
También para esta parte del análisis de datos, pandas proporciona una herramienta que es muy flexible y
alto rendimiento: GroupBy.
De nuevo, como en el caso de join, aquellos familiarizados con bases de datos relacionales y SQL
el lenguaje puede encontrar similitudes. Sin embargo, lenguajes como SQL son bastante limitados
cuando se aplica a operaciones en grupos. De hecho, dada la flexibilidad de una programación
lenguaje como Python, con todas las bibliotecas disponibles, especialmente pandas, puede realizar
operaciones muy complejas en grupos.
217
Página 233
Agrupar por
Ahora analizarás en detalle el proceso de GroupBy y cómo funciona. Generalmente, es
se refiere a su mecanismo interno como un proceso llamado dividir-aplicar-combinar . En su patrón de
operación puede concebir este proceso como dividido en tres fases expresadas por tres
operaciones:
• División: división en grupos de conjuntos de datos
• Aplicar : aplicación de una función en cada grupo
• Combinación: combinación de todos los resultados obtenidos por diferentes

grupos
Analice las tres fases diferentes (ver Figura 6-1). En la primera fase, la de la escisión,
los datos contenidos dentro de una estructura de datos, como una serie o un marco de datos, se dividen
en varios grupos, de acuerdo con criterios dados, que a menudo está vinculado a índices o
ciertos valores en una columna. En la jerga de SQL, los valores contenidos en esta columna son
informado como claves. Además, si está trabajando con objetos bidimensionales como
un marco de datos, el criterio de agrupación se puede aplicar tanto a la línea (eje = 0) para que
columna (eje = 1).
Figura 6-1. El mecanismo dividir-aplicar-combinar
218
Página 234
La segunda fase, la de aplicar, consiste en aplicar una función, o mejor una

cálculo expresado precisamente por una función, que producirá un valor nuevo y único
eso es específico para ese grupo.
La última fase, la de combinar, recogerá todos los resultados obtenidos de cada
agruparlos y combinarlos para formar un nuevo objeto.
Un ejemplo practico
Acaba de ver que el proceso de agregación de datos en pandas se divide en varios
fases llamadas dividir-aplicar-combinar. Con estos pandas no se expresan explícitamente
con las funciones como era de esperar, pero mediante una función groupby () que genera una
El objeto GroupBy, entonces, es el núcleo de todo el proceso.
Para comprender mejor este mecanismo, pasemos a un ejemplo práctico. Primero defina
un marco de datos que contiene valores numéricos y de cadena.
>>> frame = pd.DataFrame ({'color': ['blanco', 'rojo', 'verde', 'rojo', 'verde'],

... 'objeto': ['bolígrafo', 'lápiz', 'lápiz', 'cenicero', 'bolígrafo'],
... 'precio1': [5.56,4.20,1.30,0.56,2.75],
... 'precio2': [4.75,4.12,1.60,0.75,3.15]})
>>> marco
color objeto precio1 precio2
0 bolígrafo blanco 5,56 4,75
1 lápiz rojo 4.20 4.12
2 lápices verdes 1,30 1,60
3 cenicero rojo 0,56 0,75
Suponga que desea calcular el promedio de la columna price1 usando etiquetas de grupo
enumerados en la columna de color. Hay varias formas de hacer esto. Por ejemplo, puede acceder
la columna precio1 y llame a la función groupby () con la columna de color.
>>> grupo = marco ['precio1']. grupo por (marco ['color'])

>>> grupo
<objeto pandas.core.groupby.SeriesGroupBy en 0x00000000098A2A20>
219
Página 235
El objeto que obtuvimos es un objeto GroupBy. En la operación que acabas de hacer,

no fue realmente ningún cálculo; solo había una recopilación de toda la información necesaria
para calcular el promedio. Lo que ha hecho es un grupo, en el que todas las filas tienen el mismo
el valor del color se agrupan en un solo elemento.
Para analizar en detalle cómo se dividió el marco de datos en grupos de filas, llame al
objeto GroupBy de los grupos de atributos.
>>> grupo.grupos
{'verde': Int64Index ([2, 4], dtype = 'int64'),
'rojo': Int64Index ([1, 3], dtype = 'int64'),
'blanco': Int64Index ([0], dtype = 'int64')}
Como puede ver, cada grupo se enumera y especifica explícitamente las filas del marco de datos
asignado a cada uno de ellos. Ahora basta con aplicar la operación en el grupo para
obtener los resultados para cada grupo individual.
>>> grupo.mean ()
color
verde 2.025
rojo 2.380
blanco 5.560
Nombre: price1, dtype: float64
>>> grupo.sum ()
color
verde 4.05
rojo 4.76
blanco 5.56
Agrupación jerárquica
Ha visto cómo agrupar los datos según los valores de una columna como opción clave.
Lo mismo se puede extender a múltiples columnas, es decir, hacer una agrupación de múltiples
claves jerárquicas.
220
Página 236
>>> ggroup = frame ['price1']. groupby ([frame ['color'], frame ['objeto']])

>>> ggroup.groups
{('verde', 'lápiz'): Int64Index ([4], dtype = 'int64'),
('verde', 'lápiz'): Int64Index ([2], dtype = 'int64'),
('rojo', 'cenicero'): Int64Index ([3], dtype = 'int64'),
('rojo', 'lápiz'): Int64Index ([1], dtype = 'int64'),
('blanco', 'lápiz'): Int64Index ([0], dtype = 'int64')}
>>> ggroup.sum ()
objeto de color
bolígrafo verde 2,75
lápiz 1,30
cenicero rojo 0.56
lápiz 4.20
bolígrafo blanco 5.56
Hasta ahora ha aplicado la agrupación a una sola columna de datos, pero en realidad puede
extenderse a varias columnas oa todo el marco de datos. También si no es necesario
reutilizar el objeto GroupBy varias veces, es conveniente combinar en una sola pasada todos
de la agrupación y cálculo a realizar, sin definir ninguna variable intermedia.
>>> marco [['precio1', 'precio2']]. groupby (marco ['color']). mean ()

precio1 precio2
color
verde 2.025 2.375
rojo 2.380 2.435
blanco 5.560 4.750
>>> frame.groupby (frame ['color']). mean ()
precio1 precio2
color
verde 2.025 2.375
rojo 2.380 2.435
blanco 5.560 4.750
221
Página 237
Iteración de grupo
El objeto GroupBy admite la operación de una iteración para generar una secuencia de dos
tuplas que contienen el nombre del grupo junto con la parte de datos.
>>> para nombre, grupo en frame.groupby ('color'):

... imprimir (nombre)
... imprimir (grupo)
...
verde
2 lápices verdes 1,30 1,60
rojo
1 lápiz rojo 4.20 4.12
3 cenicero rojo 0,56 0,75
blanco
0 bolígrafo blanco 5,56 4,75
En el ejemplo que acaba de ver, solo aplicó la variable de impresión como ilustración. En
De hecho, reemplaza la operación de impresión de una variable con la función que se le aplicará.
Cadena de transformaciones
A partir de estos ejemplos, ha visto que para cada agrupación, cuando se somete a
cálculo de funciones u otras operaciones en general, independientemente de cómo se haya obtenido y
los criterios de selección, el resultado será una serie de estructura de datos (si seleccionamos una sola columna
data) o un marco de datos, que luego conserva el sistema de índice y el nombre de las columnas.
>>> resultado1 = marco ['precio1']. groupby (marco ['color']). mean ()

>>> tipo (resultado1)
<clase 'pandas.core.series.Series'>
>>> resultado2 = frame.groupby (frame ['color']). mean ()
>>> tipo (resultado2)
<clase 'pandas.core.frame.DataFrame'>
222
Página 238
Por tanto, es posible seleccionar una sola columna en cualquier punto de las distintas fases.
de este proceso. Aquí hay tres casos en los que la selección de una sola columna en tres
se aplica a diferentes etapas del proceso. Este ejemplo ilustra la gran flexibilidad de este
sistema de agrupación proporcionado por pandas.
>>> marco ['precio1']. groupby (marco ['color']). mean ()

color
verde 2.025
rojo 2.380
blanco 5.560
>>> frame.groupby (frame ['color']) ['price1']. mean ()
color
verde 2.025
rojo 2.380
blanco 5.560
>>> (frame.groupby (frame ['color']). mean ()) ['price1']
color
verde 2.025
rojo 2.380
blanco 5.560
Además, después de una operación de agregación, los nombres de algunas columnas pueden
no ser muy significativo. De hecho, a menudo es útil agregar un prefijo al nombre de la columna.
que describe el tipo de combinación de negocios. Agregar un prefijo, en lugar de completamente
reemplazar el nombre, es muy útil para realizar un seguimiento de los datos de origen de los que
derivar valores agregados. Esto es importante si aplicas un proceso de cadena de transformación
(una serie o marco de datos se genera entre sí) en el que es importante mantener
alguna referencia con los datos de origen.
>>> significa = frame.groupby ('color'). mean (). add_prefix ('mean_')

>>> significa
mean_price1 mean_price2
223
Página 239
color
verde 2.025 2.375
rojo 2.380 2.435
blanco 5.560 4.750
Funciones en grupos
Aunque muchos métodos no se han implementado específicamente para su uso con GroupBy,
en realidad, funcionan correctamente con estructuras de datos como serie. Que viste en la anterior
sección lo fácil que es obtener la serie por un objeto GroupBy, especificando el nombre del
columna y luego aplicando el método para realizar el cálculo. Por ejemplo, puedes
utilice el cálculo de cuantiles con la función cuantiles ().
>>> grupo = frame.groupby ('color')

>>> grupo ['precio1']. cuantil (0,6)
color
verde 2.170
rojo 2.744
blanco 5.560
También puede definir sus propias funciones de agregación. Definir la función por separado
y luego pasa como argumento a la función mark (). Por ejemplo, podrías
calcular el rango de los valores de cada grupo.
>>> rango def (serie):

... return series.max () - series.min ()
...
>>> grupo ['precio1']. agg (rango)
color
verde 1,45
rojo 3.64
blanco 0.00
224
Página 240
La función agg () le permite usar funciones agregadas en un marco de datos completo.
>>> group.agg (rango)

precio1 precio2
color
verde 1,45 1,55
rojo 3,64 3,37
blanco 0,00 0,00
También puede usar más funciones agregadas al mismo tiempo, con la marca ()
función pasando una matriz que contiene la lista de operaciones a realizar, que se convertirá en
las nuevas columnas.
>>> grupo ['precio1']. agg (['media', 'estándar', rango])

rango estándar medio
color
verde 2.025 1.025305 1.45
rojo 2.380 2.573869 3.64
blanco 5.560 NaN 0.00
Agregación de datos avanzada

En esta sección, se le presentarán las funciones transform () y apply (), que
le permiten realizar muchos tipos de operaciones grupales, algunas muy complejas.
Ahora suponga que queremos juntar en el mismo marco de datos lo siguiente:
marco de datos de origen (el que contiene los datos) y el obtenido por el cálculo de
agregación de grupo, por ejemplo, la suma.
>>> frame = pd.DataFrame ({'color': ['blanco', 'rojo', 'verde', 'rojo', 'verde'],

... 'precio1': [5.56,4.20,1.30,0.56,2.75],
... 'precio2': [4.75,4.12,1.60,0.75,3.15]})
>>> marco
color precio1 precio2
0 blanco 5.56 4.75
1 rojo 4,20 4,12
2 verdes 1,30 1,60
3 rojo 0,56 0,75
225
Página 241
4 verdes 2,75 3,15

>>> sumas = frame.groupby ('color'). sum (). add_prefix ('tot_')
>>> sumas
tot_price1 tot_price2
color
verde 4.05 4,75
rojo 4,76 4.87
blanco 5.56 4,75
>>> fusionar (marco, sumas, left_on = 'color', right_index = True)
color precio1 precio2 tot_price1 tot_price2
0 blanco 5.56 4.75 5.56 4,75
1 rojo 4,20 4,12 4,76 4.87
3 rojo 0,56 0,75 4,76 4.87
2 verdes 1,30 1,60 4.05 4,75
4 verdes 2,75 3,15 4.05 4,75
Gracias a merge (), se pueden agregar los resultados de la agregación en cada línea del
marco de datos para comenzar. Pero hay otra forma de hacer este tipo de operación. Eso es por
usando transform (). Esta función realiza la agregación como ha visto antes, pero en
al mismo tiempo, muestra los valores calculados en función del valor clave en cada línea del
marco de datos para comenzar.
>>> frame.groupby ('color'). transform (np.sum) .add_prefix ('tot_')

tot_price1 tot_price2
0 5.56 4,75
1 4,76 4.87
2 4.05 4,75
3 4,76 4.87
4 4.05 4,75
Como puede ver, el método transform () es una función más especializada que tiene muy
requisitos específicos: la función pasada como argumento debe producir un solo escalar
valor (agregación) que se transmitirá.
El método para cubrir GroupBy más general es aplicable a apply (). Este método
aplica en su totalidad el esquema dividir-aplicar-combinar. De hecho, esta función divide el
objeto en partes para ser manipulado, invoca el paso de funciones en cada
pieza, y luego trata de encadenar las distintas partes.
226
Página 242
>>> frame = pd.DataFrame ({'color': ['blanco', 'negro', 'blanco', 'blanco', 'negro', 'negro'],
... 'status': ['arriba', 'arriba', 'abajo', 'abajo', 'abajo', 'arriba'],
... 'valor1': [12.33,14.55,22.34,27.84,23.40,18.33],
... 'valor2': [11.23,31.80,29.99,31.18,18.25,22.44]})
>>> marco
color estado valor1 valor2
0 blanco hasta 12,33 11,23
1 negro hasta 14,55 31,80
2 plumón blanco 22,34 29,99
3 blanco abajo 27,84 31,18
4 plumón negro 23,40 18,25
>>> frame.groupby (['color', 'status']). apply (lambda x: x.max ())

color estado valor1 valor2
estado del color
negro abajo negro abajo 23,40 18,25
hasta negro hasta 18,33 31,80
blanco abajo blanco abajo 27,84 31,18
hasta blanco hasta 12,33 11,23
5 negro hasta 18,33 22,44
>>> frame.rename (índice = reindexar, columnas = volver a columna)

valor del objeto de color
>>> temp = pd.date_range ('1/1/2015', períodos = 10, frecuencia = 'H')
>>> temp
DatetimeIndex (['2015-01-01 00:00:00', '2015-01-01 01:00:00',
'2015-01-01 02:00:00', '2015-01-01 03:00:00',
'2015-01-01 04:00:00', '2015-01-01 05:00:00',
'2015-01-01 06:00:00', '2015-01-01 07:00:00',
'2015-01-01 08:00:00', '2015-01-01 09:00:00'],
dtype = 'datetime64 [ns]', freq = 'H')
227
Página 243
Duración: 10, Frecuencia: H, Zona horaria: Ninguna

>>> serie temporal = pd.Series (np.random.rand (10), índice = temp)
>>> series temporales
2015-01-01 00:00:00 0.368960
2015-01-01 01:00:00 0.486875
2015-01-01 02:00:00 0.074269
2015-01-01 03:00:00 0,694613
2015-01-01 04:00:00 0.936190
01-01-2015 05:00:00 0.903345
2015-01-01 06:00:00 0.790933
01-01-2015 07:00:00 0.128697
2015-01-01 08:00:00 0.515943
2015-01-01 09:00:00 0.227647
Frecuencia: H, dtipo: float64
>>> calendario = pd.DataFrame ({'fecha': temp, 'valor1': np.random.rand (10),

... 'valor2': np.random.rand (10)})
>>> horario
fecha valor1 valor2
0 2015-01-01 00:00:00 0.545737 0.772712
1 2015-01-01 01:00:00 0,236035 0,082847
2 2015-01-01 02:00:00 0.248293 0.938431
3 2015-01-01 03:00:00 0.888109 0.605302
4 2015-01-01 04:00:00 0,632222 0,080418
5 2015-01-01 05:00:00 0.249867 0.235366
6 2015-01-01 06:00:00 0.993940 0.125965
7 2015-01-01 07:00:00 0.154491 0.641867
8 2015-01-01 08:00:00 0.856238 0.521911
9 2015-01-01 09:00:00 0.307773 0.332822
Luego, agrega al marco de datos que precede a una columna que representa un conjunto de valores de texto
que utilizará como valores clave.
>>> horario ['gato'] = ['arriba', 'abajo', 'izquierda', 'izquierda', 'arriba', 'arriba', 'abajo', 'derecha',
'hasta']
228
Página 244
>>> horario
fecha valor1 valor2 gato
0 2015-01-01 00:00:00 0.545737 0.772712 hasta
1 2015-01-01 01:00:00 0.236035 0.082847 abajo
2 2015-01-01 02:00:00 0.248293 0.938431 izquierda
3 2015-01-01 03:00:00 0.888109 0.605302 izquierda
4 2015-01-01 04:00:00 0,632222 0,080418 hasta
5 2015-01-01 05:00:00 0.249867 0.235366 arriba
6 2015-01-01 06:00:00 0.993940 0.125965 abajo
7 2015-01-01 07:00:00 0.154491 0.641867 derecha
8 2015-01-01 08:00:00 0.856238 0.521911 derecha
9 2015-01-01 09:00:00 0.307773 0.332822 arriba
Sin embargo, el ejemplo que se muestra aquí tiene valores clave duplicados.
Conclusiones
En este capítulo, vio las tres partes básicas que dividen la manipulación de datos:
preparación, procesamiento y agregación de datos. Gracias a una serie de ejemplos,
aprendí sobre un conjunto de funciones de biblioteca que permiten a los pandas realizar estas operaciones.
Viste cómo aplicar estas funciones en estructuras de datos simples para que puedas
familiarizarse con su funcionamiento y comprender su aplicabilidad a más
casos complejos.
Eventualmente, ahora tiene el conocimiento que necesita para preparar un conjunto de datos para el próximo
fase de análisis de datos: visualización de datos.
En el siguiente capítulo, se le presentará la biblioteca de Python matplotlib, que
puede convertir estructuras de datos en cualquier gráfico.
229
Página 245
CAPÍTULO 7
Visualización de datos
con matplotlib
Después de discutir en los capítulos anteriores las bibliotecas de Python que eran responsables de los datos
procesamiento, ahora es el momento de que vea una biblioteca que se encarga de la visualización. Esta
la biblioteca es matplotlib.
La visualización de datos a menudo se subestima en el análisis de datos, pero en realidad es un
factor muy importante porque la representación de datos incorrecta o ineficaz puede arruinar un
por lo demás excelente análisis. En este capítulo, descubrirá los diversos aspectos de la
biblioteca matplotlib, incluyendo cómo está estructurada y cómo maximizar el potencial que
Ofrece.
La biblioteca matplotlib
matplotlib es una biblioteca de Python especializada en el desarrollo de bidimensionales
gráficos (incluidos gráficos 3D). En los últimos años, se ha generalizado en el ámbito científico y
círculos de ingenieríahttp://matplolib.org ).
Entre todas las características que la han convertido en la herramienta más utilizada en la gráfica
representación de datos, hay algunos que se destacan:
• Extrema sencillez en su uso
• Desarrollo gradual y visualización interactiva de datos
• Expresiones y texto en LaTeX
• Mayor control sobre los elementos gráficos
• Exporte a muchos formatos, como PNG, PDF, SVG y EPS
231
© Fabio Nelli 2018
Página 246
CAPÍTULO 7 VISUALIZACIÓN DE DATOS CON MATPLOTLIB
matplotlib está diseñado para reproducir tanto como sea posible un entorno similar a
MATLAB en términos de vista gráfica y forma sintáctica. Este enfoque ha demostrado
exitoso, ya que ha sido capaz de explotar la experiencia del software (MATLAB) que ha
estado en el mercado durante varios años y ahora está muy extendido en todos los
círculos científicos. Matplotlib no solo se basa en un esquema conocido y bastante familiar
para la mayoría de los expertos en el campo, pero también aprovecha las optimizaciones que durante
años han llevado a una deducibilidad y simplicidad en su uso, lo que hace que esta biblioteca también
una excelente opción para quienes se acercan a la visualización de datos por primera vez, especialmente
aquellos sin experiencia con aplicaciones como MATLAB o similares.
Además de la simplicidad y la deducibilidad, la biblioteca matplotlib heredó
interactividad de MATLAB también. Es decir, el analista puede insertar un comando después
comando para controlar el desarrollo gradual de una representación gráfica de datos.
Este modo se adapta bien a los enfoques más interactivos de Python como IPython
QtConsole e IPython Notebook (consulte el Capítulo 2 ), proporcionando así un entorno
para el análisis de datos que tiene poco que envidiar a otras herramientas como Mathematica, IDL o
MATLAB.
La genialidad de quienes desarrollaron esta hermosa biblioteca fue utilizar e incorporar
las cosas buenas actualmente disponibles y en uso en la ciencia. Esto no es solo limitado, ya que
hemos visto, al modo de funcionamiento de MATLAB y similares, pero también a modelos de textual
formato de expresiones científicas y símbolos representados por LaTeX. Debido a su
gran capacidad de visualización y presentación de expresiones científicas, LaTeX ha sido un
elemento insustituible en cualquier publicación o documentación científica, donde la necesidad de
Representar visualmente expresiones como integrales, sumas y derivadas es obligatorio.
Por lo tanto, matplotlib integra este notable instrumento para mejorar la
capacidad representativa de cartas.
Además, no debes olvidar que matplotlib no es una aplicación separada sino
una biblioteca de un lenguaje de programación como Python. Así que también aprovecha al máximo las
potencial que ofrecen los lenguajes de programación. matplotlib parece una biblioteca de gráficos
que le permite administrar mediante programación los elementos gráficos que componen un gráfico
para que la pantalla gráfica se pueda controlar en su totalidad. La capacidad de programar
la representación gráfica permite gestionar la reproducibilidad de los datos
representación en múltiples entornos y especialmente cuando realiza cambios o
cuando se actualizan los datos.
232
Página 247
Además, dado que matplotlib es una biblioteca de Python, le permite explotar el

potencial de otras bibliotecas disponibles para cualquier desarrollador que implemente con este
idioma. De hecho, con respecto al análisis de datos, matplotlib normalmente coopera con un conjunto
de otras bibliotecas como NumPy y pandas, pero se pueden integrar muchas otras bibliotecas
Sin ningún problema.
Finalmente, las representaciones gráficas obtenidas mediante la codificación con esta biblioteca se pueden
exportados en los formatos gráficos más comunes (como PNG y SVG) y luego ser utilizados
en otras aplicaciones, documentación, páginas web, etc.
Instalación
Hay muchas opciones para instalar la biblioteca matplotlib. Si elige utilizar un
distribución de paquetes como Anaconda o Enthought Canopy, instalando el matplotlib
el paquete es muy simple. Por ejemplo, con el administrador de paquetes conda, debe ingresar
el seguimiento:
conda instalar matplotlib
Si desea instalar directamente este paquete, los comandos para insertar varían según
en el sistema operativo.
En los sistemas Linux Debian-Ubuntu, use esto:
sudo apt-get install python-matplotlib
En los sistemas Fedora-Redhat Linux, use esto:
sudo yum instalar python-matplotlib
En Windows o MacOS, debe usar pip para instalar matplotlib.
IPython e IPython QtConsole

Para familiarizarme con todas las herramientas proporcionadas por el mundo de Python, elegí usar
IPython tanto desde un terminal como desde QtConsole. Esto se debe a que IPython permite
explotar la interactividad de su terminal mejorado y, como verá, IPython
QtConsole también le permite integrar gráficos directamente dentro de la consola.
233
Página 248
Para ejecutar una sesión de IPython, simplemente ejecute el siguiente comando:
ipython
Python 3.6.3 (predeterminado, 15 de octubre de 2017, 03:27:45) [MSC v.1900 64 bit (AMD64)]
Escriba "derechos de autor", "créditos" o "licencia" para obtener más información.
IPython 3.6.3: un Python interactivo mejorado. Tipo '?' por ayuda.
En 1]:
Mientras que si desea ejecutar Jupyter QtConsole con la capacidad de mostrar gráficos
dentro de los comandos de línea de la sesión, usa:
jupyter qtconsole
Una ventana con una nueva sesión de IPython abierta aparecerá inmediatamente en la pantalla,
como se muestra en la Figura 7-1.
Figura 7-1. El IPython QtConsole
234
Página 249
Sin embargo, si desea continuar usando una sesión estándar de Python, puede hacerlo
entonces. Si no le gusta trabajar con IPython y desea continuar usando Python desde el
terminal, todos los ejemplos de este capítulo seguirán siendo válidos.
La arquitectura matplotlib
Una de las tareas clave que debe asumir matplotlib es proporcionar un conjunto de funciones y herramientas
que permiten la representación y manipulación de una Figura (el objeto principal), junto con
todos los objetos internos que lo componen. Sin embargo, matplotlib no solo se ocupa de
gráficos, pero también proporciona todas las herramientas para el manejo de eventos y la capacidad de animar
gráficos. Entonces, gracias a estas características adicionales, matplotlib demuestra ser capaz de
Producir gráficos interactivos basados en los eventos desencadenados al presionar una tecla en el
teclado o en el movimiento del mouse.
La arquitectura de matplotlib está estructurada lógicamente en tres capas, que son
colocados en tres niveles diferentes (ver Figura 7-2). La comunicación es unidireccional,
es decir, cada capa puede comunicarse con la capa subyacente, mientras que las capas inferiores
no se puede comunicar con los de arriba.
Figura 7-2. Las tres capas de la arquitectura matplotlib
Las tres capas son las siguientes:
• Scripting
• Artista
• Backend
235
Página 250
Capa de backend
En el diagrama de la arquitectura matplotlib, la capa que funciona en el nivel más bajo es
la capa Backend . Esta capa contiene las API de matplotlib, un conjunto de clases que juegan
papel de la implementación de los elementos gráficos a bajo nivel.
• FigureCanvas es el objeto que encarna el concepto de

área de dibujo.
• Renderer es el objeto que dibuja en FigureCanvas.
• Evento es el objeto que maneja las entradas del usuario (teclado y

eventos de ratón).
Capa de artista
Como capa intermedia, tenemos una capa llamada Artista . Todos los elementos que componen un
gráfico, como el título, las etiquetas de los ejes, los marcadores, etc., son instancias del objeto Artista. Cada uno de
Estas instancias desempeñan su papel dentro de una estructura jerárquica (como se muestra en la Figura 7-3).
Figura 7-3. Cada elemento de un gráfico corresponde a una instancia de Artista estructurada
en una jerarquía
236
Página 251
Hay dos clases de Artista: primitivo y compuesto.
• Los artistas primitivos son objetos individuales que constituyen la base

elementos para formar una representación gráfica en un diagrama, por ejemplo, un
Line2D, o como una figura geométrica como un rectángulo o un círculo, o incluso
fragmentos de texto.
• Los artistas compuestos son aquellos elementos gráficos presentes en un gráfico.

que se componen de varios elementos base, a saber, el primitivo
artistas. Los artistas compuestos son, por ejemplo, Axis, Ticks, Axes y
Figuras (ver Figura 7-4).
Por lo general, al trabajar en este nivel, tendrá que lidiar con frecuencia con objetos en niveles más altos.
jerarquía como figura, ejes y eje. Por lo tanto, es importante comprender completamente qué
Los objetos son y qué papel juegan dentro de la representación gráfica. Figura 7-4
muestra los tres objetos de artista principales (artistas compuestos) que se utilizan generalmente en todos
implementaciones realizadas a este nivel.
Figura 7-4. Los tres objetos de artista principales en la jerarquía de la capa Artista
• La figura es el objeto con el nivel más alto en la jerarquía. Eso

corresponde a la representación gráfica completa y generalmente puede
contienen muchos ejes.
237
Página 252
• Ejes es generalmente lo que usted quiere decir como diagrama o gráfico. Cada objeto Axis
pertenece a una sola figura, y se caracteriza por dos ejes de artista
(tres en el caso tridimensional). Otros objetos, como el título,
la etiqueta xy la etiqueta y pertenecen a este artista compuesto.
• Objetos de eje que tienen en cuenta los valores numéricos a ser

representados en Axes, definir los límites y gestionar los ticks (el
marca en los ejes) y marque las etiquetas (el texto de la etiqueta representado en cada
garrapata). La posición de la marca se ajusta mediante un objeto llamado localizador
mientras que la etiqueta de marcación de formato está regulada por un objeto llamado
Formateador .
Capa de secuencias de comandos (pyplot)

Las clases de artista y sus funciones relacionadas (la API matplotlib) son particularmente adecuadas para
todos los desarrolladores, especialmente para aquellos que trabajan en servidores de aplicaciones web o desarrollan el
GUI. Pero para fines de cálculo, y en particular para el análisis y visualización
de datos, la capa de secuencias de comandos es la mejor. Esta capa consta de una interfaz llamada pyplot .
pylab y pyplot
En general se habla de pylab y pyplot . Pero, ¿cuál es la diferencia entre estos
dos paquetes? Pylab es un módulo que se instala junto con matplotlib, mientras que pyplot
es un módulo interno de matplotlib. A menudo encontrará referencias a uno u otro
Acercarse.
desde pylab import *
importar matplotlib.pyplot como plt

importar numpy como np
Pylab combina la funcionalidad de pyplot con las capacidades de NumPy en un solo

espacio de nombres y, por lo tanto, no es necesario importar NumPy por separado. Además,
si importa pylab, las funciones pyplot y NumPy se pueden llamar directamente sin ningún
referencia a un módulo (espacio de nombres), haciendo que el entorno sea más similar a MATLAB.
238
Página 253
trama (x, y)
matriz ([1,2,3,4])
En vez de
plt.plot ()
np.array ([1,2,3,4]
El paquete pyplot proporciona la interfaz clásica de Python para programar el

biblioteca matplotlib, tiene su propio espacio de nombres y requiere la importación de NumPy
paquete por separado. Este enfoque es el elegido para este libro; es el tema principal de
Este capítulo; y se utilizará durante el resto del libro. De hecho, esta elección es compartida y
aprobado por la mayoría de los desarrolladores de Python.
pyplot
El módulo pyplot es una colección de funciones de estilo de comando que le permiten usar
matplotlib muy parecido a MATLAB. Cada función de pyplot funcionará o realizará algunos cambios
al objeto Figura, por ejemplo, la creación de la Figura misma, la creación de un
área de trazado, representación de una línea, decoración de la parcela con una etiqueta, etc.
Pyplot también tiene estado , ya que rastrea el estado de la figura actual y su trazado
zona. Las funciones llamadas actúan sobre la figura actual.
Un gráfico interactivo simple

Para familiarizarse con la biblioteca matplotlib y de una manera particular con Pyplot,
comience a crear un gráfico interactivo simple. Usando matplotlib, esta operación es muy simple;
de hecho, puede lograrlo usando solo tres líneas de código.
Pero primero debe importar el paquete pyplot y cambiarle el nombre a plt.
En [1]: importar matplotlib.pyplot como plt
En Python, los constructores generalmente no son necesarios; todo ya esta

definido implícitamente. De hecho, cuando importa el paquete, el objeto plt con todas sus
Las capacidades gráficas ya se han instanciado y están listas para usar. De hecho, simplemente
utilice la función plot () para pasar los valores que se trazarán.
239
Página 254
Por lo tanto, simplemente puede pasar los valores que desea representar como una secuencia de
enteros.
En [2]: plt.plot ([1,2,3,4])

Salida [2]: [<matplotlib.lines.Line2D en 0xa3eb438>]
Como puede ver, se ha generado un objeto Line2D. El objeto es una línea que
representa la tendencia lineal de los puntos incluidos en el gráfico.
Ahora está todo listo. Solo tienes que dar el comando para mostrar la trama usando show ()
función.
En [3]: plt.show ()
El resultado será el que se muestra en la Figura 7-5. Parece solo una ventana, llamada
ventana de trazado, con una barra de herramientas y la trama representada dentro de ella, al igual que con MATLAB.
Figura 7-5. La ventana de trazado
240
Página 255
La ventana de trazado
La ventana de trazado se caracteriza por una barra de herramientas en la parte superior en la que hay una serie de
botones.
• Restablece la vista original
• Va a la vista anterior / siguiente
• Desplaza los ejes con el mouse izquierdo, zoom con el derecho
• Se acerca al rectángulo
• Configura subtramas
• Guarda / exporta la figura
• Edita los parámetros de eje, curva e imagen.
El código ingresado en la consola de IPython corresponde en la consola de Python al
siguiente serie de comandos:
>>> importar matplotlib.pyplot como plt
>>> plt.plot ([1,2,3,4])
[<matplotlib.lines.Line2D en 0x0000000007DABFD0>]
>>> plt.show ()
Si está utilizando IPython QtConsole, es posible que haya notado que después de llamar al
función plot () el gráfico se muestra directamente sin invocar explícitamente la función show ()
función (consulte la Figura 7-6 ).
241
Página 256
Figura 7-6. QtConsole muestra el gráfico directamente como salida
Si pasa solo una lista de números o una matriz a la función plt.plot (), matplotlib
asume que es la secuencia de valores y del gráfico, y los asocia al valor natural
secuencia de valores x: 0,1,2,3, ....
Generalmente, un gráfico representa pares de valores (x, y), por lo que si desea definir un gráfico
correctamente, debe definir dos matrices, la primera que contiene los valores en el eje xy
el segundo contiene los valores en el eje y. Además, la función plot () puede
Acepte un tercer argumento, que describe los detalles de cómo desea que sea el punto.
representado en el gráfico.
242
Página 257
Establecer las propiedades de la parcela

Como puede ver en la Figura 7-6, los puntos estaban representados por una línea azul. De hecho, si lo haces
no especifique lo contrario, la trama se representa teniendo en cuenta una configuración predeterminada
de la función plt.plot ():
• El tamaño de los ejes coincide perfectamente con el rango de los datos de entrada
• No hay título ni etiquetas de eje.
• No hay leyenda
• Se dibuja una línea azul que conecta los puntos
Por lo tanto, debe cambiar esta representación para tener una trama real en la que cada
par de valores (x, y) está representado por un punto rojo (ver Figura 7-7).
Si está trabajando en IPython, cierre la ventana para volver al indicador activo de
ingresando nuevos comandos. Luego debe volver a llamar a la función show () para observar el
cambios realizados en la trama.
En [4]: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')

Salida [4]: [<matplotlib.lines.Line2D en 0x93e6898>]
En [5]: plt.show ()
En cambio, si está trabajando en Jupyter QtConsole, verá un gráfico diferente para cada nuevo
comando que ingresa.
243
Página 258
Figura 7-7. Los pares de valores (x, y) se representan en la gráfica mediante círculos rojos
Nota En este punto del libro, ya tiene una idea muy clara sobre el
diferencia entre los distintos entornos. Para evitar confusiones desde este punto,
Consideraré IPython QtConsole como el único entorno de desarrollo.
244
Página 259
Capítulo 7 Visualización de datos con matplotlib
Puede definir el rango tanto en el eje x como en el eje y definiendo los detalles
de una lista [ xmin, xmax, ymin, ymax ] y luego pasarla como argumento al eje ()
función.
Tenga en cuenta que en ipython QtConsole, para generar un gráfico a veces es necesario
ingrese más filas de comandos. para evitar generar un gráfico cada vez que presione
ingrese (comience una nueva línea) junto con la pérdida de la configuración especificada anteriormente, debe
presione Ctrl + enter. cuando desee generar finalmente el gráfico, simplemente presione enter dos veces.
Puede establecer varias propiedades, una de las cuales es el título que se puede ingresar usando el
función title ().
En [4]: plt.axis ([0,5,0,20])

...: plt.title ('Mi primera trama')
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
Salida [4]: [<matplotlib.lines.Line2D en 0x97f1c18>]
En figura 7-8 puede ver cómo la nueva configuración hizo que la trama fuera más legible. En
De hecho, los puntos finales del conjunto de datos ahora se representan dentro de la gráfica en lugar de en el
bordes. Además, el título de la trama ahora es visible en la parte superior.
Figura 7-8. La parcela después de que se hayan establecido las propiedades
245
Página 260
matplotlib y NumPy
Incluso la biblioteca matplot, a pesar de ser una biblioteca completamente gráfica, tiene su base como
la biblioteca NumPy. De hecho, ha visto hasta ahora cómo pasar listas como argumentos, tanto para
representar los datos y establecer los extremos de los ejes. En realidad, estas listas han sido
convertido internamente en matrices NumPy.
Por lo tanto, puede ingresar directamente matrices NumPy como datos de entrada. Esta matriz de datos,
que han sido procesados por pandas, se pueden usar directamente con matplotlib sin
su posterior procesamiento.
Como ejemplo, ve cómo es posible trazar tres tendencias diferentes en el mismo
trama (vea la Figura 7-9 ). Puede elegir para este ejemplo la función sin () perteneciente a
el módulo de matemáticas. Entonces necesitarás importarlo. Para generar puntos siguiendo una sinusoidal
tendencia, utilizará la biblioteca NumPy. Genere una serie de puntos en el eje x usando el
función arange (), mientras que para los valores en el eje y usará la función map () para
aplique la función sin () en todos los elementos de la matriz (sin usar un bucle for).
En [5]: importar matemáticas

En [6]: importar numpy como np
En [7]: t = np. Rango (0,2.5,0.1)
...: y1 = np.sin (math.pi * t)
...: y2 = np.sin (math.pi * t + math.pi / 2)
...: y3 = np.sin (math.pi * t-math.pi / 2)
En [8]: plt.plot (t, y1, 'b *', t, y2, 'g ^', t, y3, 'ys')
Fuera [8]:
[<matplotlib.lines.Line2D en 0xcbd2e48>,
<matplotlib.lines.Line2D en 0xcbe10b8>,
<matplotlib.lines.Line2D en 0xcbe15c0>]
246
Página 261
Figura 7-9. Tres tendencias sinusoidales desfasadas por π / 4 representadas por marcadores
Tenga en cuenta si no está utilizando el conjunto ipython QtConsole con matplotlib en línea o si
están implementando este código en una sesión simple de Python, inserte el plt.show ()
comando al final del código para obtener el gráfico que se muestra en la Figura 7-10 .
Como puede ver en la Figura 7-9, la trama representa las tres tendencias temporales diferentes
con tres colores y marcadores diferentes. En estos casos, cuando la tendencia de una función es
tan obvio, la trama tal vez no sea la representación más apropiada, pero es mejor
para usar las líneas (vea la Figura 7-10 ). Diferenciar las tres tendencias con algo diferente
que el color, puede utilizar el patrón compuesto por diferentes combinaciones de puntos y
guiones (- y.).
En [9]: plt.plot (t, y1, 'b -', t, y2, 'g', t, y3, 'r-.')
Fuera [9]:
[<matplotlib.lines.Line2D en 0xd1eb550>,
<matplotlib.lines.Line2D en 0xd1eb780>,
<matplotlib.lines.Line2D en 0xd1ebd68>]
Tenga en cuenta si no está utilizando el conjunto ipython QtConsole con matplotlib en línea o si
están implementando este código en una sesión simple de Python, inserte el plt.show ()
comando al final del código para obtener el gráfico que se muestra en la Figura 7-10 .
247
Página 262
Figura 7-10. Este gráfico representa los tres patrones sinusoidales con líneas de colores.
Usando los kwargs

Los objetos que componen un gráfico tienen muchos atributos que los caracterizan. Estas
Los atributos son todos valores predeterminados, pero se pueden establecer mediante el uso de argumentos de palabras clave, a menudo
referidos como kwargs .
Estas palabras clave se pasan como argumentos a funciones. En documentación de referencia
de las diversas funciones de la biblioteca matplotlib, siempre las encontrará denominadas
kwargs en la última posición. Por ejemplo, la función plot () que está utilizando en estos
Se hace referencia a los ejemplos de la siguiente manera.
matplotlib.pyplot.plot (* argumentos, ** kwargs)
Para un ejemplo práctico, el grosor de una línea se puede cambiar si configura el

palabra clave linewidth (consulte la Figura 7-11 ).
En [10]: plt.plot ([1,2,4,2,1,0,1,2,1,4], linewidth = 2.0)

Salida [10]: [<matplotlib.lines.Line2D en 0xc909da0>]
248
Página 263
Figura 7-11. El grosor de una línea se puede configurar directamente desde la función plot ()
Trabajar con varias figuras y ejes

Hasta ahora, ha visto cómo todos los comandos de pyplot se envían a la pantalla de una sola figura.
En realidad, matplotlib le permite administrar varias figuras simultáneamente y dentro de
cada figura, ofrece la posibilidad de ver diferentes parcelas definidas como subparcelas.
Entonces, cuando trabaje con pyplot, siempre debe tener en cuenta el concepto de
la figura actual y los ejes actuales (es decir, la gráfica que se muestra dentro de la figura).
Ahora verá un ejemplo en el que se representan dos subtramas en una sola figura.
La función subplot (), además de subdividir la figura en diferentes áreas de dibujo,
se utiliza para enfocar los comandos en una subtrama específica.
El argumento pasado a la función subplot () establece el modo de subdivisión y
determina cuál es la subtrama actual. La subtrama actual será la única figura
que se verá afectado por los comandos. El argumento de la función subplot () es
compuesto por tres enteros. El primer número define cuántas partes se divide la figura.
en vertical. El segundo número define en cuántas partes se divide la figura
horizontalmente. El tercer problema selecciona cuál es la subtrama actual sobre la que puede dirigir
comandos.
Ahora mostrará dos tendencias sinusoidales (seno y coseno) y la mejor manera de hacerlo
es decir, dividir el lienzo verticalmente en dos subparcelas horizontales (como se muestra en la Figura 7- 12 ).
Entonces, los números para pasar como argumento son 211 y 212.
249
Página 264
En [11]: t = np. Rango (0,5,0.1)

...: y1 = np.sin (2 * np.pi * t)
...: y2 = np.sin (2 * np.pi * t)
En [12]: plt.subplot (211)
...: plt.plot (t, y1, 'b-.')
...: subparcela plt. (212)
...: plt.plot (t, y2, 'r--')
Fuera [12]: [<matplotlib.lines.Line2D en 0xd47f518>]
Figura 7-12. La figura se ha dividido en dos subparcelas horizontales.
Ahora haces lo mismo dividiendo la figura en dos subparcelas verticales. los

los números que se pasarán como argumentos a la función subplot () son 121 y 122
(como se muestra en la Figura 7-13).
En []: t = np. Rango (0., 1., 0.05)

...: y1 = np.sin (2 * np.pi * t)
...: y2 = np.cos (2 * np.pi * t)
En []: plt.subplot (121)
...: plt.plot (t, y1, 'b-.')
...: subparcela plt. (122)
...: plt.plot (t, y2, 'r--')
Fuera [94]: [<matplotlib.lines.Line2D en 0xed0c208>]
250
Página 265
Figura 7-13. La figura se ha dividido en dos subtramas verticales.
Agregar elementos al gráfico

Para hacer un gráfico más informativo, muchas veces no es suficiente representar el
datos usando líneas o marcadores y asigne el rango de valores usando dos ejes. De hecho, hay
Hay muchos otros elementos que se pueden agregar a un gráfico para enriquecerlo con
información.
En esta sección, verá cómo agregar elementos al gráfico como etiquetas de texto, una leyenda,
y así.
Agregar texto
Ya ha visto cómo puede agregar el título a un gráfico con la función title (). Dos
otras indicaciones textuales puede agregar las etiquetas de los ejes. Esto es posible mediante el uso de
otras dos funciones específicas, llamadas xlabel () y ylabel (). Estas funciones toman como
argumento una cadena, que será el texto mostrado.
Nota Las líneas de comando que forman el código para representar su gráfico están creciendo en
número. No es necesario que vuelva a escribir todos los comandos cada vez, pero utilice el
teclas de flecha en el teclado, puede abrir la lista de comandos previamente
pasados y edítelos agregando nuevas filas (en el texto se indican en negrita).
251
Página 266
Ahora agregue dos etiquetas de eje al gráfico. Describirán qué tipo de valor es
asignado a cada eje (como se muestra en la Figura 7-14).
En [10]: plt.axis ([0,5,0,20])

...: plt.title ('Mi primera trama')
...: plt.xlabel ('Contando')
...: plt.ylabel ('Valores cuadrados')
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
Salida [10]: [<matplotlib.lines.Line2D en 0x990f3c8>]
Figura 7-14. Un gráfico es más informativo al agregar etiquetas de eje
Gracias a las palabras clave, puedes cambiar las características del texto. Por ejemplo,
puede modificar el título cambiando la fuente y aumentando el tamaño de los caracteres.
También puede modificar el color de las etiquetas de los ejes para acentuar el título del gráfico.
(como se muestra en la Figura 7-15).
En []: plt.axis ([0,5,0,20])

...: plt.title ('Mi primera trama', tamaño de fuente = 20, nombre de fuente = 'Times New Roman')
...: plt.xlabel ('Contando', color = 'gris')
...: plt.ylabel ('Valores cuadrados', color = 'gris')
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
Fuera [116]: [<matplotlib.lines.Line2D en 0x11f17470>]
252
Página 267
Figura 7-15. El texto se puede modificar configurando las palabras clave
Pero matplotlib no se limita a esto: pyplot le permite agregar texto a cualquier posición
dentro de un gráfico. Esta característica es realizada por una función específica llamada text ().
texto (x, y, s, fontdict = Ninguno, ** kwargs)
Los dos primeros argumentos son las coordenadas de la ubicación donde desea colocar
el texto. s es la cadena de texto que se agregará y fontdict (opcional) es la fuente que
quiere usar. Finalmente, puede agregar las palabras clave.
Agrega la etiqueta a cada punto de la trama. Porque los dos primeros argumentos del texto ()
función son las coordenadas del gráfico, tienes que usar las coordenadas de los cuatro
los puntos del gráfico se desplazaron ligeramente en el eje y.
En []: plt.axis ([0,5,0,20])

...: plt.text (1,1.5, 'Primero')
...: plt.text (2,4.5, 'Segundo')
...: plt.text (3,9.5, 'Tercero')
...: plt.text (4,16.5, 'Cuarto')
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
253
Página 268
Como puede ver en la Figura 7-16, ahora cada punto de la trama tiene una etiqueta.
Figura 7-16. Cada punto de la trama tiene una etiqueta informativa
Dado que matplotlib es una biblioteca de gráficos diseñada para ser utilizada en círculos científicos,
debe ser capaz de explotar todo el potencial del lenguaje científico, incluidas las matemáticas
Expresiones matplotlib ofrece la posibilidad de integrar expresiones LaTeX, por lo tanto
permitiéndole insertar expresiones matemáticas dentro del gráfico.
Para hacer esto, puede agregar una expresión LaTeX al texto, encerrándola entre dos $
caracteres. El intérprete las reconocerá como expresiones LaTeX y las convertirá
al gráfico correspondiente, que puede ser una expresión matemática, una fórmula,
caracteres matemáticos, o simplemente letras griegas. Generalmente tienes que preceder a la cadena
que contiene expresiones LaTeX con una r, que indica texto sin formato, para evitar
secuencias de escape no deseadas.
Aquí, también puede utilizar las palabras clave para enriquecer aún más el texto que se mostrará en el
trama. Por lo tanto, como ejemplo, puede agregar la fórmula que describe la tendencia seguida de
el punto del gráfico y enciérrelo en un cuadro delimitador de color (consulte la Figura 7-17).
254
Página 269
En []: plt.axis ([0,5,0,20])

...: plt.text (1.1,12, r '$ y = x ^ 2 $', tamaño de fuente = 20, bbox = {'facecolor': 'amarillo',
'alfa': 0.2})
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
Fuera [130]: [<matplotlib.lines.Line2D en 0x13920860>]
Figura 7-17. Cualquier expresión matemática se puede ver en el contexto de un gráfico.
Para obtener una visión completa del potencial que ofrece LaTeX, consulte el Apéndice A de
este libro.
255
Página 270
Agregar una cuadrícula

Otro elemento que puede agregar a una gráfica es una cuadrícula. A menudo, su adición es necesaria para
comprender mejor la posición ocupada por cada punto en el gráfico.
Agregar una cuadrícula a un gráfico es una operación muy simple: simplemente agregue la función grid (),
pasando True como argumento (ver Figura 7-18 ).
En []: plt.axis ([0,5,0,20])

...: plt.text (1.1,12, r '$ y = x ^ 2 $', tamaño de fuente = 20, bbox = {'facecolor': 'amarillo',
'alfa': 0.2})
...: plt.grid (Verdadero)
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
Figura 7-18. Una cuadrícula facilita la lectura de los valores de los puntos de datos
representado en un gráfico
256
Página 271
Agregar una leyenda

Otro componente muy importante que debe estar presente en cualquier gráfico es la leyenda.
pyplot también proporciona una función específica para este tipo de objeto: legend ().
Agregue una leyenda a su gráfico con la función legend () y una cadena que indique el
palabras con las que desea que se muestre la serie. En este ejemplo, asigna el primer
nombre de la serie a la matriz de datos de entrada (consulte la Figura 7-19 ).
En []: plt.axis ([0,5,0,20])

...: plt.text (1.1,12, '$ y = x ^ 2 $', tamaño de fuente = 20, bbox = {'facecolor': 'amarillo',
'alfa': 0.2})
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
...: plt.legend (['Primera serie'])
Fuera [156]: <matplotlib.legend.Legend en 0x16377550>
Figura 7-19. Se agrega una leyenda en la esquina superior derecha de forma predeterminada
257
Página 272
Como puede ver en la Figura 7-19, la leyenda se agrega en la esquina superior derecha por
defecto. Nuevamente, si desea cambiar este comportamiento, deberá agregar algunos kwargs. por
ejemplo, la posición ocupada por la leyenda se establece asignando números del 0 al 10 para
el loc kwarg. Cada uno de estos números caracteriza una de las esquinas del gráfico.
(ver Tabla 7-1). El valor predeterminado es 1, es decir, la esquina superior derecha. En el proximo
Por ejemplo, moverá la leyenda en la esquina superior izquierda para que no se superponga con la
puntos representados en la trama.
Tabla 7-1. Los valores posibles para la palabra clave loc
Código de localización Cadena de ubicación
0 mejor
1 superior derecha
2 arriba a la izquierda
3 inferior derecha
4 abajo a la izquierda
5 Derecha
6 centro-izquierda
7 centro-derecha
8 centro inferior
9 centro superior
10 centrar
Antes de que comience a modificar el código para mover la leyenda, quiero agregar un pequeño aviso.
Generalmente, las leyendas se utilizan para indicar la definición de una serie al lector a través de
una etiqueta asociada a un color y / o un marcador que lo distingue en la trama. Hasta aquí
en los ejemplos, ha utilizado una sola serie que se expresó mediante un solo gráfico ()
función. Ahora, debe centrarse en un caso más general en el que la misma trama muestra
más series simultáneamente. Cada serie del gráfico se caracterizará por una
color y un marcador específico (ver Figura 7-20). En términos de código, en cambio, cada serie será
caracterizado por una llamada a la función plot () y el orden en el que se definen será
corresponden al orden de las etiquetas de texto pasadas como argumento a la función legend ().
258
Página 273
En []: importar matplotlib.pyplot como plt

...: eje plt. ([0,5,0,20])
'alfa': 0.2})
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
...: plt.plot ([1,2,3,4], [0.8,3.5,8,15], 'g ^')
...: plt.plot ([1,2,3,4], [0.5,2.5,4,12], 'b *')
...: plt.legend (['Primera serie', 'Segunda serie', 'Tercera serie'], loc = 2)
Fuera [170]: <matplotlib.legend.Legend en 0x1828d7b8>
Figura 7-20. Una leyenda es necesaria en cada gráfico multiserie.
259
Página 274
Guardar sus gráficos

En esta sección, aprenderá cómo guardar su gráfico de diferentes formas dependiendo de su
necesidades. Si necesita reproducir su gráfico en diferentes cuadernos o sesiones de Python, o
reutilizarlos en proyectos futuros, es una buena práctica guardar el código Python. En el otro
Por otro lado, si necesita realizar informes o presentaciones, puede ser muy útil guardar su
gráfico como imagen. Además, es posible guardar su gráfico como una página HTML, y esto
podría resultar muy útil cuando necesite compartir su trabajo en la Web.
Guardar el código
Como puede ver en los ejemplos de las secciones anteriores, el código relativo al
La representación de un solo gráfico está creciendo en un buen número de filas. Una vez que piensas
ha llegado a un buen punto en su proceso de desarrollo, puede optar por guardar todos
filas de código en un archivo .py que puede recuperar en cualquier momento.
Puede usar el comando mágico save% seguido del nombre del archivo que desea
guardar seguido del número de solicitudes de entrada que contienen la fila de código que desea
ahorrar. Si todo el código está escrito en un solo mensaje, como su caso, debe agregar solo
su número; de lo contrario, si desea guardar el código escrito en muchas solicitudes, por ejemplo
del 10 al 20, hay que indicar este rango con los dos números separados por un -, que
es, 10-20.
En su caso, guardaría el código Python subyacente a la representación de su
primer gráfico contenido en el indicador de entrada con el número 171.
En [171]: importar matplotlib.pyplot como plt

...
Debe insertar el siguiente comando para guardar el código en un nuevo archivo .py.
% guardar my_first_chart 171
Después de ejecutar el comando, encontrará el archivo my_first_chart.py en su

directorio de trabajo (ver Listado 7-1).
260
Página 275
Listado 7-1. my_first_chart.py
# codificación: utf-8
eje plt. ([0,5,0,20])
plt.title ('Mi primera trama', tamaño de fuente = 20, nombre de fuente = 'Times New Roman')
plt.xlabel ('Contando', color = 'gris')
plt.ylabel ('Valores cuadrados', color = 'gris')
plt.text (1,1.5, 'Primero')
plt.text (2,4.5, 'Segundo')
plt.text (3,9.5, 'Tercero')
plt.text (4,16.5, 'Cuarto')
plt.text (1.1,12, '$ y = x ^ 2 $', tamaño de fuente = 20, bbox = {'facecolor': 'amarillo',
'alfa': 0.2})
plt.grid (verdadero)
plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
plt.plot ([1,2,3,4], [0.8,3.5,8,15], 'g ^')
plt.plot ([1,2,3,4], [0.5,2.5,4,12], 'b *')
plt.legend (['Primera serie', 'Segunda serie', 'Tercera serie'], loc = 2)
Más tarde, cuando abra una nueva sesión de IPython, tendrá su gráfico y comenzará a
cambie el código en el punto donde lo había guardado ingresando el siguiente comando:
ipython qtconsole --matplotlib en línea -m my_first_chart.py
O puede volver a cargar el código completo en un solo mensaje en QtConsole usando el

comando mágico% de carga.
% load my_first_chart.py
O puede ejecutarlo durante una sesión con el comando mágico% run.
% ejecutar my_first_chart.py
Nota en mi sistema, este comando funciona solo después de iniciar los dos anteriores
comandos.
261
Página 276
Conversión de su sesión a un archivo HTML

Usando IPython QtConsole, puede convertir todo el código y gráficos presentes en su
sesión actual a una página HTML. Simplemente elija Archivo -> Guardar en HTML / XHTML desde el
menú (como se muestra en la Figura 7-21).
Figura 7-21. Puede guardar su sesión actual como una página web
Se le pedirá que guarde su sesión en dos formatos diferentes: HTML y

XHMTL. La diferencia entre los dos formatos se basa en el tipo de conversión de imagen.
Si selecciona HTML como formato de archivo de salida, las imágenes contenidas en su sesión
convertirse a formato PNG. Si selecciona XHTML como formato de archivo de salida, el
las imágenes se convertirán a formato SVG.
262
Página 277
En este ejemplo, guarde su sesión como un archivo HTML y asígnele el nombre my_session.html, como
se muestra en la Figura 7-22.
Figura 7-22. Puede seleccionar el tipo de archivo entre HTML y XHTML
En este punto, se le preguntará si desea guardar sus imágenes en una

directorio o en línea (ver Figura 7-23 ).
Figura 7-23. Puede elegir entre crear archivos de imagen externos e incrustar
el formato PNG directamente en la página HTML
Al elegir la opción externa, las imágenes se recopilarán en un directorio llamado

my_session_files. Al elegir en línea, la información gráfica relativa a la imagen
está incrustado en el código HTML.
263
Página 278
Guardar su gráfico directamente como una imagen

Si está interesado en guardar solo la figura de un gráfico como archivo de imagen, ignorando todos
el código que ha escrito durante la sesión, esto también es posible. De hecho, gracias a
la función savefig (), puede guardar directamente el gráfico en formato PNG, aunque
debe tener cuidado de agregar esta función al final de la misma serie de comandos
(de lo contrario, obtendrá un archivo PNG en blanco).
En []: plt.axis ([0,5,0,20])

'alfa': 0.2})
...: plt.plot ([1,2,3,4], [1,4,9,16], 'ro')
...: plt.plot ([1,2,3,4], [0.8,3.5,8,15], 'g ^')
...: plt.plot ([1,2,3,4], [0.5,2.5,4,12], 'b *')
...: plt.legend (['Primera serie', 'Segunda serie', 'Tercera serie'], loc = 2)
...: plt.savefig ('my_chart.png')
Al ejecutar el código anterior, se creará un nuevo archivo en su directorio de trabajo.

Este archivo se llamará my_chart.png y contendrá la imagen de su gráfico.
Manejo de valores de fecha

Uno de los problemas más comunes que se encuentran al realizar análisis de datos es el manejo
datos del tipo fecha-hora. Mostrar esos datos a lo largo de un eje (normalmente el eje x) se puede
problemático, especialmente cuando se manejan garrapatas (ver Figura 7-24 ).
264
Página 279
Tomemos, por ejemplo, la visualización de un gráfico lineal con un conjunto de datos de ocho puntos en el que
tiene que representar los valores de fecha en el eje x con el siguiente formato: día-mes-año.
En []: importar fecha y hora

...: importar numpy como np
...: importar matplotlib.pyplot como plt
...: events = [datetime.date (2015,1,23), datetime.
date (2015,1,28), datetime.date (2015,2,3), datetime.
fecha (2015,2,21), fecha y hora.fecha (2015,3,15), fecha y hora.
fecha (2015,3,24), datetime.date (2015,4,8), datetime.date (2015,4,24)]
...: lecturas = [12,22,25,20,18,15,17,14]
...: plt.plot (eventos, lecturas)
Salida [83]: [<matplotlib.lines.Line2D en 0x12666400>]
Figura 7-24. Si no se maneja, mostrar los valores de fecha y hora puede ser problemático
Como puede ver en la Figura 7-24, gestión automática de garrapatas, y especialmente la

marque las etiquetas, puede ser un desastre. Las fechas expresadas de esta manera son difíciles de leer,
no hay intervalos de tiempo claros transcurridos entre un punto y otro, y hay
también se superponen.
265
Página 280
Por tanto, para gestionar las fechas es aconsejable definir una escala de tiempo con
objetos. Primero necesita importar matplotlib.dates, un módulo especializado para este tipo
de datos. Luego define las escalas de los tiempos, como en este caso, una escala de días y una de
los meses, a través de las funciones MonthLocator () y DayLocator (). En estos casos,
el formato también es muy importante, y para evitar superposiciones o referencias innecesarias,
hay que limitar las etiquetas de tick a lo esencial, que en este caso es año-mes. Esta
El formato se puede pasar como argumento a la función DateFormatter ().
Después de definir las dos escalas, una para los días y otra para los meses, puede
establecer dos tipos diferentes de ticks en el eje x, usando set_major_locator () y set_
minor_locator () funciona en el objeto xaxis. En su lugar, para establecer el formato de texto de la marca
etiquetas referidas a los meses en los que tienes que usar la función set_major_formatter ().
Al cambiar todas estas configuraciones, finalmente obtiene el gráfico como se muestra en la Figura 7-25.
En []: importar fecha y hora

...: importar matplotlib.dates como mdates
...: meses = mdates.MonthLocator ()
...: días = mdates.DayLocator ()
...: timeFmt = mdates.DateFormatter ('% Y-% m')
...: events = [datetime.date (2015,1,23), datetime.
date (2015,1,28), datetime.date (2015,2,3), datetime.
fecha (2015,2,21), fecha y hora.fecha (2015,3,15), fecha y hora.
fecha (2015,3,24), datetime.date (2015,4,8), datetime.date (2015,4,24)]
lecturas = [12,22,25,20,18,15,17,14]
...: fig, ax = plt.subplots ()
...: plt.plot (eventos, lecturas)
...: ax.xaxis.set_major_locator (meses)
...: ax.xaxis.set_major_formatter (timeFmt)
...: ax.xaxis.set_minor_locator (días)
266
Página 281
Figura 7-25. Ahora, las etiquetas de marca del eje x se refieren solo a los meses, lo que hace que
trama más legible
Tipología de gráficos
En las secciones anteriores vio una serie de ejemplos relacionados con la arquitectura del
biblioteca matplotlib. Ahora que está familiarizado con el uso de los principales elementos gráficos
en un gráfico, es hora de ver una serie de ejemplos que tratan diferentes tipos de gráficos, comenzando
desde los más comunes, como gráficos lineales, gráficos de barras y gráficos circulares, hasta un
discusión sobre algunos que son más sofisticados pero de uso común, no obstante.
Esta parte del capítulo es muy importante ya que el propósito de esta biblioteca es la
visualización de los resultados producidos por el análisis de datos. Así, saber elegir el
el tipo de gráfico adecuado es una elección fundamental. Recuerde que un excelente análisis de datos
representado incorrectamente puede conducir a una interpretación incorrecta de los resultados experimentales.
Gráficos de líneas
Entre todos los tipos de gráficos, el gráfico lineal es el más simple. Un gráfico de líneas es una secuencia de
puntos de datos conectados por una línea. Cada punto de datos consta de un par de valores (x, y), que
se informará en el gráfico según la escala de valores de los dos ejes (xey).
267
Página 282
A modo de ejemplo, puede comenzar a graficar los puntos generados por una
función. Entonces, puede considerar una función matemática genérica como esta:
y = sin (3 * x) / x
Por lo tanto, si desea crear una secuencia de puntos de datos, debe crear dos
Matrices NumPy. Primero crea una matriz que contiene los valores x que se referirán a la
eje x. Para definir una secuencia de valores crecientes, utilizará np.arange ()
función. Dado que la función es sinusoidal, debe referirse a valores que son múltiplos
y submúltiplos del griego pi ( np.pi ). Luego, usando esta secuencia de valores, puede
obtener los valores de y aplicando la función np.sin () directamente a estos valores (gracias a
¡NumPy!).
Después de todo esto, solo tiene que trazarlos llamando a la función plot (). Vas a
obtener un gráfico de líneas, como se muestra en la Figura 7-26.

...: x = np. rango (-2 * np.pi, 2 * np.pi, 0.01)
...: y = np.sin (3 * x) / x
...: plt.plot (x, y)
Fuera [393]: [<matplotlib.lines.Line2D en 0x22404358>]
Figura 7-26. Una función matemática representada en un gráfico de líneas.
268
Página 283
Ahora puede ampliar el caso en el que desee mostrar una familia de funciones, como
como este:
y = sin (n * x) / x
variando el parámetro n.

...: y = np.sin (3 * x) / x
...: y2 = np.sin (2 * x) / x
...: y3 = np.sin (3 * x) / x
...: plt.plot (x, y)
...: plt.plot (x, y2)
...: plt.plot (x, y3)
Como puede ver en la Figura 7-27, se asigna automáticamente un color diferente a cada línea.
Todas las parcelas están representadas en la misma escala; es decir, los puntos de datos de cada serie se refieren
al mismo eje xy eje y. Esto se debe a que cada llamada de la función plot () toma en
cuenta las llamadas anteriores a la misma función, por lo que la Figura aplica los cambios manteniendo
memoria de los comandos anteriores hasta que no se muestre la Figura (usando show () con
Python y Enter con IPython QtConsole).
Figura 7-27. Se dibujan tres series diferentes con diferentes colores en el mismo gráfico
269
Página 284
Como vio en las secciones anteriores, independientemente de la configuración predeterminada, puede seleccionar
el tipo de trazo, color, etc. Como tercer argumento de la función plot () puedes
especificar algunos códigos que corresponden al color (ver Tabla 7-2 ) y otros códigos que
corresponden a estilos de línea, todos incluidos en la misma cadena. Otra posibilidad es utilizar
dos kwargs por separado, color para definir el color y estilo de línea para definir el trazo
(ver figura 7-28 ).

...: y = np.sin (3 * x) / x
...: y2 = np.sin (2 * x) / x
...: y3 = np.sin (3 * x) / x
...: plt.plot (x, y, 'k -', ancho de línea = 3)
...: plt.plot (x, y2, 'm-.')
...: plt.plot (x, y3, color = '# 87a3cc', linestyle = '-')
Figura 7-28. Puede definir colores y estilos de línea utilizando códigos de caracteres
270
Página 285
Tabla 7-2. Códigos de color

Código Color
si azul
gramo verde
r rojo
C cian
metro magenta
y amarillo
k negro
w blanco
Acaba de definir un rango de -2π a 2π en el eje x, pero de forma predeterminada, los valores en
las garrapatas se muestran en forma numérica. Por lo tanto, debe reemplazar los valores numéricos
con múltiplo de π. También puede reemplazar las marcas en el eje y. Para hacer todo esto, tienes que
utilice las funciones xticks () y yticks (), pasando a cada una de ellas dos listas de valores. los
La primera lista contiene valores correspondientes a las posiciones donde se colocarán los ticks,
y el segundo contiene las etiquetas de marca. En este caso particular, tienes que usar cadenas
que contiene formato LaTeX para mostrar correctamente el símbolo π. Recuerda definir
ellos dentro de dos caracteres $ y agregar ar como prefijo.

...: y = np.sin (3 * x) / x
...: y2 = np.sin (2 * x) / x
...: y3 = np.sin (x) / x
...: plt.plot (x, y, color = 'b')
...: plt.plot (x, y2, color = 'r')
...: plt.plot (x, y3, color = 'g')
...: plt.xticks ([- 2 * np.pi, -np.pi, 0, np.pi, 2 * np.pi],
[r '$ - 2 \ pi $', r '$ - \ pi $', r '$ 0 $', r '$ + \ pi $', r '$ + 2 \ pi $'])
271
Página 286
...: plt.yticks ([- 1,0,1,2,3],
[r '$ - 1 $', r '$ 0 $', r '$ + 1 $', r '$ + 2 $', r '$ + 3 $'])
Fuera [423]:
([<matplotlib.axis.YTick en 0x26877ac8>,
<matplotlib.axis.YTick en 0x271d26d8>,
<matplotlib.axis.YTick en 0x273c7f98>,
<matplotlib.axis.YTick en 0x273cc470>,
<matplotlib.axis.YTick en 0x273cc9e8>],
<a lista de 5 objetos Text yticklabel>)
Al final, obtendrá un gráfico de líneas limpio y agradable que muestra caracteres griegos, como
en la Figura 7-29 .
Figura 7-29. La etiqueta de marca se puede mejorar agregando texto con formato LaTeX
En todos los gráficos lineales que ha visto hasta ahora, siempre tiene el eje xy el eje y
colocado en el borde de la figura (correspondiente a los lados del cuadro de borde delimitador).
Otra forma de mostrar los ejes es hacer que los dos ejes pasen por el origen (0, 0),
es decir, los dos ejes cartesianos.
272
Página 287
Para hacer esto, primero debe capturar el objeto Axes a través de la función gca (). Luego
a través de este objeto, puede seleccionar cada uno de los cuatro lados que componen el cuadro delimitador,
especificando para cada uno su posición: derecha, izquierda, abajo y arriba. Recorta los lados que no
coincidir con cualquier eje (derecho e inferior) usando la función set_color () e indicando ninguno
por el color. Luego, los lados correspondientes a los ejes xey se mueven para pasar
el origen (0,0) con la función set_position ().

...: y = np.sin (3 * x) / x
...: y2 = np.sin (2 * x) / x
...: y3 = np.sin (x) / x
[r '$ - 2 \ pi $', r '$ - \ pi $', r '$ 0 $', r '$ + \ pi $', r '$ + 2 \ pi $'])
...: plt.yticks ([- 1,0, + 1, + 2, + 3],
[r '$ - 1 $', r '$ 0 $', r '$ + 1 $', r '$ + 2 $', r '$ + 3 $'])
...: ax = plt.gca ()
...: ax.spines ['derecha']. set_color ('ninguno')
...: ax.spines ['top']. set_color ('ninguno')
...: ax.xaxis.set_ticks_position ('abajo')
...: ax.spines ['bottom']. set_position (('datos', 0))
...: ax.yaxis.set_ticks_position ('izquierda')
...: ax.spines ['left']. set_position (('data', 0))
Ahora el gráfico mostrará los dos ejes que se cruzan en el medio de la figura, es decir, el
origen de los ejes cartesianos, como se muestra en la Figura 7-30 .
273
Página 288
Figura 7-30. El gráfico muestra dos ejes cartesianos
A menudo, es muy útil poder especificar un punto particular de la línea usando un

notación y, opcionalmente, añadir una flecha para indicar mejor la posición del punto. por
ejemplo, esta notación puede ser una expresión LaTeX, como la fórmula para el límite de
la función sinx / x con x tiende a 0.
En este sentido, matplotlib proporciona una función llamada annotate (), que es especialmente
útil en estos casos, incluso si los numerosos kwargs necesarios para obtener un buen resultado pueden
hacen que su configuración sea bastante compleja. El primer argumento es la cadena a representar
que contiene la expresión en LaTeX; luego puede agregar los distintos kwargs. El punto de
el gráfico a tener en cuenta se indica mediante una lista que contiene las coordenadas del punto [x, y] pasado
al xy kwarg. La distancia de la notación textual desde el punto a resaltar
está definido por el xytext kwarg y representado por medio de una flecha curva cuya
las características se definen en el kwarg de arrowprops.

...: y = np.sin (3 * x) / x
...: y2 = np.sin (2 * x) / x
...: y3 = np.sin (x) / x
274
Página 289

[r '$ - 2 \ pi $', r '$ - \ pi $', r '$ 0 $', r '$ + \ pi $', r '$ + 2 \ pi $'])
...: plt.yticks ([- 1,0, + 1, + 2, + 3],
[r '$ - 1 $', r '$ 0 $', r '$ + 1 $', r '$ + 2 $', r '$ + 3 $'])
...: plt.annotate (r '$ \ lim_ {x \ to 0} \ frac {\ sin (x)} {x} = 1 $', xy = [0,1],
xycoords = 'data', xytext = [30,30], fontsize = 16, textcoords = 'puntos de compensación',
arrowprops = dict (arrowstyle = "->", connectionstyle = "arc3, rad = .2"))
...: ax = plt.gca ()
...: ax.spines ['derecha']. set_color ('ninguno')
...: ax.spines ['top']. set_color ('ninguno')
...: ax.xaxis.set_ticks_position ('abajo')
...: ax.spines ['bottom']. set_position (('datos', 0))
...: ax.yaxis.set_ticks_position ('izquierda')
...: ax.spines ['left']. set_position (('data', 0))
Al ejecutar este código, obtendrá el gráfico con la notación matemática del límite,
que es el punto que muestra la flecha en la Figura 7-31.
Figura 7-31. Las expresiones matemáticas se pueden agregar a un gráfico con la

función annotate ()
275
Página 290
Gráficos de líneas con pandas

Pasando a casos más prácticos, o al menos más estrechamente relacionados con el análisis de datos, ahora
es el momento de ver lo fácil que es aplicar la biblioteca matplotlib a los marcos de datos del
biblioteca de pandas. La visualización de los datos en un marco de datos como un gráfico lineal es muy
operación simple. Es suficiente pasar el marco de datos como argumento a la trama ()
función para obtener un gráfico lineal multiseries (consulte la Figura 7-32).

...: importar pandas como pd
...: data = {'series1': [1,3,4,3,5],
'series2': [2,4,5,2,4],
'series3': [3,2,3,1,3]}
...: df = pd.DataFrame (datos)
...: x = np. rango (5)
...: eje plt. ([0,5,0,7])
...: plt.plot (x, df)
...: plt.legend (datos, loc = 2)
Figura 7-32. El gráfico de líneas de varias series muestra los datos dentro de un pandas
marco de datos
276
Página 291
Histogramas
Un histograma consta de rectángulos adyacentes erigidos en el eje x, divididos en discretos
intervalos llamados bins , y con un área proporcional a la frecuencia de las ocurrencias
para ese contenedor. Este tipo de visualización se usa comúnmente en estudios estadísticos sobre
distribución de muestras.
Para representar un histograma, pyplot proporciona una función especial llamada hist ().
Esta función gráfica también tiene una característica que otras funciones que producen gráficos no tienen.
La función hist (), además de dibujar el histograma, devuelve una tupla de valores que
son los resultados del cálculo del histograma. De hecho, la función hist () también puede
implementar el cálculo del histograma, es decir, es suficiente con proporcionar una serie de
muestras de valores como argumento y el número de bins en los que se dividirán, y
se encargará de dividir el rango de muestras en muchos intervalos (contenedores) y luego calculará
las ocurrencias de cada contenedor. El resultado de esta operación, además de mostrarse en
forma gráfica (ver Figura 7-33), se devolverá en forma de tupla.
(n, contenedores, parches)
Para comprender esta operación, lo mejor es un ejemplo práctico. Entonces puedes generar un
población de 100 valores aleatorios de 0 a 100 utilizando la función random.randint ().

...: pop = np.random.randint (0,100,100)
...: pop
Fuera[ ]:
matriz ([32, 14, 55, 33, 54, 85, 35, 50, 91, 54, 44, 74, 77, 6, 77, 74, 2,
54, 14, 30, 80, 70, 6, 37, 62, 68, 88, 4, 35, 97, 50, 85, 19, 90,
65, 86, 29, 99, 15, 48, 67, 96, 81, 34, 43, 41, 21, 79, 96, 56, 68,
49, 43, 93, 63, 26, 4, 21, 19, 64, 16, 47, 57, 5, 12, 28, 7, 75,
6, 33, 92, 44, 23, 11, 61, 40, 5, 91, 34, 58, 48, 75, 10, 39, 77,
70, 84, 95, 46, 81, 27, 6, 83, 9, 79, 39, 90, 77, 94, 29])
Ahora, cree el histograma de estas muestras pasando como argumento el hist ()

función. Por ejemplo, desea dividir las ocurrencias en 20 bins (si no se especifica,
el valor predeterminado es 10 bins) y para ello tienes que usar el kwarg bin (como se muestra en
Figura 7-33).
En []: n, bins, patches = plt.hist (pop, bins = 20)
277
Página 292
Figura 7-33. El histograma muestra las ocurrencias en cada contenedor.
Gráfica de barras
Otro tipo de gráfico muy común es el gráfico de barras. Es muy similar a un histograma.
pero en este caso el eje x no se utiliza para hacer referencia a valores numéricos sino a categorías. los
La realización del gráfico de barras es muy simple con matplotlib, usando la función bar ().

...: índice = [0,1,2,3,4]
...: valores = [5,7,3,4,6]
...: plt.bar (índice, valores)
Fuera [15]: <Objeto contenedor de 5 artistas>
Con estas pocas filas de código, obtendrá un gráfico de barras como se muestra en la Figura 7-34.
278
Página 293
Figura 7-34. El gráfico de barras más simple con matplotlib
Si observa la Figura 7-34 , puede ver que los índices se dibujan en el eje x en la
comienzo de cada barra. En realidad, dado que cada barra corresponde a una categoría, sería
será mejor si especifica las categorías a través de la etiqueta de marca, definida por una lista de cadenas
pasado a la función xticks (). En cuanto a la ubicación de estas etiquetas de marca, debe
pasar una lista que contiene los valores correspondientes a sus posiciones en el eje x como el
primer argumento de la función xticks (). Al final obtendrá un gráfico de barras, como se muestra en
Figura 7-35.
En []: importar numpy como np

...: índice = np. rango (5)
...: valores1 = [5,7,3,4,6]
...: plt.bar (índice, valores1)
...: plt.xticks (índice + 0.4, ['A', 'B', 'C', 'D', 'E'])
279
Página 294
Figura 7-35. Un gráfico de barras simple con categorías en el eje x
En realidad, hay muchos otros pasos que puede seguir para refinar aún más el gráfico de barras.
Cada uno de estos acabados se establece agregando un kwarg específico como argumento en la barra ()
función. Por ejemplo, puede agregar los valores de desviación estándar de la barra a través del
yerr kwarg junto con una lista que contiene las desviaciones estándar. Este kwarg suele ser
combinado con otro kwarg llamado error_kw, que, a su vez, acepta otros kwargs
especializado en representar barras de error. Dos kwargs muy específicos utilizados en este caso son
eColor, que especifica el color de las barras de error, y volcar, que define el ancho
de las líneas transversales que marcan los extremos de las barras de error.
Otro kwarg que puedes usar es alpha, que indica el grado de transparencia
de la barra de color. Alfa es un valor que va de 0 a 1. Cuando este valor es 0, el objeto
es completamente transparente para volverse gradualmente más significativo con el aumento de la
valor, hasta llegar a 1, en el que el color está completamente representado.
Como es habitual, se recomienda el uso de una leyenda, por lo que en este caso conviene utilizar un kwarg
llamada etiqueta para identificar la serie que estás representando.
Al final obtendrá un gráfico de barras con barras de error, como se muestra en la Figura 7-36..

...: valores1 = [5,7,3,4,6]
...: std1 = [0.8,1,0.4,0.9,1.3]
...: plt.title ('Un gráfico de barras')
280
Página 295
...: plt.bar (index, values1, yerr = std1, error_kw = {'ecolor': '0.1',

'capsize': 6}, alpha = 0.7, label = 'First')
...: plt.xticks (índice + 0.4, ['A', 'B', 'C', 'D', 'E'])
...: plt.legend (loc = 2)
Figura 7-36. Un gráfico de barras con barras de error.
Gráficos de barras horizontales

Hasta ahora has visto el gráfico de barras orientado verticalmente. También hay gráficos de barras orientados
horizontalmente. Este modo se implementa mediante una función especial llamada barh (). los
Los argumentos y los kwargs válidos para la función bar () siguen siendo los mismos para esta función.
El único cambio que hay que tener en cuenta es que los roles de los ejes son
invertido. Ahora, las categorías están representadas en el eje y y los valores numéricos son
que se muestra en el eje x (ver Figura 7-37 ).

...: valores1 = [5,7,3,4,6]
...: std1 = [0.8,1,0.4,0.9,1.3]
...: plt.title ('Un gráfico de barras horizontales')
281
Página 296
...: plt.barh (índice, valores1, xerr = std1, error_kw = {'ecolor': '0.1',

'capsize': 6}, alpha = 0.7, label = 'First')
...: plt.yticks (índice + 0.4, ['A', 'B', 'C', 'D', 'E'])
...: plt.legend (loc = 5)
Figura 7-37. Un gráfico de barras horizontales simple
Gráficos de barras multiseriales

Como gráficos de líneas, los gráficos de barras también se utilizan generalmente para mostrar
serie de valores. Pero en este caso es necesario hacer algunas aclaraciones sobre cómo
estructurar un gráfico de barras multiserie. Hasta ahora ha definido una secuencia de índices, cada uno
correspondiente a una barra, que se asignará al eje x. Estos índices deben representar
categorías. En este caso, sin embargo, tiene más barras que deben compartir la misma categoría.
Un enfoque utilizado para superar este problema es dividir el espacio ocupado por un
índice (por conveniencia, su ancho es 1) en tantas partes como las barras que comparten ese índice
y que queremos mostrar. Además, es aconsejable añadir espacio, que servirá como
brecha para separar una categoría con respecto a la siguiente (como se muestra en la Figura 7-38).
282
Página 297

...: valores1 = [5,7,3,4,6]
...: valores2 = [6,6,4,5,7]
...: valores3 = [5,6,5,4,6]
...: bw = 0.3
...: eje plt. ([0,5,0,8])
...: plt.title ('Un gráfico de barras multiserie', tamaño de fuente = 20)
...: plt.bar (índice, valores1, bw, color = 'b')
...: plt.bar (índice + bw, valores2, bw, color = 'g')
...: plt.bar (índice + 2 * bw, valores3, bw, color = 'r')
...: plt.xticks (índice + 1.5 * bw, ['A', 'B', 'C', 'D', 'E'])
Figura 7-38. Un gráfico de barras de varias series que muestra tres series
283
Página 298
Con respecto al gráfico de barras horizontales de varias series (consulte la Figura 7-39 ), las cosas están muy
similar. Tienes que reemplazar la función bar () con la función barh () correspondiente
y recuerde reemplazar la función xticks () con la función yticks (). Necesitas
invertir el rango de valores cubiertos por los ejes en la función axis ().

...: valores1 = [5,7,3,4,6]
...: valores2 = [6,6,4,5,7]
...: valores3 = [5,6,5,4,6]
...: bw = 0.3
...: eje plt. ([0,8,0,5])
...: plt.title ('Un gráfico de barras horizontales multiserie', tamaño de fuente = 20)
...: plt.barh (índice, valores1, bw, color = 'b')
...: plt.barh (índice + bw, valores2, bw, color = 'g')
...: plt.barh (índice + 2 * bw, valores3, bw, color = 'r')
...: plt.yticks (índice + 0.4, ['A', 'B', 'C', 'D', 'E'])
Figura 7-39. Un gráfico de barras horizontales de varias series
284
Página 299
Gráficos de barras multiserie con pandas Dataframe

Como vio en los gráficos de líneas, la biblioteca matplotlib también brinda la capacidad de
representar los objetos del marco de datos que contienen los resultados del análisis de datos en forma de barra
gráficos. E incluso aquí lo hace de forma rápida, directa y automática. Lo único que tu
lo que hay que hacer es usar la función plot () aplicada al objeto del marco de datos y especificar dentro
un kwarg llamado kind al que tienes que asignar el tipo de gráfico que quieres representar,
que en este caso es bar. Por lo tanto, sin especificar ninguna otra configuración, obtendrá la barra
cuadro que se muestra en la Figura 7-40.

...: data = {'series1': [1,3,4,3,5],
'series2': [2,4,5,2,4],
'series3': [3,2,3,1,3]}
...: df.plot (kind = 'bar')
Figura 7-40. Los valores en un marco de datos se pueden mostrar directamente como un gráfico de barras
285
Página 300
Sin embargo, si desea tener más control, o si su caso lo requiere, aún puede
extraer porciones del marco de datos como matrices NumPy y utilizarlas como se ilustra en la
ejemplos anteriores en esta sección. Es decir, pasándolos por separado como argumentos a
las funciones matplotlib.
Además, con respecto al gráfico de barras horizontales, se pueden aplicar las mismas reglas, pero
recuerde establecer barh como el valor del tipo kwarg. Obtendrás una multiserie horizontal
gráfico de barras, como se muestra en la Figura 7-41.
Figura 7-41. Un gráfico de barras horizontales podría ser una alternativa válida para visualizar su
valores de marco de datos
Gráficos de barras apiladas multiserie

Otra forma de representar un gráfico de barras de varias series es en forma apilada, en la que
las barras se apilan una sobre otra. Esto es especialmente útil cuando desea mostrar el
valor total obtenido por la suma de todas las barras.
Para transformar un gráfico de barras multiserie simple en uno apilado, agregue la parte inferior
kwarg a cada función bar (). Cada serie debe asignarse al correspondiente
kwarg inferior. Al final obtendrá el gráfico de barras apiladas, como se muestra
En figura 7-42.
286
Página 301

...: series1 = np.array ([3,4,5,3])
...: series2 = np.array ([1,2,2,5])
...: series3 = np.array ([2,3,3,4])
...: eje plt. ([- 0.5,3.5,0,15])
...: plt.title ('Un gráfico de barras apiladas multiseries')
...: plt.bar (índice, serie1, color = 'r')
...: plt.bar (índice, serie2, color = 'b', parte inferior = serie1)
...: plt.bar (índice, serie3, color = 'g', parte inferior = (serie2 + serie1))
...: plt.xticks (índice + 0.4, ['Jan18', 'Feb18', 'Mar18', 'Abr18'])
Figura 7-42. Una barra apilada multiserie
Aquí también, para crear el gráfico de barras apiladas horizontales equivalente, necesita
para reemplazar la función bar () con la función barh (), teniendo cuidado de cambiar la otra
parámetros también. De hecho, la función xticks () debería reemplazarse por yticks ()
función porque las etiquetas de las categorías ahora deben informarse en el eje y. Después
haciendo todos estos cambios, obtendrá el gráfico de barras apiladas horizontales como se muestra en
Figura 7-43.
287
Página 302
...: series1 = np.array ([3,4,5,3])
...: series2 = np.array ([1,2,2,5])
...: series3 = np.array ([2,3,3,4])
...: eje plt. ([0,15, -0.5,3.5])
...: plt.title ('Un gráfico de barras apiladas horizontales de varias series')
...: plt.barh (índice, serie1, color = 'r')
...: plt.barh (índice, serie2, color = 'g', izquierda = serie1)
...: plt.barh (índice, serie3, color = 'b', izquierda = (serie1 + serie2))
...: plt.yticks (índice + 0.4, ['Jan18', 'Feb18', 'Mar18', 'Abr18'])
Figura 7-43. Un gráfico de barras apiladas horizontales de varias series
288
Página 303
Hasta ahora, las distintas series se han distinguido por el uso de diferentes colores. Otro
El modo de distinción entre las diversas series es utilizar tramas que le permitan rellenar
las distintas barras con trazos dibujados de forma diferente. Para hacer esto, primero debe configurar
el color de la barra como blanco y luego tienes que usar el hatch kwarg para definir cómo
la trampilla se va a poner. Las distintas trampillas tienen códigos distinguibles entre estos
caracteres (|, /, -, \, *, -) correspondientes al estilo de línea que llena la barra. Cuanto más un símbolo
se replica, más densas serán las líneas que forman la trama. Por ejemplo, /// es más
denso que //, que es más denso que / (ver Figura 7-44 ).

...: series1 = np.array ([3,4,5,3])
...: series2 = np.array ([1,2,2,5])
...: series3 = np.array ([2,3,3,4])
...: eje plt. ([0,15, -0.5,3.5])
...: plt.title ('Un gráfico de barras apiladas horizontales de varias series')
...: plt.barh (índice, serie1, color = 'w', sombreado = 'xx')
...: plt.barh (índice, serie2, color = 'w', sombreado = '///', izquierda = serie1)
...: plt.barh (índice, serie3, color = 'w', sombreado = '\\\\\\', izquierda = (serie1 + serie2))
...: plt.yticks (índice + 0.4, ['Jan18', 'Feb18', 'Mar18', 'Abr18'])
Fuera [453]:
([<matplotlib.axis.YTick en 0x2a9f0748>,
<matplotlib.axis.YTick en 0x2a9e1f98>,
<matplotlib.axis.YTick en 0x2ac06518>,
<matplotlib.axis.YTick en 0x2ac52128>],
<a lista de 4 objetos Text yticklabel>)
289
Página 304
Figura 7-44. Las barras apiladas se distinguen por sus trampillas.
Gráficos de barras apiladas con un marco de datos de pandas

También con respecto a los gráficos de barras apiladas, es muy sencillo representar directamente los valores
contenido en el objeto de marco de datos mediante la función plot (). Solo necesitas agregar como
un argumento que el kwarg apilado establece en Verdadero (consulte la Figura 7-45).

...: data = {'series1': [1,3,4,3,5],
'series2': [2,4,5,2,4],
'series3': [3,2,3,1,3]}
...: df.plot (kind = 'bar', stacked = True)
Salida [5]: <matplotlib.axes._subplots.AxesSubplot en 0xcda8f98>
290
Página 305
Figura 7-45. Los valores de un marco de datos se pueden mostrar directamente como una pila
gráfico de barras
Otras representaciones de gráficos de barras

Otro tipo de representación muy útil es la de un gráfico de barras para comparación, donde
dos series de valores que comparten las mismas categorías se comparan colocando las barras en
direcciones opuestas a lo largo del eje y. Para hacer esto, debe poner los valores y de
una de las dos series en forma negativa. También en este ejemplo, verá la posibilidad
de colorear el color interior de las barras de una manera diferente. De hecho, puede hacer esto configurando
los dos colores diferentes en un kwarg específico: facecolor.
Además, en este ejemplo, verá cómo agregar el valor y con una etiqueta en el
final de cada barra. Esto podría resultar útil para aumentar la legibilidad del gráfico de barras. Tú
puede hacer esto usando un bucle for en el que la función text () mostrará el valor y. Tú
puede ajustar la posición de la etiqueta con los dos kwargs llamados ha y va, que controlan el
alineación horizontal y vertical, respectivamente. El resultado será el gráfico que se muestra en
Figura 7-46.

...: x0 = np. rango (8)
...: y1 = np.array ([1,3,4,6,4,3,2,1])
...: y2 = np.array ([1,2,5,4,3,3,2,1])
...: plt.ylim (-7,7)
291
Página 306
...: plt.bar (x0, y1,0.9, facecolor = 'r')

...: plt.bar (x0, -y2,0.9, facecolor = 'b')
...: plt.xticks (())
...: para x, y en zip (x0, y1):
plt.text (x + 0.4, y + 0.05, '% d'% y, ha = 'centro', va = 'abajo')
...:
...: para x, y en zip (x0, y2):
plt.text (x + 0.4, -y - 0.05, '% d'% y, ha = 'centro', va = 'arriba')
Figura 7-46. Se pueden comparar dos series usando este tipo de gráfico de barras
Gráficos circulares
Una forma alternativa de mostrar datos en los gráficos de barras es el gráfico circular, que se puede obtener fácilmente.
usando la función pie ().
Incluso para este tipo de función, pasa como argumento principal una lista que contiene el
valores que se mostrarán. Elegí los porcentajes (su suma es 100), pero puedes usar cualquier
tipo de valor. Dependerá de la función pie () calcular inherentemente el porcentaje
ocupado por cada valor.
292
Página 307
Además, con este tipo de representación, es necesario definir algunas características clave que hacen
uso de los kwargs. Por ejemplo, si desea definir la secuencia de colores, que
se asignará a la secuencia de valores de entrada correspondientemente, debe utilizar el
colores kwarg. Por lo tanto, debe asignar una lista de cadenas, cada una con el nombre de
el color deseado. Otra característica importante es agregar etiquetas a cada porción del pastel. Que hacer
esto, debes usar las etiquetas kwarg a las que asignarás una lista de cadenas que contienen
las etiquetas que se mostrarán en secuencia.
Además, para dibujar el gráfico circular de forma perfectamente esférica, debes
agregue la función axis () al final, especificando la cadena 'igual' como argumento. Tú
obtendrá un gráfico circular como se muestra en la Figura 7-47.

...: labels = ['Nokia', 'Samsung', 'Apple', 'Lumia']
...: valores = [10,30,45,15]
...: colors = ['amarillo', 'verde', 'rojo', 'azul']
...: plt.pie (valores, etiquetas = etiquetas, colores = colores)
...: plt.axis ('igual')
Figura 7-47. Un gráfico circular muy simple
293
Página 308
Para agregar complejidad al gráfico circular, puede dibujarlo con un sector extraído del
tarta. Esto generalmente se hace cuando desea enfocarse en un segmento específico. En este caso, para
Por ejemplo, destacaría el segmento que se refiere a Nokia. Para hacer esto, hay
un kwarg especial llamado explotar. No es más que una secuencia de valores flotantes de 0 o 1,
donde 1 corresponde al corte completamente extendido y 0 corresponde a cortes completamente
en el pastel. Todos los valores intermedios corresponden a un grado intermedio de extracción
(ver figura 7- 48).
También puede agregar un título al gráfico circular con la función title (). Tú también puedes
ajustar el ángulo de rotación del pastel agregando el ángulo de inicio kwarg, que toma un
valor entero entre 0 y 360, que son los grados de rotación con precisión (0 es el
valor por defecto).
El gráfico modificado debería aparecer como se muestra en la Figura 7-48.

...: valores = [10,30,45,15]
...: explotar = [0.3,0,0,0]
...: plt.title ('Un gráfico circular')
...: plt.pie (valores, etiquetas = etiquetas, colores = colores, explotar = explotar,
ángulo inicial = 180)
Figura 7-48. Un gráfico circular más avanzado
294
Página 309
Pero las posibles adiciones que puede insertar en un gráfico circular no terminan aquí. Por ejemplo,
un gráfico circular no tiene ejes con ticks, por lo que es difícil imaginar el perfecto
porcentaje representado por cada rebanada. Para superar esto, puede utilizar el autopct kwarg,
que agrega al centro de cada rebanada una etiqueta de texto que muestra el valor correspondiente.
Si desea que sea una imagen aún más atractiva, puede agregar una sombra
con el kwarg de sombra configurándolo en Verdadero. Al final obtendrá un gráfico circular como se muestra
en la Figura 7-49 .

...: valores = [10,30,45,15]
...: explotar = [0.3,0,0,0]
...: plt.title ('Un gráfico circular')
...: plt.pie (valores, etiquetas = etiquetas, colores = colores, explotar = explotar,
shadow = True, autopct = '% 1.1f %%', startangle = 180)
Figura 7-49. Un gráfico circular aún más avanzado
295
Página 310
Gráficos circulares con un marco de datos de pandas

Incluso para el gráfico circular, puede representar los valores contenidos dentro de un objeto de marco de datos.
En este caso, sin embargo, el gráfico circular puede representar solo una serie a la vez, por lo que en este
Por ejemplo, mostrará solo los valores de la primera serie especificando df ['series1'].
Debe especificar el tipo de gráfico que desea representar mediante el tipo kwarg en el
función plot (), que en este caso es circular. Además, debido a que desea representar un
gráfico circular como perfectamente circular, es necesario que agregue el tamaño de la figura kwarg. Al final
obtendrá un gráfico circular como se muestra en la Figura 7-50 .

...: data = {'series1': [1,3,4,3,5],
'series2': [2,4,5,2,4],
'series3': [3,2,3,1,3]}
...: df ['series1']. plot (kind = 'pie', figsize = (6,6))
Fuera [14]: <matplotlib.axes._subplots.AxesSubplot en 0xe1ba710>
Figura 7-50. Los valores en un marco de datos de pandas se pueden dibujar directamente como un gráfico circular
296
Página 311
Gráficos avanzados
Además de los gráficos más clásicos, como los gráficos de barras o los gráficos circulares, puede
quiere representar sus resultados de forma alternativa. En Internet y en varios
publicaciones hay muchos ejemplos en los que muchas soluciones gráficas alternativas son
discutidos y propuestos, algunos realmente brillantes y cautivadores. Esta sección solo muestra
algunas representaciones gráficas; una discusión más detallada sobre este tema está más allá
el propósito de este libro. Puede utilizar esta sección como una introducción a un mundo que
en constante expansión: visualización de datos.
Gráficos de contorno
Un tipo de gráfico bastante común en el mundo científico es el gráfico de contorno o mapa de contorno .
De hecho, esta visualización es adecuada para mostrar superficies tridimensionales a través de
un mapa de curvas de nivel compuesto por curvas cerradas que muestra los puntos de la superficie que
ubicadas en el mismo nivel, o que tengan el mismo valor z.
Aunque visualmente la gráfica de contorno es una estructura muy compleja, su implementación es
no tan difícil, gracias a la biblioteca matplotlib. Primero, necesitas la función z = f (x, y) para
generando una superficie tridimensional. Luego, una vez que haya definido un rango de valores
x, y que definirá el área del mapa que se mostrará, puede calcular los valores z
para cada par (x, y), aplicando la función f (x, y) recién definida para obtener una matriz
de valores z. Finalmente, gracias a la función contour (), puede generar el mapa de contorno
de la superficie. A menudo es deseable agregar también un mapa de color junto con un mapa de contorno.
Es decir, las áreas delimitadas por las curvas de nivel se rellenan con un degradado de color, definido
por un mapa de color. Por ejemplo, como en la Figura 7-51 , puede indicar valores negativos con
tonos cada vez más oscuros de azul, y se mueven al amarillo y luego al rojo con el aumento de
valores positivos.

...: dx = 0.01; dy = 0,01
...: x = np. rango (-2.0,2.0, dx)
...: y = np. rango (-2.0,2.0, dy)
...: X, Y = np.meshgrid (x, y)
...: def f (x, y):
return (1 - y ** 5 + x ** 5) * np.exp (-x ** 2-y ** 2)
297
Página 312
...: C = plt.contour (X, Y, f (X, Y), 8, colors = 'negro')

...: plt.contourf (X, Y, f (X, Y), 8)
...: plt.clabel (C, en línea = 1, tamaño de fuente = 10)
Figura 7-51. Un mapa de contorno puede describir los valores z de una superficie
El degradado de color estándar (mapa de color) se representa en la Figura 7-51. En realidad tu

Elija entre una gran cantidad de mapas de color disponibles simplemente especificándolos con el
cmap kwarg.
Además, cuando tienes que lidiar con este tipo de representaciones, agregar un
La escala de colores como referencia al lado del gráfico es casi imprescindible. Esto es posible por
simplemente agregando la función colorbar () al final del código. En figura 7-52 puedes
ver otro ejemplo de mapa de color que comienza en negro, pasa por rojo y luego gira
amarillo hasta llegar al blanco para los valores más altos. Este mapa de color es plt.cm.hot.

...: dx = 0.01; dy = 0,01
...: x = np. rango (-2.0,2.0, dx)
...: y = np. rango (-2.0,2.0, dy)
...: X, Y = np.meshgrid (x, y)
...: def f (x, y):
298
Página 313
...: C = plt.contour (X, Y, f (X, Y), 8, colors = 'negro')

...: plt.contourf (X, Y, f (X, Y), 8, cmap = plt.cm.hot)
...: plt.clabel (C, en línea = 1, tamaño de fuente = 10)
...: plt.colorbar ()
Figura 7-52. El degradado del mapa de color "caliente" le da un aspecto atractivo al mapa de contorno
Gráficos polares
Otro tipo de gráfico avanzado que es popular es el gráfico polar. Este tipo de gráfico
se caracteriza por una serie de sectores que se extienden radialmente; cada una de estas áreas
ocupar un cierto ángulo. Por tanto, puede visualizar dos valores diferentes asignándolos a la
magnitudes que caracterizan la carta polar: la extensión del radio ry el ángulo
θ ocupado por el sector. De hecho, estas son las coordenadas polares (r, θ), una forma alternativa
de representar funciones en los ejes de coordenadas. Desde el punto de vista gráfico,
Podría imaginarlo como una especie de gráfico que tiene características tanto del gráfico circular como del
gráfico de barras. De hecho, como el gráfico circular, el ángulo de cada sector da información porcentual
representada por esa categoría con respecto al total. En cuanto al gráfico de barras, el radial
extensión es el valor numérico de esa categoría.
Hasta ahora hemos utilizado el conjunto estándar de colores utilizando caracteres individuales como color
código (por ejemplo, r para indicar rojo). De hecho, puede utilizar cualquier secuencia de colores que desee. Tú
tiene que definir una lista de valores de cadena que contienen códigos RGB en el formato #rrggbb
correspondiente a los colores que desee.
299
Página 314
Curiosamente, para obtener un gráfico polar tienes que usar la función bar () y pasar la lista
que contiene los ángulos θ y una lista de la extensión radial de cada sector. El resultado sera
un gráfico polar, como se muestra en la Figura 7-53 .

...: N = 8
...: theta = np.arange (0., 2 * np.pi, 2 * np.pi / N)
...: radii = np.array ([4,7,5,3,1,5,6,7])
...: plt.axes ([0.025, 0.025, 0.95, 0.95], polar = True)
...: colors = np.array (['# 4bb2c5', '# c5b47f', '# EAA228', '# 579575',
'# 839557', '# 958c12', '# 953579', '# 4b5de4'])
...: bars = plt.bar (theta, radii, width = (2 * np.pi / N), bottom = 0.0,
color = colores)
Figura 7-53. Una carta polar
300
Página 315
En este ejemplo, ha definido la secuencia de colores utilizando el formato

#rrggbb, pero también puede especificar una secuencia de colores como cadenas con su nombre real

...: N = 8
...: theta = np.arange (0., 2 * np.pi, 2 * np.pi / N)
...: radii = np.array ([4,7,5,3,1,5,6,7])
...: plt.axes ([0.025, 0.025, 0.95, 0.95], polar = True)
...: colors = np.array (['verde claro', 'rojo oscuro', 'azul marino', 'marrón',
'violeta', 'ciruela', 'amarillo', 'verde oscuro'])
...: bars = plt.bar (theta, radii, width = (2 * np.pi / N), bottom = 0.0,
color = colores)
Figura 7-54. Un gráfico polar con otra secuencia de colores.
301
Página 316
El kit de herramientas de mplot3d

El kit de herramientas mplot3d se incluye con todas las instalaciones estándar de matplotlib y permite
que amplíe las capacidades de visualización a datos 3D. Si la figura se muestra en un
ventana separada, puede rotar los ejes de la representación tridimensional con
el ratón.
Con este paquete, todavía está usando el objeto Figure, solo que en lugar de Axes
objeto, definirá un nuevo tipo de objeto, llamado Axes3D, e introducido por este kit de herramientas.
Por lo tanto, debe agregar una nueva importación al código, si desea utilizar el objeto Axes3D.
de mpl_toolkits.mplot3d importar Axes3D
Superficies 3D
En una sección anterior, usó la gráfica de contorno para representar la
superficies a través de las líneas de nivel. Con el paquete mplot3D, se pueden dibujar superficies
directamente en 3D. En este ejemplo, usará la misma función z = f (x, y) que usó en
el mapa de contorno.
Una vez que haya calculado la cuadrícula de malla, puede ver la superficie con plot_
función de superficie (). Aparecerá una superficie azul tridimensional, como en la Figura 7-55..
En []: de mpl_toolkits.mplot3d importar Axes3D

...: fig = plt.figure ()
...: ax = Axes3D (fig)
...: X = np. Rango (-2,2,0.1)
...: Y = np. Rango (-2,2,0.1)
...: X, Y = np.meshgrid (X, Y)
...: def f (x, y):
...: return (1 - y ** 5 + x ** 5) * np.exp (-x ** 2-y ** 2)
...: ax.plot_surface (X, Y, f (X, Y), rstride = 1, cstride = 1)
302
Página 317
Figura 7-55. Se puede representar una superficie 3D con el kit de herramientas mplot3d
Una superficie 3D se destaca más al cambiar el mapa de color, por ejemplo, al configurar el
cmap kwarg. También puede rotar la superficie usando la función view_init (). De hecho, este
La función ajusta el punto de vista desde el que se ve la superficie, cambiando los dos kwargs
llamado elev y azim. A través de su combinación, puede obtener la superficie mostrada desde
cualquier ángulo. El primer kwarg ajusta la altura a la que se ve la superficie, mientras que azim
ajusta el ángulo de rotación de la superficie.
Por ejemplo, puede cambiar el mapa de color usando plt.cm.hot y moviendo la vista
apunta a elev = 30 y azim = 125. El resultado se muestra en la Figura 7-56 .
En []: de mpl_toolkits.mplot3d importar Axes3D

...: X = np. Rango (-2,2,0.1)
...: Y = np. Rango (-2,2,0.1)
...: X, Y = np.meshgrid (X, Y)
...: def f (x, y):
...: ax.plot_surface (X, Y, f (X, Y), rstride = 1, cstride = 1, cmap = plt.cm.hot)
...: ax.view_init (elev = 30, azim = 125)
303
Página 318
Figura 7-56. La superficie 3D se puede girar y observar desde un punto de vista más alto.
Gráficos de dispersión en 3D
El modo más utilizado entre todas las vistas 3D sigue siendo el gráfico de dispersión 3D. Con este tipo de
visualización, puede identificar si los puntos siguen tendencias particulares, pero sobre todo si
tienden a agruparse.
En este caso, usará la función scatter () como el caso 2D pero aplicada en el
Objeto Axes3D. Al hacer esto, puede visualizar diferentes series, expresadas por las llamadas a
la función scatter (), todos juntos en la misma representación 3D (ver Figura 7-57 ).

...: desde mpl_toolkits.mplot3d importar Axes3D
...: xs = np.random.randint (30,40,100)
...: ys = np.random.randint (20,30,100)
...: zs = np.random.randint (10,20,100)
...: xs2 = np.random.randint (50,60,100)
...: ys2 = np.random.randint (30,40,100)
...: zs2 = np.random.randint (50,70,100)
...: xs3 = np.random.randint (10,30,100)
304
Página 319
...: ys3 = np.random.randint (40,50,100)

...: zs3 = np.random.randint (40,50,100)
...: dispersión del eje (xs, ys, zs)
...: ax.scatter (xs2, ys2, zs2, c = 'r', marcador = '^')
...: ax.scatter (xs3, ys3, zs3, c = 'g', marcador = '*')
...: ax.set_xlabel ('Etiqueta X')
...: ax.set_ylabel ('Etiqueta Y')
...: ax.set_zlabel ('Etiqueta Z')
Fuera [34]: <matplotlib.text.Text en 0xe1c2438>
Figura 7-57. Este diagrama de dispersión 3D muestra tres grupos diferentes
305
Página 320
Gráficos de barras en 3D
Otro tipo de gráfico 3D muy utilizado en el análisis de datos es el gráfico de barras 3D. También en este caso,
utiliza la función bar () aplicada al objeto Axes3D. Si define varias series,
puede acumular varias llamadas a la función bar () en la misma visualización 3D

...: desde mpl_toolkits.mplot3d importar Axes3D
...: x = np. rango (8)
...: y = np.random.randint (0,10,8)
...: y2 = y + np.random.randint (0,3,8)
...: y3 = y2 + np.random.randint (0,3,8)
...: clr = ['# 4bb2c5', '# c5b47f', '# EAA228', '# 579575', '# 839557',
'# 958c12', '# 953579', '# 4b5de4']
...: ax.bar (x, y, 0, zdir = 'y', color = clr)
...: ax.bar (x, y2,10, zdir = 'y', color = clr)
...: ax.set_xlabel ('Eje X')
...: ax.set_ylabel ('Eje Y')
...: ax.set_zlabel ('Eje Z')
...: ax.view_init (elev = 40)
306
Página 321
Figura 7-58. Un gráfico de barras 3D
Gráficos de paneles múltiples

Hasta ahora, ha tenido la oportunidad de ver diferentes formas de representar datos a través de un gráfico. Tú
vi cómo ver más gráficos en la misma figura separándolos con subparcelas. En esto
sección, profundizará su comprensión de este tema mediante el análisis de casos más complejos.
Mostrar subparcelas dentro de otras subparcelas

Ahora se explicará un método aún más avanzado: la capacidad de ver gráficos dentro
otros, encerrados dentro de marcos. Como estamos hablando de marcos, es decir, objetos Axes,
necesita separar los ejes principales (es decir, el gráfico general) del marco que desea agregar
esa será otra instancia de Axes. Para hacer esto, usa la función de figuras () para
obtener el objeto Figure en el que definirá dos objetos Axes diferentes utilizando el
función add_axes (). Vea el resultado de este ejemplo en la Figura 7-59.

...: ax = fig.add_axes ([0.1,0.1,0.8,0.8])
...: inner_ax = fig.add_axes ([0.6,0.6,0.25,0.25])
307
Página 322
Figura 7-59. Se muestra una subparcela dentro de otra parcela
Para comprender mejor el efecto de este modo de visualización, puede completar los ejes anteriores
con datos reales, como se muestra en la Figura 7-60.
...: ax = fig.add_axes ([0.1,0.1,0.8,0.8])
...: inner_ax = fig.add_axes ([0.6,0.6,0.25,0.25])
...: x1 = np. rango (10)
...: y1 = np.array ([1,2,7,1,5,2,4,2,3,1])
...: x2 = np. rango (10)
...: y2 = np.array ([1,3,4,5,4,5,2,6,4,3])
...: ax.plot (x1, y1)
...: inner_ax.plot (x2, y2)
Fuera [95]: [<matplotlib.lines.Line2D en 0x14acf6d8>]
308
Página 323
Figura 7-60. Una visualización más realista de una subtrama dentro de otra trama.
Cuadrículas de subparcelas
Ya has visto la creación de subtramas. Es bastante simple agregar subtramas usando
la función subplots () y dividiendo una parcela en sectores. matplotlib te permite
administre casos aún más complejos usando otra función llamada GridSpec (). Esta
La subdivisión permite dividir el área de dibujo en una cuadrícula de subáreas, a las que puede
Asignar uno o más de ellos a cada subparcela, para que al final puedas obtener subtramas
con diferentes tamaños y orientaciones, como se puede ver en la Figura 7-61.

...: gs = plt.GridSpec (3,3)
...: fig = plt.figure (figsize = (6,6))
...: fig.add_subplot (gs [1,: 2])
...: fig.add_subplot (gs [0,: 2])
...: fig.add_subplot (gs [2,0])
...: fig.add_subplot (gs [: 2,2])
...: fig.add_subplot (gs [2,1:])
Fuera [97]: <matplotlib.axes._subplots.AxesSubplot en 0x12717438>
309
Página 324
Figura 7-61. Se pueden definir subparcelas con diferentes tamaños en una cuadrícula de subáreas
Ahora que tiene claro cómo administrar la cuadrícula asignando los distintos sectores
para la subtrama, es hora de ver cómo usar estas subtramas. De hecho, puedes usar los ejes
objeto devuelto por cada función add_subplot () para llamar a la función plot () para dibujar el
parcela correspondiente (ver Figura 7-62).

...: gs = plt.GridSpec (3,3)
...: fig = plt.figure (figsize = (6,6))
...: x1 = np.array ([1,3,2,5])
...: y1 = np.array ([4,3,7,2])
...: x2 = np. rango (5)
310
Página 325
...: y2 = np.array ([3,2,4,6,4])

...: s1 = fig.add_subplot (gs [1,: 2])
...: s1.plot (x, y, 'r')
...: s2 = fig.add_subplot (gs [0,: 2])
...: s2.bar (x2, y2)
...: s3 = fig.add_subplot (gs [2,0])
...: s3.barh (x2, y2, color = 'g')
...: s4 = fig.add_subplot (gs [: 2,2])
...: s4.plot (x2, y2, 'k')
...: s5 = fig.add_subplot (gs [2,1:])
...: s5.plot (x1, y1, 'b ^', x2, y2, 'yo')
Figura 7-62. Una cuadrícula de subparcelas puede mostrar muchas parcelas al mismo tiempo
311
Página 326
Conclusiones
En este capítulo, recibió todos los aspectos fundamentales de la biblioteca matplotlib,
y a través de una serie de ejemplos, ha aprendido sobre las herramientas básicas para manejar
Visualización de datos. Se ha familiarizado con varios ejemplos de cómo desarrollar
diferentes tipos de gráficos con unas pocas líneas de código.
Con este capítulo, concluimos la parte sobre las bibliotecas que proporciona los
herramientas para realizar análisis de datos. En el próximo capítulo, comenzará a tratar los temas más
estrechamente relacionado con el análisis de datos.
312
Página 327
CAPÍTULO 8
Aprendizaje automático
con scikit-learn
En la cadena de procesos que componen el análisis de datos, la fase de construcción del predictivo
Los modelos y su validación se realizan mediante una potente biblioteca llamada scikit-learn. En
este capítulo, verá algunos ejemplos que ilustran la construcción básica de predicciones
modelos con algunos métodos diferentes.
La biblioteca scikit-learn
scikit-learn es un módulo de Python que integra muchos de los algoritmos de aprendizaje automático.
Esta biblioteca fue desarrollada inicialmente por Cournapeu en 2007, pero la primera versión real
fue en 2010.
Esta biblioteca es parte del grupo SciPy (Scientific Python), un conjunto de bibliotecas creadas para
informática científica y especialmente para el análisis de datos, muchos de los cuales se discuten en este
libro. Generalmente estas bibliotecas se definen como SciKits , de ahí la primera parte del nombre de
esta biblioteca. La segunda parte del nombre de la biblioteca se deriva del aprendizaje automático , el
disciplina perteneciente a esta biblioteca.
Aprendizaje automático
El aprendizaje automático es una disciplina que se ocupa del estudio de métodos para patrones
reconocimiento en conjuntos de datos sometidos a análisis de datos. En particular, se ocupa de la
desarrollo de algoritmos que aprenden de los datos y hacen predicciones. Cada
La metodología se basa en la construcción de un modelo específico.
313
© Fabio Nelli 2018
Página 328
CAPÍTULO 8 APRENDIZAJE MÁQUINA CON SCIKIT-LEARN
Hay muchos métodos que pertenecen a la máquina de aprendizaje, cada uno con su
características únicas, que son específicas de la naturaleza de los datos y el predictivo
modelo que desea construir. La elección de qué método se aplicará se denomina
problema de aprendizaje .
Los datos a someter a un patrón en la fase de aprendizaje pueden ser arreglos compuestos
por un solo valor por elemento, o por un valor multivariado. Estos valores se refieren a menudo
a como características o atributos .
Aprendizaje supervisado y no supervisado
Dependiendo del tipo de datos y del modelo a construir, puede separar los
problemas de aprendizaje en dos categorías amplias:
Aprendizaje supervisado
Son los métodos en los que el conjunto de entrenamiento contiene atributos adicionales que
quieres predecir (el objetivo ). Gracias a estos valores, puede indicar al modelo que
proporcione valores similares cuando tenga que enviar nuevos valores (el conjunto de prueba ).
• Clasificación: los datos del conjunto de entrenamiento pertenecen a dos o más

clases o categorías; entonces, los datos, ya etiquetados, te permiten
enseñar al sistema a reconocer las características que distinguen
cada clase. Cuándo necesitará considerar un nuevo valor desconocido
al sistema, el sistema evaluará su clase de acuerdo con su
caracteristicas.
• Regresión: cuando el valor que se va a predecir es una variable continua.

El caso más simple de entender es cuando quiere encontrar la línea
que describe la tendencia de una serie de puntos representados en un
gráfico de dispersión.
Aprendizaje sin supervisión

Estos son los métodos en los que el conjunto de entrenamiento consta de una serie de valores de entrada x
sin ningún valor objetivo correspondiente.
• Agrupación: el objetivo de estos métodos es descubrir grupos de

ejemplos en un conjunto de datos.
314
Página 329
• Reducción de dimensionalidad: reducción de un conjunto de datos de alta dimensión

a uno con solo dos o tres dimensiones es útil no solo para datos
visualización, pero para convertir datos de muy alta dimensionalidad
en datos de dimensionalidad mucho más baja de modo que cada uno de los
dimensiones transmite mucha más información.
Además de estas dos categorías principales, existe un grupo adicional de métodos que
tienen como finalidad la validación y evaluación de los modelos.
Conjunto de entrenamiento y conjunto de pruebas

El aprendizaje automático permite aprender algunas propiedades mediante un modelo de un conjunto de datos y
aplicándolos a nuevos datos. Esto se debe a que una práctica común en el aprendizaje automático es
para evaluar un algoritmo. Esta valoración consiste en dividir los datos en dos partes, una
llamado conjunto de entrenamiento , con el cual aprenderemos las propiedades de los datos, y el otro
llamado conjunto de prueba, en el que probar estas propiedades.
Aprendizaje supervisado con scikit-learn

En este capítulo, verá varios ejemplos de aprendizaje supervisado.
• Clasificación, utilizando el conjunto de datos Iris
• Clasificador K-Vecinos más cercanos
• Soporte de máquinas vectoriales (SVC)
• Regresión, usando el conjunto de datos de diabetes
• Regresión lineal
• Máquinas vectoriales de soporte (SVR)
El aprendizaje supervisado consiste en aprender patrones posibles entre dos o más

presenta valores de lectura de un conjunto de entrenamiento; el aprendizaje es posible porque el entrenamiento
el conjunto contiene resultados conocidos (objetivo o etiquetas). Todos los modelos de scikit-learn se denominan
estimadores supervisados, utilizando la función de ajuste (x, y) que realiza su entrenamiento.
x comprende las características observadas, mientras que y indica el objetivo. Una vez que el estimador ha
llevado a cabo el entrenamiento, podrá predecir el valor de y para cualquier nueva observación x no
etiquetado. Esta operación lo hará a través de la función de predicción (x).
315
Página 330
El conjunto de datos de flores de iris

El conjunto de datos de flores de iris es un conjunto de datos particular utilizado por primera vez por Sir Ronald Fisher
en 1936. A menudo también se llama Anderson Iris Dataset, en honor a la persona que recopiló el
datos que miden directamente el tamaño de las distintas partes de las flores del iris. En este conjunto de datos,
Los datos de tres especies diferentes de iris (Iris sedoso, virginica Iris e Iris versicolor) son
recogidos y estos datos corresponden a la longitud y el ancho de los sépalos y la longitud
y ancho de los pétalos (ver Figura 8-1 ).
Figura 8-1. Iris versicolor y el ancho y largo del pétalo y sépalo
Este conjunto de datos se utiliza actualmente como un buen ejemplo para muchos tipos de análisis,
en particular para los problemas de clasificación, que se pueden abordar mediante
metodologías de aprendizaje automático. Entonces no es una coincidencia que este conjunto de datos se proporcione
junto con la biblioteca scikit-learn como una matriz NumPy 150x4.
Ahora estudiará este conjunto de datos en detalle importándolo en IPython QtConsole o en un
sesión normal de Python.
316
Página 331
En []: de sklearn importar conjuntos de datos

...: iris = conjuntos de datos.load_iris ()
De esta manera, cargó todos los datos y metadatos relacionados con el conjunto de datos Iris en el
variable de iris. Para ver los valores de los datos recogidos en él, basta con llamar
los datos de atributo de la variable iris.
En []: iris.data
Fuera[ ]:
matriz ([[5.1, 3.5, 1.4, 0.2],
[4.9, 3., 1.4, 0.2],
[4.7, 3.2, 1.3, 0.2],
[4.6, 3.1, 1.5, 0.2],
...
Como puede ver, obtendrá una matriz de 150 elementos, cada uno con cuatro números
valores: el tamaño de los sépalos y pétalos respectivamente.
Para saber en cambio a qué tipo de flor pertenece cada elemento, se referirá al objetivo
atributo.
En []: iris.target
Fuera[ ]:
matriz ([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
Obtienes 150 elementos con tres posibles valores enteros (0, 1 y 2), que
corresponden a las tres especies de iris. Conocer la correspondencia entre las especies.
y número, debe llamar al atributo target_names.
En []: iris.target_names
Fuera[ ]:
array (['setosa', 'versicolor', 'virginica'],
dtype = '| S10')
317
Página 332
Para comprender mejor este conjunto de datos, puede usar la biblioteca matplotlib, usando el
técnicas que aprendiste en el capítulo 7. Por lo tanto, cree un diagrama de dispersión que muestre
tres especies diferentes en tres colores diferentes. El eje x representará la longitud del
sépalo mientras que el eje y representará el ancho del sépalo.

...: importar matplotlib.patches como mpatches
...: desde sklearn importar conjuntos de datos
...:
...: x = iris.data [:, 0] # Eje X - longitud del sépalo
...: y = iris.data [:, 1] # Eje Y - longitud del sépalo
...: species = iris.target #Especies
...:
...: x_min, x_max = x.min () - .5, x.max () + .5
...: y_min, y_max = y.min () - .5, y.max () + .5
...:
...: #GRÁFICO DE DISPERSIÓN
...: plt.figure ()
...: plt.title ('Conjunto de datos de Iris - Clasificación por tamaños de sépalo')
...: plt. dispersión (x, y, c = especie)
...: plt.xlabel ('Longitud del sépalo')
...: plt.ylabel ('Ancho del sépalo')
...: plt.xlim (x_min, x_max)
...: plt.ylim (y_min, y_max)
...: plt.yticks (())
...: plt.show ()
Como resultado, obtiene el diagrama de dispersión que se muestra en la Figura 8-2 . Los azules son los Iris
setosa, las flores, las verdes son el Iris versicolor, y las rojas son el Iris virginica.
En la Figura 8-2 puede ver cómo las características de Iris setosa difieren de las otras dos,
formando un grupo de puntos azules separados de los demás.
318
Página 333
Figura 8-2. Las diferentes especies de iris se muestran con diferentes colores.
Intente seguir el mismo procedimiento, pero esta vez utilizando las otras dos variables, es decir
la medida del largo y ancho del pétalo. Puedes usar el mismo código y cambiar
solo algunos valores.

...: importar matplotlib.patches como mpatches
...: desde sklearn importar conjuntos de datos
...:
...: x = iris.data [:, 2] # Eje X - longitud del pétalo
...: y = iris.data [:, 3] # Eje Y - longitud del pétalo
...: species = iris.target #Especies
...:
...: x_min, x_max = x.min () - .5, x.max () + .5
...: y_min, y_max = y.min () - .5, y.max () + .5
...: #GRÁFICO DE DISPERSIÓN
...: plt.figure ()
...: plt.title ('Conjunto de datos de iris - Clasificación por tamaños de pétalos', tamaño = 14)
...: plt. dispersión (x, y, c = especie)
...: plt.xlabel ('Longitud del pétalo')
...: plt.ylabel ('Ancho del pétalo')
319
Página 334
...: plt.xlim (x_min, x_max)

...: plt.ylim (y_min, y_max)
...: plt.yticks (())
El resultado es el diagrama de dispersión que se muestra en la Figura 8-3 . En este caso la división entre el
tres especies es mucho más evidente. Como puede ver, tiene tres grupos diferentes.
Figura 8-3. Las diferentes especies de iris se muestran con diferentes colores.
La descomposición de PCA
Has visto cómo se podrían caracterizar las tres especies, teniendo en cuenta cuatro
Medidas del tamaño de los pétalos y sépalos. Representamos dos diagramas de dispersión, uno para el
pétalos y uno para los sépalos, pero ¿cómo se puede unificar todo? Cuatro dimensiones
son un problema que ni siquiera un Scatterplot 3D es capaz de resolver.
En este sentido, una técnica especial llamada Análisis de componentes principales (PCA) ha
ha sido desarrollado. Esta técnica le permite reducir el número de dimensiones de
un sistema que mantiene toda la información para la caracterización de los distintos puntos,
las nuevas dimensiones generadas se denominan componentes principales . En nuestro caso, entonces tu
puede reducir el sistema de cuatro a tres dimensiones y luego trazar los resultados dentro
un diagrama de dispersión 3D. De esta forma se pueden utilizar medidas tanto de sépalos como de pétalos para
caracterizar las diversas especies de iris de los elementos de prueba en el conjunto de datos.
320
Página 335
La función scikit-learn que le permite hacer la reducción dimensional es

la función fit_transform (). Pertenece al objeto PCA. Para usarlo, primero
Necesita importar el módulo sklearn.decomposition de PCA. Entonces tienes que definir el
constructor de objetos usando PCA () y defina el número de nuevas dimensiones (principal
components) como valor de la opción n_components. En tu caso, son 3. Finalmente tienes
para llamar a la función fit_transform () pasando el conjunto de datos Iris de cuatro dimensiones como un
argumento.
de sklearn.decomposition import PCA

x_reduced = PCA (n_components = 3) .fit_transform (iris.data)
Además, para visualizar los nuevos valores utilizará un diagrama de dispersión 3D usando
el módulo mpl_toolkits.mplot3d de matplotlib. Si no recuerda cómo hacerlo,
consulte la sección Scatterplot 3D en el Capítulo 7.

de mpl_toolkits.mplot3d importar Axes3D
desde sklearn importar conjuntos de datos
de sklearn.decomposition import PCA
iris = datasets.load_iris ()
especies = iris.target #Especies
x_reduced = PCA (n_components = 3) .fit_transform (iris.data)
#SCATTERPLOT 3D
fig = plt.figure ()
ax = Axes3D (fig)
ax.set_title ('Conjunto de datos de iris por PCA', tamaño = 14)
ax.scatter (x_reduced [:, 0], x_reduced [:, 1], x_reduced [:, 2], c = especie)
ax.set_xlabel ('Primer vector propio')
ax.set_ylabel ('Segundo vector propio')
ax.set_zlabel ('Tercer vector propio')
ax.w_xaxis.set_ticklabels (())
ax.w_yaxis.set_ticklabels (())
ax.w_zaxis.set_ticklabels (())
321
Página 336
El resultado será el diagrama de dispersión que se muestra en la Figura 8-4 . Las tres especies de iris son
bien caracterizados unos con respecto a otros para formar un racimo.
Figura 8-4. Diagrama de dispersión 3D con tres grupos representativos de cada especie de iris
Clasificador K-Vecinos más cercanos

Ahora, realizarás una clasificación , y para hacer esta operación con el scikit-learn
biblioteca necesita un clasificador .
Dada una nueva medida de una flor de iris, la tarea del clasificador es averiguar
a cuál de las tres especies pertenece. El clasificador más simple posible es el más cercano
vecino. Este algoritmo buscará dentro del conjunto de entrenamiento la observación que la mayoría de
se acerca mucho a la nueva muestra de prueba.
Algo muy importante a considerar en este punto son los conceptos de conjunto de entrenamiento y
conjunto de prueba (ya visto en el Capítulo 1). De hecho, si solo tiene un único conjunto de datos,
es importante no utilizar los mismos datos tanto para la prueba como para el entrenamiento. En esto
Al respecto, los elementos del conjunto de datos se dividen en dos partes, una dedicada a capacitar al
algoritmo y el otro para realizar su validación.
322
Página 337
Por lo tanto, antes de continuar, debe dividir su conjunto de datos Iris en dos partes.
Sin embargo, es aconsejable mezclar aleatoriamente los elementos de la matriz y luego hacer la división. En
De hecho, a menudo los datos pueden haber sido recopilados en un orden particular y, en su caso,
El conjunto de datos de Iris contiene elementos clasificados por especies. Entonces, para hacer una combinación de elementos del
conjunto de datos utilizará una función NumPy llamada random.permutation (). El conjunto de datos mixto
consta de 150 observaciones diferentes; los primeros 140 se utilizarán como conjunto de entrenamiento,
restantes 10 como el equipo de prueba.

np.random.seed (0)
x = iris.data
y = iris.target
i = np.permutación.aleatoria (len (iris.data))
x_train = x [i [: - 10]]
y_train = y [i [: - 10]]
x_prueba = x [i [-10:]]
y_test = y [i [-10:]]
Ahora puede aplicar el algoritmo de vecino más cercano K. Importar el

KNeighborsClassifier, llame al constructor del clasificador y luego entrenelo con el
función fit ().
de sklearn.neighbors importar KNeighborsClassifier

knn = KNeighborsClassifier ()
knn.fit (tren_x, tren_y)
Fuera [86]:
KNeighborsClassifier (algoritmo = 'auto', tamaño_hoja = 30, métrica = 'minkowski',
metric_params = None, n_neighbors = 5, p = 2, weights = 'uniform')
Ahora que tiene un modelo predictivo que consta del clasificador knn, entrenado por
140 observaciones, descubrirás cómo es válido. El clasificador debe predecir correctamente
la especie de iris de las 10 observaciones del conjunto de prueba. Para obtener la predicción
tienes que usar la función predict (), que se aplicará directamente al predictivo
modelo, knn. Finalmente, comparará los resultados predichos con los observados reales.
contenido en y_test.
323
Página 338
knn.predict (prueba_x)
Fuera [100]: matriz ([1, 2, 1, 0, 0, 0, 2, 1, 2, 0])
y_test
Salida [101]: matriz ([1, 1, 1, 0, 0, 0, 2, 1, 2, 0])
Puede ver que obtuvo un error del 10%. Ahora puedes visualizar todo esto usando
límites de decisión en un espacio representado por el diagrama de dispersión 2D de sépalos.

de matplotlib.colors import ListedColormap
x = iris.data [:,: 2] # Eje X - longitud-ancho del sépalo
y = iris.target # Eje Y - especies
x_min, x_max = x [:, 0] .min () - .5, x [:, 0] .max () + .5

y_min, y_max = x [:, 1] .min () - .5, x [:, 1] .max () + .5
#MALLA
cmap_light = ListedColormap (['# AAAAFF', '# AAFFAA', '# FFAAAA'])
h = .02
xx, yy = np.meshgrid (np.arange (x_min, x_max, h), np.arange (y_min, y_max, h))
knn.fit (x, y)
Z = knn.predict (np.c_ [xx.ravel (), yy.ravel ()])
Z = Z.reforma (forma xx)
plt.figure ()
plt.pcolormesh (xx, yy, Z, cmap = cmap_light)
# Trazar los puntos de entrenamiento

plt.dispersión (x [:, 0], x [:, 1], c = y)
plt.xlim (xx.min (), xx.max ())
plt.ylim (aa.min (), aa.max ())
Fuera [120]: (1.5, 4.900000000000003)
324
Página 339
Obtiene una subdivisión del diagrama de dispersión en los límites de decisión, como se muestra
En figura 8-5 .
Figura 8-5. Los tres límites de decisión están representados por tres colores diferentes.
Puedes hacer lo mismo considerando el tamaño de los pétalos.

de matplotlib.colors import ListedColormap
x = iris.data [:, 2: 4] # Eje X - pétalos largo-ancho
y = iris.target # Eje Y - especies

#MALLA
cmap_light = ListedColormap (['# AAAAFF', '# AAFFAA', '# FFAAAA'])
h = .02
xx, yy = np.meshgrid (np.arange (x_min, x_max, h), np.arange (y_min, y_max, h))
325
Página 340
knn.fit (x, y)
Z = knn.predict (np.c_ [xx.ravel (), yy.ravel ()])
Z = Z.reforma (forma xx)
plt.figure ()
plt.pcolormesh (xx, yy, Z, cmap = cmap_light)
# Trazar los puntos de entrenamiento

plt.xlim (xx.min (), xx.max ())
plt.ylim (aa.min (), aa.max ())
Fuera [126]: (-0.40000000000000002, 2.9800000000000031)
Como se muestra en la figura 8-6 , tendrá los límites de decisión correspondientes

en cuanto a la caracterización de las flores de iris teniendo en cuenta el tamaño de los pétalos.
Figura 8-6. Los límites de decisión en un diagrama de dispersión 2D que describe los tamaños de los pétalos
326
Página 341
Conjunto de datos de diabetes

Entre los diversos conjuntos de datos disponibles dentro de la biblioteca scikit-learn, está el
conjunto de datos de diabetes. Este conjunto de datos se utilizó por primera vez en 2004 ( Annals of Statistics , por
Efron, Hastie, Johnston y Tibshirani). Desde entonces se ha convertido en un ejemplo ampliamente
utilizado para estudiar varios modelos predictivos y su eficacia.
Para cargar los datos contenidos en este conjunto de datos, antes debe importar los conjuntos de datos
módulo de la biblioteca scikit-learn y luego llama a la función load_diabetes () para
cargue el conjunto de datos en una variable que se llamará diabetes.
En []: de sklearn importar conjuntos de datos

...: diabetes = datasets.load_diabetes ()
Este conjunto de datos contiene datos fisiológicos recopilados en 442 pacientes y como un
apuntar a un indicador de la progresión de la enfermedad después de un año. Los datos fisiológicos ocupan
las primeras 10 columnas con valores que indican respectivamente lo siguiente:
• Años
• Sexo
• Índice de masa corporal
• Presión arterial
• S1, S2, S3, S4, S5 y S6 (seis mediciones de suero sanguíneo)
Estas medidas se pueden obtener llamando al atributo de datos. Pero yendo a

verifique los valores en el conjunto de datos, encontrará valores muy diferentes de lo que buscaría
han esperado. Por ejemplo, miramos los 10 valores del primer paciente.
diabetes.data [0]
Fuera[ ]:
matriz ([0.03807591, 0.05068012, 0.06169621, 0.02187235, -0.0442235,
-0.03482076, -0.04340085, -0.00259226, 0.01990842, -0.01764613])
Estos valores son de hecho el resultado de un procesamiento. Cada uno de los 10 valores fue la media
centrado y posteriormente escalado por la desviación estándar multiplicada por el número de
muestras. La verificación revelará que la suma de los cuadrados de cada columna es igual a 1. Intente
haciendo este cálculo con las medidas de edad; obtendrás un valor muy cercano a 1.
np.sum (diabetes.data [:, 0] ** 2)

Fuera [143]: 1.0000000000000746
327
Página 342
Aunque estos valores están normalizados y, por tanto, son difíciles de leer,
continúan expresando las 10 características fisiológicas y por lo tanto no han perdido su
valor o información estadística.
En cuanto a los indicadores del avance de la enfermedad, es decir, los valores que deben
corresponden a los resultados de sus predicciones, estos se pueden obtener mediante el
atributo de destino.
diabetes.target
Fuera [146]:
matriz ([151., 75., 141., 206., 135., 97., 138., 63., 110.,
310., 101., 69., 179., 185., 118., 171., 166., 144.,
97., 168., 68., 49., 68., 245., 184., 202., 137
...
Obtienes una serie de 442 valores enteros entre 25 y 346.
Regresión lineal: la regresión de mínimos cuadrados

La regresión lineal es un procedimiento que utiliza datos contenidos en el conjunto de entrenamiento para construir
un modelo lineal. El más simple se basa en la ecuación de un rect con los dos
parámetros ayb para caracterizarlo. Estos parámetros se calcularán para hacer
la suma de los residuos al cuadrado lo más pequeña posible.
y=a*x+c
En esta expresión, x es el conjunto de entrenamiento, y es el objetivo, b es la pendiente y c es la

intersección del rect representado por el modelo. En scikit-learn, para usar el predictivo
modelo para la regresión lineal, debe importar el módulo linear_model y luego
utilice el constructor LinearRegression () del fabricante para crear el modelo predictivo,
al que llamas linreg.
desde sklearn importar linear_model

linreg = linear_model.LinearRegression ()
Para practicar con un ejemplo de regresión lineal, puede utilizar el conjunto de datos de diabetes
descrito anteriormente. Primero deberá dividir a los 442 pacientes en un conjunto de entrenamiento
(compuesto por los primeros 422 pacientes) y un conjunto de prueba (los últimos 20 pacientes).
328
Página 343

diabetes = datasets.load_diabetes ()
x_train = diabetes.data [: - 20]
y_train = diabetes.target [: - 20]
x_test = diabetes.data [-20:]
y_test = diabetes.target [-20:]
Ahora aplique el conjunto de entrenamiento al modelo predictivo mediante el uso de la función fit ().
linreg.fit (tren_x, tren_y)

Fuera []: LinearRegression (copy_X = True, fit_intercept = True, normalize = False)
Una vez entrenado el modelo, puede obtener los coeficientes de 10 b calculados para cada
variable fisiológica, utilizando el atributo coef_ del modelo predictivo.
linreg.coef_
Fuera [164]:
matriz ([3.03499549e-01, -2.37639315e + 02, 5.10530605e + 02,
3.27736980e + 02, -8.14131709e + 02, 4.92814588e + 02,
1.02848452e + 02, 1.84606489e + 02, 7.43519617e + 02,
7.60951722e + 01])
Si aplica el conjunto de prueba al modelo de predicción linreg, obtendrá una serie de objetivos
comparar con los valores realmente observados.
linreg.predict (prueba_x)
Fuera[ ]:
matriz ([197.61846908, 155.43979328, 172.88665147, 111.53537279,
164.80054784, 131.06954875, 259.12237761, 100.47935157,
117.0601052, 124.30503555, 218.36632793, 61.19831284,
132.25046751, 120.3332925, 52.54458691, 194.03798088,
102.57139702, 123.56604987, 211.0346317, 52.60335674])
y_test
Fuera[ ]:
matriz ([233., 91., 111., 152., 120., 67., 310., 94., 183.,
66., 173., 72., 49., 64., 48., 178., 104., 132.,
220., 57.])
329
Página 344
Sin embargo, un buen indicador de qué predicción debería ser perfecta es la varianza . los
cuanto más cerca esté la varianza de 1, más perfecta será la predicción.
linreg.score (prueba_x, prueba_y)

Fuera []: 0.58507530226905713
Ahora comenzará con la regresión lineal, teniendo en cuenta un solo

factor fisiológico, por ejemplo, puede comenzar desde la edad.

x0_test = x_test [:, 0]

x0_train = x_train [:, 0]
x0_test = x0_test [:, np.newaxis]
x0_train = x0_train [:, np.newaxis]
linreg = linear_model.LinearRegression ()
linreg.fit (tren_x0, tren_y)
y = linreg.predict (x0_test)
plt.scatter (prueba_x0, prueba_y, color = 'k')
plt.plot (x0_test, y, color = 'b', linewidth = 3)
Salida [230]: [<matplotlib.lines.Line2D en 0x380b1908>]
Figura 8-7 muestra la línea azul que representa la correlación lineal entre las edades
de los pacientes y la progresión de la enfermedad.
330
Página 345
Figura 8-7. Una regresión lineal representa una correlación lineal entre una característica
y los objetivos
En realidad, tiene 10 factores fisiológicos dentro del conjunto de datos de diabetes. Por lo tanto,
para tener una imagen más completa de todo el conjunto de entrenamiento, puede hacer una regresión lineal
para cada característica fisiológica, creando 10 modelos y viendo el resultado de cada uno de ellos
a través de un gráfico lineal.

plt.figure (figsize = (8,12))
para f en el rango (0,10):
xi_test = x_test [:, f]
xi_train = x_train [:, f]
xi_test = xi_test [:, np.newaxis]
331
Página 346
xi_train = xi_train [:, np.newaxis]

linreg.fit (xi_train, y_train)
y = linreg.predict (xi_test)
plt. subparcela (5,2, f + 1)
plt.scatter (xi_test, y_test, color = 'k')
plt.plot (xi_test, y, color = 'b', linewidth = 3)
Figura 8-8 muestra 10 gráficos lineales, cada uno de los cuales representa la correlación entre un
factor fisiológico y progresión de la diabetes.
332
Página 347
Figura 8-8. Diez gráficos lineales que muestran las correlaciones entre fisiológicas
factores y la progresión de la diabetes
333
Página 348
Máquinas de vectores de soporte (SVM)

Support Vector Machines son una serie de técnicas de aprendizaje automático que fueron
desarrollado en los laboratorios de AT&T por Vapnik y sus colegas a principios de los 90. los
La base de esta clase de procedimientos es de hecho un algoritmo llamado Vector de soporte , que es un
generalización de un algoritmo anterior llamado retrato generalizado, desarrollado en Rusia
en 1963 por Vapnik también.
En palabras simples, los clasificadores SVM son modelos binarios o discriminantes, que funcionan
en dos clases de diferenciación. Su principal tarea es básicamente discriminar
nuevas observaciones entre dos clases. Durante la fase de aprendizaje, estos clasificadores
proyectar las observaciones en un espacio multidimensional llamado espacio decisional y construir
una superficie de separación llamada límite de decisión que divide este espacio en dos áreas
de pertenecer. En el caso más simple, es decir, el caso lineal, el límite de decisión será
representado por un plano (en 3D) o por una línea recta (en 2D). En casos más complejos, el
Las superficies de separación son formas curvas con formas cada vez más articuladas.
El SVM se puede utilizar tanto en regresión con el SVR (Support Vector Regression)
y en clasificación con la SVC (Clasificación de vectores de soporte) .
Clasificación de vectores de soporte (SVC)

Si desea comprender mejor cómo funciona este algoritmo, puede comenzar consultando el
caso más simple, ese es el caso 2D lineal, donde el límite de decisión será una línea recta
separando en dos partes el área de decisión. Tomemos, por ejemplo, un conjunto de entrenamiento simple donde
algunos puntos se asignan a dos clases diferentes. El conjunto de entrenamiento constará de 11 puntos
(observaciones) con dos atributos diferentes que tendrán valores entre 0 y 4. Estos
los valores estarán contenidos dentro de una matriz NumPy llamada x. Su pertenencia a uno de dos
las clases serán definidas por valores 0 o 1 contenidos en otra matriz llamada y.
Visualice la distribución de estos puntos en el espacio con un diagrama de dispersión que luego será
definido como un espacio de decisión (ver Figura 8-9).

desde sklearn import svm
x = np.array ([[1,3], [1,2], [1,1.5], [1.5,2], [2,3], [2.5,1.5],
[2,1], [3,1], [3,2], [3.5,1], [3.5,3]])
334
Página 349
y = [0] * 6 + [1] * 5
plt.scatter (x [:, 0], x [:, 1], c = y, s = 50, alpha = 0.9)
Fuera [360]: <matplotlib.collections.PathCollection at 0x545634a8>
Figura 8-9. La gráfica de dispersión del conjunto de entrenamiento muestra el espacio de decisión
Ahora que ha definido el conjunto de entrenamiento, puede aplicar el SVC (Vector de soporte
Algoritmo de clasificación). Este algoritmo creará una línea (límite de decisión) en orden
para dividir el área de decisión en dos partes (ver Figura 8-10), y esta línea recta será
colocado para maximizar su distancia de las observaciones más cercanas contenidas en el entrenamiento
conjunto. Esta condición debe producir dos porciones diferentes en las que todos los puntos de un mismo
la clase debe estar contenida.
Luego aplica el algoritmo SVC al conjunto de entrenamiento y para hacerlo, primero define
el modelo con el constructor SVC ( ) definiendo el kernel como lineal. (Un kernel es una clase de
algoritmos para el análisis de patrones). Luego, usará la función fit () con el entrenamiento
establecido como argumento. Una vez que el modelo está entrenado, puede trazar el límite de decisión
con la función decision_function (). Luego dibuja el diagrama de dispersión y proporciona un
color diferente a las dos porciones del espacio de decisión.

x = np.array ([[1,3], [1,2], [1,1.5], [1.5,2], [2,3], [2.5,1.5],
[2,1], [3,1], [3,2], [3.5,1], [3.5,3]])
335
Página 350
y = [0] * 6 + [1] * 5
svc = svm.SVC (kernel = 'lineal'). fit (x, y)
X, Y = np.mgrid [0: 4: 200j, 0: 4: 200j]
Z = svc.decision_function (np.c_ [X.ravel (), Y.ravel ()])
Z = Z.rehape (X.shape)
plt.contourf (X, Y, Z> 0, alpha = 0.4)
plt.contour (X, Y, Z, colores = ['k'], estilos de línea = ['-'], niveles = [0])
Fuera [363]: <matplotlib.collections.PathCollection en 0x54acae10>
En figura 8-10 , puede ver las dos partes que contienen las dos clases. Puede decirse
que la división es exitosa excepto por un punto azul en la parte roja.
Figura 8-10. El área de decisión se divide en dos partes
Entonces, una vez que se ha entrenado el modelo, es sencillo comprender cómo las predicciones
funcionar. Gráficamente, dependiendo de la posición ocupada por la nueva observación,
conocerá su pertenencia correspondiente en una de las dos clases.
En cambio, desde un punto de vista más programático, la función predecir () devolverá el
número de la clase de pertenencia correspondiente (0 para la clase en azul, 1 para la clase en rojo).
336
Página 351
svc.predict ([[1.5,2.5]])
Fuera [56]: matriz ([0])
svc.predict ([[2.5,1]])
Fuera [57]: matriz ([1])
Un concepto relacionado con el algoritmo SVC es la regularización . Lo establece el parámetro

C: un valor pequeño de C significa que el margen se calcula utilizando muchos o todos los
observaciones alrededor de la línea de separación (mayor regularización), mientras que un valor grande
de C significa que el margen se calcula sobre las observaciones cercanas a la línea de separación
(menor regularización). A menos que se especifique lo contrario, el valor predeterminado de C es igual a 1.
Puede resaltar los puntos que participaron en el cálculo del margen, identificándolos
a través de la matriz support_vectors.

x = np.array ([[1,3], [1,2], [1,1.5], [1.5,2], [2,3], [2.5,1.5],
[2,1], [3,1], [3,2], [3.5,1], [3.5,3]])
y = [0] * 6 + [1] * 5
svc = svm.SVC (kernel = 'lineal', C = 1) .fit (x, y)
X, Y = np.mgrid [0: 4: 200j, 0: 4: 200j]
plt.contour (X, Y, Z, colors = ['k', 'k', 'k'], linestyles = ['-', '-', '-'],
niveles = [- 1,0,1])
plt.scatter (svc.support_vectors _ [:, 0], svc.support_vectors _ [:, 1], s = 120,
facecolors = 'r')
Fuera [23]: <matplotlib.collections.PathCollection en 0x177066a0>
Estos puntos están representados por círculos con borde en el diagrama de dispersión. Además, ellos
estará dentro de un área de evaluación en las proximidades de la línea de separación (ver el
líneas en la figura 8-11 ).
337
Página 352
Figura 8-11. El número de puntos involucrados en el cálculo depende de la C

parámetro
Para ver el efecto en el límite de decisión, puede restringir el valor a C = 0,1. Vamos
vea cuántos puntos se tendrán en cuenta.

x = np.array ([[1,3], [1,2], [1,1.5], [1.5,2], [2,3], [2.5,1.5],
[2,1], [3,1], [3,2], [3.5,1], [3.5,3]])
y = [0] * 6 + [1] * 5
svc = svm.SVC (kernel = 'lineal', C = 0.1) .fit (x, y)
X, Y = np.mgrid [0: 4: 200j, 0: 4: 200j]
plt.contour (X, Y, Z, colors = ['k', 'k', 'k'], linestyles = ['-', '-', '-
'], niveles = [- 1,0,1])
plt.scatter (svc.support_vectors _ [:, 0], svc.support_vectors_
[:, 1], s = 120, facecolors = 'w')
Salida [24]: <matplotlib.collections.PathCollection en 0x1a01ecc0>
338
Página 353
Se aumentan los puntos tomados en consideración y consecuentemente la separación

la línea (límite de decisión) ha cambiado de orientación. Pero ahora hay dos puntos que son
en las áreas de decisión equivocada (ver Figura 8-12 ).
Figura 8-12. El número de puntos involucrados en el cálculo crece con

disminución de C
SVC no lineal
Hasta ahora, ha visto el algoritmo lineal SVC que define una línea de separación que era
destinado a dividir las dos clases. También hay algoritmos SVC más complejos que
puede establecer curvas (2D) o superficies curvas (3D) basándose en los mismos principios de
maximizando las distancias entre los puntos más cercanos a la superficie. Veamos el sistema
utilizando un núcleo polinomial.
Como su nombre lo indica, puede definir una curva polinomial que separe el área
decisión en dos partes. El grado del polinomio se puede definir por el grado
opción. Incluso en este caso C es el coeficiente de regularización. Así que intenta aplicar un SVC
algoritmo con un núcleo polinomial de tercer grado y con un coeficiente C igual a 1.

x = np.array ([[1,3], [1,2], [1,1.5], [1.5,2], [2,3], [2.5,1.5],
339
Página 354
[2,1], [3,1], [3,2], [3.5,1], [3.5,3]])

y = [0] * 6 + [1] * 5
svc = svm.SVC (kernel = 'poli', C = 1, grado = 3) .fit (x, y)
X, Y = np.mgrid [0: 4: 200j, 0: 4: 200j]
'], niveles = [- 1,0,1])
[:, 1], s = 120, facecolors = 'w')
Fuera [34]: <matplotlib.collections.PathCollection en 0x1b6a9198>
Como puede ver, obtiene la situación que se muestra en la Figura 8-13..
Figura 8-13. El espacio de decisión usando un SVC con un núcleo polinomial
Otro tipo de kernel no lineal es la función de base radial (RBF) . En este caso el
Las curvas de separación tienden a definir las zonas radialmente con respecto a los puntos de observación.
del conjunto de entrenamiento.
340
Página 355

x = np.array ([[1,3], [1,2], [1,1.5], [1.5,2], [2,3], [2.5,1.5],
[2,1], [3,1], [3,2], [3.5,1], [3.5,3]])
y = [0] * 6 + [1] * 5
svc = svm.SVC (kernel = 'rbf', C = 1, gamma = 3) .fit (x, y)
X, Y = np.mgrid [0: 4: 200j, 0: 4: 200j]
'], niveles = [- 1,0,1])
[:, 1], s = 120, facecolors = 'w')
Fuera [43]: <matplotlib.collections.PathCollection en 0x1cb8d550>
En figura 8-14 , puede ver las dos partes de la decisión con todos los puntos del
conjunto de entrenamiento colocado correctamente.
Figura 8-14. El área de decisión usando un SVC con el kernel RBF
341
Página 356
Trazado de diferentes clasificadores de SVM mediante el conjunto de datos Iris

El ejemplo de SVM que acaba de ver se basa en un conjunto de datos muy simple. Esta sección
utiliza conjuntos de datos más complejos para un problema de clasificación con SVC. De hecho, utiliza el
conjunto de datos utilizado anteriormente: el conjunto de datos Iris.
El algoritmo SVC utilizado anteriormente se aprendió de un conjunto de entrenamiento que contiene solo dos
clases. En este caso, extenderá el caso a tres clasificaciones, ya que el conjunto de datos Iris es
dividido en tres clases, correspondientes a las tres diferentes especies de flores.
En este caso, los límites de decisión se cruzan entre sí, subdividiendo la decisión
área (en el caso 2D) o el volumen de decisión (3D) en varias porciones.
Ambos modelos lineales tienen límites de decisión lineales (intersección de hiperplanos),
mientras que los modelos con núcleos no lineales (polinomio o RBF gaussiano) tienen
límites de decisión. Estos límites son más flexibles con figuras que dependen
sobre el tipo de kernel y sus parámetros.

desde sklearn import svm, datasets
x = iris.data [:,: 2]
y = iris.target
h = .05
svc = svm.SVC (kernel = 'lineal', C = 1.0) .fit (x, y)
h = .02
X, Y = np.meshgrid (np.arange (x_min, x_max, h), np.arange (y_min, y_max, h))
Z = svc.predict (np.c_ [X.ravel (), Y.ravel ()])

plt.contourf (X, Y, Z, alpha = 0.4)
plt.contour (X, Y, Z, colores = 'k')
Fuera [49]: <matplotlib.collections.PathCollection en 0x1f2bd828>
342
Página 357
En figura 8-15 , el espacio de decisión se divide en tres partes separadas por

fronteras decisionales.
Figura 8-15. Los límites decisorios dividen el área decisional en tres
diferentes porciones
Ahora es el momento de aplicar un kernel no lineal para generar decisiones no lineales

límites, como el núcleo polinomial.

desde sklearn import svm, datasets
x = iris.data [:,: 2]
y = iris.target
h = .05
svc = svm.SVC (kernel = 'poli', C = 1.0, grado = 3) .fit (x, y)
h = .02
X, Y = np.meshgrid (np.arange (x_min, x_max, h), np.arange (y_min, y_max, h))
343
Página 358
Z = svc.predict (np.c_ [X.ravel (), Y.ravel ()])

plt.contourf (X, Y, Z, alpha = 0.4)
plt.contour (X, Y, Z, colores = 'k')
Salida [50]: <matplotlib.collections.PathCollection en 0x1f4cc4e0>
Figura 8-16 muestra cómo los límites de decisión polinomial dividen el área de una manera muy
forma diferente en comparación con el caso lineal.
Figura 8-16. En el caso del polinomio, la parte azul no está conectada directamente con
la porción roja
Ahora puede aplicar el kernel RBF para ver la diferencia en la distribución de áreas.
svc = svm.SVC (kernel = 'rbf', gamma = 3, C = 1.0) .fit (x, y)
Figura 8-17 muestra cómo el kernel RBF genera áreas radiales.
344
Página 359
Figura 8-17. El kernel RBF define áreas de decisión radiales
Soporte de regresión vectorial (SVR)

El método SVC se puede ampliar para resolver incluso problemas de regresión. Este método es
llamado Regresión de vectores de soporte .
El modelo producido por SVC en realidad no depende del conjunto de entrenamiento completo,
pero utiliza sólo un subconjunto de elementos, es decir, los más cercanos al límite decisional. en un
De manera similar, el modelo producido por SVR también depende solo de un subconjunto del conjunto de entrenamiento.
Demostraremos cómo el algoritmo SVR utilizará el conjunto de datos de diabetes que
que ya ha visto en este capítulo. A modo de ejemplo, se referirá únicamente a la
terceros datos fisiológicos. Realizarás tres regresiones diferentes, una lineal y una
dos no lineales (polinomios). El caso lineal producirá una línea recta como el lineal
modelo predictivo es muy similar a la regresión lineal visto anteriormente, mientras que
Se construirán regresiones polinomiales de segundo y tercer grados. La función SVR ()
es casi idéntica a la función SVC () vista anteriormente.
El único aspecto a considerar es que el conjunto de datos de prueba debe ordenarse en orden ascendente
orden.
345
Página 360

x0_test = x_test [:, 2]

x0_train = x_train [:, 2]
x0_test = x0_test [:, np.newaxis]
x0_train = x0_train [:, np.newaxis]
x0_test.sort (eje = 0)
x0_test = x0_test * 100
x0_train = x0_train * 100
svr = svm.SVR (kernel = 'lineal', C = 1000)

svr2 = svm.SVR (kernel = 'poli', C = 1000, grado = 2)
svr3 = svm.SVR (kernel = 'poli', C = 1000, grado = 3)
svr.fit (tren_x0, tren_y)
svr2.fit (tren_x0, tren_y)
svr3.fit (tren_x0, tren_y)
y = svr.predict (x0_test)
y2 = svr2.predict (x0_test)
y3 = svr3.predict (x0_test)
plt.scatter (prueba_x0, prueba_y, color = 'k')
plt.plot (x0_test, y, color = 'b')
plt.plot (x0_test, y2, c = 'r')
plt.plot (x0_test, y3, c = 'g')
Fuera [155]: [<matplotlib.lines.Line2D en 0x262e10b8>]
346
Página 361
Las tres curvas de regresión se representarán con tres colores. El lineal

la regresión será azul; el polinomio de segundo grado, es decir, una parábola, será rojo;
y el polinomio de tercer grado será verde (ver Figura 8-18).
Figura 8-18. Las tres curvas de regresión producen tendencias muy diferentes a partir de
del set de entrenamiento
Conclusiones
En este capítulo, vio los casos más simples de problemas de regresión y clasificación.
resuelto usando la biblioteca scikit-learn. Muchos conceptos de la fase de validación de un
El modelo predictivo se presentó de forma práctica a través de algunos ejemplos prácticos.
En el siguiente capítulo verá un caso completo en el que todos los pasos del análisis de datos
se discuten a modo de un solo ejemplo práctico. Todo se implementará en
IPython Notebook, un entorno interactivo e innovador muy adecuado para compartir
cada paso del análisis de datos con la forma de una documentación interactiva útil como
informe o como presentación web.
347
Página 362
CAPÍTULO 9
Aprendizaje profundo con

TensorFlow
2017 fue un año especial para el aprendizaje profundo . Además de los grandes resultados experimentales
obtenido gracias a los algoritmos desarrollados, el aprendizaje profundo ha visto su gloria en la
lanzamiento de muchos frameworks con los que desarrollar numerosos proyectos. Algunos de ustedes lo harán
ciertamente ya conoces esta rama del aprendizaje automático, otras que ciertamente has escuchado
alguien lo menciona. Dada la gran importancia que el aprendizaje profundo está adquiriendo en los datos
técnicas de procesamiento y análisis, me pareció importante agregar este nuevo capítulo en el
segunda edición de este libro.
En este capítulo puede tener una descripción general introductoria del mundo del aprendizaje profundo,
y las redes neuronales artificiales en las que se basan sus técnicas. Además,
entre los nuevos marcos de Python para el aprendizaje profundo, utilizará TensorFlow, que es
demostrando ser una excelente herramienta para la investigación y el desarrollo de análisis de aprendizaje profundo
Técnicas Con esta biblioteca verá cómo desarrollar diferentes modelos de neuronas
redes que son la base del aprendizaje profundo.
Inteligencia artificial, aprendizaje automático y profundidad

Aprendizaje
Para cualquiera que se ocupe del mundo del análisis de datos, estos tres términos son, en última instancia, muy
común en la web, en texto y en seminarios relacionados con el tema. Pero cual es el
relación entre ellos? ¿Y en qué consisten realmente?
En esta sección verá las definiciones detalladas de estos tres términos. Vas a
descubrir cómo en las últimas décadas, la necesidad de crear algoritmos cada vez más elaborados,
y poder hacer predicciones y clasificar datos de forma cada vez más eficiente, ha llevado a
349
© Fabio Nelli 2018
Página 363
CAPÍTULO 9 APRENDIZAJE PROFUNDO CON TENSORFLOW
aprendizaje automático. Entonces descubrirás cómo, gracias a las nuevas innovaciones tecnológicas,
y en particular a la potencia informática alcanzada por la GPU, aprendizaje profundo
Se han desarrollado técnicas basadas en redes neuronales.
Inteligencia artificial
El término inteligencia artificial fue utilizado por primera vez por John McCarthy en 1956, en un momento
lleno de grandes esperanzas y entusiasmo por el mundo de la tecnología. Estaban al amanecer
de electrónica y computadoras tan grandes como habitaciones enteras que podrían hacer algunos
cálculos, pero lo hicieron de manera tan eficiente y rápida en comparación con los humanos que
Ya vislumbraba posibles desarrollos futuros de la inteligencia electrónica.
Pero sin entrar en el mundo de la ciencia ficción, la definición actual más adecuada
a la inteligencia artificial, a menudo referida como IA, podría resumirse brevemente con el
la siguiente frase:
Procesamiento automático en una computadora capaz de realizar operaciones que

parecería ser exclusivamente relevante para la inteligencia humana.
De ahí que el concepto de inteligencia artificial sea un concepto variable que varía con
el progreso de las propias máquinas y con el concepto de "exclusividad humana
Relevancia". Mientras que en los años 60 y 70 veíamos la inteligencia artificial como la capacidad de
computadoras para realizar cálculos y encontrar soluciones matemáticas de complejos
problemas "de relevancia exclusiva de grandes científicos", en los años 80 y 90 maduró en
la capacidad de evaluar riesgos, recursos y tomar decisiones. En el año 2000, con el
crecimiento continuo del potencial informático, la posibilidad de estos sistemas para
aprender con aprendizaje automático se agregó a la definición.
Finalmente, en los últimos años, el concepto de inteligencia artificial se ha centrado en
operaciones de reconocimiento visual y auditivo, que hasta hace poco se pensaba
“Relevancia humana exclusiva”.
Estas operaciones incluyen:
• Reconocimiento de imagen
• Detección de objetos
• Segmentación de objetos
• Traducción de idiomas
350
Página 364
• Comprensión del lenguaje natural
• Reconocimiento de voz
Estos son los problemas aún en estudio gracias a las técnicas de deep learning.
El aprendizaje automático es una rama de la inteligencia artificial

En el capítulo anterior, vio el aprendizaje automático en detalle, con muchos ejemplos de
diferentes técnicas para clasificar o predecir datos.
El aprendizaje automático (ML), con todas sus técnicas y algoritmos, es una gran rama de
inteligencia artificial. De hecho, se refiere a él, sin dejar de estar dentro del ámbito de la
inteligencia cuando utiliza sistemas que son capaces de aprender (sistemas de aprendizaje) para resolver
diversos problemas que poco antes habían sido “considerados exclusivos del ser humano”.
El aprendizaje profundo es una rama del aprendizaje automático

Dentro de las técnicas de aprendizaje automático, se puede definir una subclase adicional, denominada deep
aprendiendo . En el Capítulo 8, vio que el aprendizaje automático usa sistemas que pueden aprender y
esto se puede hacer a través de características dentro del sistema (a menudo parámetros de un modelo fijo)
que se modifican en respuesta a los datos de entrada destinados al aprendizaje (conjunto de formación).
Las técnicas de deep learning dan un paso adelante. De hecho, los sistemas de aprendizaje profundo son
estructurado para no tener estas características intrínsecas en el modelo, pero estas
características son extraídas y detectadas por el sistema automáticamente como resultado de
aprendiendo a sí mismo. Entre estos sistemas que pueden hacer esto, nos referimos en particular a la artificial
redes neuronales .
La relación entre inteligencia artificial, máquina

Aprendizaje y aprendizaje profundo

En resumen, en esta sección ha visto que el aprendizaje automático y el aprendizaje profundo son
en realidad, subclases de inteligencia artificial. La figura 9-1 muestra una esquematización de clases.
en esta relación.
351
Página 365
Figura 9-1. Esquematización de la relación entre inteligencia artificial,

aprendizaje automático y aprendizaje profundo
Aprendizaje profundo
En esta sección, aprenderá sobre algunos factores importantes que llevaron al desarrollo de
aprendizaje profundo y leer por qué solo en estos últimos años se han dado tantos pasos hacia adelante.
Redes neuronales y GPU

En la sección anterior, aprendiste que en el campo de la inteligencia artificial, en profundidad
El aprendizaje se ha hecho popular sólo en los últimos años precisamente para resolver problemas de
reconocimiento visual y auditivo.
En el contexto del aprendizaje profundo, muchas técnicas de cálculo y algoritmos han
desarrollado en los últimos años, aprovechando al máximo el potencial del lenguaje Python.
Pero la teoría detrás del aprendizaje profundo en realidad se remonta a muchos años atrás. De hecho, el concepto
de la red neuronal se introdujo en 1943, y los primeros estudios teóricos sobre
Las redes neuronales artificiales y sus aplicaciones se desarrollaron en los años 60.
El caso es que sólo en los últimos años las redes neuronales, con el profundo relacionado
técnicas de aprendizaje que las utilizan, han resultado útiles para resolver muchos problemas de
inteligencia artificial. Esto se debe al hecho de que solo ahora existen tecnologías que pueden
implementarse de manera útil y eficiente.
352
Página 366
De hecho, a nivel de aplicación, el aprendizaje profundo requiere matemáticas muy complejas.

operaciones que requieren millones o incluso miles de millones de parámetros. Las CPU de los 90,
incluso si fueran poderosos, no pudieron realizar este tipo de operaciones en tiempos eficientes.
Incluso hoy en día el cálculo con las CPU, aunque mejorado considerablemente, requiere
largos tiempos de procesamiento. Esta ineficiencia se debe a la arquitectura particular de las CPU,
que han sido diseñados para realizar eficientemente operaciones matemáticas que no son
los requeridos por las redes neuronales.
Pero en las últimas décadas se ha desarrollado un nuevo tipo de hardware, el procesamiento de gráficos
Unit (GPU), gracias al enorme impulso comercial del mercado de los videojuegos. En
De hecho, este tipo de procesador ha sido diseñado para gestionar vectores cada vez más eficientes.
cálculos, como multiplicaciones entre matrices, que es necesario para la realidad 3D
simulaciones y renderizado.
Gracias a esta innovación tecnológica, muchas técnicas de aprendizaje profundo han
se ha realizado. De hecho, para darse cuenta de las redes neuronales y su aprendizaje, los tensores
(matrices multidimensionales), realizando muchas operaciones matemáticas. Eso
Es precisamente este tipo de trabajo el que las GPU pueden realizar de forma más eficiente. Gracias a su
contribución, la velocidad de procesamiento del aprendizaje profundo se incrementa en varios órdenes de
magnitud (días en lugar de meses).
Disponibilidad de datos: fuente de datos abierta, Internet de las cosas,

y Big Data
Otro factor muy importante que afecta el desarrollo del aprendizaje profundo es la enorme
cantidad de datos a los que se puede acceder. De hecho, los datos son el ingrediente fundamental para la
funcionamiento de las redes neuronales, tanto para la fase de aprendizaje como para su fase de verificación.
Gracias a la expansión de Internet en todo el mundo, ahora todos pueden acceder
y producir datos. Mientras que hace unos años solo unas pocas organizaciones proporcionaban datos
para el análisis, hoy, gracias al IoT (Internet of Things), muchos sensores y dispositivos
Adquirir datos y ponerlos a disposición en redes. No solo eso, incluso las redes sociales
y los motores de búsqueda (como Facebook, Google, etc.) pueden recopilar grandes cantidades de datos,
analizando en tiempo real millones de usuarios conectados a sus servicios (denominado Big Data ).
Así que hoy en día muchos datos relacionados con los problemas que queremos resolver con el aprendizaje profundo
técnicas, están fácilmente disponibles no solo por una tarifa, sino también en forma gratuita (fuente de datos abierta).
353
Página 367
Pitón
Otro factor que contribuyó al gran éxito y difusión del aprendizaje profundo
técnicas fue el lenguaje de programación Python.
En el pasado, la planificación de sistemas de redes neuronales era muy compleja. El único idioma
capaz de llevar a cabo esta tarea era C ++, un lenguaje muy complejo, difícil de usar y conocido
solo a unos pocos especialistas. Además, para trabajar con la GPU (necesaria para este tipo
de cálculo), era necesario conocer CUDA (Compute Unified Device Architecture),
la arquitectura de desarrollo de hardware de las tarjetas gráficas NVIDIA con todas sus características técnicas
especificaciones.
Hoy, gracias a Python, la programación de redes neuronales y el aprendizaje profundo
Las técnicas se han vuelto de alto nivel. De hecho, los programadores ya no tienen que pensar en
la arquitectura y las especificaciones técnicas de la tarjeta gráfica (GPU), pero puede
centrarse exclusivamente en la parte relacionada con el aprendizaje profundo. Además, las características del
El lenguaje Python permite a los programadores desarrollar código simple e intuitivo. Tienes
ya probé esto con el aprendizaje automático en el capítulo anterior, y lo mismo se aplica a
aprendizaje profundo.
Marcos de Python de aprendizaje profundo

Durante los últimos dos años, muchas organizaciones y comunidades de desarrolladores se han
desarrollar marcos de Python que simplifican enormemente el cálculo y
aplicación de técnicas de aprendizaje profundo. Hay mucho entusiasmo al respecto y muchos
de estas bibliotecas realizan las mismas operaciones casi de forma competitiva, pero cada una de ellas
basado en diferentes mecanismos internos. Veremos cuáles en los próximos años serán
más exitoso o no.
Entre estos frameworks disponibles hoy en día de forma gratuita, cabe mencionar algunos que
están obteniendo cierto éxito.
• TensorFlow es una biblioteca de código abierto para el cálculo numérico que

basa su uso en gráficos de flujo de datos. Estos son gráficos donde los nodos
representan las operaciones matemáticas y los bordes representan
tensores (matrices de datos multidimensionales). Su arquitectura es muy
flexible y puede distribuir los cálculos en múltiples CPU
y en múltiples GPU.
354
Página 368
• Caffe2 es un marco desarrollado para proporcionar una forma fácil y sencilla

trabajar en el aprendizaje profundo. Te permite probar el modelo y el algoritmo
cálculos utilizando la potencia de las GPU en la nube.
• PyTorch es un marco científico completamente basado en el uso de

GPU. Funciona de manera muy eficiente y fue desarrollado recientemente
y aún no está bien consolidado. Todavía está demostrando ser una herramienta poderosa para
investigación científica.
• Theano es la biblioteca de Python más utilizada en el campo científico para la

desarrollo, definición y evaluación de expresiones matemáticas
y modelos físicos. Desafortunadamente, el equipo de desarrollo
anunció que ya no se lanzarán nuevas versiones. Sin embargo,
sigue siendo un marco de referencia gracias a la cantidad de programas
desarrollado con esta biblioteca, tanto en la literatura como en la web.
Redes neuronales artificiales

Las redes neuronales artificiales son un elemento fundamental para el aprendizaje profundo y su uso
es la base de muchas, si no casi todas, técnicas de aprendizaje profundo. De hecho, estos sistemas
son capaces de aprender, gracias a su estructura particular que se refiere a las neuronas biológicas
circuitos.
En esta sección, verá con más detalle qué son las redes neuronales artificiales y
cómo están estructurados.
Cómo se estructuran las redes neuronales artificiales

Las redes neuronales artificiales son estructuras complejas creadas conectando elementos básicos simples
componentes que se repiten dentro de la estructura. Dependiendo del número de estos
componentes básicos y el tipo de conexiones, las redes cada vez más complejas serán
formado, con diferentes arquitecturas, cada una de las cuales presentará características peculiares
en cuanto a la capacidad de aprender y resolver diferentes problemas del aprendizaje profundo.
Figura 9-2 muestra un ejemplo de cómo se estructura una red neuronal artificial genérica.
355
Página 369
Figura 9-2. Una esquematización de cómo es una red neuronal artificial genérica
estructurado
Las unidades básicas se denominan nodos (los círculos de colores que se muestran en la Figura 9-2 ), que
en el modelo biológico simulan el funcionamiento de una neurona dentro de una red neuronal.
Estas neuronas artificiales realizan operaciones muy simples, similares a las biológicas.
contrapartes. Se activan cuando la suma total de las señales de entrada que reciben
supera un umbral de activación.
Estos nodos pueden transmitir señales entre ellos mediante conexiones, denominadas
bordes , que simulan el funcionamiento de las sinapsis biológicas (las flechas azules que se muestran
en la Figura 9-2 ). A través de estos bordes, las señales enviadas por una neurona pasan a la siguiente,
comportándose como un filtro. Es decir, un borde convierte el mensaje de salida de una neurona en un
señal inhibitoria o excitante, disminuyendo o aumentando su intensidad, según
reglas preestablecidas ( generalmente se aplica un peso diferente para cada borde).
La red neuronal tiene una cierta cantidad de nodos que se utilizan para recibir la señal de entrada.
desde el exterior (ver Figura 9-2). Este primer grupo de nodos generalmente se representa en un
columna en el extremo izquierdo del esquema de red neuronal. Este grupo de nodos representa
la primera capa de la red neuronal ( capa de entrada ). Dependiendo de las señales de entrada
recibido, algunas (o todas) de estas neuronas se activarán procesando el recibido
señal y transmitir el resultado como salida a otro grupo de neuronas, a través de bordes.
356
Página 370
Este segundo grupo se encuentra en una posición intermedia en la red neuronal y se denomina
la capa oculta . Esto se debe a que las neuronas de este grupo no se comunican con
el exterior ni en la entrada ni en la salida y, por tanto, están ocultos. Como puedes ver en
Figura 9-2, cada una de estas neuronas tiene muchos bordes entrantes, a menudo con todas las neuronas
de la capa anterior. Incluso estas neuronas ocultas se activarán si el total
la señal entrante excederá un cierto umbral. Si es afirmativo, procesarán la señal.
y transmitirlo a otro grupo de neuronas (en la dirección correcta del esquema que se muestra
en la Figura 9-2 ). Este grupo puede ser otra capa oculta o la capa de salida, es decir, la última
capa que enviará los resultados directamente al exterior.
Entonces en general tendremos un flujo de datos que ingresará a la red neuronal (de izquierda a derecha
a la derecha), y que se tramitará de forma más o menos compleja en función de la
estructura, y producirá un resultado de salida.
El comportamiento, las capacidades y la eficiencia de una red neuronal dependerán exclusivamente
sobre cómo están conectados los nodos y el número total de capas y neuronas asignadas a
cada uno de ellos. Todos estos factores definen la arquitectura de la red neuronal.
Perceptrón de capa única (SLP)

El perceptrón de capa única (SLP) es el modelo más simple de red neuronal y fue
diseñado por Frank Rosenblatt en 1958. Su arquitectura está representada en la Figura 9-3.
Figura 9-3. La arquitectura del perceptrón de capa única (SLP)
La estructura del perceptrón de capa única (SLP) es muy simple; es un neural de dos capas
red, sin capas ocultas, en la que una serie de neuronas de entrada envían señales a un
neurona de salida a través de diferentes conexiones, cada una con su propio peso. La figura 9-4 muestra
con más detalle el funcionamiento interno de este tipo de red neuronal.
357
Página 371
Figura 9-4. Una representación más detallada del perceptrón de capa única (SLP) con la
operación interna expresada matemáticamente
Los bordes de esta estructura se representan en este modelo matemático por medio de un
vector de peso que consiste en la memoria local de la neurona.
W = (w1, w2, ......, wn)
La neurona de salida recibe señales de un vector de entrada xi, cada una procedente de un
neurona.
X = (x1, x2, ......, xn)
Luego procesa las señales de entrada a través de una suma ponderada.

norte
una
wx i yo = w 1 x 1 + w 2 x 2 +… + w n x n = s
yo= 0
La señal total s es la percibida por la neurona de salida. Si la señal excede el

umbral de activación de la neurona, se activará, enviando 1 como valor, de lo contrario
permanecer inactivo, enviando -1.
yo1 , si s > 0
Salida = yo
-
yo 1 , de otra manera
Esta es la función de activación más simple (consulte la función A que se muestra en la Figura 9-5), pero tu
También puede utilizar otros más complejos, como el sigmoide (ver la función D que se muestra en
Figura 9-5).
358
Página 372
Figura 9-5. Algunos ejemplos de funciones de activación
Ahora que ha visto la estructura de la red neuronal SLP, puede cambiar para ver
cómo pueden aprender.
El procedimiento de aprendizaje de una red neuronal, llamado fase de aprendizaje, funciona
iterativamente. Es decir, un número predeterminado de ciclos de funcionamiento de la red neuronal
se llevan a cabo, en cada uno de los cuales los pesos de las sinapsis wi se modifican ligeramente.
Cada ciclo de aprendizaje se llama época . Para llevar a cabo el aprendizaje deberás
usar datos de entrada apropiados, llamados conjuntos de entrenamiento (ya los ha usado en profundidad
en el Capítulo 8 ).
En los conjuntos de entrenamiento, para cada valor de entrada, se obtiene el valor de salida esperado. Por
comparar los valores de salida producidos por la red neuronal con los esperados
puede analizar las diferencias y modificar los valores de peso, y también puede reducir
ellos. En la práctica, esto se hace minimizando una función de costo (pérdida) que es específica de
el problema del aprendizaje profundo. De hecho, los pesos de las diferentes conexiones serán
modificado para cada época con el fin de minimizar el costo ( pérdida ).
En conclusión, el aprendizaje supervisado se aplica a las redes neuronales.
Al final de la fase de aprendizaje, pasará a la fase de evaluación , en la que
el perceptrón SLP aprendido debe analizar otro conjunto de entradas (conjunto de prueba) cuyos resultados
también se conocen aquí. Evaluando las diferencias entre los valores obtenidos y
los esperados, el grado de capacidad de la red neuronal para resolver el problema de
Se conocerá el aprendizaje. A menudo, el porcentaje de casos adivinados con los incorrectos es
utilizado para indicar este valor, y se llama precisión .
359
Página 373
Perceptrón multicapa (MLP)

Una arquitectura más compleja y eficiente es el perceptrón multicapa (MLP) . En esto
estructura, hay una o más capas ocultas interpuestas entre la capa de entrada y
la capa de salida. La arquitectura está representada en la Figura 9-6 .
Figura 9-6. La arquitectura del perceptrón multicapa (MLP)
Al final de la fase de aprendizaje, pasará a la fase de evaluación, en la que

el perceptrón SLP aprendido debe analizar otro conjunto de entradas (conjunto de prueba) cuyos resultados
también se conocen aquí. Evaluando las diferencias entre los valores obtenidos y
los esperados, el grado de capacidad de la red neuronal para resolver el problema de
Se conocerá el aprendizaje. A menudo, el porcentaje de casos adivinados con los incorrectos es
utilizado para indicar este valor, y se llama precisión.
Aunque más complejos, los modelos de redes neuronales MLP se basan principalmente en
los mismos conceptos que los modelos de las redes neuronales SLP. Incluso en MLP, los pesos son
asignado a cada conexión. Estos pesos deben minimizarse en función de la evaluación
de un conjunto de entrenamiento, al igual que los SLP. Aquí, también, cada nodo debe procesar todas las entradas
señales a través de una función de activación, incluso si esta vez la presencia de varios ocultos
capas, hará que la red neuronal pueda aprender más, adaptándose más eficazmente a la
tipo de problema que el aprendizaje profundo está tratando de resolver.
360
Página 374
Por otro lado, desde un punto de vista práctico, la mayor complejidad de este
El sistema requiere algoritmos más complejos tanto para la fase de aprendizaje como para la
fase de evaluación. Uno de ellos es el algoritmo de retropropagación , que se utiliza para
modificar los pesos de las diversas conexiones para minimizar la función de costo, con el fin de
converger rápida y progresivamente los valores de salida con los esperados.
Otros algoritmos se utilizan específicamente para la fase de minimización del costo (o
error) y se conocen generalmente como técnicas de descenso de gradiente .
El estudio y análisis detallado de estos algoritmos está fuera del alcance de este texto,
que tiene sólo una función introductoria del argumento, con el objetivo de tratar de mantener
el tema del aprendizaje profundo lo más simple y claro posible. Si lo desea, sugiero
se profundiza en el tema tanto en varios libros como en Internet.
Correspondencia entre neuronales artificiales y biológicas

Redes
Hasta ahora has visto cómo el aprendizaje profundo utiliza estructuras básicas, llamadas neuronales artificiales.
redes, para simular el funcionamiento del cerebro humano, particularmente en la forma en que
procesa la información.
También existe una correspondencia real entre los dos sistemas en la lectura más alta
nivel. De hecho, acaba de ver que las redes neuronales tienen estructuras basadas en capas de
neuronas. La primera capa procesa la señal entrante, luego la pasa a la siguiente capa,
que a su vez lo procesa y así sucesivamente, hasta llegar a un resultado final. Para cada capa de
neuronas, la información entrante se procesa de cierta manera, generando diferentes niveles
de representación de la misma información.
De hecho, toda la operación de elaboración de una red neuronal artificial no es nada.
más que la transformación de la información a niveles cada vez más abstractos.
Este funcionamiento es idéntico al que ocurre en la corteza cerebral. Por ejemplo,
cuando el ojo recibe una imagen, la señal de la imagen pasa por varios procesos
etapas (como las capas de la red neuronal), en las que, por ejemplo, los contornos de
las figuras se detectan primero (detección de bordes), luego la forma geométrica (percepción de la forma),
y luego al reconocimiento de la naturaleza del objeto con su nombre. Por lo tanto, tiene
ha sido una transformación en diferentes niveles de conceptualidad de una información entrante,
pasar de una imagen, a las líneas, a las figuras geométricas, para llegar a una palabra.
361
Página 375
TensorFlow
En una sección anterior de este capítulo, vio que hay varios marcos en Python
que te permiten desarrollar proyectos de deep learning. Uno de ellos es TensorFlow . En esto
sección que aprenderá a conocer en detalle este marco, incluido cómo funciona y cómo
se utiliza para realizar redes neuronales para el aprendizaje profundo.
TensorFlow: marco de Google

TensorFlow (https://www.tensorflow.org) es una biblioteca desarrollada por Google Brain
Team, un grupo de Machine Learning Intelligence, una organización de investigación encabezada por
Google.
El propósito de esta biblioteca es contar con una excelente herramienta en el campo de la investigación para
aprendizaje automático y aprendizaje profundo.
Google lanzó la primera versión de TensorFlow en febrero de 2017 y en
año y medio, se han lanzado muchas versiones de actualización, en las que el potencial,
la estabilidad y la usabilidad de esta biblioteca aumentan considerablemente. Esto se debe principalmente a la
gran número de usuarios entre profesionales e investigadores que están utilizando plenamente esta
marco de referencia. En la actualidad, TensorFlow ya es un aprendizaje profundo consolidado
framework, rico en documentación, tutoriales y proyectos disponibles en Internet.
Además del paquete principal, hay muchas otras bibliotecas que se han
liberados a lo largo del tiempo, que incluyen:
• TensorBoard: un kit que permite la visualización de gráficos internos para

TensorFlow ( https://github.com/tensorflow/tensorboard).
• TensorFlow Fold: produce hermosos gráficos de cálculo dinámico

(https://github.com/tensorflow/fold)
• TensorFlow Transform : canalizaciones de datos de entrada creadas y administradas

(https://github.com/tensorflow/transform)
TensorFlow: gráfico de flujo de datos

TensorFlow (https://www.tensorflow.org) es una biblioteca desarrollada por Google Brain
Team, un grupo de Machine Learning Intelligence, una organización de investigación encabezada por
Google.
362
Página 376
TensorFlow se basa completamente en la estructuración y el uso de gráficos y en el flujo de

datos a través de él, explotándolos de tal manera que se hagan cálculos matemáticos.
El gráfico creado internamente en el sistema de tiempo de ejecución de TensorFlow se llama Data Flow
Graph y está estructurado en runtime según el modelo matemático que es el
base del cálculo que desea realizar. De hecho, Tensor Flow te permite definir
cualquier modelo matemático a través de una serie de instrucciones implementadas en el código.
TensorFlow se encargará de traducir ese modelo al gráfico de flujo de datos internamente.
Entonces, cuando vaya a modelar su red neuronal de aprendizaje profundo, se traducirá
en un gráfico de flujo de datos. Dada la gran similitud entre la estructura de las neuronas
redes y la representación matemática de gráficos, es fácil entender por qué
esta biblioteca es excelente para desarrollar proyectos de aprendizaje profundo.
Pero TensorFlow no se limita al aprendizaje profundo y puede usarse para representar
Redes neuronales. Se pueden implementar muchos otros métodos de cálculo y análisis
con esta biblioteca, ya que cualquier sistema físico se puede representar con una matemática
modelo. De hecho, esta biblioteca también se puede utilizar para implementar otro aprendizaje automático
técnicas, y para el estudio de sistemas físicos complejos mediante el cálculo de
diferenciales parciales, etc.
Los nodos del gráfico de flujo de datos representan operaciones matemáticas, mientras que
los bordes del gráfico representan tensores (matrices de datos multidimensionales). El nombre
TensorFlow se deriva del hecho de que estos tensores representan el flujo de datos a través
gráficos, que se pueden utilizar para modelar redes neuronales artificiales.
Comience a programar con TensorFlow

Ahora que ha visto en general en qué consiste el marco de TensorFlow, puede
comience a trabajar con esta biblioteca. En esta sección, verá cómo instalar este marco,
cómo definir y usar tensores dentro de un modelo, y cómo acceder al flujo de datos interno
Grafica a través de sesiones.
Instalación de TensorFlow
Antes de comenzar a trabajar, debe instalar esta biblioteca en su computadora.
En el sistema Ubuntu Linux (versión 16 o más reciente), puede usar pip para instalar el
paquete:
pip3 instalar tensorflow
363
Página 377
En sistemas Windows, puede usar Anaconda para instalar el paquete:
conda instalar tensorflow
TensorFlow es un marco bastante reciente y, desafortunadamente, no está presente en algunos

Distribuciones de Linux y en las versiones de hace unos años. Entonces en estos casos la instalación
de TensorFlow debe hacerse manualmente, siguiendo las indicaciones sugeridas en el oficial
Sitio web de TensorFlow ( https://www.tensorflow.org/install/install_linux).
Para aquellos que tienen Anaconda (incluidos Linux y OS) como sistema para distribuir
Paquetes de Python en sus computadoras, la instalación de TensorFlow es mucho más simple.
Programación con IPython QtConsole

Una vez que TensorFlow esté instalado, puede comenzar a programar con esta biblioteca. En el
En este capítulo, usamos IPython, pero puede hacer lo mismo abriendo un
sesión normal de Python (o si lo prefiere, usando Jupyter Notebook). A través de la terminal,
abra una sesión de IPython ingresando la siguiente línea de comando.
jupyter qtconsole
Después de abrir una sesión de IPython, importe la biblioteca:
En []: importar tensorflow como tf
Nota Recuerde que para ingresar varios comandos en diferentes líneas, debe
use Ctrl + Enter. Para ejecutar los comandos, presione Entrar solamente.
El modelo y las sesiones en TensorFlow

Antes de comenzar a programar, es importante comprender el funcionamiento interno de
TensorFlow, incluido cómo interpreta los comandos en Python y cómo se ejecuta
internamente. TensorFlow trabaja a través del concepto de modelo y sesiones , que definen
la estructura de un programa con una determinada secuencia de comandos.
En la base de cualquier proyecto de TensorFlow hay un modelo que incluye una serie completa de
variables a tener en cuenta y que definirán el sistema. Las variables pueden ser
definidas directamente o parametrizadas mediante expresiones matemáticas sobre constantes.
364
Página 378
En []: c = tf.constant (2, name = 'c')

...: x = tf.Variable (3, name = 'x')
...: y = tf.Variable (c * x, name = 'y')
...:
Pero ahora, si intenta ver el valor interno de y (espera un valor de 6) con el

print (), verá que le dará el objeto y no el valor.
En [3]: imprimir (x)

...: imprimir (y)
...:
<tf.Variable 'x: 0' forma = () dtype = int32_ref>
<tf.Variable 'y: 0' forma = () dtype = int32_ref>
De hecho, ha definido variables que pertenecen al gráfico de flujo de datos de TensorFlow,

que es un gráfico con nodos y conexiones que representan su modelo matemático. Tú
Veremos más adelante cómo acceder a estos valores a través de sesiones.
En cuanto a las variables directamente implicadas en el cálculo del deep learning
se refiere al método, se utilizan marcadores de posición , es decir, aquellos tensores directamente involucrados en el
flujo de datos y en el procesamiento de cada neurona.
Los marcadores de posición le permiten crear el gráfico correspondiente a la red neuronal y
para crear operaciones en el interior sin conocer absolutamente los datos a calcular. De hecho,
puede construir la estructura del gráfico (y también la red neuronal).
En casos prácticos, dado un conjunto de entrenamiento que consiste en el valor a analizar x (a
tensor) y un valor esperado y (un tensor), definirás dos marcadores de posición xey, es decir, dos
tensores que contendrán los valores procesados por los datos para toda la red neuronal.
Por ejemplo, defina dos marcadores de posición que contengan números enteros con tf.
función placeholder ().
En []: X = tf.placeholder ("int32")

...: X = tf.placeholder ("int32")
...:
Una vez que haya definido todas las variables involucradas, es decir, haya definido el
modelo matemático en la base del sistema, debe realizar el
procesar e inicializar todo el modelo con tf.global_variables_
función initializer ().
En []: model = tf.global_variables_initializer ()
365
Página 379
Ahora que tiene un modelo inicializado y cargado en la memoria, debe comenzar

haciendo los cálculos, pero para hacerlo necesita comunicarse con TensorFlow
sistema de tiempo de ejecución. Para ello, se crea una sesión de TensorFlow, durante la cual puede
lanzar una serie de comandos para interactuar con el gráfico subyacente correspondiente al
modelo que ha creado.
Puede crear una nueva sesión con el constructor tf.Session ().
Dentro de una sesión, puede realizar los cálculos y recibir los valores del
variables obtenidas como resultados, es decir, se puede comprobar el estado del gráfico durante el procesamiento.
Ya has visto que el funcionamiento de TensorFlow se basa en la creación de
una estructura gráfica interna, en la que los nodos pueden realizar el procesamiento en el
flujo de datos dentro de tensores que siguen las conexiones del gráfico.
Por tanto, cuando inicia una sesión, en la práctica no hace más que crear una instancia de este gráfico.
Una sesión tiene dos métodos principales:
• session.extend () le permite realizar cambios en el gráfico durante

el cálculo, como agregar nuevos nodos o conexiones.
• session.run () lanza la ejecución del gráfico y le permite

obtener los resultados en salida.
Dado que se realizan varias operaciones dentro de la misma sesión, se prefiere utilizar
la construcción con: con todas las llamadas a métodos inherentes a él.
En este caso simple, simplemente desea ver los valores de las variables definidas en el
modelo e imprimirlos en el terminal.
En []: con tf.Session () como sesión:

...: session.run (modelo)
...: imprimir (sesión.run (y))
...:
6
Como puede ver dentro de la sesión, puede acceder a los valores del Gráfico de flujo de datos,
incluyendo la variable y que definió previamente.
Tensores
El elemento básico de la biblioteca de TensorFlow es el tensor . De hecho, los datos que siguen al
flujo dentro del gráfico de flujo de datos son tensores (ver Figura 9-7 ).
366
Página 380
Figura 9-7. Algunas representaciones de los tensores según los diferentes

dimensiones
Un tensor se identifica mediante tres parámetros:
• rango: dimensión del tensor (una matriz tiene rango 2, un vector tiene
rango 1)
• forma: número de filas y columnas (por ejemplo, (3.3) es una matriz de 3x3)
• type: tipo de elementos tensoriales.
tipo de elementos tensores y columnas (por ejemplo, (3.3) es una matriz de 3x3) tiene rango 2, un
vector tiene rango 1) s ic
Los tensores no son más que matrices multidimensionales. En capítulos anteriores,

vio lo fácil que es conseguirlos gracias a la biblioteca NumPy. Entonces puedes empezar por definir
uno con esta biblioteca.

...: t = np.arange (9) .rehape ((3,3))
367
Página 381
...: imprimir (t)

...:
[[0 1 2]
[3 4 5]
[6 7 8]]
Ahora puede convertir esta matriz multidimensional en un tensor de TensorFlow muy

fácilmente gracias a la función tf.convert_to_tensor (), que toma dos parámetros. los
El primer parámetro es la matriz t que desea convertir y el segundo es el tipo de datos
desea convertirlo a, en este caso int32.
En []: tensor = tf.convert_to_tensor (t, dtype = tf.int32)
Si desea ver el contenido del sensor ahora, debe crear un TensorFlow

sesión y ejecutarlo, imprimiendo el resultado en el terminal gracias a la función print ().
En []: con tf.Session () como sess:

...: print (sess.run (tensor))
...:
[[0 1 2]
[3 4 5]
[6 7 8]]
Como puede ver, tiene un tensor que contiene los mismos valores y los mismos
dimensiones como la matriz multidimensional definida con NumPy. Este enfoque es muy
útil para calcular el aprendizaje profundo, ya que muchos valores de entrada están en forma de NumPy
matrices.
Pero los tensores se pueden construir directamente desde TensorFlow, sin usar la biblioteca NumPy.
Hay una serie de funciones que permiten mejorar los tensores de forma rápida y
fácilmente.
Por ejemplo, si desea inicializar un tensor con todos los valores cero, puede usar el
Método tf.zeros ().
En [10]: t0 = tf.zeros ((3,3), 'float64')
En [11]: con tf.Session () como sesión:

...: imprimir (session.run (t0))
...:
[[0. 0. 0.]
368
Página 382
[0. 0. 0.]
[0. 0. 0.]]
Del mismo modo, si desea un tensor con todos los valores de 1, use el método tf.ones ().
En [12]: t1 = tf.ones ((3,3), 'float64')
En [13]: con tf.Session () como sesión:

...: imprimir (session.run (t1))
...:
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
Finalmente, también es posible crear un tensor que contenga valores aleatorios, que siguen un
distribución uniforme (todos los valores dentro de un rango tienen la misma probabilidad de salir), gracias a la
Función tf.random_uniform ().
Por ejemplo, si desea un tensor de 3x3 con valores flotantes entre 0 y 1, puede escribir:
En []: tensorrand = tf.random_uniform ((3, 3), minval = 0, maxval = 1,

dtype = tf.float32)

...: print (session.run (tensorrand))
...:
[[0.63391674 0.38456023 0.13723993]
[0,7398864 0,44730318 0,95689237]
[0.48043406 0.96536028 0.40439832]]
Pero a menudo puede ser útil crear un tensor que contenga valores que sigan una
distribución con una elección de desviación estándar y media. Puede hacer esto con tf.
función random_normal ().
Por ejemplo, si desea crear un tensor de tamaño 3x3 con media 0 y estándar
desviación de 3, escribirás:
En []: norm = tf.random_normal ((3, 3), mean = 0, stddev = 3)

...: imprimir (session.run (norma))
369
Página 383
...:
[[-1.51012492 2.52284908 1.10865617]
[-5.08502769 1.92598009 -4.25456524]
[4.85962772 -6.69154644 5.32387066]]
Operación en tensores
Una vez definidos los tensores, será necesario realizar operaciones sobre ellos.
La mayoría de los cálculos matemáticos sobre tensores se basan en la suma y la multiplicación
entre tensores.
Defina dos tensores, t1 y t2, que utilizará para realizar las operaciones entre
tensores.
En []: t1 = tf.random_uniform ((3, 3), minval = 0, maxval = 1, dtype = tf.

float32)
...: t2 = tf.random_uniform ((3, 3), minval = 0, maxval = 1, dtype = tf.
float32)
...:

...: print ('t1 =', sess.run (t1))
...: print ('t2 =', sess.run (t2))
...:
t1 = [[0.22056699 0.15718663 0.11314452]
[0.43978345 0,27561605 0,41013181]
[0.58318019 0,3019532 0,04094303]]
t2 = [[0.16032183 0.32963789 0.30250323]
[0.02322233 0,79547286 0,01091838]
[0.63182664 0,64371264 0,06646919]]
Ahora, para sumar estos dos tensores, puede usar la función tf.add (). Actuar
multiplicación, usa la función tf.matmul ().
En []: suma = tf.add (t1, t2)

...: mul = tf.matmul (t1, t2)
...:
370
Página 384

...: print ('suma =', sess.run (suma))
...: print ('mul =', sess.run (mul))
...:
suma = [[0.78942883 0.73469722 1.0990597]
[0.42483664 0,62457812 0,98524892]
[1.30883813 0,75967956 0,19211888]]
mul = [[0.26865649 0.43188229 0.98241472]
[0.13723138 0,25498611 0,49761111]
[0.32352239 0,48217845 0,80896515]]
Otra operación muy común con tensores es el cálculo del determinante.

TensorFlow proporciona el método tf.matrix_determinant () para este propósito:
En []: det = tf.matrix_determinant (t1)

...: con tf.Session () como sess:
...: print ('det =', sess.run (det))
...:
det = 0.101594
Con estas operaciones básicas, puede implementar muchas expresiones matemáticas

que utilizan tensores.
Perceptrón de capa única con TensorFlow

Para comprender mejor cómo desarrollar redes neuronales con TensorFlow, comenzará a
implementar una red neuronal de perceptrón de una sola capa (SLP) que sea lo más simple posible.
Usarás las herramientas disponibles en la biblioteca de TensorFlow y usarás los conceptos
que ha aprendido durante el capítulo e introduciendo gradualmente otros nuevos.
Durante el transcurso de esta sección, verá la práctica general de construir un
red neuronal. Gracias a un procedimiento paso a paso con el que puede familiarizarse
los diferentes comandos utilizados. Luego, en la siguiente sección, los usará para crear un
Red neuronal Perceptron Multi Layer.
En ambos casos trabajará con ejemplos sencillos pero completos de cada parte, para que
no añadir demasiados detalles técnicos y complejos, sino centrarse en la parte central que
implica la implementación de redes neuronales con TensorFlow.
371
Página 385
Antes de empezar
Antes de comenzar, vuelva a abrir una sesión con IPython iniciando un nuevo kernel. Una vez que la sesión
está abierto importa todos los módulos necesarios:

...: importar tensorflow como tf
...:
Datos a analizar
Para los ejemplos que considerará en este capítulo, utilizará una serie de datos que
que utilizó en el capítulo de aprendizaje automático, en particular en la sección sobre el soporte
Técnica de máquinas vectoriales (SVM).
El conjunto de datos que estudiarás es un conjunto de 11 puntos distribuidos en un eje cartesiano
dividido en dos clases de miembros. Los primeros seis pertenecen a la primera clase, los otros
cinco al segundo. Las coordenadas (x, y) de los puntos están contenidas dentro de un numpy
inputX, mientras que la clase a la que pertenecen se indica en inputY. Esta es una lista de
matrices de dos elementos, con un elemento para cada clase a la que pertenecen. El valor 1 en el primero
o el segundo elemento indica la clase a la que pertenece.
Si el elemento tiene valor [1.0], pertenecerá a la primera clase. Si tiene valor [0,1],
pertenece a la segunda clase. El hecho de que sean valores flotantes se debe a la optimización
cálculo de deep learning. Verá más adelante que los resultados de las pruebas de las redes neuronales
serán números flotantes, lo que indica la probabilidad de que un elemento pertenezca al primero o
segunda clase.
Suponga, por ejemplo, que la red neuronal le dará el resultado de un elemento
que tendrá los siguientes valores:
[0,910, 0,090]
Este resultado significará que la red neuronal considera que el elemento bajo
el análisis pertenece al 91% a la primera clase y al 9% a la segunda clase. Verás esto
en la práctica al final de la sección, pero era importante explicar el concepto para mejorar
comprender el propósito de algunos valores.
Entonces, según los valores tomados del ejemplo de SVM en el aprendizaje automático
capítulo, puede definir los siguientes valores.
372
Página 386
En [2]: # conjunto de entrenamiento

...: inputX = np.arr
ay ([[1., 3.], [1., 2.], [1., 1.5], [1.5,2.], [2., 3.], [2.5,1.5]
, [2., 1.], [3., 1.], [3., 2.], [3.5,1.], [3.5,3.]])
...: inputY = [[1., 0.]] * 6+ [[0., 1.]] * 5
...: imprimir (entradaX)
...: imprimir (entradaY)
...:
[[1. 3.]
[1. 2.]
[1. 1.5]
[1.5 2.]
[2. 3.]
[2,5 1,5]
[2. 1.]
[3. 1.]
[3. 2.]
[3.5 1.]
[3.5 3.]]
[[1.0, 0.0], [1.0, 0.0], [1.0, 0.0], [1.0, 0.0], [1.0, 0.0],
[1.0, 0.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]
Para ver mejor cómo estos puntos están organizados espacialmente y a qué clases pertenecen
a, no hay mejor enfoque que trazar todo con matplotlib.
En [3]: yc = [0] * 6 + [1] * 5

...: imprimir (yc)
...:% matplotlib en línea
...: plt.scatter (inputX [:, 0], inputX [:, 1], c = yc, s = 50, alpha = 0.9)
...: plt.show ()
...:
[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]
Obtendrá el gráfico de la Figura 9-8 como resultado.
373
Página 387
Figura 9-8. El conjunto de entrenamiento es un conjunto de puntos cartesianos divididos en dos clases de
membresía (amarillo y azul oscuro)
Para ayudar en la representación gráfica (como se muestra en la Figura 9-8 ) del color
asignación, la matriz inputY ha sido reemplazada por la matriz yc.
Como puede ver, las dos clases son fácilmente identificables en dos regiones opuestas. los
la primera región cubre la parte superior izquierda, la segunda región cubre la parte inferior derecha. Todas
esto parecería estar simplemente subdividido por una línea diagonal imaginaria, pero para hacer
sistema más complejo, hay una excepción con el punto número 6 que es interno a
los otros puntos.
Será interesante ver cómo y si las redes neuronales que implementamos serán
capaz de asignar correctamente la clase a puntos de este tipo.
La definición del modelo SLP

Para los ejemplos que considerará en este capítulo, utilizará una serie de datos que
que ya ha utilizado en el capítulo de aprendizaje automático, en particular en la sección sobre
la técnica Support Vector Machines (SVM).
Si desea hacer un análisis de aprendizaje profundo, lo primero que debe hacer es definir la
modelo de red que desea implementar. Entonces ya tendrás en mente la estructura para
implementarse, cuántas neuronas y capas y compuestos (en este caso solo uno),
el peso de las conexiones y la función de costo a aplicar.
374
Página 388
Siguiendo la práctica de TensorFlow, puede comenzar por definir una serie de parámetros
necesario para caracterizar la ejecución de los cálculos durante la fase de aprendizaje. los
La tasa de aprendizaje es un parámetro que regula la velocidad de aprendizaje de cada neurona. Este parámetro
es muy importante y juega un papel muy importante en la regulación de la eficiencia de un sistema neuronal
red durante la fase de aprendizaje. Establecer el valor óptimo a priori del aprendizaje
tasa es imposible, porque depende mucho de la estructura de la red neuronal y
sobre el tipo particular de datos a analizar. Por tanto, es necesario ajustar este valor
a través de diferentes pruebas de aprendizaje, eligiendo el valor que garantice la mayor precisión.
Puede comenzar con un valor genérico de 0.01, asignando este valor a learning_rate
parámetro.
En []: tasa_de_aprendizaje = 0.01
Otro parámetro a definir es training_epochs. Esto define cuántos

Las épocas (ciclos de aprendizaje) se aplicarán a la red neuronal para la fase de aprendizaje.
En []: training_epochs = 2000
Durante la ejecución del programa, será necesario de alguna manera monitorear el progreso
de aprendizaje y esto se puede hacer imprimiendo valores en el terminal. Puedes decidir como
muchas épocas, tendrá que mostrar una impresión con los resultados e insertarlos en el
parámetro display_step. Un valor razonable es cada 50 o 100 pasos.
En []: display_step = 50
Para que el código implementado sea reutilizable, es necesario agregar parámetros que
especificar la cantidad de elementos que componen el conjunto de entrenamiento y cuántos lotes
debe dividirse. En este caso, tiene un pequeño conjunto de entrenamiento de solo 11 elementos. Así que puedes
Úselos todos en un solo lote.
En []: n_samples = 11
...: tamaño_lote = 11
...: total_batch = int (n_samples / batch_size)
...:
Finalmente, puede agregar dos parámetros más que describen el tamaño y el número de
clases a las que pertenecen los datos entrantes.
En []: n_input = 2 # entrada de datos de tamaño (# tamaño de cada elemento de x)

...: n_classes = 2 # n de clases
...:
375
Página 389
Ahora que ha definido los parámetros del método, pasemos a construir

la red neuronal. Primero, defina las entradas y salidas de la red neuronal mediante
el uso de marcadores de posición .
En []: # tf Entrada de gráfico

...: x = tf.placeholder ("float", [None, n_input])
...: y = tf.placeholder ("float", [None, n_classes])
...:
Entonces acaba de definir implícitamente una red neuronal SLP con dos neuronas en
la capa de entrada y dos neuronas en la capa de salida (ver Figura 9-9 ), definiendo una entrada
marcador de posición x con dos valores y un marcador de posición de salida y con dos valores. de manera explícita ,
en cambio, ha definido dos tensores, el tensor x que contendrá los valores de la
coordenadas de entrada, y un tensor y que contendrá las probabilidades de pertenecer a la
dos clases de cada elemento.
Figura 9-9. El modelo de perceptrón de capa única utilizado en este ejemplo
Pero esto será mucho más visible en el siguiente ejemplo, cuando se trate de
Redes neuronales MLP. Ahora que ha definido los marcadores de posición, ocupado con el
pesos y el sesgo, que, como viste, se utilizan para definir las conexiones de la neural
red. Estos tensores W yb están definidos como variables por el constructor Variable ()
e inicializado a todos los valores cero con tf.zeros ().
En []: # Establecer pesos de modelo

...: W = tf.Variable (tf.zeros ([n_input, n_classes]))
...: b = tf.Variable (tf.zeros ([n_classes]))
...:
376
Página 390
Las variables ponderación y sesgo que acaba de definir se utilizarán para definir la
evidencia x * W + b, que caracteriza la red neuronal en forma matemática. los
La función tf.matmul () realiza una multiplicación entre los tensores x * W, mientras que tf.
La función add () agrega al resultado el valor del sesgo b.
En []: evidencia = tf.add (tf.matmul (x, W), b)
A partir del valor de la evidencia, puede calcular directamente las probabilidades de la

valores de salida con la función tf.nn.softmax ().
En []: y_ = tf.nn.softmax (evidencia)
La función tf.nn.softmax () realiza dos pasos:
• Calcula la evidencia de que un determinado punto de entrada cartesiano xi

pertenece a una clase particular.
• Convierte la evidencia en probabilidad de pertenencia a cada uno de los

dos clases posibles y lo devuelve como y_.
Continuando con la construcción del modelo, ahora debes pensar en

estableciendo las reglas para la minimización de estos parámetros y lo hace
definir el costo (o pérdida). En esta fase puede elegir muchas funciones; uno de los mas
común es la pérdida por error cuadrático medio.
En []: costo = tf.reduce_sum (tf.pow (y-y_, 2)) / (2 * n_samples)
Pero puede utilizar cualquier otra función que considere más conveniente. Una vez el
Se ha definido la función de costo (o pérdida), se debe establecer un algoritmo para realizar
la minimización en cada ciclo de aprendizaje (optimización). Puede utilizar tf.train.
GradientDescentOptimizer () funciona como un optimizador que basa su funcionamiento en la
Algoritmo de Gradient Descent.
En []: optimizer = tf.train.GradientDescentOptimizer (learning_

rate = learning_rate) .minimize (costo)
Con la definición del método de optimización de costos (minimización), tiene

Completó la definición del modelo de red neuronal. Ahora está listo para comenzar a
implementar su fase de aprendizaje.
377
Página 391
Fase de aprendizaje
Antes de comenzar, defina dos listas que servirán de contenedor para los resultados obtenidos
durante la fase de aprendizaje. En avg_set ingresará todos los valores de costo para cada época
(ciclo de aprendizaje), mientras que en epoch_set ingresará el número de época relativo. Estas
Los datos serán útiles al final para visualizar la tendencia de costos durante la fase de aprendizaje del
red neuronal, que será muy útil para comprender la eficiencia del elegido
método de aprendizaje para la red neuronal.
En []: avg_set = []
...: epoch_set = []
...:
Luego, antes de comenzar la sesión, debe inicializar todas las variables con el
función que ha visto antes, tf.global_variables_initializer ().
En []: init = tf.global_variables_initializer ()
Ahora está listo para iniciar la sesión (no presione Enter al final; debe ingresar
otros comandos dentro de la sesión).

...: sess.run (init)
...:
Ya has visto que cada paso del aprendizaje se llama época. Es posible
intervenir dentro de cada época, gracias a un bucle for que escanea todos los valores de entrenamiento_
épocas.
Dentro de este ciclo para cada época, optimizará utilizando sess.run (optimizador)
mando. Además, cada 50 épocas, la condición si% display_step == 0 será
estar satisfecho. Luego, extraerá el valor del costo a través de sess.run (costo) y lo insertará en el
c variable que usará para imprimir en el terminal como el argumento print () que
almacena la lista avg_set, usando la función append (). Al final, cuando el bucle for tiene
completado, imprimirá un mensaje en el terminal informándole del final de
la fase de aprendizaje. (No presione Enter, ya que aún tiene que agregar otros comandos ...)

...:
...: para i en el rango (training_epochs):
378
Página 392
...: sess.run (optimizador, feed_dict = {x: inputX, y: inputY})

...: si i% display_step == 0:
...: c = sess.run (costo, feed_dict = {x: inputX, y: inputY})
...: print ("Época:", '% 04d'% (i), "costo =", "{: .9f}".
formato (c))
...: avg_set.append (c)
...: epoch_set.append (i + 1)
...:
...: print ("Fase de formación finalizada")
Ahora que la fase de aprendizaje ha terminado, es útil imprimir una tabla de resumen en el
terminal que le muestra la tendencia del costo durante el mismo. Puedes hacerlo gracias a los valores
contenido en las listas avg_set y epoch_set que llenó durante el proceso de aprendizaje.
Siempre en la sesión agregue estas últimas líneas de código, al final de las cuales finalmente podrá
presione Enter e inicie la sesión ejecutando la fase de aprendizaje.

...:
...: si i% display_step == 0:
...: c = sess.run (costo, feed_dict = {x: inputX, y: inputY})
...: print ("Época:", '% 04d'% (i), "costo =", "{: .9f}".
formato (c))
...: avg_set.append (c)
...: epoch_set.append (i + 1)
...:
...:
...: training_cost = sess.run (cost, feed_dict = {x: inputX, y:
inputY})
...: print ("Training cost =", training_cost, "\ nW =", sess.run (W),
"\ nb =", sess.run (b))
...: last_result = sess.run (y_, feed_dict = {x: inputX})
...: print ("Último resultado =", last_result)
...:
379
Página 393
Cuando finaliza la sesión con la fase de aprendizaje de la red neuronal, obtienes

los siguientes resultados.
Época: 0000 costo = 0.249360308

Época: 0050 costo = 0.221041128
Época: 0100 costo = 0.198898271
Época: 0150 costo = 0.181669712
Época: 0200 costo = 0.168204829
Época: 0250 costo = 0.157555178
Época: 0300 costo = 0.149002746
Época: 0350 costo = 0.142023861
Época: 0400 costo = 0.136240512
Época: 0450 costo = 0.131378993
Época: 0500 costo = 0.127239138
Época: 0550 costo = 0.123672642
Época: 0600 costo = 0.120568059
Época: 0650 costo = 0.117840447
Época: 0700 costo = 0.115424201
Época: 0750 costo = 0.113267884
Época: 0800 costo = 0.111330733
Época: 0850 costo = 0.109580085
Época: 0900 costo = 0.107989430
Época: 0950 costo = 0.106537104
Época: 1000 costo = 0.105205171
Época: 1050 costo = 0.103978693
Época: 1100 costo = 0.102845162
Época: 1150 costo = 0.101793952
Época: 1200 costo = 0.100816071
Época: 1250 costo = 0.099903718
Época: 1300 costo = 0.099050261
Época: 1350 costo = 0.098249927
Época: 1400 costo = 0.097497642
Época: 1450 costo = 0.096789025
Época: 1500 costo = 0.096120209
Época: 1550 costo = 0.095487759
Época: 1600 costo = 0.094888613
380
Página 394
Época: 1650 costo = 0.094320126

Época: 1700 costo = 0.093779817
Época: 1750 costo = 0.093265578
Época: 1800 costo = 0.092775457
Época: 1850 costo = 0.092307687
Época: 1900 costo = 0.091860712
Época: costo 1950 = 0.091433071
Fase de formación finalizada
Costo de formación = 0,0910315
W = [[-0.70927787 0.70927781]
[0,62999243 -0,62999237]]
b = [0.34513065 -0.34513068]
Último resultado = [[0.95485419 0.04514586]
[0.85713255 0.14286745]
[0,76163834 0,23836163]
[0,74694741 0,25305259]
[0.83659446 0.16340555]
[0,27564839 0,72435158]
[0.29175714 0.70824283]
[0.090675 0.909325]
[0.26010245 0.73989749]
[0.04676624 0.95323378]
[0.37878013 0.62121987]]
Como puede ver, el costo está mejorando gradualmente durante la época, hasta un valor de
0,168. Entonces es interesante ver los valores de los pesos W y el sesgo de la neural
red. Estos valores representan los parámetros del modelo, es decir, la red neuronal
instruido para analizar este tipo de datos y realizar este tipo de clasificación.
Estos parámetros son muy importantes, porque una vez obtenidos y conociendo
la estructura de la red neuronal utilizada, será posible reutilizarlos en cualquier lugar
sin repetir la fase de aprendizaje. No considere este ejemplo que solo toma
un minuto para hacer el cálculo; en casos reales, puede llevar días hacerlo y, a menudo,
tener que hacer muchos intentos y ajustar y calibrar los diferentes parámetros antes
desarrollar una red neuronal eficiente que sea muy precisa en el reconocimiento de clase, o en
realizar cualquier otra tarea.
381
Página 395
Si ve los resultados desde un punto de vista gráfico, puede ser más fácil y rápido
entender. Puede usar matplotlib para hacer esto.
En []: plt.plot (epoch_set, avg_set, 'o', label = 'Fase de entrenamiento SLP')

...: plt.ylabel ('costo')
...: plt.xlabel ('épocas')
...: plt.legend ()
...: plt.show ()
...:
Puede analizar la fase de aprendizaje de la red neuronal siguiendo la tendencia de

el valor del costo, como se muestra en la Figura 9-10 .
Figura 9-10. El valor del costo disminuye durante la fase de aprendizaje (costo
mejoramiento)
Ahora puede pasar a ver los resultados de la clasificación durante el último paso de la
fase de aprendizaje.
En []: yc = last_result [:, 1]

...: plt.scatter (inputX [:, 0], inputX [:, 1], c = yc, s = 50, alpha = 1)
...: plt.show ()
...:
382
Página 396
Obtendrá la representación de los puntos en el plano cartesiano, como se muestra en

Figura 9-11.
Figura 9-11. La estimación de la clase a la que pertenecen los puntos en la última época.
de la fase de aprendizaje
El gráfico representa los puntos en el plano cartesiano (consulte la Figura 9-11), con un
color que va desde el azul (perteneciente al 100% al primer grupo) al amarillo (perteneciente al
100% al segundo grupo). Como puede ver, la división en las dos clases de puntos
del conjunto de entrenamiento es bastante óptimo, con una incertidumbre para los cuatro puntos en el centro
diagonal (verde).
Este gráfico muestra de alguna manera la capacidad de aprendizaje de la red neuronal utilizada. Como tu
puede ver, a pesar de las épocas de aprendizaje con el conjunto de entrenamiento utilizado, la red neuronal falló
para aprender que el punto 6 (x = 2.5, y = 1.5) pertenece a la primera clase. Este es un resultado que podrías
esperar, ya que representa una excepción y agrega un efecto de incertidumbre a otros puntos en
la segunda clase (los puntos verdes).
Fase de prueba y cálculo de precisión

Ahora que tiene una red neuronal educada, puede crear las evaluaciones y
calcular la precisión.
Primero, define un conjunto de pruebas con elementos diferentes al conjunto de entrenamiento. por
conveniencia, estos ejemplos siempre usan 11 elementos.
383
Página 397
En []: # conjunto de pruebas

...: testX = np.arr
ay ([[1., 2.25], [1.25,3.], [2,2.5], [2.25,2.75], [2.5,3.],
[2., 0.9], [2.5,1.2], [3., 1.25], [3., 1.5], [3.5,2.], [3.5,2.5]])
...: testY = [[1., 0.]] * 5 + [[0., 1.]] * 6
...: imprimir (pruebaX)
...: imprimir (pruebaY)
...:
[[1. 2.25]
[1.25 3.]
[2. 2.5]
[2,25 2,75]
[2.5 3.]
[2. 0.9]
[2.5 1.2]
[3. 1.25]
[3. 1.5]
[3.5 2.]
[3.5 2.5]]
[[1.0, 0.0], [1.0, 0.0], [1.0, 0.0], [1.0, 0.0], [1.0, 0.0],
[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]
Para comprender mejor los datos del conjunto de prueba y sus clases de membresía, muestre los puntos
en un gráfico usando matplotlib.
En []: yc = [0] * 5 + [1] * 6

...: imprimir (yc)
...: plt.scatter (testX [:, 0], testX [:, 1], c = yc, s = 50, alpha = 0.9)
...: plt.show ()
...:
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]

Figura 9-12.
384
Página 398
Figura 9-12. El conjunto de pruebas
Ahora utilizará este conjunto de pruebas para evaluar la red neuronal SLP y calcular la
exactitud.
En []: init = tf.global_variables_initializer ()

...:
...:
...: pred = tf.nn.softmax (evidencia)
...: resultado = sess.run (pred, feed_dict = {x: testX})
...: predicción_correcta = tf.equal (tf.argmax (pred, 1),
tf.argmax (testY, 1))
...:
...: # Calcular la precisión
...: exactitud = tf.reduce_mean (tf.cast (correct_prediction, "float"))
...: print ("Precisión:", precisión.eval ({x: testX, y: testY}))
...:
Precisión: 1.0
385
Página 399
Aparentemente, la red neuronal pudo clasificar correctamente a los 11 campeones anteriores.

Muestra los puntos en el plano cartesiano con el mismo sistema de gradaciones de color.
que van del azul oscuro al amarillo.
En []: yc = resultado [:, 1]

...: plt.scatter (testX [:, 0], testX [:, 1], c = yc, s = 50, alpha = 1)
...: plt.show ()

Figura 9-13.
Figura 9-13. La estimación de la clase a la que pertenecen los puntos de ajuste de prueba.
Los resultados pueden considerarse óptimos, dada la sencillez del modelo utilizado y
la pequeña cantidad de datos utilizados en el conjunto de entrenamiento. Ahora te enfrentarás al mismo problema
con una red neuronal más compleja, el Perceptron Multi Layer.
Perceptrón multicapa (con una capa oculta)

con TensorFlow
En esta sección, tratará el mismo problema que en la sección anterior, pero utilizando
una red neuronal MLP (perceptrón multicapa).
386
Página 400
Inicie una nueva sesión de IPython, reiniciando el kernel. En cuanto a la primera parte del código,
sigue siendo el mismo que el ejemplo anterior.
En [1]: importar tensorflow como tf

...:
...: #Conjunto de entrenamiento
ay ([[1., 3.], [1., 2.], [1., 1.5], [1.5,2.], [2., 3.], [2.5,1.5],
[2., 1.], [3., 1.], [3., 2.], [3.5,1.], [3.5,3.]])
...: inputY = [[1., 0.]] * 6+ [[0., 1.]] * 5
...:
...: tasa_de_aprendizaje = 0.001
...: training_epochs = 2000
...: display_step = 50
...: n_muestras = 11
La definición del modelo MLP

Como vio anteriormente en este capítulo, una red neuronal MLP difiere de una SLP neuronal
red en que puede tener una o más capas ocultas.
Por tanto, escribirás código parametrizado que te permitirá trabajar de la forma más
forma general posible, estableciendo en el momento de la definición el número de capas ocultas
presentes en la red neuronal y de cuántas neuronas están compuestas.
Definir dos nuevos parámetros que definan el número de neuronas presentes para cada uno.
capa oculta. El parámetro n_hidden_1 indicará cuántas neuronas están presentes en
la primera capa oculta, mientras que n_hidden_2 indicará cuántas neuronas están presentes en
la segunda capa oculta.
Para comenzar con un caso simple, comenzará con una red neuronal MLP con solo una
capa oculta que consta de solo dos neuronas. Comentemos la parte relacionada con el
segunda capa oculta.
En cuanto a los parámetros n_input y n_classes, tendrán los mismos valores que los
ejemplo anterior con la red neuronal SLP.
387
Página 401
En [2]: # parámetros de red
...: n_hidden_1 = 2 # 1a capa número de neuronas
...: # n_hidden_2 = 0 # 2da capa número de neuronas
...: n_input = 2 # entrada de datos de tamaño
...: n_classes = 2 # clases
...:
La definición de los marcadores de posición también es la misma que en el ejemplo anterior.
En [3]: # tf Entrada de gráfico

...: X = tf.placeholder ("float", [None, n_input])
...: Y = tf.placeholder ("float", [None, n_classes])
...:
Ahora tiene que lidiar con la definición de los diversos pesos W y sesgo b para el
diferentes conexiones. La red neuronal es ahora mucho más compleja, con varios
capas a tener en cuenta. Una forma eficaz de parametrizarlos es definirlos como
sigue, comentando los parámetros de peso y sesgo para la segunda capa oculta
(solo para MLP con una capa oculta como este ejemplo).
En [4]: # almacene el peso y el sesgo de las capas

...: pesos = {
...: 'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])),
...: # 'h2': tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])),
...: 'fuera': tf.Variable (tf.random_normal ([n_hidden_1, n_classes]))
...:}
...: sesgos = {
...: 'b1': tf.Variable (tf.random_normal ([n_hidden_1])),
...: # 'b2': tf.Variable (tf.random_normal ([n_hidden_2])),
...: 'fuera': tf.Variable (tf.random_normal ([n_classes]))
...:}
...:
Para crear un modelo de red neuronal que tenga en cuenta todos los parámetros que ha
especificado dinámicamente, necesita definir una función conveniente, que llamará
multilayer_perceptron ().
388
Página 402
En [5]: # Crear modelo

...: def multilayer_perceptron (x):
...: layer_1 = tf.add (tf.matmul (x, weights ['h1']), sesgos ['b1'])
...: # layer_2 = tf.add (tf.matmul (layer_1, pesos ['h2']), sesgos ['b2'])
...: # Capa de salida completamente conectada con una neurona para cada clase
...: out_layer = tf.matmul (layer_1, ponderaciones ['out']) + sesgos ['out']
...: return out_layer
...:
Ahora puede construir el modelo llamando a la función que acaba de definir.
En [6]: # modelo de construcción

...: evidencia = multilayer_perceptron (X)
...: y_ = tf.nn.softmax (evidencia)
...:
El siguiente paso es definir la función de costo y elegir un método de optimización. por

Redes neuronales MLP, una buena opción es tf.train.AdamOptimizer () como optimización
método.
En [7]: # Defina costo y optimizador

...: costo = tf.reduce_sum (tf.pow (Y-y_, 2)) / (2 * n_samples)
...: optimizador = tf.train.AdamOptimizer (tasa_de_aprendizaje = tasa_de_aprendizaje).
minimizar (costo)
...:
Con estas dos últimas líneas has completado la definición del modelo del MLP
red neuronal. Ahora puede pasar a crear una sesión para implementar el aprendizaje
fase.
Fase de aprendizaje
Como en el ejemplo anterior, ahora definirá dos listas que contendrán el número
de épocas y los valores de coste medidos para cada una de ellas. También inicializará todos los
variables antes de iniciar la sesión.
389
Página 403
En [8]: avg_set = []
...: epoch_set = []
...: init = tf.global_variables_initializer ()
...:
Ahora está listo para comenzar a implementar la sesión de aprendizaje. Abra la sesión con
las siguientes instrucciones (recuerde no presionar Enter, sino Enter + Ctrl para insertar otro
comandos más tarde):
En [9]: con tf.Session () como sess:

...:
Ahora implementa el código a ejecutar para cada época, y dentro de él un escaneo para cada
lote perteneciente al conjunto de entrenamiento. En este caso, tiene un conjunto de entrenamiento que consta de un
un solo lote, por lo que solo tendrá una iteración en la que asignará directamente inputX
y inputY a batch_x y batch_y. En otros casos, necesitará implementar una función,
como next_batch (batch_size), que subdivide todo el conjunto de entrenamiento (por ejemplo,
inputdata) en diferentes lotes, devolviéndolos progresivamente como valor de retorno.
En cada ciclo de lote, la función de costo se minimizará con sess.run ([optimizer,
costo]), que corresponderá a un costo parcial. Todos los lotes contribuirán al
cálculo del costo promedio de todos los lotes avg_cost. Sin embargo, en este caso, dado que
solo tiene un lote, avg_cost es equivalente al costo de todo el conjunto de capacitación.

...:
...: para época en rango (training_epochs):
...: avg_cost = 0.
...: # Bucle sobre todos los lotes
...: para i en el rango (total_batch):
...: #batch_x, batch_y = inputdata.next_batch (batch_size)
A SER IMPLEMENTADO
...: batch_x = inputX
...: batch_y = inputY
...: _, c = sess.run ([optimizador, costo], feed_dict = {X:
lote_x, Y: lote_y})
390
Página 404
...: # Calcular la pérdida promedio

...: avg_cost + = c / total_batch
Cada cierto número de épocas, seguramente querrá mostrar el valor de la

costo actual en la terminal y agregue estos valores a las listas avg_set y epoch_set, como
en el ejemplo anterior con SLP.

...:
...: avg_cost = 0.
A SER IMPLEMENTADO
...: _, c = sess.run ([optimizador, costo], feed_dict = {X:
lote_x, Y: lote_y})
...: si epoch% display_step == 0:
...: print ("Época:", '% 04d'% (época + 1), "costo = {:. 9f}".
formato (avg_cost))
...: avg_set.append (avg_cost)
...: epoch_set.append (época + 1)
...:
Antes de ejecutar la sesión, agregue algunas líneas de instrucciones para ver los resultados de la
fase de aprendizaje.

...:
...: avg_cost = 0.
391
Página 405

...: #batch_x, batch_y = inputdata.next
_batch (batch_size) PARA SER IMPLEMENTADO
...: _, c = sess.run ([optimizer, cost], feed
_dict = {X: batch_x, Y: batch_y})
formato (avg_cost))
...:
...: last_result = sess.run (y_, feed_dict = {X: inputX})
...: training_cost = sess.run (cost, feed_dict = {X:
inputX, Y: inputY})
...: print ("Training cost =", training_cost)
...:
Finalmente, puedes ejecutar la sesión y obtener los siguientes resultados del aprendizaje
fase.
Época: 0001 costo = 0.454545379

Época: 0051 costo = 0.454544961
Época: 0101 costo = 0.454536706
Época: 0151 costo = 0.454053283
Época: 0201 costo = 0.391623020
Época: 0251 costo = 0.197094142
Época: 0301 costo = 0.145846367
Época: 0351 costo = 0.121205062
Época: 0401 costo = 0.106998600
Época: 0451 costo = 0.097896501
392
Página 406
Época: 0501 costo = 0.091660112

Época: 0551 costo = 0.087186322
Época: 0601 costo = 0.083868250
Época: 0651 costo = 0.081344165
Época: 0701 costo = 0.079385243
Época: 0751 costo = 0.077839941
Época: 0801 costo = 0.076604150
Época: 0851 costo = 0.075604357
Época: 0901 costo = 0.074787453
Época: 0951 costo = 0.074113965
Época: 1001 costo = 0.073554687
Época: 1051 costo = 0.073086999
Época: 1101 costo = 0.072693743
Época: 1151 costo = 0.072361387
Época: 1201 costo = 0.072079219
Época: 1251 costo = 0.071838818
Época: 1301 costo = 0.071633331
Época: 1351 costo = 0.071457185
Época: 1401 costo = 0.071305975
Época: 1451 costo = 0.071175829
Época: 1501 costo = 0.071063705
Época: 1551 costo = 0.070967078
Época: 1601 costo = 0.070883729
Época: 1651 costo = 0.070811756
Época: 1701 costo = 0.070749618
Época: 1751 costo = 0.070696011
Época: 1801 costo = 0.070649780
Época: 1851 costo = 0.070609920
Época: 1901 costo = 0.070575655
Época: 1951 costo = 0.070546091
Último resultado = [[0,994959 0,00504093]
[0,97760069 0,02239927]
[0,95353836 0,04646158]
[0.91986829 0.0801317]
393
Página 407
[0.93176246 0.06823757]
[0.27190316 0.7280969]
[0.40035316 0.59964687]
[0.04414944 0.9558506]
[0.17278962 0.82721037]
[0.01200284 0.98799717]
[0.19901533 0.80098462]]
Ahora puede ver los datos recopilados en las listas avg_set y epoch_set para analizar
el progreso de la fase de aprendizaje.
En [10]: plt.plot (epoch_set, avg_set, 'o', label = 'MLP Training phase')

...: plt.legend ()
...: plt.show ()
...:

Figura 9-14. El valor del costo disminuye durante la fase de aprendizaje (costo
mejoramiento)
394
Página 408
En figura 9-14 , puede ver que durante las épocas de aprendizaje hay una gran
mejora en cuanto a la optimización de costes, luego en la parte final, la
las mejoras de época se hacen más pequeñas y luego convergen a cero.
Sin embargo, del análisis del gráfico se puede determinar que el ciclo de aprendizaje
de la red neuronal se ha completado en los ciclos de época asignados. Así que puedes
considere la red neuronal como aprendida. Ahora puede pasar a la fase de evaluación.

Ahora que tiene una red neuronal educada, puede hacer el texto de evaluación y
calcular la precisión.
Ahora que tiene una red neuronal con instrucciones para realizar la asignación, puede
pasar a la fase de evaluación. Luego calculará la precisión del modelo que
generado.
Para probar este modelo de red neuronal MLP, utilizará el mismo conjunto de pruebas utilizado en el
Ejemplo de red neuronal SLP.
En [11]: # conjunto de pruebas

...: testX = np.arr
ay ([[1., 2.25], [1.25,3.], [2,2.5], [2.25,2.75], [2.5,3.],
[2., 0.9], [2.5,1.2], [3., 1.25], [3., 1.5], [3.5,2.], [3.5,2.5]])
...: testY = [[1., 0.]] * 5 + [[0., 1.]] * 6
...:
Ahora no es necesario ver este conjunto de pruebas, ya que ya lo hizo en la

sección (puede marcarla si es necesario).
Inicie la sesión con la prueba de entrenamiento y evalúe la exactitud de los resultados
obtenido calculando la precisión.

...:
...: _, c = sess.run ([optimizador, coste],
395
Página 409
feed_dict = {X: batch_x, Y: batch_y})

...:
...: # Modelo de prueba
...: result = sess.run (pred, feed_dict = {X: testX})
...: predicción_correcta = tf.equal (tf.argmax (pred, 1),
tf.argmax (Y, 1))
...:
...: print ("Precisión:", precisión.eval ({X: testX, Y: testY}))
...: imprimir (resultado)
Al ejecutar toda la sesión, obtendrá el siguiente resultado.
Precisión: 1.0
Resultado = [[0.98507893 0.0149211]
[0.99064976 0.00935023]
[0.86788082 0.13211915]
[0.83086801 0.16913196]
[0,78604239 0,21395761]
[0.36329603 0.63670397]
[0.19036612 0.80963391]
[0.06203776 0.93796223]
[0.0883315 0.91166848]
[0.05140254 0.94859749]
[0.10417036 0.89582968]]
También en el caso de la red neuronal MLP has obtenido un 100% de precisión

(11 puntos correctamente clasificados sobre 11 puntos en total). Ahora muestra la clasificación obtenida
dibujando puntos en el plano cartesiano.
En [13]: yc = resultado [:, 1]

...: imprimir (yc)
...: plt.show ()
...:
396
Página 410
[0.0149211 0.00935023 0.13211915 0.16913196 0.21395761 0.63670397

0.80963391 0.93796223 0.91166848 0.94859749 0.89582968]
Obtendrá una tabla (vea la Figura 9-15) de los puntos distribuidos en el plano cartesiano
con el color que va del azul al amarillo, lo que indica la probabilidad de pertenecer a
una de las dos clases.
Perceptrón multicapa (con dos capas ocultas)

con TensorFlow
En esta sección, ampliará la estructura anterior agregando dos neuronas a la primera
capa oculta y agregando una segunda capa oculta con dos neuronas.
Inicie una nueva sesión de IPython y vuelva a escribir el código del ejemplo anterior, que
permaneció igual excepto por algunos parámetros (los ve en el texto del código).
Gracias a la parametrización del código que usaste, es muy fácil de extender y
modificar la estructura de la red neuronal MLP. En este caso solo tienes que cambiar el
siguiendo los parámetros y vuelva a ejecutarlo de nuevo.
En [1]: importar tensorflow como tf

...:
397
Página 411
...: #Conjunto de entrenamiento

ay ([[1., 3.], [1., 2.], [1., 1.5], [1.5,2.], [2., 3.], [2.5,1.5],
[2., 1.], [3., 1.], [3., 2.], [3.5,1.], [3.5,3.]])
...: inputY = [[1., 0.]] * 6+ [[0., 1.]] * 5
...:
...: tasa_de_aprendizaje = 0.001
...: training_epochs = 2000
...: display_step = 50
...: n_muestras = 11
...:
...: # Parámetros de red
...: n_hidden_1 = 4 # 1a capa número de neuronas
...: n_hidden_2 = 2 # 2da capa número de neuronas
...: n_input = 2 # entrada de datos de tamaño
...: n_classes = 2 # clases
...:
...: # tf Entrada de gráfico
...: X = tf.placeholder ("float", [None, n_input])
...: Y = tf.placeholder ("float", [None, n_classes])
...:
...: # Almacenar el peso y el sesgo de las capas
...: pesos = {
...: 'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])),
...: 'h2': tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])),
...: 'fuera': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))
...:}
...: sesgos = {
...: 'fuera': tf.Variable (tf.random_normal ([n_classes]))
...:}
...:
...: # Crear modelo
398
Página 412
...: def multilayer_perceptron (x):

...: layer_1 = tf.add (tf.matmul (x, weights ['h1']), sesgos ['b1'])
...: layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']),
sesgos ['b2'])
...: # Capa de salida completamente conectada con una neurona para cada clase
...: out_layer = tf.add (tf.matmul (layer_2, weights ['out']),
sesgos ['fuera'])
...: return out_layer
...:
...: # Construir modelo
...: evidencia = multilayer_perceptron (X)
...: y_ = tf.nn.softmax (evidencia)
...:
...: # Definir costo y optimizador
...: costo = tf.reduce_sum (tf.pow (Y-y_, 2)) / (2 * n_samples)
...: optimizador = tf.train.AdamOptimizer (tasa_de_aprendizaje = tasa_de_aprendizaje).
minimizar (costo)
...:
...: avg_set = []
...: epoch_set = []
...: init = tf.global_variables_initializer ()
...:
...:
...: avg_cost = 0.
A SER IMPLEMENTADO
399
Página 413

formato (avg_cost))
...:
...: last_result = sess.run (y_, feed_dict = {X: inputX})
...: training_cost = sess.run (cost, feed_dict = {X: inputX, Y:
inputY})
...: print ("Training cost =", training_cost)
...:
Al ejecutar la sesión, se obtienen los siguientes resultados.
Época: 0001 costo = 0.545502067

Época: 0051 costo = 0.545424163
Época: 0101 costo = 0.545238674
Época: 0151 costo = 0.540347397
Época: 0201 costo = 0.439834774
Época: 0251 costo = 0.137688771
Época: 0301 costo = 0.093460977
Época: 0351 costo = 0.082653232
Época: 0401 costo = 0.077882372
Época: 0451 costo = 0.075265951
Época: 0501 costo = 0.073665120
Época: 0551 costo = 0.072624505
Época: 0601 costo = 0.071925417
Época: 0651 costo = 0.071447782
Época: 0701 costo = 0.071118690
Época: 0751 costo = 0.070890851
Época: 0801 costo = 0.070732787
Época: 0851 costo = 0.070622921
Época: 0901 costo = 0.070546582
400
Página 414
Época: 0951 costo = 0.070493549

Época: 1001 costo = 0.070456795
Época: 1051 costo = 0.070431381
Época: 1101 costo = 0.070413873
Época: 1151 costo = 0.070401885
Época: 1201 costo = 0.070393734
Época: 1251 costo = 0.070388250
Época: 1301 costo = 0.070384577
Época: 1351 costo = 0.070382126
Época: 1401 costo = 0.070380524
Época: 1451 costo = 0.070379473
Época: 1501 costo = 0.070378840
Época: 1551 costo = 0.070378408
Época: 1601 costo = 0.070378155
Época: 1651 costo = 0.070378013
Época: 1701 costo = 0.070377886
Época: 1751 costo = 0.070377827
Época: 1801 costo = 0.070377797
Época: 1851 costo = 0.070377767
Época: 1901 costo = 0.070377775
Época: costo de 1951 = 0.070377789
Último resultado = [[0,99683338 0,00316658]
[0.98408335 0.01591668]
[0.96478891 0.0352111]
[0.93620235 0.06379762]
[0.94662082 0.05337923]
[0.26812935 0.73187065]
[0.40619871 0.59380126]
[0.03710628 0.96289372]
[0.16402677 0.83597326]
[0.0090636 0.99093646]
[0.19166829 0.80833173]]
Ver el progreso de la fase de aprendizaje de la forma habitual.
401
Página 415
En [2]: plt.plot (epoch_set, avg_set, 'o', label = 'MLP Training phase')

...: plt.legend ()
...: plt.show ()
...:

Figura 9-16. La tendencia del costo durante la fase de aprendizaje para un MLP con dos
capas ocultas
Por lo que puede ver en la Figura 9-16, el aprendizaje en este caso es mucho más rápido que el
caso anterior (en 1000 épocas, estaría bien). El costo optimizado es casi el mismo
como en la red neuronal anterior (0.0703778 versus 0.0705207 en el caso anterior).

Aquí también utilizará el mismo conjunto de pruebas para evaluar la precisión del sistema neuronal MLP.
red para clasificar las muestras en análisis.
En [3]: # conjunto de pruebas

...: testX = np.array ([[1., 2.25], [1.25,3.], [2,2.5], [2.25,2.75], [2.5,3.],
402
Página 416
[2., 0.9], [2.5,1.2], [3., 1.25], [3., 1.5], [3.5,2.], [3.5,2.5]])

...: testY = [[1., 0.]] * 5 + [[0., 1.]] * 6
...:

...:
...:
...: pred = tf.nn.softmax (evidencia) # Aplicar softmax a logits
...: result = sess.run (pred, feed_dict = {X: testX})
...: predicción_correcta = tf.equal (tf.argmax (pred, 1), tf.argmax (Y, 1))

...: print ("Precisión:", precisión.eval ({X: testX, Y: testY}))
...: print ("Resultado =", resultado)
Al ejecutar la sesión, obtendrá el siguiente resultado.
Precisión: 1.0
Resultado = [[0.98924851 0.01075149]
[0,99344641 0,00655352]
[0.88655776 0.11344216]
[0.85117978 0.14882027]
[0,8071683 0,19283174]
[0.36805421 0.63194579]
[0.18399802 0.81600195]
[0.05498539 0.9450146]
[0.08029026 0.91970974]
[0.04467025 0.95532972]
[0.09523712 0.90476292]]
403
Página 417
Aquí, también, tiene una precisión del 100% y con matplotlib mostrando los puntos de ajuste de prueba
en el plano cartesiano con el sistema de degradado de color habitual, obtendrá muy similar
resultados a los ejemplos anteriores (ver Figura 9-17 ).

...: plt.show ()
...:
Evaluación de datos experimentales

Ahora harás algo que no has hecho hasta ahora. Hasta ahora, ha creado nuevos
modelos de redes neuronales y cuidado de la fase de aprendizaje para que puedas aprender
cómo clasificar el tipo particular de datos que eligió.
De los datos que utilizó para el conjunto de entrenamiento y el conjunto de prueba, conocía perfectamente el
valores esperados (contenidos en y). En este caso, el valor correspondió a la clase a
al que pertenece. Entonces aplicó el aprendizaje supervisado .
Finalmente, con la fase de prueba y el cálculo de la precisión, evaluó el
validez del modelo de red neuronal.
404
Página 418
Ahora pasemos a la clasificación adecuada, pasando a la red neuronal un

gran cantidad de datos (puntos en el plano cartesiano) sin saber qué clase
pertenecen a. De hecho, es el momento en que la red neuronal le informa sobre la
posibles clases.
Para ello, el programa simula datos experimentales, creando puntos en el
Plano cartesiano que son completamente aleatorios. Por ejemplo, genere una matriz que contenga
1000 puntos aleatorios.
En []: prueba = 3 * np.random.random ((1000,2))
Luego envíe estos puntos a la red neuronal para determinar la clase de membresía.

...:
...:
...: result = sess.run (pred, feed_dict = {X: test})
...:
Finalmente, puede visualizar los datos experimentales en función de su probabilidad de

clasificación, evaluada por la red neuronal.

...: plt.scatter (prueba [:, 0], prueba [:, 1], c = yc, s = 50, alfa = 1)
...: plt.show ()
...:
Obtendrá una tabla, como se muestra en la Figura 9-18 .
405
Página 419
Figura 9-18. Un gráfico con todos los puntos experimentales y la estimación de la

clases a las que pertenecen
Como puede ver según las tonalidades, se delimitan dos áreas de clasificación en
el plano, con las partes alrededor del verde que indican las zonas de incertidumbre.
Los resultados de la clasificación se pueden hacer más comprensibles y claros al decidir
establecer con base en la probabilidad si el punto pertenece a una u otra clase. Si el
La probabilidad de que un punto pertenezca a una clase sea mayor que 0.5, entonces pertenecerá a ella.
En [9]: yc = np.round (resultado [:, 1])

...: plt.scatter (prueba [:, 0], prueba [:, 1], c = yc, s = 50, alfa = 1)
...: plt.show ()
...:
Obtendrá una tabla, como se muestra en la Figura 9-19 .
406
Página 420
Figura 9-19. Los puntos delimitan las dos regiones correspondientes a las dos
clases de pertenencia
En el gráfico que se muestra en la Figura 9-19 , puede ver claramente las dos regiones del
Plano cartesiano que caracteriza a las dos clases de pertenencia.
Conclusiones
En este capítulo, aprendió sobre la rama del aprendizaje automático que usa
redes como una estructura informática, llamado aprendizaje profundo. Ha leído una descripción general de la
conceptos básicos de aprendizaje profundo, que involucra redes neuronales y su estructura.
Finalmente, gracias a la biblioteca de TensorFlow, implementó diferentes tipos de
redes, como Perceptron Single Layer y Perceptron Multi Layer.
El aprendizaje profundo, con todas sus técnicas y algoritmos, es un tema muy complejo, y
es prácticamente imposible tratarlo adecuadamente en un capítulo. Sin embargo, ahora tienes
familiarizarse con el aprendizaje profundo y puede comenzar a implementar sistemas neuronales más complejos
redes.
407
Página 421
CAPÍTULO 10
Un ejemplo-
Datos meteorológicos
Un tipo de datos que es más fácil de encontrar en la red son los datos meteorológicos. Muchos sitios
proporcionar datos históricos sobre muchos parámetros meteorológicos como la presión,
temperatura, humedad, lluvia, etc. Solo necesita especificar la ubicación y la fecha para
Obtenga un archivo con conjuntos de datos de mediciones recopilados por estaciones meteorológicas. Estos datos son una
fuente de una amplia gama de información. Como leyó en el primer capítulo de este libro, la
El propósito del análisis de datos es transformar los datos sin procesar en información y luego convertirlos
en conocimiento.
En este capítulo, verá un ejemplo sencillo de cómo utilizar los datos meteorológicos. Esta
Este ejemplo será útil para tener una idea general de cómo aplicar muchas de las técnicas vistas
en los capítulos anteriores.
Una hipótesis para ser probada: la influencia

de la proximidad del mar
En el momento de escribir este capítulo, me encuentro a principios de verano y
temperaturas subiendo. El fin de semana, mucha gente del interior viaja a pueblos de montaña o
ciudades cercanas al mar, para disfrutar de un refresco y alejarse del bochorno
tiempo de las ciudades del interior. Esto siempre me ha hecho preguntarme qué efecto tiene la proximidad
del mar tiene sobre el clima.
Esta simple pregunta puede ser un buen punto de partida para el análisis de datos. No quiero
haga pasar este capítulo como algo científico; es solo una forma para alguien apasionado
análisis de datos para poner en práctica el conocimiento a fin de responder a esta pregunta: ¿qué
¿Influencia, si la hay, tiene la proximidad del mar en el clima local?
409
© Fabio Nelli 2018
Página 422
CAPÍTULO 10 UN EJEMPLO: DATOS METEOROLÓGICOS
El sistema en el estudio: el mar Adriático y

el valle del Po
Ahora que se ha definido el problema, es necesario buscar un sistema que esté bien
adecuado para el estudio de los datos y para proporcionar un entorno adecuado para esta pregunta.
Primero necesitas un mar. Bueno, estoy en Italia y tengo muchos mares para elegir, ya que
Italia es una península rodeada de mares. ¿Por qué limitarme a Italia? Bueno el problema
implica un comportamiento propio de los italianos, es decir, se refugian en lugares cercanos al
mar durante el verano para evitar el calor del interior. Sin saber si este comportamiento
Es lo mismo para personas de otras naciones, solo consideraré a Italia como un sistema de estudio.
Pero, ¿qué áreas de Italia podríamos considerar estudiar? ¿Podemos evaluar los efectos
del mar a varias distancias? Esto crea muchos problemas. De hecho, Italia es rica en
áreas montañosas y no tiene mucho territorio que se extienda uniformemente por muchos
kilómetros tierra adentro. Entonces, para evaluar los efectos del mar, excluyo las montañas, ya que
puede introducir muchos otros factores que también afectan al clima, como la altitud, por ejemplo.
Una parte de Italia que se adapta bien a esta evaluación es el valle del Po. Esta llanura comienza
del mar Adriático y se extiende tierra adentro por cientos de kilómetros (ver Figura 10-1 ). Eso
está rodeado de montañas, pero el ancho del valle mitiga los efectos de las montañas.
También tiene muchos pueblos por lo que será fácil elegir un conjunto de ciudades cada vez más distantes
del mar, para cubrir una distancia de casi 400 km en esta evaluación.
410
Página 423
Figura 10-1. Una imagen del valle del Po y el mar Adriático (Google Maps)
411
Página 424
El primer paso es elegir un conjunto de 10 ciudades que servirán como estándares de referencia.
Estas ciudades se seleccionan para cubrir todo el rango de la llanura (ver Figura 10-2 ).
Figura 10-2. Las 10 ciudades elegidas como muestra (hay otra que se utiliza como
referencia para tomar distancias del mar)
En figura 10-2 puede ver las 10 ciudades que se eligieron para analizar los datos meteorológicos: cinco
ciudades dentro de los primeros 100 km y las otras cinco distribuidas en los 300 km restantes.
Aquí están las ciudades elegidas:
• Ferrara
• Turín
• Mantua
• Milán
• Ravenna
• Asti
• Bolonia
• Piacenza
• Cesena
• Faenza
412
Página 425
Capítulo 10 un ejemplo: datos meteorológicos
Ahora tenemos que determinar las distancias de estas ciudades al mar. Puedes seguir
muchos procedimientos para obtener estos valores. En este caso, puede utilizar el servicio proporcionado por
el sitio TheTimeNow (http://www.thetimenow.com/distance-calculator.php), cual
está disponible en muchos idiomas (ver Figura 10-3).
Figura 10-3. El sitio web TheTimeNow le permite calcular distancias entre

dos ciudades
Gracias a este servicio, es posible calcular las distancias aproximadas del
ciudades del mar. Puede hacerlo seleccionando una ciudad de la costa como destino.
Para muchos de ellos se puede elegir la ciudad de Comacchio como referencia para calcular el
distancia del mar (ver Figura 10-2 ). Una vez que haya determinado las distancias desde
las 10 ciudades, obtendrá los valores que se muestran en la Tabla 10-1 .
Tabla 10-1. Las distancias desde el mar de las 10 ciudades
Ciudad Distancia (km) Nota
ravenna 8 medido con google earth
Cesena 14 medido con google earth
Faenza 37 Distancia Faenza-ravenna + 8 km
Ferrara 47 Distancia Ferrara-Comacchio
Bolonia 71 Distancia Bolonia-Comacchio
mantova 121 Distancia mantova-Comacchio
Piacenza 200 Distancia piacenza-Comacchio
milano 250 Distancia milano-Comacchio
asti 315 Distancia asti-Comacchio
torino 357 Distancia torino-Comacchio
413
Página 426
Encontrar la fuente de datos

Una vez que se ha definido el sistema en estudio, es necesario establecer una fuente de datos desde
que para obtener los datos necesarios. Navegando por Internet, puede descubrir muchos sitios
que proporcionan datos meteorológicos medidos desde varios lugares del mundo.
Uno de esos sitios es Open Weather Map, disponible en http://openweathermap.org/
Figura 10-4. El sitio de OpenWeatherMap
Una vez que se haya registrado para obtener una cuenta y haya recibido un código de identificación de la aplicación, este sitio habilita
Usted puede capturar datos especificando la ciudad a través de una solicitud a través de URL.
http://api.openweathermap.org/data/2.5/weather?q=Atlanta,US&appid=5807ad2a4
5eb6bf4e81d137dafe74e15
Esta solicitud devolverá un archivo JSON que contiene toda la información sobre el
situación meteorológica actual en la ciudad en cuestión (ver Figura 10-5 ). Este archivo JSON será
enviado para el análisis de datos utilizando la biblioteca Python pandas.
414
Página 427
Figura 10-5. El archivo JSON que contiene los datos meteorológicos de la ciudad.
pedido
Análisis de datos en Jupyter Notebook

Este capítulo abordará el análisis de datos utilizando Jupyter Notebook. Esto te permitirá
ingrese y estudie partes del código gradualmente.
Para iniciar la aplicación Jupyter Notebook, ejecute el siguiente comando desde el
línea de comando:
cuaderno jupyter
Una vez iniciado el servicio, cree un nuevo Notebook.

Comencemos importando las bibliotecas necesarias:

importar pandas como pd
importar fecha y hora
El primer paso es estudiar la estructura de los datos recibidos del sitio a través de un
solicitud específica.
Elija una ciudad de las elegidas para nuestro estudio, por ejemplo Ferrara, y haga una
solicitud de sus datos meteorológicos actuales, utilizando la URL especificada. Sin navegador
puede obtener el contenido de texto de una página utilizando la función de texto request.get (). Desde el
El contenido obtenido está en formato JSON podemos leer directamente el texto recibido siguiendo este
formatear con la función json.load ().
importar json
solicitudes de importación
ferrara = json.loads (request.get ('http://api.openweathermap.org/data/2.5/
weather? q = Ferrara, IT & appid = 5807ad2a45eb6bf4e81d137dafe74e15 '). texto)
415
Página 428
Ahora puede ver el contenido del archivo JSON con los datos meteorológicos relacionados
a la ciudad de Ferrara.
ferrara
{'base': 'estaciones',
'nubes': {'todo': 40},
'bacalao': 200,
'coord': {'lat': 44.84, 'lon': 11.62},
'dt': 1525960500,
'id': 3177090,
'principal': {'humedad': 64,
'presión': 1010,
'temp': 296.58,
'temp_max': 297,15,
'temp_min': 296.15},
'nombre': 'Ferrara',
'sys': {'país': 'IT',
'id': 5816,
'mensaje': 0.0051,
'amanecer': 1525924226,
'atardecer': 1525977007,
'tipo 1},
'visibilidad': 10000,
'weather': [{'description': 'nubes dispersas',
'icono': '03d',
'id': 802,
'main': 'Nubes'}],
'viento': {'deg': 240, 'velocidad': 3.1}}
Cuando desee analizar la estructura de un archivo JSON, un comando útil puede ser el
siguiendo:
lista (ferrara.keys ())
['coord',
'clima',
'base',
416
Página 429
'principal',
'visibilidad',
'viento',
'nubes',
'dt',
'sys',
'carné de identidad',
'nombre',
'bacalao']
De esta forma, puede tener una lista de todas las claves que componen la estructura interna del
JSON. Una vez que sepa el nombre de estas claves, podrá acceder fácilmente a los datos internos.
print ('Coordenadas =', ferrara ['coord'])

print ('Weather =', ferrara ['weather'])
print ('base =', ferrara ['base'])
print ('main =', ferrara ['main'])
print ('visibilidad =', ferrara ['visibilidad'])
print ('viento =', ferrara ['viento'])
print ('nubes =', ferrara ['nubes'])
imprimir ('dt =', ferrara ['dt'])
print ('sys =', ferrara ['sys'])
print ('id =', ferrara ['id'])
print ('nombre =', ferrara ['nombre'])
print ('cod =', ferrara ['cod'])
Coordenadas = {'lon': 11.62, 'lat': 44.84}
Clima = [{'id': 802, 'main': 'Nubes', 'descripción': 'disperso
nubes ',' icono ':' 03d '}]
base = estaciones
principal = {'temp': 296.59, 'presión': 1010, 'humedad': 64, 'temp_min':
296.15, 'temp_max': 297.15}
visibilidad = 10000
viento = {'velocidad': 3.1, 'grados': 240}
nubes = {'todo': 40}
dt = 1525960500
417
Página 430
sys = {'type': 1, 'id': 5816, 'message': 0.0029, 'country': 'IT',

'amanecer': 1525924227, 'atardecer': 1525977006}
id = 3177090
nombre = Ferrara
bacalao = 200
Ahora elegirás los valores que consideres más interesantes o útiles para este
tipo de análisis. Por ejemplo, un valor importante es la temperatura:
ferrara ['principal'] ['temp']

296,58
El propósito de este análisis de la estructura inicial es identificar los datos que podrían ser
más importante en la estructura JSON. Estos datos deben procesarse para su análisis. Ese
es decir, los datos deben extraerse de la estructura, limpiarse o modificarse de acuerdo con nuestro
necesidades y ordenado dentro de un marco de datos. De esta manera, luego puede aplicar todo el análisis de datos
técnicas presentadas en este libro.
Una forma conveniente de evitar repetir el mismo código es insertar alguna extracción
procedimientos en una función, como la siguiente.
def prepare (ciudad, nombre_ciudad):

temp = []
humedad = []
presión = []
descripción = []
dt = []
wind_speed = []
wind_deg = []
temp.append (ciudad ['principal'] ['temp'] - 273,15)
humedad.append (ciudad ['principal'] ['humedad'])
presión.append (ciudad ['principal'] ['presión'])
description.append (ciudad ['clima'] [0] ['descripción'])
dt.append (ciudad ['dt'])
wind_speed.append (ciudad ['viento'] ['velocidad'])
wind_deg.append (ciudad ['viento'] ['grado'])
encabezados = ['temperatura', 'humedad', 'presión', 'descripción', 'dt', 'viento_
velocidad ',' wind_deg ']
418
Página 431
datos = [temperatura, humedad, presión, descripción, dt, wind_speed, wind_deg]

df = pd.DataFrame (datos, índice = encabezados)
ciudad = df.T
ciudad ['ciudad'] = nombre_ciudad
ciudad ['día'] = ciudad ['dt']. aplicar (datetime.datetime.fromtimestamp)
ciudad de regreso
Esta función no hace más que tomar los datos meteorológicos que estás
interesado en la estructura JSON, y una vez limpiado o modificado (por ejemplo, fechas
y tiempos), esos datos se recopilan en una fila de un marco de datos (como se muestra en la Figura 10-6 ).
t1 = preparar (ferrara, 'ferrara')

t1
Figura 10-6. El marco de datos obtenido con los datos procesados a partir de la extracción JSON
Entre todos los parámetros descritos en la estructura JSON dentro de la columna de la lista,
aquí están los más apropiados para el estudio.
• Temperatura
• Humedad
• Presión
• Descripción
• Velocidad del viento
• Grado de viento
Todas estas propiedades estarán relacionadas con el tiempo de adquisición expresado a partir del dt
columna, que contiene una marca de tiempo como tipo de datos. Este valor es difícil de leer, por lo que
lo convertirá en un formato de fecha y hora que le permite expresar la fecha y la hora en un
manera más familiar para ti. La nueva columna se llamará día.
ciudad ['día'] = ciudad ['dt']. aplicar (datetime.datetime.fromtimestamp)
419
Página 432
La temperatura se expresa en grados Kelvin, por lo que deberá convertir estos valores
a Celsius restando 273.15 de cada valor.
Finalmente, agrega el nombre de la ciudad pasada como segundo argumento a prepare ()
función.
La recopilación de datos se realiza a intervalos regulares para recopilar datos durante diferentes momentos
del día. Por ejemplo, puede utilizar un programa que ejecute estas solicitudes cada
hora. Cada adquisición tendrá una fila de la estructura del marco de datos que se agregará a
un marco de datos general relacionado con la ciudad, llamado por ejemplo, df_ferrara (como se muestra en
Figura 10-7).
df_ferrara = t1
t2 = preparar (ferrara, 'ferrara')
df_ferrara = df_ferrara.append (t2)
df_ferrara
Figura 10-7. La estructura del marco de datos correspondiente a una ciudad
A menudo sucede que algunos datos útiles para nuestro análisis pueden no estar presentes en el
Fuente JSON. En este caso, debe recurrir a otras fuentes de datos e importar el
datos faltantes en la estructura. Dentro de este ejemplo de análisis, las distancias de las ciudades
del mar son indispensables.
.
df_ravenna ['dist'] = 8
df_cesena ['dist'] = 14
df_faenza ['dist'] = 37
df_ferrara ['dist'] = 47
df_bologna ['dist'] = 71
df_mantova ['dist'] = 121
df_piacenza ['dist'] = 200
df_milano ['dist'] = 250
df_asti ['dist'] = 315
df_torino ['dist'] = 357
.
420
Página 433
Análisis de datos meteorológicos procesados

Para fines prácticos, ya he recopilado datos de todas las ciudades involucradas en el

análisis. Ya los he procesado y recopilado en un marco de datos, que he guardado
como un archivo CSV.
Si desea consultar los datos utilizados en este capítulo, debe cargar los 10 archivos CSV
que guardé en el momento de escribir este artículo. Estos archivos contienen datos ya procesados para ser utilizados
para este análisis.
df_ferrara = pd.read_csv ('ferrara_270615.csv')

df_milano = pd.read_csv ('milano_270615.csv')
df_mantova = pd.read_csv ('mantova_270615.csv')
df_ravenna = pd.read_csv ('ravenna_270615.csv')
df_torino = pd.read_csv ('torino_270615.csv')
df_asti = pd.read_csv ('asti_270615.csv')
df_bologna = pd.read_csv ('bologna_270615.csv')
df_piacenza = pd.read_csv ('piacenza_270615.csv')
df_cesena = pd.read_csv ('cesena_270615.csv')
df_faenza = pd.read_csv ('faenza_270615.csv')
Gracias a la función read_csv () de pandas, puede convertir archivos CSV a la

marco de datos en un solo paso.
Una vez que haya cargado los datos de cada ciudad como un marco de datos, puede ver fácilmente la
contenido.
df_cesena
Como puede ver en la Figura 10-8, Jupyter Notebook hace que sea mucho más fácil de leer
marcos de datos con la generación de tablas gráficas. Además, puede ver que cada
La fila muestra los valores medidos para cada hora del día, cubriendo una línea de tiempo de aproximadamente 20
horas en el pasado.
421
Página 434
Figura 10-8. La estructura del marco de datos correspondiente a una ciudad
En el caso que se muestra en la Figura 10-8 , tenga en cuenta que solo hay 19 filas. De hecho, observando
otras ciudades, es posible que los sistemas de medición meteorológica a veces fallaran
durante el proceso de medición, dejando huecos durante la adquisición. Sin embargo, si los datos
recolectados son 19, como en este caso, son suficientes para describir la tendencia de la meteorología
propiedades durante el día. Sin embargo, es una buena práctica comprobar el tamaño de los 10
marcos de datos. Si una ciudad proporciona datos insuficientes para describir la tendencia diaria, necesitará
para reemplazarlo con otra ciudad.
Existe una forma sencilla de comprobar el tamaño, sin tener que poner una mesa tras otra.
Gracias a la función shape () puedes determinar el número de datos adquiridos (líneas)
para cada ciudad.
imprimir (df_ferrara.shape)
imprimir (df_milano.shape)
imprimir (df_mantova.shape)
imprimir (df_ravenna.shape)
imprimir (df_torino.shape)
imprimir (df_asti.shape)
422
Página 435
imprimir (df_bologna.shape)
imprimir (df_piacenza.shape)
imprimir (df_cesena.shape)
imprimir (df_faenza.shape)
Esto dará el siguiente resultado:
(20, 9)
(18, 9)
(20, 9)
(18, 9)
(20, 9)
(20, 9)
(20, 9)
(20, 9)
(20, 9)
(19, 9)
Como puede ver, la elección de 10 ciudades ha resultado ser óptima, ya que el control
las unidades han proporcionado datos suficientes para continuar en el análisis de datos.
Una forma normal de abordar el análisis de los datos que acaba de recopilar es utilizar
Visualización de datos. Viste que la biblioteca matplotlib incluye un conjunto de herramientas para generar
gráficos en los que mostrar datos. De hecho, la visualización de datos le ayuda mucho durante la
análisis para descubrir algunas características del sistema que está estudiando.
Luego activa las bibliotecas necesarias:
% matplotlib en línea
importar matplotlib.dates como mdates
Por ejemplo, una forma sencilla de elegir es analizar la tendencia de la temperatura

durante el día. Considere la ciudad de Milán.
y1 = df_milano ['temp']
x1 = df_milano ['día']
fig, ax = plt.subplots ()
plt.xticks (rotación = 70)
423
Página 436
horas = mdates.DateFormatter ('% H:% M')

ax.xaxis.set_major_formatter (horas)
ax.plot (x1, y1, 'r')
Al ejecutar este código, obtendrá el gráfico que se muestra en la Figura 10-9 . Como puede ver, el
La tendencia de temperatura sigue un patrón casi sinusoidal caracterizado por una temperatura
que sube por la mañana, para alcanzar el valor máximo durante el calor de la tarde
(entre las 2:00 y las 6:00 pm). Entonces la temperatura desciende a un valor mínimo
correspondiente a poco antes del amanecer, es decir, a las 6:00 am.
Figura 10-9. Tendencia de la temperatura de Milán durante el día
Dado que el propósito de su análisis es tratar de interpretar si es posible evaluar

cómo y si el mar influye en esta tendencia. Esta vez, evalúas las tendencias de diferentes
ciudades simultáneamente. Ésta es la única forma de ver si el análisis va bien
dirección. Por lo tanto, elija las tres ciudades más cercanas al mar y las tres ciudades más lejanas
de eso.
y1 = df_ravenna ['temp']
x1 = df_ravenna ['día']
y2 = df_faenza ['temp']
x2 = df_faenza ['día']
424
Página 437
y3 = df_cesena ['temp']
x3 = df_cesena ['día']
y4 = df_milano ['temp']
y5 = df_asti ['temp']
x5 = df_asti ['día']
y6 = df_torino ['temp']
x6 = df_torino ['día']
plt.plot (x1, y1, 'r', x2, y2, 'r', x3, y3, 'r')
plt.plot (x4, y4, 'g', x5, y5, 'g', x6, y6, 'g')
Este código producirá el gráfico que se muestra en la Figura 10-10. La temperatura de los tres
ciudades más cercanas al mar se muestra en rojo, mientras que la temperatura de las tres ciudades más alejadas
de distancia está en verde.
Figura 10-10. La tendencia de las temperaturas de seis ciudades diferentes (el rojo es el más cercano
al mar; el verde es el más lejano)
425
Página 438
Mirando la Figura 10-10, los resultados parecen prometedores. De hecho, las tres ciudades más cercanas
tienen temperaturas máximas mucho más bajas que las más lejanas, mientras que parece
ser poca diferencia en las temperaturas mínimas.
Para profundizar en este aspecto, puede recoger el máximo y el mínimo
temperaturas de las 10 ciudades y mostrar un gráfico de líneas que muestra estas temperaturas
en comparación con la distancia del mar.
dist = [df_ravenna ['dist'] [0],

df_cesena ['dist'] [0],
df_faenza ['dist'] [0],
df_ferrara ['dist'] [0],
df_bologna ['dist'] [0],
df_mantova ['dist'] [0],
df_piacenza ['dist'] [0],
df_milano ['dist'] [0],
df_asti ['dist'] [0],
df_torino ['dist'] [0]
]
temp_max = [df_ravenna ['temp']. max (),
df_cesena ['temp']. max (),
df_faenza ['temp']. max (),
df_ferrara ['temp']. max (),
df_bologna ['temp']. max (),
df_mantova ['temp']. max (),
df_piacenza ['temp']. max (),
df_milano ['temp']. max (),
df_asti ['temp']. max (),
df_torino ['temp']. max ()
]
temp_min = [df_ravenna ['temp']. min (),
df_cesena ['temp']. min (),
df_faenza ['temp']. min (),
df_ferrara ['temp']. min (),
df_bologna ['temp']. min (),
df_mantova ['temp']. min (),
df_piacenza ['temp']. min (),
426
Página 439
df_milano ['temp']. min (),

df_asti ['temp']. min (),
df_torino ['temp']. min ()
]
Empiece por representar las temperaturas máximas.
plt.plot (dist, temp_max, 'ro')
El resultado se muestra en la Figura 10-11 .
Figura 10-11. Tendencia de la temperatura máxima en relación a la distancia de

el mar
427
Página 440
Como se muestra en la figura 10-11, se puede afirmar que la hipótesis de que la presencia del
el mar de alguna manera influye en los parámetros meteorológicos es cierto (al menos en el día de hoy ☺).
Además, puede ver que el efecto del mar disminuye rápidamente, y después de aproximadamente
60-70 km, las temperaturas máximas alcanzan una meseta.
Algo interesante sería representar las dos tendencias diferentes con dos
líneas obtenidas por regresión lineal. Para hacer esto, puede utilizar el método SVR proporcionado por
la biblioteca scikit-learn.
x = np.array (dist)
y = np.array (temp_max)
x1 = x [x <100]
x1 = x1.reshape ((x1.size, 1))
y1 = y [x <100]
x2 = x [x> 50]
x2 = x2.reforma ((x2.tamaño, 1))
y2 = y [x> 50]
desde sklearn.svm importar SVR
svr_lin1 = SVR (kernel = 'lineal', C = 1e3)
svr_lin2 = SVR (kernel = 'lineal', C = 1e3)
svr_lin1.fit (x1, y1)
svr_lin2.fit (x2, y2)
xp1 = np. rango (10,100,10) .reshape ((9,1))
xp2 = np. rango (50,400,50) .reshape ((7,1))
yp1 = svr_lin1.predict (xp1)
yp2 = svr_lin2.predict (xp2)
plt.plot (xp1, yp1, c = 'r', label = 'Fuerte efecto de mar')
plt.plot (xp2, yp2, c = 'b', label = 'Efecto mar de luz')
eje plt. ((0,400,27,32))
plt.scatter (x, y, c = 'k', etiqueta = 'datos')
428
Página 441
Este código producirá el gráfico que se muestra en la Figura 10-12.
Figura 10-12. Las dos tendencias descritas por las temperaturas máximas en relación
a distancia
Como puede ver, el aumento de temperatura en los primeros 60 km es muy rápido, pasando de 28 a
31 grados. Luego aumenta muy levemente (si es que lo hace) en distancias más largas. Las dos tendencias
se describen mediante dos líneas rectas que tienen la siguiente expresión
x = ax + b
donde a es la pendiente y b es la intersección.
imprimir (svr_lin1.coef_)
imprimir (svr_lin1.intercept_)
imprimir (svr_lin2.coef_)
imprimir (svr_lin2.intercept_)
[[-0.04794118]]
[27.65617647]
[[-0.00317797]]
[30.2854661]
429
Página 442
Puede considerar el punto de intersección de las dos líneas como el punto entre
área donde el mar ejerce su influencia y área donde no, o al menos no como
fuertemente.
desde scipy.optimize import fsolve
def línea1 (x):

a1 = svr_lin1.coef_ [0] [0]
b1 = svr_lin1.intercept_ [0]
devuelve a1 * x + b1
def línea2 (x):
a2 = svr_lin2.coef_ [0] [0]
b2 = svr_lin2.intercept_ [0]
devuelve a2 * x + b2
def findIntersection (fun1, fun2, x0):
return fsolve (lambda x: fun1 (x) - fun2 (x), x0)
resultado = encontrarIntersección (línea1, línea2,0.0)

print ("[x, y] = [% d,% d]"% (resultado, línea1 (resultado)))
x = np.linspace (0,300,31)
plt.plot (x, línea1 (x), x, línea2 (x), resultado, línea1 (resultado), 'ro')
Al ejecutar el código, puede encontrar el punto de intersección de la siguiente manera:
[x, y] = [58, 30]
430
Página 443
Este punto está representado en el gráfico que se muestra en la Figura 10-13..
Figura 10-13. El punto de intersección entre dos líneas rectas obtenido por
regresión lineal
Entonces se puede decir que la distancia promedio en la que se desvanecen los efectos del mar es
58 km.
Ahora puedes analizar las temperaturas mínimas.
eje plt. ((0,400,15,25))

plt.plot (dist, temp_min, 'bo')
431
Página 444
Al hacer esto, obtendrá el gráfico que se muestra en la Figura 10-14..
Figura 10-14. Las temperaturas mínimas parecen ser independientes de la

distancia del mar
En este caso parece muy claro que el mar no influye en las temperaturas mínimas
grabado durante la noche, o mejor dicho, alrededor de las seis de la mañana. Si recuerdo bien
cuando era niño me enseñaron que el mar mitigaba las frías temperaturas, o que el
mar libera el calor absorbido durante el día. Este no parece ser el caso. Esta
caso rastrea el verano en Italia; Sería interesante ver si esta hipótesis es cierta en el
invierno o en otro lugar.
Otra medida meteorológica contenida en los 10 marcos de datos es la humedad.
Incluso para esta medida, puede ver la tendencia de la humedad durante el día para los tres
ciudades más cercanas al mar y para las tres más alejadas.
y1 = df_ravenna ['humedad']
x1 = df_ravenna ['día']
y2 = df_faenza ['humedad']
x2 = df_faenza ['día']
y3 = df_cesena ['humedad']
x3 = df_cesena ['día']
y4 = df_milano ['humedad']
432
Página 445
y5 = df_asti ['humedad']
x5 = df_asti ['día']
y6 = df_torino ['humedad']
x6 = df_torino ['día']
plt.plot (x1, y1, 'r', x2, y2, 'r', x3, y3, 'r')
plt.plot (x4, y4, 'g', x5, y5, 'g', x6, y6, 'g')
Este código creará el gráfico que se muestra en la Figura 10-15..
Figura 10-15. La tendencia de la humedad durante el día para las tres ciudades más cercanas al
mar (se muestra en rojo) y las tres ciudades más lejanas (indicadas en verde)
A primera vista, parecería que las ciudades más cercanas al mar experimentan más
humedad que los más lejanos y que esta diferencia de humedad (alrededor del 20%)
se extiende a lo largo del día. Veamos si esto sigue siendo cierto cuando informamos el máximo
y humedad mínima con respecto a las distancias del mar.
433
Página 446
hum_max = [df_ravenna ['humedad']. max (),

df_cesena ['humedad']. max (),
df_faenza ['humedad']. max (),
df_ferrara ['humedad']. max (),
df_bologna ['humedad']. max (),
df_mantova ['humedad']. max (),
df_piacenza ['humedad']. max (),
df_milano ['humedad']. max (),
df_asti ['humedad']. max (),
df_torino ['humedad']. max ()
]
plt.plot (dist, hum_max, 'bo')
La humedad máxima de 10 ciudades según su distancia al mar son

representado en el gráfico de la Figura 10-16 .
Figura 10-16. La tendencia de la función de humedad máxima con respecto a la

distancia del mar
434
Página 447
hum_min = [df_ravenna ['humedad']. min (),

df_cesena ['humedad']. min (),
df_faenza ['humedad']. min (),
df_ferrara ['humedad']. min (),
df_bologna ['humedad']. min (),
df_mantova ['humedad']. min (),
df_piacenza ['humedad']. min (),
df_milano ['humedad']. min (),
df_asti ['humedad']. min (),
df_torino ['humedad']. min ()
]
plt.plot (dist, hum_min, 'bo')
La humedad mínima de 10 ciudades según su distancia al mar son

representado en el gráfico de la Figura 10-17 .
Figura 10-17. La tendencia de la humedad mínima en función de la distancia desde

el mar
435
Página 448
Mirando Figuras 10-16 y10-17, ciertamente puede ver que la humedad es más alta,
tanto el mínimo como el máximo, en la ciudad más cercana al mar. Sin embargo, en mi opinión,
No es posible decir que existe una relación lineal o algún otro tipo de relación con
dibuja una curva. Los puntos recopilados (10) son demasiado pocos para resaltar una tendencia en este caso.
El viento rosa
Entre los diversos datos meteorológicos medidos que hemos recopilado para cada ciudad
son las relativas al viento:
• Grado de viento (dirección)
• Velocidad del viento
Si analiza el marco de datos, notará que la velocidad del viento es relativa a la

dirección en la que sopla y la hora del día. Por ejemplo, cada medida muestra el
dirección en la que sopla el viento (ver Figura 10-18).
436
Página 449
Figura 10-18. Los datos del viento contenidos en el marco de datos
Para analizar mejor este tipo de datos es necesario visualizarlos. En este caso un
El gráfico lineal en coordenadas cartesianas no es el enfoque más óptimo.
Si usa el gráfico de dispersión clásico con los puntos contenidos en un solo marco de datos:
plt.plot (df_ravenna ['wind_deg'], df_ravenna ['wind_speed'], 'ro')
437
Página 450
Obtienes un gráfico como el que se muestra en la Figura 10-19 , que ciertamente no es muy

educativo.
Figura 10-19. Un diagrama de dispersión que representa una distribución de 360 grados.
Para representar una distribución de puntos en 360 grados, es mejor utilizar otro tipo de
visualización: la carta polar. Ya ha visto este tipo de gráfico en el Capítulo 8 .
Primero debe crear un histograma, mediante el cual los datos se distribuyan
intervalo de 360 grados dividido en ocho contenedores, cada uno de los cuales es de 45 grados.
hist, bins = np.histogram (df_ravenna ['wind_deg'], 8, [0,360])
imprimir (hist)
imprimir (contenedores)
Los valores devueltos son ocurrencias dentro de cada bin expresados por una matriz llamada hist:
[0 5 11 1 0 1 0 0]
y una matriz llamada bins, que define los bordes de cada bin dentro del rango de 360
grados.
[0. 45. 90. 135. 180. 225. 270. 315. 360.]
438
Página 451
Estos arreglos serán útiles para definir correctamente el gráfico polar a dibujar. Para esto
propósito, debe crear una función en parte utilizando el código contenido en el Capítulo 8 .
Llamará a esta función showRoseWind () y necesitará tres argumentos diferentes:
valores es la matriz que contiene los valores a mostrar, que en nuestro caso será el
matriz hist; city_name es una cadena que contiene el nombre de la ciudad que se mostrará como gráfico
título; y max_value es un número entero que establecerá el valor máximo para presentar
el color azul.
Definir una función de este tipo le ayuda a evitar reescribir el mismo código muchas veces,
y produce un código más modular, lo que le permite centrarse en los conceptos relacionados
a una operación particular dentro de una función.
def showRoseWind (valores, city_name, max_value):

N=8
theta = np.arange (0., 2 * np.pi, 2 * np.pi / N)
radios = np.array (valores)
plt.axes ([0.025, 0.025, 0.95, 0.95], polar = True)
colores = [(1-x / max_value, 1-x / max_value, 0,75) para x en radios]
plt.bar (theta + np.pi / 8, radii, width = (2 * np.pi / N), bottom = 0.0,
color = colores)
plt.title (nombre_ciudad, x = 0.2, tamaño de fuente = 20)
Una cosa que cambió es el mapa de colores en colores. En este caso, cuanto más cerca del azul
color de la rebanada, mayor es el valor que representa.
Una vez que defina una función, puede usarla:
showRoseWind (hist, 'Ravenna', max (hist))
439
Página 452
Ejecutando este código obtendrás un gráfico polar como el que se muestra en la Figura 10-20 .
Figura 10-20. El gráfico polar representa la distribución de valores dentro de un rango

de 360 grados
Como puede ver en la Figura 10-20 , tiene un rango de 360 grados dividido en ocho
áreas de 45 grados cada una (bin), en las que se representa radialmente una escala de valores. En cada
de las ocho áreas, un corte se representa con una longitud variable que corresponde exactamente
al valor correspondiente. Cuanto más extendido radialmente esté el corte, mayor será el valor
representado. Para aumentar la legibilidad del gráfico, se ha creado una escala de colores.
ingresado que corresponde a la extensión de su segmento. Cuanto más ancha sea la rebanada, más
el color tiende a un azul profundo.
Este gráfico polar le proporciona información sobre cómo será la dirección del viento.
distribuido radialmente. En este caso, el viento ha soplado puramente hacia el suroeste / oeste.
la mayor parte del día.
440
Página 453
Una vez que haya definido la función showRoseWind, es muy fácil observar la
vientos con respecto a cualquiera de las 10 ciudades de la muestra.
hist, bin = np.histogram (df_ferrara ['wind_deg'], 8, [0,360])

imprimir (hist)
showRoseWind (hist, 'Ferrara', 15.0)
Figura 10-21 muestra los mapas polares de las 10 ciudades.
Figura 10-21. Los gráficos polares muestran la distribución de la dirección del viento.
Cálculo de la distribución media de la velocidad del viento

Incluso la otra cantidad que relaciona la velocidad de los vientos se puede representar como
Distribución en 360 grados.
Ahora defina una función llamada RoseWind_Speed que le permitirá calcular la media
velocidades del viento para cada uno de los ocho contenedores en los que se dividen 360 grados.
def RoseWind_Speed (df_city):

grados = np. rango (45,361,45)
tmp = []
para grados en grados:
tmp.append (df_city [(df_city ['wind_deg']> (deg-46)) & (df_city ['wind_
deg '] <deg)] [' wind_speed ']. mean ())
return np.nan_to_num (tmp)
441
Página 454
Esta función devuelve una matriz NumPy que contiene las ocho velocidades medias del viento. Esta
array se utilizará como primer argumento de la función ShowRoseWind_Speed (), que
es una versión mejorada de la función ShowRoseWind () anterior utilizada para representar la
carta polar.
def showRoseWind_Speed (velocidades, nombre_ciudad):

N=8
theta = np.arange (0,2 * np.pi, 2 * np.pi / N)
radios = np.array (velocidades)
plt.axes ([0.025, 0.025, 0.95, 0.95], polar = True)
colores = [(1-x / 10.0, 1-x / 10.0, 0.75) para x en radios]
bars = plt.bar (theta + np.pi / 8, radii, width = (2 * np.pi / N), bottom = 0.0,
color = colores)
plt.title (nombre_ciudad, x = 0.2, tamaño de fuente = 20)
showRoseWind_Speed (RoseWind_Speed (df_ravenna), 'Ravenna')
Figura 10-22 representa el RoseWind correspondiente a las velocidades del viento distribuidas
alrededor de 360 grados.
Figura 10-22. Este gráfico polar representa la distribución de las velocidades del viento dentro
360 grados
442
Página 455
Al final de todo este trabajo, puede guardar el marco de datos como un archivo CSV, gracias a la
función to_csv () de la biblioteca de pandas.
df_ferrara.to_csv ('ferrara.csv')
df_milano.to_csv ('milano.csv')
df_mantova.to_csv ('mantova.csv')
df_ravenna.to_csv ('ravenna.csv')
df_torino.to_csv ('torino.csv')
df_asti.to_csv ('asti.csv')
df_bologna.to_csv ('bologna.csv')
df_piacenza.to_csv ('piacenza.csv')
df_cesena.to_csv ('cesena.csv')
df_faenza.to_csv ('faenza.csv')
Conclusiones
El propósito de este capítulo fue principalmente mostrar cómo puede obtener información de
datos brutos. Parte de esta información no conducirá a conclusiones importantes, mientras que otras
información conducirá a la confirmación de una hipótesis, aumentando así su estado de
conocimiento. Estos son los casos en los que el análisis de datos ha tenido éxito.
En el siguiente capítulo, verá otro caso relacionado con datos reales obtenidos de
una fuente de datos abierta. También verá cómo puede mejorar aún más el gráfico
representación de los datos utilizando la biblioteca de JavaScript D3. Esta biblioteca, aunque no
Python, se puede integrar fácilmente en Python.
443
Página 456
CAPÍTULO 11
Incrustar JavaScript
Biblioteca D3 en IPython
Cuaderno
En este capítulo, verá cómo ampliar las capacidades de la representación gráfica
incluida la biblioteca JavaScript D3 en su Jupyter Notebook. Esta biblioteca tiene enormes
gráficos potenciales y le permite construir representaciones gráficas que incluso el
La biblioteca matplotlib no puede representar.
En el transcurso de los diversos ejemplos, verá cómo puede implementar JavaScript
código en un entorno Python, utilizando la gran capacidad del Jupyter integrador
Cuaderno. También verá diferentes formas de usar los datos contenidos en los marcos de datos de Pandas
Pandas en representaciones basadas en código JavaScript.
La fuente de datos abierta para la demografía

En este capítulo, utilizará datos demográficos como el conjunto de datos sobre el que realizar la
análisis. Un buen punto de partida es el que se sugiere en el artículo web "Incrustar
Gráficos interactivos en un cuaderno IPython ", escrito por Agustín Barto ( http: // www.
machinalis.com/blog/embedding-interactive-charts-on-an-ipython-nb/). Esta
artículo sugirió el sitio de la Oficina del Censo de los Estados Unidos ( http://www.census.gov )
como fuente de datos para datos demográficos (consulte la Figura 11-1).
445
© Fabio Nelli 2018
Página 457
CAPÍTULO 11 INTEGRANDO LA BIBLIOTECA JAVASCRIPT D3 EN EL PORTÁTIL IPYTHON
Figura 11-1. Esta es la página de inicio de la Oficina del Censo de Estados Unidos.
La Oficina del Censo de los Estados Unidos es parte del Departamento de

Commerce, y está oficialmente a cargo de recopilar datos demográficos en los EE. UU.
población y reportando estadísticas al respecto. Su sitio proporciona una gran cantidad de datos como
Archivos CSV, que, como ha visto en capítulos anteriores, se importan fácilmente en el formulario
de marcos de datos de Pandas.
Para los propósitos de este capítulo, desea que los datos que estimen la población
de cada estado y condados de los Estados Unidos. Un archivo CSV que contiene todo esto
la información es CO-EST2014-alldata.csv.
Primero, abra Jupyter Notebook y en el primer cuadro, importe todos los aspectos del
Biblioteca de Python que luego podría ser necesaria en cualquier página de IPython Notebook.

importar pandas como pd
Ahora que tiene todas las bibliotecas necesarias, puede comenzar importando datos
de Census.gov en su cuaderno. Por lo tanto, debe cargar CO-EST2014-alldata.
csv directamente en forma de marco de datos de Pandas. La función pd.read_csv ()
446
Página 458
convertir los datos tabulares contenidos en un archivo CSV a un marco de datos Pandas, que nombrará
pop2014. Con la opción dtype, puede forzar la interpretación de algunos campos que
podría interpretarse como números, en su lugar, como cadenas.
url = "https://raw.githubusercontent.com/dwdii/IS608-VizAnalytics/master/
Proyecto final / Datos / CO-EST2014-alldata.csv "
pop2014 = pd.read_csv (url, encoding = 'latin-1', dtype = {'ESTADO': 'str',
'CONDADO': 'str'})
Una vez que haya adquirido y recopilado datos en el marco de datos pop2014, podrá ver
cómo están estructurados simplemente escribiendo:
pop2014
Obtendrá una imagen como la que se muestra en la Figura 11-2 .
Figura 11-2. El marco de datos pop2014 contiene todos los datos demográficos de los años.
de 2010 a 2014
Analizando cuidadosamente la naturaleza de los datos, puede ver cómo están organizados
dentro del marco de datos. La columna SUMLEV contiene el nivel geográfico de los datos; para
ejemplo, 40 indica un estado y 50 indica datos que cubren un solo condado.
Las columnas REGION, DIVISION, STATE y COUNTY contienen subdivisiones jerárquicas
de todas las áreas en las que se ha dividido el territorio estadounidense. STNAME y CTYNAME indican
el nombre del estado y el condado, respectivamente. Las siguientes columnas contienen el
datos sobre población. CENSUS2010POP es la columna que contiene los datos reales en el
población, es decir, los datos que fueron recopilados por el censo de 2010. Siguiendo eso son
otras columnas con las estimaciones de población calculadas para cada año. En este ejemplo,
puede ver 2010 (2011, 2012, 2013 y 2014 también están en el marco de datos, pero no se muestran en
Figura 11-2).
447
Página 459
Utilizará estos valores de estimaciones de población como datos que se representarán en el

ejemplos discutidos en este capítulo.
El marco de datos pop2014 contiene una gran cantidad de columnas y filas que
no les interesa, por lo que es inteligente eliminar la información innecesaria. Primero tú
están interesados en los valores de las personas que se relacionan con estados enteros, por lo que extrae
solo las filas con SUMLEV igual a 40. Recopile estos datos dentro de pop2014_by_state
marco de datos.
pop2014_by_state = pop2014 [pop2014.SUMLEV == 40]

pop2014_by_state
Obtiene un marco de datos como el que se muestra en la Figura 11-3 .
Figura 11-3. El marco de datos pop2014_by_state contiene todos los datos demográficos relacionados
a los estados
Sin embargo, el marco de datos que se acaba de obtener todavía contiene demasiadas columnas con
información innecesaria. Dado el elevado número de columnas, en lugar de realizar
su eliminación con la función drop (), es más conveniente realizar una extracción.
estados = pop2014_by_state [['STNAME', 'POPESTIMATE2011', 'POPESTIMATE2012',

'POPESTIMATE2013', 'POPESTIMATE2014']]
448
Página 460
Ahora que tiene la información esencial necesaria, puede comenzar a hacer gráficos
representaciones. Por ejemplo, puede determinar los cinco estados más poblados del
país.
state.sort_values (['POPESTIMATE2014'], ascendente = Falso) [: 5]
Enumerarlos en orden descendente, recibirá una trama de datos como se muestra en la Figura 11- 4.
Figura 11-4. Los cinco estados más poblados de los Estados Unidos
Por ejemplo, puede utilizar un gráfico de barras para representar los cinco estados más poblados de
orden descendiente. Este trabajo se logra fácilmente con matplotlib, pero en este capítulo,
aprovechará esta sencilla representación para ver cómo puede utilizar JavaScript
Biblioteca D3 para crear la misma representación.
La biblioteca JavaScript D3
D3 es una biblioteca de JavaScript que permite la inspección y manipulación directa del DOM
objeto (HTML5), pero está destinado únicamente a la visualización de datos y hace su trabajo
excelentemente. De hecho, el nombre D3 se deriva de las tres D contenidas en "datos controlados
documentos." D3 fue desarrollado íntegramente por Mike Bostock.
Esta biblioteca está demostrando ser muy versátil y potente, gracias a las tecnologías
en el que se basa: JavaScript, SVG y CSS. D3 combina una visualización potente
componentes con un enfoque basado en datos para la manipulación DOM. Al hacerlo, D3
aprovecha al máximo las capacidades del navegador moderno.
Dado que incluso los Jupyter Notebooks son objetos web y utilizan las mismas tecnologías
que son la base del navegador actual, la idea de utilizar esta biblioteca, aunque
JavaScript, dentro del cuaderno no es tan absurdo como puede parecer al principio.
449
Página 461
Para aquellos que no están familiarizados con la biblioteca JavaScript D3 y quieren saber más sobre
este tema, recomiendo leer otro libro, titulado "Crear gráficos web con D3",
por F. Nelli (Apress, 2014).
De hecho, Jupyter Notebook tiene la función mágica %% javascript para integrar
Código JavaScript dentro del código Python.
Pero el código JavaScript, de manera similar a Python, requiere que importe algunos
Bibliotecas. Las bibliotecas están disponibles en línea y deben cargarse cada vez que inicie el
ejecución. En HTML, el proceso de importación de la biblioteca tiene una construcción particular:
<script src = "https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min.js">

</script>
Esta es una etiqueta HTML. Para realizar la importación dentro de un Jupyter Notebook, debe
en su lugar, use esta construcción diferente:
%% javascript
require.config ({
caminos: {
d3: '//cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min'
}
});
Con require.config (), puede importar todas las bibliotecas de JavaScript necesarias.
Además, si está familiarizado con el código HTML, sabrá con seguridad que necesita
para definir estilos CSS si desea fortalecer la capacidad de visualización de un HTML
página. Paralelamente, también en Jupyter Notebook, puede definir un conjunto de estilos CSS. Que hacer
esto se puede escribir código HTML, gracias a la función HTML () perteneciente al IPython.
módulo core.display. Por lo tanto, realice las definiciones CSS adecuadas de la siguiente manera:
desde IPython.core.display importar pantalla, Javascript, HTML
mostrar (HTML ("" "

<estilo>
.bar {
relleno: azul acero;
}
450
Página 462
.bar: hover {
relleno: marrón;
}
.axis {
fuente: 10px sans-serif;
}
ruta del eje.
.axis line {
llenar: ninguno;
trazo: # 000;
}
.x.axis path {
pantalla: ninguna;
}
</style>
<div id = "chart_d3" />
"" "))
En la parte inferior del código anterior, observa que se identifica la etiqueta HTML <div>
como chart_d3. Esta etiqueta identifica la ubicación donde se representará.
Ahora tienes que escribir el código JavaScript utilizando las funciones proporcionadas por
Biblioteca D3. Usando el objeto Plantilla proporcionado por la biblioteca Jinja2, puede definir
código JavaScript dinámico donde puede reemplazar el texto según los valores
contenido en un marco de datos Pandas.
Si todavía no hay una biblioteca Jinja2 instalada en su sistema, siempre puede instalarla
con Anaconda.
conda instalar jinja2
O usando
pip instalar jinja2
451
Página 463
Una vez que haya instalado esta biblioteca, puede definir la plantilla.
importar jinja2
myTemplate = jinja2.Template ("" "
require (["d3"], function (d3) {
var data = []
{% para fila en datos%}

data.push ({'estado': '{{fila [1]}}', 'población': {{fila [5]}}});
{% endfor%}
d3.select ("# chart_d3 svg"). remove ()
var margin = {top: 20, right: 20, bottom: 30, left: 40},
ancho = 800 - margin.left - margin.right,
altura = 400 - margin.top - margin.bottom;
var x = d3.scale.ordinal ()
.rangeRoundBands ([0, ancho], .25);
var y = d3.scale.linear ()
.range ([altura, 0]);
var xAxis = d3.svg.axis ()
.escala (x)
.orient ("abajo");
var yAxis = d3.svg.axis ()

.escala (y)
.orient ("izquierda")
garrapatas (10)
.tickFormat (d3.format ('. 1s'));
var svg = d3.select ("# chart_d3"). append ("svg")

.attr ("ancho", ancho + margen.izquierda + margen.derecha)
.attr ("altura", altura + margin.top + margin.bottom)
.append ("g")
.attr ("transformar", "traducir (" + margin.left + "," + margin.top + ")");
452
Página 464
x.domain (data.map (function (d) {return d.state;}));

y.domain ([0, d3.max (data, function (d) {return d.population;})]);
svg.append ("g")
.attr ("clase", "eje x")
.attr ("transformar", "traducir (0," + altura + ")")
.call (xAxis);
svg.append ("g")
.attr ("clase", "eje y")
.call (yAxis)
.append ("texto")
.attr ("transformar", "rotar (-90)")
.attr ("y", 6)
.attr ("dy", ".71em")
.style ("ancla de texto", "fin")
.text ("Población");
svg.selectAll (". bar")
.data (datos)
.enter (). append ("rect")
.attr ("clase", "barra")
.attr ("x", function (d) {return x (d.state);})
.attr ("ancho", x.rangeBand ())
.attr ("y", function (d) {return y (d.población);})
.attr ("altura", función (d) {altura de retorno - y (d.población);});
});
"" ");
No has terminado. Ahora es el momento de lanzar la representación de este gráfico D3 que

acabamos de definir. También necesita escribir los comandos necesarios para pasar los datos contenidos
en el marco de datos de Pandas a la plantilla, por lo que se pueden integrar directamente en el
Código JavaScript escrito anteriormente. La representación del código JavaScript, o más bien el
plantilla recién definida, se ejecutará iniciando la función render ().
display (Javascript (myTemplate.render (

data = states.sort_values (['POPESTIMATE2012'], ascendente = Falso) [: 10].
itertuples ()
)))
453
Página 465
El gráfico de barras aparecerá en el cuadro anterior en el que se colocó el <div>, como

se muestra en la Figura 11-5, que muestra todas las estimaciones de población para el año 2014.
Figura 11-5. Los cinco estados más poblados de los Estados Unidos representados por un
gráfico de barras relativo a 2014
Dibujar un gráfico de barras agrupadas

Hasta ahora, se ha basado ampliamente en lo que se describió en el fantástico artículo
escrito por Barto. Sin embargo, el tipo de datos que extrajo le ha dado la tendencia de
estimaciones de población en los últimos cuatro años para los Estados Unidos. Un gráfico más útil para
visualizar datos sería mostrar la tendencia de la población de cada estado a lo largo del tiempo.
Para hacer eso, una buena opción es usar un gráfico de barras agrupadas, donde cada grupo es uno
de los cinco estados más poblados y cada grupo tendrá cuatro barras para representar la
población en un año dado.
En este punto puede modificar el código anterior o escribir código nuevamente en su Jupyter
Cuaderno.
mostrar (HTML ("" "

<estilo>
.bar2011 {
relleno: azul acero;
}
454
Página 466
.bar2012 {
relleno: rojo;
}
.bar2013 {
relleno: amarillo;
}
.bar2014 {
relleno: verde;
}
.axis {
fuente: 10px sans-serif;
}
ruta del eje.
.axis line {
llenar: ninguno;
trazo: # 000;
}
.x.axis path {
pantalla: ninguna;
}
</style>
<div id = "chart_d3" />
"" "))
También debe modificar la plantilla agregando los otros tres conjuntos de datos
correspondientes a los años 2011, 2012 y 2013. Estos años estarán representados por un
color diferente en el gráfico de barras agrupadas.
importar jinja2
myTemplate = jinja2.Template ("" "
require (["d3"], function (d3) {
455
Página 467
var data = []
var data2 = []
var data3 = []
var data4 = []
{% para fila en datos%}

data.push ({'estado': '{{fila [1]}}', 'población': {{fila [2]}}});
data2.push ({'estado': '{{fila [1]}}', 'población': {{fila [3]}}});
{% endfor%}
d3.select ("# chart_d3 svg"). remove ()
var margin = {top: 20, right: 20, bottom: 30, left: 40},
ancho = 800 - margin.left - margin.right,
altura = 400 - margin.top - margin.bottom;
var x = d3.scale.ordinal ()
.rangeRoundBands ([0, ancho], .25);
var y = d3.scale.linear ()
.range ([altura, 0]);
var xAxis = d3.svg.axis ()

.escala (x)
.orient ("abajo");
var yAxis = d3.svg.axis ()

.escala (y)
.orient ("izquierda")
garrapatas (10)
.tickFormat (d3.format ('. 1s'));
var svg = d3.select ("# chart_d3"). append ("svg")

.attr ("ancho", ancho + margen.izquierda + margen.derecha)
.attr ("altura", altura + margin.top + margin.bottom)
.append ("g")
. attr ("transformar", "traducir (" + margin.left + "," +
margin.top + ")");
456
Página 468
x.domain (data.map (function (d) {return d.state;}));

y.domain ([0, d3.max (data, function (d) {return d.population;})]);
svg.append ("g")
.attr ("clase", "eje x")
.attr ("transformar", "traducir (0," + altura + ")")
.call (xAxis);
svg.append ("g")
.attr ("clase", "eje y")
.call (yAxis)
.append ("texto")
.attr ("transformar", "rotar (-90)")
.attr ("y", 6)
.attr ("dy", ".71em")
.style ("ancla de texto", "fin")
.text ("Población");
svg.selectAll (". bar2011")

.data (datos)
.attr ("clase", "bar2011")
.attr ("x", function (d) {return x (d.state);})
.attr ("ancho", x.rangeBand () / 4)

.data (data2)
.attr ("x", function (d) {return (x (d.state) + x.rangeBand () / 4);})
457
Página 469

.data (data3)
.attr ("x", function (d) {return (x (d.state) + 2 * x.rangeBand () / 4);})

.data (data4)
.attr ("x", function (d) {return (x (d.state) + 3 * x.rangeBand () / 4);})
});
"" ");
La serie de datos que se pasarán del marco de datos a la plantilla ahora son cuatro,
por lo que debe actualizar los datos y los cambios que acaba de realizar en el código.
Por lo tanto, debe volver a ejecutar el código de la función render ().
display (Javascript (myTemplate.render (

data = states.sort_values (['POPESTIMATE2014'], ascendente = Falso) [: 5].
itertuples ()
)))
Una vez que haya lanzado la función render () nuevamente, obtendrá un gráfico como el
458
Página 470
Figura 11-6. Un gráfico de barras agrupadas que representa las poblaciones de los cinco
estados poblados de 2011 a 2014
Los mapas de coropletas

En las secciones anteriores, vio cómo usar el código JavaScript y la biblioteca D3 para
representan un gráfico de barras. Bueno, estos logros hubieran sido fáciles con matplotlib
y quizás implementado de una manera aún mejor. El propósito del código anterior era
solo con fines educativos.
Algo muy diferente es el uso de vistas mucho más complejas que son
inalcanzable por matplotlib. Así que ahora pondremos en marcha el verdadero potencial creado
disponible en la biblioteca D3. Los mapas de coropletas son tipos muy complejos de
representaciones.
Los mapas de coropletas son representaciones geográficas donde las áreas terrestres son
dividido en porciones caracterizadas por diferentes colores. Los colores y los límites
entre una porción geográfica y otra son representaciones de datos.
Este tipo de representación es muy útil para representar los resultados del análisis de datos.
realizado sobre información demográfica o económica, y este es también el caso de los datos
que se correlaciona con sus distribuciones geográficas.
459
Página 471
La representación de coropletas se basa en un archivo particular llamado TopoJSON. Esta

tipo de archivo contiene toda la información interna que representa un mapa de coropletas como el
Estados Unidos (ver Figura 11-7).
Figura 11-7. La representación de un mapa coropleta de territorios de EE. UU. Sin

valor relacionado con cada condado o estado
Un buen enlace para encontrar dicho material es el Atlas TopoJSON de EE. UU. (https://github.com/
mbostock / us-atlas ), pero hay mucha literatura disponible en línea.
Una representación de este tipo no solo es posible, sino que también es personalizable. Gracias a
la biblioteca D3, puede correlacionar las porciones geográficas en función del valor de particular
columnas contenidas en un marco de datos.
Primero, comencemos con un ejemplo que ya está en Internet, en la biblioteca D3,
http://bl.ocks.org/mbostock/4060606, pero completamente desarrollado en HTML. Así que ahora lo harás
aprenda a adaptar un ejemplo de D3 en HTML en un cuaderno IPython.
Si observa el código que se muestra en la página web del ejemplo, puede ver que allí
son tres bibliotecas JavaScript necesarias. Esta vez, además de la biblioteca D3, necesitamos
para importar bibliotecas de cola y TopoJSON.
460
Página 472
<script src = "https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min.js">

</script>
<script src = "https://cdnjs.cloudflare.com/ajax/libs/queue-async/1.0.7/
queue.min.js "> </script>
<script src = "https://cdnjs.cloudflare.com/ajax/libs/topojson/1.6.19/
topojson.min.js "> </script>
Por lo tanto, debe usar require.config () como lo hizo en las secciones anteriores.
%% javascript
require.config ({
caminos: {
d3: '//cdnjs.cloudflare.com/ajax/libs/d3/3.5.5/d3.min',
cola: '//cdnjs.cloudflare.com/ajax/libs/queue-async/1.0.7/queue.min',
topojson: '//cdnjs.cloudflare.com/ajax/libs/topojson/1.6.19/
topojson.min '
}
});
La parte pertinente de CSS se muestra nuevamente, todo dentro de la función HTML ().
mostrar (HTML ("" "

<estilo>
.condados {
llenar: ninguno;
}
.states {
llenar: ninguno;
trazo: #fff;
stroke-linejoin: redondo;
}
.q0-9 {relleno: rgb (247,251,255); }

.q1-9 {relleno: rgb (222,235,247); }
.q2-9 {relleno: rgb (198,219,239); }
461
Página 473
.q3-9 {relleno: rgb (158,202,225); }

.q4-9 {relleno: rgb (107,174,214); }
.q5-9 {relleno: rgb (66,146,198); }
.q6-9 {relleno: rgb (33,113,181); }
.q7-9 {relleno: rgb (8,81,156); }
.q8-9 {relleno: rgb (8,48,107); }
</style>
<div id = "choropleth" />
"" "))
Aquí está la nueva plantilla que refleja el código que se muestra en el ejemplo de Bostock, con
algunos cambios:
importar jinja2
choropleth = jinja2.Template ("" "
require (["d3", "cola", "topojson"], función (d3, cola, topojson) {
// var data = []
// {% para fila en datos%}

// data.push ({'estado': '{{fila [1]}}', 'población': {{fila [2]}}});
// {% endfor%}
d3.select ("# choropleth svg"). remove ()
var ancho = 960,

altura = 600;
var rateById = d3.map ();
var quantize = d3.scale.quantize ()

.dominio ([0, .15])
.range (d3.range (9) .map (function (i) {return "q" + i + "-9";}));
proyección var = d3.geo.albersUsa ()

.escala (1280)
.translate ([ancho / 2, alto / 2]);
var ruta = d3.geo.path ()
462
Página 474
.projection (proyección);
// fila para modificar

var svg = d3.select ("# coropletas"). append ("svg")
.attr ("ancho", ancho)
.attr ("altura", altura);
cola()
.defer (d3.json, "us.json")
.defer (d3.tsv, "desempleo.tsv", función (d) {rateById.set (d.id,
+ d. tasa); })
.await (listo);
función lista (error, nosotros) {

si (error) arrojar error;
svg.append ("g")
.attr ("clase", "condados")
.selectAll ("ruta")
.data (topojson.feature (us, us.objects.counties) .features)
.enter (). append ("ruta")
.attr ("clase", función (d) {return quantize (rateById.get (d.id));})
.attr ("d", ruta);
svg.append ("ruta")
.datum (topojson.mesh (us, us.objects.states, function (a, b) {return a
! == b; }))
.attr ("clase", "estados")
.attr ("d", ruta);
}
});
"" ");
Ahora lanza la representación, esta vez sin ningún valor para la plantilla,
ya que todos los valores están contenidos en los archivos us.json y Employment.tsv (puede encontrar
ellos en el código fuente de este libro).
mostrar (Javascript (choropleth.render ()))
463
Página 475
Los resultados son idénticos a los que se muestran en el ejemplo de Bostock (ver Figura 11-8).
Figura 11-8. El mapa coroplético de los Estados Unidos con el color del
condados según los valores contenidos en el archivo TSV
El mapa coropleta de la población de EE. UU. En 2014

Ahora que ha visto cómo extraer información demográfica del censo de EE. UU.
Bureau y puede crear el mapa de coropletas, puede unificar ambas cosas para representar
un mapa de coropletas que muestra los valores de la población. Cuanto más poblado es el condado,
azul más profundo será. En condados con niveles de población muy bajos, el tono tenderá
hacia el blanco.
En la primera sección del capítulo, extrajo información sobre los estados por
marco de datos pop2014. Esto se hizo seleccionando las filas del marco de datos con SUMLEV
valores iguales a 40. En este ejemplo, necesita los valores de las poblaciones de
cada condado, por lo que tiene que sacar un nuevo marco de datos tomando pop2014 usando solo
líneas con SUMLEV de 50.
464
Página 476
En su lugar, debe seleccionar las filas al nivel 50.
pop2014_by_county = pop2014 [pop2014.SUMLEV == 50]

pop2014_by_county
Obtiene un marco de datos que contiene todos los condados de EE. UU., Como se muestra en la Figura 11-9 .
Figura 11-9. El marco de datos pop2014_by_county contiene todos los datos demográficos de todos
Condados de EE. UU.
Debe utilizar sus datos en lugar del TSV utilizado anteriormente. Dentro de él, están los
Números de identificación correspondientes a los distintos condados. Puede utilizar un archivo en la Web para
determinar sus nombres. Puede descargarlo y convertirlo en un marco de datos.
USJSONnames = pd.read_table ('us-county-names.tsv')

USJSONnames
465
Página 477
Gracias a este archivo, ves los códigos con los condados correspondientes
Figura 11-10. Los códigos de las provincias están contenidos en el archivo TSV
Si toma, por ejemplo, el condado de Baldwin ”
USJSONnames [USJSONnames ['name'] == 'Baldwin']
466
Página 478
Puede ver que en realidad hay dos condados con el mismo nombre, pero son
identificado por dos identificadores diferentes (Figura 11-11 ).
Figura 11-11. Hay dos condados de Baldwin
Obtienes una tabla y ves que hay dos condados y dos códigos diferentes.
Ahora ve esto en su marco de datos con datos tomados de la fuente de datos census.gov
pop2014_by_county [pop2014_by_county ['CTYNAME'] == 'Condado de Baldwin']
Figura 11-12. Los códigos de identificación en los archivos TSV corresponden a la combinación de
valores contenidos en las columnas STATE y COUNTY
Puedes reconocer que hay una coincidencia. El ID contenido en TOPOJSON coincide con el
números en las columnas STATE y COUNTY si se combinan, pero eliminando el 0
cuando es el dígito al principio del código. Entonces ahora puedes reconstruir todos los datos
necesario para replicar el ejemplo de TSV de coropletas del marco de datos de los condados. los
El archivo se guardará como población.csv.
condados = pop2014_by_county [['ESTADO', 'CONDADO', 'POPESTIMATE2014']]

counties.is_copy = Falso
condados ['id'] = condados ['ESTADO']. str.lstrip ('0') + "" +
condados ['COUNTY']
del condados ['ESTADO']
del condados ['CONDADO']
467
Página 479
counties.columns = ['pop', 'id']

condados = condados [['id', 'pop']]
condados.to_csv ('población.csv')
Ahora reescribe el contenido de la función HTML () especificando una nueva etiqueta <div>
con el ID como choropleth2.
mostrar (HTML ("" "

<estilo>
.condados {
llenar: ninguno;
}
.states {
llenar: ninguno;
trazo: #fff;
stroke-linejoin: redondo;
}
.q0-9 {relleno: rgb (247,251,255); }

.q1-9 {relleno: rgb (222,235,247); }
.q2-9 {relleno: rgb (198,219,239); }
.q3-9 {relleno: rgb (158,202,225); }
.q4-9 {relleno: rgb (107,174,214); }
.q5-9 {relleno: rgb (66,146,198); }
.q6-9 {relleno: rgb (33,113,181); }
.q7-9 {relleno: rgb (8,81,156); }
.q8-9 {relleno: rgb (8,48,107); }
</style>
<div id = "choropleth2" />
"" "))
468
Página 480
Finalmente, debe definir un nuevo objeto Plantilla.
choropleth2 = jinja2.Template ("" "
require (["d3", "cola", "topojson"], función (d3, cola, topojson) {
var data = []
d3.select ("# choropleth2 svg"). remove ()
var ancho = 960,

altura = 600;
var rateById = d3.map ();
var quantize = d3.scale.quantize ()

.dominio ([0, 1000000])
.range (d3.range (9) .map (function (i) {return "q" + i + "-9";}));
proyección var = d3.geo.albersUsa ()

.escala (1280)
.translate ([ancho / 2, alto / 2]);
var ruta = d3.geo.path ()

.projection (proyección);
var svg = d3.select ("# choropleth2"). append ("svg")
.attr ("ancho", ancho)
.attr ("altura", altura);
cola()
.defer (d3.json, "us.json")
.defer (d3.csv, "población.csv", función (d) {rateById.set (d.id,
+ d.pop); })
.await (listo);
función lista (error, nosotros) {

si (error) arrojar error;
svg.append ("g")
.attr ("clase", "condados")
.selectAll ("ruta")
.data (topojson.feature (us, us.objects.counties) .features)
469
Página 481
.enter (). append ("ruta")

.attr ("clase", función (d) {return quantize (rateById.get (d.id));})
.attr ("d", ruta);
svg.append ("ruta")
. datum (topojson.mesh (us, us.objects.states, function (a, b) {return a
! == b; }))
.attr ("clase", "estados")
.attr ("d", ruta);
}
});
"" ");
Finalmente, puede ejecutar la función render () para obtener el gráfico.
mostrar (JavaScript (choropleth2.render ()))
El mapa de coropletas se mostrará con los condados de diferentes colores según

en su población, como se muestra en la Figura 11-13 .
470
Página 482
Figura 11-13. El mapa de coropletas de los Estados Unidos muestra la densidad del
población de todos los condados
Conclusiones
En este capítulo, ha visto cómo es posible ampliar aún más la capacidad de mostrar
datos utilizando una biblioteca de JavaScript llamada D3. Los mapas de coropletas son solo uno de los muchos
ejemplos de gráficos avanzados que se utilizan para representar datos. Esto también es muy bueno
manera de ver el Jupyter Notebook en acción. El mundo no gira en torno a Python
solo, pero Python puede proporcionar capacidades adicionales para nuestro trabajo.
En el próximo capítulo, verá cómo aplicar el análisis de datos a las imágenes. Verás como
fácil es construir un modelo que pueda reconocer números escritos a mano.
471
Página 483
CAPITULO 12
Reconociendo
Dígitos escritos a mano
Hasta ahora has visto cómo aplicar las técnicas de análisis de datos a los marcos de datos de Pandas
que contiene números y cadenas. De hecho, el análisis de datos no se limita a números y
cadenas, porque las imágenes y los sonidos también se pueden analizar y clasificar.
En este breve pero no menos importante capítulo, aprenderá a escribir a mano
reconocimiento.
Reconocimiento de escritura a mano

Reconocer el texto escrito a mano es un problema que se remonta al primer
máquinas que necesitaban reconocer caracteres individuales en documentos escritos a mano.
Piense, por ejemplo, en los códigos postales de las cartas en la oficina de correos y la automatización
necesario para reconocer estos cinco dígitos. El perfecto reconocimiento de estos códigos es necesario en
ordenar el correo de forma automática y eficiente.
Entre las otras aplicaciones que pueden venir a la mente se incluye OCR (Optical
Software de reconocimiento de caracteres). El software de OCR debe leer texto escrito a mano o páginas de
libros impresos, para documentos electrónicos generales en los que cada carácter está bien definido.
Pero el problema del reconocimiento de escritura a mano se remonta más atrás en el tiempo, más
precisamente hasta principios del siglo XX (década de 1920), cuando Emanuel Goldberg (1881-1970) comenzó
sus estudios sobre este tema y sugirió que un enfoque estadístico sería una
elección óptima.
Para abordar este problema en Python, la biblioteca scikit-learn proporciona un buen ejemplo
para comprender mejor esta técnica, los problemas involucrados y la posibilidad de hacer
predicciones.
473
© Fabio Nelli 2018
Página 484
CAPÍTULO 12 RECONOCIENDO LOS DÍGITOS ESCRITOS A MANO
Reconocer dígitos escritos a mano con scikit-learn

La biblioteca scikit-learn ( http://scikit-learn.org/) le permite acercarse a esto
tipo de análisis de datos de una manera ligeramente diferente de lo que ha usado en el libro
hasta aquí. Los datos a analizar están estrechamente relacionados con valores numéricos o cadenas, pero pueden
también involucran imágenes y sonidos.
El problema que debe afrontar en este capítulo consiste en predecir un valor numérico,
y luego leer e interpretar una imagen que usa una fuente escrita a mano.
Entonces, incluso en este caso, tendrá un estimador con la tarea de aprender a través
una función de ajuste (), y una vez que ha alcanzado un grado de capacidad predictiva (un modelo
suficientemente válido), producirá una predicción con la función predict (). Luego lo haremos
discuta el conjunto de entrenamiento y el conjunto de validación, creado esta vez a partir de una serie de imágenes.
Ahora abra una nueva sesión de IPython Notebook desde la línea de comando ingresando el
siguiente comando:
cuaderno ipython
Luego cree un nuevo Cuaderno eligiendo Nuevo ➤ Python 3, como se muestra en la Figura 12-1 .
Figura 12-1. La página de inicio de IPython Notebook (Jupyter)
474
Página 485
Un estimador útil en este caso es sklearn.svm.SVC, que utiliza la técnica

de Clasificación de vectores de soporte (SVC).
Por lo tanto, debe importar el módulo svm de la biblioteca scikit-learn. Puedes crear
un estimador de tipo SVC y luego elegir un ajuste inicial, asignando los valores C y
valores genéricos de gamma. Estos valores se pueden ajustar de una manera diferente durante la
curso del análisis.

svc = svm.SVC (gamma = 0.001, C = 100.)
El conjunto de datos de dígitos

Como viste en el capítulo 8 , la biblioteca scikit-learn proporciona numerosos conjuntos de datos que son
útil para probar muchos problemas de análisis de datos y predicción de los resultados. También en
en este caso hay un conjunto de datos de imágenes llamado Digits .
Este conjunto de datos consta de 1797 imágenes que tienen un tamaño de 8x8 píxeles. Cada imagen es una
dígito escrito a mano en escala de grises, como se muestra en la Figura 12-2 .
Figura 12-2. Una de las 1797 imágenes numéricas escritas a mano que componen el conjunto de datos
dígito
475
Página 486
Por lo tanto, puede cargar el conjunto de datos Digits en su computadora portátil.

dígitos = conjuntos de datos.load_digits ()
Después de cargar el conjunto de datos, puede analizar el contenido. Primero, puedes leer muchos
información sobre los conjuntos de datos llamando al atributo DESCR.
imprimir (dígitos.DESCR)
Para una descripción textual del conjunto de datos, los autores que contribuyeron a su creación
y las referencias aparecerán como se muestra en la Figura 12-3.
Figura 12-3. Cada conjunto de datos de la biblioteca scikit-learn tiene un campo que contiene todos los
información
476
Página 487
Las imágenes de los dígitos escritos a mano están contenidas en una matriz digits.images. Cada
El elemento de esta matriz es una imagen que está representada por una matriz de 8x8 de valores numéricos.
que corresponden a una escala de grises desde el blanco, con un valor de 0, hasta el negro, con el valor de 15.
digits.images [0]
Obtendrá el siguiente resultado:
matriz ([[0., 0., 5., 13., 9., 1., 0., 0.],

[0., 0., 13., 15., 10., 15., 5., 0.],
[0., 3., 15., 2., 0., 11., 8., 0.],
[0., 4., 12., 0., 0., 8., 8., 0.],
[0., 5., 8., 0., 0., 9., 8., 0.],
[0., 4., 11., 0., 1., 12., 7., 0.],
[0., 2., 14., 5., 10., 12., 0., 0.],
[0., 0., 6., 13., 10., 0., 0., 0.]])
Puede verificar visualmente el contenido de este resultado utilizando la biblioteca matplotlib.

plt.imshow (digits.images [0], cmap = plt.cm.gray_r, interpolation = 'más cercano')
Al ejecutar este comando, obtendrá la imagen en escala de grises que se muestra en

Figura 12-4.
Figura 12-4. Uno de los 1797 dígitos escritos a mano
477
Página 488
Los valores numéricos representados por imágenes, es decir, los objetivos, están contenidos en el
matriz digit.targets.
digits.target
Obtendrá el siguiente resultado:
matriz ([0, 1, 2, ..., 8, 9, 8])
Se informó que el conjunto de datos es un conjunto de entrenamiento que consta de 1797 imágenes. Usted puede
determinar si eso es cierto.
digits.target.size
Este será el resultado:
1797
Aprender y predecir
Ahora que ha cargado los conjuntos de datos Digits en su computadora portátil y ha definido un
Estimador SVC, puedes empezar a aprender.
Como aprendiste en el capítulo 8, una vez que defina un modelo predictivo, debe instruirlo
con un conjunto de entrenamiento, que es un conjunto de datos en el que ya conoce la clase a la que pertenece.
Dada la gran cantidad de elementos contenidos en el conjunto de datos Digits, seguramente
obtener un modelo muy efectivo, es decir, uno que sea capaz de reconocer con certeza
el número escrito a mano.
Este conjunto de datos contiene 1797 elementos, por lo que puede considerar los primeros 1791 como un
conjunto de entrenamiento y utilizará los últimos seis como conjunto de validación.
Puede ver en detalle estos seis dígitos escritos a mano utilizando la biblioteca matplotlib:

subparcela plt. (321)

plt.imshow (digits.images [1791], cmap = plt.cm.gray_r,
interpolación = 'más cercano')
478
Página 489

plt. subparcela (324)
subplot plt. (326)
Esto producirá una imagen con seis dígitos, como se muestra en la Figura 12-5 .
Figura 12-5. Los seis dígitos del conjunto de validación
479
Página 490
Ahora puede entrenar el estimador svc que definió anteriormente.
svc.fit (digits.data [1: 1790], digits.target [1: 1790])
Después de un breve período de tiempo, aparecerá el estimador entrenado con salida de texto.
SVC (C = 100.0, cache_size = 200, class_weight = Ninguno, coef0 = 0.0, grado = 3,

gamma = 0.001, kernel = 'rbf', max_iter = -1, probabilidad = False,
random_state = None, shrinking = True, tol = 0.001, verbose = False)
Ahora tienes que probar tu estimador, haciéndolo interpretar los seis dígitos del
conjunto de validación.
svc.predict (dígitos.datos [1791: 1976])
Obtendrás estos resultados:
matriz ([4, 9, 0, 8, 9, 8])
Si los compara con los dígitos reales, de la siguiente manera:
digits.target [1791: 1976]
matriz ([4, 9, 0, 8, 9, 8])
Puede ver que el estimador svc ha aprendido correctamente. Es capaz de reconocer el

dígitos escritos a mano, interpretando correctamente los seis dígitos del conjunto de validación.
Reconocimiento de dígitos escritos a mano con TensorFlow

Acaba de ver un ejemplo de cómo las técnicas de aprendizaje automático pueden reconocer
números escritos a mano. Ahora se aplicará el mismo problema al aprendizaje profundo
técnicas que usamos en el capítulo 9.
Dado el gran valor del conjunto de datos MNIST, la biblioteca TensorFlow también contiene una
copia de ella. Por tanto, será realmente fácil realizar estudios y pruebas en redes neuronales.
con este conjunto de datos, sin tener que descargarlos o importarlos de otras fuentes de datos.
Importar el conjunto de datos MNIST a Jupyter Notebook (en cualquier sesión de Python) es
muy simple; solo importa tensorflow.contrib.learn.python.learn.datasets.
mnist directamente como cualquier otro paquete de Python. Para cargar el conjunto de datos en una variable, debe
use la función read_data_sets (). Por lo tanto, una forma óptima para importar el conjunto de datos es
como sigue.
480
Página 491
de tensorflow.contrib.learn.python.learn.datasets.mnist importar read_data_

conjuntos
Dado que el conjunto de datos está contenido en archivos comprimidos, estos serán automáticamente
descargado al espacio de trabajo de la sesión tan pronto como llame a la función read_data_sets.
Una buena práctica es crear un directorio que los contenga como MNIST_data.
mnist = read_data_sets ("MNIST_data /", one_hot = False)
En la salida, los archivos descargados se mostrarán de la siguiente manera:
Extrayendo MNIST_data / train-images-idx3-ubyte.gz
Extrayendo MNIST_data / train-labels-idx1-ubyte.gz
Extrayendo MNIST_data / t10k-images-idx3-ubyte.gz
Extrayendo MNIST_data / t10k-labels-idx1-ubyte.gz
Los datos de MNIST se dividen en tres partes: 55.000 puntos de datos de datos de entrenamiento (mnist.
train), 10,000 puntos de datos de prueba (mnist.test) y 5,000 puntos de datos de validación
(validación de mnist).
Dado el gran tamaño de este conjunto de datos, una buena práctica es dividirlo en lotes más pequeños,
especialmente cuando necesita ser analizado como un conjunto de entrenamiento. Para ayudarte a hacer esto, TensorFlow
utiliza la función next_batch (n), que le permite extraer n elementos del
conjunto de entrenamiento. Siempre que se llame a la función next_batch (n), los n elementos siguientes
se extraerán, hasta que se alcance el final del conjunto de entrenamiento.
Para ver los primeros 10 elementos del conjunto de entrenamiento, ingrese el siguiente código.
píxeles, valores_real = mnist.train.next_batch (10)

print ("lista de valores cargados", real_values)
lista de valores cargados [2 6 8 3 4 2 0 9 8 7]
Al publicar el mismo código, obtendrá los siguientes 10 elementos del conjunto de entrenamiento,
y así.
píxeles, valores_real = mnist.train.next_batch (10)

print ("lista de valores cargados", real_values)
lista de valores cargados [6 1 8 5 0 1 8 4 7 3]
481
Página 492
Si desea ver la imagen del dígito manuscrito de uno de los elementos

contenido en píxeles (una matriz que contiene imágenes en escala de grises), puede usar matplotlib.
imagen = np.reshape (píxeles [1,:], [28,28])

plt.imshow (imagen, cmap = plt.cm.gray_r, interpolación = 'más cercano')
plt.show ()
Obtendrá la imagen en blanco y negro de un número escrito a mano similar al

Figura 12-6. Un dígito del conjunto de entrenamiento en el conjunto de datos MNIST proporcionado por el
Biblioteca de TensorFlow
Aprender y predecir
Ahora que ha visto cómo obtener el conjunto de entrenamiento, el conjunto de pruebas y el conjunto de validación
con TensorFlow, es hora de hacer un análisis con una red neuronal muy similar a la
que usaste en el Capítulo 9.
de tensorflow.examples.tutorials.mnist importar input_data

mnist = input_data.read_data_sets ("MNIST_data /", one_hot = True)
importar tensorflow como tf

482
Página 493
# Parámetros
tasa_de_aprendizaje = 0.01
training_epochs = 25
tamaño_lote = 100
display_step = 1
# tf Entrada de gráfico
x = tf.placeholder ("float", [None, 784]) # mnist imagen de datos de forma
28 * 28 = 784
y = tf.placeholder ("float", [None, 10]) # 0-9 dígitos de reconocimiento => 10 clases
# Crear modelo
# Establecer pesos de modelo

W = tf.Variable (tf.zeros ([784, 10]))
b = tf.Variable (tf.zeros ([10]))
evidencia = tf.matmul (x, W) + b
# Construir modelo
activación = tf.nn.softmax (evidencia) # Softmax
# Minimizar el error usando entropía cruzada

cross_entropy = y * tf.log (activación)
costo = tf.reduce_mean (-tf.reduce_sum (cross_entropy, reducciones_indices = 1))
optimizador = tf.train.GradientDescentOptimizer (tasa de aprendizaje) .minimize (costo)
# Configuración de parcela
avg_set = []
epoch_set = []
# Inicializando las variables

init = tf.global_variables_initializer ()
# Lanzar el gráfico
con tf.Session () como sess:
sess.run (init)
# Ciclo formativo
para la época en el rango (training_epochs):
483
Página 494
avg_cost = 0.
total_batch = int (mnist.train.num_examples / batch_size)
# Bucle sobre todos los lotes
para i en el rango (total_batch):
batch_xs, batch_ys = mnist.train.next_batch (tamaño_lote)
sess.run (optimizador, feed_dict = {x: batch_xs, y: batch_ys})
avg_cost + = sess.run (cost, feed_dict = {x: batch_xs, y: batch_
ys}) / total_batch
si epoch% display_step == 0:
print ("Época:", '% 04d'% (época + 1), "costo =", "{: .9f}".
formato (avg_cost))
avg_set.append (avg_cost)
epoch_set.append (época + 1)
imprimir ("Fase de formación finalizada")
plt.plot (epoch_set, avg_set, 'o', label = 'Entrenamiento de regresión logística

fase')
plt.ylabel ('costo')
plt.xlabel ('época')
plt.legend ()
plt.show ()
# Modelo de prueba
predicción_correcta = tf.equal (tf.argmax (activación, 1), tf.argmax (y, 1))
# Calcular la precisión
precisión = tf.reduce_mean (tf.cast (correct_prediction, "flotar"))
print ("Precisión del modelo:", precision.eval ({x: mnist.test.images, y: mnist.
test.labels}))
Al realizar el análisis, obtendrá la tendencia de costos durante la fase de aprendizaje

(ciclo de época) y cuando la red neuronal reciba las instrucciones adecuadas, la prueba
set mnist.test será evaluado. El valor de la precisión obtenida le dirá el
porcentaje de números leídos e interpretados correctamente por la red neuronal.
484
Página 495
Extrayendo MNIST_data / train-images-idx3-ubyte.gz

Extrayendo MNIST_data / train-labels-idx1-ubyte.gz
Extrayendo MNIST_data / t10k-images-idx3-ubyte.gz
Extrayendo MNIST_data / t10k-labels-idx1-ubyte.gz
Época: 0001 costo = 1.176361134
Época: 0002 costo = 0.662538510
Época: 0003 costo = 0.550689667
Época: 0004 costo = 0.496738935
Época: 0005 costo = 0.463713668
Época: 0006 costo = 0.440845339
Época: 0007 costo = 0.423968329
Época: 0008 costo = 0.410662182
Época: 0009 costo = 0.399876185
Época: 0010 costo = 0.390923975
Época: 0011 costo = 0.383305770
Época: 0012 costo = 0.376747700
Época: 0013 costo = 0.371062683
Época: 0014 costo = 0.365925885
Época: 0015 costo = 0.361331244
Época: 0016 costo = 0.357197133
Época: 0017 costo = 0.353523670
Época: 0018 costo = 0.350157993
Época: 0019 costo = 0.347037680
Época: 0020 costo = 0.344143576
Época: 0021 costo = 0.341464736
Época: 0022 costo = 0.338996708
Época: 0023 costo = 0.336639690
Época: 0024 costo = 0.334515039
Época: 0025 costo = 0.332482831
Precisión del modelo: 0,9143
A partir de los datos obtenidos, y observando la Figura 12-7 , puede ver que el aprendizaje
La fase de la red neuronal se ha completado y tiene una tendencia esperada.
El valor de precisión de 0,91 (91%) indica que el modelo que eligió funciona bastante
satisfactoriamente (no completamente).
485
Página 496
Figura 12-7. La tendencia de los costos durante la fase de aprendizaje de la red neuronal
Conclusiones
En este breve capítulo, aprendió cuántas posibilidades de aplicación este análisis de datos
proceso tiene. No se limita solo al análisis de datos numéricos o textuales, sino que también puede
analizar imágenes, como los dígitos escritos a mano leídos por una cámara o un escáner.
Además, ha visto que los modelos predictivos pueden proporcionar
resultados gracias al aprendizaje automático y las técnicas de aprendizaje profundo, que se
implementado gracias a la biblioteca scikit-learn.
486
Página 497
CAPITULO 13
Análisis de datos textuales

con NLTK
En este libro, ha visto varias técnicas de análisis y numerosos ejemplos
que trabajó en datos en forma numérica o tabular, que se procesa fácilmente a través de
expresiones matemáticas y técnicas estadísticas. Pero la mayor parte de los datos se componen
de texto, que responde a reglas gramaticales (oa veces ni siquiera eso :)) que difieren
de un idioma a otro. En el texto, las palabras y los significados atribuibles a las palabras
(así como las emociones que transmiten) puede ser una fuente de información muy útil.
En este capítulo, aprenderá sobre algunas técnicas de análisis de texto que utilizan NLTK
(Kit de herramientas de lenguaje natural), que le permitirá realizar
operaciones. Además, los temas tratados le ayudarán a comprender este importante
parte del análisis de datos.
Técnicas de análisis de texto

En los últimos años, con la llegada del Big Data y la inmensa cantidad de datos textuales
provenientes de Internet, muchas técnicas de análisis de texto han sido desarrolladas por
necesidad. De hecho, esta forma de datos puede ser muy difícil de analizar, pero al mismo tiempo
representa una fuente de mucha información útil, dada también la enorme disponibilidad
de datos. Basta pensar en toda la literatura producida, las numerosas publicaciones publicadas en el
Internet, por ejemplo. Los comentarios en las redes sociales y los chats también pueden ser una gran
fuente de datos, especialmente para comprender el grado de aprobación o desaprobación de un
tema en particular.
487
© Fabio Nelli 2018
Página 498
CAPÍTULO 13 ANÁLISIS DE DATOS TEXTUALES CON NLTK
El análisis de estos textos se ha convertido, por tanto, en una fuente de enorme interés, y
Hay muchas técnicas que se han introducido para este propósito, creando un verdadero
disciplina en sí misma. Algunas de las técnicas más importantes son las siguientes:
• Análisis de la distribución de frecuencia de palabras
• Reconocimiento de patrones
• Etiquetado
• Análisis de enlaces y asociaciones
• Análisis de los sentimientos
El kit de herramientas de lenguaje natural (NLTK)

Si programa en Python y desea analizar datos en forma de texto, uno de los
Las herramientas más utilizadas en este momento son Python Natural Language Toolkit (NLTK).
NLTK no es más que una biblioteca de Python (https://www.nltk.org/ ) en el que
Existen muchas herramientas especializadas en el procesamiento y análisis de datos de texto. NLTK fue creado
en 2001 con fines educativos, luego, con el tiempo, se desarrolló hasta tal punto que
se convirtió en una verdadera herramienta de análisis.
Dentro de la biblioteca NLTK, también hay una gran colección de textos de muestra, llamada
corpora . Esta colección de textos está tomada en gran parte de la literatura y es muy útil como
una base para la aplicación de las técnicas desarrolladas con la librería NLTK. En
En particular, se utiliza para realizar pruebas (una función similar al conjunto de datos MNIST presente en
TensorFlow, que se analiza en el capítulo 9).
Instalar NLTK en su computadora es una operación muy simple. Siendo un muy popular
Biblioteca de Python, simplemente necesita instalarla usando pip o conda.
En sistemas Linux, use esto:
pip instalar nltk
En sistemas Windows (a través de Anaconda), use esto:
conda install nltk
488
Página 499
Importar la biblioteca NLTK y la herramienta de descarga NLTK

Para tener más confianza con NLTK, no hay mejor método que trabajar
directamente con el código Python. De esta forma podrá ver y gradualmente
comprender el funcionamiento de esta biblioteca.
Entonces, lo primero que debe hacer es abrir una sesión en IPython o en un Jupyter
Cuaderno. El primer comando importa la biblioteca NLTK.
importar nltk
Entonces necesitas importar texto de la colección corpora. Para hacer esto hay un
función llamada nltk.download_shell (), que abre una herramienta llamada NLTK Downloader
que le permite realizar selecciones a través de una selección guiada de opciones.
Si ingresa este comando en la terminal:
nltk.download_shell ()
Verá las distintas opciones en formato de texto.
Descargador NLTK
-------------------------------------------------- -------------------------
d) Descargar l) Listar u) Actualizar c) Configurar h) Ayuda q) Salir
-------------------------------------------------- -------------------------
Descargador>
Ahora la herramienta está esperando una opción. Si desea ver una lista de posibles NLTK
extensiones, ingrese L para la lista y presione Enter. Inmediatamente verá una lista de todos los
posibles paquetes pertenecientes a NLTK que puede descargar para ampliar la funcionalidad
de NLTK, incluidos los textos de la colección corpora.
Paquetes:
[] abc ................. Comisión Australiana de Radiodifusión 2006
[] alpino .............. Alpino Dutch Treebank
[] averaged_perceptron_tagger Etiquetador de perceptrón promedio
[] averaged_perceptron_tagger_ru Averaged Perceptron Tagger (ruso)
[] basque_grammars ..... Gramáticas para euskera
[] biocreative_ppi ..... BioCreAtIvE (Evaluación crítica de la información
Sistemas de extracción en biología)
[] bllip_wsj_no_aux .... Analizador BLLIP: Modelo WSJ
489
Página 500
[] book_grammars ....... Grammars from NLTK Book

[] marrón ............... Brown Corpus
[] brown_tei ........... Brown Corpus (Versión XML TEI)
[] cess_cat ............ CESS-CAT Treebank
[] cess_esp ............ CESS-ESP Treebank
[] chat80 .............. Chat-80 Archivos de datos
[] city_database ....... Base de datos de ciudades
[] cmudict ............. Diccionario de pronunciación Carnegie Mellon (0.6)
[] comparative_sentences Conjunto de datos de oraciones comparativas
[] comtrans ............ ComTrans Corpus Sample
[] conll2000 ........... CONLL 2000 Chunking Corpus
[] conll2002 ........... CONLL 2002 Corpus de reconocimiento de entidades designadas
Presiona Enter para continuar:
Presionando Enter nuevamente continuará mostrando la lista mostrando otros paquetes en

orden alfabetico. Presione Enter hasta que la lista esté terminada para ver todos los paquetes posibles. A
Al final de la lista, volverán a aparecer las diferentes opciones iniciales del NLTK Downloader.
Para poder crear una serie de ejemplos para aprender sobre la biblioteca, necesita una serie
de textos para trabajar. Una excelente fuente de textos adecuados para este propósito es el Gutenberg
corpus, presente dentro de la colección corpora. El corpus de Gutenberg es una pequeña selección
de textos extraídos del archivo electrónico denominado Proyecto Gutenberg (http: // www.
gutenberg.org/). Hay más de 25.000 libros electrónicos en este archivo.
Para descargar este paquete, primero ingrese la opción d para descargarlo. La herramienta preguntará
usted por el nombre del paquete, entonces ingrese el nombre gutenberg.
-------------------------------------------------- -------------------------
d) Descargar l) Listar u) Actualizar c) Configurar h) Ayuda q) Salir
-------------------------------------------------- -------------------------
Descargador> d
¿Descargar qué paquete (l = lista; x = cancelar)?

Identificador> gutenberg
En este punto, el paquete comenzará a descargarse.
490
Página 501
Para las siguientes horas, si ya conoce el nombre del paquete que desea
descargar, simplemente ingrese el comando nltk.download () con el nombre del paquete como
argumento. Esto no abrirá la herramienta NLTK Downloader, pero descargará directamente el
paquete requerido. Entonces la operación anterior equivale a escribir:
nltk.download ('gutenberg')
Una vez completado, puede ver el contenido del paquete gracias a los fileids ()
función, que muestra los nombres de los archivos que contiene.
gb = nltk.corpus.gutenberg
print ("Archivos Gutenberg:", gb.fileids ())
Aparecerá una matriz en la terminal con todos los archivos de texto contenidos en el gutenberg
paquete.
Archivos de Gutenberg: ['austen-emma.txt', 'austen-persuasion.txt', 'austen-

sense.txt ',' bible-kjv.txt ',' blake-poems.txt ',' bryant-stories.txt ',
'burgess-busterbrown.txt', 'carroll-alice.txt', 'chesterton-ball.txt',
'chesterton-brown.txt', 'chesterton-thursday.txt', 'edgeworth-parents.txt',
'melville-moby_dick.txt', 'milton-paradise.txt', 'shakespeare-caesar.txt',
'shakespeare-hamlet.txt', 'shakespeare-macbeth.txt', 'whitman-leaves.txt']
Para acceder al contenido interno de uno de estos archivos, primero seleccione uno, por ejemplo
Macbeth de Shakespeare (shakespeare-macbeth.txt), y luego asignarlo a una variable
de conveniencia. Un modo de extracción es para palabras, es decir, desea crear una matriz
que contiene palabras como elementos. En este sentido, debe utilizar la función words ().
macbeth = nltk.corpus.gutenberg.words ('shakespeare-macbeth.txt')
Si desea ver la longitud de este texto (en palabras), puede usar la función len ().
len (macbeth)
23140
Por tanto, el texto utilizado para estos ejemplos está compuesto por 23140 palabras.
La variable macbeth que creamos es una matriz larga que contiene las palabras del texto.
Por ejemplo, si desea ver las primeras 10 palabras del texto, puede escribir lo siguiente
mando.
491
Página 502
macbeth [: 10]
['[',
'Los',
'Tragedie',
'de',
'Macbeth',
'por',
'Guillermo',
'Shakespeare',
'1603',
']']
Como puede ver, las primeras 10 palabras contienen el título de la obra, pero también el cuadrado
corchetes, que indican el comienzo y el final de una oración. Si hubiera usado el
modo de extracción de oraciones con la función sents (), habría obtenido una
matriz estructurada, con cada oración como un elemento. Estos elementos, a su vez, serían
matrices con palabras para elementos.
macbeth_sents = nltk.corpus.gutenberg.sents ('shakespeare-macbeth.txt')

macbeth_sents [: 5]
[['[',
'Los',
'Tragedie',
'de',
'Macbeth',
'por',
'Guillermo',
'Shakespeare',
'1603',
']'],
['Actus', 'Primus', '.'],
['Scoena', 'Prima', '.'],
['Truenos y relámpagos', '.'],
['Entrar', 'tres', 'Brujas', '.']]
492
Página 503
Busque una palabra con NLTK

Una de las cosas más básicas que debe hacer cuando tiene un corpus NLTK (es decir, un
conjunto de palabras extraídas de un texto) es investigar dentro de él. El concepto de investigación es
ligeramente diferente a lo que estás acostumbrado.
La función concordance () busca todas las apariciones de una palabra pasada como
argumento dentro de un corpus.
La primera vez que ejecute este comando, el sistema tardará varios segundos en volver
un resultado. Los tiempos posteriores serán más rápidos. De hecho, la primera vez que este comando es
ejecutado en un corpus crea una indexación del contenido para realizar la búsqueda, que
una vez creado se utilizará en convocatorias posteriores. Esto explica por qué el sistema necesita más
tiempo la primera vez.
Primero, asegúrese de que el corpus sea un objeto nltk.Text, y luego busque internamente
para la palabra 'Etapa'.
texto = nltk.Text (macbeth)

text.concordance ('Etapa')
Mostrando 3 de 3 coincidencias:
nts con platos y servicio ouer el escenario. Luego ingrese Macbeth Macb. Si
esto nosotros
con el acto del hombre, amenaza su sangrienta etapa: por el 'Reloj' este día, y
aún d
se pavonea y se inquieta sobre el escenario, y luego no se oye más. Eso
es
Ha obtenido tres apariciones diferentes del texto.

Otra forma de buscar una palabra presente en NLTK es la de contexto. Eso es el
palabra anterior y la palabra siguiente a la que está buscando. Para hacer esto, debes usar
la función common_contexts ().
text.common_contexts (['Etapa'])
el_ sangriento_: el_,
Si observa los resultados de la investigación anterior, puede ver que los tres resultados
corresponden a lo dicho.
Una vez que comprenda cómo NLTK concibe el concepto de la palabra y su contexto
durante la búsqueda, será fácil comprender el concepto de sinónimo. Eso es
Se supone que todas las palabras que tienen el mismo contexto pueden ser sinónimos. A
493
Página 504
buscar todas las palabras que tienen el mismo contexto que la buscada, debe utilizar la
función similar ().
text.similar ('Etapa')
fogge ayre sangrando reuolt buena muestra heeles skie otro mar miedo
consecuencia corazón cerebro seruice herbenger dama ronda deed doore
Estos métodos de investigación pueden parecer bastante extraños para aquellos que no se utilizan
procesar y analizar texto, pero pronto comprenderá que estos métodos de
investigación se adaptan perfectamente a las palabras y su significado en relación con el texto en
que están presentes.
Analizar la frecuencia de las palabras

Uno de los ejemplos más simples y básicos para el análisis de un texto es calcular la
frecuencia de las palabras que contiene. Esta operación es tan común que ha sido
incorporado en una única función nltk.FreqDist () a la que la variable que contiene
la matriz de palabras se pasa como argumento.
Entonces, para obtener una distribución estadística de todas las palabras del texto, deberá ingresar un
comando simple.
fd = nltk.FreqDist (macbeth)
Si desea ver las primeras 10 palabras más comunes del texto, puede usar la
función most_common ().
fd.most_common (10)
[(',', 1962),
('.', 1235),
("'", 637),
('el', 531),
(':', 477),
('y', 376),
('Yo', 333),
('de', 315),
('a', 311),
('?', 241)]
494
Página 505
Del resultado obtenido se puede ver que los elementos más comunes son
puntuación, preposiciones y artículos, y esto se aplica a muchos idiomas, incluidos
Inglés. Dado que estos tienen poco significado durante el análisis de texto, a menudo es necesario
eliminarlos. Se denominan palabras vacías .
Las palabras vacías son palabras que tienen poco significado en el análisis y deben filtrarse.
No existe una regla general para determinar si una palabra es una palabra de parada (para eliminar) o
no. Sin embargo, la biblioteca NLTK viene al rescate proporcionándole una variedad de
palabras vacías preseleccionadas. Para descargar palabras irrelevantes, puede utilizar nltk.download ()
mando.
nltk.download ('palabras vacías')
Una vez que haya descargado todas las palabras irrelevantes, puede seleccionar solo las relacionadas con
Inglés, guardándolos en una variable sw.
sw = set (nltk.corpus.stopwords.words ('inglés'))

imprimir (len (sw))
lista (sw) [: 10]
179
['mediante',
'son',
'que',
'ni',
'ain',
"no",
'no',
"no",
'abajo',
'nuestro']
Hay 179 palabras vacías en el vocabulario inglés según NLTK. Ahora usted puede
utilice estas palabras vacías para filtrar la variable macbeth.
macbeth_filtered = [w para w en macbeth si w.lower () no en sw]

fd = nltk.FreqDist (macbeth_filtered)
fd.most_common (10)
[(',', 1962),
495
Página 506
('.', 1235),
("'", 637),
(':', 477),
('?', 241),
('Macb', 137),
('haue', 117),
('-', 100),
('Entrar', 80),
('tú', 63)]
Ahora que se devuelven las primeras 10 palabras más comunes, puede ver que el
Se han eliminado las palabras vacías, pero el resultado aún no es satisfactorio. De hecho,
la puntuación todavía está presente en las palabras. Para eliminar toda la puntuación, puede cambiar
el código anterior insertando en el filtro una matriz de puntuación que contiene la
símbolos de puntuación. Esta matriz de puntuación se puede obtener importando la cadena
función.
importar cadena
puntuacion = set (string.punctuation)
macbeth_filtered2 = [w.lower () para w en macbeth si w.lower () no en sw
y w.lower () sin puntuación]
Ahora puede volver a calcular la distribución de frecuencia de las palabras.
fd = nltk.FreqDist (macbeth_filtered2)
fd.most_common (10)
[('macb', 137),
('haue', 122),
('tú', 90),
('entrar', 81),
('deberá', 68),
('macbeth', 62),
('vpon', 62),
('tú', 61),
('macd', 58),
('vs', 57)]
Finalmente, el resultado es lo que estabas buscando.
496
Página 507
Selección de palabras del texto

Otra forma de procesamiento y análisis de datos es el proceso de selección de palabras contenidas
en un cuerpo de texto basado en características particulares. Por ejemplo, podrías ser
interesado en extraer palabras en función de su longitud.
Para obtener todas las palabras más largas, por ejemplo, palabras que tengan más de 12 caracteres,
ingresa el siguiente comando.
long_words = [w por w en macbeth si len (w)> 12]
Todas las palabras de más de 12 caracteres se han introducido en la variable long_words.

Puede enumerarlos en orden alfabético utilizando la función sort ().
ordenado (palabras_largas)
['Asesinato',
'Chamberlaines',
'Distingue',
'Gallowgrosses',
'Metafísica',
'Northumberland',
'Voluptuousnesse',
'elogios',
'multitudinario',
'supernaturall',
'vnaccompanied']
Como puede ver, hay 11 palabras que cumplen con este criterio.
Otro ejemplo es buscar todas las palabras que contienen una determinada secuencia de
caracteres, como 'ious'. Solo tiene que cambiar la condición en el bucle for in para
obtenga la selección deseada.
ious_words = [w por w en macbeth si 'ious' en w]

ious_words = conjunto (ious_words)
ordenado (ious_words)
['Auaricious',
'Cortés',
'Industrioso',
'Juicioso',
497
Página 508
'Lujoso',
'Malicioso',
'Obliuious',
'Piadoso',
'Rebelde',
'escrupuloso',
'furioso',
'Cortés',
'pernicioso',
'pernicioso',
'piadoso',
'precioso',
'rebelde',
'sacrílego',
'grave',
'espacioso',
'tedioso']
En este caso, usó sort () para hacer una conversión de lista, de modo que no contenga
palabras duplicadas.
Estos dos ejemplos son solo un punto de partida para mostrarle el potencial de esta herramienta y
la facilidad con la que puede filtrar palabras.
Bigrams y colocaciones
Otro elemento básico del análisis de texto es considerar pares de palabras ( bigramas ) en su lugar
de palabras sueltas. Las palabras "es" y "amarillo" son, por ejemplo, un bigrama, ya que su
la combinación es posible y significativa. Entonces, "es amarillo" se puede encontrar en datos textuales. Nosotros
Todos sabemos que algunos de estos bigramas son tan comunes en nuestra literatura que son casi
siempre se utilizan juntos. Los ejemplos incluyen "comida rápida", "preste atención", "buenos días" y
pronto. Estos bigramas se denominan colocaciones .
El análisis textual también puede involucrar la búsqueda de bigramas dentro del texto bajo
examen. Para encontrarlos, simplemente use la función bigrams (). Para excluir
palabras vacías y puntuación de los bigramas, debe usar el conjunto de palabras ya
filtrado previamente, como macbeth_filtered2.
498
Página 509
bgrms = nltk.FreqDist (nltk.bigrams (macbeth_filtered2))

bgrms.most_common (15)
[(('entrar', 'macbeth'), 16),
(('exeunt', 'scena'), 15),
(('thane', 'cawdor'), 13),
(('toc', 'toc'), 10),
(('st', 'tú'), 9),
(('tú', 'eres'), 9),
(('señor', 'macb'), 9),
(('haue', 'hecho'), 8),
(('macb', 'haue'), 8),
(('bueno', 'señor'), 8),
(('dejar', 'vs'), 7),
(('entrar', 'dama'), 7),
(('pipí', 'l'), 7),
(('haría', 'st'), 6),
(('macbeth', 'macb'), 6)]
Al mostrar los bigramas más comunes en el texto, se pueden encontrar ubicaciones lingüísticas.
Además de los bigramas, también puede haber ubicaciones basadas en trigramas, que
son combinaciones de tres palabras. En este caso, se utiliza la función trigrams ().
tgrms = nltk.FreqDist (nltk.trigrams (macbeth_filtered2))

tgrms.most_common (10)
[(('toc', 'toc', 'toc'), 6),
(('entrar', 'macbeth', 'macb'), 5),
(('entrar', 'tres', 'brujas'), 4),
(('exeunt', 'scena', 'secunda'), 4),
(('bueno', 'señor', 'macb'), 4),
(('tres', 'brujas', '1'), 3),
(('exeunt', 'scena', 'tertia'), 3),
(('trueno', 'entrar', 'tres'), 3),
(('exeunt', 'scena', 'quarta'), 3),
(('scena', 'prima', 'enter'), 3)]
499
Página 510
Usar texto en la red

Hasta ahora has visto una serie de ejemplos que usan texto ya ordenado e incluido
(llamado corpus) dentro de la biblioteca NLTK como gutenberg. Pero en realidad, necesitarás
acceder a Internet para extraer el texto y recopilarlo como un corpus que se utilizará para el análisis
con NLTK.
En esta sección, verá lo simple que es este tipo de operación. Primero, necesitas
importar una biblioteca que le permita conectarse al contenido de las páginas web. El urllib
biblioteca es un excelente candidato para este propósito, ya que le permite descargar el texto
contenido de Internet, incluidas páginas HTML.
Primero importa la función request (), que se especializa en este tipo de
operación, desde la biblioteca urllib.
desde la solicitud de importación urllib
Luego tienes que escribir la URL de la página que contiene el texto a extraer.
Aún refiriéndose al proyecto de Gutenberg, puede elegir, por ejemplo, un libro escrito por
Dostoievski ( http://www.gutenberg.org). En el sitio hay texto en diferentes formatos; a
en este punto elegiremos el que está en formato raw (.txt).
url = "http://www.gutenberg.org/files/2554/2554-0.txt"
respuesta = request.urlopen (url)
raw = respuesta.read (). decode ('utf8')
Dentro del texto sin formato está todo el contenido textual del libro, descargado del
Internet. Siempre verifique el contenido de lo que ha descargado. Para hacer esto, los primeros 75
los personajes son suficientes.
crudo [: 75]
'\ ufeffThe Project Gutenberg EBook of Crime and Punishment, por Fyodor
Dostoievski \ r '
Como puede ver, estos caracteres corresponden al título del texto. Vemos eso
también hay un error en la primera palabra del texto. De hecho existe el carácter Unicode
BOM \ ufeff. Esto sucedió porque usamos el sistema de decodificación utf8, que es válido
en la mayoría de los casos, pero no en este caso. El sistema más adecuado en este caso es utf-8-sig.
Reemplace el valor incorrecto por el correcto.
500
Página 511
raw = respuesta.read (). decode ('utf8-sig')

crudo [: 75]
'The Project Gutenberg EBook of Crime and Punishment, por Fyodor Dostoevsky \
r\n'
Ahora para poder trabajar en él hay que convertirlo en un corpus compatible con
NLTK. Para hacer esto, ingrese los siguientes comandos de conversión.
tokens = nltk.word_tokenize (sin procesar)

webtext = nltk.Text (tokens)
Estos comandos no hacen más que dividir en tokens (es decir, palabras)
texto de carácter con la función nltk.word_tokenize () y luego convertir tokens en un
cuerpo textual adecuado para NLTK con nltk.Text ().
Puedes ver el título ingresando este comando
webtext [: 12]
['Los',
'Proyecto',
'Gutenberg',
'Libro electronico',
'de',
'Crimen',
'y',
'Castigo',
',',
'por',
'Fyodor',
'Dostoievski']
Ahora tienes un corpus correcto sobre el que empezar a realizar tu análisis.
Extraiga el texto de las páginas HTML

En el ejemplo anterior, creó un corpus NLTK a partir del texto descargado del
Internet. Pero la mayor parte de la documentación en Internet está en forma de páginas HTML.
En esta sección, verá cómo extraer texto de páginas HTML.
501
Página 512
Siempre usa la función request () de la biblioteca urllib para descargar el HTML

contenido de una página web.
url = "http://news.bbc.co.uk/2/hi/health/2284783.stm"
html = request.urlopen (url) .read (). decode ('utf8')
html [: 120]
'<! doctype html public "- // W3C // DTD HTML 4.0 Transitional // EN"
"http://www.w3.org/TR/REC-html40/loose.dtd">\r\n <html> \ r \ n <hea '
Ahora, sin embargo, la conversión al corpus NLTK requiere una biblioteca adicional, bs4
(BeautifulSoup), que le proporciona analizadores adecuados que pueden reconocer HTML
etiquetas y extraer el texto que contienen.
desde bs4 importar BeautifulSoup

raw = BeautifulSoup (html, "lxml"). get_text ()
tokens = nltk.word_tokenize (sin procesar)
text = nltk.Text (tokens)
Ahora también tiene un corpus en este caso, incluso si a menudo tiene que realizar más
operaciones de limpieza complejas que en el caso anterior para eliminar las palabras que no
te interesa.
Análisis sentimental
El análisis sentimental es un nuevo campo de investigación que se ha desarrollado muy recientemente en
para evaluar las opiniones de las personas sobre un tema en particular. Esta disciplina se basa
sobre diferentes técnicas que utilizan el análisis de texto y su campo de trabajo en el mundo de las
medios y foros ( minería de opinión ).
Gracias a los comentarios y reseñas de los usuarios, los algoritmos de análisis sentimental pueden
evaluar el grado de apreciación o valoración en función de determinadas palabras clave. Esta
El grado de apreciación se llama opinión y tiene tres valores posibles: positivo, neutral,
o negativo. La valoración de esta opinión se convierte así en una forma de clasificación.
Tantas técnicas de análisis sentimental son en realidad algoritmos de clasificación
similares a los que vio en capítulos anteriores que cubren el aprendizaje automático y
aprendizaje (véanse los capítulos 8 y 9 ).
502
Página 513
Como ejemplo para comprender mejor esta metodología, hacemos referencia a una clasificación
tutorial utilizando el algoritmo Naïve Bayes en el sitio web oficial (https://www.nltk.org/
libro / ch06.html), donde es posible encontrar muchos otros ejemplos muy útiles para mejorar
entender esta biblioteca.
Como conjunto de entrenamiento, este ejemplo utiliza otro corpus presente en NLTK, que es muy
Útil para este tipo de problemas de clasificación: movietitis. Este corpus contiene
numerosas reseñas de películas en las que hay texto de una extensión discreta junto con otro
campo que especifica si la crítica es positiva o negativa. Por tanto, sirve como
gran material de aprendizaje.
El propósito de este tutorial es encontrar las palabras que se repiten más en negativo.
documentos, o palabras que se repiten más en positivas, para centrarse en las palabras clave
relacionado con una opinión. Esta evaluación se realizará a través de un Naïve Bayes
Clasificación integrada en NLTK.
En primer lugar, es importante el corpus denominado movietitis.
nltk.download ('película considerable')
Luego, construye el conjunto de entrenamiento a partir del corpus obtenido, creando una matriz de
pares de elementos llamados documentos. Esta matriz contiene en el primer campo el texto del single
revisar, y en el segundo campo la evaluación negativa o positiva. Al final, lo harás
mezclar todos los elementos de la matriz en orden aleatorio.
importar al azar
reseñas = nltk.corpus.movie×
documentos = [(lista (reviews.words (fileid)), categoría)
para categoría en reviews.categories ()
para fileid en reviews.fileids (categoría)]
random.shuffle (documentos)
Para comprender mejor, consulte el contenido de los documentos en detalle. El primer elemento
contiene dos campos; la primera es la reseña que contiene todas las palabras utilizadas.
first_review = '' .join (documentos [0] [0])

imprimir (primera vista previa)
las mujeres en topless hablan de sus vidas entran en esa categoría que yo
mencionado en el abogado del diablo: películas que tienen un comienzo brillante
pero no sé cómo terminar. comienza presentándonos a una selección de
503
Página 514
personajes que todos se conocen. está liz, que se queda dormida y también
llegando tarde a su cita, prue quien se va a casar, ...
En cambio, el segundo campo contiene la evaluación de la revisión:
documentos [0] [1]

'neg'
Pero el conjunto de entrenamiento aún no está listo; de hecho tienes que crear una frecuencia
distribución de todas las palabras del corpus. Esta distribución se convertirá en una
lista de casting con la función list ().
all_words = nltk.FreqDist (w.lower () para w en reviews.words ())

word_features = lista (todas_palabras)
Luego, el siguiente paso es definir una función para el cálculo de las características, es decir,
palabras que son lo suficientemente importantes para establecer la opinión de una revisión.
def document_features (documento, word_features):

document_words = set (documento)
características = {}
por palabra en word_features:
características ['{}'. formato (palabra)] = (palabra en documento_palabras)
características de devolución
Una vez que haya definido la función document_features (), puede crear la función
conjuntos de documentos.
featureets = [(document_features (d, c)) para (d, c) en documentos]
El objetivo es crear un conjunto de todas las palabras contenidas en todo el corpus de la película,
analizar si están presentes (verdadero o falso) en cada revisión y ver cómo
mucho contribuyen al juicio positivo o negativo de la misma. Cuanto más a menudo una palabra
está presente en las críticas negativas y cuanto menos a menudo está presente en las positivas, la
más se evalúa como una palabra "mala". Lo contrario es cierto para una "buena" evaluación de palabras.
Para determinar cómo subdividir este conjunto de funciones para el conjunto de entrenamiento y el conjunto de prueba,
primero debes ver cuántos elementos contiene.
len (conjuntos de características)

2000
504
Página 515
Luego, utiliza los primeros 1500 elementos del conjunto para el conjunto de entrenamiento y los últimos 500
elementos para el conjunto de prueba, con el fin de evaluar la precisión del modelo.
train_set, test_set = featureets [1500:], featureets [: 500]
Finalmente, aplica el clasificador Naïve Bayes proporcionado por la biblioteca NLTK para clasificar
este problema. Luego, calcula su precisión y envía el conjunto de prueba al modelo.
clasificador = nltk.NaiveBayesClassifier.train (tren_conjunto)

print (nltk.classify.accuracy (clasificador, test_set))
0,85
La precisión no es tan alta como en los ejemplos de los capítulos anteriores, pero estamos
trabajar con palabras contenidas en el texto y, por lo tanto, es muy difícil crear
modelos relativos a problemas numéricos.
Ahora que ha completado el análisis, puede ver qué palabras tienen más
peso en la evaluación de la opinión negativa o positiva de una reseña.
classifier.show_most_informative_features (10)
Características más informativas
badly = True neg: pos = 11.1: 1.0
julie = Verdadero neg: pos = 9.5: 1.0
finest = Verdadero pos: neg = 9.0: 1.0
olvidó = Verdadero neg: pos = 8.8: 1.0
desnudo = Verdadero neg: pos = 8.8: 1.0
refrescante = Verdadero pos: neg = 7,9: 1,0
robado = Verdadero pos: neg = 7.3: 1.0
afortunadamente = Verdadero pos: neg = 7.3: 1.0
directs = True pos: neg = 7.3: 1.0
lluvia = Verdadero neg: pos = 7.3: 1.0
Al observar los resultados, no se sorprenderá al descubrir que la palabra "mal" es una mala
palabra de opinión y que "mejor" es una palabra de buena opinión. Lo interesante aquí es que
“Julie” es una palabra de mala opinión.
505
Página 516
Conclusiones
En este capítulo, echó un breve vistazo al mundo del análisis de texto. De hecho, hay muchos
otras técnicas y ejemplos que podrían discutirse. Sin embargo, al final de este
capítulo, debe estar familiarizado con esta rama del análisis y especialmente haber comenzado a
conozca la biblioteca NLTK (Natural Language Toolkit), una poderosa herramienta para el análisis de texto.
506
Página 517
CAPITULO 14
Análisis de imagen
y visión artificial
con OpenCV
En los capítulos anteriores, el análisis de datos se centró completamente en datos numéricos y
tabulados, mientras que en el anterior vimos cómo procesar y analizar datos en
forma textual. Este libro se cierra con razón presentando el último aspecto del análisis de datos:
análisis de imágenes .
Durante el capítulo se abordarán temas como la visión por computadora y el reconocimiento facial.
introducido. Verás como las técnicas de deep learning están en la base de este rey
de análisis. Además, se introducirá otra biblioteca, llamada openCV, que tiene
siempre ha sido el punto de referencia para el análisis de imágenes.
Análisis de imágenes y visión artificial

A lo largo del libro, ha visto cómo el propósito del análisis es extraer
nueva información, para extraer nuevos conceptos y características de un sistema bajo
investigación. Lo hiciste con datos numéricos y textuales, pero se puede hacer lo mismo
con imágenes.
Esta rama de análisis se denomina análisis de imágenes y se basa en algunos cálculos.
técnicas que se les aplican (filtros de imagen), que verá en las próximas secciones.
En los últimos años, especialmente debido al desarrollo del aprendizaje profundo, la imagen
El análisis ha experimentado un gran desarrollo en la resolución de problemas que antes
imposible, dando lugar a una nueva disciplina llamada visión por computadora .
507
© Fabio Nelli 2018
Página 518
CAPÍTULO 14 ANÁLISIS DE IMAGEN Y VISIÓN POR COMPUTADORA CON OPENCV
En el capítulo 9, aprendiste sobre inteligencia artificial, que es la rama de

cálculo que se ocupa de resolver problemas de pura “relevancia humana”. Computadora
La visión es parte de esto, ya que su propósito es reproducir la forma en que el cerebro humano percibe
imágenes.
De hecho, ver no es solo la adquisición de una imagen bidimensional, sino sobre todo
es la interpretación del contenido de esa área. La imagen capturada se descompone
y elaborado en niveles de representación que son gradualmente más abstractos (contornos,
figuras, objetos y palabras) y, por tanto, reconocibles por la mente humana.
De la misma forma, la visión artificial pretende procesar una imagen bidimensional y
extraer de él los mismos niveles de representación. Esto se hace a través de varias operaciones.
que se pueden clasificar de la siguiente manera:
• Detección : detecta formas, objetos u otros sujetos de investigación en

una imagen (por ejemplo, encontrar coches)
• Reconocimiento : los sujetos identificados se devuelven a los

clases (por ejemplo, subdividir coches por marcas y tipos)
• Identificación : se identifica una instancia de la clase anterior

(por ejemplo, encuentra mi auto)
OpenCV y Python
OpenCV (Open Source Computer Vision) es una biblioteca escrita en C ++ que está especializada
para visión artificial y análisis de imágenes ( https://opencv.org/). Esta poderosa biblioteca,
diseñado por Gary Bradsky, nació como un proyecto de Intel y en 2000 la primera versión fue
publicado. Luego, con el paso del tiempo, fue lanzado bajo una licencia de código abierto,
y desde entonces se ha ido generalizando poco a poco, llegando a la versión 3.3
(2017). En este momento, OpenCV admite muchos algoritmos relacionados con la visión por computadora y
aprendizaje automático y se expande día a día.
Su utilidad y difusión se debe precisamente a su antagonista: MATLAB. De hecho, esos
que necesitan trabajar con análisis de imágenes solo pueden seguir dos caminos: comprar MATLAB
paquetes o compile e instale la versión de código abierto de OpenCV. Bueno, es fácil de ver
por qué muchos han optado por la segunda opción.
508
Página 519
CAPÍTULO 14 ANÁLISIS DE IMAGEN Y VISIÓN POR COMPUTADORA CON OPENCV
OpenCV y aprendizaje profundo

Existe una estrecha relación entre la visión por computadora y el aprendizaje profundo. Desde 2017
fue un año importante para el desarrollo del aprendizaje profundo (lea mi artículo sobre
en http://www.meccanismocomplesso.org/en/2017-year-of-deep-learning-
frameworks /), el lanzamiento de la nueva versión de OpenCV 3.3 ha visto la mejora
de la biblioteca con muchas características nuevas de aprendizaje profundo y redes neuronales en general.
De hecho, la biblioteca tiene un módulo llamado dnn (redes neuronales profundas) dedicado a este
aspecto. Este módulo ha sido desarrollado específicamente para su uso con muchos métodos de aprendizaje profundo.
frameworks, incluidos Caffe2, TensorFlow y PyTorch (para obtener información sobre estos
frameworks ver Capítulo 9).
Instalación de OpenCV
Instalación de un paquete OpenCV en muchos sistemas operativos (Windows, iOS y Android)
se realiza a través del sitio web oficial (https://opencv.org/releases.html ).
Si usa Anaconda como medio de distribución, le recomiendo usar este enfoque.
La instalación es muy sencilla y limpia.
conda instalar opencv
Desafortunadamente para los sistemas Linux, no existe un paquete PyPI oficial (con pip
clear) para ser instalado. Se requiere la instalación manual y puede variar según el
distribución y versión utilizada. Muchos procedimientos están presentes en Internet, algunos
más o menos válido. Para aquellos con Ubuntu 16, recomiendo este procedimiento de instalación
(ver https://github.com/BVLC/caffe/wiki/OpenCV-3.3-Installation-Guide-on-
Ubuntu-16.04 ).
Primeros enfoques para el procesamiento y análisis de imágenes

En esta sección, comenzará a familiarizarse con la biblioteca OpenCV. primero
comenzará a ver cómo cargar y ver imágenes. Entonces pasarás algunos simples
operaciones a ellos, sume y reste dos imágenes, y vea un ejemplo de fusión de imágenes.
Todas estas operaciones serán de gran utilidad ya que servirán de base para cualquier otra imagen
operación de análisis.
509
Página 520
Capítulo 14 Análisis de imágenes y visualización informática con openCV
Antes de empezar
Una vez instalada la biblioteca OpenCV, puede abrir una sesión de IPython en Jupyter
QtConsole o Jupyter Notebook.
Luego, antes de comenzar a programar, debe importar la biblioteca openCV.

importar cv2
Cargar y mostrar una imagen

Primero, principalmente porque OpenCV funciona con imágenes, es importante saber cómo
cargarlos en un programa en Python, manipularlos nuevamente y finalmente verlos para ver
Los resultados.
Lo primero que debe hacer es leer el archivo que contiene la imagen usando OpenCV
biblioteca. Puede hacer esto usando el método imread (). Este método lee el archivo en un
formato comprimido como JPG y lo traduce en una estructura de datos que está hecha de un
matriz numérica correspondiente a las gradaciones de color y la posición.
Tenga en cuenta que puede encontrar las imágenes y los archivos en el código fuente de este libro.
img = cv2.imread ('italia2018.jpg')
Si está interesado en más detalles, puede ver el contenido de una imagen directamente.
Notará una matriz de matrices, cada una correspondiente a una posición específica de la imagen,
y cada uno caracterizado por números entre 0 y 255.
De hecho, si ve el contenido del primer elemento de la imagen, obtendrá la
siguiendo.
img [0]
matriz ([[38, 43, 11],
[37, 42, 10],
[36, 41, 9],
...,
[24, 37, 15],
[22, 36, 12],
[23, 36, 12]], dtype = uint8)
510
Página 521
Continuando con el código, ahora usará el método imshow () para crear una ventana
con la imagen cargada en la variable img. Este método toma dos parámetros: el
el nombre de la ventana y la variable de imagen. Una vez que haya creado la ventana, puede usar
el método waitKey ().
cv2.imshow ('Imagen', img)

cv2.waitKey (0)
Al ejecutar este comando, se abre una nueva ventana y muestra la imagen, como se muestra en
Figura 14-1.
Figura 14-1. La foto de la selección italiana de fútbol durante el entrenamiento.
El método waitKey () comienza a mostrar la ventana y le permite controlar la

tiempo de espera del programa antes de continuar con el siguiente comando. Este ejemplo
usó 0 como argumento, lo que significa que la espera será infinita siempre que presione
cualquier tecla del teclado.
511
Página 522
Si desea mantener abierta la ventana solo durante un período específico, debe escribir
el número de milisegundos como parámetro. Intente reemplazar el valor en el programa, por
ejemplo 2000 (dos segundos) y ejecute el programa.
Tenga en cuenta que este comportamiento puede variar mucho de un sistema a otro. a veces el
El kernel de Ipython podría dar problemas. luego use waitKey (0).

cv2.waitKey (2000)
La ventana con la imagen (como se muestra en la Figura 14-1) debería aparecer y luego
desaparecen después de dos segundos.
Sin embargo, para ejemplos que son más complejos, es útil tener control directo sobre
el cierre de una ventana, sin el uso de tiempos de espera. El método destroyWindow ()
le permite cerrar la ventana deseada (pueden ser varias abiertas) especificando como
argumento el nombre de la ventana, que en su caso es Imagen.

cv2.waitKey (2000)
cv2.destroyWindow ('Imagen')
Si hay varias ventanas abiertas y desea cerrarlas todas a la vez, puede

use un solo comando, la llamada al método destroyAllWindows ().
Trabajar con imágenes

Ahora que ha visto cómo ver imágenes existentes en su sistema de archivos, puede continuar.
al siguiente paso: procesar la imagen realizando una operación en ella y guardando el
resultado a un nuevo archivo.
Continuando con el ejemplo anterior, utilizará el mismo código. Esta vez,
sin embargo, realizará una manipulación de imagen simple, por ejemplo, descomponiendo
los tres canales RGB. Luego intercambiarás los canales para formar una nueva imagen. Esta
la nueva imagen tendrá todos los colores alterados.
Después de cargar la imagen, descompóngala en los tres canales RGB. Puedes hacerlo
fácilmente mediante el método split ().
b, r, g = cv2.split (img)
512
Página 523
Ahora vuelva a montar los tres canales, pero cambie el orden, por ejemplo,
intercambiando el canal rojo con el canal verde. Puede recombinar fácilmente el
canales utilizando el método merge ().
img2 = cv2.merge ((b, g, r))
La nueva imagen está contenida en la variable img2. Muéstrelo junto con el original en
una nueva ventana.
cv2.imshow ('Imagen2', img2)

cv2.waitKey (0)
Al ejecutar el programa, aparece una nueva ventana con colores alterados (como se muestra en
Figura 14-2).
Figura 14-2. La imagen procesada tiene colores alterados
513
Página 524
Guardar la nueva imagen

Finalmente, debe guardar su nueva imagen guardando el sistema de archivos.
Al final del programa, agregue un método imwrite () con el nombre del nuevo archivo
que desea guardar, que también puede ser de otro formato, como PNG.
cv2.imwrite ('italia2018altered.png', img2)
Ejecute este comando y verá un nuevo archivo italy2018altered.png en el

espacio de trabajo.
Operaciones elementales en imágenes

La operación más básica es la adición de dos imágenes. Con la biblioteca openCV, este
La operación es muy simple y puede hacerlo usando la función cv2.add (). El resultado
obtenida será la combinación de las dos imágenes.
Pero no olvides que las dos imágenes deben tener las mismas dimensiones para poder ser agregadas
juntos. En este caso, las imágenes son de 512x331 píxeles.
Lo primero que debe hacer es cargar una segunda imagen con las mismas dimensiones, en
nuestro caso soccer.jpg (lo puedes encontrar en el código fuente).
img2 = cv2.imread ('fútbol.jpg')

cv2.imshow ('Imagen2', img2)
cv2.waitKey (0)
514
Página 525
Al ejecutar el código, obtendrá la imagen que se muestra en la Figura 14-3..
Figura 14-3. Una nueva imagen del mismo tamaño (512x331 píxeles)
Ahora solo tienes que agregar las dos imágenes usando la función add ().
img = cv2.add (img, img2)

cv2.imshow ('Suma', img)
Al ejecutar este código, recibirá una combinación de las dos imágenes (como se muestra
en la Figura 14-4 ). Desafortunadamente, el efecto no es muy atractivo.
515
Página 526
Figura 14-4. Una nueva imagen obtenida sumando las dos imágenes
El resultado no es el que esperábamos. La prevalencia del blanco es de hecho el resultado de

la suma aritmética simple de los tres valores RGB, que se calcula para cada
píxel individual.
De hecho, sabe que cada uno de los tres componentes RGB toma valores de 0 a 255.
Por lo tanto, si la suma de los valores de un píxel dado es mayor que 255 (lo cual es bastante
probable) el valor seguirá siendo 255. Por lo tanto, la simple tarea de agregar las imágenes no
conducen a una imagen que es una fusión de los dos, pero que cambia gradualmente cada vez más
hacia el blanco.
Más adelante verá cómo el concepto de agregar dos imágenes para crear una nueva imagen que es
la mitad de los dos (no es la suma aritmética).
516
Página 527
Puedes hacer lo mismo restando dos imágenes. Esta operación puede ser
realizado con la función cv2.subtract (). Esta vez esperaríamos una imagen que
tenderá cada vez más hacia el negro. Reemplace la función cv2.add () con la
siguiendo.
img3 = cv2.subtract (img, img2)

cv2.imshow ('Sub1', img3)
cv2.waitKey (0)
Al ejecutar el programa, encontrará una imagen que tiende a la oscuridad (incluso si

no veo mucho), como se muestra en la Figura 14-5.
Figura 14-5. Una nueva imagen obtenida restando una imagen de otra
517
Página 528
Tenga en cuenta que este efecto es aún peor si hace lo contrario.
img3 = cv2.subtract (img2, img)

cv2.imshow ('Sub1', img3)
cv2.waitKey (0)
Obtiene una imagen negruzca, como se muestra en la Figura 14-6.
Figura 14-6. Una nueva imagen obtenida restando una imagen de otra
Sin embargo, esto es útil para saber que el orden de los operadores es importante.
por el resultado.
Más concretamente, ya ha visto que un objeto de imagen creado con OpenCV
biblioteca no es más que una serie de matrices que responden perfectamente a los cánones de
NumPy. Por lo tanto, puede utilizar las operaciones entre matrices proporcionadas por NumPy, como
la suma de matrices. Pero tenga cuidado, el resultado ciertamente no será el mismo.
img = img1 + img2
518
Página 529
De hecho, las funciones cv2.add () y cv2.subtract () mantienen los valores entre

0 y 255, independientemente del valor de los operadores. Si la suma excede 255 el resultado es
interpretado de manera diferente, creando así un efecto de color muy extraño (tal vez como un módulo de
255). Lo mismo ocurre cuando la remoción produce un valor negativo; el resultado
sería 0. Las operaciones aritméticas no tienen esta característica.
Sin embargo, puedes probarlo directamente.
img3 = img + img2

cv2.imshow ('numpy', img3)
cv2.waitKey (0)
Al ejecutarlo obtendrás una imagen con un contraste de color muy fuerte (son los
puntos por encima de 255), como se muestra en la Figura 14-7.
Figura 14-7. Una imagen obtenida agregando dos imágenes como dos NumPy
matrices
519
Página 530
Mezcla de imágenes
En el ejemplo anterior, vio que la suma o resta de dos imágenes no
no produce una imagen intermedia entre los dos, sino que cambia la coloración
hacia blancos o negros.
La operación correcta se llama mezcla . Es decir, puedes considerar la operación
de superponer las dos imágenes, una encima de la otra, haciendo que la colocada encima
gradualmente más y más transparente. Al ajustar la transparencia gradualmente, obtiene una
mezcla de las dos imágenes, creando una nueva que es la intermedia.
La operación de mezcla no corresponde a una simple adición, sino a la fórmula
corresponde a la siguiente ecuación.
img = α · img1 + (1 - α) · img2 con 0 ≥ α ≥ 1
Como puede ver en la ecuación anterior, las dos imágenes tienen dos
coeficientes que toman valores entre 0 y 1. Con el crecimiento del parámetro α obtendrá
tener una transición suave de la primera imagen a la segunda.
La biblioteca OpenCV proporciona la operación de fusión con cv2.addWeighted ()
función.
Por lo tanto, si desea crear una imagen intermedia entre dos imágenes de origen,
puede utilizar el siguiente código.
img3 = cv2.addWeighted (img, 0.3, img2, 0.7, 0)

cv2.imshow ('numpy', img3)
cv2.waitKey (0)
520
Página 531
El resultado será una imagen como la que se muestra en la Figura 14-8 .
Figura 14-8. Una imagen obtenida con mezcla de imágenes
Análisis de imagen
El propósito de los ejemplos de la sección anterior era comprender que las imágenes
no son más que matrices NumPy. Como tal, estas matrices numéricas se pueden procesar.
Por lo tanto, puede implementar muchas funciones matemáticas que procesarán el
números dentro de estas matrices para obtener nuevas imágenes. Estas nuevas imágenes, obtenidas de
operaciones, servirá para proporcionar nueva información.
Este es el concepto que subyace al análisis de imágenes . Las operaciones matemáticas realizadas
de una imagen inicial (matriz) a una imagen resultante (matriz) se denominan filtros de imagen
(ver figura 14-9 ). Para ayudarlo a comprender este proceso, seguramente tendrá que lidiar
con aplicaciones de edición de fotografías (como Photoshop). En cualquier caso, ciertamente has visto
521
Página 532
que filtros que se pueden aplicar a las fotos. Estos filtros no son más que algoritmos
(secuencias de operaciones matemáticas) que modifican los valores numéricos en la matriz
de la imagen inicial.
Figura 14-9. Una representación de los filtros de imagen que son la base de la imagen.
análisis
Detección de bordes y análisis de gradiente de imagen

En las secciones anteriores, vio cómo realizar algunas operaciones básicas que son útiles
para análisis de imágenes. En esta sección, comienza con un caso real de análisis de imágenes, llamado edge
detección .
Detección de bordes
Al analizar una imagen, y especialmente durante la visión por computadora, uno de los
operaciones fundamentales es comprender el contenido de la imagen, como los objetos
y gente. Primero es necesario comprender qué formas posibles están representadas en
la imagen. Sin embargo, para comprender las geometrías representadas, es necesario
reconocer los contornos que delimitan un objeto del fondo o de otros objetos.
Ésta es precisamente la tarea de la detección de bordes.
522
Página 533
En la detección de bordes, se han desarrollado y desarrollado una gran cantidad de algoritmos y técnicas.
explotan diferentes principios para determinar correctamente los contornos de los objetos.
Muchas de estas técnicas se basan en el principio de degradados de color y explotan la
proceso de análisis de gradiente de imagen.
La teoría del gradiente de imagen

Entre las diversas operaciones que se pueden aplicar a las imágenes, están las convoluciones
de una imagen en la que se aplican ciertos filtros para editar la imagen con el fin de obtener
información o alguna otra utilidad. Ya has visto que una imagen se representa como
una gran matriz numérica en la que los colores de cada píxel están representados por un número
de 0 a 255 en la matriz. Las convoluciones procesan todos estos valores numéricos por
aplicar una operación matemática ( filtro de imagen ) para producir nuevos valores en una nueva matriz
del mismo tamaño.
Una de estas operaciones es la derivada . En palabras simples, la derivada es una
Operación matemática que le permite obtener los valores numéricos que indican la velocidad.
en el que un valor cambia (en el espacio, el tiempo, etc.).
¿Cómo podría ser importante la derivada en el caso de las imágenes? Que tiene que ver con
variación de color, llamada degradado .
Poder calcular el degradado de un color es una excelente herramienta para calcular la
bordes de una imagen. De hecho, su ojo puede distinguir los contornos de una figura presente en
una imagen, gracias a los saltos de un color a otro. Además, tu ojo puede
percibir las profundidades gracias a las distintas tonalidades de color que van del claro al oscuro,
que es el gradiente.
De todo esto, queda bastante claro que medir un degradado en una imagen es crucial para ser
capaz de detectar los bordes de la imagen. Se hace con una simple operación (filtro) que es
realizado sobre la imagen.
523
Página 534
Para verlo mejor desde un punto de vista matemático, mire la Figura 14-10 .
Figura 14-10. La representación de la teoría del gradiente de imagen
Como puede ver en la Figura 14-10 , una ventaja no es más que una transición rápida de una
matiz a otro. Para simplificar, 0 es negro y 1 es blanco. Todos los tonos de gris son valores flotantes
entre 0 y 1.
Si grafica todos los valores correspondientes a los valores de gradiente, obtiene la función f ().
Como puede ver, hay una transición repentina de 0 a 1, lo que indica el borde.
524
Página 535
La derivada de la función f () da como resultado la función f '(). Como puede ver, el

la variación máxima del tono conduce a valores cercanos a 1. Por lo tanto, al convertir colores,
Obtendrá una figura en la que el blanco indicará el borde.
Un ejemplo práctico de detección de bordes con la imagen

Análisis de gradiente
Pasando a la parte práctica, utilizarás dos imágenes creadas específicamente para probar el
análisis de los contornos, ya que tienen varias características importantes en ellos.
La primera imagen (como se muestra en la Figura 14-11) consta de dos flechas en blanco y negro
y corresponde al archivo blackandwhite.jpg. En esta imagen, el contraste de color es muy
fuerte y los contornos de las flechas tienen todas las orientaciones posibles (horizontal,
vertical y diagonal). Esta imagen de prueba servirá para evaluar el efecto de la detección de bordes
en un sistema en blanco y negro.
Figura 14-11. Una imagen en blanco y negro que representa dos flechas.
La segunda imagen, gradients.jpg, muestra diferentes gradientes de gris que, cuando

colocados uno al lado del otro, crear rectángulos cuyos bordes tengan todas las gradaciones posibles
y combinaciones de tonos (como se muestra en la Figura 14-12). Esta imagen es una buena prueba para
Evaluar las verdaderas capacidades de detección de bordes del sistema.
525
Página 536
Figura 14-12. Un conjunto de degradados grises colocados uno al lado del otro.
Ahora puede comenzar a desarrollar el código necesario para la detección de bordes. Usarás
matplotlib para mostrar diferentes imágenes en la misma ventana. En esta prueba, usaremos dos
diferentes tipos de filtros de imagen proporcionados por OpenCV: Sobel y laplaciano . De hecho, su
Los nombres corresponden al nombre de las operaciones matemáticas realizadas en el
matrices (imágenes). La biblioteca openCV proporciona cv2.Sobel () y cv2.Laplacian () para
aplique estos dos cálculos.
Primero, comienza analizando la detección de bordes aplicada a la imagen en blanco y negro.jpg.
de matplotlib importar pyplot como plt

img = cv2.imread ('blanco y negro.jpg', 0)
laplacian = cv2.Laplacian (img, cv2.CV_64F)
sobelx = cv2.Sobel (img, cv2.CV_64F, 1,0, ksize = 5)
sobely = cv2.Sobel (img, cv2.CV_64F, 0,1, ksize = 5)
plt.subplot (2,2,1), plt.imshow (img, cmap = 'gris')

plt.title ('Original'), plt.xticks ([]), plt.yticks ([])
plt.subplot (2,2,2), plt.imshow (laplacian, cmap = 'gris')
plt.title ('Laplaciano'), plt.xticks ([]), plt.yticks ([])
plt.subplot (2,2,3), plt.imshow (sobelx, cmap = 'gris')
plt.title ('Sobel Y'), plt.xticks ([]), plt.yticks ([])
526
Página 537
plt.subplot (2,2,4), plt.imshow (sobely, cmap = 'gris')

plt.show ()
Cuando ejecuta este código, obtiene una ventana con cuatro cuadros (como se muestra en
Figura 14-13 ). El primer cuadro es la imagen original en blanco y negro, mientras que los otros tres
son el resultado de los tres filtros aplicados a la imagen.
Figura 14-13. El resultado de la detección de bordes aplicada al blanco y negro.jpg

imagen
En lo que respecta a los filtros Sobel, la detección de bordes es perfecta, incluso si está limitada horizontalmente
o verticalmente. Las líneas diagonales son visibles en ambos casos, ya que tienen ambas horizontales
componentes verticales y verticales, pero los bordes horizontales en el Sobel X y los del
verticales Sobel Y no se detectan de ninguna manera.
Combinando los dos filtros (el cálculo de dos derivadas) para obtener el Laplaciano
filtro, la determinación de los bordes es omnidireccional pero tiene alguna pérdida de resolución.
De hecho, puedes ver que las ondulaciones correspondientes a los bordes son más tenues.
527
Página 538
La coloración en gris es muy útil para detectar bordes y degradados, pero si está
Si solo está interesado en detectar bordes, debe establecer como salida un archivo de imagen en cv2.CV_8U.
Por lo tanto, puede cambiar el tipo de datos de salida de cv2.CV_64F a cv2.CV_8U en
la función de filtros del código anterior. Reemplazar los argumentos pasados a las dos imágenes
filtra de la siguiente manera.
laplacian = cv2.Laplacian (img, cv2.CV_8U)

sobelx = cv2.Sobel (img, cv2.CV_8U, 1,0, ksize = 5)
sobely = cv2.Sobel (img, cv2.CV_8U, 0,1, ksize = 5)
Al ejecutar el código, obtendrá resultados similares (como se muestra en la Figura 14-14 ), pero

esta vez solo en blanco y negro, donde los bordes se muestran en blanco sobre un negro
antecedentes.

imagen
528
Página 539
Pero si observa detenidamente los paneles del filtro Sobel X e Y, verá

note de inmediato que algo anda mal. ¿Dónde están los bordes que faltan? Tenga en cuenta este problema
en la Figura 14-15.
Figura 14-15. Bordes faltantes en la imagen en blanco y negro.jpg
De hecho, hubo un problema al convertir los datos. Los gradientes informados en

la escala de grises con valores cv2.CV_64F están representados por valores positivos (pendiente positiva)
al cambiar de negro a blanco. Sin embargo, están representados por valores negativos.
(pendiente negativa) al cambiar de blanco a negro. En la conversión de cv2.CV_64F
a cv2.CV_8U, todas las pendientes negativas se reducen a 0, y luego la información relativa a
esos bordes se pierden. Cuando el programa muestre la imagen, los bordes de blanco a
no se mostrará el negro.
Para superar esto, debe mantener los datos en la salida del filtro en cv2.CV_64F
(en lugar de cv2.CV_8U), luego calcule el valor absoluto y finalmente realice la conversión
en cv2.CV_8U.
529
Página 540
Realice estos cambios en el código.
laplacian64 = cv2.Laplacian (img, cv2.CV_64F)

sobelx64 = cv2.Sobel (img, cv2.CV_64F, 1,0, ksize = 5)
sobely64 = cv2.Sobel (img, cv2.CV_64F, 0,1, ksize = 5)
laplacian = np.uint8 (np.absolute (laplacian64))
sobelx = np.uint8 (np.absolute (sobelx64))
sobely = np.uint8 (np.absolute (sobely64))
plt.subplot (2,2,1), plt.imshow (img, cmap = 'gris')

plt.title ('Original'), plt.xticks ([]), plt.yticks ([])
plt.subplot (2,2,2), plt.imshow (laplacian, cmap = 'gris')
plt.subplot (2,2,3), plt.imshow (sobelx, cmap = 'gris')
plt.subplot (2,2,4), plt.imshow (sobely, cmap = 'gris')
plt.show ()
Ahora, si lo ejecuta, obtendrá la representación correcta en blanco sobre negro.

bordes de las flechas (como se muestra en la Figura 14-16 ). Como puede ver, los bordes no aparecen.
en Sobel X y Sobel Y porque son paralelos a la dirección de detección (horizontal
y vertical).
530
Página 541

imagen
Además de los bordes, verá que los filtros Laplacian y Sobel también pueden
detectar el nivel de degradados en una escala de grises. Aplica lo que has visto al degradado.jpg
imagen. Tienes que hacer algunos cambios al código anterior, dejando solo una imagen
(Laplaciano) que se mostrará.
de matplotlib importar pyplot como plt

img = cv2.imread ('gradients.jpg', 0)
laplacian = cv2.Laplacian (img, cv2.CV_64F)
sobelx = cv2.Sobel (img, cv2.CV_64F, 1,0, ksize = 5)
sobely = cv2.Sobel (img, cv2.CV_64F, 0,1, ksize = 5)
laplacian64 = cv2.Laplacian (img, cv2.CV_64F)

sobelx64 = cv2.Sobel (img, cv2.CV_64F, 1,0, ksize = 5)
sobely64 = cv2.Sobel (img, cv2.CV_64F, 0,1, ksize = 5)
531
Página 542
laplacian = np.uint8 (np.absolute (laplacian64))

sobelx = np.uint8 (np.absolute (sobelx64))
sobely = np.uint8 (np.absolute (sobely64))
plt.imshow (laplaciano, cmap = 'gris')

plt.show ()
Al ejecutar este código, obtendrá una imagen que muestra los bordes blancos sobre un negro.
fondo (como se muestra en la Figura 14-17 ).
Figura 14-17. El resultado de la detección de bordes aplicada a los degradados.jpg

imagen
Un ejemplo de aprendizaje profundo: la detección de rostros

En esta última sección del capítulo, centrará su atención en otro tema muy estudiado.
y caso usado en visión artificial, detección de rostros.
Este es un caso mucho más complejo que la detección de bordes, y se basa en identificar
rostros humanos en una imagen. Dada la complejidad del problema, la detección de rostros utiliza
aprendizaje. De hecho, en la base de esta técnica, existen redes neuronales que son especialmente
diseñado para reconocer diferentes sujetos, incluidos los rostros de una persona, en una foto.
Las técnicas de detección de objetos también funcionan de manera muy similar. Entonces este ejemplo será muy útil
para comprender completamente el corazón de la visión por computadora, el de interpretar los sujetos presentes
en una foto.
532
Página 543
En este ejemplo, utilizará una red neuronal ya aprendida. De hecho, educar a un

red neuronal para este tipo de problema puede ser una operación compleja y requiere una gran
gran cantidad de tiempo y recursos.
Afortunadamente, en la web, existen algunas redes neuronales ya capacitadas para realizar
este tipo de operaciones, y para esta prueba utilizará un modelo desarrollado utilizando
Marco Caffe2 (ver Capítulo 9 para obtener más información).
Cuando desee utilizar un módulo de red neuronal profunda con modelos Caffe en el
Entorno OpenCV, necesita dos tipos de archivos, de la siguiente manera:
• Un archivo de texto prototipo , que define la arquitectura del modelo (es decir, las capas
sí mismos). Utilizará un archivo deploy.prototxt.txt descargado
de la webhttps://github.com/opencv/opencv/blob/master/
samples / dnn / face_detector / deploy.prototxt ).
• El segundo tipo de archivo es un archivo caffemodel , que contiene los pesos

para las capas reales en la red neuronal profunda. Este archivo es el
más importante porque contiene todo el "aprendizaje" de ese neural
red para realizar una tarea determinada. Para sus propósitos, un archivo caffemodel
está disponible en https://github.com/opencv/opencv_3rdparty/tree/
dnn_samples_face_detector_20170830.
Tenga en cuenta que también puede encontrar estos archivos en el código fuente del libro.
Ahora que tiene todo lo que necesita, comience cargando la red neuronal
modelo y toda la información sobre tu aprendizaje.
La biblioteca OpenCV es compatible con muchos marcos de aprendizaje profundo y tiene muchos
características que le ayudarán con esto. En particular (mencionado al principio del
capítulo), OpenCV tiene el módulo dnn, que se especializa en este tipo de operaciones.
Para cargar una red neuronal aprendida, puede usar dnn.readNetFromCaffe ()
función.
net = cv2.dnn.readNetFromCaffe ('deploy.prototxt.txt', 'res10_300x300_ssd_

iter_140000.caffemodel ')
533
Página 544
Como imagen de prueba, puede utilizar la foto con los jugadores de la selección italiana,
italy2018.jpg. Esta imagen es un gran ejemplo, ya que hay muchas caras adentro.
imagen = cv2.imread ('italia2018.jpg')

(alto, ancho) = imagen.forma [: 2]
Otra función, llamada dnn . blobFromImage (), se encarga de preprocesar el

imagen para ser adaptada a redes neuronales. Por ejemplo, cambie el tamaño de la imagen a 300x300 píxeles.
para que pueda ser utilizado por el archivo caffemodel que ha sido entrenado para imágenes de este tamaño.
blob = cv2.dnn.blobFromImage (cv2.resize (imagen, (300, 300)), 1.0, (300, 300),

(104,0, 177,0, 123,0))
Luego defina un umbral de confianza con un valor óptimo de 0.5.
umbral_confianza = 0.5
Y finalmente realiza la prueba de detección de rostros.
net.setInput (blob)
detecciones = net.forward ()
para i en el rango (0, detecciones.forma [2]):

confianza = detecciones [0, 0, i, 2]
si confianza> umbral_confianza:
cuadro = detecciones [0, 0, i, 3: 7] * np.array ([w, h, w, h])
(startX, startY, endX, endY) = box.astype ("int")
text = "{: .2f}%". formato (confianza * 100)
y = startY - 10 si startY - 10> 10 en caso contrario startY + 10
cv2.rectangle (imagen, (startX, startY), (endX, endY), (0, 0, 255), 2)
cv2.putText (imagen, texto, (startX, y), cv2.FONT_HERSHEY_SIMPLEX,
0.45, (0, 0, 255), 2)
cv2.imshow ("Salida", imagen)

cv2.waitKey (0)
Al ejecutar el código, aparecerá una ventana con los resultados del procesamiento de la cara.
detección (se muestra en la Figura 14-18). Los resultados son increíbles, ya que los rostros de todos los
Se han detectado jugadores. Puedes ver las caras rodeadas por un cuadrado rojo que
534
Página 545
los resalta en la imagen con un porcentaje de confianza. Porcentajes de confianza

son todos superiores al 50% para el parámetro de umbral de confianza que especificamos en
el inicio de la prueba.
Figura 14-18. Los rostros de los futbolistas nacionales han sido todos precisos.
Reconocido
Conclusiones
En este capítulo, vio algunos ejemplos simples de técnicas que forman la base de
análisis de imágenes y en particular de visión artificial. De hecho, viste cómo se ven las imágenes
procesado a través de filtros de imagen, y cómo se pueden construir algunas técnicas complejas usando
detección de bordes. También viste cómo funciona la visión por computadora al usar el aprendizaje profundo
redes para reconocer rostros en una imagen (detección de rostros).
Espero que este capítulo sea un buen punto de partida para profundizar sus conocimientos sobre el tema.
Si está interesado, encontrará información detallada sobre este tema en mi sitio web en
https://meccanismocomplesso.org.
535
Página 546
APÉNDICE A
Escritura matemática
Expresiones con LaTeX
LaTeX se usa ampliamente en Python. En este apéndice hay muchos ejemplos que pueden
ser útil para representar expresiones LaTeX dentro de implementaciones de Python. Este mismo
la información se puede encontrar en el enlace http://matplotlib.org/users/mathtext.html .
Con matplotlib
Puede ingresar la expresión LaTeX directamente como un argumento de varias funciones que pueden
aceptarlo. Por ejemplo, la función title () que dibuja un título de gráfico.

plt.title (r '$ \ alpha> \ beta $')
Con IPython Notebook en una celda de Markdown

Puede ingresar la expresión LaTeX entre dos '$$'.
$$ c = \ sqrt {a ^ 2 + b ^ 2} $$
2 2
c=a+b
537
© Fabio Nelli 2018
F. Nelli, Python Data Analytics , https://doi.org/10.1007/978-1-4842-3913-1
Página 547
APÉNDICE A ESCRIBIR EXPRESIONES MATEMÁTICAS CON LÁTEX
Con IPython Notebook en una celda de Python 2

Puede ingresar la expresión LaTeX dentro de la función Math ().
de la pantalla de importación IPython.display, matemáticas, látex

display (Math (r'F (k) = \ int _ {- \ infty} ^ {\ infty} f (x) e ^ {2 \ pi ik} dx '))
Subíndices y superíndices
Para hacer subíndices y superíndices, use los símbolos '_' y '^':
r '$ \ alpha_i> \ beta_i $'
una
yo >
si yo
Esto puede resultar muy útil cuando tenga que escribir resúmenes:
r '$ \ sum_ {i = 0} ^ \ infty x_i $'
åx yo
i=0
Fracciones, binomios y números apilados

Se pueden crear fracciones, binomios y números apilados con \ frac {} {}, \ binom {} {},
y \ stackrel {} {} comandos, respectivamente:
r '$ \ frac {3} {4} \ binom {3} {4} \ stackrel {3} {4} $'
3 æ3 ö4
C ÷
4 mi4 ø
Las fracciones se pueden anidar arbitrariamente:
1
5-
X
4
538
Página 548
APÉNDICE A ESCRIBIR EXPRESIONES MATEMÁTICAS CON LÁTEX
Tenga en cuenta que se debe tener especial cuidado al colocar paréntesis y corchetes alrededor
fracciones. Debe insertar \ left y \ right antes del corchete para informar al
analizador que esos corchetes abarcan todo el objeto:
æ 1 ö
C5 - ÷
C X÷
C 4 ÷
mi ø
Radicales
Los radicales se pueden producir con el comando \ sqrt [] {}.
r '$ \ sqrt {2} $'
Fuentes
La fuente predeterminada es cursiva para los símbolos matemáticos. Para cambiar fuentes, por ejemplo con
funciones trigonométricas como pecado:
st()
= Asin 2 t () w
Las opciones disponibles con todas las fuentes son
de la pantalla de importación IPython.display, matemáticas, látex

mostrar (Math (r '\ mathrm {Roman}'))
mostrar (Math (r '\ mathit {Italic}'))
display (Math (r '\ mathtt {Máquina de escribir}'))
display (Math (r '\ mathcal {CALLIGRAPHY}'))
539
Página 549
Apéndice A Escritura de expresiones MAtheMAticAl con lAtex
Acentos
Un comando de acento puede preceder a cualquier símbolo para agregar un acento encima. Hay mucho
y formas cortas para algunos de ellos.
\ agudo a o \ 'a
\ bar a
\ breve a
\ ddot a o \ "a
\ dot a o \ .a
\ grave a o \ à
\ hat a o \ ^ a
\ tilde a o \ ~ a
\ vec a
\ overline {abc}
Simbolos
También puede utilizar una gran cantidad de símbolos TeX.
Griego minúsculo
\alfa \beta \ chi \delta \ digamma
\ epsilon \ eta \gama \iota \kappa
\ lambda \ mu \ nu \omega \fi
\Pi \psi \ rho \sigma \ tau
\ theta \ upsilon \ varepsilon \ varkappa \ varphi
\ varpi \ varrho \ varsigma \ vartheta \ xi
\ zeta
540
Página 550
Griego en mayúsculas
\delta \gama \ lambda \omega \Pi

\fi
\psi \sigma \ theta \ Upsilon \ xi \ mho
\ nabla
hebreo
\ aleph \ beth \ daleth \ gimel
Delimitadores
/ [ \flecha hacia abajo \ Uparrow \ Vert \ barra invertida
\flecha hacia abajo \ langle \ lceil \ lpiso \ llcorner \ lrcorner
\ rangle \ rceil \ rfloor \ ulcorner \ uparrow \ urcorner
\ vert \{ \| \} ] |
Simbolos Grandes
\ bigcap \taza grande \ bigodot \ bigoplus \ fanáticos
\ biguplus \ bigvee \ bigwedge \ coprod \En t
\ ungüento \pinchar \suma
541
Página 551
Nombres de funciones estándar
\ pr \ arccos \ arcsin \ arctan
\ arg \ cos \aporrear \cuna
\ coth \ csc \ deg \ det

\oscuro \Exp \ gcd \ hom
\ inf \ ker \ lim

\ lg
\ liminf \ limsup \ ln \Iniciar sesión
\ max \ min \segundo \pecado
\ sinh \cenar \broncearse \ tanh
Símbolos binarios de operación y relación
\ Bumpeq \gorra \taza
\ doteq \Unirse \subconjunto

\ supset \ Vdash \ Vvdash
\ aprox \ aproxeq \ ast
\ asymp \ backepsilon \ backsim
\ backsimeq \ barwedge \porque
\Entre \ bigcirc \ bigtriangledown
\ bigtriangleup \ blacktriangleleft \ blacktriangleright

\larva del moscardón \corbata de moño \ boxdot
\ boxminus \ boxplus \ boxtimes
\bala \ bumpeq \gorra
\ cdot \ circ \ circeq
\ coloneq \ cong \taza
\ curlyeqprec \ curlyeqsucc \ curlyvee
\ cuña \trozo de cuero \ dashv
( continuacion )
542
Página 552
\ ddag \diamante \ div
\ divideontimes \ doteq \ doteqdot
\ dotplus \ doublebarwedge \ eqcirc
\ eqcolon \ eqsim \ eqslantgtr
\ eqslantless \ equiv \ Fallingdotseq
\fruncir el ceño \ geq \ geqq
\ geqslant \ gg \ ggg
\ gnapprox \ gneqq \ gnsim
\ gtrapprox \ gtrdot \ gtreqless
\ gtreqqless \ gtrless \ gtrsim
\en \ intercal \ leftthreetimes
\ leq \ leqq \ leqslant
\ lessapprox \ lessdot \ lesseqgtr
\ lesseqqgtr \ lessgtr \ lesssim
\ ll \ lll \ lnaprox
\ lneqq \ lnsim \ ltimes
\medio \ modelos \ mp
\ nVdash \ nVdash \ naprox
\ ncong \nordeste \ neq
\ neq \ nequiv \ ngeq
\ ngtr \ ni \ nleq
\ nmenos \ nmid \no en
\ nparalelo \ nprec \ nsim
( continuacion )
543
Página 553
\ nsubconjunto \ nsubseteq \ nsucc
\ n trastornado \ nsupseteq \ ntriangleft
\ ntrianglelefteq \ ntriangleright \ ntrianglerighteq

\ nvdash \ nvdash \ odot
\ ominus \ oplus \ oslash
\ otimes \paralela \ perp
\horca \pm \ prec
\ precapprox \ preccurlyeq \ preceq
\ precnapprox \ precnsim \ precsim
\ propto \ rightthreetimes \ risingdotseq

\ rtimes \ sim \ simeq
\barra oblicua \sonreír \ sqcap

\ sqcup \ sqsubset \ sqsubset
\ sqsubseteq \ sqsupset \ sqsupset
\ sqsupseteq \estrella \subconjunto
\ subseteq \ subseteqq \ subsetneq
\ subsetneqq \ succ \ succapprox
\ succcurlyeq \ successq \ succnapprox
\ succnsim \ succsim \ supset
\ supseteq \ supseteqq \ supsetneq
\ supsetneqq \por lo tanto \veces
\parte superior \ triangleleft \ trianglelefteq
\ triangleq \ triangleright \ trianglerighteq

\ uplus \ vdash \ varpropto
\ vartriangleft \ vartriangleright \ vdash
\ vee \ veebar \cuña
\ wr
544
Página 554
Símbolos de flecha
\flecha hacia abajo \flecha izquierda

\ leftrightarrow \ lleftarrow
\ longleftarrow \ longleftrightarrow
\ longrightarrow \ lsh
\ nearrow \ nwarrow
\flecha correcta \ rrightarrow
\ rsh \ Searrow
\ enjambre \ Uparrow
\ Updownarrow \ circlearrowleft
\ circlearrowright \ curvearrowleft
\ curvearrowright \ dashleftarrow
\ dashrightarrow \flecha hacia abajo
\ downdownarrows \ downharpoonleft
\ downharpoonright \ hookleftarrow
\ hookrightarrow \lleva a
\flecha izquierda \ leftarrowtail
\ leftharpoondown \ leftharpoonup
\ leftleftarrows \ leftrightarrow
\ leftrightarrows \ leftrightharpoons
\ leftrightsquigarrow \ leftsquigarrow
\ longleftarrow \ longleftrightarrow
\ longmapsto \ longrightarrow
\ looparrowleft \ looparrowright
\ mapsto \ multimap
\ nleftarrow \ nleftrightarrow
\ nrightarrow \ nearrow
\ nleftarrow \ nleftrightarrow
( continuacion )
545
Página 555
\ nrightarrow \ nwarrow
\flecha correcta \ rightarrowtail
\ rightharpoondown \ rightharpoonup
\ rightleftarrows \ rightleftarrows
\ rightleftharpoons \ rightleftharpoons
\ rightrightarrows \ rightrightarrows
\ rightsquigarrow \ Searrow
\ enjambre \a
\ twoheadleftarrow \ twoheadrightarrow
\ uparrow \ updownarrow
\ updownarrow \ upharpoonleft
\ upharpoonright \ upuparrows
Símbolos Misceláneos
PS \AUTOMÓVIL CLUB BRITÁNICO

\ Finv
\juego \estoy \pags
\re \s \ángulo
\ backprime \gran estrella \ blacksquare
\ blacktriangle \ blacktriangledown \ cdots
\marca de verificación \ circledr \ círculos
\ traje de club \complemento \derechos de autor
\ ddots \ traje de diamantes \ana
\conjunto vacio \ eth \ existe
\plano \para todos \ hbar
\ traje de corazón \ hslash \ iiint
( continuacion )
546
Página 556
\ iint \ iint \ imath
\ infty \ jmath \ ldots
\ Measuredangle \natural \ neg
\ nexists \ oiiint \parcial
\principal \agudo \ traje de spa
\ sphericalangle \ ss \ triangledown
\ varnothing \ vartriangle \ vdots
\ wp \yen
547
Página 557
APÉNDICE B
Fuentes de datos abiertas

Datos políticos y gubernamentales
Data.gov
http://data.gov
Este es el recurso para la mayoría de los datos relacionados con el gobierno.
Socrata
http://www.socrata.com/resources/
Socrata es un buen lugar para explorar datos relacionados con el gobierno. Además, proporciona
algunas herramientas de visualización para explorar datos.
Oficina del Censo de EE.UU
http://www.census.gov/data.html
Este sitio proporciona información sobre ciudadanos estadounidenses que cubren datos de población,
datos y educación.
UN3ta
https://data.un.org/
UNdata es un servicio de datos basado en Internet que ofrece bases de datos estadísticas de la ONU.
Portal de datos abiertos de la Unión Europea
http://open-data.europa.eu/en/data/
Este sitio proporciona una gran cantidad de datos de las instituciones de la Unión Europea.
549
© Fabio Nelli 2018
Página 558
APÉNDICE B FUENTES DE DATOS ABIERTAS
Data.gov.uk
http://data.gov.uk/
Este sitio del gobierno del Reino Unido incluye la bibliografía nacional británica: metadatos
en todos los libros y publicaciones del Reino Unido desde 1950.
El libro mundial de hechos de la CIA
https://www.cia.gov/library/publications/the-world-factbook/
Este sitio de la Agencia Central de Inteligencia proporciona mucha información sobre la historia,
población, economía, gobierno, infraestructura y ejército de 267 países.
Datos de salud
Healthdata.gov
https://www.healthdata.gov/
Este sitio proporciona datos médicos sobre epidemiología y estadísticas de población.
Centro de información de salud y asistencia social del NHS
http://www.hscic.gov.uk/home
Conjuntos de datos de salud del Servicio Nacional de Salud del Reino Unido.
Datos sociales
Gráfico de Facebook
https://developers.facebook.com/docs/graph-api
Facebook proporciona esta API que le permite consultar la gran cantidad de

información que los usuarios comparten con el mundo.
Topsy
http://topsy.com/
Topsy proporciona una base de datos de búsqueda de tweets públicos que se remontan a 2006, así como
varias herramientas para analizar las conversaciones.
550
Página 559
Tendencias de Google
http://www.google.com/trends/explore
Estadísticas sobre el volumen de búsqueda (como proporción de la búsqueda total) para cualquier término dado,
desde el 2004.
Botón "me gusta
http://likebutton.com/
Extrae los datos públicos de Facebook, a nivel mundial y de su propia red, para brindar una
descripción general de lo que le gusta a la gente en este momento.
Conjuntos de datos públicos y diversos

Conjuntos de datos públicos de Amazon Web Services
http://aws.amazon.com/datasets
Los conjuntos de datos públicos de Amazon Web Services proporcionan un repositorio centralizado de
conjuntos de datos públicos. Un conjunto de datos interesante es el Proyecto 1000 Genome, un intento de construir
la base de datos más completa de información genética humana. También una base de datos de la NASA
de imágenes de satélite de la Tierra está disponible.
DBPedia
http://wiki.dbpedia.org
Wikipedia contiene millones de datos, estructurados y no estructurados, en

Cada tema. DBPedia es un ambicioso proyecto para catalogar y crear un público, libremente
base de datos distribuible que permite a cualquiera analizar estos datos.
Freebase
http://www.freebase.com/
Esta base de datos comunitaria proporciona información sobre varios temas, con más de 45
millones de entradas.
551
Página 560
Gapminder
http://www.gapminder.org/data/
Este sitio proporciona datos provenientes de la Organización Mundial de la Salud y el Banco Mundial
cubriendo estadísticas económicas, médicas y sociales de todo el mundo.
Datos financieros
Finanzas de Google
https://www.google.com/finance
Cuarenta años de datos del mercado de valores, actualizados en tiempo real.
Datos climáticos
Centro Nacional de Datos Climáticos
http://www.ncdc.noaa.gov/data-access/quick-links#loc-clim
Gran colección de conjuntos de datos ambientales, meteorológicos y climáticos de EE. UU.

Centro Nacional de Datos Climáticos. El archivo de datos meteorológicos más grande del mundo.
WeatherBase
http://www.weatherbase.com/
Este sitio proporciona promedios climáticos, pronósticos y condiciones actuales para más de 40,000
ciudades de todo el mundo.
Wunderground
http://www.wunderground.com/
Este sitio proporciona datos climáticos de satélites y estaciones meteorológicas, lo que le permite
Obtenga toda la información sobre la temperatura, el viento y otras medidas climáticas.
552
Página 561
Datos deportivos
Pro-Football-Reference
http://www.pro-football-reference.com/
Este sitio proporciona datos sobre fútbol y varios otros deportes.
Publicaciones, periódicos y libros

New York Times
http://developer.nytimes.com/docs
Archivo indexado y con capacidad de búsqueda de artículos de noticias que se remontan a 1851.
Ngrams de Google Books
http://storage.googleapis.com/books/ngrams/books/datasetsv2.html
Esta fuente busca y analiza el texto completo de cualquiera de los millones de libros
digitalizado como parte del proyecto Google Books.
Datos musicales
Conjunto de datos de millones de canciones
http://aws.amazon.com/datasets/6468931156960467
Metadatos de más de un millón de canciones y piezas musicales. Parte de Amazon Web Services.
553
Página 562
Índice
UNA si
Acentos, LaTeX, 540– 547 Gráfico de barras
Agregación de datos avanzada 3D 306- 307
Aplicar () funciones, 225 barras de error, 281
función transform (), 226 horizontal, 281- 282
Anaconda, 24, 88 matplotlib, 278
Anderson Iris Dataset, ver flor de Iris multiserial 282– 284
conjunto de datos barra apilada multiserie, 286– 290
Manipulación de matrices Pandas DataFrame, 285– 286
uniendo matrices representaciones, 291
column_stack () y row_stack (), 72 gráficos de barras apiladas, 290
función hstack (), 71 eje x, 280
función vstack (), 71 función xticks (), 279
dividir matrices Métodos bayesianos, 4
función hsplit (), 72 Big Data, 353
función split (), 73- 74 Bigrams, 498
función vsplit (), 72 Redes neuronales biológicas, 361
Inteligencia artificial, 5, 350 Operación de mezcla, 520
esquematización de, 352
Redes neuronales artificiales
redes biológicas, 361 C
bordes 356 Caffe2, 355
capa oculta, 357 Tipología de gráfico, 267
capa de entrada y salida, 357 Mapas de coropletas
perceptrón multicapa, 360 Biblioteca D3, 459
nodos, 356 representaciones geográficas, 459
esquematización de, 355– 356 Función HTML (), 461– 462
SLP ( ver Perceptrón de capa única (SLP)) jinja2, 462– 463
peso, 356 JSON y TSV, 463
555
© Fabio Nelli 2018
Página 563
ÍNDICE
Mapas de coropletas ( cont .) Validación cruzada, 13

JSON TopoJSON, 460 Cython, 22
require.config (), 461
resultados, 464
Población de EE. UU., 2014
re
fuente de datos census.gov, 467 Agregación de datos
archivo TSV, códigos, 466 Aplicar () funciones, 226, 228–229
Función HTML (), 468 Agrupar por, 217
jinja2.Template, 469 función groupby (), 219
pop2014_by_county operaciones, 218
trama de datos, 465- 466 salida de, 220
población.csv, 467– 468 DIVIDIR-APLICAR-COMBINAR, 218
función render (), 470– 471 agrupación jerárquica, 220- 221
Valores SUMLEV, 464 unir(), 226
Árboles de clasificación y regresión, 12 valores numéricos y de cadena, 219
Modelos de clasificación, 12 columna precio1, 219
Datos climáticos, 552 función transform (), 225
Gráfico de barras agrupadas Análisis de los datos
Portátil IPython, 454– 455 gráficos 2
jinja2, 455, 457–458 visualización de datos, 2
función render (), 458– 459 definición, 1
Modelos de agrupamiento, 4, 11–12 fase de despliegue, 2
Colocaciones, 498 información, 6
Visión por computador, 507 conocimiento, 6
Concatenación dominios de conocimiento
matrices, 188 Ciencias de la Computación, 3
combinatorio, 191, 193 disciplinas, 3
función concat (), 189- 190 campos de aplicación, 5
marco de datos, 191 aprendizaje automático y artificial
opción de llaves, 190 inteligencia, 5
pivotante, 193 matemáticas y estadística, 4
indexación jerárquica, 193 problemas de, 3
formato largo a ancho, 195 información abierta, 15- 16
función stack (), 194 modelo predictivo, 2
función unstack (), 194 proceso
eliminación, 196 fuentes de datos, 9
Correlación, 129- 131 despliegue, 13
Covarianza 129- 131 exploración / visualización, 10- 11
556
Página 564
ÍNDICE
extracción, 9- 10 pandas.merge (), 182
validación del modelo, 13 procedimientos de, 181
fase de planificación, 9 Estructuras de datos, operaciones
modelado predictivo, 12 DataFrame y series, 121- 122
preparación, 10 aritmética flexible
definición del problema, 8 métodos, 120- 121
etapas, 6- 8 Transformación de datos
propósito de, 1 función drop_duplicates (), 199
Python y, 17 cartografía
cuantitativo y cualitativo, 14 sumando valores, 201
tipos ejes, 202
datos categóricos, 6 dict objetos, 199
datos numéricos, 6 reemplazando valores, 199
Marco de datos eliminar duplicados, 198- 199
pandas Visualización de datos
definición, 103- 105 agregando texto
dictado anidado, 111 etiquetas de eje, 251- 252
operaciones, 121 etiqueta informativa, 254
estructura, 103 expresión matemática, 254- 255
transposición, 111 modificado de, 252
estructura, 102 función text (), 253
Manipulación de datos gráfico de barras ( ver gráfico de barras)
agregación ( ver agregación de datos) tipología de cartas, 267
concatenación, 188 gráfico de contorno / mapa, 297– 299
discretización y agrupamiento, 204 análisis de los datos, 231
iteración de grupo, 222 Superficies 3D, 302, 304
permutación, 210 cuadrícula, 256
fases de, 181 cuadrículas, subtramas, 309
preparación ( ver preparación de datos) manejo de valores de fecha, 264- 267
cadena ( ver manipulación de cadenas) histograma, 277– 278
transformación, 197 instalación, 233
Preparación de datos, 181 IPython e IPython
Marco de datos, 182 QtConsole, 233, 235
operación de fusión, 182 kwargs
pandas.concat (), 182 figuras y ejes, 249
pandas.DataFrame.combine_ subtramas horizontales, 249- 250
primero (), 182 ancho de línea, 248
557
Página 565
ÍNDICE
Visualización de datos ( cont .) Aprendizaje profundo, 349, 532

función plot (), 249 artificial ( ver Artificial neural
subtramas verticales, 250- 251 redes)
leyenda inteligencia artificial, 350
gráfico de 258 disponibilidad de datos, 353
función legend (), 257, 258 aprendizaje automático, 351
gráfico multiserie, 259 redes neuronales y GPU, 352
esquina superior derecha, 257 Pitón
gráfico de líneas ( ver gráfico de líneas) marcos, 354
arquitectura matplotlib y lenguaje de programación, 354
NumPy, 247 esquematización de, 352
biblioteca matplotlib ( ver matplotlib TensorFlow ( ver TensorFlow)
biblioteca) Conjunto de datos de dígitos
mplot3d, 302 definición, 475
parcelas de paneles múltiples matriz digits.images, 477
cuadrículas, subparcelas, 309, 311 matriz digit.targets, 478
subtramas, 307- 309 dígitos escritos a mano, 477
gráficos circulares, 292 imágenes de números escritos a mano, 475
función axis (), 293 biblioteca matplotlib, 477
gráfico modificado, 294 biblioteca scikit-learn, 476
marco de datos de pandas 296 Discretización y binning, 204
función pie (), 292 cualquier función (), 210
sombra kwarg, 295 tipo categórico, 206
ventana de trazado función de corte (), 205– 206, 208–209
botones de, 241 describir () función, 209
comandos, 241 detectar y filtrar
matplotlib y NumPy, 246 valores atípicos, 209
función plt.plot (), 242, 243 qcut (), 208- 209
propiedades, 243 función std (), 210
QtConsole, 241– 242 función value_counts (), 206
carta polar, 299, 301 Django, 17
módulo pyplot, 239 Goteante, 117- 118
ahorro, gráficos
Archivo HTML, 262– 263
archivo de imagen, 264
mi
código fuente, 260– 261 Eclipse (pyDev), 41– 42
gráfico de dispersión, 3D, 304- 305 Cálculo por elementos, 47
Árboles de decisión, 11 Programación orientada a expresiones, 33
558
Página 566
ÍNDICE
F yo
Datos financieros, 552 IDE, consulte Desarrollo interactivo
Métodos aritméticos flexibles, 120- 121 entornos (IDE)
Fuentes, LaTeX, 539 Análisis de imagen
concepto de, 521
convoluciones, 523
GRAMO
definición, 507
Teoría del gradiente 523
detección de bordes, 522, 525
Unidad de procesamiento de gráficos (GPU), 353 blanco y negro.jpg
Agrupación, 11
imagen, 526– 529, 531
Iteración de grupo sistema blanco y negro, 525
cadena de transformaciones, 222, 224
función de filtros, 528
funciones en grupos gradients.jpg imagen, 532
función mark (), 224- 225
degradados grises, 525
función cuantiles (), 224 Filtros Laplacianos y Sobel, 531
Objeto GroupBy, 222
resultados, 528
código fuente, 530
H detección de rostros, 532
Reconocimiento de escritura a mano teoría del gradiente, 523
conjunto de datos de dígitos, 475– 478 OpenCV ( ver Computadora de código abierto
dígitos escritos a mano, matplotlib Visión (OpenCV))
biblioteca, 478 operaciones, 508
aprender y predecir, 478, 480, 482 representacion de, 522
Software de OCR, 473 Funciones de indexación
scikit-learn, 474– 475 aritmética y datos
estimador de svc, 480 alineación, 118, 120
TensorFlow, 480 goteante, 117- 118
conjunto de validación, seis dígitos, 479 reindexar, 114, 116
Datos de salud, 550 Integración, 47
Indexación jerárquica Entornos de desarrollo interactivos
arrays, 136- 137 (IDE)
Marco de datos, 135 Eclipse (pyDev), 41– 42
reordenamiento y los niveles de clasificación, 137- 138 Komodo, 45
función stack (), 136 Liclipse, 43– 46
niveles estadísticos, 138 NinjaIDE, 44- 45
estructura, 134 Spyder, 41
estructura bidimensional, 134 Sublime, 42– 43
559
Página 567
ÍNDICE
Lenguaje de programación interactivo, 20 Cuadernos IPython, 449

Lenguaje de programación interconectado, 20 Biblioteca Jinja2, 451– 453
Internet de las cosas (IoT), 353 marco de datos de pandas, 453
Lenguaje de programación interpretado, 20 función render (), 453
Interprete método require.config (), 450
caracterización, 21 creación de gráficos web, 450
Cython, 22 años Biblioteca Jinja2, 451– 453
Jython, 22 Jython, 22 años
PVM, 21
PyPy, 22
tokenización 21 K
IPython Clasificación de vecinos más cercanos K
e IPython QtConsole, 233– 234 límites de decisión, 325– 326
Logotipo del proyecto Jupyter, 37 Diagrama de dispersión 2D, sépalos, 324
Cuaderno, 39, 474 función predecir (), 323
DataFrames, 420 permutación aleatoria (), 323
QtConsole, 38 equipo de entrenamiento y prueba, 322
cáscara, 36
herramientas de, 35
Conjunto de datos de flores de iris L
Conjunto de datos de Anderson Iris, 316 Látex
IPython QtConsole, 316 acentos, 540– 547
Características de iris setosa, 318– 319 fuentes, 539
largo y ancho, fracciones, binomios y apilados
pétalo, 319– 320 números, 538– 539
biblioteca matplotlib, 318 con IPython Notebook
Descomposición de PCA, 320 en Markdown Cell, 537
atributo de destino, 317 en Python 2 Cell, 538
tipos de análisis, 316 con matplotlib, 537
variables, 319– 320 radicales, 539
subíndices y superíndices, 538
simbolos
J símbolos de flecha, 540, 545–546
Biblioteca D3 de JavaScript grandes símbolos, 542
gráfico de barras, 454 operación binaria y relación
Definiciones CSS, 450– 451 símbolos, 542– 543
documentos basados en datos, 449 Delimitadores, 540– 541
Biblioteca de importación de HTML, 450 Hebreo, 541
560
Página 568
ÍNDICE
griego en minúsculas, 540 atributo coef_, 329

símbolos diversos, 540 función fit (), 329
nombres de funciones estándar, 542 correlación lineal, 330
griego en mayúsculas, 541 parámetros, 328
Fase de aprendizaje, 378 factores fisiológicos y
Liclipse, 43- 46 progresión de la diabetes, 332– 333
Regresión lineal, 12 factor fisiológico único, 330
Gráfico de linea esquematización de, 352
anotar (), 274 aprendizaje supervisado, 314
puntas de flecha kwarg, 274 SVM ( consulte Máquinas vectoriales compatibles
Ejes cartesianos, 273 (SVM))
códigos de color, 270- 271 equipo de entrenamiento y prueba, 315
puntos de datos, 267 aprendizaje no supervisado, 314- 315
serie diferente, 269 Cartografía
función gca (), 273 sumando valores, 201– 202
Caracteres griegos, 272 opción inplace, 204
Expresión LaTeX, 274 función renombrar (), 204
estilos de línea y color, 270 cambio de nombre, ejes, 202, 204
expresiones matemáticas, 275 reemplazando valores, 199, 201
función matemática, 268 Expresiones matemáticas con LaTeX,
pandas 276 ver LaTeX
función plot (), 268 MATLAB, 17
función set_position (), 273 matplotlib, 48
funciones xticks () y yticks (), 271 biblioteca matplotlib
Distribución de Linux, 90 arquitectura
Diagrama de nubes LOD, 16 capa de artista, 236- 238
Regresión logística, 12 capa de backend, 236
funciones y herramientas, 235
capas, 235
METRO pylab y pyplot, 238- 239
Aprendizaje automático (ML), 5 capa de secuencias de comandos (pyplot), 238
proceso de desarrollo de algoritmos, 313 capa de artista
aprendizaje profundo, 351 representación gráfica, 237
conjunto de datos de diabetes, 327– 328 estructura jerárquica, 236
características / atributos, 314 primitivo y compuesto, 237
Conjunto de datos de flores de iris, 316 representación grafica, 231, 233
problema de aprendizaje, 314 Látex, 232
regresión lineal / de mínimos cuadrados NumPy, 246
561
Página 569
ÍNDICE
Producto de matriz, 60 Cuaderno Jupyter, 415

Operación de fusión acceder a datos internos, 417
Trama de datos, 183- 184 línea de comando, 415
objetos de marco de datos, 183 marco de datos, 419– 420
índice, 187 procedimientos de extracción, 418
unirse a la función (), 187- 188 Ferrara, 416
ÚNETE a la operación, 182 Archivo JSON, 416
índice_izquierdo / índice_derecha función json.load (), 415
opciones, 187 parámetros, 419
unión izquierda, unión derecha y preparar () función, 420
unión externa, 186 RoseWind ( ver RoseWind)
left_on y right_on, 185, 187 velocidad del viento, 441
función merge (), 183, 184 Archivos de Microsoft Excel
Datos meteorológicos, 409 marco de datos, 162
Mar Adriático y Valle del Po, 410 data.xls, 160, 162
ciudades 412 módulo interno xlrd, 160
Comacchio, 413 función read_excel (), 161
imagen de, 411 MongoDB, 178– 179
zonas montañosas, 410 Perceptrón multicapa (MLP)
estándares de referencia, 412 redes artificiales, 360
El sitio web de TheTimeNow, 413 evaluación de, 404
clima, 409 datos experimentales, 404
fuente de datos capas ocultas, 397
Archivo JSON, 414 Sesión de ipython, 387
Sitio del mapa del tiempo, 414 fase de aprendizaje, 389
Cuaderno de IPython definición de modelo, 387
representación gráfica, 425, 429, 431 fase de prueba y precisión
Archivos CSV, 421 cálculo, 395, 402
DataFrames, 422, 432 Datos musicales, 553
función de humedad, 433– 435
regresión lineal, 431
biblioteca matplotlib, 423
norte
Milán, 423 Kit de herramientas de lenguaje natural (NLTK)
función read_csv (), 421 bigrams y colocaciones, 498
resultado, 423 función common_contexts (), 493
función shape (), 422 función concordancia (), 493
Método SVR, 428– 429 corpora, 488
temperatura, 424, 426–427, 432 herramienta de descarga, 489
562
Página 570
ÍNDICE
función fileids (), 491 incrementar y decrementar

Páginas HTML, texto, 501 operadores, 60- 61
función len (), 491 producto de matriz, 59– 60
biblioteca, 489 ufunc, 61
variable macbeth, 491 radiodifusión
Biblioteca de Python, 488 compatibilidad, 77
función request (), 502 casos complejos, 78– 79
seleccionar palabras, 497 operador / función, 76
análisis sentimental, 502 BSD, 50
función sents (), 492 condiciones y matrices booleanas, 69
función similar (), 494 copias / vistas de objetos, 75
texto, red, 500 análisis de los datos, 49
frecuencia de palabras, 494 indexación, 63
variable macbeth, 495 matriz bidimensional, 64
función most_common (), 494 ndarray monodimensional, 63
función nltk.download (), 495 valor de índice negativo, 63
Función nltk.FreqDist (), 494 instalación, 50
Para las palabras, 495 iterando una matriz, 67– 69
función string (), 496 ndarray ( ver Ndarray)
búsqueda de palabras, 493 Numarray, 49 años
Ndarray, 47 años lenguaje python, 49
función array (), 51– 53 leer y escribir datos de matriz, 82
tipos de datos, 53– 54 manipulación de formas, 70- 71
dtype (tipo de datos), 50, 54 rebanar, 65– 66
creación intrínseca, 55- 57 matrices estructuradas, 79
función type (), 51– 52 vectorización, 76
MÓDULO DE NARIZ, 91
Datos "No es un número"
llenado, ocurrencias de NaN, 133
O
filtrando NaN Lenguaje de programación orientado a objetos, 20
valores, 132- 133 OCR, consulte Reconocimiento óptico de caracteres
Valor de NaN, 131- 132 (OCR) software
Biblioteca NumPy Datos abiertos, 15- 16
manipulación de matrices ( ver Matriz Fuentes de datos abiertas, 353
manipulación) datos climáticos, 552
operaciones básicas demografia
funciones agregadas, 62 Cuaderno de IPython, 446
operadores aritméticos, 57– 59 matplotlib, 449
563
Página 571
ÍNDICE
Fuentes de datos abiertas ( cont .) Reconocimiento óptico de caracteres (OCR)

marcos de datos de pandas, 446– 447 software, 473
marco de datos pop2014_by_state, 448 función order (), 127
marco de datos pop2014, 447– 448
Censo de Estados Unidos
Bureau, 445– 446
PAGS
datos financieros, 552 Pandas dataframes, 446, 453
datos de salud, 550 Estructuras de datos de pandas
miscelánea y pública Trama de datos, 102- 105
conjuntos de datos, 551– 552 asignar valores, 107– 109
datos musicales, 553 borrar columna, 110
político y gubernamental selección de elementos, 105- 107
datos, 549– 550 filtrado, 110
publicaciones, periódicos, valor de membresía, 109– 110
y libros, 553 dictado anidado, 111
datos sociales, 550– 551 transposición, 111
datos deportivos, 553 evaluar valores, 98– 99
Visión por computadora de código abierto (OpenCV) objetos de índice, 112
aprendizaje profundo, 509 etiquetas duplicadas, 112- 113
procesamiento y análisis de imágenes, 509 métodos, 112
función add (), 515 Valores de NaN, 99, 101
imagen negruzca, 518 Matrices NumPy y existentes
mezcla, 520 serie, 96– 97
método destroyWindow (), 512 operaciones, 120- 122
operaciones elementales, 514 operaciones y matemática
método imread (), 510 funciones, 97– 98
método imshow (), 511 serie, 93
carga y visualización, 510 asignar valores, 95
método merge (), 513 declaración, 94
Matrices NumPy, 519 diccionarios, 101
opción de ahorro, 514 filtrado de valores, 97
método waitKey (), 511 índice, 93
proceso de trabajo, 512 elementos internos, selección, 95
instalación, 509 operaciones, 102
Paquetes MATLAB, 508 Biblioteca Pandas, 87
empezar a programar, 510 correlación y covarianza, 129- 131
Programación de código abierto estructuras de datos ( ver datos de Pandas
idioma, 21 estructuras)
564
Página 572
ÍNDICE
aplicación de funciones y mapeo PostgreSQL, 174

elemento, 123 Análisis de componentes principales
fila / columna, 123, 125 (PCA), 320, 322
estadística, 125 Conjuntos de datos públicos, 551– 552
empezar, 92 PVM, consulte máquina virtual Python (PVM)
indexación jerárquica y módulo pyplot
nivelación, 134-135 , 137-138 gráfico interactivo, 239
índices ( ver funcionalidades de indexación) Objeto Line2D, 240
instalación ventana de trazado, 240
Anaconda, 88– 89 función show (), 240
fases de desarrollo, 91 Intérprete PyPy, 22
Linux, 90 Pitón, 17
repositorio de módulos, Windows, 90 biblioteca de análisis de datos, 87– 88
PyPI, 89 aprendizaje profundo, 354
fuente, 90 marcos, 354
pruebas, 91 módulo, 91
Datos "No es un número", 131- 134 OpenCV, 508
análisis de datos pitón, 87- 88 Índice de paquetes de Python (PyPI), 39, 89
ordenar y clasificar, 126- 129 El mundo de Python
Permutación implementación de código, 28
matriz new_order, 211 distribuciones, 24
función np.random.randint (), 211 Anaconda, 24
numpy.random.permutation () Canopy enthought, 26
función, 210 Python (x, y), 26
muestreo aleatorio, 211 IDE ( consulte Desarrollo interactivo
Marco de datos, 211 entornos (IDE))
función take (), 211 instalación, 23- 24
Pickle: serialización de objetos de Python interactuar, 28
cPickle, 168 intérprete ( ver intérprete)
frame.pkl, 170 IPython ( ver IPython)
biblioteca de pandas, 169 lenguaje de programación, 19- 21
flujo de bytes, 168 PyPI, 39
Política y gobierno Python 2, 23
datos, 549– 550 Python 3, 23
marco de datos pop2014_by_county, 465 en ejecución, código de programa completo, 27
marco de datos pop2014_by_state, 448– 449 Ciencia
marco de datos
Lenguaje pop2014, 447–
de programación 448 20
portátil, bibliotecas, 46
matplotlib, 48
565
Página 573
ÍNDICE
El mundo de Python ( cont .) myCSV_03.csv, 145

NumPy, 47 opción de nombres, 145
pandas, 47 función read_csv (), 143, 145
cáscara, 26 función read_table (), 143
código fuente extensión .txt, 142
estructura de datos, 30 bases de datos
diccionarios y listas, 31 función create_engine (), 171
programación funcional, 33 marco de datos, 175
Hola Mundo, 28 módulo pandas.io.sql, 171
índice, 32 pgAdmin III, 175- 176
bibliotecas y funciones, 30 PostgreSQL, 174
función map (), 33 función read_sql (), 172
Operaciones matemáticas, 29 función read_sql_query (), 177
función print (), 29 función read_sql_table (), 177
escribir código python, sqlalchemy, 171
sangría, 34– 35 sqlite3, 171
Máquina virtual Python (PVM), 21 Objetos DataFrame, 141
PyTorch, 355 funcionalidades, 141
Biblioteca HDF5
estructuras de datos, 167
Q HDFStore, 167
Analisis cualitativo, 14 formato de datos jerárquico, 166
Análisis cuantitativo, 14 mydata.h5, 167
Archivos HTML
estructuras de datos, 152
R read_html (), 155
R, 17 web_frames, 156
Función de base radial (RBF), 340 páginas web, 152
Radicales, LaTeX, 539 raspado web, 152
Clasificación, 128- 129 Herramientas API de E / S, 141- 142
Matriz de lectura y escritura Datos JSON
archivos binarios, 82 books.json, 164
datos tabulares, 83- 84 frame.json, 164
Leer y escribir datos función json_normalize (), 165
Archivos CSV y textuales JSONViewer, 162– 163
opción de encabezado, 144 normalización, 164
opción index_col, 145 read_json () y to_json (), 162
myCSV_01.csv, 143 función read_json (), 164- 165
566
Página 574
ÍNDICE
Archivos de Microsoft Excel, 159 Análisis sentimental, 502

Base de datos NoSQL document_features ()
función insertar (), 179 función, 504
MongoDB, 178– 180 documentos, 503
pickle: serialización de objetos de Python, 168 función list (), 504
RegExp críticas de cine, 503
metacaracteres, 146 opinión negativa / positiva, 505
read_table (), 146 minería de opinión, 502
saltos, 148 Manipulación de formas
TXT, 147- 148 función reshape (), 70
opciones nrows y skiprows, 149 atributo de forma, 70
porción por porción, 149 función transpose (), 71
escritura ( ver Escritura de datos) Perceptrón de capa única (SLP), 371
XML ( ver XML) precisión, 359
Modelos de regresión, 4, 12 función de activación, 358, 359
Reindexar, 114- 116 arquitectura, 357
RoseWind optimización de costes, 382
DataFrame, 436– 437 análisis de los datos, 372
matriz hist, 438– 439 fase de evaluación, 359
carta polar, 438, 440–441 fase de aprendizaje, 359, 378
representación del diagrama de dispersión, 438 definición de modelo, 374
función showRoseWind (), 439, 441 explícitamente, 376
implícitamente, 376
fase de aprendizaje, 375
S marcadores de posición, 376
Biblioteca Scikit-learn, 473 función tf.add (), 377
análisis de los datos, 474 función tf.nn.softmax (), 377
k-clasificación de vecinos más cercanos, 322 módulos, 372
PCA, 320 representación, 358
Módulo de Python, 313 equipo de prueba, 385
sklearn.svm.SVC, 475 fase de prueba y precisión
aprendizaje supervisado, 315 cálculo, 383
módulo svm, 475 conjuntos de entrenamiento, 359
Ciencia Datos sociales, 550
bibliotecas, 46 función sort_index (), 126-128 , 138
matplotlib, 48 Datos deportivos, 553
NumPy, 47 SQLite3, 171
pandas 47 función stack (), 136
567
Página 575
ÍNDICE
Manipulación de cuerdas límites de decisión, 342

métodos incorporados límites de decisión lineal, 342– 343
función count (), 214 límites de decisión polinomial, 344
mensaje de error, 214 núcleo polinomial, 343– 344
index () y find (), 213 Núcleo RBF, 344
función join (), 213 conjunto de entrenamiento, 342
función reemplazar (), 214 SVC ( consulte Clasificación de vectores de soporte
función split (), 212 (SVC))
función strip (), 212 SVR ( consulte Regresión vectorial de soporte
expresiones regulares (RVS))
función findall (), 215- 216 Soporte de regresión vectorial (SVR)
función match (), 216 curvas, 347
función re.compile (), 215 conjunto de datos de diabetes, 345
expresiones regulares, 214 modelo predictivo lineal, 345
función re.split (), 215 equipo de prueba, datos, 345
función split (), 215 función swaplevel (), 137
Matrices estructuradas
opción dtype, 79, 81
estructuras / registros, 79
T
Interpretaciones subjetivas, 14 TensorFlow, 349, 354, 362, 480
Subíndices y superíndices, gráfico de flujo de datos, 362
LaTeX, 538 Marco de Google, 362
Aprendizaje supervisado instalación, 363
aprendizaje automático, 314 IPython QtConsole, 364
scikit-learn, 315 MLP ( ver Perceptrón multicapa
Clasificación de vectores de soporte (SVC), 475 (MLP))
área de decisión, 336 modelo y sesiones, 364
efecto, límite de decisión, 338– 339 SLP ( ver Perceptrón de capa única (SLP))
no lineal, 339– 341 tensores
número de puntos, parámetro C, 337– 338 operación, 370
función predecir (), 336– 337 parámetros, 366
regularización, 337 función print (), 368
matriz de support_vectors, 337 representaciones de, 367
conjunto de formación, espacio de decisión, 334– 336 función tf.convert_to_tensor (), 368
Soporta máquinas de vectores (SVM) método tf.ones (), 369
espacio decisional, 334 función tf.random_normal (), 369
límite de decisión, 334 función tf.random_uniform (), 369
Conjunto de datos de iris método tf.zeros (), 368
568
Página 576
ÍNDICE
Técnicas de análisis de texto Función ShowRoseWind_Speed (), 442

definición, 487 función to_csv (), 443
NLTK ( ver Kit de herramientas de lenguaje natural Escribiendo datos
(NLTK)) Archivos HTML
técnicas, 488 myFrame.html, 155
Theano, 355 función to_html (), 153- 154
función trigrams (), 499 opción na_rep, 151
función to_csv (), 150- 151
U, V
Oficina del censo de Estados Unidos, 445 a 446 X, Y, Z
Funciones universales (ufunc), 61 XML
Aprendizaje sin supervisión, 314 books.xml, 157- 158
getchildren (), 158
función getroot (), 158
W estructura de árbol lxml.etree, 159
Raspado web, 4, 10 biblioteca lxml, 157
Velocidad del viento objetivar, 158
representación de carta polar, 442 función parse (), 158
Función RoseWind_Speed (), 441 atributo de etiqueta, 158
Función ShowRoseWind (), 442 atributo de texto, 159
569

Python Data Analytics - With Pandas, NumPy, and Matplotlib

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Python Data Analytics - With Pandas, NumPy, and Matplotlib

Cargado por

Copyright:

Formatos disponibles

30/8/2020 Con Pandas, NumPy y Matplotlib - Segunda edición - Fabio Nelli

Análisis de datos de Python

Con Pandas, NumPy,

Análisis de datos de Python

ISBN-13 (pbk): 978-1-4842-3912-4 ISBN-13 (electrónico): 978-1-4842-3913-1

Número de control de la Biblioteca del Congreso: 2018957991

Copyright © 2018 por Fabio Nelli

Director gerente, Apress Media LLC: Welmoed Spahr

Imagen de portada diseñada por Freepik (www.freepik.com)

Impreso en papel sin ácido

“La ciencia nos hace avanzar en el conocimiento, pero solo el análisis

Sobre el Autor ............................................... .................................................. ..xvii

Acerca del revisor técnico .............................................. .................................. xix

Capítulo 1: Introducción al análisis de datos .......................................... ................. 1

Dominios de conocimiento del analista de datos ............................................ .......................................... 3

Comprensión de la naturaleza de los datos ............................................ .............................................. 5

El proceso de análisis de datos .............................................. .................................................. ............ 6

Información abierta ................................................ .................................................. ................................ 15

Python y análisis de datos .............................................. .................................................. ............ 17

Conclusiones ................................................. .................................................. .............................. 17

Capítulo 2: Introducción al mundo de Python .......................................... ............... 19

PyPI: el índice de paquetes de Python ............................................ .................................................. 39

Conclusiones ................................................. .................................................. .............................. 48

Capítulo 3: La biblioteca NumPy ............................................ .................................... 49

La instalación de NumPy ............................................... .................................................. .............. 50

Operaciones básicas ................................................ .................................................. ....................... 57

Indexación, corte e iteración ............................................ .................................................. ...... 62

Condiciones y matrices booleanas .............................................. .................................................. ... 69

Manipulación de matrices ................................................ .................................................. .................... 71

Conceptos generales ................................................ .................................................. ...................... 74

Matrices estructuradas ................................................ .................................................. ...................... 79

Conclusiones ................................................. .................................................. .............................. 84

Capítulo 4: La biblioteca de pandas: una introducción ......................................... .......... 87

Instalación de pandas ............................................... .................................................. ................. 88

Empezando con pandas .............................................. .................................................. ....... 92

Otras funcionalidades en índices .............................................. ................................................. 114

Aplicación y asignación de funciones .............................................. .............................................. 122

Clasiﬁcación y clasiﬁcación ............................................... .................................................. ................ 126

Correlación y covarianza ............................................... .................................................. ...... 129

Indexación y nivelación jerárquica .............................................. ............................................. 134

Capítulo 5: pandas: lectura y escritura de datos ......................................... ............. 141

Archivos CSV y textuales .............................................. .................................................. ................ 142

Lectura de datos en archivos CSV o de texto ........................................... .................................................. 143

Lectura y escritura de archivos HTML ............................................. .................................................. 152

Leyendo datos desde XML .............................................. .................................................. ............ 157

Lectura y escritura de datos en archivos de Microsoft Excel .......................................... ........................ 159

Datos JSON ................................................ .................................................. ............................... 162

El formato HDF5 ............................................... .................................................. ..................... 166

Pickle — Serialización de objetos Python ............................................. ............................................ 168

Interactuar con bases de datos ............................................... .................................................. ...... 170

Conclusiones ................................................. .................................................. ............................ 180

Capítulo 6: pandas en profundidad: manipulación de datos ......................................... .......... 181

Transformación de datos ................................................ .................................................. ................ 197

Discretización y agrupamiento ............................................... .................................................. ....... 204

Permutación ................................................. .................................................. ........................... 210

Manipulación de cadenas ................................................ .................................................. ................. 212

Agregación de datos ................................................ .................................................. .................... 217

Agregación de datos avanzada ............................................... .................................................. ..... 225

Capítulo 7: Visualización de datos con matplotlib ........................................... ........... 231

Instalación ................................................. .................................................. ............................. 233

La QtConsole de IPython e IPython ............................................. ............................................. 233

La arquitectura matplotlib ............................................... .................................................. ...... 235

pyplot ................................................. .................................................. ..................................... 239