Acceso a los datos en Jupyterlab los equipos portátiles

Cada núcleo admitido proporciona funcionalidades integradas que le permiten leer datos de Platform de un conjunto de datos dentro de un bloc de notas. Actualmente, JupyterLab en Adobe Experience Platform Data Science Workspace admite portátiles para Python, R, PySpark y Scala. Sin embargo, la compatibilidad para paginar datos se limita a Python blocs de notas y R. Este guía se centra en cómo utilizar los blocs de notas de JupyterLab para acceder a los datos.

Introducción

Antes de leer este guía, revise el usuario guía🔗 para obtener una introducción JupyterLab de alto nivel y su función dentro de Data JupyterLab Science Espacio de trabajo.

Límites de datos del bloc de notas notebook-data-limits

La siguiente información define la cantidad máxima de datos que se pueden leer, qué tipo de datos se utilizaron y el periodo de tiempo estimado que tarda la lectura de los datos.

Para y R Python , se utilizó un servidor de portátiles configurado a 40 GB de RAM para los puntos de referencia. Para PySpark y Scala, se utilizó un clúster de databricks configurado a 64 GB de RAM, 8 núcleos, 2 DBU con un máximo de 4 trabajadores para los puntos de referencia que se describen a continuación.

Los datos de ExperienceEvent esquema utilizados variaron en tamaño a partir de mil filas (1K) que van desde mil (1K) filas de hasta mil millones (1B). Tenga en cuenta que para PySpark y Spark las métricas, se utilizó un intervalo de fechas de 10 días para los datos XDM.

Los datos anuncios-hoc esquema se procesaron previamente utilizando Query Service Crear tabla como selección (CTAS). Estos datos también variaron en tamaño a partir de mil (1K) filas que van hasta mil (1B) filas.

Cuándo usar el modo por lotes o el modo interactivo mode

Al leer conjuntos de datos con portátiles PySpark y Scala, tiene la opción de utilizar el modo interactivo o el modo por lotes para leer el conjunto de datos. La interacción se realiza para obtener resultados rápidos, mientras que el modo por lotes es para conjuntos de datos grandes.

Python Límites de datos de bloc de notas

XDM ExperienceEvent esquema: debería poder leer un máximo de 2 millones de filas (~6,1 GB de datos en disco) de datos XDM en menos de 22 minutos. Añadir filas adicionales puede provocar errores.

anuncios-hoc esquema: debería poder leer un máximo de 5 millones de filas (~5,6 GB de datos en disco) de datos no XDM (anuncios-hoc) en menos de 14 minutos. Si se agregan más filas, pueden producirse errores.

Límites de datos del portátil de R

XDM ExperienceEvent esquema: debería poder leer un máximo de 1 millón de filas de datos XDM (3 GB de datos en disco) en menos de 13 minutos.

esquema ad hoc: Debería poder leer un máximo de 3 millones de filas de datos ad hoc (293 MB de datos en disco) en unos 10 minutos.

Límites de datos del bloc de notas PySpark (Python kernel): pyspark-data-limits

XDM ExperienceEvent esquema: En el modo interactivo debería poder leer un máximo de 5 millones de filas (~13,42 GB de datos en disco) de datos XDM en unos 20 minutos. interactivo modo solo admite hasta 5 millones de filas. Si desea leer conjuntos de datos más grandes, se recomienda cambiar al modo por lotes. En el modo por lotes, debería poder leer un máximo de 500 millones de filas (~ 1.31TB de datos en disco) de datos XDM en aproximadamente 14 horas.

anuncios-hoc esquema: En interactivo modo, debería poder leer un máximo de 5 millones de filas (~ 5.36GB de datos en el disco) de datos no XDM en menos de 3 minutos. En Lote modo, debería poder leer un máximo de mil millones de filas (~ 1.05TB de datos en el disco) de datos no XDM en aproximadamente 18 minutos.

Spark límites de datos de cuadernos (Scala kernel): scala-data-limits

Esquema XDM ExperienceEvent: En el modo interactivo, debería poder leer un máximo de 5 millones de filas (aproximadamente 13,42 GB de datos en el disco) de datos XDM en unos 18 minutos. El modo interactivo solo admite hasta 5 millones de filas. Si desea leer conjuntos de datos más grandes, se recomienda cambiar al modo por lotes. En el modo por lotes, debería poder leer un máximo de 500 millones de filas (aproximadamente 1,31 TB de datos en disco) de datos XDM en aproximadamente 14 horas.

anuncios-hoc esquema: En el modo interactivo, debería poder leer un máximo de 5 millones de filas (~ 5.36GB de datos en el disco) de datos no XDM en menos de 3 minutos. En el modo por lotes, debería poder leer un máximo de mil millones de filas (~ 1.05 TB de datos en disco) de datos no XDM en aproximadamente 16 minutos.

Notebooks de Python python-notebook

Python blocs de notas le permiten paginar datos al acceder a conjuntos de datos. A continuación se muestra un código de muestra para leer datos con y sin paginación. Para obtener más información sobre los blocs de notas de Python de inicio disponibles, visite la sección JupyterLab Launcher en la guía del usuario de JupyterLab.

La documentación de Python a continuación describe los siguientes conceptos:

Leer de un conjunto de datos en Python python-read-dataset

Sin paginación:

La ejecución del siguiente código leerá toda la conjunto de datos. Si la ejecución se realiza correctamente, los datos se guardarán como un marco de datos de Pandas al que hace referencia el variable df.

# Python

from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.read()
df.head()

Con paginación:

La ejecución del siguiente código leerá datos del conjunto de datos especificado. La paginación se logra limitando y compensando los datos a través de las funciones limit() y offset() respectivamente. La limitación de datos hace referencia al número máximo de puntos de datos que se van a leer, mientras que la compensación hace referencia al número de puntos de datos que se van a omitir antes de leer los datos. Si la operación de lectura se ejecuta correctamente, los datos se guardarán como un marco de datos Pandas al que hace referencia la variable df.

# Python

from platform_sdk.dataset_reader import DatasetReader

dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.limit(100).offset(10).read()

Escribir en un conjunto de datos en Python write-python

Para escribir en un conjunto de datos de su bloc de notas de JupyterLab, seleccione la pestaña Icono de datos (resaltada a continuación) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y Schemas. Seleccione Conjuntos de datos, haga clic con el botón derecho y, a continuación, seleccione la opción Escribir datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.

Como alternativa, puede copiar y pegar la siguiente celda de código. Reemplazar tanto el como el {DATASET_ID} .{PANDA_DATAFRAME}

from platform_sdk.models import Dataset
from platform_sdk.dataset_writer import DatasetWriter

dataset = Dataset(get_platform_sdk_client_context()).get_by_id(dataset_id="{DATASET_ID}")
dataset_writer = DatasetWriter(get_platform_sdk_client_context(), dataset)
write_tracker = dataset_writer.write({PANDA_DATAFRAME}, file_format='json')

Datos de consulta mediante Query ServicePython query-data-python

JupyterLab on Platform le permite utilizar SQL en un Python bloc de notas para acceder a los datos a través Adobe Experience Platform servicio de consultas. El acceso a los datos a través de Query Service puede ser útil para tratar conjuntos de datos grandes debido a sus tiempos de ejecución superiores. Tenga en cuenta que la consulta de datos mediante Query Service tiene un límite de tiempo de procesamiento de diez minutos.

Antes de usar Query Service en JupyterLab, asegúrese de que tiene una comprensión de la Query Service sintaxis SQL.

La consulta de datos mediante Query Service requiere que proporcione el nombre del conjunto de datos de destino. Puede generar las celdas de código necesarias buscando el conjunto de datos deseado mediante Explorador de datos. Haga clic con el botón derecho en la lista de conjuntos de datos y haga clic en Consultar datos en Notebook para generar dos celdas de código en su bloc de notas. Estas dos celdas se describen con más detalle a continuación.

Para usar Query Service en JupyterLab, primero debe crear una conexión entre el bloc de notas de Python que trabaja y Query Service. Esto se puede lograr ejecutando la primera celda generada.

qs_connect()

En la segunda celda generada, la primera línea debe definirse antes que la consulta SQL. De manera predeterminada, la celda generada define una variable opcional (df0) que guarda los resultados de la consulta como un marco de datos Pandas.
El argumento -c QS_CONNECTION es obligatorio y le indica al núcleo que ejecute la consulta SQL en Query Service. Consulte el apéndice para obtener una lista de argumentos adicionales.

%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/

Se puede hacer referencia directamente a las variables de Python en una consulta SQL mediante sintaxis con formato de cadena y ajustando las variables entre paréntesis angulares ({}), como se muestra en el ejemplo siguiente:

table_name = 'name_of_the_dataset'
table_columns = ','.join(['col_1','col_2','col_3'])

%%read_sql demo -c QS_CONNECTION
SELECT {table_columns}
FROM {table_name}

Filtrar datos de ExperienceEvent python-filter

Para acceder y filtrar un conjunto de datos ExperienceEvent en un bloc de notas Python, debe proporcionar el identificador del conjunto de datos ({DATASET_ID}) junto con las reglas de filtro que definen un intervalo de tiempo específico mediante operadores lógicos. Cuando se define un intervalo de tiempo, se ignora cualquier paginación especificada y se considera todo el conjunto de datos.

A continuación, se describe una lista de operadores de filtrado:

La siguiente celda filtra un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y el final del 31 de diciembre de 2019.

# Python

from platform_sdk.dataset_reader import DatasetReader

dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.\
    where(dataset_reader["timestamp"].gt("2019-01-01 00:00:00").\
    And(dataset_reader["timestamp"].lt("2019-12-31 23:59:59"))\
).read()

Portátiles R r-notebooks

Los blocs de notas de R permiten paginar datos al acceder a conjuntos de datos. A continuación se muestra un código de muestra para leer datos con y sin paginación. Para obtener más información sobre los blocs de notas de Starter R disponibles, visite la sección JupyterLab Launcher en la guía del usuario de JupyterLab.

La siguiente documentación de R describe los siguientes conceptos:

Lectura de un conjunto de datos en R r-read-dataset

Sin paginación:

Al ejecutar el siguiente código, se leerá todo el conjunto de datos. Si la ejecución se realiza correctamente, los datos se guardarán como un marco de datos Pandas al que hace referencia la variable df0.

# R

library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$read()
head(df0)

Con paginación:

Al ejecutar el siguiente código se leerán los datos del conjunto de datos especificado. La paginación se logra limitando y compensando los datos a través de las funciones limit() y offset() respectivamente. La limitación de datos hace referencia al número máximo de puntos de datos que se van a leer, mientras que la compensación hace referencia al número de puntos de datos que se van a omitir antes de leer los datos. Si la operación de lectura se ejecuta correctamente, los datos se guardarán como un dataframe de Pandas al que hace referencia el variable df0.

# R

library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")

DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$limit(100L)$offset(10L)$read()

Escribir en un conjunto de datos en R write-r

Para escribir en un conjunto de datos de su bloc de notas de JupyterLab, seleccione la pestaña Icono de datos (resaltada a continuación) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y Schemas. Seleccione Conjuntos de datos, haga clic con el botón derecho y, a continuación, seleccione la opción Escribir datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.

Como alternativa, puede copiar y pegar la siguiente celda de código:

psdk <- import("platform_sdk")
dataset <- psdk$models$Dataset(py$get_platform_sdk_client_context())$get_by_id(dataset_id="{DATASET_ID}")
dataset_writer <- psdk$dataset_writer$DatasetWriter(py$get_platform_sdk_client_context(), dataset)
write_tracker <- dataset_writer$write(df, file_format='json')

ExperienceEvent Filtrar datos r-filter

Para acceder y filtrar un ExperienceEvent conjunto de datos en un bloc de notas de R, debe proporcionar el ID del conjunto de datos ({DATASET_ID}) junto con las reglas de filtro que definen un intervalo de tiempo específico mediante operadores lógicos. Cuando se define un intervalo de tiempo, se ignora cualquier paginación especificada y se considera todo el conjunto de datos.

A continuación se describen lista operadores de filtrado:

La siguiente celda filtra un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y el final del 31 de diciembre de 2019.

# R

library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")

client_context <- py$PLATFORM_SDK_CLIENT_CONTEXT
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")

df0 <- dataset_reader$
    where(dataset_reader["timestamp"]$gt("2019-01-01 00:00:00")$
    And(dataset_reader["timestamp"]$lt("2019-12-31 23:59:59"))
)$read()

Portátiles PySpark 3 pyspark-notebook

La documentación de PySpark a continuación describe los siguientes conceptos:

Inicializando sparkSession spark-initialize

Todos los blocs de notas de Spark 2.4 requieren que inicialice la sesión con el siguiente código de repetidor.

from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()

Usar %dataset para leer y escribir con un bloc de notas PySpark 3 magic

Con la introducción de Spark 2.4, se proporciona magia personalizada de %dataset para su uso en portátiles PySpark 3 (Spark 2.4). Para obtener más información sobre los comandos mágicos disponibles en el núcleo de IPython, visite la documentación mágica de IPython.

Uso

%dataset {action} --datasetId {id} --dataFrame {df} --mode batch

Descripción

Un comando mágico Data Science Workspace personalizado para leer o escribir un conjunto de datos de un bloc de notas PySpark (Python 3 kernel).

Ejemplos

Puede generar automáticamente los ejemplos anteriores en la compra de JupyterLab mediante el siguiente método:

Seleccione la pestaña Icono de datos (resaltada a continuación) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y Schemas. Seleccione Conjuntos de datos y haga clic con el botón derecho y, a continuación, seleccione la opción Escribir datos en Notebook en el menú desplegable del conjunto de datos desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.

Crear un marco de datos local pyspark-create-dataframe

Para crear un marco de datos local con PySpark 3, utilice consultas SQL. Por ejemplo:

date_aggregation.createOrReplaceTempView("temp_df")

df = spark.sql('''
  SELECT *
  FROM sparkdf
''')

local_df

df = spark.sql('''
  SELECT *
  FROM sparkdf
  LIMIT limit
''')

sample_df = df.sample(fraction)

ExperienceEvent Filtrar datos pyspark-filter-experienceevent

Para acceder y filtrar un ExperienceEvent conjunto de datos en un bloc de notas de PySpark es necesario que proporcione la identidad conjunto de datos ({DATASET_ID}), la identidad IMS de su organización y las reglas de filtro que definen un intervalo de tiempo específico. Un intervalo de tiempo de filtrado se define mediante la función spark.sql(), donde el parámetro de función es un cadena de consulta SQL.

Las siguientes celdas filtran un ExperienceEvent conjunto de datos a los datos existentes exclusivamente entre el 1 de enero de 2019 y el final del 31 de diciembre de 2019.

# PySpark 3 (Spark 2.4)

from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()

%dataset read --datasetId {DATASET_ID} --dataFrame df --mode batch

df.createOrReplaceTempView("event")
timepd = spark.sql("""
    SELECT *
    FROM event
    WHERE timestamp > CAST('2019-01-01 00:00:00.0' AS TIMESTAMP)
    AND timestamp < CAST('2019-12-31 23:59:59.9' AS TIMESTAMP)
""")
timepd.show()

Cuadernos Scala scala-notebook

La documentación siguiente contiene ejemplos de los siguientes conceptos:

Inicialización de SparkSession scala-initialize

Todos los blocs de notas de Scala requieren que inicialice la sesión con el siguiente código repetitivo:

import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
  .builder()
  .master("local")
  .getOrCreate()

Leer un conjunto de datos read-scala-dataset

En Scala, puede importar clientContext para obtener y devolver valores de Platform, lo que elimina la necesidad de definir variables como var userToken. En el siguiente ejemplo de Scala, clientContext se usa para obtener y devolver todos los valores necesarios para leer un conjunto de datos.

import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()

val clientContext = ClientContext.getClientContext()
val df1 = spark.read.format("com.adobe.platform.query")
  .option("user-token", clientContext.getUserToken())
  .option("ims-org", clientContext.getOrgId())
  .option("api-key", clientContext.getApiKey())
  .option("service-token", clientContext.getServiceToken())
  .option("sandbox-name", clientContext.getSandboxName())
  .option("mode", "batch")
  .option("dataset-id", "5e68141134492718af974844")
  .load()

df1.printSchema()
df1.show(10)

Puede generar automáticamente el ejemplo anterior en la compra de JupyterLab mediante el siguiente método:

Seleccione la pestaña Icono de datos (resaltada a continuación) en la navegación izquierda de JupyterLab. Aparecen los directorios Datasets y Schemas. Seleccione Conjuntos de datos, haga clic con el botón derecho y, a continuación, seleccione la opción Explorar datos en el bloc de notas en el menú desplegable del conjunto de datos que desee utilizar. Aparece una entrada de código ejecutable en la parte inferior del bloc de notas.
Y

Escribir en un conjunto de datos scala-write-dataset

En Scala, puede importar clientContext para obtener y devolver valores de Platform, lo que elimina la necesidad de definir variables como var userToken. En el siguiente ejemplo de Scala, clientContext se usa para definir y devolver todos los valores necesarios para escribir en un conjunto de datos.

import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()

val clientContext = ClientContext.getClientContext()
df1.write.format("com.adobe.platform.query")
  .option("user-token", clientContext.getUserToken())
  .option("service-token", clientContext.getServiceToken())
  .option("ims-org", clientContext.getOrgId())
  .option("api-key", clientContext.getApiKey())
  .option("sandbox-name", clientContext.getSandboxName())
  .option("mode", "batch")
  .option("dataset-id", "5e68141134492718af974844")
  .save()

crear un marco de datos local scala-create-dataframe

Para crear un marco de datos local con Scala, se requieren consultas SQL. Por ejemplo:

sparkdf.createOrReplaceTempView("sparkdf")

val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)

Filtrar datos de ExperienceEvent scala-experienceevent

Para acceder y filtrar un ExperienceEvent conjunto de datos en un bloc de notas de Scala es necesario proporcionar la identidad conjunto de datos ({DATASET_ID}), la identidad IMS de la organización y las reglas de filtro que definen un intervalo de tiempo específico. Un intervalo de tiempo de filtrado se define mediante la función spark.sql(), donde el parámetro de función es una cadena de consulta SQL.

Las celdas siguientes filtran un conjunto de datos ExperienceEvent a los datos existentes exclusivamente entre el 1 de enero de 2019 y el final del 31 de diciembre de 2019.

// Spark (Spark 2.4)

// Turn off extra logging
import org.apache.log4j.{Level, Logger}
Logger.getLogger("org").setLevel(Level.OFF)
Logger.getLogger("com").setLevel(Level.OFF)

import org.apache.spark.sql.{Dataset, SparkSession}
val spark = org.apache.spark.sql.SparkSession.builder().appName("Notebook")
  .master("local")
  .getOrCreate()

// Stage Exploratory
val dataSetId: String = "{DATASET_ID}"
val orgId: String = sys.env("IMS_ORG_ID")
val clientId: String = sys.env("PYDASDK_IMS_CLIENT_ID")
val userToken: String = sys.env("PYDASDK_IMS_USER_TOKEN")
val serviceToken: String = sys.env("PYDASDK_IMS_SERVICE_TOKEN")
val mode: String = "batch"

var df = spark.read.format("com.adobe.platform.query")
  .option("user-token", userToken)
  .option("ims-org", orgId)
  .option("api-key", clientId)
  .option("mode", mode)
  .option("dataset-id", dataSetId)
  .option("service-token", serviceToken)
  .load()
df.createOrReplaceTempView("event")
val timedf = spark.sql("""
    SELECT *
    FROM event
    WHERE timestamp > CAST('2019-01-01 00:00:00.0' AS TIMESTAMP)
    AND timestamp < CAST('2019-12-31 23:59:59.9' AS TIMESTAMP)
""")
timedf.show()

Pasos siguientes

Este documento abarcaba las directrices generales para acceder a conjuntos de datos mediante cuadernos de JupyterLab. Para obtener ejemplos más detallados sobre la consulta de conjuntos de datos, visite la documentación de Query Service in JupyterLab Notebooks. Para obtener más información sobre cómo explorar y visualizar sus conjuntos de datos, visite el documento de análisis de los datos mediante blocs de notas.

Indicadores SQL opcionales para Query Service optional-sql-flags-for-query-service

Esta tabla describe los indicadores SQL opcionales que se pueden utilizar para Query Service.