Dataframe en Apache PySpark: tutorial completo [con ejemplos]

Hoy vamos a aprender sobre DataFrame en Apache PySpark . Pyspark es una de las principales herramientas de ciencia de datos en 2020. Se denomina columnas de una colección distribuida de filas en Apache Spark. Es muy similar a las tablas o columnas en las hojas de Excel y también similar a la tabla de la base de datos relacional. PySpark DataFrame también tiene características similares a RDD, que son:

Distribuido: la naturaleza de DataFrame y RDD es distribuida

Evaluaciones perezosas: la ejecución de la tarea no se realiza si la acción no se realiza

Naturaleza de Inmutable: Otra característica similar de RDD/DataFrame es que no se puede cambiar una vez creado. Pero uno puede aplicar la transformación para transformar el RDD/DataFrame.

Ventaja de los marcos de datos

1. Esto es compatible con varios lenguajes, como Java, Scala, R, Python, lo cual es útil en términos de compatibilidad con API. El soporte API para múltiples idiomas ayuda a trabajar con muchos lenguajes de programación.

2. DataFrame admite una amplia gama de fuentes y formatos de datos, lo que ayuda mucho a utilizar una fuente de datos diferente y su formato de manera conveniente.

3. Una de las mejores partes de DataFrame es que incluso puede manejar petabytes de datos, lo cual es una capacidad notable para manejar datos tan masivos.

4. Apache Spark comprende rápidamente el esquema de DataFrame con la observación en Spark DataFrame. En columnas con nombre, se organiza la observación de Spark DataFrame. De esta forma, se optimiza el plan de ejecución de consultas.

5. El volumen masivo de datos semiestructurados y estructurados se puede procesar rápidamente porque está diseñado para hacerlo en marcos de datos.

Configuración de Apache Spark

Apache Spark debe configurarse en la máquina antes de que pueda comenzar a usarse para las operaciones de DataFrame. Los datos se pueden operar con el soporte de DataFrame, ya que admite varias operaciones de DataFrame. Aquí vamos a discutir algunas operaciones comunes de DataFrame.

La creación de SparkContext es el primer paso en la programación de Apache. Para la ejecución de operaciones en un clúster, existe un requisito de SparkContext. SparkContext explica cómo acceder a un clúster. También muestra el Spark sobre la ubicación para obtener un clúster.

Leer: Marcos de aprendizaje profundo

Luego se establece la conexión de Apache Cluster. Su creación ya está hecha si se está usando Spark Shell. La otra forma, la configuración, se puede proporcionar, inicializar e importar para la creación de SparkContext.

Uno puede usar este código para la creación:

desde pyspark importar SparkContext

sc = SparkContext()

Creación de DataFrame a partir de un archivo CSV

Se debe especificar una nueva biblioteca en el shell de python para que se pueda leer el archivo CSV. Para hacer esto, el primer paso es descargar la última versión del paquete Spark-CSV y realizar la extracción del paquete en el directorio de inicio de Spark. Después de eso, abriremos el shell de PySpark y el paquete debe estar incluido.

$ ./bin/pyspark –paquetes com.databricks:spark-csv_2.10:1.3.0

Ahora el marco de datos se creará después de que se hayan leído los datos del archivo CSV.

tren = sqlContext.load(fuente=”com.databricks.spark.csv”, ruta = 'RUTA/tren.csv', encabezado = Verdadero,inferSchema = Verdadero)

prueba = sqlContext.load (fuente = "com.databricks.spark.csv", ruta = 'PATH/test-comb.csv', encabezado = True, inferSchema = True)

Los archivos CSV de prueba y los archivos CSV de entrenamiento se encuentran en la ubicación de la carpeta llamada PATH. Si el encabezado está en el archivo CSV, se mostrará como verdadero. Para saber el tipo de datos en cada columna del marco de datos, usaremos la opción inferSchema = True. Al usar la opción inferSchema = True, el contexto de SQL detectará automáticamente la detección del tipo de datos de cada columna del marco de datos. Todas las columnas se leerán como una cadena si no configuramos inferSchema como verdadero.

Leer: Bibliotecas de Python para aprendizaje automático

Manipulación de DataFrame

Ahora aquí vamos a ver cómo manipular el Data Frame:

• Conocer el tipo de datos de las columnas

printSchema se utilizará para ver el tipo de columna y su tipo de datos. Ahora el esquema se imprimirá en formato de árbol aplicando printSchema().

entrenar.imprimirEsquema()

Producción:

raíz

|– User_ID: entero (anulable = verdadero)

|– Product_ID: cadena (anulable = verdadero)

|– Género: cadena (anulable = verdadero)

|– Edad: cadena (anulable = verdadero)

|– Ocupación: entero (anulable = verdadero)

|– City_Category: cadena (anulable = verdadero)

|– Stay_In_Current_City_Years: cadena (anulable = verdadero)

|– Marital_Status: entero (anulable = verdadero)

|– Product_Category_1: entero (anulable = verdadero)

|– Product_Category_2: entero (anulable = verdadero)

|– Product_Category_3: entero (anulable = verdadero)

|– Compra: entero (anulable = verdadero)

Después de leer el archivo csv, podemos ver que obtuvimos con precisión el tipo de datos o el esquema de cada columna en el marco de datos.

• Mostrando la primera n observación

Para ver la primera observación n, se puede usar la operación de cabeza. La operación principal de Pandas es la misma que la operación principal de PySpark.

tren.cabeza(5)

Producción:

[Row(User_ID=1000001, Product_ID=u'P00069042′, Gender=u'F', Age=u'0-17′, Occupation=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status= 0, Product_Category_1=3, Product_Category_2=Ninguno, Product_Category_3=Ninguno, Compra=8370),

Fila (User_ID=1000001, Product_ID=u'P00248942′, Sexo=u'F', Edad=u'0-17′, Ocupación=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status=0 , Categoría_de_producto_1=1, Categoría_de_producto_2=6, Categoría_de_producto_3=14, Compra=15200),

Fila (User_ID=1000001, Product_ID=u'P00087842′, Sexo=u'F', Edad=u'0-17′, Ocupación=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status=0 , Product_Category_1=12, Product_Category_2=Ninguno, Product_Category_3=Ninguno, Compra=1422),

Fila (User_ID=1000001, Product_ID=u'P00085442′, Sexo=u'F', Edad=u'0-17′, Ocupación=10, City_Category=u'A', Stay_In_Current_City_Years=u'2′, Marital_Status=0 , Product_Category_1=12, Product_Category_2=14, Product_Category_3=Ninguno, Compra=1057),

Fila (User_ID=1000002, Product_ID=u'P00285442′, Sexo=u'M', Edad=u'55+', Ocupación=16, City_Category=u'C', Stay_In_Current_City_Years=u'4+', Marital_Status=0 , Product_Category_1=8, Product_Category_2=Ninguno, Product_Category_3=Ninguno, Compra=7969)]

Ahora usaremos la operación show para ver el resultado de una mejor manera porque los resultados vendrán en formato de fila. También podemos truncar el resultado usando el argumento truncar = Verdadero.

entrenar.mostrar(2,truncar=Verdadero)

Producción:

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|ID_de_usuario|ID_de_producto|Género| Edad|Ocupación|Ciudad_Categoría|Estancia_en_la_ciudad_actual_años|Estado_civil|Product_Category_1|Product_Category_2|Product_Category_3|Compra|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|1000001| P00069042| F|0-17| 10| A| 2| 0| 3| nulo| nulo| 8370|

|1000001| P00248942| F|0-17| 10| A| 2| 0| 1| 6| 14| 15200|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

solo se muestran las 2 filas superiores

• Conteo del número de filas de DataFrame

Para contar el número de filas en el marco de datos, podemos usar la operación de conteo. Ahora contaremos el número de filas de archivos de prueba y archivos de entrenamiento aplicando la operación de conteo.

entrenar.contar(), probar.contar()

Producción:

(233598, 550069)

Tenemos 233598, 550069 filas en prueba y entrenamiento, respectivamente.

• Obtener el recuento de columnas y el nombre de las columnas del archivo de prueba y entrenamiento

Similar a la operación de la columna en DataFrame of pandas, usaremos la operación de columnas para obtener el nombre de la columna. Ahora primero imprimiremos el no. de la columna y el nombre de la columna del archivo de prueba y el archivo de entrenamiento.

len(tren.columnas), tren.columnas

Producción:

12 ['User_ID', 'Product_ID', 'Gender', 'Edad', 'Occupation', 'City_Category', 'Stay_In_Current_City_Years', 'Marital_Status', 'Product_Category_1', 'Product_Category_2', 'Product_Category_3', 'Purchase']

Ahora lo estamos haciendo para el archivo de prueba de manera similar.

len(prueba.columnas), prueba.columnas

Producción:

13 [”, 'User_ID', 'Product_ID', 'Gender', 'Edad', 'Ocupación', 'City_Category', 'Stay_In_Current_City_Years', 'Marital_Status', 'Product_Category_1', 'Product_Category_2', 'Product_Category_3', 'Comb ']

Después del resultado anterior, podemos ver que hay 12 columnas en el archivo de entrenamiento y 13 columnas en el archivo de prueba. Del resultado anterior, podemos verificar que tenemos 13 columnas en el archivo de prueba y 12 en el archivo de entrenamiento. La columna "Comb" es la única columna en el archivo de prueba, y no hay ninguna "Compra" que no esté presente en el archivo de prueba. Hay una columna más en el archivo de prueba que podemos ver que no tiene ningún nombre de columna.

• Obtener las estadísticas de resumen, como conteo, máximo, mínimo, desviación estándar, media en las columnas numéricas de DataFrame

En el DataFrame, usaremos la operación llamada describe la operación. Podemos hacer el cálculo de la columna numérica y obtener un resumen estadístico usando describe la operación. Todas las columnas numéricas se calcularán en el DataFrame, si no hay un nombre de columna especificado en el cálculo de las estadísticas de resumen.

entrenar.describir().mostrar()

Producción:

+——-+——————+—————–+——————-+——————+——————+——————+—— ————+

|resumen| ID_usuario| Ocupación| Estado civil|Categoría_de_producto_1|Categoría_de_producto_2|Categoría_de_producto_3| Compra|

+——-+——————+—————–+——————-+——————+——————+——————+—— ————+

| contar| 550068| 550068| 550068| 550068| 376430| 166821| 550068|

| media|1003028,8424013031|8,076706879876669|0,40965298835780306| 5.404270017525106| 9.842329251122386|12.668243206790512| 9263.968712959126|

| dev estándar|1727.5915855308265|6.522660487341778| 0.4917701263173273|3.9362113692014082| 5.086589648693526| 4.125337631575267|5023.0653938206015|

| min| 1000001| 0| 0| 1| 2| 3| 12|

| máximo| 1006040| 20| 1| 20| 18| 18| 23961|

+——-+——————+—————–+——————-+——————+——————+——————+—— ————+

En la operación de descripción, esto es lo que obtenemos cuando se especifica el nombre de la columna de cadena o el nombre de la columna categórica.

entrenar.describe('Product_ID').show()

Producción:

+——-+———-+

|resumen|ID_producto|

+——-+———-+

| contar| 550068|

| media| nulo|

| dev estándar | nulo|

| min| P00000142|

| máximo| P0099942|

+——-+———-+

Basado en ASCII, los valores máximo y mínimo de calculados. La operación Describir se utiliza para trabajar en la columna de tipo Cadena.

• Selección de la columna de DataFrame

Usaremos el nombre de las columnas en la operación de selección para seleccionar la columna. Mencionaremos el nombre de la columna con la separación mediante el uso de comas. Ahora vamos a ver cómo se realiza la selección de “Edad” y “User_ID” del archivo de entrenamiento.

• tren.select('User_ID','Edad').show(5)
• Producción:
• +——-+—-+
• |ID_usuario| Edad|
• +——-+—-+
• |1000001|0-17|
• |1000001|0-17|
• |1000001|0-17|
• |1000001|0-17|
• |1000002| 55+|
• +——-+—-+
• Encontrar el producto Distinct no. en archivos de prueba y archivos de tren

Para calcular el número de DataFrame. de filas distintas, usaremos la operación distinta . Ahora aquí vamos a aplicar una operación distinta para el cálculo de no. de producto distinto en archivo de prueba y tren.

tren.select('Product_ID').distinct().count(),test.select('Product_ID').distinct().count()

Producción:

(3633, 3492)

Tenemos 3492 y 3633 productos distintos en archivo de prueba y entrenamiento, respectivamente. Ahora sabemos que en el archivo de entrenamiento tenemos más valores distintos que el archivo de prueba, como podemos aprender del resultado de salida. Ahora usaremos la operación de resta para encontrar las categorías Product_ID que no están presentes en el archivo de entrenamiento pero sí en el archivo de prueba. Lo mismo se puede hacer también para todas las características de categórico.

diff_cat_in_train_test=test.select('Product_ID').subtract(train.select('Product_ID'))

diff_cat_in_train_test.distinct().count()# Para recuento distinto

Producción:

46

Entonces, a partir del resultado anterior, podemos saber que hay 47 categorías diferentes, que no están presentes en el archivo de entrenamiento pero sí en el archivo de prueba. Los datos se saltarán o se recogerán del archivo de prueba, que no está presente en el archivo del tren.

• ¿Cálculo de la frecuencia por pares de columnas categóricas?

Hagamos el cálculo de la frecuencia por pares de la columna en el DataFrame usando la operación can crosstab. Ahora calculemos las columnas "Género" y "Edad" en el marco de datos del tren aplicando la operación de tabulación cruzada .

train.crosstab('Edad', 'Género').show()

Producción:

+———-+—–+——+

|Edad_Género| F| M|

+———-+—–+——+

| 0-17| 5083| 10019|

| 46-50|13199| 32502|

| 18-25|24628| 75032|

| 36-45|27170| 82843|

| 55+| 5083| 16421|

| 51-55| 9894| 28607|

| 26-35|50752|168835|

+———-+—–+——+

El valor distinto de Sexo es el nombre de la columna, y la cantidad diferente de Edad es el nombre de la fila, que se puede ver en el resultado anterior. En la tabla, el recuento del par será cero si no se ha producido.

¿Cómo obtener DataFrame con filas únicas?

Para encontrar filas únicas y no incluir filas duplicadas, usaremos la operación dropDuplicates . Obtendrá el marco de datos sin filas duplicadas al eliminar las filas duplicadas de un marco de datos. Consulte aquí para saber cómo se realiza el procedimiento dropDuplicates para obtener todas las filas únicas de las columnas.

tren.select('Edad','Género').dropDuplicates().show()

Producción:

+—–+——+

| Edad|Sexo|

+—–+——+

|51-55| F|

|51-55| M|

|26-35| F|

|26-35| M|

|36-45| F|

|36-45| M|

|46-50| F|

|46-50| M|

| 55+| F|

| 55+| M|

|18-25| F|

| 0-17| F|

|18-25| M|

| 0-17| M|

+—–+——+

• ¿Cómo soltar filas anulará el valor?

Si uno quiere eliminar todas las filas que tienen un valor nulo, entonces podemos usar la operación llamada operación dropna . Para soltar una fila del DataFrame, considera tres opciones.

• Subconjunto: es la lista de todos los nombres de las columnas a considerar para la operación de eliminación de columnas con valores nulos.
• Thresh: esto ayuda a descartar las filas con valores no nulos inferiores al umbral. Por defecto, no se especifica nada en esto.
• Cómo: se puede usar en dos tipos: todos o cualquiera. Al usar cualquiera, eliminará la fila si algún valor en la fila es nulo. Al usar todo, disminuirá la fila si todos los valores de las filas son nulos.

Ahora aquí vamos a usar todas estas opciones una por una para descartar las filas que son nulas usando opciones predeterminadas como subconjunto, umbral, Ninguno para cómo, ninguno, cualquiera.

entrenar.dropna().contar()

Producción:

166821

• ¿Cómo llenar los valores nulos de DataFrame con un número constante?

Para llenar los valores nulos con constante no. Usaremos la operación fillna aquí. Hay dos parámetros a considerar por la operación de relleno para llenar los valores nulos.

• subconjunto: aquí, es necesario especificar las columnas que se considerarán para llenar los valores.
• valor: aquí, podemos mencionar la cantidad a reemplazar con qué valor, que puede ser cualquier tipo de datos, como cadena, flotador, int en todas las columnas.

Aquí vamos a llenar '-1' en lugar de valores nulos en tren DataFrame.

tren.fillna(-1).show(2)

Producción:

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|ID_de_usuario|ID_de_producto|Género| Edad|Ocupación|Ciudad_Categoría|Estancia_en_la_ciudad_actual_años|Estado_civil|Product_Category_1|Product_Category_2|Product_Category_3|Compra|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

|1000001| P00069042| F|0-17| 10| A| 2| 0| 3| -1| -1| 8370|

|1000001| P00248942| F|0-17| 10| A| 2| 0| 1| 6| 14| 15200|

+——-+———-+——+—-+———-+————-+————————–+————–+——————+ ——————+——————+——–+

solo se muestran las 2 filas superiores

Conclusión

PySpark está ganando impulso en el mundo de la inteligencia artificial y el aprendizaje automático. PySpark se utiliza para resolver problemas de aprendizaje automático del mundo real. Puede crear RDD a partir de diferentes fuentes de datos, tanto externas como existentes, y realizar todo tipo de transformaciones en él. Espero que este artículo haya sido informativo y haya podido brindarle información detallada sobre los marcos de datos de PySpark.

Si tiene curiosidad por aprender sobre PySpark y otras herramientas de ciencia de datos, consulte el Diploma PG en ciencia de datos de IIIT-B y upGrad, creado para profesionales que trabajan y ofrece más de 10 estudios de casos y proyectos, talleres prácticos prácticos, tutoría con expertos de la industria, 1 a 1 con mentores de la industria, más de 400 horas de aprendizaje y asistencia laboral con las mejores empresas.