Temario curso

Tema 1: Introducción

• ¿Por qué PySpark?
  • Tomándolo desde el principio: ¿Qué es Spark?
  • PySpark = Spark + Python.
  • ¿Por qué PySpark?
• Tu propia fábrica: cómo funciona PySpark.
  • Algo de planificación física con el administrador de clústeres.
  • Una fábrica hecha eficiente a través de un líder perezoso.

Tema 2: Tu primer programa de datos en PySpark

• Configuración del shell de PySpark.
  • El punto de entrada de SparkSession.
  • Configuración de qué tan parlanchín es Spark: el nivel de registro.
• Mapeo de nuestro programa.
• Ingesta y exploración: Preparando el escenario para la transformación de datos.
  • Lectura de datos en un marco de datos con spark.read.
  • De la estructura al contenido: Explorando nuestro marco de datos con show().
• Transformaciones simples de columnas: Pasar de una oración a una lista de palabras.
  • Selección de columnas específicas mediante select().
  • Transformación de columnas: división de una cadena en una lista de palabras.
  • Cambiar el nombre de las columnas: alias y withColumnRenamed.
  • Remodelar los datos: Dividir una lista en filas.
  • Trabajar con palabras: Cambiar mayúsculas y minúsculas y eliminar signos de puntuación.
• Filtrado de filas.

Tema 3: Envío y escalado de tu primer programa PySpark

• Agrupación de registros: Conteo de frecuencias de palabras.
• Ordenar los resultados en la pantalla usando orderBy.
• Escribir datos desde un marco de datos.
• Poniéndolo todo junto: Contando.
  • Simplificación de las dependencias con las convenciones de importación de PySpark.
  • Simplificando nuestro programa a través del encadenamiento de métodos.
• Uso de spark-submit para iniciar el programa en modo por lotes.
• Lo que no sucedió en este capítulo.
• Ampliación de nuestro programa de frecuencia de palabras.

Tema 4: Análisis de datos tabulares con pyspark.sql

• ¿Qué son los datos tabulares?
  • ¿Cómo representa PySpark los datos tabulares?
• PySpark para analizar y procesar datos tabulares.
• Lectura y evaluación de datos delimitados en PySpark.
  • Un primer paso en el SparkReader especializado para archivos CSV.
  • Personalización del objeto SparkReader para leer archivos de datos CSV.
  • Explorando la forma de nuestro universo de datos.
• Conceptos básicos de la manipulación de datos: seleccionar, eliminar, cambiar el nombre, ordenar, diagnosticar.
  • Saber lo que queremos: Seleccionar columnas.
  • Mantener lo que necesitamos: Eliminar columnas.
  • Creando lo que no está: Nuevas columnas con withColumn().
  • Ordenar nuestro marco de datos: Renombrar y reordenar columnas.
  • Diagnóstico de un marco de datos con describe() y summary().

Tema 5: Gimnasia de marco de datos: Unir y agrupar

• De muchos a uno: Uniendo datos.
  • ¿Qué es qué en el mundo de las uniones?
  • Distinguiendo nuestra izquierda de nuestra derecha.
  • Las reglas para una combinación correcta: los predicados.
  • ¿Cómo se hace?: El método de unión.
  • Convenciones de nomenclatura en el mundo de la unión.
• Resumen de los datos a través de groupby y GroupedData.
  • Un simple plano de agrupación.
  • Una columna es una columna: usando agg() con definiciones de columna personalizadas.
• Cuidado de los valores nulos: Quitar y rellenar.
  • Soltarlo como si estuviera caliente: usar dropna() para eliminar registros con valores nulos.
  • Rellenando valores a nuestro antojo usando fillna().
• ¿Cuál era nuestra pregunta de nuevo? Nuestro programa de principio a fin.

Tema 6: Marcos de datos multidimensionales: Uso de PySpark con datos JSON

• Lectura de datos JSON: Preparándose para el schemapocalypse.
  • Empezando con algo pequeño: datos JSON como un diccionario de Python limitado.
  • Ir a lo grande: lectura de datos JSON en PySpark.
• Rompiendo la segunda dimensión con tipos de datos complejos.
  • Cuando tiene más de un valor: La matriz.
  • El tipo de mapa: Claves y valores dentro de una columna.
• La estructura: Anidamiento de columnas dentro de columnas.
  • Navegar por las estructuras como si fueran columnas anidadas.
• Construcción y uso del esquema de marco de datos.
  • Usar tipos de Spark como bloques base de un esquema.
  • Lectura de un documento JSON con un esquema estricto.
  • Cerrando el círculo: Especificación de los esquemas en JSON.
• Ponerlo todo junto: Reducir los datos duplicados con tipos de datos complejos.
  • Llegar al marco de datos "correcto": Explotar y recopilar.
  • Creación de sus propias jerarquías: Struct como una función.

Tema 7: PySpark bilingüe: Mezcla de código Python y SQL

• Apostando por lo que conocemos: pyspark.sql vs. SQL simple.
• Preparación de una trama de datos para SQL.
  • Promoción de un marco de datos a una tabla de Spark.
  • Uso del catálogo de Spark.
• SQL y PySpark.
• Uso de sintaxis similar a SQL dentro de métodos de marco de datos.
  • Obtenga las filas y columnas que desee: seleccione y dónde.
  • Agrupar registros similares: agrupar por y ordenar por.
  • Filtrado después de agrupar mediante having.
  • Creación de nuevas tablas/vistas mediante la palabra clave CREATE.
  • Agregar datos a nuestra tabla usando UNION y JOIN.
  • Organizar mejor el código SQL a través de subconsultas y expresiones de tabla comunes.
  • Un resumen rápido de la sintaxis de PySpark vs. SQL.
• Simplificando nuestro código: Combinando SQL y Python.
  • Uso de Python para aumentar la resiliencia y simplificar la etapa de lectura de datos.
  • Uso de expresiones de estilo SQL en PySpark.
• Conclusión.

Tema 8: Extendiendo PySpark con Python: RDD y UDFs

• PySpark, estilo libre: El RDD.
  • Manipulación de datos a la manera RDD: map(), filter() y reduce().
• Uso de Python para extender PySpark a través de UDF.
  • Todo comienza con Python simple: usando funciones de Python con tipo.
  • De la función de Python a las UDF usando udf().

Tema 9: Big data es solo un montón de small data: Usando UDFs de pandas

• Transformaciones de columnas con pandas: Uso de series UDF.
  • Conectando Spark a BigQuery de Google.
  • UDF de serie a serie: Funciones de columna, pero con pandas.
  • UDF escalar + arranque en frío = Iterador de UDF de serie.
• UDF en datos agrupados: Agregar y aplicar.
  • Agrupar UDF agregadas.
  • Mapa de grupo UDF.
• Qué usar, cuándo.

Tema 10: Sus datos bajo una lente diferente: Funciones de la ventana

• Crecimiento y uso de una función de ventana simple.
  • Identificar el día más frío de cada año, el camino largo.
  • Creación y uso de una sencilla función de ventana para obtener los días más fríos.
  • Comparando ambos enfoques.
• Más allá de resumir: Uso de funciones analíticas y de clasificación.
  • Funciones de clasificación: Rápido, ¿quién es el primero?
  • Funciones analíticas: Mirando hacia atrás y hacia adelante.
• ¡Flexiona esas ventanas! Uso de límites de fila y rango.
  • Conteo, estilo de ventana: Estático, creciente, ilimitado.
  • Lo que eres vs. dónde estás: Rango vs. filas.
• Cerrando el círculo: Uso de UDF dentro de ventanas.
• Mirar en la ventana: Los pasos principales para una función de ventana exitosa.

Tema 11: PySpark más rápido: Descripción de la planificación de consultas de Spark

• Ábrete sésamo: Navegar por la interfaz de usuario de Spark para comprender el entorno.
  • Revisión de la configuración: La pestaña de entorno.
  • Mayor que la suma de sus partes: la pestaña Ejecutores y la administración de recursos.
  • Observe lo que ha hecho: Diagnóstico de un trabajo completado a través de la interfaz de usuario de Spark.
  • Asignación de las operaciones a través de planes de consulta de Spark: la pestaña SQL.
  • El núcleo de Spark: los planes analizados, analizados, optimizados y físicos.
• Pensando en el rendimiento: Operaciones y memoria.
  • Operaciones estrechas vs. anchas.
  • Almacenamiento en caché de un marco de datos: potente, pero a menudo mortal (para el rendimiento).

Tema 12: Preparando el escenario: Preparando las características para el aprendizaje automático

• Lectura, exploración y preparación de nuestro conjunto de datos de aprendizaje automático.
  • Estandarización de nombres de columna mediante toDF().
  • Exploramos nuestros datos y obtenemos nuestras primeras columnas de características.
  • Abordamos los contratiempos con los datos y creamos nuestro primer conjunto de funciones.
  • Eliminar registros inútiles e imputar características binarias.
  • Cuidado de los valores extremos: Limpieza de columnas continuas.
  • Eliminación de las columnas de ocurrencia binaria poco frecuentes.
• Creación y refinamiento de funciones.
  • Creación de características personalizadas.
  • Eliminación de características altamente correlacionadas.
• Preparación de características con transformadores y estimadores.
  • Imputación de características continuas mediante el estimador Imputer.
  • Escalado de nuestras funciones mediante el estimador MinMaxScaler.

Tema 13: Aprendizaje automático robusto con ML Pipelines

• Transformadores y estimadores: los componentes básicos de ML en Spark.
  • Los datos entran, los datos salen: El Transformador.
  • Entran los datos, sale el transformador: el estimador.
• Creación de una canalización de aprendizaje automático (completa).
  • Ensamblar el conjunto de datos final con el tipo de columna vectorial.
  • Entrenamiento de un modelo de ML mediante un clasificador LogisticRegression.
• Evaluar y optimizar nuestro modelo.
  • Evaluación de la precisión del modelo: Matriz de confusión y objeto evaluador.
  • Verdaderos positivos vs. falsos positivos: La curva ROC.
  • Optimización de hiperparámetros con validación cruzada.
• Obtención de los mayores impulsores de nuestro modelo: Extracción de los coeficientes.

Tema 14: Creación de transformadores y estimadores de ML personalizados

• Creación de su propio transformador.
  • Diseño de un transformador: Pensar en términos de parámetros y transformación.
  • Creación de los parámetros de un transformador.
  • Getters and setters: Ser un buen ciudadano de PySpark.
  • Creación de la función de inicialización de un transformador personalizado.
  • Creando nuestra función de transformación.
  • Usando nuestro transformador.
• Creación de su propio estimador.
  • Diseño de nuestro estimador: Del modelo a los parámetros.
  • Implementando el modelo complementario: Creando nuestro propio Mixin.
  • Creación del estimador ExtremeValueCapper.
  • Probando nuestro estimador personalizado.
• Uso de nuestro transformador y estimador en una tubería de ML.
  • Tratar con múltiples entradasCols.
  • En la práctica: Inserción de componentes personalizados en una canalización de ML.